MacGui: HBAudio Indentation Cleanup

- Patch by Rodeo ... Thanks!
- Change hard tabs to 4 spaces
- Place the opening bracket of if, else if, else, while and for statements on another line, not the same line as the condition.
- Xcode's Edit > Format > Re-Indent on all files.
- This patch is purely about cosmetics and indentation. There shouldn't be any change in behavior.
- As per https://reviews.handbrake.fr/r/101/


git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@4054 b64f7644-9d1e-0410-96f1-a4d463321fa5

4 files changed, 963 insertions, 848 deletions

diff --git a/macosx/HBAudio.h b/macosx/HBAudio.h
index 618bd2430..65655a3a6 100644
--- a/macosx/HBAudio.h
+++ b/macosx/HBAudio.h
@@ -21,18 +21,18 @@ extern NSString *keyAudioBitrate;
 @interface HBAudio : NSObject
 
 {
-	NSDictionary *track;
-	NSDictionary *codec;
-	NSDictionary *mixdown;
-	NSDictionary *sampleRate;
-	NSDictionary *bitRate;
-	NSNumber *drc;
-    NSNumber *gain;
-	NSNumber *videoContainerTag;
-	HBAudioController *controller;
-	NSMutableArray *codecs;
-	NSMutableArray *mixdowns;
-	NSMutableArray *bitRates;
+    NSDictionary                 * track;
+    NSDictionary                 * codec;
+    NSDictionary                 * mixdown;
+    NSDictionary                 * sampleRate;
+    NSDictionary                 * bitRate;
+    NSNumber                     * drc;
+    NSNumber                     * gain;
+    NSNumber                     * videoContainerTag;
+    HBAudioController            * controller;
+    NSMutableArray               * codecs;
+    NSMutableArray               * mixdowns;
+    NSMutableArray               * bitRates;
 }
 
 @property (nonatomic, retain) NSDictionary *track;
@@ -58,4 +58,3 @@ extern NSString *keyAudioBitrate;
 - (void) setBitRateFromName: (NSString *) aValue;
 
 @end
-
diff --git a/macosx/HBAudio.m b/macosx/HBAudio.m
index ba684a3ca..194d4dd16 100644
--- a/macosx/HBAudio.m
+++ b/macosx/HBAudio.m
@@ -35,22 +35,28 @@ static NSMutableArray *masterBitRateArray = nil;
 - (NSDictionary *) dictionaryWithObject: (id) anObject matchingKey: (NSString *) aKey reverse: (BOOL) reverse
 
 {
-	NSDictionary *retval = nil;
-	NSEnumerator *enumerator = reverse ? [self reverseObjectEnumerator] : [self objectEnumerator];
-	NSDictionary *dict;
-	id aValue;
-	
-	while (nil != (dict = [enumerator nextObject]) && nil == retval) {
-		if (nil != (aValue = [dict objectForKey: aKey]) && YES == [aValue isEqual: anObject]) {
-			retval = dict;
-		}
-	}
-	return retval;
+    NSDictionary *retval = nil;
+    NSEnumerator *enumerator = reverse ? [self reverseObjectEnumerator] : [self objectEnumerator];
+    NSDictionary *dict;
+    id aValue;
+
+    while (nil != (dict = [enumerator nextObject]) && nil == retval)
+    {
+        if (nil != (aValue = [dict objectForKey: aKey]) && YES == [aValue isEqual: anObject])
+        {
+            retval = dict;
+        }
+    }
+    return retval;
 }
 - (NSDictionary *) dictionaryWithObject: (id) anObject matchingKey: (NSString *) aKey
-{	return [self dictionaryWithObject: anObject matchingKey: aKey reverse: NO];	}
+{
+    return [self dictionaryWithObject: anObject matchingKey: aKey reverse: NO];
+}
 - (NSDictionary *) lastDictionaryWithObject: (id) anObject matchingKey: (NSString *) aKey
-{	return [self dictionaryWithObject: anObject matchingKey: aKey reverse: YES];	}
+{
+    return [self dictionaryWithObject: anObject matchingKey: aKey reverse: YES];
+}
 
 @end
 
@@ -62,332 +68,368 @@ static NSMutableArray *masterBitRateArray = nil;
 + (void) load
 
 {
-	if ([HBAudio class] == self) {
-		int i;
-		NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-		NSDictionary *dict;
-		
-		masterCodecArray = [[NSMutableArray alloc] init];	//	knowingly leaked
-		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"AAC (CoreAudio)", @"AAC (CoreAudio)"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_CA_AAC], keyAudioCodec,
-									  [NSNumber numberWithBool: YES], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
-									  nil]];
-		if (encca_haac_available()) {
-			[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"HE-AAC (CoreAudio)", @"HE-AAC (CoreAudio)"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_CA_HAAC], keyAudioCodec,
-									  [NSNumber numberWithBool: YES], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
-									  nil]];
-		}
-		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"AAC (ffmpeg)", @"AAC (ffmpeg)"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_FFAAC], keyAudioCodec,
-									  [NSNumber numberWithBool: YES], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
-									  nil]];
-		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"AAC (faac)", @"AAC (faac)"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_FAAC], keyAudioCodec,
-									  [NSNumber numberWithBool: YES], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
-									  nil]];
-		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"MP3 (lame)", @"MP3 (lame)"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_LAME], keyAudioCodec,
-									  [NSNumber numberWithBool: YES], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
-									  nil]];
-		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"AC3 Passthru", @"AC3 Passthru"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_AC3_PASS], keyAudioCodec,
-									  [NSNumber numberWithBool: YES], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithInt: HB_ACODEC_AC3], keyAudioMustMatchTrack,
-									  nil]];
-		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"AC3", @"AC3"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_AC3], keyAudioCodec,
-									  [NSNumber numberWithBool: YES], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
-									  nil]];
-		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"DTS Passthru", @"DTS Passthru"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_DCA_PASS], keyAudioCodec,
-									  [NSNumber numberWithBool: NO], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithInt: HB_ACODEC_DCA], keyAudioMustMatchTrack,
-									  nil]];
-		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									  NSLocalizedString(@"Vorbis (vorbis)", @"Vorbis (vorbis)"), keyAudioCodecName,
-									  [NSNumber numberWithInt: HB_ACODEC_VORBIS], keyAudioCodec,
-									  [NSNumber numberWithBool: NO], keyAudioMP4,
-									  [NSNumber numberWithBool: YES], keyAudioMKV,
-									  [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
-									  nil]];
-		
-		masterMixdownArray = [[NSMutableArray alloc] init];	//	knowingly leaked
-		[masterMixdownArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-										NSLocalizedString(@"AC3 Passthru", @"AC3 Passthru"), keyAudioMixdownName,
-										[NSNumber numberWithInt: HB_ACODEC_AC3_PASS], keyAudioMixdown,
-										nil]];
-		[masterMixdownArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-										NSLocalizedString(@"DTS Passthru", @"DTS Passthru"), keyAudioMixdownName,
-										[NSNumber numberWithInt: HB_ACODEC_DCA_PASS], keyAudioMixdown,
-										nil]];
-		for (i = 0; i < hb_audio_mixdowns_count; i++) {
-			[masterMixdownArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-											[NSString stringWithUTF8String: hb_audio_mixdowns[i].human_readable_name], keyAudioMixdownName,
-											[NSNumber numberWithInt: hb_audio_mixdowns[i].amixdown], keyAudioMixdown,
-											nil]];
-		}
-
-		//	Note that for the Auto value we use 0 for the sample rate because our controller will give back the track's
-		//	input sample rate when it finds this 0 value as the selected sample rate.  We do this because the input
-		//	sample rate depends on the track, which means it depends on the title, so cannot be nicely set up here.
-		masterSampleRateArray = [[NSMutableArray alloc] init];	//	knowingly leaked
-		[masterSampleRateArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-										   NSLocalizedString(@"Auto", @"Auto"), keyAudioSampleRateName,
-										   [NSNumber numberWithInt: 0], keyAudioSamplerate,
-										   nil]];
-		for (i = 0; i < hb_audio_rates_count; i++) {
-			[masterSampleRateArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-											   [NSString stringWithUTF8String: hb_audio_rates[i].string], keyAudioSampleRateName,
-											   [NSNumber numberWithInt: hb_audio_rates[i].rate], keyAudioSamplerate,
-											   nil]];
-		}
-		
-		masterBitRateArray = [[NSMutableArray alloc] init];	// knowingly leaked
-		for (i = 0; i < hb_audio_bitrates_count; i++) {
-			dict = [NSDictionary dictionaryWithObjectsAndKeys:
-					[NSString stringWithUTF8String: hb_audio_bitrates[i].string], keyAudioBitrateName,
-					[NSNumber numberWithInt: hb_audio_bitrates[i].rate], keyAudioBitrate,
-					nil];
-			[masterBitRateArray addObject: dict];
-		}
-		
-		[pool release];
-	}
-	return;
+    if ([HBAudio class] == self)
+    {
+        int i;
+        NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+        NSDictionary *dict;
+
+        masterCodecArray = [[NSMutableArray alloc] init]; // knowingly leaked
+        [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                      NSLocalizedString(@"AAC (CoreAudio)", @"AAC (CoreAudio)"), keyAudioCodecName,
+                                      [NSNumber numberWithInt: HB_ACODEC_CA_AAC], keyAudioCodec,
+                                      [NSNumber numberWithBool: YES], keyAudioMP4,
+                                      [NSNumber numberWithBool: YES], keyAudioMKV,
+                                      [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
+                                      nil]];
+        if (encca_haac_available())
+        {
+            [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                          NSLocalizedString(@"HE-AAC (CoreAudio)", @"HE-AAC (CoreAudio)"), keyAudioCodecName,
+                                          [NSNumber numberWithInt: HB_ACODEC_CA_HAAC], keyAudioCodec,
+                                          [NSNumber numberWithBool: YES], keyAudioMP4,
+                                          [NSNumber numberWithBool: YES], keyAudioMKV,
+                                          [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
+                                          nil]];
+        }
+        [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                      NSLocalizedString(@"AAC (ffmpeg)", @"AAC (ffmpeg)"), keyAudioCodecName,
+                                      [NSNumber numberWithInt: HB_ACODEC_FFAAC], keyAudioCodec,
+                                      [NSNumber numberWithBool: YES], keyAudioMP4,
+                                      [NSNumber numberWithBool: YES], keyAudioMKV,
+                                      [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
+                                      nil]];
+        [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                      NSLocalizedString(@"AAC (faac)", @"AAC (faac)"), keyAudioCodecName,
+                                      [NSNumber numberWithInt: HB_ACODEC_FAAC], keyAudioCodec,
+                                      [NSNumber numberWithBool: YES], keyAudioMP4,
+                                      [NSNumber numberWithBool: YES], keyAudioMKV,
+                                      [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
+                                      nil]];
+        [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                      NSLocalizedString(@"MP3 (lame)", @"MP3 (lame)"), keyAudioCodecName,
+                                      [NSNumber numberWithInt: HB_ACODEC_LAME], keyAudioCodec,
+                                      [NSNumber numberWithBool: YES], keyAudioMP4,
+                                      [NSNumber numberWithBool: YES], keyAudioMKV,
+                                      [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
+                                      nil]];
+        [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                      NSLocalizedString(@"AC3 Passthru", @"AC3 Passthru"), keyAudioCodecName,
+                                      [NSNumber numberWithInt: HB_ACODEC_AC3_PASS], keyAudioCodec,
+                                      [NSNumber numberWithBool: YES], keyAudioMP4,
+                                      [NSNumber numberWithBool: YES], keyAudioMKV,
+                                      [NSNumber numberWithInt: HB_ACODEC_AC3], keyAudioMustMatchTrack,
+                                      nil]];
+        [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                      NSLocalizedString(@"AC3", @"AC3"), keyAudioCodecName,
+                                      [NSNumber numberWithInt: HB_ACODEC_AC3], keyAudioCodec,
+                                      [NSNumber numberWithBool: YES], keyAudioMP4,
+                                      [NSNumber numberWithBool: YES], keyAudioMKV,
+                                      [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
+                                      nil]];
+        [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                      NSLocalizedString(@"DTS Passthru", @"DTS Passthru"), keyAudioCodecName,
+                                      [NSNumber numberWithInt: HB_ACODEC_DCA_PASS], keyAudioCodec,
+                                      [NSNumber numberWithBool: NO], keyAudioMP4,
+                                      [NSNumber numberWithBool: YES], keyAudioMKV,
+                                      [NSNumber numberWithInt: HB_ACODEC_DCA], keyAudioMustMatchTrack,
+                                      nil]];
+        [masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                      NSLocalizedString(@"Vorbis (vorbis)", @"Vorbis (vorbis)"), keyAudioCodecName,
+                                      [NSNumber numberWithInt: HB_ACODEC_VORBIS], keyAudioCodec,
+                                      [NSNumber numberWithBool: NO], keyAudioMP4,
+                                      [NSNumber numberWithBool: YES], keyAudioMKV,
+                                      [NSNumber numberWithBool: NO], keyAudioMustMatchTrack,
+                                      nil]];
+
+        masterMixdownArray = [[NSMutableArray alloc] init]; // knowingly leaked
+        [masterMixdownArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                        NSLocalizedString(@"AC3 Passthru", @"AC3 Passthru"), keyAudioMixdownName,
+                                        [NSNumber numberWithInt: HB_ACODEC_AC3_PASS], keyAudioMixdown,
+                                        nil]];
+        [masterMixdownArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                        NSLocalizedString(@"DTS Passthru", @"DTS Passthru"), keyAudioMixdownName,
+                                        [NSNumber numberWithInt: HB_ACODEC_DCA_PASS], keyAudioMixdown,
+                                        nil]];
+        for (i = 0; i < hb_audio_mixdowns_count; i++)
+        {
+            [masterMixdownArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                            [NSString stringWithUTF8String: hb_audio_mixdowns[i].human_readable_name], keyAudioMixdownName,
+                                            [NSNumber numberWithInt: hb_audio_mixdowns[i].amixdown], keyAudioMixdown,
+                                            nil]];
+        }
+
+        // Note that for the Auto value we use 0 for the sample rate because our controller will give back the track's
+        // input sample rate when it finds this 0 value as the selected sample rate.  We do this because the input
+        // sample rate depends on the track, which means it depends on the title, so cannot be nicely set up here.
+        masterSampleRateArray = [[NSMutableArray alloc] init]; // knowingly leaked
+        [masterSampleRateArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                           NSLocalizedString(@"Auto", @"Auto"), keyAudioSampleRateName,
+                                           [NSNumber numberWithInt: 0], keyAudioSamplerate,
+                                           nil]];
+        for (i = 0; i < hb_audio_rates_count; i++)
+        {
+            [masterSampleRateArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                               [NSString stringWithUTF8String: hb_audio_rates[i].string], keyAudioSampleRateName,
+                                               [NSNumber numberWithInt: hb_audio_rates[i].rate], keyAudioSamplerate,
+                                               nil]];
+        }
+
+        masterBitRateArray = [[NSMutableArray alloc] init]; // knowingly leaked
+        for (i = 0; i < hb_audio_bitrates_count; i++)
+        {
+            dict = [NSDictionary dictionaryWithObjectsAndKeys:
+                    [NSString stringWithUTF8String: hb_audio_bitrates[i].string], keyAudioBitrateName,
+                    [NSNumber numberWithInt: hb_audio_bitrates[i].rate], keyAudioBitrate,
+                    nil];
+            [masterBitRateArray addObject: dict];
+        }
+
+        [pool release];
+    }
+    return;
 }
 
-//	Ensure the list of codecs is accurate
-//	Update the current value of codec based on the revised list
+// Ensure the list of codecs is accurate
+// Update the current value of codec based on the revised list
 - (void) updateCodecs
 
 {
-	NSMutableArray *permittedCodecs = [NSMutableArray array];
-	unsigned int count = [masterCodecArray count];
-	NSDictionary *dict;
-	NSString *keyThatAllows = nil;
-
-	//	Determine which key we use to see which codecs are permitted
-	switch ([videoContainerTag intValue]) {
-		case HB_MUX_MP4:
-			keyThatAllows = keyAudioMP4;
-			break;
-		case HB_MUX_MKV:
-			keyThatAllows = keyAudioMKV;
-			break;
-		default:
-			keyThatAllows = @"error condition";
-			break;
-	}
-
-	//	First get a list of the permitted codecs based on the internal rules
-	if (nil != track && YES == [self enabled]) {
-		BOOL goodToAdd;
-
-		for (unsigned int i = 0; i < count; i++) {
-			dict = [masterCodecArray objectAtIndex: i];
-			
-			//	First make sure only codecs permitted by the container are here
-			goodToAdd = [[dict objectForKey: keyThatAllows] boolValue];
-			
-			//	Now we make sure if DTS or AC3 is not available in the track it is not put in the codec list, but in a general way
-			if (YES == [[dict objectForKey: keyAudioMustMatchTrack] boolValue]) {
-				if ([[dict objectForKey: keyAudioMustMatchTrack] intValue] != [[[self track] objectForKey: keyAudioInputCodec] intValue]) {
-					goodToAdd = NO;
-				}
-			}
-			
-			if (YES == goodToAdd) {
-				[permittedCodecs addObject: dict];
-			}
-		}
-	}
-	
-	//	Now make sure the permitted list and the actual ones matches
-	[self setCodecs: permittedCodecs];
-
-	//	Ensure our codec is on the list of permitted codecs
-	if (nil == [self codec] || NO == [permittedCodecs containsObject: [self codec]]) {
-		if (0 < [permittedCodecs count]) {
-			[self setCodec: [permittedCodecs objectAtIndex: 0]];	//	This should be defaulting to Core Audio
-		}
-		else {
-			[self setCodec: nil];
-		}
-	}
-
-	return;
+    NSMutableArray *permittedCodecs = [NSMutableArray array];
+    unsigned int count = [masterCodecArray count];
+    NSDictionary *dict;
+    NSString *keyThatAllows = nil;
+
+    // Determine which key we use to see which codecs are permitted
+    switch ([videoContainerTag intValue])
+    {
+        case HB_MUX_MP4:
+            keyThatAllows = keyAudioMP4;
+            break;
+        case HB_MUX_MKV:
+            keyThatAllows = keyAudioMKV;
+            break;
+        default:
+            keyThatAllows = @"error condition";
+            break;
+    }
+
+    // First get a list of the permitted codecs based on the internal rules
+    if (nil != track && YES == [self enabled])
+    {
+        BOOL goodToAdd;
+
+        for (unsigned int i = 0; i < count; i++)
+        {
+            dict = [masterCodecArray objectAtIndex: i];
+
+            // First make sure only codecs permitted by the container are here
+            goodToAdd = [[dict objectForKey: keyThatAllows] boolValue];
+
+            // Now we make sure if DTS or AC3 is not available in the track it is not put in the codec list, but in a general way
+            if (YES == [[dict objectForKey: keyAudioMustMatchTrack] boolValue])
+            {
+                if ([[dict objectForKey: keyAudioMustMatchTrack] intValue] != [[[self track] objectForKey: keyAudioInputCodec] intValue])
+                {
+                    goodToAdd = NO;
+                }
+            }
+
+            if (YES == goodToAdd)
+            {
+                [permittedCodecs addObject: dict];
+            }
+        }
+    }
+
+    // Now make sure the permitted list and the actual ones matches
+    [self setCodecs: permittedCodecs];
+
+    // Ensure our codec is on the list of permitted codecs
+    if (nil == [self codec] || NO == [permittedCodecs containsObject: [self codec]])
+    {
+        if (0 < [permittedCodecs count])
+        {
+            [self setCodec: [permittedCodecs objectAtIndex: 0]]; // This should be defaulting to Core Audio
+        }
+        else
+        {
+            [self setCodec: nil];
+        }
+    }
+
+    return;
 }
 
 - (void) updateMixdowns: (BOOL) shouldSetDefault
 
 {
-	NSMutableArray *permittedMixdowns = [NSMutableArray array];
-	NSDictionary *dict;
-	BOOL shouldAdd;
-	int currentMixdown;
-
-	unsigned int count = [masterMixdownArray count];
-	int codecCodec = [[codec objectForKey: keyAudioCodec] intValue];
-	int channelLayout = [[track objectForKey: keyAudioInputChannelLayout] intValue];
-	int theDefaultMixdown = hb_get_default_mixdown(codecCodec, channelLayout);
-	int theBestMixdown = hb_get_best_mixdown(codecCodec, channelLayout, 0);
-
-	for (unsigned int i = 0; i < count; i++) {
-		dict = [masterMixdownArray objectAtIndex: i];
-		currentMixdown = [[dict objectForKey: keyAudioMixdown] intValue];
-
-		//	Basically with the way the mixdowns are stored, the assumption from the libhb point of view
-		//	currently is that all mixdowns from the best down to mono are supported.
-		if (currentMixdown <= theBestMixdown) {
-			shouldAdd = YES;
-		} else if (0 == theBestMixdown && codecCodec == currentMixdown) {
-			// 0 means passthrough, add the current mixdown if it matches the passthrough codec
-			shouldAdd = YES;
-		} else {
-			shouldAdd = NO;
-		}
-
-		if (YES == shouldAdd) {
-			[permittedMixdowns addObject: dict];
-		}
-	}
-
-	if (0 == theDefaultMixdown) {
-		// a mixdown of 0 means passthrough
-		theDefaultMixdown = codecCodec;
-	}
-
-	if (NO == [self enabled]) {
-		permittedMixdowns = nil;
-	}
-
-	//	Now make sure the permitted list and the actual ones matches
-	[self setMixdowns: permittedMixdowns];
-
-	//	Select the proper one
-	if (YES == shouldSetDefault) {
-		[self setMixdown: [permittedMixdowns dictionaryWithObject: [NSNumber numberWithInt: theDefaultMixdown] matchingKey: keyAudioMixdown]];
-	}
-
-	if (nil == [self mixdown] || NO == [permittedMixdowns containsObject: [self mixdown]]) {
-		[self setMixdown: [permittedMixdowns lastObject]];
-	}
-
-	return;
+    NSMutableArray *permittedMixdowns = [NSMutableArray array];
+    NSDictionary *dict;
+    BOOL shouldAdd;
+    int currentMixdown;
+
+    unsigned int count = [masterMixdownArray count];
+    int codecCodec = [[codec objectForKey: keyAudioCodec] intValue];
+    int channelLayout = [[track objectForKey: keyAudioInputChannelLayout] intValue];
+    int theDefaultMixdown = hb_get_default_mixdown(codecCodec, channelLayout);
+    int theBestMixdown = hb_get_best_mixdown(codecCodec, channelLayout, 0);
+
+    for (unsigned int i = 0; i < count; i++)
+    {
+        dict = [masterMixdownArray objectAtIndex: i];
+        currentMixdown = [[dict objectForKey: keyAudioMixdown] intValue];
+
+        // Basically with the way the mixdowns are stored, the assumption from the libhb point of view
+        // currently is that all mixdowns from the best down to mono are supported.
+        if (currentMixdown <= theBestMixdown)
+        {
+            shouldAdd = YES;
+        }
+        else if (0 == theBestMixdown && codecCodec == currentMixdown)
+        {
+            // 0 means passthrough, add the current mixdown if it matches the passthrough codec
+            shouldAdd = YES;
+        }
+        else
+        {
+            shouldAdd = NO;
+        }
+
+        if (YES == shouldAdd)
+        {
+            [permittedMixdowns addObject: dict];
+        }
+    }
+
+    if (0 == theDefaultMixdown)
+    {
+        // a mixdown of 0 means passthrough
+        theDefaultMixdown = codecCodec;
+    }
+
+    if (NO == [self enabled])
+    {
+        permittedMixdowns = nil;
+    }
+
+    // Now make sure the permitted list and the actual ones matches
+    [self setMixdowns: permittedMixdowns];
+
+    // Select the proper one
+    if (YES == shouldSetDefault)
+    {
+        [self setMixdown: [permittedMixdowns dictionaryWithObject: [NSNumber numberWithInt: theDefaultMixdown] matchingKey: keyAudioMixdown]];
+    }
+
+    if (nil == [self mixdown] || NO == [permittedMixdowns containsObject: [self mixdown]])
+    {
+        [self setMixdown: [permittedMixdowns lastObject]];
+    }
+
+    return;
 }
 
 - (void) updateBitRates: (BOOL) shouldSetDefault
 
 {
-	NSMutableArray *permittedBitRates = [NSMutableArray array];
-	NSDictionary *dict;
-	int minBitRate;
-	int maxBitRate;
-	int currentBitRate;
-	BOOL shouldAdd;
-	
-	unsigned int count = [masterBitRateArray count];
-	int trackInputBitRate = [[[self track] objectForKey: keyAudioInputBitrate] intValue];
-	BOOL limitsToTrackInputBitRate = ([[codec objectForKey: keyAudioCodec] intValue] & HB_ACODEC_PASS_FLAG) ? YES : NO;
-	int theSampleRate = [[[self sampleRate] objectForKey: keyAudioSamplerate] intValue];
-		
-	if (0 == theSampleRate) {	//	this means Auto
-		theSampleRate = [[[self track] objectForKey: keyAudioInputSampleRate] intValue];
-		}
-
-	int ourCodec = [[codec objectForKey: keyAudioCodec] intValue];
-	int ourMixdown = [[[self mixdown] objectForKey: keyAudioMixdown] intValue];
-	hb_get_audio_bitrate_limits(ourCodec, theSampleRate, ourMixdown, &minBitRate, &maxBitRate);
-	int theDefaultBitRate = hb_get_default_audio_bitrate(ourCodec, theSampleRate, ourMixdown);
-
-	for (unsigned int i = 0; i < count; i++) {
-		dict = [masterBitRateArray objectAtIndex: i];
-		currentBitRate = [[dict objectForKey: keyAudioBitrate] intValue];
-		
-		//	First ensure the bitrate falls within range of the codec
-		shouldAdd = (currentBitRate >= minBitRate && currentBitRate <= maxBitRate);
-		
-		//	Now make sure the mixdown is not limiting us to the track input bitrate
-		if (YES == shouldAdd && YES == limitsToTrackInputBitRate) {
-			if (currentBitRate != trackInputBitRate) {
-				shouldAdd = NO;
-			}
-		}
-				
-		if (YES == shouldAdd) {
-			[permittedBitRates addObject: dict];
-		}
-	}
-	
-	//	There is a situation where we have a mixdown requirement to match the track input bit rate,
-	//	but it does not fall into the range the codec supports.  Therefore, we force it here.
-	if (YES == limitsToTrackInputBitRate && 0 == [permittedBitRates count]) {
-		NSDictionary *missingBitRate = [masterBitRateArray dictionaryWithObject: [NSNumber numberWithInt: trackInputBitRate] matchingKey: keyAudioBitrate];
-		if (nil == missingBitRate) {
-			//	We are in an even worse situation where the requested bit rate does not even exist in the underlying
-			//	library of supported bitrates.  Of course since this value is ignored we can freely make a bogus one
-			//	for the UI just to make the user a little more aware.
-			missingBitRate = [NSDictionary dictionaryWithObjectsAndKeys:
-							  [NSString stringWithFormat: @"%d", trackInputBitRate], keyAudioBitrateName,
-							  [NSNumber numberWithInt: trackInputBitRate], keyAudioBitrate,
-							  nil];
-			}
-		[permittedBitRates addObject: missingBitRate];
-	}
-
-	if (NO == [self enabled]) {
-		permittedBitRates = nil;
-	}
-
-	//	Make sure we are updated with the permitted list
-	[self setBitRates: permittedBitRates];
-
-	//	Select the proper one
-	if (YES == shouldSetDefault) {
-		[self setBitRateFromName: [NSString stringWithFormat:@"%d", theDefaultBitRate]];
-		}
-
-	if (nil == [self bitRate] || NO == [permittedBitRates containsObject: [self bitRate]]) {
-		[self setBitRate: [permittedBitRates lastObject]];
-	}
-	
-	return;
+    NSMutableArray *permittedBitRates = [NSMutableArray array];
+    NSDictionary *dict;
+    int minBitRate;
+    int maxBitRate;
+    int currentBitRate;
+    BOOL shouldAdd;
+
+    unsigned int count = [masterBitRateArray count];
+    int trackInputBitRate = [[[self track] objectForKey: keyAudioInputBitrate] intValue];
+    BOOL limitsToTrackInputBitRate = ([[codec objectForKey: keyAudioCodec] intValue] & HB_ACODEC_PASS_FLAG) ? YES : NO;
+    int theSampleRate = [[[self sampleRate] objectForKey: keyAudioSamplerate] intValue];
+
+    if (0 == theSampleRate) // this means Auto
+    {
+        theSampleRate = [[[self track] objectForKey: keyAudioInputSampleRate] intValue];
+    }
+
+    int ourCodec = [[codec objectForKey: keyAudioCodec] intValue];
+    int ourMixdown = [[[self mixdown] objectForKey: keyAudioMixdown] intValue];
+    hb_get_audio_bitrate_limits(ourCodec, theSampleRate, ourMixdown, &minBitRate, &maxBitRate);
+    int theDefaultBitRate = hb_get_default_audio_bitrate(ourCodec, theSampleRate, ourMixdown);
+
+    for (unsigned int i = 0; i < count; i++)
+    {
+        dict = [masterBitRateArray objectAtIndex: i];
+        currentBitRate = [[dict objectForKey: keyAudioBitrate] intValue];
+
+        // First ensure the bitrate falls within range of the codec
+        shouldAdd = (currentBitRate >= minBitRate && currentBitRate <= maxBitRate);
+
+        // Now make sure the mixdown is not limiting us to the track input bitrate
+        if (YES == shouldAdd && YES == limitsToTrackInputBitRate)
+        {
+            if (currentBitRate != trackInputBitRate)
+            {
+                shouldAdd = NO;
+            }
+        }
+
+        if (YES == shouldAdd)
+        {
+            [permittedBitRates addObject: dict];
+        }
+    }
+
+    // There is a situation where we have a mixdown requirement to match the track input bit rate,
+    // but it does not fall into the range the codec supports.  Therefore, we force it here.
+    if (YES == limitsToTrackInputBitRate && 0 == [permittedBitRates count])
+    {
+        NSDictionary *missingBitRate = [masterBitRateArray dictionaryWithObject: [NSNumber numberWithInt: trackInputBitRate] matchingKey: keyAudioBitrate];
+        if (nil == missingBitRate)
+        {
+            // We are in an even worse situation where the requested bit rate does not even exist in the underlying
+            // library of supported bitrates.  Of course since this value is ignored we can freely make a bogus one
+            // for the UI just to make the user a little more aware.
+            missingBitRate = [NSDictionary dictionaryWithObjectsAndKeys:
+                              [NSString stringWithFormat: @"%d", trackInputBitRate], keyAudioBitrateName,
+                              [NSNumber numberWithInt: trackInputBitRate], keyAudioBitrate,
+                              nil];
+        }
+        [permittedBitRates addObject: missingBitRate];
+    }
+
+    if (NO == [self enabled])
+    {
+        permittedBitRates = nil;
+    }
+
+    // Make sure we are updated with the permitted list
+    [self setBitRates: permittedBitRates];
+
+    // Select the proper one
+    if (YES == shouldSetDefault)
+    {
+        [self setBitRateFromName: [NSString stringWithFormat:@"%d", theDefaultBitRate]];
+    }
+
+    if (nil == [self bitRate] || NO == [permittedBitRates containsObject: [self bitRate]])
+    {
+        [self setBitRate: [permittedBitRates lastObject]];
+    }
+
+    return;
 }
 
 - (id) init
 
 {
-	if (self = [super init]) {
-		[self addObserver: self forKeyPath: @"videoContainerTag" options: 0 context: NULL];
-		[self addObserver: self forKeyPath: @"track" options: NSKeyValueObservingOptionOld context: NULL];
-		[self addObserver: self forKeyPath: @"codec" options: 0 context: NULL];
-		[self addObserver: self forKeyPath: @"mixdown" options: 0 context: NULL];
-		[self addObserver: self forKeyPath: @"sampleRate" options: 0 context: NULL];
-		}
-	return self;
+    if (self = [super init])
+    {
+        [self addObserver: self forKeyPath: @"videoContainerTag" options: 0 context: NULL];
+        [self addObserver: self forKeyPath: @"track" options: NSKeyValueObservingOptionOld context: NULL];
+        [self addObserver: self forKeyPath: @"codec" options: 0 context: NULL];
+        [self addObserver: self forKeyPath: @"mixdown" options: 0 context: NULL];
+        [self addObserver: self forKeyPath: @"sampleRate" options: 0 context: NULL];
+    }
+    return self;
 }
 
 #pragma mark -
@@ -407,29 +449,32 @@ static NSMutableArray *masterBitRateArray = nil;
 @synthesize mixdowns;
 @synthesize bitRates;
 
-- (NSArray *) sampleRates	{	return masterSampleRateArray;	}
+- (NSArray *) sampleRates
+{
+    return masterSampleRateArray;
+}
 
 - (void) dealloc
 
 {
-	[self removeObserver: self forKeyPath: @"videoContainerTag"];
-	[self removeObserver: self forKeyPath: @"track"];
-	[self removeObserver: self forKeyPath: @"codec"];
-	[self removeObserver: self forKeyPath: @"mixdown"];
-	[self removeObserver: self forKeyPath: @"sampleRate"];
-	[self setTrack: nil];
-	[self setCodec: nil];
-	[self setMixdown: nil];
-	[self setSampleRate: nil];
-	[self setBitRate: nil];
-	[self setDrc: nil];
+    [self removeObserver: self forKeyPath: @"videoContainerTag"];
+    [self removeObserver: self forKeyPath: @"track"];
+    [self removeObserver: self forKeyPath: @"codec"];
+    [self removeObserver: self forKeyPath: @"mixdown"];
+    [self removeObserver: self forKeyPath: @"sampleRate"];
+    [self setTrack: nil];
+    [self setCodec: nil];
+    [self setMixdown: nil];
+    [self setSampleRate: nil];
+    [self setBitRate: nil];
+    [self setDrc: nil];
     [self setGain: nil];
-	[self setVideoContainerTag: nil];
-	[self setCodecs: nil];
-	[self setMixdowns: nil];
-	[self setBitRates: nil];
-	[super dealloc];
-	return;
+    [self setVideoContainerTag: nil];
+    [self setCodecs: nil];
+    [self setMixdowns: nil];
+    [self setBitRates: nil];
+    [super dealloc];
+    return;
 }
 
 #pragma mark -
@@ -438,36 +483,45 @@ static NSMutableArray *masterBitRateArray = nil;
 - (void) observeValueForKeyPath: (NSString *) keyPath ofObject: (id) object change: (NSDictionary *) change context: (void *) context
 
 {
-	if (YES == [keyPath isEqualToString: @"videoContainerTag"]) {
-		[self updateCodecs];
-		}
-	else if (YES == [keyPath isEqualToString: @"track"]) {
-		if (nil != [self track]) {
-			[self updateCodecs];
-			[self updateMixdowns: YES];
-			if (YES == [self enabled]) {
-				[self setSampleRate: [[self sampleRates] objectAtIndex: 0]];	// default to Auto
-				}
-			if (YES == [[controller noneTrack] isEqual: [change objectForKey: NSKeyValueChangeOldKey]]) {
-				[controller switchingTrackFromNone: self];
-				}
-			if (YES == [[controller noneTrack] isEqual: [self track]]) {
-				[controller settingTrackToNone: self];
-				}
-			}
-		}
-	else if (YES == [keyPath isEqualToString: @"codec"]) {
-		[self updateMixdowns: YES];
-		[self updateBitRates: YES];
-		}
-	else if (YES == [keyPath isEqualToString: @"mixdown"]) {
-		[self updateBitRates: YES];
-		[[NSNotificationCenter defaultCenter] postNotificationName: HBMixdownChangedNotification object: self];
-		}
-	else if (YES == [keyPath isEqualToString: @"sampleRate"]) {
-		[self updateBitRates: NO];
-		}
-	return;
+    if (YES == [keyPath isEqualToString: @"videoContainerTag"])
+    {
+        [self updateCodecs];
+    }
+    else if (YES == [keyPath isEqualToString: @"track"])
+    {
+        if (nil != [self track])
+        {
+            [self updateCodecs];
+            [self updateMixdowns: YES];
+            if (YES == [self enabled])
+            {
+                [self setSampleRate: [[self sampleRates] objectAtIndex: 0]]; // default to Auto
+            }
+            if (YES == [[controller noneTrack] isEqual: [change objectForKey: NSKeyValueChangeOldKey]])
+            {
+                [controller switchingTrackFromNone: self];
+            }
+            if (YES == [[controller noneTrack] isEqual: [self track]])
+            {
+                [controller settingTrackToNone: self];
+            }
+        }
+    }
+    else if (YES == [keyPath isEqualToString: @"codec"])
+    {
+        [self updateMixdowns: YES];
+        [self updateBitRates: YES];
+    }
+    else if (YES == [keyPath isEqualToString: @"mixdown"])
+    {
+        [self updateBitRates: YES];
+        [[NSNotificationCenter defaultCenter] postNotificationName: HBMixdownChangedNotification object: self];
+    }
+    else if (YES == [keyPath isEqualToString: @"sampleRate"])
+    {
+        [self updateBitRates: NO];
+    }
+    return;
 }
 
 #pragma mark -
@@ -476,88 +530,96 @@ static NSMutableArray *masterBitRateArray = nil;
 - (void) setTrackFromIndex: (int) aValue
 
 {
-	[self setTrack: [self.controller.masterTrackArray dictionaryWithObject: [NSNumber numberWithInt: aValue] matchingKey: keyAudioTrackIndex]];
+    [self setTrack: [self.controller.masterTrackArray dictionaryWithObject: [NSNumber numberWithInt: aValue] matchingKey: keyAudioTrackIndex]];
 }
 
-//	This returns whether it is able to set the actual codec desired.
+// This returns whether it is able to set the actual codec desired.
 - (BOOL) setCodecFromName: (NSString *) aValue
 
 {
-	NSDictionary *dict = [[self codecs] dictionaryWithObject: aValue matchingKey: keyAudioCodecName];
-	
-	if (nil != dict) {
-		[self setCodec: dict];
-	}
-	return (nil != dict);
+    NSDictionary *dict = [[self codecs] dictionaryWithObject: aValue matchingKey: keyAudioCodecName];
+
+    if (nil != dict)
+    {
+        [self setCodec: dict];
+    }
+    return (nil != dict);
 }
 
 - (void) setMixdownFromName: (NSString *) aValue
 
 {
-	NSDictionary *dict = [[self mixdowns] dictionaryWithObject: aValue matchingKey: keyAudioMixdownName];
+    NSDictionary *dict = [[self mixdowns] dictionaryWithObject: aValue matchingKey: keyAudioMixdownName];
 
-	if (nil != dict) {
-		[self setMixdown: dict];
-	}
-	return;
+    if (nil != dict)
+    {
+        [self setMixdown: dict];
+    }
+    return;
 }
 
 - (void) setSampleRateFromName: (NSString *) aValue
 
 {
-	NSDictionary *dict = [[self sampleRates] dictionaryWithObject: aValue matchingKey: keyAudioSampleRateName];
-	
-	if (nil != dict) {
-		[self setSampleRate: dict];
-	}
-	return;
+    NSDictionary *dict = [[self sampleRates] dictionaryWithObject: aValue matchingKey: keyAudioSampleRateName];
+
+    if (nil != dict)
+    {
+        [self setSampleRate: dict];
+    }
+    return;
 }
 
 - (void) setBitRateFromName: (NSString *) aValue
 
 {
-	NSDictionary *dict = [[self bitRates] dictionaryWithObject: aValue matchingKey: keyAudioBitrateName];
-	
-	if (nil != dict) {
-		[self setBitRate: dict];
-	}
-	return;
+    NSDictionary *dict = [[self bitRates] dictionaryWithObject: aValue matchingKey: keyAudioBitrateName];
+
+    if (nil != dict)
+    {
+        [self setBitRate: dict];
+    }
+    return;
 }
 
 
 #pragma mark -
 #pragma mark Validation
 
-//	Because we have indicated that the binding for the drc validates immediately we can implement the
-//	key value binding method to ensure the drc stays in our accepted range.
+// Because we have indicated that the binding for the drc validates immediately we can implement the
+// key value binding method to ensure the drc stays in our accepted range.
 - (BOOL) validateDrc: (id *) ioValue error: (NSError *) outError
 
 {
-	BOOL retval = YES;
-	
-	if (nil != *ioValue) {
-		if (0.0 < [*ioValue floatValue] && 1.0 > [*ioValue floatValue]) {
-			*ioValue = [NSNumber numberWithFloat: 1.0];
-		}
-	}
-	
-	return retval;
+    BOOL retval = YES;
+
+    if (nil != *ioValue)
+    {
+        if (0.0 < [*ioValue floatValue] && 1.0 > [*ioValue floatValue])
+        {
+            *ioValue = [NSNumber numberWithFloat: 1.0];
+        }
+    }
+
+    return retval;
 }
 
-//	Because we have indicated that the binding for the gain validates immediately we can implement the
-//	key value binding method to ensure the gain stays in our accepted range.
- 
+// Because we have indicated that the binding for the gain validates immediately we can implement the
+// key value binding method to ensure the gain stays in our accepted range.
+
 - (BOOL) validateGain: (id *) ioValue error: (NSError *) outError
 {
-	BOOL retval = YES;
-	
-	if (nil != *ioValue) {
-		if (0.0 < [*ioValue floatValue] && 1.0 > [*ioValue floatValue]) {
-			*ioValue = [NSNumber numberWithFloat: 0.0];
-		}
-	}
-	
-	return retval;
+    BOOL retval = YES;
+
+    if (nil != *ioValue)
+    {
+        if (0.0 < [*ioValue floatValue] && 1.0 > [*ioValue floatValue])
+        {
+            *ioValue = [NSNumber numberWithFloat: 0.0];
+        }
+    }
+
+    return retval;
 }
 
 #pragma mark -
@@ -566,70 +628,80 @@ static NSMutableArray *masterBitRateArray = nil;
 - (BOOL) enabled
 
 {
-	return (nil != track) ? (NO == [track isEqual: [controller noneTrack]]) : NO;
+    return (nil != track) ? (NO == [track isEqual: [controller noneTrack]]) : NO;
 }
 
 - (BOOL) mixdownEnabled
 
 {
-	BOOL retval = [self enabled];
-
-	if (YES == retval) {
-		int myMixdown = [[[self mixdown] objectForKey: keyAudioMixdown] intValue];
-		if (HB_ACODEC_AC3_PASS == myMixdown || HB_ACODEC_DCA_PASS == myMixdown) {
-			retval = NO;
-		}
-	}
-	return retval;
+    BOOL retval = [self enabled];
+
+    if (YES == retval)
+    {
+        int myMixdown = [[[self mixdown] objectForKey: keyAudioMixdown] intValue];
+        if (HB_ACODEC_AC3_PASS == myMixdown || HB_ACODEC_DCA_PASS == myMixdown)
+        {
+            retval = NO;
+        }
+    }
+    return retval;
 }
 
 - (BOOL) AC3Enabled
 
 {
-	BOOL retval = [self enabled];
-	
-	if (YES == retval) {
-		int myTrackCodec = [[[self track] objectForKey: keyAudioInputCodec] intValue];
-		int myCodecCodec = [[[self codec] objectForKey: keyAudioCodec] intValue];
-		if (HB_ACODEC_AC3 != myTrackCodec || HB_ACODEC_AC3_PASS == myCodecCodec) {
-			retval = NO;
-		}
-	}
-	return retval;
+    BOOL retval = [self enabled];
+
+    if (YES == retval)
+    {
+        int myTrackCodec = [[[self track] objectForKey: keyAudioInputCodec] intValue];
+        int myCodecCodec = [[[self codec] objectForKey: keyAudioCodec] intValue];
+        if (HB_ACODEC_AC3 != myTrackCodec || HB_ACODEC_AC3_PASS == myCodecCodec)
+        {
+            retval = NO;
+        }
+    }
+    return retval;
 }
 
 - (BOOL) PassThruDisabled
 
 {
-	BOOL retval = [self enabled];
-	
-	if (YES == retval) {
-		int myCodecCodec = [[[self codec] objectForKey: keyAudioCodec] intValue];
-		if (HB_ACODEC_AC3_PASS == myCodecCodec || HB_ACODEC_DCA_PASS == myCodecCodec) {
-			retval = NO;
-		}
-	}
-	return retval;
+    BOOL retval = [self enabled];
+
+    if (YES == retval)
+    {
+        int myCodecCodec = [[[self codec] objectForKey: keyAudioCodec] intValue];
+        if (HB_ACODEC_AC3_PASS == myCodecCodec || HB_ACODEC_DCA_PASS == myCodecCodec)
+        {
+            retval = NO;
+        }
+    }
+    return retval;
 }
 
 + (NSSet *) keyPathsForValuesAffectingValueForKey: (NSString *) key
 
 {
-	NSSet *retval = nil;
-
-	if (YES == [key isEqualToString: @"enabled"]) {
-		retval = [NSSet setWithObjects: @"track", nil];
-		}
-    else if (YES == [key isEqualToString: @"PassThruDisabled"]) {
-		retval = [NSSet setWithObjects: @"track", @"codec", nil];
-	}
-	else if (YES == [key isEqualToString: @"AC3Enabled"]) {
-		retval = [NSSet setWithObjects: @"track", @"codec", nil];
-	}
-	else if (YES == [key isEqualToString: @"mixdownEnabled"]) {
-		retval = [NSSet setWithObjects: @"track", @"mixdown", nil];
-		}
-	return retval;
+    NSSet *retval = nil;
+
+    if (YES == [key isEqualToString: @"enabled"])
+    {
+        retval = [NSSet setWithObjects: @"track", nil];
+    }
+    else if (YES == [key isEqualToString: @"PassThruDisabled"])
+    {
+        retval = [NSSet setWithObjects: @"track", @"codec", nil];
+    }
+    else if (YES == [key isEqualToString: @"AC3Enabled"])
+    {
+        retval = [NSSet setWithObjects: @"track", @"codec", nil];
+    }
+    else if (YES == [key isEqualToString: @"mixdownEnabled"])
+    {
+        retval = [NSSet setWithObjects: @"track", @"mixdown", nil];
+    }
+    return retval;
 }
 
 @end
diff --git a/macosx/HBAudioController.h b/macosx/HBAudioController.h
index a998b446d..69c1d501a 100644
--- a/macosx/HBAudioController.h
+++ b/macosx/HBAudioController.h
@@ -20,13 +20,13 @@ extern NSString *HBMixdownChangedNotification;
 
 @interface HBAudioController : NSObject
 
-	{
-	id					myController;
-	NSMutableArray		*audioArray;		//	the configured audio information
-	NSArray				*masterTrackArray;	//	the master list of audio tracks from the title
-	NSDictionary		*noneTrack;			//	this represents no audio track selection
-	NSNumber			*videoContainerTag;	//	initially is the default HB_MUX_MP4
-	}
+{
+    id                             myController;
+    NSMutableArray               * audioArray;        // the configured audio information
+    NSArray                      * masterTrackArray;  // the master list of audio tracks from the title
+    NSDictionary                 * noneTrack;         // this represents no audio track selection
+    NSNumber                     * videoContainerTag; // initially is the default HB_MUX_MP4
+}
 
 @property (nonatomic, readonly, retain) NSArray *masterTrackArray;
 @property (nonatomic, readonly) NSDictionary *noneTrack;
diff --git a/macosx/HBAudioController.m b/macosx/HBAudioController.m
index 9aabe2536..b604fcc87 100644
--- a/macosx/HBAudioController.m
+++ b/macosx/HBAudioController.m
@@ -38,44 +38,46 @@ NSString *HBMixdownChangedNotification = @"HBMixdownChangedNotification";
 - (id) init
 
 {
-	if (self = [super init]) {
-		[self setVideoContainerTag: [NSNumber numberWithInt: HB_MUX_MP4]];
-		audioArray = [[NSMutableArray alloc] init];
-	}
-	return self;
+    if (self = [super init])
+    {
+        [self setVideoContainerTag: [NSNumber numberWithInt: HB_MUX_MP4]];
+        audioArray = [[NSMutableArray alloc] init];
+    }
+    return self;
 }
 
 - (void) dealloc
 
 {
-	[[NSNotificationCenter defaultCenter] removeObserver: self];
-	[masterTrackArray release];
-	[noneTrack release];
-	[audioArray release];
-	[self setVideoContainerTag: nil];
-	[super dealloc];
-	return;
+    [[NSNotificationCenter defaultCenter] removeObserver: self];
+    [masterTrackArray release];
+    [noneTrack release];
+    [audioArray release];
+    [self setVideoContainerTag: nil];
+    [super dealloc];
+    return;
 }
 
 - (void) setHBController: (id) aController
 
 {
-	NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
-	myController = aController;
+    NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+    myController = aController;
 
-	/* register that we are interested in changes made to the video container */
-	[center addObserver: self selector: @selector(containerChanged:) name: HBContainerChangedNotification object: aController];
-	[center addObserver: self selector: @selector(titleChanged:) name: HBTitleChangedNotification object: aController];
-	return;
+    /* register that we are interested in changes made to the video container */
+    [center addObserver: self selector: @selector(containerChanged:) name: HBContainerChangedNotification object: aController];
+    [center addObserver: self selector: @selector(titleChanged:) name: HBTitleChangedNotification object: aController];
+    return;
 }
 
 - (void) _clearAudioArray
 
 {
-	while (0 < [self countOfAudioArray]) {
-		[self removeObjectFromAudioArrayAtIndex: 0];
-	}
-	return;
+    while (0 < [self countOfAudioArray])
+    {
+        [self removeObjectFromAudioArrayAtIndex: 0];
+    }
+    return;
 }
 
 #pragma mark -
@@ -84,22 +86,24 @@ NSString *HBMixdownChangedNotification = @"HBMixdownChangedNotification";
 - (void) prepareAudioForQueueFileJob: (NSMutableDictionary *) aDict
 
 {
-	unsigned int audioArrayCount = [self countOfAudioArray];
-	for (unsigned int counter = 0; counter < audioArrayCount; counter++) {
-		HBAudio *anAudio = [self objectInAudioArrayAtIndex: counter];
-		if (YES == [anAudio enabled]) {
-			NSString *prefix = [NSString stringWithFormat: @"Audio%d", counter + 1];
-			NSNumber *sampleRateToUse = (0 == [[[anAudio sampleRate] objectForKey: keyAudioSamplerate] intValue]) ?
-								[[anAudio track] objectForKey: keyAudioInputSampleRate] :
-								[[anAudio sampleRate] objectForKey: keyAudioSamplerate];
-		
-			[aDict setObject: [[anAudio track] objectForKey: keyAudioTrackIndex] forKey: [prefix stringByAppendingString: @"Track"]];
-			[aDict setObject: [[anAudio track] objectForKey: keyAudioTrackName] forKey: [prefix stringByAppendingString: @"TrackDescription"]];
-			[aDict setObject: [[anAudio codec] objectForKey: keyAudioCodecName] forKey: [prefix stringByAppendingString: @"Encoder"]];
-			[aDict setObject: [[anAudio mixdown] objectForKey: keyAudioMixdownName] forKey: [prefix stringByAppendingString: @"Mixdown"]];
-			[aDict setObject: [[anAudio sampleRate] objectForKey: keyAudioSampleRateName] forKey: [prefix stringByAppendingString: @"Samplerate"]];
-			[aDict setObject: [[anAudio bitRate] objectForKey: keyAudioBitrateName] forKey: [prefix stringByAppendingString: @"Bitrate"]];
-            
+    unsigned int audioArrayCount = [self countOfAudioArray];
+    for (unsigned int counter = 0; counter < audioArrayCount; counter++)
+    {
+        HBAudio *anAudio = [self objectInAudioArrayAtIndex: counter];
+        if (YES == [anAudio enabled])
+        {
+            NSString *prefix = [NSString stringWithFormat: @"Audio%d", counter + 1];
+            NSNumber *sampleRateToUse = (0 == [[[anAudio sampleRate] objectForKey: keyAudioSamplerate] intValue]) ?
+            [[anAudio track] objectForKey: keyAudioInputSampleRate] :
+            [[anAudio sampleRate] objectForKey: keyAudioSamplerate];
+
+            [aDict setObject: [[anAudio track] objectForKey: keyAudioTrackIndex] forKey: [prefix stringByAppendingString: @"Track"]];
+            [aDict setObject: [[anAudio track] objectForKey: keyAudioTrackName] forKey: [prefix stringByAppendingString: @"TrackDescription"]];
+            [aDict setObject: [[anAudio codec] objectForKey: keyAudioCodecName] forKey: [prefix stringByAppendingString: @"Encoder"]];
+            [aDict setObject: [[anAudio mixdown] objectForKey: keyAudioMixdownName] forKey: [prefix stringByAppendingString: @"Mixdown"]];
+            [aDict setObject: [[anAudio sampleRate] objectForKey: keyAudioSampleRateName] forKey: [prefix stringByAppendingString: @"Samplerate"]];
+            [aDict setObject: [[anAudio bitRate] objectForKey: keyAudioBitrateName] forKey: [prefix stringByAppendingString: @"Bitrate"]];
+
             // output is not passthru so apply gain
             if (HB_ACODEC_AC3_PASS != [[[anAudio codec] objectForKey: keyAudioCodec] intValue] && HB_ACODEC_DCA_PASS != [[[anAudio codec] objectForKey: keyAudioCodec] intValue])
             {
@@ -108,339 +112,369 @@ NSString *HBMixdownChangedNotification = @"HBMixdownChangedNotification";
             else
             {
                 // output is passthru - the Gain dial is disabled so don't apply its value
-				[aDict setObject: [NSNumber numberWithInt:0] forKey: [prefix stringByAppendingString: @"TrackGainSlider"]];
+                [aDict setObject: [NSNumber numberWithInt:0] forKey: [prefix stringByAppendingString: @"TrackGainSlider"]];
             }
-		
-			if ((HB_ACODEC_AC3 == [[[anAudio track] objectForKey: keyAudioInputCodec] intValue]) &&
-			    (HB_ACODEC_AC3_PASS != [[[anAudio codec] objectForKey: keyAudioCodec] intValue])) {
-				[aDict setObject: [anAudio drc] forKey: [prefix stringByAppendingString: @"TrackDRCSlider"]];
-			}
-			else {
-				// source isn't AC3 or output is passthru - the DRC dial is disabled so don't apply its value
-				[aDict setObject: [NSNumber numberWithInt:0] forKey: [prefix stringByAppendingString: @"TrackDRCSlider"]];
-			}
-		
-			prefix = [NSString stringWithFormat: @"JobAudio%d", counter + 1];
-			[aDict setObject: [[anAudio codec] objectForKey: keyAudioCodec] forKey: [prefix stringByAppendingString: @"Encoder"]];
-			[aDict setObject: [[anAudio mixdown] objectForKey: keyAudioMixdown] forKey: [prefix stringByAppendingString: @"Mixdown"]];
-			[aDict setObject: sampleRateToUse forKey: [prefix stringByAppendingString: @"Samplerate"]];
-			[aDict setObject: [[anAudio bitRate] objectForKey: keyAudioBitrate] forKey: [prefix stringByAppendingString: @"Bitrate"]];
-		}
-	}
-	return;
+
+            if ((HB_ACODEC_AC3 == [[[anAudio track] objectForKey: keyAudioInputCodec] intValue]) &&
+                (HB_ACODEC_AC3_PASS != [[[anAudio codec] objectForKey: keyAudioCodec] intValue]))
+            {
+                [aDict setObject: [anAudio drc] forKey: [prefix stringByAppendingString: @"TrackDRCSlider"]];
+            }
+            else
+            {
+                // source isn't AC3 or output is passthru - the DRC dial is disabled so don't apply its value
+                [aDict setObject: [NSNumber numberWithInt:0] forKey: [prefix stringByAppendingString: @"TrackDRCSlider"]];
+            }
+
+            prefix = [NSString stringWithFormat: @"JobAudio%d", counter + 1];
+            [aDict setObject: [[anAudio codec] objectForKey: keyAudioCodec] forKey: [prefix stringByAppendingString: @"Encoder"]];
+            [aDict setObject: [[anAudio mixdown] objectForKey: keyAudioMixdown] forKey: [prefix stringByAppendingString: @"Mixdown"]];
+            [aDict setObject: sampleRateToUse forKey: [prefix stringByAppendingString: @"Samplerate"]];
+            [aDict setObject: [[anAudio bitRate] objectForKey: keyAudioBitrate] forKey: [prefix stringByAppendingString: @"Bitrate"]];
+        }
+    }
+    return;
 }
 
 - (void) prepareAudioForJob: (hb_job_t *) aJob
 
 {
-	unsigned int i;
-	
-	//	First clear out any audio tracks in the job currently
+    unsigned int i;
+
+    // First clear out any audio tracks in the job currently
     int audiotrack_count = hb_list_count(aJob->list_audio);
     for(i = 0; i < audiotrack_count; i++)
+
     {
         hb_audio_t *temp_audio = (hb_audio_t *) hb_list_item(aJob->list_audio, 0);
         hb_list_rem(aJob->list_audio, temp_audio);
     }
 
-	//	Now add audio tracks based on the current settings
-	unsigned int audioArrayCount = [self countOfAudioArray];
-	for (i = 0; i < audioArrayCount; i++) {
-		HBAudio *anAudio = [self objectInAudioArrayAtIndex: i];
-		if (YES == [anAudio enabled]) {
-			NSNumber *sampleRateToUse = (0 == [[[anAudio sampleRate] objectForKey: keyAudioSamplerate] intValue]) ?
-										[[anAudio track] objectForKey: keyAudioInputSampleRate] :
-										[[anAudio sampleRate] objectForKey: keyAudioSamplerate];
-			
-			hb_audio_config_t *audio = (hb_audio_config_t *) calloc(1, sizeof(*audio));
-			hb_audio_config_init(audio);
-			audio->in.track = [[[anAudio track] objectForKey: keyAudioTrackIndex] intValue] - 1;
-			/* We go ahead and assign values to our audio->out.<properties> */
-			audio->out.track = audio->in.track;
-			audio->out.codec = [[[anAudio codec] objectForKey: keyAudioCodec] intValue];
-			audio->out.mixdown = [[[anAudio mixdown] objectForKey: keyAudioMixdown] intValue];
-			audio->out.bitrate = [[[anAudio bitRate] objectForKey: keyAudioBitrate] intValue];
-			audio->out.samplerate = [sampleRateToUse intValue];
-			audio->out.dynamic_range_compression = [[anAudio drc] floatValue];
+    // Now add audio tracks based on the current settings
+    unsigned int audioArrayCount = [self countOfAudioArray];
+    for (i = 0; i < audioArrayCount; i++)
+    {
+        HBAudio *anAudio = [self objectInAudioArrayAtIndex: i];
+        if (YES == [anAudio enabled])
+        {
+            NSNumber *sampleRateToUse = (0 == [[[anAudio sampleRate] objectForKey: keyAudioSamplerate] intValue]) ?
+            [[anAudio track] objectForKey: keyAudioInputSampleRate] :
+            [[anAudio sampleRate] objectForKey: keyAudioSamplerate];
+
+            hb_audio_config_t *audio = (hb_audio_config_t *) calloc(1, sizeof(*audio));
+            hb_audio_config_init(audio);
+            audio->in.track = [[[anAudio track] objectForKey: keyAudioTrackIndex] intValue] - 1;
+            /* We go ahead and assign values to our audio->out.<properties> */
+            audio->out.track = audio->in.track;
+            audio->out.codec = [[[anAudio codec] objectForKey: keyAudioCodec] intValue];
+            audio->out.mixdown = [[[anAudio mixdown] objectForKey: keyAudioMixdown] intValue];
+            audio->out.bitrate = [[[anAudio bitRate] objectForKey: keyAudioBitrate] intValue];
+            audio->out.samplerate = [sampleRateToUse intValue];
+            audio->out.dynamic_range_compression = [[anAudio drc] floatValue];
             audio->out.gain = [[anAudio gain] floatValue];
-        
-			hb_audio_add(aJob, audio);
-			free(audio);
-		}
-	}
-	return;
+
+            hb_audio_add(aJob, audio);
+            free(audio);
+        }
+    }
+    return;
 }
 
 - (void) prepareAudioForPreset: (NSMutableArray *) anArray
 
 {
-	unsigned int audioArrayCount = [self countOfAudioArray];
-	unsigned int i;
-
-	for (i = 0; i < audioArrayCount; i++) {
-		HBAudio *anAudio = [self objectInAudioArrayAtIndex: i];
-		if (YES == [anAudio enabled]) {
-			NSMutableDictionary *dict = [[NSMutableDictionary alloc] initWithCapacity: 7];
-			[dict setObject: [[anAudio track] objectForKey: keyAudioTrackIndex] forKey: @"AudioTrack"];
-			[dict setObject: [[anAudio track] objectForKey: keyAudioTrackName] forKey: @"AudioTrackDescription"];
-			[dict setObject: [[anAudio codec] objectForKey: keyAudioCodecName] forKey: @"AudioEncoder"];
-			[dict setObject: [[anAudio mixdown] objectForKey: keyAudioMixdownName] forKey: @"AudioMixdown"];
-			[dict setObject: [[anAudio sampleRate] objectForKey: keyAudioSampleRateName] forKey: @"AudioSamplerate"];
-			[dict setObject: [[anAudio bitRate] objectForKey: keyAudioBitrateName] forKey: @"AudioBitrate"];
-			[dict setObject: [anAudio drc] forKey: @"AudioTrackDRCSlider"];
+    unsigned int audioArrayCount = [self countOfAudioArray];
+    unsigned int i;
+
+    for (i = 0; i < audioArrayCount; i++)
+    {
+        HBAudio *anAudio = [self objectInAudioArrayAtIndex: i];
+        if (YES == [anAudio enabled])
+        {
+            NSMutableDictionary *dict = [[NSMutableDictionary alloc] initWithCapacity: 7];
+            [dict setObject: [[anAudio track] objectForKey: keyAudioTrackIndex] forKey: @"AudioTrack"];
+            [dict setObject: [[anAudio track] objectForKey: keyAudioTrackName] forKey: @"AudioTrackDescription"];
+            [dict setObject: [[anAudio codec] objectForKey: keyAudioCodecName] forKey: @"AudioEncoder"];
+            [dict setObject: [[anAudio mixdown] objectForKey: keyAudioMixdownName] forKey: @"AudioMixdown"];
+            [dict setObject: [[anAudio sampleRate] objectForKey: keyAudioSampleRateName] forKey: @"AudioSamplerate"];
+            [dict setObject: [[anAudio bitRate] objectForKey: keyAudioBitrateName] forKey: @"AudioBitrate"];
+            [dict setObject: [anAudio drc] forKey: @"AudioTrackDRCSlider"];
             [dict setObject: [anAudio gain] forKey: @"AudioTrackGainSlider"];
-			[anArray addObject: dict];
-			[dict release];
-		}
-	}
-	return;
+            [anArray addObject: dict];
+            [dict release];
+        }
+    }
+    return;
 }
 
 - (void) addTracksFromQueue: (NSMutableDictionary *) aQueue
 
 {
-	NSString *base;
-	int value;
-	int maximumNumberOfAllowedAudioTracks = [HBController maximumNumberOfAllowedAudioTracks];
-
-	//	Reinitialize the configured list of audio tracks
-	[self _clearAudioArray];
-	
-	//	The following is the pattern to follow, but with Audio%dTrack being the key to seek...
-	//	Can we assume that there will be no skip in the data?
-	for (unsigned int i = 1; i <= maximumNumberOfAllowedAudioTracks; i++) {
-		base = [NSString stringWithFormat: @"Audio%d", i];
-		value = [[aQueue objectForKey: [base stringByAppendingString: @"Track"]] intValue];
-		if (0 < value) {
-			HBAudio *newAudio = [[HBAudio alloc] init];
-			[newAudio setController: self];
-			[self insertObject: newAudio inAudioArrayAtIndex: [self countOfAudioArray]];
-			[newAudio setVideoContainerTag: [self videoContainerTag]];
-			[newAudio setTrackFromIndex: value];
-			[newAudio setCodecFromName: [aQueue objectForKey: [base stringByAppendingString: @"Encoder"]]];
-			[newAudio setMixdownFromName: [aQueue objectForKey: [base stringByAppendingString: @"Mixdown"]]];
-			[newAudio setSampleRateFromName: [aQueue objectForKey: [base stringByAppendingString: @"Samplerate"]]];
-			[newAudio setBitRateFromName: [aQueue objectForKey: [base stringByAppendingString: @"Bitrate"]]];
-			[newAudio setDrc: [aQueue objectForKey: [base stringByAppendingString: @"TrackDRCSlider"]]];
+    NSString *base;
+    int value;
+    int maximumNumberOfAllowedAudioTracks = [HBController maximumNumberOfAllowedAudioTracks];
+
+    // Reinitialize the configured list of audio tracks
+    [self _clearAudioArray];
+
+    // The following is the pattern to follow, but with Audio%dTrack being the key to seek...
+    // Can we assume that there will be no skip in the data?
+    for (unsigned int i = 1; i <= maximumNumberOfAllowedAudioTracks; i++)
+    {
+        base = [NSString stringWithFormat: @"Audio%d", i];
+        value = [[aQueue objectForKey: [base stringByAppendingString: @"Track"]] intValue];
+        if (0 < value)
+        {
+            HBAudio *newAudio = [[HBAudio alloc] init];
+            [newAudio setController: self];
+            [self insertObject: newAudio inAudioArrayAtIndex: [self countOfAudioArray]];
+            [newAudio setVideoContainerTag: [self videoContainerTag]];
+            [newAudio setTrackFromIndex: value];
+            [newAudio setCodecFromName: [aQueue objectForKey: [base stringByAppendingString: @"Encoder"]]];
+            [newAudio setMixdownFromName: [aQueue objectForKey: [base stringByAppendingString: @"Mixdown"]]];
+            [newAudio setSampleRateFromName: [aQueue objectForKey: [base stringByAppendingString: @"Samplerate"]]];
+            [newAudio setBitRateFromName: [aQueue objectForKey: [base stringByAppendingString: @"Bitrate"]]];
+            [newAudio setDrc: [aQueue objectForKey: [base stringByAppendingString: @"TrackDRCSlider"]]];
             [newAudio setGain: [aQueue objectForKey: [base stringByAppendingString: @"TrackGainSlider"]]];
-			[newAudio release];
-		}
-	}
+            [newAudio release];
+        }
+    }
+
+    [self switchingTrackFromNone: nil]; // see if we need to add one to the list
 
-	[self switchingTrackFromNone: nil];	// see if we need to add one to the list
-	
-	return;
+    return;
 }
 
-//	This routine takes the preset and will return the value for the key AudioList
-//	if it exists, otherwise it creates an array from the data in the present.
+// This routine takes the preset and will return the value for the key AudioList
+// if it exists, otherwise it creates an array from the data in the present.
 - (NSArray *) _presetAudioArrayFromPreset: (NSMutableDictionary *) aPreset
 
 {
-	NSArray *retval = [aPreset objectForKey: @"AudioList"];
-
-	if (nil == retval) {
-		int maximumNumberOfAllowedAudioTracks = [HBController maximumNumberOfAllowedAudioTracks];
-		NSString *base;
-		NSMutableArray *whatToUse = [NSMutableArray array];
-		for (unsigned int i = 1; i <= maximumNumberOfAllowedAudioTracks; i++) {
-			base = [NSString stringWithFormat: @"Audio%d", i];
-			if (nil != [aPreset objectForKey: [base stringByAppendingString: @"Track"]]) {
-				[whatToUse addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									   [aPreset objectForKey: [base stringByAppendingString: @"Encoder"]], @"AudioEncoder",
-									   [aPreset objectForKey: [base stringByAppendingString: @"Mixdown"]], @"AudioMixdown",
-									   [aPreset objectForKey: [base stringByAppendingString: @"Samplerate"]], @"AudioSamplerate",
-									   [aPreset objectForKey: [base stringByAppendingString: @"Bitrate"]], @"AudioBitrate",
-									   [aPreset objectForKey: [base stringByAppendingString: @"TrackDRCSlider"]], @"AudioTrackDRCSlider",
+    NSArray *retval = [aPreset objectForKey: @"AudioList"];
+
+    if (nil == retval)
+    {
+        int maximumNumberOfAllowedAudioTracks = [HBController maximumNumberOfAllowedAudioTracks];
+        NSString *base;
+        NSMutableArray *whatToUse = [NSMutableArray array];
+        for (unsigned int i = 1; i <= maximumNumberOfAllowedAudioTracks; i++)
+        {
+            base = [NSString stringWithFormat: @"Audio%d", i];
+            if (nil != [aPreset objectForKey: [base stringByAppendingString: @"Track"]])
+            {
+                [whatToUse addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                       [aPreset objectForKey: [base stringByAppendingString: @"Encoder"]], @"AudioEncoder",
+                                       [aPreset objectForKey: [base stringByAppendingString: @"Mixdown"]], @"AudioMixdown",
+                                       [aPreset objectForKey: [base stringByAppendingString: @"Samplerate"]], @"AudioSamplerate",
+                                       [aPreset objectForKey: [base stringByAppendingString: @"Bitrate"]], @"AudioBitrate",
+                                       [aPreset objectForKey: [base stringByAppendingString: @"TrackDRCSlider"]], @"AudioTrackDRCSlider",
                                        [aPreset objectForKey: [base stringByAppendingString: @"TrackGainSlider"]], @"AudioTrackGainSlider",
-									   nil]];
-			}
-		}
-		retval = whatToUse;
-	}
-	return retval;
+                                       nil]];
+            }
+        }
+        retval = whatToUse;
+    }
+    return retval;
 }
 
-//	This uses the templateAudioArray from the preset to create the audios for the specified trackIndex
+// This uses the templateAudioArray from the preset to create the audios for the specified trackIndex
 - (void) _processPresetAudioArray: (NSArray *) templateAudioArray forTrack: (unsigned int) trackIndex andType: (int) aType
 
 {
-	NSEnumerator *enumerator = [templateAudioArray objectEnumerator];
-	NSMutableDictionary *dict;
-	NSString *key;
-	int maximumNumberOfAllowedAudioTracks = [HBController maximumNumberOfAllowedAudioTracks];
-	
-	while (nil != (dict = [enumerator nextObject])) {
-		if ([self countOfAudioArray] < maximumNumberOfAllowedAudioTracks) {
-			BOOL fallenBack = NO;
-			HBAudio *newAudio = [[HBAudio alloc] init];
-			[newAudio setController: self];
-			[self insertObject: newAudio inAudioArrayAtIndex: [self countOfAudioArray]];
-			[newAudio setVideoContainerTag: [self videoContainerTag]];
-			[newAudio setTrackFromIndex: trackIndex];
-			key = [dict objectForKey: @"AudioEncoder"];
-			if (0 == aType &&
-				YES == [[NSUserDefaults standardUserDefaults] boolForKey: @"UseCoreAudio"] &&
-				YES == [key isEqualToString: @"AAC (faac)"]
-				) {
-				key = @"AAC (CoreAudio)";
-			}
-			if (YES == [[NSUserDefaults standardUserDefaults] boolForKey: @"AC3PassthruDefaultsToAC3"] &&
-				YES == [key isEqualToString: @"AC3 Passthru"]) {
-				if (NO == [newAudio setCodecFromName: key]) {
-					key = @"AC3";
-					fallenBack = YES;
-				}
-			}
+    NSEnumerator *enumerator = [templateAudioArray objectEnumerator];
+    NSMutableDictionary *dict;
+    NSString *key;
+    int maximumNumberOfAllowedAudioTracks = [HBController maximumNumberOfAllowedAudioTracks];
+
+    while (nil != (dict = [enumerator nextObject]))
+    {
+        if ([self countOfAudioArray] < maximumNumberOfAllowedAudioTracks)
+        {
+            BOOL fallenBack = NO;
+            HBAudio *newAudio = [[HBAudio alloc] init];
+            [newAudio setController: self];
+            [self insertObject: newAudio inAudioArrayAtIndex: [self countOfAudioArray]];
+            [newAudio setVideoContainerTag: [self videoContainerTag]];
+            [newAudio setTrackFromIndex: trackIndex];
+            key = [dict objectForKey: @"AudioEncoder"];
+            if (0 == aType &&
+                YES == [[NSUserDefaults standardUserDefaults] boolForKey: @"UseCoreAudio"] &&
+                YES == [key isEqualToString: @"AAC (faac)"])
+            {
+                key = @"AAC (CoreAudio)";
+            }
+            if (YES == [[NSUserDefaults standardUserDefaults] boolForKey: @"AC3PassthruDefaultsToAC3"] &&
+                YES == [key isEqualToString: @"AC3 Passthru"])
+            {
+                if (NO == [newAudio setCodecFromName: key])
+                {
+                    key = @"AC3";
+                    fallenBack = YES;
+                }
+            }
             // If our preset does not contain a drc or gain value set it to a default of 0.0
             if (![dict objectForKey: @"AudioTrackDRCSlider"])
+
             {
                 [dict setObject:[NSNumber numberWithFloat:0.0] forKey:@"AudioTrackDRCSlider"];
             }
             if (![dict objectForKey: @"AudioTrackGainSlider"])
+
             {
                 [dict setObject:[NSNumber numberWithFloat:0.0] forKey:@"AudioTrackGainSlider"];
             }
-            
-			//	If our preset wants us to support a codec that the track does not support, instead
-			//	of changing the codec we remove the audio instead.
-			if (YES == [newAudio setCodecFromName: key]) {
-				[newAudio setMixdownFromName: [dict objectForKey: @"AudioMixdown"]];
-				[newAudio setSampleRateFromName: [dict objectForKey: @"AudioSamplerate"]];
-				if (NO == fallenBack) {
-					[newAudio setBitRateFromName: [dict objectForKey: @"AudioBitrate"]];
-					}
-				[newAudio setDrc: [dict objectForKey: @"AudioTrackDRCSlider"]];
+
+            // If our preset wants us to support a codec that the track does not support, instead
+            // of changing the codec we remove the audio instead.
+            if (YES == [newAudio setCodecFromName: key])
+            {
+                [newAudio setMixdownFromName: [dict objectForKey: @"AudioMixdown"]];
+                [newAudio setSampleRateFromName: [dict objectForKey: @"AudioSamplerate"]];
+                if (NO == fallenBack)
+                {
+                    [newAudio setBitRateFromName: [dict objectForKey: @"AudioBitrate"]];
+                }
+                [newAudio setDrc: [dict objectForKey: @"AudioTrackDRCSlider"]];
                 [newAudio setGain: [dict objectForKey: @"AudioTrackGainSlider"]];
-			}
-			else {
-				[self removeObjectFromAudioArrayAtIndex: [self countOfAudioArray] - 1];
-			}
-			[newAudio release];
-		}
-	}
-	return;
+            }
+            else
+            {
+                [self removeObjectFromAudioArrayAtIndex: [self countOfAudioArray] - 1];
+            }
+            [newAudio release];
+        }
+    }
+    return;
 }
 
-//	This matches the FIRST track with the specified prefix, otherwise it uses the defaultIfNotFound value
+// This matches the FIRST track with the specified prefix, otherwise it uses the defaultIfNotFound value
 - (unsigned int) _trackWithTitlePrefix: (NSString *) prefix defaultIfNotFound: (unsigned int) defaultIfNotFound
 
 {
-	unsigned int retval = defaultIfNotFound;
-	int count = [masterTrackArray count];
-	NSString *languageTitle;
-	BOOL found = NO;
-	
-	//	We search for the prefix noting that our titles have the format %d: %s where the %s is the prefix
-	for (unsigned int i = 1; i < count && NO == found; i++) {	//	Note that we skip the "None" track
-		languageTitle = [[masterTrackArray objectAtIndex: i] objectForKey: keyAudioTrackName];
-		if (YES == [[languageTitle substringFromIndex: [languageTitle rangeOfString: @" "].location + 1] hasPrefix: prefix]) {
-			retval = i;
-			found = YES;
-		}
-	}
-	return retval;
+    unsigned int retval = defaultIfNotFound;
+    int count = [masterTrackArray count];
+    NSString *languageTitle;
+    BOOL found = NO;
+
+    // We search for the prefix noting that our titles have the format %d: %s where the %s is the prefix
+    for (unsigned int i = 1; i < count && NO == found; i++) // Note that we skip the "None" track
+    {
+        languageTitle = [[masterTrackArray objectAtIndex: i] objectForKey: keyAudioTrackName];
+        if (YES == [[languageTitle substringFromIndex: [languageTitle rangeOfString: @" "].location + 1] hasPrefix: prefix])
+        {
+            retval = i;
+            found = YES;
+        }
+    }
+    return retval;
 }
 
-//	When we add a track and we do not have a preset to use for the track we use
-//	this bogus preset to do the dirty work.
+// When we add a track and we do not have a preset to use for the track we use
+// this bogus preset to do the dirty work.
 - (NSMutableDictionary *) _defaultPreset
 
 {
-	static NSMutableDictionary *retval = nil;
-	
-	if (nil == retval) {
-		retval = [[NSMutableDictionary dictionaryWithObjectsAndKeys:
-		[NSArray arrayWithObject:
-		[NSDictionary dictionaryWithObjectsAndKeys:
-		[NSNumber numberWithInt: 1],     @"AudioTrack",
-		@"AAC (faac)",                   @"AudioEncoder",
-		@"Dolby Pro Logic II",           @"AudioMixdown",
-		@"Auto",                         @"AudioSamplerate",
-		@"160",                          @"AudioBitrate",
-		[NSNumber numberWithFloat: 0.0], @"AudioTrackDRCSlider",
-        [NSNumber numberWithFloat: 0.0], @"AudioTrackGainSlider",
-		nil]], @"AudioList", nil] retain];
-	}
-	return retval;
+    static NSMutableDictionary *retval = nil;
+
+    if (nil == retval)
+    {
+        retval = [[NSMutableDictionary dictionaryWithObjectsAndKeys:
+                   [NSArray arrayWithObject:
+                    [NSDictionary dictionaryWithObjectsAndKeys:
+                     [NSNumber numberWithInt: 1],     @"AudioTrack",
+                     @"AAC (faac)",                   @"AudioEncoder",
+                     @"Dolby Pro Logic II",           @"AudioMixdown",
+                     @"Auto",                         @"AudioSamplerate",
+                     @"160",                          @"AudioBitrate",
+                     [NSNumber numberWithFloat: 0.0], @"AudioTrackDRCSlider",
+                     [NSNumber numberWithFloat: 0.0], @"AudioTrackGainSlider",
+                     nil]], @"AudioList", nil] retain];
+    }
+    return retval;
 }
 
 - (void) addTracksFromPreset: (NSMutableDictionary *) aPreset allTracks: (BOOL) allTracks
 
 {
-	id whatToUse = [self _presetAudioArrayFromPreset: aPreset];
-	NSString *preferredLanguageName = [[NSUserDefaults standardUserDefaults] stringForKey: @"DefaultLanguage"];
-	int preferredLanguage = [self _trackWithTitlePrefix: preferredLanguageName defaultIfNotFound: 1];
-
-	//	Reinitialize the configured list of audio tracks
-	[self _clearAudioArray];
-	
-	[self _processPresetAudioArray: whatToUse forTrack: preferredLanguage andType: [[aPreset objectForKey: @"Type"] intValue]];
-	if (YES == allTracks) {
-		unsigned int count = [masterTrackArray count];
-		for (unsigned int i = 1; i < count; i++) {
-			if (i != preferredLanguage) {
-				[self _processPresetAudioArray: whatToUse forTrack: i andType: [[aPreset objectForKey: @"Type"] intValue]];
-			}
-		}
-	}
-
-	return;
+    id whatToUse = [self _presetAudioArrayFromPreset: aPreset];
+    NSString *preferredLanguageName = [[NSUserDefaults standardUserDefaults] stringForKey: @"DefaultLanguage"];
+    int preferredLanguage = [self _trackWithTitlePrefix: preferredLanguageName defaultIfNotFound: 1];
+
+    // Reinitialize the configured list of audio tracks
+    [self _clearAudioArray];
+
+    [self _processPresetAudioArray: whatToUse forTrack: preferredLanguage andType: [[aPreset objectForKey: @"Type"] intValue]];
+    if (YES == allTracks)
+    {
+        unsigned int count = [masterTrackArray count];
+        for (unsigned int i = 1; i < count; i++)
+        {
+            if (i != preferredLanguage)
+            {
+                [self _processPresetAudioArray: whatToUse forTrack: i andType: [[aPreset objectForKey: @"Type"] intValue]];
+            }
+        }
+    }
+
+    return;
 }
 
 - (void) _ensureAtLeastOneNonEmptyTrackExists
 
 {
-	int count = [self countOfAudioArray];
-	if (0 == count || NO == [[self objectInAudioArrayAtIndex: 0] enabled]) {
-		[self addTracksFromPreset: [self _defaultPreset] allTracks: NO];
-		}
-	[self switchingTrackFromNone: nil];	//	this ensures there is a None track at the end of the list
-	return;
+    int count = [self countOfAudioArray];
+    if (0 == count || NO == [[self objectInAudioArrayAtIndex: 0] enabled])
+    {
+        [self addTracksFromPreset: [self _defaultPreset] allTracks: NO];
+    }
+    [self switchingTrackFromNone: nil]; // this ensures there is a None track at the end of the list
+    return;
 }
 
 - (void) addTracksFromPreset: (NSMutableDictionary *) aPreset
 
 {
-	[self addTracksFromPreset: aPreset allTracks: NO];
-	[self _ensureAtLeastOneNonEmptyTrackExists];
-	return;
+    [self addTracksFromPreset: aPreset allTracks: NO];
+    [self _ensureAtLeastOneNonEmptyTrackExists];
+    return;
 }
 
 - (void) addAllTracksFromPreset: (NSMutableDictionary *) aPreset
 
 {
-	[self addTracksFromPreset: aPreset allTracks: YES];
-	[self _ensureAtLeastOneNonEmptyTrackExists];
-	return;
+    [self addTracksFromPreset: aPreset allTracks: YES];
+    [self _ensureAtLeastOneNonEmptyTrackExists];
+    return;
 }
 
 - (BOOL) anyCodecMatches: (int) aCodecValue
 
 {
-	BOOL retval = NO;
-	unsigned int audioArrayCount = [self countOfAudioArray];
-	for (unsigned int i = 0; i < audioArrayCount && NO == retval; i++) {
-		HBAudio *anAudio = [self objectInAudioArrayAtIndex: i];
-        if (YES == [anAudio enabled] && aCodecValue == [[[anAudio codec] objectForKey: keyAudioCodec] intValue]) {
-			retval = YES;
-		}
-	}
-	return retval;
+    BOOL retval = NO;
+    unsigned int audioArrayCount = [self countOfAudioArray];
+    for (unsigned int i = 0; i < audioArrayCount && NO == retval; i++)
+    {
+        HBAudio *anAudio = [self objectInAudioArrayAtIndex: i];
+        if (YES == [anAudio enabled] && aCodecValue == [[[anAudio codec] objectForKey: keyAudioCodec] intValue])
+        {
+            retval = YES;
+        }
+    }
+    return retval;
 }
 
 - (void) addNewAudioTrack
 
 {
-	HBAudio *newAudio = [[HBAudio alloc] init];
-	[newAudio setController: self];
-	[self insertObject: newAudio inAudioArrayAtIndex: [self countOfAudioArray]];
-	[newAudio setVideoContainerTag: [self videoContainerTag]];
-	[newAudio setTrack: noneTrack];
-	[newAudio setDrc: [NSNumber numberWithFloat: 0.0]];
+    HBAudio *newAudio = [[HBAudio alloc] init];
+    [newAudio setController: self];
+    [self insertObject: newAudio inAudioArrayAtIndex: [self countOfAudioArray]];
+    [newAudio setVideoContainerTag: [self videoContainerTag]];
+    [newAudio setTrack: noneTrack];
+    [newAudio setDrc: [NSNumber numberWithFloat: 0.0]];
     [newAudio setGain: [NSNumber numberWithFloat: 0.0]];
-	[newAudio release];	
-	return;
+    [newAudio release];
+    return;
 }
 
 #pragma mark -
@@ -449,105 +483,115 @@ NSString *HBMixdownChangedNotification = @"HBMixdownChangedNotification";
 - (void) settingTrackToNone: (HBAudio *) newNoneTrack
 
 {
-	//	If this is not the last track in the array we need to remove it.  We then need to see if a new
-	//	one needs to be added (in the case when we were at maximum count and this switching makes it
-	//	so we are no longer at maximum.
-	NSUInteger index = [audioArray indexOfObject: newNoneTrack];
-
-	if (NSNotFound != index && index < [self countOfAudioArray] - 1) {
-		[self removeObjectFromAudioArrayAtIndex: index];
-	}
-	[self switchingTrackFromNone: nil];	// see if we need to add one to the list
-	return;
+    // If this is not the last track in the array we need to remove it.  We then need to see if a new
+    // one needs to be added (in the case when we were at maximum count and this switching makes it
+    // so we are no longer at maximum.
+    NSUInteger index = [audioArray indexOfObject: newNoneTrack];
+
+    if (NSNotFound != index && index < [self countOfAudioArray] - 1)
+    {
+        [self removeObjectFromAudioArrayAtIndex: index];
+    }
+    [self switchingTrackFromNone: nil]; // see if we need to add one to the list
+    return;
 }
 
 - (void) switchingTrackFromNone: (HBAudio *) noLongerNoneTrack
 
 {
-	int count = [self countOfAudioArray];
-	BOOL needToAdd = NO;
-	int maximumNumberOfAllowedAudioTracks = [HBController maximumNumberOfAllowedAudioTracks];
-
-	//	If there is no last track that is None and we are less than our maximum number of permitted tracks, we add one.
-	if (count < maximumNumberOfAllowedAudioTracks) {
-		if (0 < count) {
-			HBAudio *lastAudio = [self objectInAudioArrayAtIndex: count - 1];
-			if (YES == [lastAudio enabled]) {
-				needToAdd = YES;
-			}
-		}
-		else {
-			needToAdd = YES;
-		}
-	}
-
-	if (YES == needToAdd) {
-		[self addNewAudioTrack];
-	}
-	return;
+    int count = [self countOfAudioArray];
+    BOOL needToAdd = NO;
+    int maximumNumberOfAllowedAudioTracks = [HBController maximumNumberOfAllowedAudioTracks];
+
+    // If there is no last track that is None and we are less than our maximum number of permitted tracks, we add one.
+    if (count < maximumNumberOfAllowedAudioTracks)
+    {
+        if (0 < count)
+        {
+            HBAudio *lastAudio = [self objectInAudioArrayAtIndex: count - 1];
+            if (YES == [lastAudio enabled])
+            {
+                needToAdd = YES;
+            }
+        }
+        else
+        {
+            needToAdd = YES;
+        }
+    }
+
+    if (YES == needToAdd)
+    {
+        [self addNewAudioTrack];
+    }
+    return;
 }
 
-//	This gets called whenever the video container changes.
+// This gets called whenever the video container changes.
 - (void) containerChanged: (NSNotification *) aNotification
 
 {
-	NSDictionary *notDict = [aNotification userInfo];
+    NSDictionary *notDict = [aNotification userInfo];
 
-	[self setVideoContainerTag: [notDict objectForKey: keyContainerTag]];
+    [self setVideoContainerTag: [notDict objectForKey: keyContainerTag]];
 
-	//	Update each of the instances because this value influences possible settings.
-	NSEnumerator *enumerator = [audioArray objectEnumerator];
-	HBAudio *audioObject;
+    // Update each of the instances because this value influences possible settings.
+    NSEnumerator *enumerator = [audioArray objectEnumerator];
+    HBAudio *audioObject;
 
-	while (nil != (audioObject = [enumerator nextObject])) {
-		[audioObject setVideoContainerTag: [self videoContainerTag]];
-	}
-	return;
+    while (nil != (audioObject = [enumerator nextObject]))
+    {
+        [audioObject setVideoContainerTag: [self videoContainerTag]];
+    }
+    return;
 }
 
 - (void) titleChanged: (NSNotification *) aNotification
 
 {
-	NSDictionary *notDict = [aNotification userInfo];
-	NSData *theData = [notDict objectForKey: keyTitleTag];
-	hb_title_t *title = NULL;
-
-	[theData getBytes: &title length: sizeof(title)];
-	if (title) {
-		hb_audio_config_t *audio;
-		hb_list_t *list = title->list_audio;
-		int i, count = hb_list_count(list);
-
-		//	Reinitialize the master list of available audio tracks from this title
-		NSMutableArray *newTrackArray = [NSMutableArray array];
-		[noneTrack release];
-		noneTrack = [[NSDictionary dictionaryWithObjectsAndKeys:
-					 [NSNumber numberWithInt: 0], keyAudioTrackIndex,
-					 NSLocalizedString(@"None", @"None"), keyAudioTrackName,
-					 [NSNumber numberWithInt: 0], keyAudioInputCodec,
-							 nil] retain];
-		[newTrackArray addObject: noneTrack];
-		for (i = 0; i < count; i++) {
-			audio = (hb_audio_config_t *) hb_list_audio_config_item(list, i);
-			[newTrackArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
-									   [NSNumber numberWithInt: i + 1], keyAudioTrackIndex,
-									   [NSString stringWithFormat: @"%d: %s", i, audio->lang.description], keyAudioTrackName,
-									   [NSNumber numberWithInt: audio->in.bitrate / 1000], keyAudioInputBitrate,
-									   [NSNumber numberWithInt: audio->in.samplerate], keyAudioInputSampleRate,
-									   [NSNumber numberWithInt: audio->in.codec], keyAudioInputCodec,
-									   [NSNumber numberWithInt: audio->in.channel_layout], keyAudioInputChannelLayout,
-									   nil]];
-		}
-		self.masterTrackArray = newTrackArray;
-	}
-
-	//	Reinitialize the configured list of audio tracks
-	[self _clearAudioArray];
-
-	if (NO == [myController hasValidPresetSelected]) {
-		[self _ensureAtLeastOneNonEmptyTrackExists];
-	}
-	return;
+    NSDictionary *notDict = [aNotification userInfo];
+    NSData *theData = [notDict objectForKey: keyTitleTag];
+    hb_title_t *title = NULL;
+
+    [theData getBytes: &title length: sizeof(title)];
+    if (title)
+    {
+        hb_audio_config_t *audio;
+        hb_list_t *list = title->list_audio;
+        int i, count = hb_list_count(list);
+
+        // Reinitialize the master list of available audio tracks from this title
+        NSMutableArray *newTrackArray = [NSMutableArray array];
+        [noneTrack release];
+        noneTrack = [[NSDictionary dictionaryWithObjectsAndKeys:
+                      [NSNumber numberWithInt: 0], keyAudioTrackIndex,
+                      NSLocalizedString(@"None", @"None"), keyAudioTrackName,
+                      [NSNumber numberWithInt: 0], keyAudioInputCodec,
+                      nil] retain];
+        [newTrackArray addObject: noneTrack];
+        for (i = 0; i < count; i++)
+        {
+            audio = (hb_audio_config_t *) hb_list_audio_config_item(list, i);
+            [newTrackArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+                                       [NSNumber numberWithInt: i + 1], keyAudioTrackIndex,
+                                       [NSString stringWithFormat: @"%d: %s", i, audio->lang.description], keyAudioTrackName,
+                                       [NSNumber numberWithInt: audio->in.bitrate / 1000], keyAudioInputBitrate,
+                                       [NSNumber numberWithInt: audio->in.samplerate], keyAudioInputSampleRate,
+                                       [NSNumber numberWithInt: audio->in.codec], keyAudioInputCodec,
+                                       [NSNumber numberWithInt: audio->in.channel_layout], keyAudioInputChannelLayout,
+                                       nil]];
+        }
+        self.masterTrackArray = newTrackArray;
+    }
+
+    // Reinitialize the configured list of audio tracks
+    [self _clearAudioArray];
+
+    if (NO == [myController hasValidPresetSelected])
+    {
+        [self _ensureAtLeastOneNonEmptyTrackExists];
+    }
+    return;
 }
 
 #pragma mark -
@@ -556,27 +600,27 @@ NSString *HBMixdownChangedNotification = @"HBMixdownChangedNotification";
 - (unsigned int) countOfAudioArray
 
 {
-	return [audioArray count];
+    return [audioArray count];
 }
 
 - (HBAudio *) objectInAudioArrayAtIndex: (unsigned int) index
 
 {
-	return [audioArray objectAtIndex: index];
+    return [audioArray objectAtIndex: index];
 }
 
 - (void) insertObject: (HBAudio *) audioObject inAudioArrayAtIndex: (unsigned int) index;
 
 {
-	[audioArray insertObject: audioObject atIndex: index];
-	return;
+    [audioArray insertObject: audioObject atIndex: index];
+    return;
 }
 
 - (void) removeObjectFromAudioArrayAtIndex: (unsigned int) index
 
 {
-	[audioArray removeObjectAtIndex: index];
-	return;
+    [audioArray removeObjectAtIndex: index];
+    return;
 }
 
 @end