path: root/macosx/HBAudioController.m

//
//  HBAudioController.m
//  HandBrake
//
//  Created on 2010-08-24.
//

#import "HBAudioController.h"
#import "Controller.h"
#import "HBAudio.h"
#import "hb.h"

NSString *keyAudioTrackIndex = @"keyAudioTrackIndex";
NSString *keyAudioTrackName = @"keyAudioTrackName";
NSString *keyAudioInputBitrate = @"keyAudioInputBitrate";
NSString *keyAudioInputSampleRate = @"keyAudioInputSampleRate";
NSString *keyAudioInputCodec = @"keyAudioInputCodec";
NSString *keyAudioInputChannelLayout = @"keyAudioInputChannelLayout";
NSString *HBMixdownChangedNotification = @"HBMixdownChangedNotification";

@implementation HBAudioController

#pragma mark -
#pragma mark Accessors

@synthesize masterTrackArray;
@synthesize noneTrack;
@synthesize videoContainerTag;

- (id) init

{
	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;
}

- (void) setHBController: (id) 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;
}

- (void) _clearAudioArray

{
	while (0 < [self countOfAudioArray]) {
		[self removeObjectFromAudioArrayAtIndex: 0];
	}
	return;
}

#pragma mark -
#pragma mark HBController Support

- (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"]];
			[aDict setObject: [anAudio drc] 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
    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];
        
			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"];
			[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"]]];
			[newAudio release];
		}
	}

	[self switchingTrackFromNone: nil];	// see if we need to add one to the list
	
	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.
- (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",
									   nil]];
			}
		}
		retval = whatToUse;
	}
	return retval;
}

//	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];
	NSDictionary *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 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"]];
			}
			else {
				[self removeObjectFromAudioArrayAtIndex: [self countOfAudioArray] - 1];
			}
			[newAudio release];
		}
	}
	return;
}

//	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;
}

//	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",
		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;
}

- (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;
}

- (void) addTracksFromPreset: (NSMutableDictionary *) aPreset

{
	[self addTracksFromPreset: aPreset allTracks: NO];
	[self _ensureAtLeastOneNonEmptyTrackExists];
	return;
}

- (void) addAllTracksFromPreset: (NSMutableDictionary *) aPreset

{
	[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;
}

- (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]];
	[newAudio release];	
	return;
}

#pragma mark -
#pragma mark Notification Handling

- (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.
	unsigned int 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;
}

//	This gets called whenever the video container changes.
- (void) containerChanged: (NSNotification *) aNotification

{
	NSDictionary *notDict = [aNotification userInfo];

	[self setVideoContainerTag: [notDict objectForKey: keyContainerTag]];

	//	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;
}

- (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
		[masterTrackArray release];
		masterTrackArray = [[NSMutableArray alloc] init];
		[noneTrack release];
		noneTrack = [[NSDictionary dictionaryWithObjectsAndKeys:
					 [NSNumber numberWithInt: 0], keyAudioTrackIndex,
					 NSLocalizedString(@"None", @"None"), keyAudioTrackName,
					 [NSNumber numberWithInt: 0], keyAudioInputCodec,
							 nil] retain];
		[masterTrackArray addObject: noneTrack];
		for (i = 0; i < count; i++) {
			audio = (hb_audio_config_t *) hb_list_audio_config_item(list, i);
			[masterTrackArray 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]];
		}
	}

	//	Reinitialize the configured list of audio tracks
	[self _clearAudioArray];

	if (NO == [myController hasValidPresetSelected]) {
		[self _ensureAtLeastOneNonEmptyTrackExists];
	}
	return;
}

#pragma mark -
#pragma mark KVC

- (unsigned int) countOfAudioArray

{
	return [audioArray count];
}

- (HBAudio *) objectInAudioArrayAtIndex: (unsigned int) index

{
	return [audioArray objectAtIndex: index];
}

- (void) insertObject: (HBAudio *) audioObject inAudioArrayAtIndex: (unsigned int) index;

{
	[audioArray insertObject: audioObject atIndex: index];
	return;
}

- (void) removeObjectFromAudioArrayAtIndex: (unsigned int) index

{
	[audioArray removeObjectAtIndex: index];
	return;
}

@end