/* HBAudioTrack.m $ This file is part of the HandBrake source code. Homepage: . It may be used under the terms of the GNU General Public License. */ #import "HBAudioTrack.h" #import "HBAudioController.h" #import "HBJob.h" #import "HBCodingUtilities.h" #import "hb.h" NSString *keyAudioTrackIndex = @"keyAudioTrackIndex"; NSString *keyAudioTrackName = @"keyAudioTrackName"; NSString *keyAudioInputBitrate = @"keyAudioInputBitrate"; NSString *keyAudioInputSampleRate = @"keyAudioInputSampleRate"; NSString *keyAudioInputCodec = @"keyAudioInputCodec"; NSString *keyAudioInputCodecParam = @"keyAudioInputCodecParam"; NSString *keyAudioInputChannelLayout = @"keyAudioInputChannelLayout"; NSString *keyAudioTrackLanguageIsoCode = @"keyAudioTrackLanguageIsoCode"; #define DEFAULT_SAMPLERATE 48000 @interface HBAudioTrack () @property (nonatomic, readwrite) BOOL validating; @end @implementation HBAudioTrack - (instancetype)init { self = [super init]; if (self) { // Defaults settings _encoder = HB_ACODEC_CA_AAC; _container = HB_MUX_MKV; _sampleRate = 0; _bitRate = 160; _mixdown = HB_AMIXDOWN_DOLBYPLII; } return self; } - (instancetype)initWithTrackIdx:(NSUInteger)index container:(int)container dataSource:(id)dataSource delegate:(id)delegate; { self = [super init]; if (self) { _dataSource = dataSource; _sourceTrackIdx = index; _container = container; [self validateSettings]; _delegate = delegate; } return self; } - (void)validateSettings { if (_sourceTrackIdx) { if (self.encoder == 0) { self.encoder = HB_ACODEC_CA_AAC; self.bitRate = 160; } else { self.encoder = [self sanatizeEncoderValue:self.encoder]; } } else { self.encoder = 0; self.mixdown = 0; self.sampleRate = 0; self.bitRate = -1; } } #pragma mark - Track properties - (void)setSourceTrackIdx:(NSUInteger)sourceTrackIdx { if (sourceTrackIdx != _sourceTrackIdx) { [[self.undo prepareWithInvocationTarget:self] setSourceTrackIdx:_sourceTrackIdx]; } NSUInteger oldIdx = _sourceTrackIdx; _sourceTrackIdx = sourceTrackIdx; if (!(self.undo.isUndoing || self.undo.isRedoing)) { [self validateSettings]; if (oldIdx != sourceTrackIdx) { [self.delegate track:self didChangeSourceFrom:oldIdx]; } } } - (void)setContainer:(int)container { if (container != _container) { [[self.undo prepareWithInvocationTarget:self] setContainer:_container]; } _container = container; if (!(self.undo.isUndoing || self.undo.isRedoing)) { if (self.encoder) { self.encoder = [self sanatizeEncoderValue:self.encoder]; } } } - (void)setEncoder:(int)encoder { if (encoder != _encoder) { [[self.undo prepareWithInvocationTarget:self] setEncoder:_encoder]; } _encoder = encoder; if (!(self.undo.isUndoing || self.undo.isRedoing) && !self.validating) { self.validating = YES; [self.delegate encoderChanged]; self.mixdown = [self sanatizeMixdownValue:self.mixdown]; self.sampleRate = [self sanatizeSamplerateValue:self.sampleRate]; self.bitRate = [self sanatizeBitrateValue:self.bitRate]; self.validating = NO; } } - (void)setMixdown:(int)mixdown { if (mixdown != _mixdown) { [[self.undo prepareWithInvocationTarget:self] setMixdown:_mixdown]; } _mixdown = mixdown; if (!(self.undo.isUndoing || self.undo.isRedoing) && !self.validating) { self.validating = YES; self.bitRate = [self sanatizeBitrateValue:self.bitRate]; self.validating = NO; } } - (void)setSampleRate:(int)sampleRate { if (sampleRate != _sampleRate) { [[self.undo prepareWithInvocationTarget:self] setSampleRate:_sampleRate]; } _sampleRate = sampleRate; if (!(self.undo.isUndoing || self.undo.isRedoing) && !self.validating) { self.validating = YES; self.bitRate = [self sanatizeBitrateValue:self.bitRate]; self.validating = NO; } } - (void)setBitRate:(int)bitRate { if (bitRate != _bitRate) { [[self.undo prepareWithInvocationTarget:self] setBitRate:_bitRate]; } _bitRate = bitRate; } - (void)setGain:(double)gain { if (gain != _gain) { [[self.undo prepareWithInvocationTarget:self] setGain:_gain]; } _gain = gain; } // 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 * __autoreleasing *)outError { BOOL retval = YES; if (nil != *ioValue) { if ([*ioValue intValue] < -20) { *ioValue = @(-20); } else if ([*ioValue intValue] > 20) { *ioValue = @20; } } return retval; } - (void)setDrc:(double)drc { if (drc != _drc) { [[self.undo prepareWithInvocationTarget:self] setDrc:_drc]; } _drc = drc; } #pragma mark - Validation - (int)sanatizeEncoderValue:(int)proposedEncoder { if (proposedEncoder) { NSDictionary *sourceTrack = [_dataSource sourceTrackAtIndex:_sourceTrackIdx]; int inputCodec = [sourceTrack[keyAudioInputCodec] intValue]; hb_encoder_t *proposedEncoderInfo = hb_audio_encoder_get_from_codec(proposedEncoder); if (proposedEncoderInfo && proposedEncoderInfo->muxers & self.container) { // If the codec is passthru, see if the new source supports it. if (proposedEncoderInfo->codec & HB_ACODEC_PASS_FLAG) { if ((proposedEncoderInfo->codec & inputCodec & HB_ACODEC_PASS_MASK)) { return proposedEncoder; } } else { return proposedEncoder; } } return HB_ACODEC_CA_AAC; } else { return proposedEncoder; } } - (int)sanatizeMixdownValue:(int)proposedMixdown { NSDictionary *sourceTrack = [_dataSource sourceTrackAtIndex:_sourceTrackIdx]; unsigned long long channelLayout = [sourceTrack[keyAudioInputChannelLayout] unsignedLongLongValue]; if (!hb_mixdown_is_supported(proposedMixdown, self.encoder, channelLayout)) { return hb_mixdown_get_default(self.encoder, channelLayout); } return proposedMixdown; } - (int)sanatizeSamplerateValue:(int)proposedSamplerate { if (self.encoder & HB_ACODEC_PASS_FLAG) { return 0; // Auto (same as source) } else if (proposedSamplerate) { return hb_audio_samplerate_find_closest(proposedSamplerate, self.encoder); } return proposedSamplerate; } - (int)sanatizeBitrateValue:(int)proposedBitrate { if (self.encoder & HB_ACODEC_PASS_FLAG) { return -1; } else if (proposedBitrate == -1) // switching from passthru { return hb_audio_bitrate_get_default(self.encoder, self.sampleRate ? self.sampleRate : DEFAULT_SAMPLERATE, self.mixdown); } else { return hb_audio_bitrate_get_best(self.encoder, proposedBitrate, self.sampleRate, self.mixdown); } } #pragma mark - Options - (NSArray *)encoders { NSMutableArray *encoders = [[NSMutableArray alloc] init]; NSDictionary *sourceTrack = [_dataSource sourceTrackAtIndex:_sourceTrackIdx]; int inputCodec = [sourceTrack[keyAudioInputCodec] intValue]; for (const hb_encoder_t *audio_encoder = hb_audio_encoder_get_next(NULL); audio_encoder != NULL; audio_encoder = hb_audio_encoder_get_next(audio_encoder)) { if (audio_encoder->muxers & self.container && audio_encoder->codec != HB_ACODEC_AUTO_PASS) { if (audio_encoder->codec & HB_ACODEC_PASS_FLAG) { // If the codec is passthru, show only the supported ones. if ((audio_encoder->codec & inputCodec & HB_ACODEC_PASS_MASK)) { [encoders addObject:@(audio_encoder->name)]; } } else { [encoders addObject:@(audio_encoder->name)]; } } } return encoders; } - (NSArray *)mixdowns { NSMutableArray *mixdowns = [[NSMutableArray alloc] init]; NSDictionary *sourceTrack = [_dataSource sourceTrackAtIndex:_sourceTrackIdx]; unsigned long long channelLayout = [sourceTrack[keyAudioInputChannelLayout] unsignedLongLongValue]; for (const hb_mixdown_t *mixdown = hb_mixdown_get_next(NULL); mixdown != NULL; mixdown = hb_mixdown_get_next(mixdown)) { if (hb_mixdown_is_supported(mixdown->amixdown, self.encoder, channelLayout)) { [mixdowns addObject:@(mixdown->name)]; } } return mixdowns; } - (NSArray *)sampleRates { NSMutableArray *sampleRates = [[NSMutableArray alloc] init]; [sampleRates addObject:@"Auto"]; for (const hb_rate_t *audio_samplerate = hb_audio_samplerate_get_next(NULL); audio_samplerate != NULL; audio_samplerate = hb_audio_samplerate_get_next(audio_samplerate)) { int rate = audio_samplerate->rate; if (rate == hb_audio_samplerate_find_closest(rate, self.encoder)) { [sampleRates addObject:@(audio_samplerate->name)]; } } return sampleRates; } - (NSArray *)bitRates { int minBitRate = 0; int maxBitRate = 0; hb_audio_bitrate_get_limits(self.encoder, self.sampleRate, self.mixdown, &minBitRate, &maxBitRate); NSMutableArray *bitRates = [[NSMutableArray alloc] init]; for (const hb_rate_t *audio_bitrate = hb_audio_bitrate_get_next(NULL); audio_bitrate != NULL; audio_bitrate = hb_audio_bitrate_get_next(audio_bitrate)) { if (audio_bitrate->rate >= minBitRate && audio_bitrate->rate <= maxBitRate) { [bitRates addObject:@(audio_bitrate->name)]; } } return bitRates; } #pragma mark - KVO UI Additions - (NSArray *)sourceTracksArray { return [self.dataSource sourceTracksArray]; } - (BOOL)isEnabled { return self.sourceTrackIdx != 0; } - (BOOL)mixdownEnabled { BOOL retval = self.isEnabled; if (retval && self.mixdown == HB_AMIXDOWN_NONE) { // "None" mixdown (passthru) retval = NO; } return retval; } - (BOOL)bitrateEnabled { BOOL retval = self.isEnabled; if (retval) { int myCodecDefaultBitrate = hb_audio_bitrate_get_default(self.encoder, 0, 0); if (myCodecDefaultBitrate < 0) { retval = NO; } } return retval; } - (BOOL)drcEnabled { BOOL retval = self.isEnabled; if (retval) { NSDictionary *sourceTrack = [_dataSource sourceTrackAtIndex:_sourceTrackIdx]; int inputCodec = [sourceTrack[keyAudioInputCodec] intValue]; int inputCodecParam = [sourceTrack[keyAudioInputCodecParam] intValue]; if (!hb_audio_can_apply_drc(inputCodec, inputCodecParam, self.encoder)) { retval = NO; } } return retval; } - (BOOL)passThruDisabled { BOOL retval = YES; if (self.encoder & HB_ACODEC_PASS_FLAG) { retval = NO; } return retval; } #pragma mark - KVO + (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key { NSSet *retval = nil; if ([key isEqualToString:@"bitrateEnabled"] || [key isEqualToString:@"passThruDisabled"] || [key isEqualToString:@"mixdownEnabled"]) { retval = [NSSet setWithObjects:@"encoder", nil]; } else if ([key isEqualToString:@"mixdowns"] || [key isEqualToString:@"drcEnabled"]) { retval = [NSSet setWithObjects:@"sourceTrackIdx", @"encoder", nil]; } else if ([key isEqualToString:@"sampleRates"]) { retval = [NSSet setWithObjects:@"encoder", @"mixdown", nil]; } else if ([key isEqualToString:@"bitRates"]) { retval = [NSSet setWithObjects:@"encoder", @"mixdown", @"sampleRate", nil]; } else if ([key isEqualToString:@"encoders"]) { retval = [NSSet setWithObjects:@"container", @"sourceTrackIdx", nil]; } else { retval = [NSSet set]; } return retval; } - (void)setNilValueForKey:(NSString *)key { if ([key isEqualToString:@"drc"] || [key isEqualToString:@"gain"]) { [self setValue:@0 forKey:key]; } } #pragma mark - NSCopying - (instancetype)copyWithZone:(NSZone *)zone { HBAudioTrack *copy = [[[self class] alloc] init]; if (copy) { copy->_sourceTrackIdx = _sourceTrackIdx; copy->_container = _container; copy->_encoder = _encoder; copy->_mixdown = _mixdown; copy->_sampleRate = _sampleRate; copy->_bitRate = _bitRate; copy->_gain = _gain; copy->_drc = _drc; } return copy; } #pragma mark - NSCoding + (BOOL)supportsSecureCoding { return YES; } - (void)encodeWithCoder:(NSCoder *)coder { [coder encodeInt:3 forKey:@"HBAudioTrackVersion"]; encodeInteger(_sourceTrackIdx); encodeInt(_container); encodeInt(_encoder); encodeInt(_mixdown); encodeInt(_sampleRate); encodeInt(_bitRate); encodeDouble(_gain); encodeDouble(_drc); } - (instancetype)initWithCoder:(NSCoder *)decoder { self = [super init]; decodeInteger(_sourceTrackIdx); decodeInt(_container); decodeInt(_encoder); decodeInt(_mixdown); decodeInt(_sampleRate); decodeInt(_bitRate); decodeDouble(_gain); decodeDouble(_drc); return self; } @end