media_processing_tool 1.0.0

data/lib/mig/http.rb

@@ -0,0 +1,54 @@
+require 'json'
+require 'sinatra/base'
+
+class MediaInformationGatherer
+
+  class HTTP < Sinatra::Base
+    enable :logging
+    disable :protection
+
+    # Will try to convert a body to parameters and merge them into the params hash
+    # Params will override the body parameters
+    #
+    # @params [Hash] _params (params) The parameters parsed from the query and form fields
+    def merge_params_from_body(_params = params)
+      _params = _params.dup
+      if request.media_type == 'application/json'
+        request.body.rewind
+        body_contents = request.body.read
+        logger.debug { "Parsing: '#{body_contents}'" }
+        if body_contents
+          json_params = JSON.parse(body_contents)
+          if json_params.is_a?(Hash)
+            _params = json_params.merge(_params)
+          else
+            _params['body'] = json_params
+          end
+        end
+      end
+      _params
+    end # merge_params_from_body
+
+
+    post '/' do
+      logger.level = Logger::DEBUG
+      _params = merge_params_from_body
+      logger.debug { "Params: #{_params}" }
+      #return params
+
+      response = { }
+      file_paths = _params['file_paths']
+      [*file_paths].each do |file_path|
+        begin
+          response[file_path] = settings.mig.run(file_path)
+        rescue => e
+          response[file_path] = {:exception => {:message => e.message, :backtrace => e.backtrace}}
+        end
+      end
+      content_type :json
+      JSON.generate(response)
+    end # post '/'
+
+  end # HTTP
+
+end # MediaInformationGatherer

data/lib/mig/modules/common.rb

@@ -0,0 +1,333 @@
+require 'time'
+
+class MediaInformationGatherer
+
+  class Common
+
+    STANDARD_VIDEO_FRAME_RATES = [ 23.97, 23.976, 24.0, 24.97, 24.975, 25.0, 29.97, 30.0, 50.0, 59.94, 60.0 ]
+
+    def self.common_variables(metadata_sources)
+      new.common_variables(metadata_sources)
+    end
+
+    def metadata_sources; @metadata_sources || { } end
+    def ffmpeg; @ffmpeg ||= metadata_sources[:ffmpeg] || { } end
+    def mediainfo; @mediainfo ||= metadata_sources[:mediainfo] || { 'section_type_count' => { 'audio' => 0 } } end
+    def stat; @stat ||= metadata_sources[:stat] || { } end
+    def cv; @cv ||= { } end
+
+    def common_variables(_metadata_sources)
+      @metadata_sources = _metadata_sources.dup
+      @cv = { }
+
+      file_path = ffmpeg['path']
+      source_directory = file_path ? File.dirname(File.expand_path(file_path)) : ''
+      creation_date_time = Time.parse(ffmpeg['creation_time']).strftime('%B %d, %Y %r') rescue ffmpeg['creation_time']
+
+      cv[:file_path] = file_path
+      cv[:source_directory] = source_directory
+      cv[:creation_date_time] = creation_date_time
+      cv[:ctime] = stat[:ctime]
+      cv[:mtime] = stat[:mtime]
+      cv[:bytes] = stat[:size]
+      cv[:size] = (mediainfo['General'] || { })['File size']
+      cv[:uid] = stat[:uid]
+      cv[:gid] = stat[:gid]
+      cv[:ftype] = stat[:ftype]
+
+      type = :video # Need to figure out where to determine the type from
+      case type #.to_s.downcase.to_sym
+        when :video
+          common_audio_variables
+          common_video_variables
+        when :audio
+          common_audio_variables
+        when :image
+          common_image_variables
+        else
+          # What else is there?
+      end
+      if RUBY_VERSION.start_with?('1.8.')
+        Hash[cv.map { |a| [ a[0].to_s, a[1] ] }.sort.map { |a| [ a[0].to_sym, a[1] ] }]
+      else
+        Hash[cv.sort]
+      end
+    end # common_variables
+
+    def common_audio_variables
+      mi_audio = mediainfo['Audio'] || { }
+      mi_audio = { } unless mi_audio.is_a?(Hash)
+
+      duration = ffmpeg['duration']
+      if duration
+        dl = duration
+        dlh = dl / 3600
+        dl %= 3600
+        dlm = dl / 60
+        dl %= 60
+        duration_long = sprintf('%02d:%02d:%02d', dlh, dlm, dl)
+      else
+        duration_long = '00:00:00'
+      end
+      section_type_counts = mediainfo['section_type_counts'] || { }
+      audio_track_count = section_type_counts['audio']
+
+      cv[:audio_codec_id] = mi_audio['Codec ID']
+      cv[:audio_sample_rate] = ffmpeg['audio_sample_rate']
+      cv[:duration] = duration
+      cv[:duration_long] = duration_long
+      cv[:number_of_audio_tracks] = audio_track_count # Determine the number of audio channels
+      cv[:number_of_audio_channels] = ffmpeg['audio_channel_count']
+
+    end # common_audio_variables
+
+    # @return [Fixed]
+    def aspect_from_dimensions(height, width)
+      aspect = width.to_f / height.to_f
+      aspect.nan? ? nil : aspect
+    end
+
+    # Determines if the aspect from dimensions is widescreen (>= 1.5 (3/2)
+    # 1.55 is derived from the following tables
+    #   {http://en.wikipedia.org/wiki/Storage_Aspect_Ratio#Previous_and_currently_used_aspect_ratios Aspect Ratios}
+    #   {http://en.wikipedia.org/wiki/List_of_common_resolutions#Television}
+    #
+    # 1.55:1 (14:9): Widescreen aspect ratio sometimes used in shooting commercials etc. as a compromise format
+    # between 4:3 (12:9) and 16:9. When converted to a 16:9 frame, there is slight pillarboxing, while conversion to
+    # 4:3 creates slight letterboxing. All widescreen content on ABC Family's SD feed is presented in this ratio.
+    #
+    # @return [Boolean]
+    def is_widescreen?(height, width)
+      _aspect_from_dimensions = aspect_from_dimensions(height, width)
+      (_aspect_from_dimensions ? (_aspect_from_dimensions >= 1.55) : false)
+    end
+
+    # (@link http://en.wikipedia.osrg/wiki/List_of_common_resolution)
+    #
+    # Lowest Width High Resolution Format Found:
+    #   Panasonic DVCPRO100 for 50/60Hz over 720p - SMPTE Resolution = 960x720
+    #
+    # @return [Boolean]
+    def is_high_definition?(height, width)
+      (width.respond_to?(:to_i) and height.respond_to?(:to_i)) ? (width.to_i >= 950 and height.to_i >= 700) : false
+    end
+
+
+    def common_image_variables
+
+    end # common_image_variables
+
+    def common_video_variables
+      mi_video = mediainfo['Video'] || { }
+      #return unless ffmpeg['video_stream'] or !mi_video.empty?
+
+      frame_rate = ffmpeg['frame_rate']
+      frame_rate ||= mi_video['Frame rate'].respond_to?(:to_f) ? mi_video['Frame rate'].to_f : mi_video['Frame rate']
+
+      height = ffmpeg['height'] || mi_video['Height']
+      width = ffmpeg['width'] || mi_video['Width']
+
+      is_widescreen = ffmpeg['is_widescreen']
+      is_widescreen ||= is_widescreen?(height, width) if is_widescreen.nil?
+
+      is_high_definition = is_high_definition?(height, width)
+
+      calculated_aspect_ratio = ffmpeg['calculated_aspect_ratio'] || (height.respond_to?(:to_f) and width.respond_to?(:to_f) ? (width.to_f / height.to_f) : nil)
+
+      video_codec_id = mi_video['Codec ID']
+      video_codec_description = video_codec_descriptions.fetch(video_codec_id, 'Unknown')
+
+      video_system = determine_video_system(height, width, frame_rate)
+
+      #aspect_ratio = ffmpeg['video_stream'] ? (ffmpeg['is_widescreen'] ? '16:9' : '4:3') : nil
+      if ffmpeg['video_stream']
+        aspect_ratio = ffmpeg['is_widescreen'] ? '16:9' : '4:3'
+      else
+        aspect_ratio = nil
+      end
+
+      cv[:aspect_ratio] = aspect_ratio
+      cv[:bit_depth] = mi_video['Bit depth']
+      cv[:calculated_aspect_ratio] = calculated_aspect_ratio
+      cv[:chroma_subsampling] = mi_video['Chroma subsampling']
+      cv[:display_aspect_ratio] = ffmpeg['display_aspect_ratio']
+      cv[:frames_per_second] = frame_rate # Video frames per second
+      cv[:height] = height
+      cv[:is_high_definition] = is_high_definition # Determine if video is Standard Def or High Definition
+      cv[:is_widescreen] = is_widescreen
+      cv[:pixel_aspect_ratio] = ffmpeg['pixel_aspect_ratio']
+      cv[:resolution] = ffmpeg['resolution']
+      cv[:scan_order] = mi_video['Scan order']
+      cv[:scan_type] = mi_video['Scan type']
+      cv[:storage_aspect_ratio] = ffmpeg['storage_aspect_ratio']
+      cv[:timecode] = ffmpeg['timecode']
+      cv[:video_codec_id] = video_codec_id
+      cv[:video_codec_commercial_name] = mi_video['Commercial name']
+      cv[:video_codec_description] = video_codec_description
+      cv[:video_system] = video_system
+      cv[:width] = width
+      cv
+    end # common_video_variables
+
+    # A hash of fourcc codes
+    # http://www.videolan.org/developers/vlc/src/misc/fourcc.c
+    def fourcc_codes
+      @fourcc_codes ||= {
+          '2vuy' => 'Apple FCP Uncompressed 8-bit 4:2:2',
+          'v210' => 'Apple FCP Uncompressed 10-bit 4:2:2',
+          'apcn' => 'Apple ProRes Standard',
+          'apch' => 'Apple ProRes High Quality (HQ)',
+          'apcs' => 'Apple ProRes LT',
+          'apco' => 'Apple ProRes Proxy',
+          'ap4c' => 'Apple ProRes 4444',
+          'ap4h' => 'Apple ProRes 4444',
+          'xdv1' => 'XDCAM HD 720p30 35Mb/s',
+          'xdv2' => 'XDCAM HD 1080i60 35Mb/s',
+          'xdv3' => 'XDCAM HD 1080i50 35Mb/s',
+          'xdv4' => 'XDCAM HD 720p24 35Mb/s',
+          'xdv5' => 'XDCAM HD 720p25 35Mb/s',
+          'xdv6' => 'XDCAM HD 1080p24 35Mb/s',
+          'xdv7' => 'XDCAM HD 1080p25 35Mb/s',
+          'xdv8' => 'XDCAM HD 1080p30 35Mb/s',
+          'xdv9' => 'XDCAM HD 720p60 35Mb/s',
+          'xdva' => 'XDCAM HD 720p50 35Mb/s',
+          'xdhd' => 'XDCAM HD 540p',
+          'xdh2' => 'XDCAM HD422 540p',
+          'xdvb' => 'XDCAM EX 1080i60 50Mb/s CBR',
+          'xdvc' => 'XDCAM EX 1080i50 50Mb/s CBR',
+          'xdvd' => 'XDCAM EX 1080p24 50Mb/s CBR',
+          'xdve' => 'XDCAM EX 1080p25 50Mb/s CBR',
+          'xdvf' => 'XDCAM EX 1080p30 50Mb/s CBR',
+          'xd54' => 'XDCAM HD422 720p24 50Mb/s CBR',
+          'xd55' => 'XDCAM HD422 720p25 50Mb/s CBR',
+          'xd59' => 'XDCAM HD422 720p60 50Mb/s CBR',
+          'xd5a' => 'XDCAM HD422 720p50 50Mb/s CBR',
+          'xd5b' => 'XDCAM HD422 1080i60 50Mb/s CBR',
+          'xd5c' => 'XDCAM HD422 1080i50 50Mb/s CBR',
+          'xd5d' => 'XDCAM HD422 1080p24 50Mb/s CBR',
+          'xd5e' => 'XDCAM HD422 1080p25 50Mb/s CBR',
+          'xd5f' => 'XDCAM HD422 1080p30 50Mb/s CBR',
+          'dvh2' => 'DV Video 720p24',
+          'dvh3' => 'DV Video 720p25',
+          'dvh4' => 'DV Video 720p30',
+          'dvcp' => 'DV Video PAL',
+          'dvc'  => 'DV Video NTSC',
+          'dvp'  => 'DV Video Pro',
+          'dvpp' => 'DV Video Pro PAL',
+          'dv50' => 'DV Video C Pro 50',
+          'dv5p' => 'DV Video C Pro 50 PAL',
+          'dv5n' => 'DV Video C Pro 50 NTSC',
+          'dv1p' => 'DV Video C Pro 100 PAL',
+          'dv1n' => 'DV Video C Pro 100 NTSC',
+          'dvhp' => 'DV Video C Pro HD 720p',
+          'dvh5' => 'DV Video C Pro HD 1080i50',
+          'dvh6' => 'DV Video C Pro HD 1080i60',
+          'AVdv' => 'AVID DV',
+          'AVd1' => 'MPEG2 I',
+          'mx5n' => 'MPEG2 IMX NTSC 625/60 50Mb/s (FCP)',
+          'mx5p' => 'MPEG2 IMX PAL 525/50 50Mb/s (FCP',
+          'mx4n' => 'MPEG2 IMX NTSC 625/60 40Mb/s (FCP)',
+          'mx4p' => 'MPEG2 IMX PAL 525/50 40Mb/s (FCP',
+          'mx3n' => 'MPEG2 IMX NTSC 625/60 30Mb/s (FCP)',
+          'mx3p' => 'MPEG2 IMX PAL 525/50 30Mb/s (FCP)',
+          'hdv1' => 'HDV 720p30',
+          'hdv2' => 'HDV 1080i60',
+          'hdv3' => 'HDV 1080i50',
+          'hdv4' => 'HDV 720p24',
+          'hdv5' => 'HDV 720p25',
+          'hdv6' => 'HDV 1080p24',
+          'hdv7' => 'HDV 1080p25',
+          'hdv8' => 'HDV 1080p30',
+          'hdv9' => 'HDV 720p60',
+          'hdva' => 'HDV 720p50',
+          'avc1' => 'AVC-Intra',
+          'ai5p' => 'AVC-Intra  50M 720p25/50',
+          'ai5q' => 'AVC-Intra  50M 1080p25/50',
+          'ai52' => 'AVC-Intra  50M 1080p24/30',
+          'ai53' => 'AVC-Intra  50M 1080i50',
+          'ai55' => 'AVC-Intra  50M 1080i60',
+          'ai56' => 'AVC-Intra 100M 720p24/30',
+          'ai1p' => 'AVC-Intra 100M 720p25/50',
+          'ai1q' => 'AVC-Intra 100M 1080p25/50',
+          'ai12' => 'AVC-Intra 100M 1080p24/30',
+          'ai13' => 'AVC-Intra 100M 1080i50',
+          'ai15' => 'AVC-Intra 100M 1080i60',
+          'ai16' => 'AVC-Intra 100M 1080i60',
+          'mpgv' => 'MPEG-2',
+          'mp1v' => 'MPEG-2',
+          'mpeg' => 'MPEG-2',
+          'mpg1' => 'MPEG-2',
+          'mp2v' => 'MPEG-2',
+          'MPEG' => 'MPEG-2',
+          'mpg2' => 'MPEG-2',
+          'MPG2' => 'MPEG-2',
+          'H262' => 'MPEG-2',
+          'mjpg' => 'Motion JPEG',
+          'mJPG' => 'Motion JPEG',
+          'mjpa' => 'Motion JPEG',
+          'JPEG' => 'Motion JPEG',
+          'AVRn' => 'Avid Motion JPEG',
+          'AVRn' => 'Avid Motion JPEG',
+          'AVDJ' => 'Avid Motion JPEG',
+          'ADJV' => 'Avid Motion JPEG',
+          'wvc1' => 'Microsoft VC-1',
+          'vc-1' => 'Microsoft VC-1',
+          'VC-1' => 'Microsoft VC-1',
+          'jpeg' => 'Photo JPEG',
+      }
+    end # fourcc_codes
+
+    def video_codec_descriptions
+      @video_codec_descriptions ||= fourcc_codes.merge({
+        27 => 'MPEG-TS',
+      })
+    end
+
+    def determine_video_system(height, width, frame_rate)
+      # http://en.wikipedia.org/wiki/Broadcast_television_system
+      # http://en.wikipedia.org/wiki/Standard-definition_television#Resolution
+      # http://en.wikipedia.org/wiki/Pixel_aspect_ratio
+      # http://www.bambooav.com/ntsc-and-pal-video-standards.html
+      # Programmer's Guide to Video Systems - http://lurkertech.com/lg/video-systems/#fields
+
+      # PAL = 25fps Standard: 768x576  Widescreen: 1024x576
+      # NTSC = 29.97fps Standard: 720x540  Widescreen: 854x480
+      video_system = 'unknown'
+
+      return video_system unless height and width and frame_rate
+
+      frame_rate = frame_rate.to_f
+      return video_system unless STANDARD_VIDEO_FRAME_RATES.include?(frame_rate)
+
+      height = height.to_i
+      width = width.to_i
+
+      # The following case statement is based off of - http://images.apple.com/finalcutpro/docs/Apple_ProRes_White_Paper_October_2012.pdf
+      case height
+        when 480, 486, 512
+          case width
+            when 720, 848, 854
+              video_system = 'NTSC'
+          end
+        when 576, 608
+          case width
+            when 720
+              video_system = 'PAL'
+          end
+        when 720
+          case width
+            when 960, 1280
+              video_system = 'HD'
+          end
+        when 1080
+          case width
+            when 1280, 1440, 1920
+              video_system = 'HD'
+          end
+      end # case height
+      video_system
+    end # determine_video_system
+
+  end # Common
+
+end # MediaInformationGatherer

data/lib/mig/modules/exiftool.rb

@@ -0,0 +1,26 @@
+require 'json'
+require 'shellwords'
+class MediaInformationGatherer
+
+class ExifTool
+
+  DEFAULT_EXECUTABLE_PATH = 'exiftool'
+
+  def initialize(options = { })
+    #@logger = options[:logger] || Logger.new(STDOUT)
+    @exiftool_cmd_path = options.fetch(:exiftool_cmd_path, DEFAULT_EXECUTABLE_PATH)
+  end # initialize
+  
+  # @param [String] file_path
+  # @param [Hash] options
+  def run(file_path, options = {})
+    cmd_line = [@exiftool_cmd_path, '-json', file_path].shelljoin
+    #@logger.debug { "[ExifTool] Executing command: #{cmd_line}" }
+    metadata_json = %x(#{cmd_line})
+    #@logger.debug { "[ExifTool] Result: #{metadata_json}" }
+    JSON.parse(metadata_json)[0]
+  end # self.run
+  
+end #ExifTool
+
+end

data/lib/mig/modules/ffmpeg.rb

@@ -0,0 +1,225 @@
+require 'open3'
+require 'shellwords'
+require 'time' # unless defined? Time
+
+class MediaInformationGatherer
+class FFMPEG
+
+  DEFAULT_EXECUTABLE_PATH = 'ffmpeg'
+
+  class Movie
+    attr_reader :command, :output,
+                :path, :duration, :time, :bitrate, :rotation, :creation_time,
+                :video_stream, :video_codec, :video_bitrate, :colorspace, :resolution,
+                :dar, :display_aspect_ratio,
+                :sar, :storage_aspect_ratio,
+                :par, :pixel_aspect_ratio,
+                :width, :height, :is_widescreen, :is_high_definition, :calculated_aspect_ratio,
+                :audio_stream, :audio_codec, :audio_bitrate, :audio_sample_rate
+    
+    def initialize(path, options = { })
+      raise Errno::ENOENT, "No such file or directory - '#{path}'" unless File.exists?(path)
+      @path = path
+      
+      #@logger = options.fetch(:logger, Logger.new(STDOUT)) 
+      @ffmpeg_cmd_path = options.fetch(:ffmpeg_cmd_path, FFMPEG::DEFAULT_EXECUTABLE_PATH)
+      
+
+      # ffmpeg will output to stderr
+      @command = [@ffmpeg_cmd_path, '-i', path].shelljoin
+      #@logger.debug { "[FFMPEG] Executing command '#{command}'" }
+      @output = Open3.popen3(command) { |stdin, stdout, stderr| stderr.read }
+      #@logger.debug { "[FFMPEG] Command response: #{@output}" }
+      
+      fix_encoding(@output)
+      
+      @output[/Duration: (\d{2}):(\d{2}):(\d{2}\.\d{2})/]
+      @duration = ($1.to_i*60*60) + ($2.to_i*60) + $3.to_f
+      
+      @output[/start: (\d*\.\d*)/]
+      @time = $1 ? $1.to_f : 0.0
+
+      @output[/creation_time {1,}: {1,}(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})/]
+      @creation_time = $1 ? Time.parse("#{$1}") : nil
+      
+      @output[/bitrate: (\d*)/]
+      @bitrate = $1 ? $1.to_i : nil
+      
+      @output[/rotate\ {1,}:\ {1,}(\d*)/]
+      @rotation = $1 ? $1.to_i : nil
+
+      @output[/Video: (.*)/]
+      @video_stream = $1
+      
+      @output[/Audio: (.*)/]
+      @audio_stream = $1
+      
+      @output[/timecode .* : (.*)/]
+      @timecode = $1
+      
+      if video_stream
+        # Example Strings
+        #
+        #  "dvvideo (dvc  / 0x20637664), 720x480, 28771 kb/s): unspecified pixel format"
+        #  "mpeg2video (4:2:2) (mx5n / 0x6E35786D), yuv422p, 720x512 [SAR 512:405 DAR 16:9], 50084 kb/s, SAR 40:33 DAR 75:44, 29.97 fps, 29.97 tbr, 2997 tbn, 59.94 tbc"
+        #  "h264 (Main) (avc1 / 0x31637661), yuv420p, 854x480 [SAR 1:1 DAR 427:240], 2196 kb/s, 29.97 fps, 29.97 tbr, 2997 tbn, 59.94 tbc"
+        #  "prores (apcn / 0x6E637061), yuv422p10le, 720x486, 23587 kb/s, SAR 10:11 DAR 400:297, 29.97 fps, 29.97 tbr, 2997 tbn, 2997 tbc"
+        #  "Apple ProRes 422 (HQ), 1920x1080, 187905 kb/s, 29.97 fps, 29.97 tbr, 29970 tbn, 29970 tbc"
+        if video_stream.end_with?('unspecified pixel format')
+          @video_codec, @resolution, video_bitrate = video_stream.split(':').first.split(/\s?,\s?/)
+          video_bitrate = video_bitrate[0..-2] if video_bitrate and video_bitrate.end_with?(')')
+        else
+          @video_codec, @colorspace, @resolution, video_bitrate, aspect_ratios = video_stream.split(/\s?,\s?/)
+          if @colorspace.match(/\d*x\d*/)
+            @colorspace = nil
+            @video_codec, @resolution, video_bitrate, fps, tbr, tbn, tbc = video_stream.split(/\s?,\s?/)
+          end
+        end
+
+
+        @video_bitrate = video_bitrate =~ %r(\A(\d+) kb/s\Z) ? $1.to_i : nil
+
+
+        process_aspect_ratios(aspect_ratios) if aspect_ratios and aspect_ratios.include?(':')
+
+        @resolution, aspect_ratios = @resolution.strip.split(' ', 2) rescue @resolution = aspect_ratios = nil
+
+        process_aspect_ratios(aspect_ratios) if aspect_ratios and aspect_ratios.include?(':')
+
+        @width, @height = @resolution.split('x') rescue @width = @height = nil
+        @frame_rate = $1 if video_stream[/(\d*\.?\d*)\s?fps/]
+
+        is_widescreen?
+        
+        is_high_definition?
+      end
+      
+      if audio_stream
+        @audio_codec, audio_sample_rate, @audio_channels, unused, audio_bitrate = audio_stream.split(/\s?,\s?/)
+        @audio_bitrate = audio_bitrate =~ %r(\A(\d+) kb/s\Z) ? $1.to_i : nil
+        @audio_sample_rate = audio_sample_rate[/\d*/].to_i
+      end
+      
+      @invalid = true if @video_stream.to_s.empty? && @audio_stream.to_s.empty?
+      @invalid = true if @output.include?('is not supported')
+      @invalid = true if @output.include?('could not find codec parameters')
+    end # initialize
+
+    def process_aspect_ratios(aspect_ratios)
+      @dar = @display_aspect_ratio = $1 if aspect_ratios[/DAR (\d+:\d+)/] rescue nil # Display Aspect Ratio = SAR * PAR
+      @sar = @storage_aspect_ratio = $1 if aspect_ratios[/SAR (\d+:\d+)/] rescue nil # Storage Aspect Ratio = DAR/PAR
+      @par = @pixel_aspect_ratio   = $1 if aspect_ratios[/PAR (\d+:\d+)/] rescue nil # Pixel aspect ratio = DAR/SAR
+    end # process_aspect_ratios
+
+    # @return [Boolean]
+    def valid?
+      not @invalid
+    end
+    
+    # Determines if the aspect from dimensions is widescreen (> 1.5 (3/2)
+    # 1.55 is derived from the following tables
+    #   {http://en.wikipedia.org/wiki/Storage_Aspect_Ratio#Previous_and_currently_used_aspect_ratios Aspect Ratios}
+    #   {http://en.wikipedia.org/wiki/List_of_common_resolutions#Television}
+    #
+    # 1.55:1 (14:9): Widescreen aspect ratio sometimes used in shooting commercials etc. as a compromise format
+    # between 4:3 (12:9) and 16:9. When converted to a 16:9 frame, there is slight pillarboxing, while conversion to
+    # 4:3 creates slight letterboxing. All widescreen content on ABC Family's SD feed is presented in this ratio.
+    #
+    # @return [Boolean]
+    def is_widescreen?
+      @is_widescreen ||= (calculated_aspect_ratio ? (calculated_aspect_ratio >= 1.55) : false)
+    end
+    alias :is_wide_screen :is_widescreen
+    
+    # (@link http://en.wikipedia.osrg/wiki/List_of_common_resolution)
+    #
+    # Lowest Width High Resolution Format Found:
+    #   Panasonic DVCPRO100 for 50/60Hz over 720p - SMPTE Resolution = 960x720
+    #
+    # @return [Boolean]
+    def is_high_definition?
+      @is_high_definition ||= ( (width.respond_to?(:to_i) and height.respond_to?(:to_i)) ? (@width.to_i >= 950 and @height.to_i >= 700) : false )
+    end
+    alias :is_high_def? :is_high_definition?
+
+    # Will attempt to
+    def calculated_aspect_ratio
+      @calculated_aspect_ratio ||= aspect_from_dar || aspect_from_dimensions
+    end
+    
+    # @return [Integer] File Size
+    def size
+      @size ||= File.size(@path)
+    end
+    
+    # @return [Integer]
+    def audio_channel_count(audio_channels = @audio_channels)
+      return 0 unless audio_channels
+      return 1 if audio_channels['mono']
+      return 2 if audio_channels['stereo']
+      return 6 if audio_channels['5.1']
+      return 9 if audio_channels['7.2']
+      
+      # If we didn't hit a match above then find any number in #.# format and add them together to get a channel count
+      audio_channels[/(\d+.?\d?).*/]
+      audio_channels = $1.to_s.split('.').map(&:to_i).inject(:+) if $1 rescue audio_channels 
+      return audio_channels if audio_channels.is_a? Integer 
+    end
+    
+    # Outputs relavant instance variables names and values as a hash
+    # @return [Hash]
+    def to_hash
+      hash = Hash.new
+      variables = instance_variables
+      [ :@ffmpeg_cmd_path, :@logger ].each { |cmd| variables.delete(cmd) }
+      variables.each { |instance_variable_name| 
+        hash[instance_variable_name.to_s[1..-1]] = instance_variable_get(instance_variable_name)
+      }
+      hash['audio_channel_count'] = audio_channel_count
+      hash['calculated_aspect_ratio'] = calculated_aspect_ratio
+      hash
+    end
+    
+    protected
+    # @return [Integer|nil]
+    def aspect_from_dar
+      return nil unless dar
+      return @aspect_from_dar if @aspect_from_dar
+      w, h = dar.split(':')
+      aspect = w.to_f / h.to_f
+      @aspect_from_dar = aspect.zero? ? nil : aspect
+    end
+    
+    # @return [Fixed]
+    def aspect_from_dimensions
+      return @aspect_from_dimensions if @aspect_from_dimensions
+      
+      aspect = width.to_f / height.to_f
+      @aspect_from_dimensions = aspect.nan? ? nil : aspect
+    end
+    
+    # @param [String] output
+    def fix_encoding(output)
+      output[/test/] # Running a regexp on the string throws error if it's not UTF-8
+    rescue ArgumentError
+      output.force_encoding('ISO-8859-1')
+    end
+  end
+  
+  # @param [Hash] options
+  # @option options [String] :ffmpeg_cmd_path
+  def initialize(options = { })
+    @ffmpeg_cmd_path = options.fetch(:ffmpeg_cmd_path, 'ffmpeg')
+  end # initialize
+  
+  # @param [String] file_path
+  # @param [Hash] options
+  # @option options [String] :ffmpeg_cmd_path  
+  def run(file_path, options = { })
+    options = { :ffmpeg_cmd_path => @ffmpeg_cmd_path }.merge(options)
+    Movie.new(file_path, options).to_hash
+  end # run
+
+end # FFMPEG
+
+end