rvideo 0.8.0

data/lib/rvideo/reporter.rb

@@ -0,0 +1,176 @@
+require 'erb'
+
+module RVideo
+  class Reporter
+    include ERB::Util
+
+    def self.run
+      Reporter.new.run
+    end
+    
+    def run
+      @current_report_path = Reporter.next_available_report_path(File.join(REPORT_PATH, 'generated_reports'))
+      files = available_files
+      recipes = available_recipes
+
+      puts "\nInput files:\n--#{files.collect { |file| File.basename(file) }.join("\n--")}" 
+      puts "\nInput recipes:\n--#{recipes.map {|name, recipe| name }.join("\n--")}"
+      combinations = calculate_combinations_using recipes, files
+      results = mass_transcode combinations
+      build_report_from results
+      puts "Done! Report available at #{@current_report_path}"
+      puts "Launching report in browser..."
+      exec "open #{@current_report_path}/index.html"
+    end
+    
+    private
+    
+    def self.next_available_report_path(base_path)
+      ordered_reports = Dir[File.join(base_path, "*")].sort_by {|name| File.basename(name).to_i }
+      ordered_reports = ["0"] if ordered_reports.empty? 
+      last_report = File.basename(ordered_reports.last)
+      new_report_name = (last_report.to_i + 1).to_s
+      new_dir = File.join(base_path, new_report_name)
+      FileUtils.mkdir_p(new_dir)
+      new_dir
+    end
+
+    def available_recipes
+      recipes = []
+      recipe_files = Dir[File.join(REPORT_PATH, "*.yml")]
+      recipe_files.each do |recipe_file|
+        YAML.load_file(recipe_file).each { |recipe| recipes << recipe }
+      end
+      if recipes.empty?
+        puts "No recipes found. Add recipe YAML files to report/."
+        exit
+      else
+        recipes
+      end
+    end
+
+    def available_files
+      files = Dir[File.join(REPORT_PATH, "files/input/*.*")]
+      if files.empty?
+        puts "No input files. Add files to report/files/input to test."
+        exit
+      else
+        files
+      end
+    end
+
+    def calculate_combinations_using(recipes, files)
+      @combinations = {}
+      files.each { |file| @combinations[file] = recipes }
+      @combinations
+    end
+
+    def build_report_from(results, options = nil)
+      @results = results
+      #build main report
+      report = load_view 'index'
+      full_report_path = File.join(@current_report_path, "index.html")
+      File.open(full_report_path, "w+") do |file|
+        file.write report
+      end
+      #build individual reports
+       @results.each do |input_file, recipes|
+        recipes.each do |recipe_name, result|
+          build_individual_report(input_file, recipe_name, result)
+         end
+       end
+    end
+
+    def build_individual_report(input_file, recipe_name, result)
+      #instance variables may no longer be necessary...
+      @input_file = input_file
+      @recipe_name = recipe_name
+      @result = result
+      individual_report = load_view 'report'
+      individual_report_name = "#{underscoreize_file_basename(input_file)}_#{recipe_name}.html"
+      File.makedirs(File.join(@current_report_path, "individual_reports"))
+      full_report_path = File.join(@current_report_path, "individual_reports", individual_report_name)
+      File.open(full_report_path, "w+") do |file|
+        file.write individual_report
+      end
+    end
+
+
+    def load_view(template_name)
+      template_file = "#{File.dirname(__FILE__)}/reporter/views/#{template_name}.html.erb"
+      template = File.read(template_file).gsub(/^  /, '')
+      ERB.new(template).result(binding)
+    end
+
+    def mass_transcode(combinations)
+      results = {}
+      combinations.each do |file, recipes|
+        results[file] = {}
+        recipes.each do |recipe_name, recipe|
+          puts "Transcoding #{File.basename(file)} using recipe #{recipe_name}"
+          
+          #generate input/output file paths
+          input_file  = File.expand_path(file)
+          output_file = generate_output_file_using input_file, recipe_name, recipe 
+          #raise output_file
+          #input_file.gsub!(" ","\\ ")
+          input_file = "#{File.dirname(input_file)}/\"#{File.basename(input_file)}\""
+          
+          #create logfile
+          log_file_name = underscoreize_file_basename(input_file) + "_" + recipe_name + ".log" 
+          log_file = create_log_file(log_file_name)
+          RVideo::Transcoder.logger = Logger.new(log_file)
+
+          transcoder, errors = transcode(recipe, input_file, output_file)
+          
+          #build the results object for the views
+          results[file][recipe_name] = {}
+          results[file][recipe_name]['output_file'] = output_file
+          results[file][recipe_name]['transcoder'] = transcoder
+          results[file][recipe_name]['errors'] = errors
+          results[file][recipe_name]['recipe'] = recipe
+          results[file][recipe_name]['log'] = log_file
+        end
+      end
+      return results
+    end
+
+    def generate_output_file_using(selected_file, recipe_name, recipe)
+      #File.join(@current_report_path, 'output_files')
+      output_path = File.join(@current_report_path, 'output_files' + underscoreize_file_basename(selected_file))
+      File.makedirs output_path
+      output_filename = "#{recipe_name}.#{recipe['extension']}"
+      output_file = File.join(output_path, output_filename)
+      #output_file.gsub(" ","_")
+    end
+
+    def underscoreize_file_basename(file)
+      File.basename(file).gsub(".","_").gsub(" ","_")
+    end
+
+    def transcode(recipe, input_file, output_file)
+      command     = recipe['command']
+      errors = nil
+
+      #RVideo::Transcoder.logger = Logger.new(STDOUT)
+      begin
+      transcoder = RVideo::Transcoder.new
+      transcoder.execute(command, {:input_file => input_file,
+                                  :output_file => output_file})
+      #rescue => errors
+      end
+      
+      return transcoder, errors 
+    end
+
+    def create_log_file(log_file_name)
+      log_path = File.join(@current_report_path, "logs")
+      File.makedirs log_path
+      logfile = File.join(log_path, log_file_name)
+      File.open(logfile, "w+") { |file| }
+      logfile
+    end
+  
+  end
+
+end

data/lib/rvideo/reporter/views/index.html.erb

@@ -0,0 +1,27 @@
+ <html>
+    <head>
+      <title>RVideo Reports Index</title>
+      <link rel="stylesheet" href="report.css" type="text/css" media="screen" />
+      <script type="text/javascript" src="report.js"></script>
+    </head>
+    <body>
+      <% @results.each do |input_file, recipes| %>
+        <h1>
+          <a href="<%= input_file %>"><%= File.basename(input_file) %> (launch file)</a>
+        </h1>
+        <ol>
+        <% recipes.each do |recipe_name, result| %>
+        <li>
+          <% css_class = 'warning' unless result['transcoder'].errors.empty? %>
+          <% css_class = 'critical' if result['errors']  %>
+          <% css_class = 'passed' if css_class.nil? %>
+          <div class="<%= css_class %>">
+          <% individual_report_url = "individual_reports/" + underscoreize_file_basename(input_file) + "_" + recipe_name + ".html"  %>
+            <h2><a href="<%= result['output_file'] %>">Launch <%= recipe_name %></a> <a class="view-report" href="<%= individual_report_url %>" >view full report</a></h2>
+          </div>
+        </li>
+        <% end %>
+        </ol>
+      <% end %>
+    </body>
+  </html>

data/lib/rvideo/reporter/views/report.css

@@ -0,0 +1,27 @@
+/* a { color: black; margin-left: 20px;}
+ a:visited { color: #111; }
+.critical { background-color: #E6E6E6; border-left: 20px solid #F00; }
+.warning { background-color: #E6E6E6; border-left: 20px solid orange; }
+.passed { background-color: #E6E6E6; border-left: 20px solid #0F0; }
+
+div { margin: 10px; border: 1px solid #ccc; padding: 5px; }
+li { margin: 20px; padding: 5px; list-style-type: none; }
+span { background-color: #ccc; padding: 5px; width: 500px;}
+span:hover { cursor: pointer; text-decoration: underline; }
+*/
+
+ html { font-size: .75em;}
+ div { font-size: 1.2em;}
+ h1, h2, h3, h4, h5, ul { margin: .5em; }
+ a { color: black; margin-left: 2em; padding: 1em;}
+ a:visited { color: #111; }
+.critical, .warning, .passed { background-color: #E6E6E6; border-left: 5em solid; }
+.critical { border-left-color: #F00; }
+.warning { border-left-color: orange; }
+.passed { border-left-color: #0F0; }
+
+div { margin: 1em; border: 1px solid #ccc; padding: .5em; }
+ol li { margin: .01em; padding: 0; margin-left: 5em;  }
+ul li { margin: 1em; padding: 1em; list-style-type: none; }
+span { background-color: #ccc; padding: 1em; width: 500px;}
+span:hover { cursor: pointer; text-decoration: underline; }

data/lib/rvideo/reporter/views/report.html.erb

@@ -0,0 +1,81 @@
+  <html>
+    <head>
+      <title>RVideo Reports</title>
+      <link rel="stylesheet" href="<%= report.css %>" type="text/css" media="screen" />
+      <script type="text/javascript" src="<%= report.js %>"></script>
+    </head>
+    <body>
+      <div>
+        <h2><a href="<%= @result['output_file'] %>">Launch output file</a></h2>
+        <ul>
+          <li>
+            <div>
+              <h2>Recipe: <%= @recipe_name %></h2>
+              <p>
+              <% @result['recipe'].each do |key, value|%>
+                <%= key %>: <%= value %><br />
+              <% end %>
+              </p>
+            </div>
+          </li>
+          <% unless @result['errors'].nil? %>
+          <li>
+            <span onclick="toggle('rescued-errors');">Hide/Show Rescued Errors</span>
+            <div id='rescued-errors' style="display: none;">
+            <h2>Rescued Error Backtrace</h2>
+             <h4><%= h(@result['errors'].class.name) %></h4>
+             <p><%= h(@result['errors'].message)%>
+             <p><%= h(@result['errors'].backtrace) %></p>
+            </div>
+          </li>
+          <% end %>
+          <li>
+          <span onclick="toggle('transcoder');">Hide/Show Transcoder</span>
+          <div id='transcoder' style="display: none;">
+              <h2>Transcoder</h2>
+              <% unless @result['transcoder'].errors.empty? %>
+              <h3>Transcoder Errors</h3>
+              <p><%= h(@result['transcoder'].errors.inspect) %></p>
+              <% end %>
+              <h3>Executed Commands</h3>
+              <p><%= h(@result['transcoder'].executed_commands.map(&:command)) %></p>
+              <h3>Raw Meta</h3>
+              <p><%= h(@result['transcoder'].metadata) %></p>
+            </div>
+          <li> 
+            <span onclick="toggle('input-file');">Hide/Show Input File</span>
+            <div id='input-file' style="display: none;">
+              <h2>Original Input File</h2>
+              <h3>Raw Metadata</h3> 
+              <p><%= h(@result['transcoder'].original.raw_metadata) %></p>
+              <h3>Raw Response</h3> 
+              <p><%= h(@result['transcoder'].original.raw_response) %></p>
+            </div>
+          </li>
+          <% if @result['transcoder'].processed %>
+          <li>
+            <span onclick="toggle('output-file');">Hide/Show Output File</span>
+            <div id='output-file' style="display: none;">
+              <h2>Processed Output File</h2>
+              <h3>Raw Metadata</h3>
+              <p><%= h(@result['transcoder'].processed.raw_metadata) %></p>
+              <h3>Raw Response</h3>
+              <p><%= h(@result['transcoder'].processed.raw_response) %></p>
+            </div>          
+          </li>
+          <% end %>
+          <li> 
+            <span onclick="toggle('log');">Hide/Show Log</span>
+            <div id='log' style="display: none;">
+              <h2>Log</h2>
+              <p>
+              <% File.readlines(@result['log']).each do |line| %>
+                <%= line %> <br />
+              <% end %>
+              </p>
+            </div>
+          </li>
+        </ul>
+      </div>
+    </body>
+  </html>

data/lib/rvideo/reporter/views/report.js

@@ -0,0 +1,9 @@
+function toggle(obj) {
+	var el = document.getElementById(obj);
+	if ( el.style.display != 'none' ) {
+		el.style.display = 'none';
+	}
+	else {
+		el.style.display = '';
+	}
+}

data/lib/rvideo/tools/abstract_tool.rb

@@ -0,0 +1,79 @@
+module RVideo # :nodoc:
+  module Tools # :nodoc:
+    class AbstractTool
+      
+      #
+      # AbstractTool is an interface to every transcoder tool class (e.g. 
+      # ffmpeg, flvtool2). Called by the Transcoder class.
+      #
+      
+      def self.assign(cmd, options = {})
+        tool_name = cmd.split(" ").first
+        tool = "RVideo::Tools::#{tool_name.classify}".constantize.send(:new, cmd, options)
+      end
+      
+      
+      module InstanceMethods
+        attr_reader :options, :command, :raw_result
+        
+        def initialize(raw_command, options = {})
+          @options = HashWithIndifferentAccess.new(options)
+          @command = interpolate_variables(raw_command)
+        end
+        
+        #
+        # Look for variables surrounded by $, and interpolate with either (1)
+        # variables passed in the options hash, or special methods provided by
+        # the tool class (e.g. "$original_fps$" with ffmpeg).
+        #
+        # $foo$ should match
+        # \$foo or $foo\$ or \$foo\$ should not
+
+        def interpolate_variables(raw_command)
+          
+          raw_command.scan(/[^\\]\$[-_a-zA-Z]+\$/).each do |match|
+            match.strip!
+            raw_command.gsub!(match, matched_variable(match))
+          end
+          raw_command.gsub("\\$", "$")
+        end
+        
+        #
+        # Strip the $s. First, look for a supplied option that matches the
+        # variable name. If one is not found, look for a method that matches.
+        # If not found, raise ParameterError exception.
+        # 
+        
+        def matched_variable(match)
+          variable_name = match.gsub("$","")
+          if @options.key?(variable_name) 
+            @options[variable_name] || ""
+          elsif self.respond_to? variable_name
+            self.send(variable_name)
+          else
+            raise TranscoderError::ParameterError, "recipe is expecting a value for the #{variable_name} parameter, but it was not provided."
+          end
+        end
+    
+        #
+        # Execute the command and parse the result.
+        #
+        
+        def execute
+          final_command = "#{@command} 2>&1"
+          Transcoder.logger.info("Executing: #{final_command}")
+          @raw_result = `#{final_command}`
+          Transcoder.logger.info("Result: #{@raw_result}")
+          parse_result(@raw_result)
+        end
+
+        private
+        
+        def inspect_original
+          @original = Inspector.new(:file => options[:input_file])
+        end
+      end
+    
+    end
+  end
+end

data/lib/rvideo/tools/ffmpeg.rb

@@ -0,0 +1,111 @@
+module RVideo
+  module Tools
+    class Ffmpeg
+      include AbstractTool::InstanceMethods
+      
+      attr_reader :frame, :q, :size, :time, :bitrate, :video_size, :audio_size, :header_size, :overhead, :psnr, :fps
+      
+      # Not sure if this is needed anymore...
+      def tool_command
+        'ffmpeg'
+      end
+      
+      #
+      # Return -r and the frame rate of the original file. E.g.:
+      #
+      #   -r 29.97
+      #
+      # If the original frame rate can't be determined, return an empty 
+      # string.
+      def original_fps
+        inspect_original if @original.nil?
+        if @original.fps
+          "-r #{@original.fps}" 
+        else
+          ""
+        end
+      end
+      
+      private
+      
+      def parse_result(result)
+        if m = /Unable for find a suitable output format for.*$/.match(result)
+          raise TranscoderError::InvalidCommand, m[0]
+        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 result =~ /usage: ffmpeg/
+          raise TranscoderError::InvalidCommand, "must pass a command to ffmpeg"
+        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%
+        
+        # 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 = sanitary_match(/frame=\s*(\S*)/, details)
+          @fps = sanitary_match(/fps=\s*(\S*)/, details)
+          @q = sanitary_match(/\s+q=\s*(\S*)/, details)
+          @size = sanitary_match(/size=\s*(\S*)/, details)
+          @time = sanitary_match(/time=\s*(\S*)/, details)
+          @bitrate = sanitary_match(/bitrate=\s*(\S*)/, details)
+          
+          @video_size = /video:\s*(\S*)/.match(details)[1]
+          @audio_size = /audio:\s*(\S*)/.match(details)[1]
+          @header_size = /headers:\s*(\S*)/.match(details)[1]
+          @overhead = /overhead[:]*\s*(\S*)/.match(details)[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
+
+      def sanitary_match(regexp, string)
+        match = regexp.match(string)
+        return match[1] if match
+      end
+      
+    end
+  end
+end