diff options
Diffstat (limited to 'macosx/HBVideoController.m')
| -rw-r--r-- | macosx/HBVideoController.m | 1339 |
1 files changed, 1339 insertions, 0 deletions
diff --git a/macosx/HBVideoController.m b/macosx/HBVideoController.m new file mode 100644 index 000000000..e602e3f8d --- /dev/null +++ b/macosx/HBVideoController.m @@ -0,0 +1,1339 @@ +/* HBVideoController.m $ + + This file is part of the HandBrake source code. + Homepage: <http://handbrake.fr/>. + It may be used under the terms of the GNU General Public License. */ + +#import "HBVideoController.h" + +#include "hb.h" + +#import "Controller.h" +#import "HBAdvancedController.h" + +NSString *HBVideoEncoderChangedNotification = @"HBVideoEncoderChangedNotification"; + +@interface HBVideoController () { + /* Framerate */ + /* Radio Button Framerate Controls */ + IBOutlet NSMatrix * fFramerateMatrix; + IBOutlet NSButtonCell * fFramerateVfrPfrCell; + IBOutlet NSButtonCell * fFramerateCfrCell; + + /* Video Encoder */ + IBOutlet NSTextField * fVidRateField; + IBOutlet NSPopUpButton * fVidRatePopUp; + IBOutlet NSTextField * fVidEncoderField; + IBOutlet NSPopUpButton * fVidEncoderPopUp; + IBOutlet NSTextField * fVidQualityField; + IBOutlet NSTextField * fVidQualityRFLabel; + IBOutlet NSTextField * fVidQualityRFField; + IBOutlet NSMatrix * fVidQualityMatrix; + IBOutlet NSButtonCell * fVidBitrateCell; + IBOutlet NSTextField * fVidBitrateField; + IBOutlet NSButtonCell * fVidConstantCell; + IBOutlet NSSlider * fVidQualitySlider; + IBOutlet NSButton * fVidTwoPassCheck; + IBOutlet NSButton * fVidTurboPassCheck; + + /* Status read out fields for picture settings and video filters */ + IBOutlet NSTextField * fPictureSettingsField; + IBOutlet NSTextField * fPictureFiltersField; + + /* x264 Presets Box */ + NSArray * fX264PresetNames; + NSUInteger fX264MediumPresetIndex; + IBOutlet NSButton * fX264UseAdvancedOptionsCheck; + IBOutlet NSBox * fX264PresetsBox; + IBOutlet NSSlider * fX264PresetsSlider; + IBOutlet NSTextField * fX264PresetSliderLabel; + IBOutlet NSTextField * fX264PresetSelectedTextField; + IBOutlet NSPopUpButton * fX264TunePopUp; + IBOutlet NSTextField * fX264TunePopUpLabel; + IBOutlet NSPopUpButton * fX264ProfilePopUp; + IBOutlet NSTextField * fX264ProfilePopUpLabel; + IBOutlet NSPopUpButton * fX264LevelPopUp; + IBOutlet NSTextField * fX264LevelPopUpLabel; + IBOutlet NSButton * fX264FastDecodeCheck; + IBOutlet NSTextField * fDisplayX264PresetsAdditonalOptionsTextField; + IBOutlet NSTextField * fDisplayX264PresetsAdditonalOptionsLabel; + // Text Field to show the expanded opts from unparse() + IBOutlet NSTextField * fDisplayX264PresetsUnparseTextField; + char * fX264PresetsUnparsedUTF8String; + NSUInteger _fX264PresetsHeightForUnparse; + NSUInteger _fX264PresetsWidthForUnparse; +} + +@end + +@implementation HBVideoController + +@synthesize fX264PresetsHeightForUnparse = _fX264PresetsHeightForUnparse; +@synthesize fX264PresetsWidthForUnparse = _fX264PresetsWidthForUnparse; + +- (void)setPictureSettingsField:(NSString *)string +{ + if (string) + { + [_pictureSettingsField autorelease]; + _pictureSettingsField = [[NSString stringWithFormat:@"Picture Settings: %@", string] retain]; + } +} + +- (void)setPictureFiltersField:(NSString *)string +{ + if (string) + { + [_pictureFiltersField autorelease]; + _pictureFiltersField = [[NSString stringWithFormat:@"Picture Filters: %@", string] retain]; + } +} + +- (int)selectedCodec +{ + return (int)[[fVidEncoderPopUp selectedItem] tag]; +} + +- (int)selectedQualityType +{ + return (int)[[fVidQualityMatrix selectedCell] tag]; +} + +- (NSString *)selectedBitrate +{ + return [fVidBitrateField stringValue]; +} + +- (NSString *)selectedQuality +{ + return [fVidQualityRFField stringValue]; +} + + +- (instancetype)init +{ + self = [super initWithNibName:@"Video" bundle:nil]; + if (self) + { + /* + * initialize fX264PresetsUnparsedUTF8String as early as possible + * avoids an invalid free + */ + fX264PresetsUnparsedUTF8String = NULL; + _pictureFiltersField = @"Pictures Filters:"; + _pictureSettingsField = @"Pictures Settings:"; + + NSNotificationCenter *center = [NSNotificationCenter defaultCenter]; + + /* register that we are interested in changes made to the video container */ + [center addObserver:self selector: @selector(containerChanged:) name:HBContainerChangedNotification object:nil]; + [center addObserver:self selector: @selector(titleChanged:) name:HBTitleChangedNotification object:nil]; + } + + return self; +} + +- (void)loadView { + [super loadView]; + + /* Video encoder */ + [fVidEncoderPopUp removeAllItems]; + [fVidEncoderPopUp addItemWithTitle: @"FFmpeg"]; + + /* setup our x264 presets widgets - this only needs to be done once */ + [self setupX264PresetsWidgets]; + + /* Video quality */ + [fVidBitrateField setIntValue: 1000]; + [fVidQualityMatrix selectCell: fVidBitrateCell]; + [self videoMatrixChanged:nil]; + + /* Video framerate */ + [fVidRatePopUp removeAllItems]; + NSMenuItem *menuItem = [[fVidRatePopUp menu] addItemWithTitle:@"Same as source" + action:nil + keyEquivalent:@""]; + [menuItem setTag:hb_video_framerate_get_from_name("Same as source")]; + for (const hb_rate_t *video_framerate = hb_video_framerate_get_next(NULL); + video_framerate != NULL; + video_framerate = hb_video_framerate_get_next(video_framerate)) + { + NSString *itemTitle; + if (!strcmp(video_framerate->name, "23.976")) + { + itemTitle = @"23.976 (NTSC Film)"; + } + else if (!strcmp(video_framerate->name, "25")) + { + itemTitle = @"25 (PAL Film/Video)"; + } + else if (!strcmp(video_framerate->name, "29.97")) + { + itemTitle = @"29.97 (NTSC Video)"; + } + else + { + itemTitle = [NSString stringWithUTF8String:video_framerate->name]; + } + menuItem = [[fVidRatePopUp menu] addItemWithTitle:itemTitle + action:nil + keyEquivalent:@""]; + [menuItem setTag:video_framerate->rate]; + } + [fVidRatePopUp selectItemAtIndex:0]; + + /* We disable the Turbo 1st pass checkbox since we are not x264 */ + [fVidTurboPassCheck setEnabled: NO]; + [fVidTurboPassCheck setState: NSOffState]; +} + +- (void)enableUI:(BOOL)b { + NSControl *controls[] = + { + fFramerateMatrix, + fVidRateField, + fVidRatePopUp, + fVidEncoderField, + fVidEncoderPopUp, + fVidQualityField, + fVidQualityRFLabel, + fVidQualityRFField, + fVidQualityMatrix, + fVidBitrateField, + fVidQualitySlider, + fVidTwoPassCheck, + fVidTurboPassCheck, + fPictureSettingsField, + fPictureFiltersField + }; + + for (unsigned i = 0; i < (sizeof(controls) / sizeof(NSControl *)); i++) + { + if ([[controls[i] className] isEqualToString: @"NSTextField"]) + { + NSTextField *tf = (NSTextField *)controls[i]; + if (![tf isBezeled]) + { + [tf setTextColor: (b ? + [NSColor controlTextColor] : + [NSColor disabledControlTextColor])]; + continue; + } + } + [controls[i] setEnabled: b]; + } + + [self videoMatrixChanged:nil]; + [self enableX264Widgets:b]; +} + +- (void)containerChanged:(NSNotification *)aNotification +{ + NSDictionary *notDict = [aNotification userInfo]; + + int videoContainer = [[notDict objectForKey: keyContainerTag] intValue]; + + /* lets get the tag of the currently selected item first so we might reset it later */ + int selectedVidEncoderTag = (int)[[fVidEncoderPopUp selectedItem] tag]; + + /* Note: we now store the video encoder int values from common.c in the tags of each popup for easy retrieval later */ + [fVidEncoderPopUp removeAllItems]; + for (const hb_encoder_t *video_encoder = hb_video_encoder_get_next(NULL); + video_encoder != NULL; + video_encoder = hb_video_encoder_get_next(video_encoder)) + { + if (video_encoder->muxers & videoContainer) + { + NSMenuItem *menuItem = [[fVidEncoderPopUp menu] addItemWithTitle:[NSString stringWithUTF8String:video_encoder->name] + action:nil + keyEquivalent:@""]; + [menuItem setTag:video_encoder->codec]; + } + } + + /* + * item 0 will be selected by default + * deselect it so that we can detect whether the video encoder has changed + */ + [fVidEncoderPopUp selectItem:nil]; + if (selectedVidEncoderTag) + { + // if we have a tag for previously selected encoder, try to select it + // if this fails, [fVidEncoderPopUp selectedItem] will be nil + // we'll handle that scenario further down + [fVidEncoderPopUp selectItemWithTag:selectedVidEncoderTag]; + } + + if ([fVidEncoderPopUp selectedItem] == nil) + { + /* this means the above call to selectItemWithTag failed */ + [fVidEncoderPopUp selectItemAtIndex:0]; + [self videoEncoderPopUpChanged:nil]; + } +} + +- (void)titleChanged:(NSNotification *)aNotification +{ + [fVidRatePopUp selectItemAtIndex: 0]; +} + +#pragma mark - apply settings + +- (void)applyVideoSettingsFromQueue:(NSDictionary *)queueToApply +{ + /* video encoder */ + [fVidEncoderPopUp selectItemWithTitle:[queueToApply objectForKey:@"VideoEncoder"]]; + [self.fAdvancedOptions setLavcOptions: [queueToApply objectForKey:@"lavcOption"]]; + /* advanced x264 options */ + if ([[queueToApply objectForKey:@"x264UseAdvancedOptions"] intValue]) + { + // we are using the advanced panel + [self.fAdvancedOptions setOptions:[queueToApply objectForKey:@"x264Option"]]; + // preset does not use the x264 preset system, reset the widgets + [self setX264Preset: nil]; + [self setX264Tune: nil]; + [self setX264OptionExtra:[queueToApply objectForKey:@"x264Option"]]; + [self setH264Profile: nil]; + [self setH264Level: nil]; + // enable the advanced panel and update the widgets + [fX264UseAdvancedOptionsCheck setState:NSOnState]; + [self updateX264Widgets:nil]; + } + else + { + // we are using the x264 preset system + [self setX264Preset: [queueToApply objectForKey:@"x264Preset"]]; + [self setX264Tune: [queueToApply objectForKey:@"x264Tune"]]; + [self setX264OptionExtra:[queueToApply objectForKey:@"x264OptionExtra"]]; + [self setH264Profile: [queueToApply objectForKey:@"h264Profile"]]; + [self setH264Level: [queueToApply objectForKey:@"h264Level"]]; + // preset does not use the advanced panel, reset it + [self.fAdvancedOptions setOptions:@""]; + // disable the advanced panel and update the widgets + [fX264UseAdvancedOptionsCheck setState:NSOffState]; + [self updateX264Widgets:nil]; + } + + /* Lets run through the following functions to get variables set there */ + [self videoEncoderPopUpChanged:nil]; + + /* Video quality */ + [fVidQualityMatrix selectCellAtRow:[[queueToApply objectForKey:@"VideoQualityType"] intValue] column:0]; + + [fVidBitrateField setStringValue:[queueToApply objectForKey:@"VideoAvgBitrate"]]; + + int direction; + float minValue, maxValue, granularity; + hb_video_quality_get_limits((int)[[fVidEncoderPopUp selectedItem] tag], + &minValue, &maxValue, &granularity, &direction); + if (!direction) + { + [fVidQualitySlider setFloatValue:[[queueToApply objectForKey:@"VideoQualitySlider"] floatValue]]; + } + else + { + /* + * Since ffmpeg and x264 use an "inverted" slider (lower values + * indicate a higher quality) we invert the value on the slider + */ + [fVidQualitySlider setFloatValue:([fVidQualitySlider minValue] + + [fVidQualitySlider maxValue] - + [[queueToApply objectForKey:@"VideoQualitySlider"] floatValue])]; + } + + [self videoMatrixChanged:nil]; + + /* Video framerate */ + if ([[queueToApply objectForKey:@"VideoFramerate"] isEqualToString:@"Same as source"]) + { + /* Now set the Video Frame Rate Mode to either vfr or cfr according to the preset */ + if ([[queueToApply objectForKey:@"VideoFramerateMode"] isEqualToString:@"vfr"]) + { + [fFramerateMatrix selectCellAtRow:0 column:0]; // we want vfr + } + else + { + [fFramerateMatrix selectCellAtRow:1 column:0]; // we want cfr + } + } + else + { + /* Now set the Video Frame Rate Mode to either pfr or cfr according to the preset */ + if ([[queueToApply objectForKey:@"VideoFramerateMode"] isEqualToString:@"pfr"]) + { + [fFramerateMatrix selectCellAtRow:0 column:0]; // we want pfr + } + else + { + [fFramerateMatrix selectCellAtRow:1 column:0]; // we want cfr + } + } + [fVidRatePopUp selectItemWithTitle:[queueToApply objectForKey:@"VideoFramerate"]]; + [self videoFrameRateChanged:nil]; + + /* 2 Pass Encoding */ + [fVidTwoPassCheck setState:[[queueToApply objectForKey:@"VideoTwoPass"] intValue]]; + [self twoPassCheckboxChanged:nil]; + /* Turbo 1st pass for 2 Pass Encoding */ + [fVidTurboPassCheck setState:[[queueToApply objectForKey:@"VideoTurboTwoPass"] intValue]]; +} + +- (void)applySettingsFromPreset:(NSDictionary *)preset +{ + /* map legacy encoder names via libhb */ + const char *strValue = hb_video_encoder_sanitize_name([[preset objectForKey:@"VideoEncoder"] UTF8String]); + [fVidEncoderPopUp selectItemWithTitle:[NSString stringWithFormat:@"%s", strValue]]; + [self videoEncoderPopUpChanged:nil]; + + if ([[fVidEncoderPopUp selectedItem] tag] == HB_VCODEC_X264) + { + if (![preset objectForKey:@"x264UseAdvancedOptions"] || + [[preset objectForKey:@"x264UseAdvancedOptions"] intValue]) + { + /* + * x264UseAdvancedOptions is not set (legacy preset) + * or set to 1 (enabled), so we use the old advanced panel + */ + if ([preset objectForKey:@"x264Option"]) + { + /* we set the advanced options string here if applicable */ + [self.fAdvancedOptions setOptions:[preset objectForKey:@"x264Option"]]; + [self setX264OptionExtra:[preset objectForKey:@"x264Option"]]; + } + else + { + [self.fAdvancedOptions setOptions: @""]; + [self setX264OptionExtra:nil]; + } + /* preset does not use the x264 preset system, reset the widgets */ + [self setX264Preset: nil]; + [self setX264Tune: nil]; + [self setH264Profile:nil]; + [self setH264Level: nil]; + /* we enable the advanced panel and update the widgets */ + [fX264UseAdvancedOptionsCheck setState:NSOnState]; + [self updateX264Widgets:nil]; + } + else + { + /* + * x264UseAdvancedOptions is set to 0 (disabled), + * so we use the x264 preset system + */ + [self setX264Preset: [preset objectForKey:@"x264Preset"]]; + [self setX264Tune: [preset objectForKey:@"x264Tune"]]; + [self setX264OptionExtra:[preset objectForKey:@"x264OptionExtra"]]; + [self setH264Profile: [preset objectForKey:@"h264Profile"]]; + [self setH264Level: [preset objectForKey:@"h264Level"]]; + /* preset does not use the advanced panel, reset it */ + [self.fAdvancedOptions setOptions:@""]; + /* we disable the advanced panel and update the widgets */ + [fX264UseAdvancedOptionsCheck setState:NSOffState]; + [self updateX264Widgets:nil]; + } + } + + int qualityType = [[preset objectForKey:@"VideoQualityType"] intValue] - 1; + /* Note since the removal of Target Size encoding, the possible values for VideoQuality type are 0 - 1. + * Therefore any preset that uses the old 2 for Constant Quality would now use 1 since there is one less index + * for the fVidQualityMatrix. It should also be noted that any preset that used the deprecated Target Size + * setting of 0 would set us to 0 or ABR since ABR is now tagged 0. Fortunately this does not affect any built-in + * presets since they all use Constant Quality or Average Bitrate.*/ + if (qualityType == -1) + { + qualityType = 0; + } + [fVidQualityMatrix selectCellWithTag:qualityType]; + + [fVidBitrateField setStringValue:[preset objectForKey:@"VideoAvgBitrate"]]; + + int direction; + float minValue, maxValue, granularity; + hb_video_quality_get_limits((int)[[fVidEncoderPopUp selectedItem] tag], + &minValue, &maxValue, &granularity, &direction); + if (!direction) + { + [fVidQualitySlider setFloatValue:[[preset objectForKey:@"VideoQualitySlider"] floatValue]]; + } + else + { + /* + * Since ffmpeg and x264 use an "inverted" slider (lower values + * indicate a higher quality) we invert the value on the slider + */ + [fVidQualitySlider setFloatValue:([fVidQualitySlider minValue] + + [fVidQualitySlider maxValue] - + [[preset objectForKey:@"VideoQualitySlider"] floatValue])]; + } + + [self videoMatrixChanged:nil]; + + /* Video framerate */ + if ([[preset objectForKey:@"VideoFramerate"] isEqualToString:@"Same as source"]) + { + /* Now set the Video Frame Rate Mode to either vfr or cfr according to the preset */ + if (![preset objectForKey:@"VideoFramerateMode"] || + [[preset objectForKey:@"VideoFramerateMode"] isEqualToString:@"vfr"]) + { + [fFramerateMatrix selectCellAtRow:0 column:0]; // we want vfr + } + else + { + [fFramerateMatrix selectCellAtRow:1 column:0]; // we want cfr + } + } + else + { + /* Now set the Video Frame Rate Mode to either pfr or cfr according to the preset */ + if ([[preset objectForKey:@"VideoFramerateMode"] isEqualToString:@"pfr"] || + [[preset objectForKey:@"VideoFrameratePFR"] intValue] == 1) + { + [fFramerateMatrix selectCellAtRow:0 column:0]; // we want pfr + } + else + { + [fFramerateMatrix selectCellAtRow:1 column:0]; // we want cfr + } + } + /* map legacy names via libhb */ + int intValue = hb_video_framerate_get_from_name([[preset objectForKey:@"VideoFramerate"] UTF8String]); + [fVidRatePopUp selectItemWithTag:intValue]; + [self videoFrameRateChanged:nil]; + + /* 2 Pass Encoding */ + [fVidTwoPassCheck setState:[[preset objectForKey:@"VideoTwoPass"] intValue]]; + [self twoPassCheckboxChanged:nil]; + + /* Turbo 1st pass for 2 Pass Encoding */ + [fVidTurboPassCheck setState:[[preset objectForKey:@"VideoTurboTwoPass"] intValue]]; +} + +- (void)prepareVideoForQueueFileJob:(NSMutableDictionary *)queueFileJob +{ + [queueFileJob setObject:[fVidEncoderPopUp titleOfSelectedItem] forKey:@"VideoEncoder"]; + + /* x264 advanced options */ + if ([fX264UseAdvancedOptionsCheck state]) + { + // we are using the advanced panel + [queueFileJob setObject:[NSNumber numberWithInt:1] forKey: @"x264UseAdvancedOptions"]; + [queueFileJob setObject:[self.fAdvancedOptions optionsString] forKey:@"x264Option"]; + } + else + { + // we are using the x264 preset system + [queueFileJob setObject:[NSNumber numberWithInt:0] forKey: @"x264UseAdvancedOptions"]; + [queueFileJob setObject:[self x264Preset] forKey: @"x264Preset"]; + [queueFileJob setObject:[self x264Tune] forKey: @"x264Tune"]; + [queueFileJob setObject:[self x264OptionExtra] forKey: @"x264OptionExtra"]; + [queueFileJob setObject:[self h264Profile] forKey: @"h264Profile"]; + [queueFileJob setObject:[self h264Level] forKey: @"h264Level"]; + } + + /* FFmpeg (lavc) Option String */ + [queueFileJob setObject:[self.fAdvancedOptions optionsStringLavc] forKey:@"lavcOption"]; + + [queueFileJob setObject:[NSNumber numberWithInteger:[[fVidQualityMatrix selectedCell] tag] + 1] forKey:@"VideoQualityType"]; + [queueFileJob setObject:[fVidBitrateField stringValue] forKey:@"VideoAvgBitrate"]; + [queueFileJob setObject:[NSNumber numberWithFloat:[fVidQualityRFField floatValue]] forKey:@"VideoQualitySlider"]; + /* Framerate */ + [queueFileJob setObject:[fVidRatePopUp titleOfSelectedItem] forKey:@"VideoFramerate"]; + /* Frame Rate Mode */ + if ([fFramerateMatrix selectedRow] == 1) // if selected we are cfr regardless of the frame rate popup + { + [queueFileJob setObject:@"cfr" forKey:@"VideoFramerateMode"]; + } + else + { + if ([fVidRatePopUp indexOfSelectedItem] == 0) // Same as source frame rate + { + [queueFileJob setObject:@"vfr" forKey:@"VideoFramerateMode"]; + } + else + { + [queueFileJob setObject:@"pfr" forKey:@"VideoFramerateMode"]; + } + + } + + /* 2 Pass Encoding */ + [queueFileJob setObject:[NSNumber numberWithInteger:[fVidTwoPassCheck state]] forKey:@"VideoTwoPass"]; + /* Turbo 2 pass Encoding fVidTurboPassCheck*/ + [queueFileJob setObject:[NSNumber numberWithInteger:[fVidTurboPassCheck state]] forKey:@"VideoTurboTwoPass"]; + + /* Video encoder */ + [queueFileJob setObject:[NSNumber numberWithInteger:[[fVidEncoderPopUp selectedItem] tag]] forKey:@"JobVideoEncoderVcodec"]; + + /* Framerate */ + [queueFileJob setObject:[NSNumber numberWithInteger:[[fVidRatePopUp selectedItem] tag]] forKey:@"JobIndexVideoFramerate"]; +} + +- (void)prepareVideoForJobPreview:(hb_job_t *)job andTitle:(hb_title_t *)title +{ + job->vcodec = (int)[[fVidEncoderPopUp selectedItem] tag]; + job->fastfirstpass = 0; + + job->chapter_markers = 0; + + if (job->vcodec == HB_VCODEC_X264) + { + /* advanced x264 options */ + NSString *tmpString; + // translate zero-length strings to NULL for libhb + const char *encoder_preset = NULL; + const char *encoder_tune = NULL; + const char *encoder_options = NULL; + const char *encoder_profile = NULL; + const char *encoder_level = NULL; + if ([fX264UseAdvancedOptionsCheck state]) + { + // we are using the advanced panel + if ([(tmpString = [self.fAdvancedOptions optionsString]) length]) + { + encoder_options = [tmpString UTF8String]; + } + } + else + { + // we are using the x264 preset system + if ([(tmpString = [self x264Tune]) length]) + { + encoder_tune = [tmpString UTF8String]; + } + if ([(tmpString = [self x264OptionExtra]) length]) + { + encoder_options = [tmpString UTF8String]; + } + if ([(tmpString = [self h264Profile]) length]) + { + encoder_profile = [tmpString UTF8String]; + } + if ([(tmpString = [self h264Level]) length]) + { + encoder_level = [tmpString UTF8String]; + } + encoder_preset = [[self x264Preset] UTF8String]; + } + hb_job_set_encoder_preset (job, encoder_preset); + hb_job_set_encoder_tune (job, encoder_tune); + hb_job_set_encoder_options(job, encoder_options); + hb_job_set_encoder_profile(job, encoder_profile); + hb_job_set_encoder_level (job, encoder_level); + } + else if (job->vcodec & HB_VCODEC_FFMPEG_MASK) + { + hb_job_set_encoder_options(job, + [[self.fAdvancedOptions optionsStringLavc] + UTF8String]); + } + + /* Video settings */ + int fps_mode, fps_num, fps_den; + if( [fVidRatePopUp indexOfSelectedItem] > 0 ) + { + /* a specific framerate has been chosen */ + fps_num = 27000000; + fps_den = (int)[[fVidRatePopUp selectedItem] tag]; + if ([fFramerateMatrix selectedRow] == 1) + { + // CFR + fps_mode = 1; + } + else + { + // PFR + fps_mode = 2; + } + } + else + { + /* same as source */ + fps_num = title->rate; + fps_den = title->rate_base; + if ([fFramerateMatrix selectedRow] == 1) + { + // CFR + fps_mode = 1; + } + else + { + // VFR + fps_mode = 0; + } + } + + switch( [[fVidQualityMatrix selectedCell] tag] ) + { + case 0: + /* ABR */ + job->vquality = -1.0; + job->vbitrate = [fVidBitrateField intValue]; + break; + case 1: + /* Constant Quality */ + job->vquality = [fVidQualityRFField floatValue]; + job->vbitrate = 0; + break; + } + + /* Add framerate shaping filter */ + hb_filter_object_t *filter = hb_filter_init(HB_FILTER_VFR); + hb_add_filter(job, filter, [[NSString stringWithFormat:@"%d:%d:%d", + fps_mode, fps_num, fps_den] UTF8String]); +} + +- (void)prepareVideoForPreset:(NSMutableDictionary *)preset +{ + [preset setObject:[fVidEncoderPopUp titleOfSelectedItem] forKey:@"VideoEncoder"]; + /* x264 Options, this will either be advanced panel or the video tabs x264 presets panel with modded option string */ + + if ([fX264UseAdvancedOptionsCheck state] == NSOnState) + { + /* use the old advanced panel */ + [preset setObject:[NSNumber numberWithInt:1] forKey:@"x264UseAdvancedOptions"]; + [preset setObject:[self.fAdvancedOptions optionsString] forKey:@"x264Option"]; + } + else + { + /* use the x264 preset system */ + [preset setObject:[NSNumber numberWithInt:0] forKey:@"x264UseAdvancedOptions"]; + [preset setObject:[self x264Preset] forKey:@"x264Preset"]; + [preset setObject:[self x264Tune] forKey:@"x264Tune"]; + [preset setObject:[self x264OptionExtra] forKey:@"x264OptionExtra"]; + [preset setObject:[self h264Profile] forKey:@"h264Profile"]; + [preset setObject:[self h264Level] forKey:@"h264Level"]; + /* + * bonus: set the unparsed options to make the preset compatible + * with old HB versions + */ + if (fX264PresetsUnparsedUTF8String != NULL) + { + [preset setObject:[NSString stringWithUTF8String:fX264PresetsUnparsedUTF8String] + forKey:@"x264Option"]; + } + else + { + [preset setObject:@"" forKey:@"x264Option"]; + } + } + + /* FFmpeg (lavc) Option String */ + [preset setObject:[self.fAdvancedOptions optionsStringLavc] forKey:@"lavcOption"]; + + /* though there are actually only 0 - 1 types available in the ui we need to map to the old 0 - 2 + * set of indexes from when we had 0 == Target , 1 == Abr and 2 == Constant Quality for presets + * to take care of any legacy presets. */ + [preset setObject:[NSNumber numberWithInteger:[[fVidQualityMatrix selectedCell] tag] +1 ] forKey:@"VideoQualityType"]; + [preset setObject:[fVidBitrateField stringValue] forKey:@"VideoAvgBitrate"]; + [preset setObject:[NSNumber numberWithFloat:[fVidQualityRFField floatValue]] forKey:@"VideoQualitySlider"]; + + /* Video framerate and framerate mode */ + if ([fFramerateMatrix selectedRow] == 1) + { + [preset setObject:@"cfr" forKey:@"VideoFramerateMode"]; + } + if ([fVidRatePopUp indexOfSelectedItem] == 0) // Same as source is selected + { + [preset setObject:@"Same as source" forKey:@"VideoFramerate"]; + + if ([fFramerateMatrix selectedRow] == 0) + { + [preset setObject:@"vfr" forKey:@"VideoFramerateMode"]; + } + } + else // translate the rate (selected item's tag) to the official libhb name + { + [preset setObject:[NSString stringWithFormat:@"%s", + hb_video_framerate_get_name((int)[[fVidRatePopUp selectedItem] tag])] + forKey:@"VideoFramerate"]; + + if ([fFramerateMatrix selectedRow] == 0) + { + [preset setObject:@"pfr" forKey:@"VideoFramerateMode"]; + } + } + + + + /* 2 Pass Encoding */ + [preset setObject:[NSNumber numberWithInteger:[fVidTwoPassCheck state]] forKey:@"VideoTwoPass"]; + /* Turbo 2 pass Encoding fVidTurboPassCheck*/ + [preset setObject:[NSNumber numberWithInteger:[fVidTurboPassCheck state]] forKey:@"VideoTurboTwoPass"]; +} + +#pragma mark - Video + +- (IBAction) videoEncoderPopUpChanged: (id) sender +{ + /* if no valid encoder is selected, use the first one */ + if ([fVidEncoderPopUp selectedItem] == nil) + { + [fVidEncoderPopUp selectItemAtIndex:0]; + } + + int videoEncoder = (int)[[fVidEncoderPopUp selectedItem] tag]; + + [self.fAdvancedOptions setHidden:YES]; + /* If we are using x264 then show the x264 advanced panel and the x264 presets box */ + if (videoEncoder == HB_VCODEC_X264) + { + [self.fAdvancedOptions setHidden:NO]; + + // show the x264 presets box + [fX264PresetsBox setHidden:NO]; + } + else // we are FFmpeg (lavc) or Theora + { + [self.fAdvancedOptions setHidden:YES]; + [fX264PresetsBox setHidden:YES]; + + // We Are Lavc + if ([[fVidEncoderPopUp selectedItem] tag] & HB_VCODEC_FFMPEG_MASK) + { + [self.fAdvancedOptions setLavcOptsEnabled:YES]; + } + else /// We are Theora + { + [self.fAdvancedOptions setLavcOptsEnabled:NO]; + } + } + + [[NSNotificationCenter defaultCenter] postNotificationName:HBVideoEncoderChangedNotification object:self]; + + [self setupQualitySlider]; + [self twoPassCheckboxChanged: sender]; +} + + +- (IBAction) twoPassCheckboxChanged: (id) sender +{ + /* check to see if x264 is chosen */ + if([[fVidEncoderPopUp selectedItem] tag] == HB_VCODEC_X264) + { + if( [fVidTwoPassCheck state] == NSOnState) + { + [fVidTurboPassCheck setHidden: NO]; + } + else + { + [fVidTurboPassCheck setHidden: YES]; + [fVidTurboPassCheck setState: NSOffState]; + } + /* Make sure Two Pass is checked if Turbo is checked */ + if( [fVidTurboPassCheck state] == NSOnState) + { + [fVidTwoPassCheck setState: NSOnState]; + } + } + else + { + [fVidTurboPassCheck setHidden: YES]; + [fVidTurboPassCheck setState: NSOffState]; + } + + /* We call method method to change UI to reflect whether a preset is used or not*/ + [self.fHBController customSettingUsed: sender]; +} + +- (IBAction ) videoFrameRateChanged: (id) sender +{ + /* if no valid framerate is selected, use "Same as source" */ + if ([fVidRatePopUp selectedItem] == nil) + { + [fVidRatePopUp selectItemAtIndex:0]; + } + + /* Hide and set the PFR Checkbox to OFF if we are set to Same as Source */ + /* Depending on whether or not Same as source is selected modify the title for + * fFramerateVfrPfrCell*/ + if ([fVidRatePopUp indexOfSelectedItem] == 0) // We are Same as Source + { + [fFramerateVfrPfrCell setTitle:@"Variable Framerate"]; + } + else + { + [fFramerateVfrPfrCell setTitle:@"Peak Framerate (VFR)"]; + + + } + + /* We call method method to change UI to reflect whether a preset is used or not*/ + [self.fHBController customSettingUsed: sender]; +} + +- (IBAction) videoMatrixChanged: (id) sender; +{ + /* We use the selectedCell: tag of the fVidQualityMatrix instead of selectedRow + * so that the order of the video controls can be switched around. + * Constant quality is 1 and Average bitrate is 0 for reference. */ + bool bitrate, quality; + bitrate = quality = false; + if( [fVidQualityMatrix isEnabled] ) + { + switch( [[fVidQualityMatrix selectedCell] tag] ) + { + case 0: + bitrate = true; + break; + case 1: + quality = true; + break; + } + } + + [fVidBitrateField setEnabled: bitrate]; + [fVidQualitySlider setEnabled: quality]; + [fVidQualityRFField setEnabled: quality]; + [fVidQualityRFLabel setEnabled: quality]; + [fVidTwoPassCheck setEnabled: !quality && + [fVidQualityMatrix isEnabled]]; + if( quality ) + { + [fVidTwoPassCheck setState: NSOffState]; + [fVidTurboPassCheck setHidden: YES]; + [fVidTurboPassCheck setState: NSOffState]; + } + + [self qualitySliderChanged: sender]; + [self.fHBController customSettingUsed: sender]; +} + +/* Use this method to setup the quality slider for cq/rf values depending on + * the video encoder selected. + */ +- (void) setupQualitySlider +{ + /* + * Get the current slider maxValue to check for a change in slider scale + * later so that we can choose a new similar value on the new slider scale + */ + float previousMaxValue = [fVidQualitySlider maxValue]; + float previousPercentOfSliderScale = ([fVidQualitySlider floatValue] / + ([fVidQualitySlider maxValue] - + [fVidQualitySlider minValue] + 1)); + [fVidQualityRFLabel setStringValue:[NSString stringWithFormat:@"%s", + hb_video_quality_get_name((int)[[fVidEncoderPopUp + selectedItem] tag])]]; + int direction; + float minValue, maxValue, granularity; + hb_video_quality_get_limits((int)[[fVidEncoderPopUp selectedItem] tag], + &minValue, &maxValue, &granularity, &direction); + if (granularity < 1.0f) + { + /* + * Encoders that allow fractional CQ values often have a low granularity + * which makes the slider hard to use, so use a value from preferences. + */ + granularity = [[NSUserDefaults standardUserDefaults] + floatForKey:@"x264CqSliderFractional"]; + } + [fVidQualitySlider setMinValue:minValue]; + [fVidQualitySlider setMaxValue:maxValue]; + [fVidQualitySlider setNumberOfTickMarks:((maxValue - minValue) * + (1.0f / granularity)) + 1]; + + /* check to see if we have changed slider scales */ + if (previousMaxValue != maxValue) + { + /* + * if so, convert the old setting to the new scale as close as possible + * based on percentages + */ + [fVidQualitySlider setFloatValue:((maxValue - minValue + 1.) * + (previousPercentOfSliderScale))]; + } + + [self qualitySliderChanged:nil]; +} + +- (IBAction) qualitySliderChanged: (id) sender +{ + /* + * Our constant quality slider is in a range based + * on each encoders qp/rf values. The range depends + * on the encoder. Also, the range is inverse of quality + * for all of the encoders *except* for theora + * (ie. as the "quality" goes up, the cq or rf value + * actually goes down). Since the IB sliders always set + * their max value at the right end of the slider, we + * will calculate the inverse, so as the slider floatValue + * goes up, we will show the inverse in the rf field + * so, the floatValue at the right for x264 would be 51 + * and our rf field needs to show 0 and vice versa. + */ + int direction; + float minValue, maxValue, granularity; + float inverseValue = ([fVidQualitySlider minValue] + + [fVidQualitySlider maxValue] - + [fVidQualitySlider floatValue]); + hb_video_quality_get_limits((int)[[fVidEncoderPopUp selectedItem] tag], + &minValue, &maxValue, &granularity, &direction); + if (!direction) + { + [fVidQualityRFField setStringValue:[NSString stringWithFormat:@"%.2f", + [fVidQualitySlider floatValue]]]; + } + else + { + [fVidQualityRFField setStringValue:[NSString stringWithFormat:@"%.2f", + inverseValue]]; + } + /* Show a warning if x264 and rf 0 which is lossless */ + if ([[fVidEncoderPopUp selectedItem] tag] == HB_VCODEC_X264 && inverseValue == 0.0) + { + [fVidQualityRFField setStringValue:[NSString stringWithFormat:@"%.2f (Warning: Lossless)", + inverseValue]]; + } + + [self.fHBController customSettingUsed: sender]; +} + +#pragma mark - Video x264 Presets + +- (void) setupX264PresetsWidgets +{ + NSUInteger i; + // populate the preset system widgets via hb_video_encoder_get_* functions. + // store x264 preset names + const char* const *x264_presets = hb_video_encoder_get_presets(HB_VCODEC_X264); + NSMutableArray *tmp_array = [[NSMutableArray alloc] init]; + for (i = 0; x264_presets[i] != NULL; i++) + { + [tmp_array addObject:[NSString stringWithUTF8String:x264_presets[i]]]; + if (!strcasecmp(x264_presets[i], "medium")) + { + fX264MediumPresetIndex = i; + } + } + fX264PresetNames = [[NSArray alloc] initWithArray:tmp_array]; + [tmp_array release]; + // setup the x264 preset slider + [fX264PresetsSlider setMinValue:0]; + [fX264PresetsSlider setMaxValue:[fX264PresetNames count]-1]; + [fX264PresetsSlider setNumberOfTickMarks:[fX264PresetNames count]]; + [fX264PresetsSlider setIntegerValue:fX264MediumPresetIndex]; + [fX264PresetsSlider setTickMarkPosition:NSTickMarkAbove]; + [fX264PresetsSlider setAllowsTickMarkValuesOnly:YES]; + [self x264PresetsSliderChanged: nil]; + // setup the x264 tune popup + [fX264TunePopUp removeAllItems]; + [fX264TunePopUp addItemWithTitle: @"none"]; + const char* const *x264_tunes = hb_video_encoder_get_tunes(HB_VCODEC_X264); + for (int i = 0; x264_tunes[i] != NULL; i++) + { + // we filter out "fastdecode" as we have a dedicated checkbox for it + if (strcasecmp(x264_tunes[i], "fastdecode") != 0) + { + [fX264TunePopUp addItemWithTitle: [NSString stringWithUTF8String:x264_tunes[i]]]; + } + } + // the fastdecode checkbox is off by default + [fX264FastDecodeCheck setState: NSOffState]; + // setup the h264 profile popup + [fX264ProfilePopUp removeAllItems]; + const char* const *h264_profiles = hb_video_encoder_get_profiles(HB_VCODEC_X264); + for (int i = 0; h264_profiles[i] != NULL; i++) + { + [fX264ProfilePopUp addItemWithTitle: [NSString stringWithUTF8String:h264_profiles[i]]]; + } + // setup the h264 level popup + [fX264LevelPopUp removeAllItems]; + const char* const *h264_levels = hb_video_encoder_get_levels(HB_VCODEC_X264); + for (int i = 0; h264_levels[i] != NULL; i++) + { + [fX264LevelPopUp addItemWithTitle: [NSString stringWithUTF8String:h264_levels[i]]]; + } + // clear the additional x264 options + [fDisplayX264PresetsAdditonalOptionsTextField setStringValue:@""]; +} + +- (void) enableX264Widgets: (bool) enable +{ + NSControl *controls[] = + { + fX264PresetsSlider, fX264PresetSliderLabel, fX264PresetSelectedTextField, + fX264TunePopUp, fX264TunePopUpLabel, fX264FastDecodeCheck, + fDisplayX264PresetsAdditonalOptionsTextField, fDisplayX264PresetsAdditonalOptionsLabel, + fX264ProfilePopUp, fX264ProfilePopUpLabel, + fX264LevelPopUp, fX264LevelPopUpLabel, + fDisplayX264PresetsUnparseTextField, + }; + + // check whether the x264 preset system and the advanced panel should be enabled + BOOL enable_x264_controls = (enable && [fX264UseAdvancedOptionsCheck state] == NSOffState); + BOOL enable_advanced_panel = (enable && [fX264UseAdvancedOptionsCheck state] == NSOnState); + + // enable/disable the checkbox and advanced panel + [fX264UseAdvancedOptionsCheck setEnabled:enable]; + [self.fAdvancedOptions enableUI:enable_advanced_panel]; + + // enable/disable the x264 preset system controls + for (unsigned i = 0; i < (sizeof(controls) / sizeof(NSControl*)); i++) + { + if ([[controls[i] className] isEqualToString: @"NSTextField"]) + { + NSTextField *tf = (NSTextField*)controls[i]; + if (![tf isBezeled]) + { + [tf setTextColor:(enable_x264_controls ? + [NSColor controlTextColor] : + [NSColor disabledControlTextColor])]; + continue; + } + } + [controls[i] setEnabled:enable_x264_controls]; + } +} + +- (IBAction) updateX264Widgets: (id) sender +{ + if ([fX264UseAdvancedOptionsCheck state] == NSOnState) + { + /* + * we are using or switching to the advanced panel + * + * if triggered by selectPreset or applyQueueSettingToMainWindow, + * the options string will have been specified explicitly - leave it. + * + * if triggered by the advanced panel on/off checkbox, set the options + * string to the value of the unparsed x264 preset system string. + */ + if (sender == fX264UseAdvancedOptionsCheck) + { + if (fX264PresetsUnparsedUTF8String != NULL) + { + [self.fAdvancedOptions setOptions: + [NSString stringWithUTF8String:fX264PresetsUnparsedUTF8String]]; + } + else + { + [self.fAdvancedOptions setOptions:@""]; + } + } + } + // enable/disable, populate and update the various widgets + [self enableX264Widgets: YES]; + [self x264PresetsSliderChanged:nil]; + [self.fAdvancedOptions X264AdvancedOptionsSet: nil]; +} + +#pragma mark - +#pragma mark x264 preset system + +- (NSString *) x264Preset +{ + return (NSString *)[fX264PresetNames objectAtIndex:[fX264PresetsSlider intValue]]; +} + +- (NSString *) x264Tune +{ + NSString *x264Tune = @""; + if ([fX264TunePopUp indexOfSelectedItem]) + { + x264Tune = [x264Tune stringByAppendingString: + [fX264TunePopUp titleOfSelectedItem]]; + } + if ([fX264FastDecodeCheck state]) + { + if ([x264Tune length]) + { + x264Tune = [x264Tune stringByAppendingString: @","]; + } + x264Tune = [x264Tune stringByAppendingString: @"fastdecode"]; + } + return x264Tune; +} + +- (NSString*) x264OptionExtra +{ + return [fDisplayX264PresetsAdditonalOptionsTextField stringValue]; +} + +- (NSString*) h264Profile +{ + if ([fX264ProfilePopUp indexOfSelectedItem]) + { + return [fX264ProfilePopUp titleOfSelectedItem]; + } + return @""; +} + +- (NSString*) h264Level +{ + if ([fX264LevelPopUp indexOfSelectedItem]) + { + return [fX264LevelPopUp titleOfSelectedItem]; + } + return @""; +} + +- (void) setX264Preset: (NSString*)x264Preset +{ + if (x264Preset) + { + NSString *name; + NSEnumerator *enumerator = [fX264PresetNames objectEnumerator]; + while ((name = (NSString *)[enumerator nextObject])) + { + if ([name isEqualToString:x264Preset]) + { + [fX264PresetsSlider setIntegerValue: + [fX264PresetNames indexOfObject:name]]; + return; + } + } + } + [fX264PresetsSlider setIntegerValue:fX264MediumPresetIndex]; +} + +- (void) setX264Tune: (NSString*)x264Tune +{ + if (!x264Tune) + { + [fX264TunePopUp selectItemAtIndex:0]; + [fX264FastDecodeCheck setState:NSOffState]; + return; + } + // handle fastdecode + if ([x264Tune rangeOfString:@"fastdecode"].location != NSNotFound) + { + [fX264FastDecodeCheck setState:NSOnState]; + } + else + { + [fX264FastDecodeCheck setState:NSOffState]; + } + // filter out fastdecode + x264Tune = [x264Tune stringByReplacingOccurrencesOfString:@"," + withString:@""]; + x264Tune = [x264Tune stringByReplacingOccurrencesOfString:@"fastdecode" + withString:@""]; + // set the tune + [fX264TunePopUp selectItemWithTitle:x264Tune]; + // fallback + if ([fX264TunePopUp indexOfSelectedItem] == -1) + { + [fX264TunePopUp selectItemAtIndex:0]; + } +} + +- (void) setX264OptionExtra: (NSString*)x264OptionExtra +{ + if (!x264OptionExtra) + { + [fDisplayX264PresetsAdditonalOptionsTextField setStringValue:@""]; + return; + } + [fDisplayX264PresetsAdditonalOptionsTextField setStringValue:x264OptionExtra]; +} + +- (void) setH264Profile: (NSString*)h264Profile +{ + if (!h264Profile) + { + [fX264ProfilePopUp selectItemAtIndex:0]; + return; + } + // set the profile + [fX264ProfilePopUp selectItemWithTitle:h264Profile]; + // fallback + if ([fX264ProfilePopUp indexOfSelectedItem] == -1) + { + [fX264ProfilePopUp selectItemAtIndex:0]; + } +} + +- (void) setH264Level: (NSString*)h264Level +{ + if (!h264Level) + { + [fX264LevelPopUp selectItemAtIndex:0]; + return; + } + // set the level + [fX264LevelPopUp selectItemWithTitle:h264Level]; + // fallback + if ([fX264LevelPopUp indexOfSelectedItem] == -1) + { + [fX264LevelPopUp selectItemAtIndex:0]; + } +} + + +- (IBAction) x264PresetsSliderChanged: (id) sender +{ + // we assume the preset names and slider were setup properly + [fX264PresetSelectedTextField setStringValue: [self x264Preset]]; + [self x264PresetsChangedDisplayExpandedOptions:nil]; + +} + +/* This is called everytime a x264 widget in the video tab is changed to + display the expanded options in a text field via outlet fDisplayX264PresetsUnparseTextField + */ +- (IBAction) x264PresetsChangedDisplayExpandedOptions: (id) sender + +{ + /* API reference: + * + * char * hb_x264_param_unparse(const char *x264_preset, + * const char *x264_tune, + * const char *x264_encopts, + * const char *h264_profile, + * const char *h264_level, + * int width, int height); + */ + NSString *tmpString; + const char *x264_preset = [[self x264Preset] UTF8String]; + const char *x264_tune = NULL; + const char *advanced_opts = NULL; + const char *h264_profile = NULL; + const char *h264_level = NULL; + int width = 1; + int height = 1; + // prepare the tune, advanced options, profile and level + if ([(tmpString = [self x264Tune]) length]) + { + x264_tune = [tmpString UTF8String]; + } + if ([(tmpString = [self x264OptionExtra]) length]) + { + advanced_opts = [tmpString UTF8String]; + } + if ([(tmpString = [self h264Profile]) length]) + { + h264_profile = [tmpString UTF8String]; + } + if ([(tmpString = [self h264Level]) length]) + { + h264_level = [tmpString UTF8String]; + } + // width and height must be non-zero + if (_fX264PresetsWidthForUnparse && _fX264PresetsHeightForUnparse) + { + width = (int)_fX264PresetsWidthForUnparse; + height = (int)_fX264PresetsHeightForUnparse; + } + // free the previous unparsed string + free(fX264PresetsUnparsedUTF8String); + // now, unparse + fX264PresetsUnparsedUTF8String = hb_x264_param_unparse(x264_preset, + x264_tune, + advanced_opts, + h264_profile, + h264_level, + width, height); + // update the text field + if (fX264PresetsUnparsedUTF8String != NULL) + { + [fDisplayX264PresetsUnparseTextField setStringValue: + [NSString stringWithFormat:@"x264 Unparse: %s", + fX264PresetsUnparsedUTF8String]]; + } + else + { + [fDisplayX264PresetsUnparseTextField setStringValue:@"x264 Unparse:"]; + } +} + +@end |