MacGui: completed the HBVideo class.

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

1 files changed, 988 insertions, 7 deletions

diff --git a/macosx/HBVideo.m b/macosx/HBVideo.m
index 9160934e9..0319174f7 100644
--- a/macosx/HBVideo.m
+++ b/macosx/HBVideo.m
@@ -1,18 +1,999 @@
-//
-//  HBVideo.m
-//  HandBrake
-//
-//  Created by Damiano Galassi on 12/08/14.
-//
-//
+/*  HBVideo.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 "HBVideo.h"
 
+@interface HBVideo ()
+
+@property (nonatomic, readwrite) double qualityMinValue;
+@property (nonatomic, readwrite) double qualityMaxValue;
+
+@property (nonatomic, readwrite) NSUInteger mediumPresetIndex;
+
+@end
+
 @implementation HBVideo
 
+- (instancetype)init
+{
+    self = [super init];
+    if (self) {
+        _encoder = HB_VCODEC_X264;
+        _avgBitrate = 1000;
+        _quality = 18.0;
+        _qualityMaxValue = 51.0f;
+
+        _widthForUnparse = 1;
+        _heightForUnparse = 1;
+
+        [self updateQualityBounds];
+    }
+    return self;
+}
+
+#pragma mark - Setters
+
+/**
+ *  Updates the min/max quality values
+ */
+- (void)updateQualityBounds
+{
+    // 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
+    double previousMaxValue             = self.qualityMaxValue;
+    double previousPercentOfSliderScale = (self.quality / (self.qualityMaxValue - self.qualityMinValue + 1));
+
+    int direction;
+    float minValue, maxValue, granularity;
+    hb_video_quality_get_limits(self.encoder,
+                                &minValue, &maxValue, &granularity, &direction);
+
+    self.qualityMinValue = minValue;
+    self.qualityMaxValue = maxValue;
+
+    // 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
+        self.quality = floor((maxValue - minValue + 1.) * (previousPercentOfSliderScale));
+    }
+}
+
+- (void)setEncoder:(int)encoder
+{
+    _encoder = encoder;
+    [self updateQualityBounds];
+    [self validatePresetsSettings];
+    [self validateAdvancedOptions];
+}
+
+- (void)setContainer:(int)container
+{
+    _container = container;
+
+    BOOL encoderSupported = NO;
+
+    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 & self.container)
+        {
+            if (video_encoder->codec == self.encoder)
+            {
+                encoderSupported = YES;
+            }
+        }
+    }
+
+    if (!encoderSupported)
+    {
+        self.encoder = HB_VCODEC_X264;
+    }
+}
+
+- (void)setTune:(NSString *)tune
+{
+    [_tune autorelease];
+
+    if (![tune isEqualToString:@"none"])
+    {
+        _tune = [tune copy];
+    }
+    else
+    {
+        _tune = @"";
+    }
+}
+
+- (void)validatePresetsSettings
+{
+    NSArray *presets = self.presets;
+    if (presets.count && ![presets containsObject:self.preset]) {
+        self.preset = presets[self.mediumPresetIndex];
+    }
+
+    NSArray *tunes = self.tunes;
+    if (tunes.count && ![tunes containsObject:self.tune]) {
+        self.tune = tunes.firstObject;
+    }
+
+    NSArray *profiles = self.profiles;
+    if (profiles.count && ![profiles containsObject:self.profile]) {
+        self.profile = profiles.firstObject;
+    }
+
+    NSArray *levels = self.levels;
+    if (levels.count && ![levels containsObject:self.level]) {
+        self.level = levels.firstObject;
+    }
+}
+
+- (void)validateAdvancedOptions
+{
+    if (self.encoder != HB_VCODEC_H264_MASK)
+    {
+        self.advancedOptions = NO;
+    }
+}
+
+#pragma mark - Possible values
+
+- (NSArray *)encoders
+{
+    NSMutableArray *encoders = [NSMutableArray array];
+    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 & self.container)
+        {
+            [encoders addObject:@(video_encoder->name)];
+        }
+    }
+    return [[encoders copy] autorelease];
+}
+
+- (NSArray *)frameRates
+{
+    NSMutableArray *framerates = [NSMutableArray array];
+
+    [framerates addObject:NSLocalizedString(@"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 = @(video_framerate->name);
+        }
+
+        [framerates addObject:itemTitle];
+    }
+    return [[framerates copy] autorelease];
+}
+
+- (NSArray *)presets
+{
+    NSMutableArray *temp = [NSMutableArray array];
+
+    const char * const *presets = hb_video_encoder_get_presets(self.encoder);
+    for (int i = 0; presets != NULL && presets[i] != NULL; i++)
+    {
+        [temp addObject:@(presets[i])];
+        if (!strcasecmp(presets[i], "medium"))
+        {
+            self.mediumPresetIndex = i;
+        }
+    }
+
+    return [[temp copy] autorelease];
+}
+
+- (NSArray *)tunes
+{
+    NSMutableArray *temp = [NSMutableArray array];
+
+    [temp addObject:@"none"];
+
+    const char * const *tunes = hb_video_encoder_get_tunes(self.encoder);
+
+    for (int i = 0; tunes != NULL && tunes[i] != NULL; i++)
+    {
+        // we filter out "fastdecode" as we have a dedicated checkbox for it
+        if (strcasecmp(tunes[i], "fastdecode") != 0)
+        {
+            [temp addObject:@(tunes[i])];
+        }
+    }
+
+    return [[temp copy] autorelease];
+}
+
+- (NSArray *)profiles
+{
+    NSMutableArray *temp = [NSMutableArray array];
+
+    const char * const *profiles = hb_video_encoder_get_profiles(self.encoder);
+    for (int i = 0; profiles != NULL && profiles[i] != NULL; i++)
+    {
+        [temp addObject:@(profiles[i])];
+    }
+
+    return [[temp copy] autorelease];
+}
+
+- (NSArray *)levels
+{
+    NSMutableArray *temp = [NSMutableArray array];
+
+    const char * const *levels = hb_video_encoder_get_levels(self.encoder);
+    for (int i = 0; levels != NULL && levels[i] != NULL; i++)
+    {
+        [temp addObject:@(levels[i])];
+    }
+    if (!temp.count)
+    {
+        [temp addObject:@"auto"];
+    }
+
+    return [[temp copy] autorelease];
+}
+
+- (BOOL)fastDecodeSupported
+{
+    return (self.encoder == HB_VCODEC_X264);
+}
+
+/**
+ *  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
+ */
+- (NSString *)unparseOptions
+{
+    if (self.encoder != HB_VCODEC_X264)
+    {
+        return @"";
+    }
+
+    /* 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.preset UTF8String];
+    const char *x264_tune     = NULL;
+    const char *advanced_opts = NULL;
+    const char *h264_profile  = NULL;
+    const char *h264_level    = NULL;
+
+    tmpString = self.tune;
+    if (self.fastDecode)
+    {
+        if (self.tune.length)
+        {
+            tmpString = [tmpString stringByAppendingString: @","];
+        }
+        tmpString = [tmpString stringByAppendingString: @"fastdecode"];
+    }
+
+    // prepare the tune, advanced options, profile and level
+    if ([tmpString length])
+    {
+        x264_tune = [tmpString UTF8String];
+    }
+    if ([(tmpString = self.videoOptionExtra) length])
+    {
+        advanced_opts = [tmpString UTF8String];
+    }
+    if ([(tmpString = self.profile) length])
+    {
+        h264_profile = [tmpString UTF8String];
+    }
+    if ([(tmpString = self.level) length])
+    {
+        h264_level = [tmpString UTF8String];
+    }
+
+    // now, unparse
+    char *fX264PresetsUnparsedUTF8String = hb_x264_param_unparse(x264_preset,
+                                                           x264_tune,
+                                                           advanced_opts,
+                                                           h264_profile,
+                                                           h264_level,
+                                                           _widthForUnparse, _heightForUnparse);
+    // update the text field
+    if (fX264PresetsUnparsedUTF8String != NULL)
+    {
+        tmpString = [NSString stringWithUTF8String:fX264PresetsUnparsedUTF8String];
+        free(fX264PresetsUnparsedUTF8String);
+    }
+    else
+    {
+        tmpString = @"";
+    }
+
+    return tmpString;
+}
+
++ (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
+{
+    NSSet *retval = nil;
+
+    // Tell KVO to reload the presets settings
+    // after a change to the encoder.
+    if ([key isEqualToString:@"presets"] ||
+        [key isEqualToString:@"tunes"] ||
+        [key isEqualToString:@"profiles"] ||
+        [key isEqualToString:@"levels"])
+    {
+        retval = [NSSet setWithObjects:@"encoder", nil];
+    }
+
+    // Tell KVO to reload the x264 unparse string
+    // after values changes.
+    if ([key isEqualToString:@"unparseOptions"])
+    {
+        retval = [NSSet setWithObjects:@"encoder", @"preset", @"tune", @"profile", @"level",
+                  @"videoOptionExtra", @"fastDecode", @"widthForUnparse", @"heightForUnparse", nil];
+    }
+
+    if ([key isEqualToString:@"encoders"])
+    {
+        retval = [NSSet setWithObjects:@"container", nil];
+    }
+
+    if ([key isEqualToString:@"fastDecodeSupported"])
+    {
+        retval = [NSSet setWithObjects:@"encoder", nil];
+    }
+
+    return retval;
+}
+
+#pragma mark - Various conversion methods from dict/preset/queue/etc
+
 - (void)applySettingsFromPreset:(NSDictionary *)preset
 {
+    // map legacy encoder names via libhb.
+    const char *strValue = hb_video_encoder_sanitize_name([preset[@"VideoEncoder"] UTF8String]);
+    self.encoder = hb_video_encoder_get_from_name(strValue);
+
+    if (self.encoder == HB_VCODEC_X264 || self.encoder == HB_VCODEC_X265)
+    {
+        if (self.encoder == HB_VCODEC_X264 &&
+            (!preset[@"x264UseAdvancedOptions"] ||
+             [preset[@"x264UseAdvancedOptions"] intValue]))
+        {
+            // x264UseAdvancedOptions is not set (legacy preset)
+            // or set to 1 (enabled), so we use the old advanced panel.
+            if (preset[@"x264Option"])
+            {
+                // we set the advanced options string here if applicable.
+                self.advancedOptions = YES;
+                self.videoOptionExtra = preset[@"x264Option"];
+            }
+            else
+            {
+                self.videoOptionExtra = nil;
+            }
+            // preset does not use the x264 preset system, reset the widgets.
+            self.preset = nil;
+            self.tune = nil;
+            self.profile = nil;
+            self.level = nil;
+        }
+        else
+        {
+            // x264UseAdvancedOptions is set to 0 (disabled),
+            // so we use the new preset system and
+            // disable the advanced panel
+            self.advancedOptions = NO;
+
+            if (preset[@"x264Preset"])
+            {
+                // Read the old x264 preset keys
+                self.preset = preset[@"x264Preset"];
+                self.tune   = preset[@"x264Tune"];
+                self.videoOptionExtra = preset[@"x264OptionExtra"];
+                self.profile = preset[@"h264Profile"];
+                self.level   = preset[@"h264Level"];
+            }
+            else
+            {
+                // Read the new preset keys (0.10)
+                self.preset = preset[@"VideoPreset"];
+                self.tune   = preset[@"VideoTune"];
+                self.videoOptionExtra = preset[@"VideoOptionExtra"];
+                self.profile = preset[@"VideoProfile"];
+                self.level   = preset[@"VideoLevel"];
+            }
+        }
+    }
+    else
+    {
+        if (preset[@"lavcOption"])
+        {
+            // Load the old format
+            self.videoOptionExtra = preset[@"lavcOption"];
+        }
+        else
+        {
+            self.videoOptionExtra = preset[@"VideoOptionExtra"];
+        }
+    }
+
+    int qualityType = [preset[@"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;
+    }
+    self.qualityType = qualityType;
+
+    self.avgBitrate = [preset[@"VideoAvgBitrate"] intValue];
+    self.quality = [preset[@"VideoQualitySlider"] floatValue];
+
+    // Video framerate
+    if ([preset[@"VideoFramerate"] isEqualToString:@"Same as source"])
+    {
+        // Now set the Video Frame Rate Mode to either vfr or cfr according to the preset.
+        if (!preset[@"VideoFramerateMode"] ||
+            [preset[@"VideoFramerateMode"] isEqualToString:@"vfr"])
+        {
+            self.frameRateMode = 0; // we want vfr
+        }
+        else
+        {
+            self.frameRateMode = 1; // we want cfr
+        }
+    }
+    else
+    {
+        // Now set the Video Frame Rate Mode to either pfr or cfr according to the preset.
+        if ([preset[@"VideoFramerateMode"] isEqualToString:@"pfr"] ||
+            [preset[@"VideoFrameratePFR"]  intValue] == 1)
+        {
+            self.frameRateMode = 0; // we want pfr
+        }
+        else
+        {
+            self.frameRateMode = 1; // we want cfr
+        }
+    }
+    // map legacy names via libhb.
+    int intValue = hb_video_framerate_get_from_name([preset[@"VideoFramerate"] UTF8String]);
+    if (intValue == -1)
+    {
+        intValue = 0;
+    }
+    self.frameRate = intValue;
 
+    // 2 Pass Encoding.
+    self.twoPass = [preset[@"VideoTwoPass"] intValue];
+
+    // Turbo 1st pass for 2 Pass Encoding.
+    self.turboTwoPass = [preset[@"VideoTurboTwoPass"] intValue];
+}
+
+- (void)prepareVideoForPreset:(NSMutableDictionary *)preset
+{
+    preset[@"VideoEncoder"] = @(hb_video_encoder_get_name(self.encoder));
+
+    // x264 Options, this will either be advanced panel or the video tabs x264 presets panel with modded option string
+    if (self.advancedOptions)
+    {
+        // use the old advanced panel.
+        preset[@"x264UseAdvancedOptions"] = @1;
+        preset[@"x264Option"] = self.videoOptionExtra;
+    }
+    else if (self.encoder == HB_VCODEC_X264 || self.encoder == HB_VCODEC_X265)
+    {
+        // use the new preset system.
+        preset[@"x264UseAdvancedOptions"] = @0;
+        preset[@"VideoPreset"]      = self.preset;
+        preset[@"VideoTune"]        = self.tune;
+        preset[@"VideoOptionExtra"] = self.videoOptionExtra;
+        preset[@"VideoProfile"]     = self.profile;
+        preset[@"VideoLevel"]       = self.level;
+    }
+    else
+    {
+        // FFmpeg (lavc) Option String
+        preset[@"VideoOptionExtra"] = self.videoOptionExtra;
+    }
+
+    /* 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[@"VideoQualityType"] = @(self.qualityType + 1);
+    preset[@"VideoAvgBitrate"] = @(self.avgBitrate);
+    preset[@"VideoQualitySlider"] = @(self.quality);
+
+    /* Video framerate and framerate mode */
+    if (self.frameRateMode == 1)
+    {
+        preset[@"VideoFramerateMode"] = @"cfr";
+    }
+    if (self.frameRateMode == 0) // Same as source is selected
+    {
+        preset[@"VideoFramerate"] = @"Same as source";
+
+        if (self.frameRateMode == 0)
+        {
+            preset[@"VideoFramerateMode"] = @"vfr";
+        }
+    }
+    else // translate the rate (selected item's tag) to the official libhb name
+    {
+        preset[@"VideoFramerate"] = [NSString stringWithFormat:@"%s",
+                                     hb_video_framerate_get_name((int)self.frameRate)];
+
+        if (self.frameRateMode == 0)
+        {
+            preset[@"VideoFramerateMode"] = @"pfr";
+        }
+    }
+
+    preset[@"VideoTwoPass"] = @(self.twoPass);
+    preset[@"VideoTurboTwoPass"] = @(self.turboTwoPass);
+}
+
+- (void)applyVideoSettingsFromQueue:(NSDictionary *)queueToApply
+{
+    // Video encoder
+    self.encoder = [queueToApply[@"JobVideoEncoderVcodec"] intValue];
+
+    // Advanced x264 options
+    if ([queueToApply[@"x264UseAdvancedOptions"] intValue])
+    {
+        // we are using the advanced panel
+        self.preset = nil;
+        self.tune = nil;
+        self.videoOptionExtra = queueToApply[@"x264Option"];
+        self.profile = nil;
+        self.level = nil;
+    }
+    else if (self.encoder == HB_VCODEC_X264 || self.encoder == HB_VCODEC_X265)
+    {
+        // we are using the x264 preset system
+        self.preset = queueToApply[@"VideoPreset"];
+        self.tune = queueToApply[@"VideoTune"];
+        self.videoOptionExtra = queueToApply[@"VideoOptionExtra"];
+        self.profile = queueToApply[@"VideoProfile"];
+        self.level = queueToApply[@"VideoLevel"];
+    }
+    else
+    {
+        self.videoOptionExtra = queueToApply[@"VideoOptionExtra"];
+    }
+
+    self.qualityType = [queueToApply[@"VideoQualityType"] intValue] - 1;
+
+    self.avgBitrate = [queueToApply[@"VideoAvgBitrate"] intValue];
+    self.quality = [queueToApply[@"VideoQualitySlider"] doubleValue];
+
+    // Video framerate
+    if ([queueToApply[@"JobIndexVideoFramerate"] intValue] == 0)
+    {
+        // Now set the Video Frame Rate Mode to either vfr or cfr according to the preset
+        if ([queueToApply[@"VideoFramerateMode"] isEqualToString:@"vfr"])
+        {
+            self.frameRateMode = 0; // we want vfr
+        }
+        else
+        {
+            self.frameRateMode = 1; // we want cfr
+        }
+    }
+    else
+    {
+        // Now set the Video Frame Rate Mode to either pfr or cfr according to the preset
+        if ([queueToApply[@"VideoFramerateMode"] isEqualToString:@"pfr"])
+        {
+            self.frameRateMode = 0; // we want pfr
+        }
+        else
+        {
+            self.frameRateMode = 1; // we want cfr
+        }
+    }
+
+    self.frameRate = [queueToApply[@"JobIndexVideoFramerate"] intValue];
+
+    self.twoPass = [queueToApply[@"VideoTwoPass"] intValue];
+    self.turboTwoPass = [queueToApply[@"VideoTurboTwoPass"] intValue];
+}
+
+- (void)prepareVideoForQueueFileJob:(NSMutableDictionary *)queueFileJob
+{
+    // Video encoder.
+    queueFileJob[@"VideoEncoder"] = @(hb_video_encoder_get_name(self.encoder));
+    queueFileJob[@"JobVideoEncoderVcodec"] = @(self.encoder);
+
+    // x264 advanced options.
+    if (self.advancedOptions)
+    {
+        // we are using the advanced panel
+        queueFileJob[@"x264UseAdvancedOptions"] = @1;
+        queueFileJob[@"x264Option"] = self.videoOptionExtra;
+     }
+     else if (self.encoder == HB_VCODEC_X264 || self.encoder == HB_VCODEC_X265)
+     {
+         // we are using the x264/x265 preset system.
+         queueFileJob[@"x264UseAdvancedOptions"] = @0;
+         queueFileJob[@"VideoPreset"] = self.preset;
+         queueFileJob[@"VideoTune"] = self.tune;
+         queueFileJob[@"VideoOptionExtra"] = self.videoOptionExtra;
+         queueFileJob[@"VideoProfile"] = self.profile;
+         queueFileJob[@"VideoLevel"] = self.level;
+     }
+     else
+     {
+         // FFmpeg (lavc) Option String.
+         queueFileJob[@"VideoOptionExtra"] = self.videoOptionExtra;
+     }
+
+    queueFileJob[@"VideoQualityType"] = @(self.qualityType + 1);
+    queueFileJob[@"VideoAvgBitrate"] = @(self.avgBitrate);
+    queueFileJob[@"VideoQualitySlider"] = @(self.quality);
+
+    // Framerate
+    if (self.frameRate)
+    {
+        queueFileJob[@"VideoFramerate"] = @(hb_video_framerate_get_name(self.frameRate));
+    }
+    else
+    {
+        queueFileJob[@"VideoFramerate"] = @"Same as source";
+    }
+    queueFileJob[@"JobIndexVideoFramerate"] = @(self.frameRate);
+
+    // Frame Rate Mode
+    if (self.frameRateMode == 1) // if selected we are cfr regardless of the frame rate popup
+    {
+        queueFileJob[@"VideoFramerateMode"] = @"cfr";
+    }
+    else
+    {
+        if (self.frameRate == 0) // Same as source frame rate
+        {
+            queueFileJob[@"VideoFramerateMode"] = @"vfr";
+        }
+        else
+        {
+            queueFileJob[@"VideoFramerateMode"] = @"pfr";
+        }
+    }
+
+    // 2 Pass Encoding
+    queueFileJob[@"VideoTwoPass"] = @(self.twoPass);
+    queueFileJob[@"VideoTurboTwoPass"] = @(self.turboTwoPass);
+}
+
+- (void)prepareVideoForJobPreview:(hb_job_t *)job andTitle:(hb_title_t *)title
+{
+    job->vcodec = self.encoder;
+    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 (self.advancedOptions)
+        {
+            // we are using the advanced panel
+            if ([(tmpString = self.videoOptionExtra) length])
+            {
+                encoder_options = [tmpString UTF8String];
+            }
+        }
+        else
+        {
+            // we are using the x264 preset system
+            if ([(tmpString = self.tune) length])
+            {
+                encoder_tune = [tmpString UTF8String];
+            }
+            if ([(tmpString = self.videoOptionExtra) length])
+            {
+                encoder_options = [tmpString UTF8String];
+            }
+            if ([(tmpString = self.profile) length])
+            {
+                encoder_profile = [tmpString UTF8String];
+            }
+            if ([(tmpString = self.level) length])
+            {
+                encoder_level = [tmpString UTF8String];
+            }
+            encoder_preset = [self.preset 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.videoOptionExtra UTF8String]);
+    }
+
+    /* Video settings */
+    int fps_mode, fps_num, fps_den;
+    if (self.frameRate > 0 )
+    {
+        /* a specific framerate has been chosen */
+        fps_num = 27000000;
+        fps_den = (int)self.frameRate;
+        if (self.frameRateMode == 1)
+        {
+            // CFR
+            fps_mode = 1;
+        }
+        else
+        {
+            // PFR
+            fps_mode = 2;
+        }
+    }
+    else
+    {
+        /* same as source */
+        fps_num = title->rate;
+        fps_den = title->rate_base;
+        if (self.frameRateMode == 1)
+        {
+            // CFR
+            fps_mode = 1;
+        }
+        else
+        {
+            // VFR
+            fps_mode = 0;
+        }
+    }
+
+    switch (self.qualityType)
+    {
+        case 0:
+            /* ABR */
+            job->vquality = -1.0;
+            job->vbitrate = self.avgBitrate;
+            break;
+        case 1:
+            /* Constant Quality */
+            job->vquality = self.quality;
+            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]);
+}
+
+@end
+
+#pragma mark - Value Trasformers
+
+@implementation HBVideoEncoderTransformer
+
++ (Class)transformedValueClass
+{
+    return [NSString class];
+}
+
+- (id)transformedValue:(id)value
+{
+    const char *name = hb_video_encoder_get_name([value intValue]);
+    if (name)
+    {
+        return @(name);
+    }
+    else
+    {
+        return nil;
+    }
+}
+
++ (BOOL)allowsReverseTransformation
+{
+    return YES;
+}
+
+- (id)reverseTransformedValue:(id)value
+{
+    return @(hb_video_encoder_get_from_name([value UTF8String]));
+}
+
+@end
+
+@implementation HBFrameRateTransformer
+
++ (Class)transformedValueClass
+{
+    return [NSString class];
+}
+
+- (id)transformedValue:(id)value
+{
+    const char *name = hb_video_framerate_get_name([value intValue]);
+    if (name)
+    {
+        return @(name);
+    }
+    else
+    {
+        return NSLocalizedString(@"Same as source", @"");
+    }
+}
+
++ (BOOL)allowsReverseTransformation
+{
+    return YES;
+}
+
+- (id)reverseTransformedValue:(id)value
+{
+    if ([value isEqualTo:NSLocalizedString(@"Same as source", @"")])
+    {
+        return @0;
+    }
+    else
+    {
+        return @(hb_video_framerate_get_from_name([value UTF8String]));
+    }
 }
 
 @end
+
+@implementation HBPresetsTransformer
+{
+    int _encoder;
+}
+
+- (instancetype)initWithEncoder:(int)encoder
+{
+    self = [super init];
+    if (self)
+    {
+        _encoder = encoder;
+    }
+    return self;
+}
+
++ (Class)transformedValueClass
+{
+    return [NSNumber class];
+}
+
+- (id)transformedValue:(id)value
+{
+    const char * const *presets = hb_video_encoder_get_presets(_encoder);
+    for (int i = 0; presets[i] != NULL; i++)
+    {
+        if (!strcasecmp(presets[i], [value UTF8String]))
+        {
+            return @(i);
+        }
+    }
+
+    return @(-1);
+}
+
++ (BOOL)allowsReverseTransformation
+{
+    return YES;
+}
+
+- (id)reverseTransformedValue:(id)value
+{
+    const char * const *presets = hb_video_encoder_get_presets(_encoder);
+    for (int i = 0; presets[i] != NULL; i++)
+    {
+        if (i == [value intValue])
+        {
+            return @(presets[i]);
+        }
+    }
+
+    return @"none";
+}
+
+@end
+
+@implementation HBQualityTransformer
+{
+    BOOL _reverse;
+    double _min;
+    double _max;
+}
+
+- (instancetype)initWithReversedDirection:(BOOL)reverse min:(double)min max:(double)max
+{
+    self = [super init];
+    if (self)
+    {
+        _reverse = reverse;
+        _min = min;
+        _max = max;
+    }
+
+    return self;
+}
+
++ (Class)transformedValueClass
+{
+    return [NSNumber class];
+}
+
+- (id)transformedValue:(id)value
+{
+    if (_reverse)
+    {
+        double inverseValue = _min + _max - [value doubleValue];
+        return @(inverseValue);
+    }
+    else
+    {
+        return value;
+    }
+}
+
++ (BOOL)allowsReverseTransformation
+{
+    return YES;
+}
+
+- (id)reverseTransformedValue:(id)value
+{
+    if (_reverse)
+    {
+        double inverseValue = _min + _max - [value doubleValue];
+        return @(inverseValue);
+    }
+    else
+    {
+        return value;
+    }
+}
+
+@end
\ No newline at end of file