newbamboo-rvideo 0.9.6

data/lib/rvideo/tools/ffmpeg.rb

@@ -0,0 +1,356 @@
+module RVideo
+  module Tools
+    class Ffmpeg
+      RESOLUTION_ABBREVIATIONS = {
+        "sqcif"  => "128x96",
+        "qcif"   => "176x144",
+        "cif"    => "352x288",
+        "4cif"   => "704x576",
+        "qqvga"  => "160x120",
+        "qvga"   => "320x240",
+        "vga"    => "640x480",
+        "svga"   => "800x600",
+        "xga"    => "1024x768",
+        "uxga"   => "1600x1200",
+        "qxga"   => "2048x1536",
+        "sxga"   => "1280x1024",
+        "qsxga"  => "2560x2048",
+        "hsxga"  => "5120x4096",
+        "wvga"   => "852x480",
+        "wxga"   => "1366x768",
+        "wsxga"  => "1600x1024",
+        "wuxga"  => "1920x1200",
+        "woxga"  => "2560x1600",
+        "wqsxga" => "3200x2048",
+        "wquxga" => "3840x2400",
+        "whsxga" => "6400x4096",
+        "whuxga" => "7680x4800",
+        "cga"    => "320x200",
+        "ega"    => "640x350",
+        "hd480"  => "852x480",
+        "hd720"  => "1280x720",
+        "hd1080" => "1920x1080"
+      }
+      
+      VALID_ASPECT_STRINGS = ["4:3", "16:9"]
+      VALID_ASPECT_FLOATS  = [1.3333, 1.7777]
+      
+      # The flag used to set video bitrate has apparently changed between 
+      # different ffmpeg versions. In the latest builds -b is used. 
+      # In older builds it was -v which is now used to set verbosity of logging.
+      DEFAULT_VIDEO_BIT_RATE_PARAMETER = "b"
+      cattr_accessor :video_bit_rate_parameter
+      self.video_bit_rate_parameter = DEFAULT_VIDEO_BIT_RATE_PARAMETER
+      
+      include AbstractTool::InstanceMethods
+      
+      attr_reader :frame, :q, :size, :time, :output_bitrate, :video_size, :audio_size, :header_size, :overhead, :psnr, :output_fps, :pid
+      
+      def initialize(raw_command, options = {})
+        @progress_sample_rate = options.delete(:progress_sample_rate)
+        @progress_timeout = options.delete(:progress_timeout)
+        
+        @raw_command = raw_command
+        @options = HashWithIndifferentAccess.new(options)
+        @command = interpolate_variables(raw_command)
+      end
+      
+      # Not sure if this is needed anymore...
+      def tool_command
+        'ffmpeg'
+      end
+      
+      def format_deinterlace(params={})
+        params[:deinterlace] ? "-deinterlace" : ""
+      end
+
+      def format_fps(params={})
+        "-r #{params[:fps]}"
+      end
+      
+      def format_video_bit_rate(params = {})
+        "-#{video_bit_rate_parameter} #{params[:video_bit_rate]}k"
+      end
+      
+      def format_video_bit_rate_tolerance(params = {})
+        "-bt #{params[:video_bit_rate_tolerance]}k"
+      end
+      
+      def format_video_bit_rate_min(params = {})
+        "-minrate #{params[:video_bit_rate_min]}k"
+      end
+      
+      def format_video_bit_rate_max(params = {})
+        "-maxrate #{params[:video_bit_rate_max]}k"
+      end
+      
+      def format_video_quality(params={})
+        bitrate = params[:video_bit_rate].blank? ? nil : params[:video_bit_rate]
+        
+        params.merge! get_original_fps unless params[:fps]
+        
+        factor  = params[:scale][:width].to_f * params[:scale][:height].to_f * params[:fps].to_f
+        
+        case params[:video_quality]
+        when 'low'
+          bitrate ||= (factor / 12000).to_i
+          params[:video_bit_rate] = bitrate
+          "#{format_video_bit_rate params} -crf 30 -me zero -subq 1 -refs 1 -threads auto"
+        when 'medium'
+          bitrate ||= (factor / 9000).to_i
+          params[:video_bit_rate] = bitrate
+          "#{format_video_bit_rate params} -crf 22 -flags +loop -cmp +sad -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me hex -subq 3 -trellis 1 -refs 2 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250"
+        when 'high'
+          bitrate ||= (factor / 3600).to_i
+          params[:video_bit_rate] = bitrate
+          "#{format_video_bit_rate params} -crf 18 -flags +loop -cmp +sad -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me full -subq 6 -trellis 1 -refs 3 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -keyint_min 25 -sc_threshold 40 -i_qfactor 0.71"
+        end
+      end
+      
+      def format_resolution(params={})
+        p = "-s #{params[:scale][:width]}x#{params[:scale][:height]}"
+        if params[:letterbox]
+          plr = ((params[:letterbox][:width] - params[:scale][:width]) / 2).to_i
+          ptb = ((params[:letterbox][:height] - params[:scale][:height]) / 2).to_i
+          p += " -padtop #{ptb} -padbottom #{ptb} -padleft #{plr} -padright #{plr} "
+        end
+        p
+      end
+
+      def format_audio_channels(params={})
+        "-ac #{params[:channels]}"
+      end
+      
+      def format_audio_bit_rate(params={})
+        "-ab #{params[:bit_rate]}k"
+      end
+      
+      def format_audio_sample_rate(params={})
+        "-ar #{params[:sample_rate]}"
+      end
+      
+      def execute_with_progress
+        # TODO put progress_counter stuff back in because long videos might not update their progress for some time and we wouldn't want to accidently kill them!
+        final_command = @command
+        RVideo.logger.info("\nExecuting Command: #{final_command}\n")
+        @raw_result = ''
+        duration = 0
+        previous_line = nil
+        mutex = Mutex.new
+        
+        command_thread = Thread.new do 
+          @pid, stdin, stdout, stderr = Open4::popen4(final_command)
+          stderr.each("\r") do |line|
+            if line != previous_line
+              previous_line = line
+              new_progress, duration = parse_progress(line, duration)
+                mutex.synchronize do
+                  @progress = new_progress
+                end
+              $defout.flush
+            end
+            # WARNING: we may need to set a limit to how many lines are appended to @raw_result as ffmpeg can spit out a massive amount of info if things go pear shaped
+            @raw_result += line + "\r"
+          end
+        end
+        
+        # Yield the progress and monitor the process
+        current_timeout = 0
+        progress_to_yeild = nil
+        
+        loop do
+          # Exit when the command is done
+          break unless command_thread.alive?
+          # Yield the progress
+          mutex.synchronize do
+            # First check if we're actually making progress! We should kill the command if it's not, as it's probably because ffmpeg has frozen
+            if progress_to_yeild == @progress
+              current_timeout += @progress_sample_rate
+            end
+            progress_to_yeild = @progress
+          end
+          
+          unless @progress_timeout == false
+            self.kill if current_timeout >= @progress_timeout
+          end
+          
+          yield progress_to_yeild
+          sleep @progress_sample_rate
+        end
+      end
+      
+      def kill
+        Process.kill("SIGKILL", @pid)
+        raise TranscoderError, "Transcoder hung."
+      end
+      
+private
+      
+      def parse_progress(line, duration)
+        if line =~ /Duration: (\d{2}):(\d{2}):(\d{2}).(\d{1})/
+          duration = (($1.to_i * 60 + $2.to_i) * 60 + $3.to_i) * 10 + $4.to_i
+        end
+        
+        if line =~ /time=(\d+).(\d+)/
+          if not duration.nil? and duration != 0
+            p = ($1.to_i * 10 + $2.to_i) * 100 / duration
+          else
+            p = 0
+          end
+          p = 100 if p > 100
+        end
+        return [(p || nil), duration]
+      end
+      
+      # Turns the temp log file into a useful string, from which we can parse the 
+      # transcoding results.
+      # These log files can be enormous, so pulling the whole thing into memory is not an 
+      # option.
+      def populate_raw_result(temp_file_name)
+        @raw_result = ""
+        
+        # Is the log file exceptionally long?  It's really not a big deal to pull in a thousand lines or so
+        # into memory.  It's the gigantic files that cause problems.  If the files isn't too large, 
+        # just pull it in.
+        line_count = 0
+        if m = /^\s*(\d+)/.match(`wc -l #{temp_file_name}`)
+          line_count = m[1].to_i
+        end
+        
+        if line_count > 500
+          # Find the message indicating that the command is actually running.
+          running_string = "Press .* to stop encoding"
+          @raw_result << `grep "#{running_string}" #{temp_file_name}`
+        end
+
+        # Append the bottom of the log file, where the interesting bits live.
+        @raw_result << `tail -n 500 #{temp_file_name}`
+      end
+      
+      def parse_result(result)
+        if m = /Expected .+ for (.+) but found: (.+)/.match(result)
+          raise TranscoderError::InvalidCommand, m.to_s
+        end
+        
+        if m = /Unable for find a suitable output format for.*$/.match(result)
+          raise TranscoderError::InvalidCommand, m[0]
+        end
+        
+        if m = /Unknown codec \'(.*)\'/.match(result)
+          raise TranscoderError::InvalidFile, "Codec #{m[1]} not supported by this build of ffmpeg"
+       end
+        
+        if m = /could not find codec parameters/.match(result)
+          raise TranscoderError::InvalidFile, "Codec not supported by this build of ffmpeg"
+        end
+        
+        if m = /I\/O error occured\n(.*)$/.match(result)
+          raise TranscoderError::InvalidFile, "I/O error: #{m[1].strip}"
+        end
+          
+        if m = /\n(.*)Unknown Format$/.match(result)
+          raise TranscoderError::InvalidFile, "unknown format (#{m[1]})"
+        end
+        
+        if m = /\nERROR.*/m.match(result)
+          raise TranscoderError::InvalidFile, m[0]
+        end
+        
+        if m = /[(\S+) @ \d+x\d+]error, (.+?)/.match(result)
+          raise TranscoderError::InvalidFile, "#{m[1]}: #{m[2]}"
+        end
+        
+        if result =~ /usage: ffmpeg/
+          raise TranscoderError::InvalidCommand, "must pass a command to ffmpeg"
+        end
+        
+        if result =~ /Output file does not contain.*stream/
+          raise TranscoderError, "Output file does not contain any video or audio streams."
+        end
+        
+        if m = /Unsupported codec.*id=(.*)\).*for input stream\s*(.*)\s*/.match(result) 
+          inspect_original if @original.nil?
+          case m[2]
+          when @original.audio_stream_id
+            codec_type = "audio"
+            codec = @original.audio_codec
+          when @original.video_stream_id
+            codec_type = "video"
+            codec = @original.video_codec
+          else
+            codec_type = "video or audio"
+            codec = "unknown"
+          end
+          
+          raise TranscoderError::InvalidFile, "Unsupported #{codec_type} codec: #{codec} (id=#{m[1]}, stream=#{m[2]})"
+          #raise TranscoderError, "Codec #{m[1]} not supported (in stream #{m[2]})"
+        end
+        
+        # Could not open './spec/../config/../tmp/processed/1/kites-1.avi'
+        if result =~ /Could not open .#{@output_file}.\Z/
+          raise TranscoderError, "Could not write output file to #{@output_file}"
+        end
+          
+        full_details = /Press .* to stop encoding\n(.*)/m.match(result)
+        raise TranscoderError, "Unexpected result details (#{result})" if full_details.nil?
+        details = full_details[1].strip.gsub(/\s*\n\s*/," - ")
+        
+        if details =~ /Could not write header/
+          raise TranscoderError, details
+        end
+        
+        #frame=  584 q=6.0 Lsize=     708kB time=19.5 bitrate= 297.8kbits/s    
+        #video:49kB audio:153kB global headers:0kB muxing overhead 250.444444%
+        
+        #frame= 4126 q=31.0 Lsize=    5917kB time=69.1 bitrate= 702.0kbits/s    
+        #video:2417kB audio:540kB global headers:0kB muxing overhead 100.140277%
+        
+        #frame=  273 fps= 31 q=10.0 Lsize=     398kB time=5.9 bitrate= 551.8kbits/s
+        #video:284kB audio:92kB global headers:0kB muxing overhead 5.723981%
+        
+        #mdb:94, lastbuf:0 skipping granule 0
+        #size=    1080kB time=69.1 bitrate= 128.0kbits /s    
+        #video:0kB audio:1080kB global headers:0kB muxing overhead 0.002893%
+        
+        #size=      80kB time=5.1 bitrate= 128.0kbits/s    ^Msize=     162kB time=10.3 bitrate= 128.0kbits/s    ^Msize=     241kB time=15.4 bitrate= 128.0kbits/s    ^Msize=     329kB time=21.1 bitrate= 128.0kbits/s    ^Msize=     413kB time=26.4 bitrate= 128.0kbits/s    ^Msize=     506kB time=32.4 bitrate= 128.0kbits/s    ^Msize=     591kB time=37.8 bitrate= 128.0kbits/s    ^Msize=     674kB time=43.2 bitrate= 128.0kbits/s    ^Msize=     771kB time=49.4 bitrate= 128.0kbits/s    ^Msize=     851kB time=54.5 bitrate= 128.0kbits/s    ^Msize=     932kB time=59.6 bitrate= 128.0kbits/s    ^Msize=    1015kB time=64.9 bitrate= 128.0kbits/s    ^Msize=    1094kB time=70.0 bitrate= 128.0kbits/s    ^Msize=    1175kB time=75.2 bitrate= 128.0kbits/s    ^Msize=    1244kB time=79.6 bitrate= 128.0kbits/s    ^Msize=    1335kB time=85.4 bitrate= 128.0kbits/s    ^Msize=    1417kB time=90.7 bitrate= 128.0kbits/s    ^Msize=    1508kB time=96.5 bitrate= 128.0kbits/s    ^Msize=    1589kB time=101.7 bitrate= 128.0kbits/s    ^Msize=    1671kB time=106.9 bitrate= 128.0kbits/s    ^Msize=    1711kB time=109.5 bitrate= 128.0kbits/s - video:0kB audio:1711kB global headers:0kB muxing overhead 0.001826%
+        
+        #mdb:14, lastbuf:0 skipping granule 0 - overread, skip -5 enddists: -2 -2 - overread, skip -5 enddists: -2 -2 - size=      90kB time=5.7 bitrate= 128.0kbits/s    \nsize=     189kB time=12.1 bitrate= 128.0kbits/s
+        
+        #size=      59kB time=20.2 bitrate=  24.0kbits/s    \nsize=     139kB time=47.4 bitrate=  24.0kbits/s    \nsize=     224kB time=76.5 bitrate=  24.0kbits/s    \nsize=     304kB time=103.7 bitrate=  24.0kbits/s    \nsi
+        
+        #mdb:14, lastbuf:0 skipping granule 0 - overread, skip -5 enddists: -2 -2 - overread, skip -5 enddists: -2 -2 - size=      81kB time=10.3 bitrate=  64.0kbits/s    \nsize=     153kB time=19.6 bitrate=  64.0kbits/s 
+        
+        #size=      65kB time=4.1 bitrate= 128.1kbits/s    \nsize=     119kB time=7.6 bitrate= 128.0kbits/s    \nsize=     188kB time=12.0 bitrate= 128.0kbits/s    \nsize=     268kB time=17.1 bitrate= 128.0kbits/s    \nsize=
+        
+        #Error while decoding stream #0.1     [mpeg4aac @ 0xb7d089f0]faac: frame decoding failed: Gain control not yet implementedError while decoding stream #0.1frame= 2143 fps= 83 q=4.0 size=    4476kB time=71.3 bitrate= 514.5kbits/s    ^M[mpeg4aac @ 0xb7d089f0]faac: frame decoding failed: Gain control not yet implementedError while decoding stream #0.1
+        
+        # NOTE: had to remove "\s" from "\s.*L.*size=" from this regexp below.
+        # Not sure why. Unit tests were succeeding, but hand tests weren't.
+        if details =~ /video:/ 
+          #success = /^frame=\s*(\S*)\s*q=(\S*).*L.*size=\s*(\S*)\s*time=\s*(\S*)\s*bitrate=\s*(\S*)\s*/m.match(details)
+          @frame          = details[/frame=\s*(\S*)/, 1]
+          @output_fps     = details[/fps=\s*(\S*)/, 1]
+          @q              = details[/\s+q=\s*(\S*)/, 1]
+          @size           = details[/size=\s*(\S*)/, 1]
+          @time           = details[/time=\s*(\S*)/, 1]
+          @output_bitrate = details[/bitrate=\s*(\S*)/, 1]
+          
+          @video_size     = details[/video:\s*(\S*)/, 1]
+          @audio_size     = details[/audio:\s*(\S*)/, 1]
+          @header_size    = details[/headers:\s*(\S*)/, 1]
+          @overhead       = details[/overhead[:]*\s*(\S*)/, 1]
+          
+          psnr_match = /PSNR=(.*)\s*size=/.match(details)
+          @psnr = psnr_match[1].strip if psnr_match
+          return true
+        end
+        
+        #[mp3 @ 0x54340c]flv doesnt support that sample rate, choose from (44100, 22050, 11025)
+        #Could not write header for output file #0 (incorrect codec parameters ?)
+        
+        raise TranscoderError::UnexpectedResult, details
+      end
+      
+    end
+  end
+end

data/lib/rvideo/tools/ffmpeg2theora.rb

@@ -0,0 +1,42 @@
+module RVideo
+  module Tools
+    class Ffmpeg2theora
+      include AbstractTool::InstanceMethods
+
+      attr_reader :raw_metadata
+
+      def tool_command
+        'ffmpeg2theora'
+      end
+
+      def format_video_quality(params={})
+        bitrate = params[:video_bit_rate].blank? ? nil : params[:video_bit_rate]
+        factor = (params[:scale][:width].to_f * params[:scale][:height].to_f * params[:fps].to_f)
+        case params[:video_quality]
+        when 'low'
+          " -v 1 "
+        when 'medium'
+          "-v 5 "
+        when 'high'
+          "-v 10 "
+        else
+          ""
+        end
+      end  
+
+      def parse_result(result)
+        if m = /does not exist or has an unknown data format/.match(result)
+          raise TranscoderError::InvalidFile, "I/O error"
+        end
+        
+        if m = /General output options/.match(result)
+          raise TranscoderError::InvalidCommand, "no command passed to ffmpeg2theora, or no output file specified"
+        end
+        
+        @raw_metadata = result.empty? ? "No Results" : result
+        return true
+      end
+
+    end
+  end
+end

data/lib/rvideo/tools/flvtool2.rb

@@ -0,0 +1,50 @@
+# Warning:  If you're dealing with large files, you should consider using yamdi instead.
+module RVideo
+  module Tools
+    class Flvtool2
+      include AbstractTool::InstanceMethods
+      
+      attr_reader :raw_metadata
+      
+      #attr_reader :has_key_frames, :cue_points, :audiodatarate, :has_video, :stereo, :can_seek_to_end, :framerate, :audiosamplerate, :videocodecid, :datasize, :lasttimestamp,
+      #  :audiosamplesize, :audiosize, :has_audio, :audiodelay, :videosize, :metadatadate, :metadatacreator, :lastkeyframetimestamp, :height, :filesize, :has_metadata, :audiocodecid,
+      #  :duration, :videodatarate, :has_cue_points, :width
+      
+      def tool_command
+        'flvtool2'
+      end
+      
+      private
+      
+      def parse_result(result)
+        if result.empty?
+          return true
+        end
+        
+        if m = /ERROR: No such file or directory(.*)\n/.match(result)
+          raise TranscoderError::InputFileNotFound, m[0]
+        end
+        
+        if m = /ERROR: IO is not a FLV stream/.match(result)
+          raise TranscoderError::InvalidFile, "input must be a valid FLV file"
+        end
+          
+        if m = /Copyright.*Norman Timmler/i.match(result)
+          raise TranscoderError::InvalidCommand, "command printed flvtool2 help text (and presumably didn't execute)"
+        end
+        
+        if m = /ERROR: undefined method .?timestamp.? for nil/.match(result)
+          raise TranscoderError::InvalidFile, "Output file was empty (presumably)"
+        end
+        
+        if m = /\A---(.*)...\Z/m.match(result)
+          @raw_metadata = m[0]
+          return true
+        end
+
+        raise TranscoderError::UnexpectedResult, result
+      end
+      
+    end
+  end
+end

data/lib/rvideo/tools/mencoder.rb

@@ -0,0 +1,103 @@
+module RVideo
+  module Tools
+    class Mencoder
+      include AbstractTool::InstanceMethods
+
+      attr_reader :frame, :size, :time, :bitrate, :video_size, :audio_size, :output_fps
+      
+      def tool_command
+        'mencoder'
+      end
+
+      def format_fps(params={})
+        " -ofps #{params[:fps]}" 
+      end
+
+      def format_resolution(params={})
+        p = " -vf scale=#{params[:scale][:width]}:#{params[:scale][:height]}"
+        if params[:letterbox]
+          p += ",expand=#{params[:letterbox][:width]}:#{params[:letterbox][:height]}"
+        end
+        p += ",harddup"
+      end
+
+      def format_audio_channels(params={})
+        " -channels #{params[:channels]}"
+      end
+      
+      def format_audio_bit_rate(params={})
+        " br=#{params[:bit_rate]}:"
+      end
+      
+      def format_audio_sample_rate(params={})
+        " -srate #{params[:sample_rate]}"
+      end
+      
+      def format_video_quality(params={})
+        bitrate = params[:video_bit_rate].blank? ? nil : params[:video_bit_rate]
+        factor = (params[:scale][:width].to_f * params[:scale][:height].to_f * params[:fps].to_f)
+        case params[:video_quality]
+        when 'low'
+          bitrate ||= (factor / 12000).to_i
+          " -x264encopts threads=auto:subq=1:me=dia:frameref=1:crf=30:bitrate=#{bitrate} "
+        when 'medium'
+          bitrate ||= (factor / 9000).to_i
+          " -x264encopts threads=auto:subq=3:me=hex:frameref=2:crf=22:bitrate=#{bitrate} "
+        when 'high'
+          bitrate ||= (factor / 3600).to_i
+          " -x264encopts threads=auto:subq=6:me=dia:frameref=3:crf=18:bitrate=#{bitrate} "
+        else
+          ""
+        end
+      end  
+      
+
+
+      private
+      
+      def parse_result(result)
+        if m = /Exiting.*No output file specified/.match(result)
+          raise TranscoderError::InvalidCommand, "no command passed to mencoder, or no output file specified"
+        end
+        
+        if m = /counldn't set specified parameters, exiting/.match(result)
+          raise TranscoderError::InvalidCommand, "a combination of the recipe parameters is invalid: #{result}"
+        end
+
+        if m = /Sorry, this file format is not recognized\/supported/.match(result)
+          raise TranscoderError::InvalidFile, "unknown format"
+        end
+        
+        if m = /Cannot open file\/device./.match(result)
+          raise TranscoderError::InvalidFile, "I/O error"
+        end
+        
+        if m = /File not found:$/.match(result)
+          raise TranscoderError::InvalidFile, "I/O error"
+        end
+        
+        video_details = result.match /Video stream:(.*)$/
+        if video_details
+          @bitrate    = video_details[0][/Video stream:\s*([0-9.]*)/, 1]
+          @video_size = video_details[0][/size:\s*(\d*)\s*(\S*)/, 1]
+          @time       = video_details[0][/bytes\s*([0-9.]*)/, 1]
+          @frame      = video_details[0][/secs\s*(\d*)/, 1]
+          @output_fps = (@frame.to_f / @time.to_f).round_to(3)
+        
+        elsif result =~ /Video stream is mandatory/
+          raise TranscoderError::InvalidFile,
+            "Video stream required, and no video stream found"
+        end
+        
+        audio_details = result.match /Audio stream:(.*)$/
+        if audio_details
+          @audio_size = audio_details[0][/size:\s*(\d*)\s*\S*/, 1]
+        else
+          @audio_size = 0
+        end
+        @size = (@video_size.to_i + @audio_size.to_i).to_s
+      end
+      
+    end
+  end
+end