macosx/HBVideo.m

   1 /*  HBVideo.m $
   2
   3  This file is part of the HandBrake source code.
   4  Homepage: <http://handbrake.fr/>.
   5  It may be used under the terms of the GNU General Public License. */
   6
   7 #import "HBVideo.h"
   8 #import "HBJob.h"
   9 #import "HBCodingUtilities.h"
  10 #include "hb.h"
  11
  12 NSString * const HBVideoChangedNotification = @"HBVideoChangedNotification";
  13
  14 @interface HBVideo ()
  15
  16 @property (nonatomic, readwrite) double qualityMinValue;
  17 @property (nonatomic, readwrite) double qualityMaxValue;
  18
  19 @property (nonatomic, readwrite) NSUInteger mediumPresetIndex;
  20
  21 @property (nonatomic, readwrite, getter=areNotificationsEnabled) BOOL notificationsEnabled;
  22
  23 @end
  24
  25 @implementation HBVideo
  26
  27 - (instancetype)initWithJob:(HBJob *)job;
  28 {
  29     self = [super init];
  30     if (self) {
  31         _encoder = HB_VCODEC_X264;
  32         _avgBitrate = 1000;
  33         _quality = 18.0;
  34         _qualityMaxValue = 51.0f;
  35         _job = job;
  36
  37         _preset = @"medium";
  38         _tune = @"";
  39         _profile = @"auto";
  40         _level = @"auto";
  41
  42         [self updateQualityBounds];
  43
  44         _notificationsEnabled = YES;
  45     }
  46     return self;
  47 }
  48
  49 - (void)postChangedNotification
  50 {
  51     if (self.areNotificationsEnabled)
  52     {
  53         [[NSNotificationCenter defaultCenter] postNotification: [NSNotification notificationWithName:HBVideoChangedNotification
  54                                                                                               object:self
  55                                                                                             userInfo:nil]];
  56     }
  57 }
  58
  59 #pragma mark - Setters
  60
  61 /**
  62  *  Updates the min/max quality values
  63  */
  64 - (void)updateQualityBounds
  65 {
  66     // Get the current slider maxValue to check for a change in slider scale
  67     // later so that we can choose a new similar value on the new slider scale
  68     double previousMaxValue             = self.qualityMaxValue;
  69     double previousPercentOfSliderScale = (self.quality / (self.qualityMaxValue - self.qualityMinValue + 1));
  70
  71     int direction;
  72     float minValue, maxValue, granularity;
  73     hb_video_quality_get_limits(self.encoder,
  74                                 &minValue, &maxValue, &granularity, &direction);
  75
  76     self.qualityMinValue = minValue;
  77     self.qualityMaxValue = maxValue;
  78
  79     // check to see if we have changed slider scales
  80     if (previousMaxValue != maxValue)
  81     {
  82         // if so, convert the old setting to the new scale as close as possible
  83         // based on percentages
  84         self.quality = floor((maxValue - minValue + 1.) * (previousPercentOfSliderScale));
  85     }
  86 }
  87
  88 - (void)setEncoder:(int)encoder
  89 {
  90     _encoder = encoder;
  91     [self updateQualityBounds];
  92     [self validatePresetsSettings];
  93     [self validateAdvancedOptions];
  94
  95     [self postChangedNotification];
  96 }
  97
  98 - (void)setQualityType:(int)qualityType
  99 {
 100     _qualityType = qualityType;
 101     [self postChangedNotification];
 102 }
 103
 104 - (void)setAvgBitrate:(int)avgBitrate
 105 {
 106     _avgBitrate = avgBitrate;
 107     [self postChangedNotification];
 108 }
 109
 110 - (void)setQuality:(double)quality
 111 {
 112     _quality = quality;
 113     [self postChangedNotification];
 114 }
 115
 116 - (void)setFrameRate:(int)frameRate
 117 {
 118     _frameRate = frameRate;
 119     [self postChangedNotification];
 120 }
 121
 122 - (void)setFrameRateMode:(int)frameRateMode
 123 {
 124     _frameRateMode = frameRateMode;
 125     [self postChangedNotification];
 126 }
 127
 128 - (void)setTwoPass:(BOOL)twoPass
 129 {
 130     _twoPass = twoPass;
 131     [self postChangedNotification];
 132 }
 133
 134 - (void)setTurboTwoPass:(BOOL)turboTwoPass
 135 {
 136     _turboTwoPass = turboTwoPass;
 137     [self postChangedNotification];
 138 }
 139
 140 - (void)containerChanged
 141 {
 142     BOOL encoderSupported = NO;
 143
 144     for (const hb_encoder_t *video_encoder = hb_video_encoder_get_next(NULL);
 145          video_encoder != NULL;
 146          video_encoder  = hb_video_encoder_get_next(video_encoder))
 147     {
 148         if (video_encoder->muxers & self.job.container)
 149         {
 150             if (video_encoder->codec == self.encoder)
 151             {
 152                 encoderSupported = YES;
 153             }
 154         }
 155     }
 156
 157     if (!encoderSupported)
 158     {
 159         self.encoder = HB_VCODEC_X264;
 160     }
 161 }
 162
 163 - (void)setPreset:(NSString *)preset
 164 {
 165     _preset = [preset copy];
 166     [self postChangedNotification];
 167 }
 168
 169 - (void)setTune:(NSString *)tune
 170 {
 171     if (![tune isEqualToString:@"none"])
 172     {
 173         _tune = [tune copy];
 174     }
 175     else
 176     {
 177         _tune = @"";
 178     }
 179
 180     [self postChangedNotification];
 181 }
 182
 183 - (void)setProfile:(NSString *)profile
 184 {
 185     _profile = [profile copy];
 186     [self postChangedNotification];
 187 }
 188
 189 - (void)setLevel:(NSString *)level
 190 {
 191     _level = [level copy];
 192     [self postChangedNotification];
 193 }
 194
 195 - (void)setVideoOptionExtra:(NSString *)videoOptionExtra
 196 {
 197     if (videoOptionExtra != nil)
 198     {
 199         _videoOptionExtra = [videoOptionExtra copy];
 200     }
 201     else
 202     {
 203         _videoOptionExtra = @"";
 204     }
 205     [self postChangedNotification];
 206 }
 207
 208 - (void)setFastDecode:(BOOL)fastDecode
 209 {
 210     _fastDecode = fastDecode;
 211     [self postChangedNotification];
 212 }
 213
 214 - (void)validatePresetsSettings
 215 {
 216     NSArray *presets = self.presets;
 217     if (presets.count && ![presets containsObject:self.preset]) {
 218         self.preset = presets[self.mediumPresetIndex];
 219     }
 220
 221     NSArray *tunes = self.tunes;
 222     if (tunes.count && ![tunes containsObject:self.tune]) {
 223         self.tune = tunes.firstObject;
 224     }
 225
 226     NSArray *profiles = self.profiles;
 227     if (profiles.count && ![profiles containsObject:self.profile]) {
 228         self.profile = profiles.firstObject;
 229     }
 230
 231     NSArray *levels = self.levels;
 232     if (levels.count && ![levels containsObject:self.level]) {
 233         self.level = levels.firstObject;
 234     }
 235 }
 236
 237 - (void)validateAdvancedOptions
 238 {
 239     if (self.encoder != HB_VCODEC_H264_MASK)
 240     {
 241         self.advancedOptions = NO;
 242     }
 243 }
 244
 245 + (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
 246 {
 247     NSSet *retval = nil;
 248
 249     // Tell KVO to reload the presets settings
 250     // after a change to the encoder.
 251     if ([key isEqualToString:@"presets"] ||
 252         [key isEqualToString:@"tunes"] ||
 253         [key isEqualToString:@"profiles"] ||
 254         [key isEqualToString:@"levels"])
 255     {
 256         retval = [NSSet setWithObjects:@"encoder", nil];
 257     }
 258
 259     // Tell KVO to reload the x264 unparse string
 260     // after values changes.
 261     if ([key isEqualToString:@"unparseOptions"])
 262     {
 263         retval = [NSSet setWithObjects:@"encoder", @"preset", @"tune", @"profile", @"level",
 264                   @"videoOptionExtra", @"fastDecode", @"job.picture.width", @"job.picture.height", nil];
 265     }
 266
 267     if ([key isEqualToString:@"encoders"])
 268     {
 269         retval = [NSSet setWithObjects:@"job.container", nil];
 270     }
 271
 272     if ([key isEqualToString:@"fastDecodeSupported"] ||
 273         [key isEqualToString:@"turboTwoPassSupported"])
 274     {
 275         retval = [NSSet setWithObjects:@"encoder", nil];
 276     }
 277
 278     return retval;
 279 }
 280
 281 - (void)setNilValueForKey:(NSString *)key
 282 {
 283     [self setValue:@0 forKey:key];
 284 }
 285
 286 #pragma mark -
 287
 288 - (NSArray *)presets
 289 {
 290     NSMutableArray *temp = [NSMutableArray array];
 291
 292     const char * const *presets = hb_video_encoder_get_presets(self.encoder);
 293     for (int i = 0; presets != NULL && presets[i] != NULL; i++)
 294     {
 295         [temp addObject:@(presets[i])];
 296         if (!strcasecmp(presets[i], "medium"))
 297         {
 298             self.mediumPresetIndex = i;
 299         }
 300     }
 301
 302     return [temp copy];
 303 }
 304
 305 - (NSArray *)tunes
 306 {
 307     NSMutableArray *temp = [NSMutableArray array];
 308
 309     [temp addObject:@"none"];
 310
 311     const char * const *tunes = hb_video_encoder_get_tunes(self.encoder);
 312
 313     for (int i = 0; tunes != NULL && tunes[i] != NULL; i++)
 314     {
 315         // we filter out "fastdecode" as we have a dedicated checkbox for it
 316         if (strcasecmp(tunes[i], "fastdecode") != 0)
 317         {
 318             [temp addObject:@(tunes[i])];
 319         }
 320     }
 321
 322     return [temp copy];
 323 }
 324
 325 - (NSArray *)profiles
 326 {
 327     NSMutableArray *temp = [NSMutableArray array];
 328
 329     const char * const *profiles = hb_video_encoder_get_profiles(self.encoder);
 330     for (int i = 0; profiles != NULL && profiles[i] != NULL; i++)
 331     {
 332         [temp addObject:@(profiles[i])];
 333     }
 334     if (!temp.count)
 335     {
 336         [temp addObject:@"auto"];
 337     }
 338
 339     return [temp copy];
 340 }
 341
 342 - (NSArray *)levels
 343 {
 344     NSMutableArray *temp = [NSMutableArray array];
 345
 346     const char * const *levels = hb_video_encoder_get_levels(self.encoder);
 347     for (int i = 0; levels != NULL && levels[i] != NULL; i++)
 348     {
 349         [temp addObject:@(levels[i])];
 350     }
 351     if (!temp.count)
 352     {
 353         [temp addObject:@"auto"];
 354     }
 355
 356     return [temp copy];
 357 }
 358
 359 #pragma mark - NSCopying
 360
 361 - (instancetype)copyWithZone:(NSZone *)zone
 362 {
 363     HBVideo *copy = [[[self class] alloc] init];
 364
 365     if (copy)
 366     {
 367         copy->_encoder = _encoder;
 368
 369         copy->_qualityType = _qualityType;
 370         copy->_avgBitrate = _avgBitrate;
 371         copy->_quality = _quality;
 372
 373         copy->_qualityMinValue = _qualityMinValue;
 374         copy->_qualityMaxValue = _qualityMaxValue;
 375
 376         copy->_frameRate = _frameRate;
 377         copy->_frameRateMode = _frameRateMode;
 378
 379         copy->_twoPass = _twoPass;
 380         copy->_turboTwoPass = _turboTwoPass;
 381
 382         copy->_advancedOptions = _advancedOptions;
 383         copy->_preset = [_preset copy];
 384         copy->_tune = [_tune copy];
 385         copy->_profile = [_profile copy];
 386         copy->_level = [_level copy];
 387         copy->_videoOptionExtra = [_videoOptionExtra copy];
 388         copy->_fastDecode = _fastDecode;
 389
 390         copy->_notificationsEnabled = _notificationsEnabled;
 391     }
 392
 393     return copy;
 394 }
 395
 396 #pragma mark - NSCoding
 397
 398 + (BOOL)supportsSecureCoding
 399 {
 400     return YES;
 401 }
 402
 403 - (void)encodeWithCoder:(NSCoder *)coder
 404 {
 405     [coder encodeInt:1 forKey:@"HBVideoVersion"];
 406
 407     encodeInt(_encoder);
 408
 409     encodeInt(_qualityType);
 410     encodeInt(_avgBitrate);
 411     encodeDouble(_quality);
 412
 413     encodeDouble(_qualityMinValue);
 414     encodeDouble(_qualityMaxValue);
 415
 416     encodeInt(_frameRate);
 417     encodeInt(_frameRateMode);
 418
 419     encodeBool(_twoPass);
 420     encodeBool(_turboTwoPass);
 421
 422     encodeBool(_advancedOptions);
 423     encodeObject(_preset);
 424     encodeObject(_tune);
 425     encodeObject(_profile);
 426     encodeObject(_level);
 427
 428     encodeObject(_videoOptionExtra);
 429
 430     encodeBool(_fastDecode);
 431 }
 432
 433 - (instancetype)initWithCoder:(NSCoder *)decoder
 434 {
 435     self = [super init];
 436
 437     decodeInt(_encoder);
 438
 439     decodeInt(_qualityType);
 440     decodeInt(_avgBitrate);
 441     decodeDouble(_quality);
 442
 443     decodeDouble(_qualityMinValue);
 444     decodeDouble(_qualityMaxValue);
 445
 446     decodeInt(_frameRate);
 447     decodeInt(_frameRateMode);
 448
 449     decodeBool(_twoPass);
 450     decodeBool(_turboTwoPass);
 451
 452     decodeBool(_advancedOptions);
 453     decodeObject(_preset, NSString);
 454     decodeObject(_tune, NSString);
 455     decodeObject(_profile, NSString);
 456     decodeObject(_level, NSString);
 457
 458     decodeObject(_videoOptionExtra, NSString);
 459
 460     decodeBool(_fastDecode);
 461
 462     _notificationsEnabled = YES;
 463
 464     return self;
 465 }
 466
 467 #pragma mark - Various conversion methods from dict/preset/queue/etc
 468
 469 /**
 470  *  Returns a string minus the fastdecode string.
 471  */
 472 - (NSString *)stripFastDecodeFromString:(NSString *)tune
 473 {
 474     // filter out fastdecode
 475     tune = [tune stringByReplacingOccurrencesOfString:@"," withString:@""];
 476     tune = [tune stringByReplacingOccurrencesOfString:@"fastdecode" withString:@""];
 477
 478     return tune;
 479 }
 480
 481 /**
 482  *  Retuns the tune string plus the fastdecode option (if enabled)
 483  */
 484 - (NSString *)completeTune
 485 {
 486     NSMutableString *string = [[NSMutableString alloc] init];
 487
 488     if (self.tune)
 489     {
 490         [string appendString:self.tune];
 491     }
 492
 493     if (self.fastDecode)
 494     {
 495         if (string.length)
 496         {
 497             [string appendString:@","];
 498         }
 499
 500         [string appendString:@"fastdecode"];
 501     }
 502
 503     return string;
 504 }
 505
 506 - (void)applyPreset:(NSDictionary *)preset
 507 {
 508     self.notificationsEnabled = NO;
 509
 510     // map legacy encoder names via libhb.
 511     self.encoder = hb_video_encoder_get_from_name([preset[@"VideoEncoder"] UTF8String]);
 512
 513     if (hb_video_encoder_get_presets(self.encoder) != NULL)
 514     {
 515         if (self.encoder == HB_VCODEC_X264 && [preset[@"x264UseAdvancedOptions"] boolValue])
 516         {
 517             // preset does not use the x264 preset system, reset the widgets.
 518             self.preset = @"medium";
 519             self.tune = @"";
 520             self.profile = @"auto";
 521             self.level = @"auto";
 522             self.fastDecode = NO;
 523
 524             self.videoOptionExtra = preset[@"VideoOptionExtra"];
 525             self.advancedOptions = YES;
 526         }
 527         else
 528         {
 529             // x264UseAdvancedOptions is set to 0 (disabled),
 530             // so we use the new preset system and
 531             // disable the advanced panel
 532             self.advancedOptions = NO;
 533
 534             self.preset = preset[@"VideoPreset"];
 535             self.tune   = preset[@"VideoTune"];
 536             self.videoOptionExtra = preset[@"VideoOptionExtra"];
 537             self.profile = preset[@"VideoProfile"];
 538             self.level   = preset[@"VideoLevel"];
 539
 540             if ([self.tune rangeOfString:@"fastdecode"].location != NSNotFound)
 541             {
 542                 self.fastDecode = YES;;
 543             }
 544             else
 545             {
 546                 self.fastDecode = NO;
 547             }
 548
 549             self.tune = [self stripFastDecodeFromString:self.tune];
 550         }
 551     }
 552     else
 553     {
 554         self.videoOptionExtra = preset[@"VideoOptionExtra"];
 555     }
 556
 557     int qualityType = [preset[@"VideoQualityType"] intValue] - 1;
 558     /* Note since the removal of Target Size encoding, the possible values for VideoQuality type are 0 - 1.
 559      * Therefore any preset that uses the old 2 for Constant Quality would now use 1 since there is one less index
 560      * for the fVidQualityMatrix. It should also be noted that any preset that used the deprecated Target Size
 561      * setting of 0 would set us to 0 or ABR since ABR is now tagged 0. Fortunately this does not affect any built-in
 562      * presets since they all use Constant Quality or Average Bitrate.*/
 563     if (qualityType == -1)
 564     {
 565         qualityType = 0;
 566     }
 567     self.qualityType = qualityType;
 568
 569     self.avgBitrate = [preset[@"VideoAvgBitrate"] intValue];
 570     self.quality = [preset[@"VideoQualitySlider"] floatValue];
 571
 572     // Video framerate
 573     if ([preset[@"VideoFramerate"] isEqualToString:@"auto"])
 574     {
 575         // Now set the Video Frame Rate Mode to either vfr or cfr according to the preset.
 576         if (!preset[@"VideoFramerateMode"] ||
 577             [preset[@"VideoFramerateMode"] isEqualToString:@"vfr"])
 578         {
 579             self.frameRateMode = 0; // we want vfr
 580         }
 581         else
 582         {
 583             self.frameRateMode = 1; // we want cfr
 584         }
 585     }
 586     else
 587     {
 588         // Now set the Video Frame Rate Mode to either pfr or cfr according to the preset.
 589         if ([preset[@"VideoFramerateMode"] isEqualToString:@"pfr"] ||
 590             [preset[@"VideoFrameratePFR"]  intValue] == 1)
 591         {
 592             self.frameRateMode = 0; // we want pfr
 593         }
 594         else
 595         {
 596             self.frameRateMode = 1; // we want cfr
 597         }
 598     }
 599     // map legacy names via libhb.
 600     int intValue = hb_video_framerate_get_from_name([preset[@"VideoFramerate"] UTF8String]);
 601     if (intValue == -1)
 602     {
 603         intValue = 0;
 604     }
 605     self.frameRate = intValue;
 606
 607     // 2 Pass Encoding.
 608     self.twoPass = [preset[@"VideoTwoPass"] boolValue];
 609
 610     // Turbo 1st pass for 2 Pass Encoding.
 611     self.turboTwoPass = [preset[@"VideoTurboTwoPass"] boolValue];
 612
 613     self.notificationsEnabled = YES;
 614 }
 615
 616 - (void)writeToPreset:(NSMutableDictionary *)preset
 617 {
 618     preset[@"VideoEncoder"] = @(hb_video_encoder_get_short_name(self.encoder));
 619
 620     if (hb_video_encoder_get_presets(self.encoder) != NULL)
 621     {
 622         preset[@"VideoPreset"]      = self.preset;
 623         preset[@"VideoTune"]        = [self completeTune];
 624         preset[@"VideoOptionExtra"] = self.videoOptionExtra;
 625         preset[@"VideoProfile"]     = self.profile;
 626         preset[@"VideoLevel"]       = self.level;
 627
 628         // x264 Options, this will either be advanced panel or the video tabs x264 presets panel with modded option string
 629         if (self.advancedOptions)
 630         {
 631             // use the old advanced panel.
 632             preset[@"x264UseAdvancedOptions"] = @YES;
 633         }
 634         else
 635         {
 636             preset[@"x264UseAdvancedOptions"] = @NO;
 637         }
 638     }
 639     else
 640     {
 641         // FFmpeg (lavc) Option String
 642         preset[@"VideoOptionExtra"] = self.videoOptionExtra;
 643     }
 644
 645     /* though there are actually only 0 - 1 types available in the ui we need to map to the old 0 - 2
 646      * set of indexes from when we had 0 == Target , 1 == Abr and 2 == Constant Quality for presets
 647      * to take care of any legacy presets. */
 648     preset[@"VideoQualityType"] = @(self.qualityType + 1);
 649     preset[@"VideoAvgBitrate"] = @(self.avgBitrate);
 650     preset[@"VideoQualitySlider"] = @(self.quality);
 651
 652     /* Video framerate and framerate mode */
 653     if (self.frameRateMode == 1)
 654     {
 655         preset[@"VideoFramerateMode"] = @"cfr";
 656     }
 657     if (self.frameRate == 0) // Same as source is selected
 658     {
 659         preset[@"VideoFramerate"] = @"auto";
 660
 661         if (self.frameRateMode == 0)
 662         {
 663             preset[@"VideoFramerateMode"] = @"vfr";
 664         }
 665     }
 666     else // translate the rate (selected item's tag) to the official libhb name
 667     {
 668         preset[@"VideoFramerate"] = [NSString stringWithFormat:@"%s",
 669                                      hb_video_framerate_get_name((int)self.frameRate)];
 670
 671         if (self.frameRateMode == 0)
 672         {
 673             preset[@"VideoFramerateMode"] = @"pfr";
 674         }
 675     }
 676
 677     preset[@"VideoTwoPass"] = @(self.twoPass);
 678     preset[@"VideoTurboTwoPass"] = @(self.turboTwoPass);
 679 }
 680
 681 @end