scripts/manicure.rb

   1 #! /usr/bin/ruby
   2 # manincure.rb version 0.66
   3
   4 # This file is part of the HandBrake source code.
   5 # Homepage: <http://handbrake.m0k.org/>.
   6 # It may be used under the terms of the GNU General Public License.
   7
   8 # This script parses HandBrake's Mac presets into hashes, which can
   9 # be displayed in various formats for use by the CLI and its wrappers.
  10
  11 # For handling command line arguments to the script
  12 require 'optparse'
  13 require 'ostruct'
  14
  15 # CLI options: (code based on http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/index.html )
  16 def readOptions
  17
  18   # --[no-]cli-raw, -r gives raw CLI for wiki
  19   # --cli-parse, -p gives CLI strings for wrappers
  20   # --api, -a gives preset code for test.c
  21   # --api-list, -A gives CLI strings for --preset-list display
  22   # --[no-]header, -h turns off banner display
  23   options = OpenStruct.new
  24   options.cliraw = false
  25   options.cliparse = false
  26   options.api = false
  27   options.apilist = false
  28   options.header = false
  29
  30   opts = OptionParser.new do |opts|
  31     opts.banner = "Usage: manicure.rb [options]"
  32
  33     opts.separator ""
  34     opts.separator "Options:"
  35
  36     opts.on("-r", "--cli-raw", "Gives example strings for the HB wiki") do |raw|
  37       options.cliraw = raw
  38       option_set = true
  39     end
  40
  41     opts.on("-p", "--cli-parse", "Gives presets as wrapper-parseable CLI", " option strings") do |par|
  42       options.cliparse = par
  43     end
  44
  45     opts.on("-a", "--api", "Gives preset code for test.c") do |api|
  46       options.api = api
  47     end
  48
  49     opts.on("-A", "--api-list", "Gives code for test.c's --preset-list", " options") do |alist|
  50       options.apilist = alist
  51     end
  52
  53     opts.on("-H", "--Header", "Display a banner before each preset") do |head|
  54       options.header = head
  55     end
  56
  57     opts.on_tail("-h", "--help", "Show this message") do
  58         puts opts
  59         exit
  60     end
  61   end.parse!
  62
  63   return options
  64
  65 end
  66
  67 # These arrays contain all the other presets and hashes that are going to be used.
  68 # Yeah, they're global variables. In an object-oriented scripting language.
  69 # Real smooth, huh?
  70
  71 # This class parses the user's presets .plist into an array of hashes
  72 class Presets
  73
  74   attr_reader :hashMasterList
  75
  76   # Running initialization runs everything.
  77   # Calling it will also call the parser
  78   # and display output.
  79   def initialize
  80
  81     # Grab input from the user's presets .plist
  82     rawPresets = readPresetPlist
  83
  84     # Store all the presets in here
  85     presetStew = []
  86
  87     # Each item in the array is one line from the .plist
  88     presetStew = rawPresets.split("\n")
  89
  90     # Now get rid of white space
  91     presetStew = cleanStew(presetStew)
  92
  93     # This stores the offsets between presets.
  94     presetBreaks = findPresetBreaks(presetStew)
  95
  96     # Now it's time to use that info to store each
  97     # preset individually, in the master list.
  98     @presetMasterList = []
  99     i = 0
 100     while i <= presetBreaks.size
 101       if i == 0 #first preset
 102         # Grab the stew, up to the 1st offset.
 103         @presetMasterList[i] = presetStew.slice(0..presetBreaks[i].to_i)
 104       elsif i < presetBreaks.size #middle presets
 105         # Grab the stew from the last offset to the current..
 106         @presetMasterList[i] = presetStew.slice(presetBreaks[i-1].to_i..presetBreaks[i].to_i)
 107       else #final preset
 108         # Grab the stew, starting at the last offset, all the way to the end.
 109         @presetMasterList[i] = presetStew.slice(presetBreaks[i-1].to_i..presetStew.length)
 110       end
 111       i += 1
 112     end
 113
 114     # Parse the presets into hashes
 115     @hashMasterList = []
 116
 117     buildPresetHash
 118
 119   end
 120
 121   def readPresetPlist # Grab the .plist and store it in presets
 122
 123     # Grab the user's home path
 124     homeLocation = `echo $HOME`.chomp
 125
 126     # Use that to build a path to the presets .plist
 127     inputFile = homeLocation+'/Library/Application\ Support/HandBrake/UserPresets.plist'
 128
 129     # Builds a command that inputs the .plist, but not before stripping all the XML gobbledygook.
 130     parseCommand = 'cat '+inputFile+' | sed -e \'s/<[a-z]*>//\' -e \'s/<\/[a-z]*>//\'  -e \'/<[?!]/d\' '
 131
 132     puts "\n\n"
 133
 134     # Run the command, return the raw presets
 135     rawPresets = `#{parseCommand}`
 136   end
 137
 138   def cleanStew(presetStew) #remove tabbed white space
 139     presetStew.each do |oneline|
 140       oneline.strip!
 141     end
 142   end
 143
 144   def findPresetBreaks(presetStew) #figure out where each preset starts and ends
 145     i = 0
 146     j = 0
 147     presetBreaks =[]
 148     presetStew.each do |presetLine|
 149       if presetLine =~ /AudioBitRate/ # This is the first line of a new preset.
 150         presetBreaks[j] = i-1         # So mark down how long the last one was.
 151         j += 1
 152       end
 153     i += 1
 154     end
 155     return presetBreaks
 156   end
 157
 158   def buildPresetHash #fill up @hashMasterList with hashes of all key/value pairs
 159     j = 0
 160
 161     # Iterate through all presets, treating each in turn as singleServing
 162     @presetMasterList.each do |singleServing|
 163
 164       # Initialize the hash for preset j (aka singleServing)
 165       @hashMasterList[j] = Hash.new
 166
 167       # Each key and value are on sequential lines.
 168       # Iterating through by twos, use that to build a hash.
 169       # Each key, on line i, paired with its value, on line i+1
 170       i = 1
 171       while i < singleServing.length
 172         @hashMasterList[j].store( singleServing[i],  singleServing[i+1] )
 173         i += 2
 174       end
 175
 176       j += 1
 177     end
 178   end
 179
 180 end
 181
 182 # This class displays the presets to stdout in various formats.
 183 class Display
 184
 185
 186   def initialize(hashMasterList, options)
 187
 188     @hashMasterList = hashMasterList
 189     @options = options
 190
 191     # A width of 40 gives nice, compact output.
 192     @columnWidth=40
 193
 194     # Print to screen.
 195     displayCommandStrings
 196
 197   end
 198
 199   def displayCommandStrings # prints everything to screen
 200
 201     # Iterate through the hashes.
 202     @hashMasterList.each do |hash|
 203
 204       # Check to make there are valid contents
 205       if hash.key?("PresetName")
 206
 207         if @options.header == true
 208           # First throw up a header to make each preset distinct
 209           displayHeader(hash)
 210         end
 211
 212         if @options.cliraw == true
 213           # Show the preset's full CLI string equivalent
 214           generateCLIString(hash)
 215         end
 216
 217         if @options.cliparse == true
 218           generateCLIParse(hash)
 219         end
 220
 221         if @options.api == true
 222           # Show the preset as code for test/test.c, HandBrakeCLI
 223           generateAPIcalls(hash)
 224         end
 225
 226         if @options.apilist == true
 227           # Show the preset as print statements, for CLI wrappers to parse.
 228           generateAPIList(hash)
 229         end
 230       end
 231     end
 232   end
 233
 234   def displayHeader(hash) # A distinct banner to separate each preset
 235
 236     # Print a line of asterisks
 237     puts "*" * @columnWidth
 238
 239     # Print the name, centered
 240     puts '* '+hash["PresetName"].to_s.center(@columnWidth-4)+' *'
 241
 242     # Print a line of dashes
 243     puts '~' * @columnWidth
 244
 245     # Print the description, centered and word-wrapped
 246     puts hash["PresetDescription"].to_s.center(@columnWidth).gsub(/\n/," ").scan(/\S.{0,#{@columnWidth-2}}\S(?=\s|$)|\S+/)
 247
 248     # Print another line of dashes
 249     puts '~' * @columnWidth
 250
 251     # Print the formats the preset uses
 252     puts "#{hash["FileCodecs"]}".center(@columnWidth)
 253
 254     # Note if the preset isn't built-in
 255     if hash["Type"].to_i == 1
 256       puts "Custom Preset".center(@columnWidth)
 257     end
 258
 259     # Note if the preset is marked as default.
 260     if hash["Default"].to_i == 1
 261       puts "This is your default preset.".center(@columnWidth)
 262     end
 263
 264     # End with a line of tildes.
 265     puts "~" * @columnWidth
 266
 267   end
 268
 269   def generateCLIString(hash) # Makes a full CLI equivalent of a preset
 270     commandString = ""
 271     commandString << './HandBrakeCLI -i DVD -o ~/Movies/movie.'
 272
 273     #Filename suffix
 274     case hash["FileFormat"]
 275     when /MP4/
 276       commandString << "mp4 "
 277     when /AVI/
 278       commandString << "avi "
 279     when /OGM/
 280       commandString << "ogm "
 281     when /MKV/
 282       commandString << "mkv "
 283     end
 284
 285     #Video encoder
 286     if hash["VideoEncoder"] != "FFmpeg"
 287       commandString << " -e "
 288       commandString << hash["VideoEncoder"].to_s.downcase
 289     end
 290
 291     #VideoRateControl
 292     case hash["VideoQualityType"].to_i
 293     when 0
 294       commandString << " -S " << hash["VideoTargetSize"]
 295     when 1
 296       commandString << " -b " << hash["VideoAvgBitrate"]
 297     when 2
 298       commandString << " -q " << hash["VideoQualitySlider"]
 299     end
 300
 301     #FPS
 302     if hash["VideoFramerate"] != "Same as source"
 303       if hash["VideoFramerate"] == "23.976 (NTSC Film)"
 304         commandString << " -r " << "23.976"
 305       elsif hash["VideoFramerate"] == "29.97 (NTSC Video)"
 306         commandString << " -r " << "29.97"
 307       else
 308         commandString << " -r " << hash["VideoFramerate"]
 309       end
 310     end
 311
 312     #Audio encoder (only specifiy bitrate and samplerate when not doing AC-3 pass-thru)
 313     commandString << " -E "
 314     case hash["FileCodecs"]
 315     when /AC-3/
 316       commandString << "ac3"
 317     when /AAC/
 318       commandString << "faac" << " -B " << hash["AudioBitRate"] << " -R " << hash["AudioSampleRate"]
 319     when /Vorbis/
 320       commandString << "vorbis" << " -B " << hash["AudioBitRate"] << " -R " << hash["AudioSampleRate"]
 321     when /MP3/
 322       commandString << "lame" << " -B " << hash["AudioBitRate"] << " -R " << hash["AudioSampleRate"]
 323     end
 324
 325     #Container
 326     commandString << " -f "
 327     case hash["FileFormat"]
 328     when /MP4/
 329       commandString << "mp4"
 330     when /AVI/
 331       commandString << "avi"
 332     when /OGM/
 333       commandString << "ogm"
 334     when /MKV/
 335       commandString << "mkv"
 336     end
 337
 338     #iPod MP4 atom
 339     if hash["Mp4iPodCompatible"].to_i == 1
 340       commandString << " -I"
 341     end
 342
 343     #Cropping
 344     if !hash["PictureAutoCrop"].to_i
 345       commandString << " --crop "
 346       commandString << hash["PictureTopCrop"]
 347       commandString << ":"
 348       commandString << hash["PictureBottomCrop"]
 349       commandString << ":"
 350       commandString << hash["PictureLeftCrop"]
 351       commandString << ":"
 352       commandString << hash["PictureRightCrop"]
 353     end
 354
 355     #Dimensions
 356     if hash["PictureWidth"].to_i != 0
 357       commandString << " -w "
 358       commandString << hash["PictureWidth"]
 359     end
 360     if hash["PictureHeight"].to_i != 0
 361       commandString << " -l "
 362       commandString << hash["PictureHeight"]
 363     end
 364
 365     #Subtitles
 366     if hash["Subtitles"] != "None"
 367       commandString << " -s "
 368       commandString << hash["Subtitles"]
 369     end
 370
 371     #Video Filters
 372     if hash["UsesPictureFilters"].to_i == 1
 373
 374       case hash["PictureDeinterlace"].to_i
 375       when 1
 376         commandString << " --deinterlace=\"fast\""
 377       when 2
 378         commandString << " --deinterlace=\slow\""
 379       when 3
 380         commandString << " --deinterlace=\"slower\""
 381       when 4
 382         commandString << " --deinterlace=\"slowest\""
 383       end
 384
 385       case hash["PictureDenoise"].to_i
 386       when 1
 387         commandString << " --denoise=\"weak\""
 388       when 2
 389         commandString << " --denoise=\"medium\""
 390       when 3
 391         commandString << " --denoise=\"strong\""
 392       end
 393
 394       if hash["PictureDetelecine"].to_i == 1 then commandString << " --detelecine" end
 395       if hash["PictureDeblock"].to_i == 1 then commandString << " --deblock" end
 396       if hash["VFR"].to_i == 1 then commandString << " --vfr" end
 397     end
 398
 399     #Booleans
 400     if hash["ChapterMarkers"].to_i == 1 then commandString << " -m" end
 401     if hash["PicturePAR"].to_i == 1 then commandString << " -p" end
 402     if hash["VideoGrayScale"].to_i == 1 then commandString << " -g" end
 403     if hash["VideoTwoPass"].to_i == 1 then commandString << " -2" end
 404     if hash["VideoTurboTwoPass"].to_i == 1 then commandString << " -T" end
 405
 406     #x264 Options
 407     if hash["x264Option"] != ""
 408       commandString << " -x "
 409       commandString << hash["x264Option"]
 410     end
 411
 412     # That's it, print to screen now
 413     puts commandString
 414
 415     #puts "*" * @columnWidth
 416
 417     puts  "\n"
 418   end
 419
 420   def generateCLIParse(hash) # Makes a CLI equivalent of all user presets, for wrappers to parse
 421     commandString = ""
 422     commandString << '+ ' << hash["PresetName"] << ":"
 423
 424     #Video encoder
 425     if hash["VideoEncoder"] != "FFmpeg"
 426       commandString << " -e "
 427       commandString << hash["VideoEncoder"].to_s.downcase
 428     end
 429
 430     #VideoRateControl
 431     case hash["VideoQualityType"].to_i
 432     when 0
 433       commandString << " -S " << hash["VideoTargetSize"]
 434     when 1
 435       commandString << " -b " << hash["VideoAvgBitrate"]
 436     when 2
 437       commandString << " -q " << hash["VideoQualitySlider"]
 438     end
 439
 440     #FPS
 441     if hash["VideoFramerate"] != "Same as source"
 442       if hash["VideoFramerate"] == "23.976 (NTSC Film)"
 443         commandString << " -r " << "23.976"
 444       elsif hash["VideoFramerate"] == "29.97 (NTSC Video)"
 445         commandString << " -r " << "29.97"
 446       else
 447         commandString << " -r " << hash["VideoFramerate"]
 448       end
 449     end
 450
 451     #Audio encoder (only include bitrate and samplerate when not doing AC3 passthru)
 452     commandString << " -E "
 453     case hash["FileCodecs"]
 454     when /AC-3/
 455       commandString << "ac3"
 456     when /AAC/
 457       commandString << "faac" << " -B " << hash["AudioBitRate"] << " -R " << hash["AudioSampleRate"]
 458     when /Vorbis/
 459       commandString << "vorbis" << " -B " << hash["AudioBitRate"] << " -R " << hash["AudioSampleRate"]
 460     when /MP3/
 461       commandString << "lame" << " -B " << hash["AudioBitRate"] << " -R " << hash["AudioSampleRate"]
 462     end
 463
 464     #Container
 465     commandString << " -f "
 466     case hash["FileFormat"]
 467     when /MP4/
 468       commandString << "mp4"
 469     when /AVI/
 470       commandString << "avi"
 471     when /OGM/
 472       commandString << "ogm"
 473     when /MKV/
 474       commandString << "mkv"
 475     end
 476
 477     #iPod MP4 atom
 478     if hash["Mp4iPodCompatible"].to_i == 1
 479       commandString << " -I"
 480     end
 481
 482     #Cropping
 483     if !hash["PictureAutoCrop"].to_i
 484       commandString << " --crop "
 485       commandString << hash["PictureTopCrop"]
 486       commandString << ":"
 487       commandString << hash["PictureBottomCrop"]
 488       commandString << ":"
 489       commandString << hash["PictureLeftCrop"]
 490       commandString << ":"
 491       commandString << hash["PictureRightCrop"]
 492     end
 493
 494     #Dimensions
 495     if hash["PictureWidth"].to_i != 0
 496       commandString << " -w "
 497       commandString << hash["PictureWidth"]
 498     end
 499     if hash["PictureHeight"].to_i != 0
 500       commandString << " -l "
 501       commandString << hash["PictureHeight"]
 502     end
 503
 504     #Subtitles
 505     if hash["Subtitles"] != "None"
 506       commandString << " -s "
 507       commandString << hash["Subtitles"]
 508     end
 509
 510     #Video Filters
 511     if hash["UsesPictureFilters"].to_i == 1
 512
 513       case hash["PictureDeinterlace"].to_i
 514       when 1
 515         commandString << " --deinterlace=\"fast\""
 516       when 2
 517         commandString << " --deinterlace=\slow\""
 518       when 3
 519         commandString << " --deinterlace=\"slower\""
 520       when 4
 521         commandString << " --deinterlace=\"slowest\""
 522       end
 523
 524       case hash["PictureDenoise"].to_i
 525       when 1
 526         commandString << " --denoise=\"weak\""
 527       when 2
 528         commandString << " --denoise=\"medium\""
 529       when 3
 530         commandString << " --denoise=\"strong\""
 531       end
 532
 533       if hash["PictureDetelecine"].to_i == 1 then commandString << " --detelecine" end
 534       if hash["PictureDeblock"].to_i == 1 then commandString << " --deblock" end
 535       if hash["VFR"].to_i == 1 then commandString << " --vfr" end
 536     end
 537
 538     #Booleans
 539     if hash["ChapterMarkers"].to_i == 1 then commandString << " -m" end
 540     if hash["PicturePAR"].to_i == 1 then commandString << " -p" end
 541     if hash["VideoGrayScale"].to_i == 1 then commandString << " -g" end
 542     if hash["VideoTwoPass"].to_i == 1 then commandString << " -2" end
 543     if hash["VideoTurboTwoPass"].to_i == 1 then commandString << " -T" end
 544
 545     #x264 Options
 546     if hash["x264Option"] != ""
 547       commandString << " -x "
 548       commandString << hash["x264Option"]
 549     end
 550
 551     # That's it, print to screen now
 552     puts commandString
 553
 554     #puts "*" * @columnWidth
 555
 556     puts  "\n"
 557   end
 558
 559   def generateAPIcalls(hash) # Makes a C version of the preset ready for coding into the CLI
 560
 561     commandString = "if (!strcmp(preset_name, \"" << hash["PresetName"] << "\"))\n{\n    "
 562
 563     #Filename suffix
 564     case hash["FileFormat"]
 565     when /MP4/
 566       commandString << "mux = " << "HB_MUX_MP4;\n    "
 567     when /AVI/
 568       commandString << "mux = " << "HB_MUX_AVI;\n    "
 569     when /OGM/
 570       commandString << "mux = " << "HB_MUX_OGM;\n    "
 571     when /MKV/
 572       commandString << "mux = " << "HB_MUX_MKV;\n    "
 573     end
 574
 575     #iPod MP4 atom
 576     if hash["Mp4iPodCompatible"].to_i == 1
 577       commandString << "job->ipod_atom = 1;\n   "
 578     end
 579
 580     #Video encoder
 581     if hash["VideoEncoder"] != "FFmpeg"
 582       commandString << "vcodec = "
 583       if hash["VideoEncoder"] == "x264"
 584         commandString << "HB_VCODEC_X264;\n    "
 585       elsif hash["VideoEncoder"].to_s.downcase == "xvid"
 586         commandString << "HB_VCODEC_XVID;\n    "
 587       end
 588     end
 589
 590     #VideoRateControl
 591     case hash["VideoQualityType"].to_i
 592     when 0
 593       commandString << "size = " << hash["VideoTargetSize"] << ";\n    "
 594     when 1
 595       commandString << "job->vbitrate = " << hash["VideoAvgBitrate"] << ";\n    "
 596     when 2
 597       commandString << "job->vquality = " << hash["VideoQualitySlider"] << ";\n    "
 598       commandString << "job->crf = 1;\n    "
 599     end
 600
 601     #FPS
 602     if hash["VideoFramerate"] != "Same as source"
 603       if hash["VideoFramerate"] == "23.976 (NTSC Film)"
 604         commandString << "job->vrate_base = " << "1126125;\n    "
 605       elsif hash["VideoFramerate"] == "29.97 (NTSC Video)"
 606         commandString << "job->vrate_base = " << "900900;\n    "
 607       # Gotta add the rest of the framerates for completion's sake.
 608       end
 609     end
 610
 611     # Only include samplerate and bitrate when not performing AC3 passthru
 612     if (hash["FileCodecs"].include? "AC-3") == false
 613       #Audio bitrate
 614       commandString << "job->abitrate = " << hash["AudioBitRate"] << ";\n    "
 615
 616       #Audio samplerate
 617       commandString << "job->arate = "
 618       case hash["AudioSampleRate"]
 619       when /48/
 620         commandString << "48000"
 621       when /44.1/
 622         commandString << "44100"
 623       when /32/
 624         commandString << "32000"
 625       when /24/
 626         commandString << "24000"
 627       when /22.05/
 628         commandString << "22050"
 629       end
 630       commandString << ";\n    "
 631     end
 632
 633     #Audio encoder
 634     commandString << "acodec = "
 635     case hash["FileCodecs"]
 636     when /AAC/
 637       commandString << "HB_ACODEC_FAAC;\n    "
 638     when /AC-3/
 639       commandString << "HB_ACODEC_AC3;\n    "
 640     when /Vorbis/
 641       commandString << "HB_ACODEC_VORBIS;\n    "
 642     when /MP3/
 643       commandString << "HB_ACODEC_LAME;\n    "
 644     end
 645
 646     #Cropping
 647     if !hash["PictureAutoCrop"].to_i
 648       commandString << "job->crop[0] = " << hash["PictureTopCrop"] << ";\n    "
 649       commandString << "job->crop[1] = " << hash["PictureBottomCrop"] << ";\n    "
 650       commandString << "job->crop[2] = " << hash["PictureLeftCrop"] << ";\n    "
 651       commandString << "job->crop[4] - " << hash["PictureRightCrop"] << ";\n    "
 652     end
 653
 654     #Dimensions
 655     if hash["PictureWidth"].to_i != 0
 656       commandString << "job->width = "
 657       commandString << hash["PictureWidth"] << ";\n    "
 658     end
 659     if hash["PictureHeight"].to_i != 0
 660       commandString << "job->height = "
 661       commandString << hash["PictureHeight"] << ";\n    "
 662     end
 663
 664     #Subtitles
 665     if hash["Subtitles"] != "None"
 666       commandString << "job->subtitle = "
 667       commandString << ( hash["Subtitles"].to_i - 1).to_s << ";\n    "
 668     end
 669
 670     #x264 Options
 671     if hash["x264Option"] != ""
 672       commandString << "x264opts = strdup(\""
 673       commandString << hash["x264Option"] << "\");\n    "
 674     end
 675
 676     #Video Filters
 677     if hash["UsesPictureFilters"].to_i == 1
 678
 679       case hash["PictureDeinterlace"].to_i
 680       when 1
 681         commandString << "deinterlace = 1;\n    "
 682         commandString << "deinterlace_opt = \"-1\";\n    "
 683       when 2
 684         commandString << "deinterlace = 1;\n    "
 685         commandString << "deinterlace_opt = \"0\";\n    "
 686       when 3
 687         commandString << "deinterlace = 1;\n    "
 688         commandString << "deinterlace_opt = \"2:-1:1\";\n    "
 689       when 4
 690         commandString << "deinterlace = 1;\n    "
 691         commandString << "deinterlace_opt = \"1:-1:1\";\n    "
 692       end
 693
 694       case hash["PictureDenoise"].to_i
 695       when 1
 696         commandString << "denoise = 1;\n    "
 697         commandString << "denoise_opt = \"2:1:2:3\";\n    "
 698       when 2
 699         commandString << "denoise = 1;\n    "
 700         commandString << "denoise_opt = \"3:2:2:3\";\n    "
 701       when 3
 702         commandString << "denoise = 1;\n    "
 703         commandString << "denoise_opt = \"7:7:5:5\";\n    "
 704       end
 705
 706       if hash["PictureDetelecine"].to_i == 1 then commandString << "detelecine = 1;\n    " end
 707       if hash["PictureDeblock"].to_i == 1 then commandString << "deblock = 1;\n    " end
 708       if hash["VFR"].to_i == 1 then commandString << "vfr = 1;\n    " end
 709     end
 710
 711     #Booleans
 712     if hash["ChapterMarkers"].to_i == 1 then commandString << "job->chapter_markers = 1;\n    " end
 713     if hash["PicturePAR"].to_i == 1 then commandString << "pixelratio = 1;\n    " end
 714     if hash["VideoGrayScale"].to_i == 1 then commandString << "job->grayscale = 1;\n    " end
 715     if hash["VideoTwoPass"].to_i == 1 then commandString << "twoPass = 1;\n    " end
 716     if hash["VideoTurboTwoPass"].to_i == 1 then commandString << "turbo_opts_enabled = 1;\n" end
 717
 718     commandString << "}"
 719
 720     # That's it, print to screen now
 721     puts commandString
 722     #puts "*" * @columnWidth
 723     puts  "\n"
 724   end
 725
 726   def generateAPIList(hash) # Makes a list of the CLI options a built-in CLI preset uses, for wrappers to parse
 727     commandString = ""
 728     commandString << "    printf(\"\\n+ " << hash["PresetName"] << ": "
 729
 730     #Video encoder
 731     if hash["VideoEncoder"] != "FFmpeg"
 732       commandString << " -e "
 733       commandString << hash["VideoEncoder"].to_s.downcase
 734     end
 735
 736     #VideoRateControl
 737     case hash["VideoQualityType"].to_i
 738     when 0
 739       commandString << " -S " << hash["VideoTargetSize"]
 740     when 1
 741       commandString << " -b " << hash["VideoAvgBitrate"]
 742     when 2
 743       commandString << " -q " << hash["VideoQualitySlider"]
 744     end
 745
 746     #FPS
 747     if hash["VideoFramerate"] != "Same as source"
 748       if hash["VideoFramerate"] == "23.976 (NTSC Film)"
 749         commandString << " -r " << "23.976"
 750       elsif hash["VideoFramerate"] == "29.97 (NTSC Video)"
 751         commandString << " -r " << "29.97"
 752       else
 753         commandString << " -r " << hash["VideoFramerate"]
 754       end
 755     end
 756
 757     # Only include samplerate and bitrate when not performing AC-3 passthru
 758     if (hash["FileCodecs"].include? "AC-3") == false
 759       #Audio bitrate
 760       commandString << " -B " << hash["AudioBitRate"]
 761       #Audio samplerate
 762       commandString << " -R " << hash["AudioSampleRate"]
 763     end
 764
 765     #Audio encoder
 766     commandString << " -E "
 767     case hash["FileCodecs"]
 768     when /AAC/
 769       commandString << "faac"
 770     when /AC-3/
 771       commandString << "ac3"
 772     when /Vorbis/
 773       commandString << "vorbis"
 774     when /MP3/
 775       commandString << "lame"
 776     end
 777
 778     #Container
 779     commandString << " -f "
 780     case hash["FileFormat"]
 781     when /MP4/
 782       commandString << "mp4"
 783     when /AVI/
 784       commandString << "avi"
 785     when /OGM/
 786       commandString << "ogm"
 787     when /MKV/
 788       commandString << "mkv"
 789     end
 790
 791     #iPod MP4 atom
 792     if hash["Mp4iPodCompatible"].to_i == 1
 793       commandString << " -I"
 794     end
 795
 796     #Cropping
 797     if !hash["PictureAutoCrop"].to_i
 798       commandString << " --crop "
 799       commandString << hash["PictureTopCrop"]
 800       commandString << ":"
 801       commandString << hash["PictureBottomCrop"]
 802       commandString << ":"
 803       commandString << hash["PictureLeftCrop"]
 804       commandString << ":"
 805       commandString << hash["PictureRightCrop"]
 806     end
 807
 808     #Dimensions
 809     if hash["PictureWidth"].to_i != 0
 810       commandString << " -w "
 811       commandString << hash["PictureWidth"]
 812     end
 813     if hash["PictureHeight"].to_i != 0
 814       commandString << " -l "
 815       commandString << hash["PictureHeight"]
 816     end
 817
 818     #Subtitles
 819     if hash["Subtitles"] != "None"
 820       commandString << " -s "
 821       commandString << hash["Subtitles"]
 822     end
 823
 824     #Video Filters
 825     if hash["UsesPictureFilters"].to_i == 1
 826
 827       case hash["PictureDeinterlace"].to_i
 828       when 1
 829         commandString << " --deinterlace=\\\"fast\\\""
 830       when 2
 831         commandString << " --deinterlace=\\\slow\\\""
 832       when 3
 833         commandString << " --deinterlace=\\\"slower\\\""
 834       when 4
 835         commandString << " --deinterlace=\\\"slowest\\\""
 836       end
 837
 838       case hash["PictureDenoise"].to_i
 839       when 1
 840         commandString << " --denoise=\\\"weak\\\""
 841       when 2
 842         commandString << " --denoise=\\\"medium\\\""
 843       when 3
 844         commandString << " --denoise=\\\"strong\\\""
 845       end
 846
 847       if hash["PictureDetelecine"].to_i == 1 then commandString << " --detelecine" end
 848       if hash["PictureDeblock"].to_i == 1 then commandString << " --deblock" end
 849       if hash["VFR"].to_i == 1 then commandString << " --vfr" end
 850     end
 851
 852     #Booleans
 853     if hash["ChapterMarkers"].to_i == 1 then commandString << " -m" end
 854     if hash["PicturePAR"].to_i == 1 then commandString << " -p" end
 855     if hash["VideoGrayScale"].to_i == 1 then commandString << " -g" end
 856     if hash["VideoTwoPass"].to_i == 1 then commandString << " -2" end
 857     if hash["VideoTurboTwoPass"].to_i == 1 then commandString << " -T" end
 858
 859       #x264 Options
 860       if hash["x264Option"] != ""
 861         commandString << " -x "
 862         commandString << hash["x264Option"]
 863       end
 864
 865     commandString << "\\n\");"
 866
 867     # That's it, print to screen now
 868     puts commandString
 869     puts  "\n"
 870   end
 871
 872 end
 873
 874 # First grab the specified CLI options
 875 options = readOptions
 876
 877 # Only run if one of the useful CLI flags have been passed
 878 if options.cliraw == true || options.cliparse == true || options.api == true || options.apilist == true
 879   # This line is the ignition -- generates hashes of
 880   # presets and then displays them to the screen
 881   # with the options the user selects on the CLI.
 882   Display.new( Presets.new.hashMasterList, options )
 883 else
 884   # Direct the user to the help
 885   puts "\n\tUsage: manicure.rb [options]"
 886   puts "\tSee help with -h or --help"
 887 end