MacGui: Audio ... Allow more than 4 audio tracks.

- Patch courtesy of circleone ...  Thanks!
- Use a NSTableView to dynamically add/delete audio tracks ala the Subtitle tab.
- Sets a 24 track limit until someone tests more than 24 tracks (the libhb 8 track limit was removed as per http://trac.handbrake.fr/changeset/3531).
- Replaces the old static 4 tracks to a dynamic array.
- Moves macgui audio handling to a separate class.
Known caveats: 
- Borks queue editing which needs a revamp anyway.
- Queue window display needs to be adjusted to show more than 4 tracks appropriately. Again, its cosmetic and is not a show stopper.
- There may be other possible unknown side effects even though tested on all presets. That said, I feel it needs to get in so that we can get feedback from nightlies.

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

1 files changed, 640 insertions, 0 deletions

diff --git a/macosx/HBAudio.m b/macosx/HBAudio.m
new file mode 100644
index 000000000..8d226d33e
--- /dev/null
+++ b/macosx/HBAudio.m
@@ -0,0 +1,640 @@
+//
+//  HBAudio.m
+//  HandBrake
+//
+//  Created on 2010-08-30.
+//
+
+#import "HBAudio.h"
+#import "HBAudioController.h"
+#import "hb.h"
+
+NSString *keyAudioCodecName = @"keyAudioCodecName";
+NSString *keyAudioMP4 = @"keyAudioMP4";
+NSString *keyAudioMKV = @"keyAudioMKV";
+NSString *keyAudioSampleRateName = @"keyAudioSampleRateName";
+NSString *keyAudioBitrateName = @"keyAudioBitrateName";
+NSString *keyAudioMinimumBitrate = @"keyAudioMinimumBitrate";
+NSString *keyAudioMaximumBitrate = @"keyAudioMaximumBitrate";
+NSString *keyAudioMinimumBitrate6Channel = @"keyAudioMinimumBitrate6Channel";
+NSString *keyAudioMaximumBitrate6Channel = @"keyAudioMaximumBitrate6Channel";
+NSString *keyAudioMustMatchTrack = @"keyAudioMustMatchTrack";
+NSString *keyAudioMixdownName = @"keyAudioMixdownName";
+NSString *keyAudioMixdownLimitsToTrackBitRate = @"keyAudioMixdownLimitsToTrackBitRate";
+NSString *keyAudioMixdownCanBeDefault = @"keyAudioMixdownCanBeDefault";
+
+NSString *keyAudioCodec = @"codec";
+NSString *keyAudioMixdown = @"mixdown";
+NSString *keyAudioSamplerate = @"samplerate";
+NSString *keyAudioBitrate = @"bitrate";
+
+static NSMutableArray *masterCodecArray = nil;
+static NSMutableArray *masterSampleRateArray = nil;
+static NSMutableArray *masterBitRateArray = nil;
+static NSDictionary *defaultBitRate = nil;
+static NSDictionary *bitRate384 = nil;
+
+@interface NSArray (HBAudioSupport)
+- (NSDictionary *) dictionaryWithObject: (id) anObject matchingKey: (NSString *) aKey;
+- (NSDictionary *) lastDictionaryWithObject: (id) anObject matchingKey: (NSString *) aKey;
+@end
+@implementation NSArray (HBAudioSupport)
+- (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 *) dictionaryWithObject: (id) anObject matchingKey: (NSString *) aKey
+{	return [self dictionaryWithObject: anObject matchingKey: aKey reverse: NO];	}
+- (NSDictionary *) lastDictionaryWithObject: (id) anObject matchingKey: (NSString *) aKey
+{	return [self dictionaryWithObject: anObject matchingKey: aKey reverse: YES];	}
+
+@end
+
+@implementation HBAudio
+
+#pragma mark -
+#pragma mark Object Setup
+
++ (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,
+									  [NSNumber numberWithInt: 64], keyAudioMinimumBitrate,
+									  [NSNumber numberWithInt: 320], keyAudioMaximumBitrate,
+									  [NSNumber numberWithInt: 128], keyAudioMinimumBitrate6Channel,
+									  [NSNumber numberWithInt: 768], keyAudioMaximumBitrate6Channel,
+									  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,
+									  [NSNumber numberWithInt: 32], keyAudioMinimumBitrate,
+									  [NSNumber numberWithInt: 320], keyAudioMaximumBitrate,
+									  [NSNumber numberWithInt: 192], keyAudioMinimumBitrate6Channel,
+									  [NSNumber numberWithInt: 768], keyAudioMaximumBitrate6Channel,
+									  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,
+									  [NSNumber numberWithInt: 32], keyAudioMinimumBitrate,
+									  [NSNumber numberWithInt: 320], keyAudioMaximumBitrate,
+									  [NSNumber numberWithInt: 32], keyAudioMinimumBitrate6Channel,
+									  [NSNumber numberWithInt: 320], keyAudioMaximumBitrate6Channel,
+									  nil]];
+		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+									  NSLocalizedString(@"AC3 Passthru", @"AC3 Passthru"), keyAudioCodecName,
+									  [NSNumber numberWithInt: HB_ACODEC_AC3], keyAudioCodec,
+									  [NSNumber numberWithBool: YES], keyAudioMP4,
+									  [NSNumber numberWithBool: YES], keyAudioMKV,
+									  [NSNumber numberWithBool: YES], keyAudioMustMatchTrack,
+									  [NSNumber numberWithInt: 32], keyAudioMinimumBitrate,
+									  [NSNumber numberWithInt: 384], keyAudioMaximumBitrate,
+									  [NSNumber numberWithInt: 32], keyAudioMinimumBitrate6Channel,
+									  [NSNumber numberWithInt: 384], keyAudioMaximumBitrate6Channel,
+									  nil]];
+		[masterCodecArray addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+									  NSLocalizedString(@"DTS Passthru", @"DTS Passthru"), keyAudioCodecName,
+									  [NSNumber numberWithInt: HB_ACODEC_DCA], keyAudioCodec,
+									  [NSNumber numberWithBool: NO], keyAudioMP4,
+									  [NSNumber numberWithBool: YES], keyAudioMKV,
+									  [NSNumber numberWithBool: YES], keyAudioMustMatchTrack,
+									  [NSNumber numberWithInt: 32], keyAudioMinimumBitrate,
+									  [NSNumber numberWithInt: 384], keyAudioMaximumBitrate,
+									  [NSNumber numberWithInt: 32], keyAudioMinimumBitrate6Channel,
+									  [NSNumber numberWithInt: 384], keyAudioMaximumBitrate6Channel,
+									  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,
+									  [NSNumber numberWithInt: 48], keyAudioMinimumBitrate,
+									  [NSNumber numberWithInt: 384], keyAudioMaximumBitrate,
+									  [NSNumber numberWithInt: 192], keyAudioMinimumBitrate6Channel,
+									  [NSNumber numberWithInt: 384], keyAudioMaximumBitrate6Channel,
+									  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
+		int defaultRate = hb_audio_bitrates[hb_audio_bitrates_default].rate;
+		for (i = 0; i < hb_audio_bitrates_count; i++) {
+			int rate = hb_audio_bitrates[i].rate;
+			dict = [NSDictionary dictionaryWithObjectsAndKeys:
+					[NSString stringWithUTF8String: hb_audio_bitrates[i].string], keyAudioBitrateName,
+					[NSNumber numberWithInt: rate], keyAudioBitrate,
+					nil];
+			if (rate == defaultRate) {
+				defaultBitRate = [dict retain];	// knowingly leaked
+			}
+			if (384 == rate) {
+				bitRate384 = [dict retain];	// knowingly leaked
+			}
+			[masterBitRateArray addObject: dict];
+		}
+		
+		[pool release];
+	}
+	return;
+}
+
+//	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: keyAudioCodec] 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;
+}
+
+//	The rules here are provided as-is from the original -[Controller audioTrackPopUpChanged:mixdownToUse:] routine
+//	with the comments taken from there as well.
+- (void) updateMixdowns
+
+{
+	NSMutableArray *retval = [NSMutableArray array];
+	int trackCodec = [[track objectForKey: keyAudioInputCodec] intValue];
+	int codecCodec = [[codec objectForKey: keyAudioCodec] intValue];
+
+	if (HB_ACODEC_AC3 == trackCodec && HB_ACODEC_AC3 == codecCodec) {
+		[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+							NSLocalizedString(@"AC3 Passthru", @"AC3 Passthru"), keyAudioMixdownName,
+							[NSNumber numberWithInt: HB_ACODEC_AC3], keyAudioMixdown,
+							[NSNumber numberWithBool: YES], keyAudioMixdownLimitsToTrackBitRate,
+							[NSNumber numberWithBool: YES], keyAudioMixdownCanBeDefault,
+							nil]];
+	}
+	else if (HB_ACODEC_DCA == trackCodec && HB_ACODEC_DCA == codecCodec) {
+		[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+							NSLocalizedString(@"DTS Passthru", @"DTS Passthru"), keyAudioMixdownName,
+							[NSNumber numberWithInt: HB_ACODEC_DCA], keyAudioMixdown,
+							[NSNumber numberWithBool: YES], keyAudioMixdownLimitsToTrackBitRate,
+							[NSNumber numberWithBool: YES], keyAudioMixdownCanBeDefault,
+							nil]];
+	}
+	else {
+		int audioCodecsSupport6Ch = (trackCodec && HB_ACODEC_LAME != codecCodec);
+		int channelLayout = [[track objectForKey: keyAudioInputChannelLayout] intValue];
+		int layout = channelLayout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK;
+		
+		/* add a mono option? */
+		[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+							[NSString stringWithUTF8String: hb_audio_mixdowns[0].human_readable_name], keyAudioMixdownName,
+							[NSNumber numberWithInt: hb_audio_mixdowns[0].amixdown], keyAudioMixdown,
+							[NSNumber numberWithBool: NO], keyAudioMixdownLimitsToTrackBitRate,
+							[NSNumber numberWithBool: YES], keyAudioMixdownCanBeDefault,
+							nil]];
+		
+		/* offer stereo if we have a stereo-or-better source */
+		if (layout >= HB_INPUT_CH_LAYOUT_STEREO) {
+			[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+								[NSString stringWithUTF8String: hb_audio_mixdowns[1].human_readable_name], keyAudioMixdownName,
+								[NSNumber numberWithInt: hb_audio_mixdowns[1].amixdown], keyAudioMixdown,
+								[NSNumber numberWithBool: NO], keyAudioMixdownLimitsToTrackBitRate,
+								[NSNumber numberWithBool: YES], keyAudioMixdownCanBeDefault,
+								nil]];
+		}
+	
+		/* do we want to add a dolby surround (DPL1) option? */
+		if (HB_INPUT_CH_LAYOUT_3F1R == layout || HB_INPUT_CH_LAYOUT_3F2R == layout || HB_INPUT_CH_LAYOUT_DOLBY == layout) {
+			[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+								[NSString stringWithUTF8String: hb_audio_mixdowns[2].human_readable_name], keyAudioMixdownName,
+								[NSNumber numberWithInt: hb_audio_mixdowns[2].amixdown], keyAudioMixdown,
+								[NSNumber numberWithBool: NO], keyAudioMixdownLimitsToTrackBitRate,
+								[NSNumber numberWithBool: YES], keyAudioMixdownCanBeDefault,
+								nil]];
+		}
+		
+		/* do we want to add a dolby pro logic 2 (DPL2) option? */
+		if (HB_INPUT_CH_LAYOUT_3F2R == layout) {
+			[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+								[NSString stringWithUTF8String: hb_audio_mixdowns[3].human_readable_name], keyAudioMixdownName,
+								[NSNumber numberWithInt: hb_audio_mixdowns[3].amixdown], keyAudioMixdown,
+								[NSNumber numberWithBool: NO], keyAudioMixdownLimitsToTrackBitRate,
+								[NSNumber numberWithBool: YES], keyAudioMixdownCanBeDefault,
+								nil]];
+		}
+		
+		/* do we want to add a 6-channel discrete option? */
+		if (1 == audioCodecsSupport6Ch && HB_INPUT_CH_LAYOUT_3F2R == layout && (channelLayout & HB_INPUT_CH_LAYOUT_HAS_LFE)) {
+			[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+								[NSString stringWithUTF8String: hb_audio_mixdowns[4].human_readable_name], keyAudioMixdownName,
+								[NSNumber numberWithInt: hb_audio_mixdowns[4].amixdown], keyAudioMixdown,
+								[NSNumber numberWithBool: NO], keyAudioMixdownLimitsToTrackBitRate,
+								[NSNumber numberWithBool: NO], keyAudioMixdownCanBeDefault,
+								nil]];
+		}
+		
+		//	based on the fact that we are in an else section where the ifs before hand would have detected the following two
+		//	situations, the following code will never add anything to the returned array.  I am leaving this in place for
+		//	historical reasons.
+		/* do we want to add an AC-3 passthrough option? */
+		if (HB_ACODEC_AC3 == trackCodec && HB_ACODEC_AC3 == codecCodec) {
+			[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+								[NSString stringWithUTF8String: hb_audio_mixdowns[5].human_readable_name], keyAudioMixdownName,
+								[NSNumber numberWithInt: HB_ACODEC_AC3], keyAudioMixdown,
+								[NSNumber numberWithBool: YES], keyAudioMixdownLimitsToTrackBitRate,
+								[NSNumber numberWithBool: YES], keyAudioMixdownCanBeDefault,
+								nil]];
+		}
+			
+		/* do we want to add a DTS Passthru option ? HB_ACODEC_DCA*/
+		if (HB_ACODEC_DCA == trackCodec && HB_ACODEC_DCA == codecCodec) {
+			[retval addObject: [NSDictionary dictionaryWithObjectsAndKeys:
+								[NSString stringWithUTF8String: hb_audio_mixdowns[5].human_readable_name], keyAudioMixdownName,
+								[NSNumber numberWithInt: HB_ACODEC_DCA], keyAudioMixdown,
+								[NSNumber numberWithBool: YES], keyAudioMixdownLimitsToTrackBitRate,
+								[NSNumber numberWithBool: YES], keyAudioMixdownCanBeDefault,
+								nil]];
+		}
+	}
+	
+	//	Now make sure the permitted list and the actual ones matches
+	[self setMixdowns: retval];
+	
+	//	Ensure our mixdown is on the list of permitted ones
+	if (nil == [self mixdown] || NO == [retval containsObject: [self mixdown]]) {
+		[self setMixdown: [retval lastDictionaryWithObject: [NSNumber numberWithBool: YES] matchingKey: keyAudioMixdownCanBeDefault]];
+	}
+	
+	return;
+}
+
+- (void) updateBitRates
+
+{
+	NSMutableArray *permittedBitRates = [NSMutableArray array];
+	int count;
+	NSDictionary *dict;
+	BOOL has6chMixdown = (HB_AMIXDOWN_6CH == [[[self mixdown] objectForKey: keyAudioMixdown] intValue]);
+	
+	count = [masterBitRateArray count];
+	NSString *minKey = (has6chMixdown) ? keyAudioMinimumBitrate6Channel : keyAudioMinimumBitrate;
+	NSString *maxKey = (has6chMixdown) ? keyAudioMaximumBitrate6Channel : keyAudioMaximumBitrate;
+	int minBitRate = [[codec objectForKey: minKey] intValue];
+	int maxBitRate = [[codec objectForKey: maxKey] intValue];
+	int currentBitRate;
+	int trackInputBitRate = [[[self track] objectForKey: keyAudioInputBitrate] intValue];
+	BOOL limitsToTrackInputBitRate = [[[self mixdown] objectForKey: keyAudioMixdownLimitsToTrackBitRate] boolValue];
+	BOOL shouldAdd;
+	
+	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];
+	}
+	
+	//	Make sure we are updated with the permitted list
+	[self setBitRates: permittedBitRates];
+
+	//	Select the proper one
+	if (YES == has6chMixdown) {
+		[self setBitRate: bitRate384];
+	}
+	else {
+		[self setBitRate: defaultBitRate];
+	}
+	if (nil == [self bitRate] || NO == [permittedBitRates containsObject: [self bitRate]]) {
+		[self setBitRate: [permittedBitRates lastObject]];
+	}
+	
+	return;
+}
+
+#pragma mark -
+#pragma mark Accessors
+
+@synthesize track;
+@synthesize codec;
+@synthesize mixdown;
+@synthesize sampleRate;
+@synthesize bitRate;
+@synthesize drc;
+@synthesize videoContainerTag;
+@synthesize controller;
+
+@synthesize codecs;
+@synthesize mixdowns;
+@synthesize bitRates;
+
+- (void) setVideoContainerTag: (NSNumber *) aValue
+
+{
+	if ((nil != aValue || nil != videoContainerTag) && NO == [aValue isEqual: videoContainerTag]) {
+		[aValue retain];
+		[videoContainerTag release];
+		videoContainerTag = aValue;
+		[self updateCodecs];
+	}
+	return;
+}
+
+//	We do some detection of the None track to do special things.
+- (void) setTrack: (NSDictionary *) aValue
+
+{
+	if ((nil != aValue || nil != track) && NO == [aValue isEqual: track]) {
+		BOOL switchingFromNone = [track isEqual: [controller noneTrack]];
+		BOOL switchingToNone = [aValue isEqual: [controller noneTrack]];
+
+		[aValue retain];
+		[track release];
+		track = aValue;
+
+		if (nil != aValue) {
+			[self updateCodecs];
+			if (YES == [self enabled]) {
+				[self setSampleRate: [[self sampleRates] objectAtIndex: 0]];	//	default to Auto
+			}
+			if (YES == switchingFromNone) {
+				[controller switchingTrackFromNone: self];
+			}
+			if (YES == switchingToNone) {
+				[controller settingTrackToNone: self];
+			}
+		}
+	}
+	return;
+}
+
+- (void) setCodec: (NSDictionary *) aValue
+
+{
+	if ((nil != aValue || nil != codec) && NO == [aValue isEqual: codec]) {
+		[aValue retain];
+		[codec release];
+		codec = aValue;
+		[self updateMixdowns];
+		[self updateBitRates];
+	}
+	return;
+}
+
+- (void) setMixdown: (NSDictionary *) aValue
+
+{
+	if ((nil != aValue || nil != mixdown) && NO == [aValue isEqual: mixdown]) {
+		[aValue retain];
+		[mixdown release];
+		mixdown = aValue;
+		[self updateBitRates];
+		[[NSNotificationCenter defaultCenter] postNotificationName: HBMixdownChangedNotification object: self];
+	}
+	return;
+}
+
+- (NSArray *) tracks	{	return [controller masterTrackArray];	}
+
+- (NSArray *) sampleRates	{	return masterSampleRateArray;	}
+
+- (void) dealloc
+
+{
+	[self setTrack: nil];
+	[self setCodec: nil];
+	[self setMixdown: nil];
+	[self setSampleRate: nil];
+	[self setBitRate: nil];
+	[self setDrc: nil];
+	[self setVideoContainerTag: nil];
+	[self setCodecs: nil];
+	[self setMixdowns: nil];
+	[self setBitRates: nil];
+	[super dealloc];
+	return;
+}
+
+#pragma mark -
+#pragma mark Special Setters
+
+- (void) setTrackFromIndex: (int) aValue
+
+{
+	[self setTrack: [[self tracks] dictionaryWithObject: [NSNumber numberWithInt: aValue] matchingKey: keyAudioTrackIndex]];
+	return;
+}
+
+//	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);
+}
+
+- (void) setMixdownFromName: (NSString *) aValue
+
+{
+	NSDictionary *dict = [[self mixdowns] dictionaryWithObject: aValue matchingKey: keyAudioMixdownName];
+
+	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;
+}
+
+- (void) setBitRateFromName: (NSString *) aValue
+
+{
+	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.
+- (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;
+}
+
+#pragma mark -
+#pragma mark Bindings Support
+
+- (BOOL) enabled
+
+{
+	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 == myMixdown || HB_ACODEC_DCA == myMixdown) {
+			retval = NO;
+		}
+	}
+	return retval;
+}
+
++ (NSSet *) keyPathsForValuesAffectingEnabled
+
+{
+	return [NSSet setWithObjects: @"track", nil];
+}
+
++ (NSSet *) keyPathsForValuesAffectingMixdownEnabled
+
+{
+	return [NSSet setWithObjects: @"track", @"mixdown", nil];
+}
+
+@end