stlondemand-rvideo 0.9.7

data/lib/rvideo/tools/lame.rb

@@ -0,0 +1,58 @@
+module RVideo
+  module Tools
+    class Lame
+      include AbstractTool::InstanceMethods
+      attr_reader :raw_metadata
+      
+      def tool_command
+        'lame'
+      end
+      
+      
+      def execute_with_progress(&block)
+        RVideo.logger.info("\nExecuting Command: #{@command}\n")
+        do_execute_with_progress(@command, &block)
+      rescue RVideo::CommandExecutor::ProcessHungError
+        raise TranscoderError, "Transcoder hung."
+      end
+      
+      def do_execute_with_progress(command,&block)
+        @raw_result = ''
+        CommandExecutor::execute_with_block(command, "\r") do |line|
+          progress = parse_progress(line)
+          block.call(progress) if block && progress
+          @raw_result += line + "\r"
+        end
+      end
+      
+      def parse_progress(line)
+        if line =~ /\((\d+)\%\)/
+          $1.to_i > 100 ? 100 : $1.to_i
+        else
+          nil
+        end
+      end
+      
+      private
+      
+      def parse_result(result)
+        
+        if m = /usage: lame [options] <infile> [outfile]/.match(result)
+          raise TranscoderError::InvalidCommand, "usage: lame [options] <infile> [outfile]"
+        end
+        
+        if m = /Warning: unsupported audio format/.match(result)
+          raise TranscoderError::InvalidFile, "Warning: unsupported audio format"
+        end
+        
+        if m = /Could not find/.match(result)
+          raise TranscoderError::InvalidFile, "No such file or directory"          
+        end
+        
+        @raw_metadata = result.empty? ? "No Results" : result
+        return true
+      end
+      
+    end
+  end
+end

data/lib/rvideo/tools/mencoder.rb

@@ -0,0 +1,126 @@
+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  
+      
+      def execute_with_progress(&block)
+        RVideo.logger.info("\nExecuting Command: #{@command}\n")
+        do_execute_with_progress(@command, &block)
+      rescue RVideo::CommandExecutor::ProcessHungError
+        raise TranscoderError, "Transcoder hung."
+      end
+      
+      def do_execute_with_progress(command,&block)
+        @raw_result = ''
+        stderr_result, stdout_result = CommandExecutor::execute_with_block(command, "\r", false) do |line|
+          progress = parse_progress(line)
+          block.call(progress) if block && progress
+          @raw_result += line + "\r"
+        end
+        @raw_result += stderr_result
+      end
+      
+      def parse_progress(line)
+        if line =~ /Pos:[^(]*\((\d+)\%\)/
+          $1.to_i > 100 ? 100 : $1.to_i
+        else
+          nil
+        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

data/lib/rvideo/tools/mp4box.rb

@@ -0,0 +1,21 @@
+module RVideo
+  module Tools
+    class Mp4box
+      include AbstractTool::InstanceMethods
+      attr_reader :raw_metadata
+
+      def tool_command
+        'MP4Box'
+      end
+      
+      private
+      
+      def parse_result(result)
+        #currently, no useful info returned in result to determine if successful or not
+        @raw_metadata = result.empty? ? "No Results" : result
+        return true
+      end
+      
+    end
+  end
+end

data/lib/rvideo/tools/mp4creator.rb

@@ -0,0 +1,35 @@
+module RVideo
+  module Tools
+    class Mp4creator
+      include AbstractTool::InstanceMethods
+
+      attr_reader :raw_metadata
+
+      def tool_command
+        'mp4creator'
+      end
+
+      def format_fps(params={})
+          " -rate=#{params[:fps]}" 
+      end
+
+      def parse_result(result)
+        if m = /can't open file/.match(result)
+          raise TranscoderError::InvalidFile, "I/O error"
+        end
+        
+        if m = /unknown file type/.match(result)
+          raise TranscoderError::InvalidFile, "I/O error"
+        end
+        
+        if @options['output_file'] && !File.exist?(@options['output_file'])
+          raise TranscoderError::UnexpectedResult, "An unknown error has occured with mp4creator:#{result}"
+        end
+
+        @raw_metadata = result.empty? ? "No Results" : result
+        return true
+      end
+
+    end
+  end
+end

data/lib/rvideo/tools/mplayer.rb

@@ -0,0 +1,31 @@
+module RVideo
+  module Tools
+    class Mplayer
+      include AbstractTool::InstanceMethods
+
+      attr_reader :raw_metadata
+
+      def tool_command
+        'mplayer'
+      end
+
+      def parse_result(result)
+        if m = /This will likely crash/.match(result)
+          raise TranscoderError::InvalidFile, "unknown format"
+        end
+        
+        if m = /Failed to open/.match(result)
+          raise TranscoderError::InvalidFile, "I/O error"
+        end
+        
+        if m = /File not found/.match(result)
+          raise TranscoderError::InvalidFile, "I/O error"
+        end
+        
+        @raw_metadata = result.empty? ? "No Results" : result
+        return true
+      end
+
+    end
+  end
+end

data/lib/rvideo/tools/qtfaststart.rb

@@ -0,0 +1,37 @@
+module RVideo
+  module Tools
+    class QtFaststart
+      include AbstractTool::InstanceMethods
+      attr_reader :raw_metadata
+      
+      def tool_command
+        'qt-faststart'
+      end
+      
+      private
+      
+      def parse_result(result)
+        
+        if m = /Usage: qt-faststart <infile.mov> <outfile.mov>/.match(result)
+          raise TranscoderError::InvalidCommand, "Usage: qt-faststart <infile.mov> <outfile.mov>"
+        end
+        
+        if m = /last atom in file was not a moov atom/.match(result)
+          raise TranscoderError::InvalidFile, "Could not find moov atom"
+        end
+        
+        if m = /No such file or directory/.match(result)
+          raise TranscoderError::InvalidFile, "No such file or directory"          
+        end
+        
+        if m = /Undefined error:/.match(result)
+          raise TranscoderError::UnexpectedResult, "Undefined error"
+        end
+
+        @raw_metadata = result.empty? ? "No Results" : result
+        return true
+      end
+      
+    end
+  end
+end

data/lib/rvideo/tools/segmenter.rb

@@ -0,0 +1,29 @@
+module RVideo
+  module Tools
+    class Segmenter
+      include AbstractTool::InstanceMethods
+      
+      attr_reader :raw_metadata
+      
+      def tool_command
+        'segmenter'
+      end
+      
+      private
+      
+      def parse_result(result)
+        if m = /Could not write mpegts header to first output file/.match(result)
+          raise TranscoderError::InvalidFile
+        end
+        
+        if m = /Usage: segmenter <input MPEG-TS file> <segment duration in seconds> <output MPEG-TS file prefix> <output m3u8 index file> <http prefix>/.match(result)
+          raise TranscoderError::InvalidCommand, "Usage: segmenter <input MPEG-TS file> <segment duration in seconds> <output MPEG-TS file prefix> <output m3u8 index file> <http prefix>"
+        end
+        
+        # TODO: parse segmenter results
+        return true
+      end
+      
+    end
+  end
+end

data/lib/rvideo/tools/yamdi.rb

@@ -0,0 +1,44 @@
+module RVideo
+  module Tools
+    class Yamdi
+      include AbstractTool::InstanceMethods
+      
+      attr_reader :raw_metadata
+      
+      def tool_command
+        'yamdi'
+      end
+      
+      private
+      
+      def parse_result(result)
+        if result.empty?
+          return true
+        end
+        
+        if m = /Couldn't stat on (.*)/.match(result)
+          raise TranscoderError::InputFileNotFound, m[0]
+        end
+        
+        if m = /The input file is not a FLV./.match(result)
+          raise TranscoderError::InvalidFile, "input must be a valid FLV file"
+        end
+          
+        if m = /\(c\) \d{4} Ingo Oppermann/i.match(result)
+          raise TranscoderError::InvalidCommand, "command printed yamdi help text (and presumably didn't execute)"
+        end
+        
+        if m = /Please provide at least one output file/i.match(result)
+          raise TranscoderError::InvalidCommand, "command did not contain a valid output file. Yamdi expects a -o switch."
+        end
+        
+        if m = /ERROR: undefined method .?timestamp.? for nil/.match(result)
+          raise TranscoderError::InvalidFile, "Output file was empty (presumably)"
+        end
+
+        raise TranscoderError::UnexpectedResult, result
+      end
+      
+    end
+  end
+end

data/lib/rvideo/transcoder.rb

@@ -0,0 +1,170 @@
+module RVideo # :nodoc:
+  class Transcoder
+
+    attr_reader :executed_commands, :errors, :warnings, :total_time
+
+    #
+    # To transcode a video, initialize a Transcoder object:
+    #
+    #   transcoder = RVideo::Transcoder.new("/path/to/input.mov")
+    #
+    # Then pass a recipe and valid options to the execute method
+    #
+    #   recipe = "ffmpeg -i $input_file$ -ar 22050 -ab 64 -f flv -r 29.97 -s"
+    #   recipe += " $resolution$ -y $output_file$"
+    #   recipe += "\nflvtool2 -U $output_file$"
+    #   begin
+    #     transcoder.execute(recipe, {:output_file => "/path/to/output.flv",
+    #       :resolution => "640x360"})
+    #   rescue TranscoderError => e
+    #     puts "Unable to transcode file: #{e.class} - #{e.message}"
+    #   end
+    #
+    # If the job succeeds, you can access the metadata of the input and output
+    # files with:
+    #
+    #   transcoder.original     # RVideo::Inspector object
+    #   transcoder.processed    # RVideo::Inspector object
+    #
+    # If the transcoding succeeds, the file may still have problems. RVideo
+    # will populate an errors array if the duration of the processed video
+    # differs from the duration of the original video, or if the processed
+    # file is unreadable.
+    #
+
+    def initialize(input_file = nil)
+      # Allow a nil input_file for backwards compatibility. (Change at 1.0?)
+      check_input_file(input_file)
+
+      @input_file = input_file
+      @executed_commands = []
+      @errors = []
+      @warnings = []
+    end
+
+    def original
+      @original ||= Inspector.new(:file => @input_file)
+    end
+
+    def processed
+      if @output_file
+        @processed ||= Inspector.new(:file => @output_file)
+      else
+        nil
+      end
+    end
+
+    #
+    # Requires a command and a hash of various interpolated options. The
+    # command should be one or more lines of transcoder tool commands (e.g.
+    # ffmpeg, flvtool2). Interpolate options by adding $option_key$ to the
+    # recipe, and passing :option_key => "value" in the options hash.
+    #
+    #   recipe = "ffmpeg -i $input_file$ -ar 22050 -ab 64 -f flv -r 29.97
+    #   recipe += "-s $resolution$ -y $output_file$"
+    #   recipe += "\nflvtool2 -U $output_file$"
+    #
+    #   transcoder = RVideo::Transcoder.new("/path/to/input.mov")
+    #   begin
+    #     transcoder.execute(recipe, {:output_file => "/path/to/output.flv", :resolution => "320x240"})
+    #   rescue TranscoderError => e
+    #     puts "Unable to transcode file: #{e.class} - #{e.message}"
+    #   end
+    #
+
+    def execute(task, options = {})
+      t1 = Time.now
+
+      if @input_file.nil?
+        @input_file = options[:input_file]
+      end
+
+      RVideo.logger.info("\nNew transcoder job\n================\nTask: #{task}\nOptions: #{options.inspect}")
+
+      if block_given?
+        parse_and_execute(task, options) do |tool, progress|
+          yield(tool, progress)
+        end
+      else
+        parse_and_execute(task, options)
+      end
+      
+      if @output_file.nil?
+        @output_file = options[:output_file]
+      end
+      result = check_integrity
+      RVideo.logger.info("\nFinished task. Total errors: #{@errors.size}\n")
+      @total_time = Time.now - t1
+      result
+    rescue TranscoderError => e
+      raise e
+    rescue Exception => e
+      handle_unknown_error(e)
+    end
+
+    private
+
+    def handle_unknown_error(e)
+      RVideo.logger.error "[ERROR] Unhandled RVideo exception: #{e.class} - #{e.message}"
+      RVideo.logger.error e.backtrace.join("\n\t")
+      raise TranscoderError::UnknownError, "Unexpected RVideo error: #{e.message} (#{e.class})"
+    end
+
+    def check_input_file(input_file)
+      if input_file and !FileTest.exist?(input_file.gsub("\"",""))
+        raise TranscoderError::InputFileNotFound, "File not found (#{input_file})"
+      end
+    end
+
+    def check_integrity
+      precision = 1.1
+      if processed.invalid?
+        @errors << "Output file invalid"
+      elsif processed.duration <= 0
+        @errors << "Processed file has a duration of #{processed.duration}"
+      end
+      return @errors.size == 0
+    end
+
+    def parse_and_execute(task, options = {})
+      raise TranscoderError::ParameterError, "Expected a recipe class (as a string), but got a #{task.class.to_s} (#{task})" unless task.is_a? String
+      options = options.merge(:input_file => @input_file)
+
+      commands = task.split(/[\n;]/).compact
+      commands_with_progress = number_of_tools_supporting_progress(commands)
+
+      progress_by_tools={}
+      commands.each do |c|
+        tool = Tools::AbstractTool.assign(c, options)
+        tool.original = original
+
+        if block_given?
+          tool.execute do |progress|
+            progress_by_tools[c.object_id] = progress
+            sum = progress_by_tools.values.inject(0) { |s,v| s += v }
+            if commands_with_progress > 0
+              total_progress = sum / commands_with_progress
+              yield(tool, total_progress) if total_progress != @prev_progress
+              @prev_progress = total_progress
+            end
+          end
+        else
+          tool.execute
+        end
+
+        executed_commands << tool
+      end
+    end
+  
+  
+    def number_of_tools_supporting_progress(commands)
+      n = 0
+      commands.each do |c|
+        tool_name = c.split(" ").first
+        n += 1 if RVideo::Tools.const_get(tool_name.underscore.classify).method_defined?(:execute_with_progress)
+      end
+      n
+    end
+  
+  end
+end