/*  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