newbamboo-rvideo 0.9.6

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.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/string.rb

@@ -0,0 +1,5 @@
+class ::String
+  def shell_quoted
+    "'" << self << "'"
+  end
+end

data/lib/rvideo/tools/abstract_tool.rb

@@ -0,0 +1,406 @@
+module RVideo # :nodoc:
+  module Tools  # :nodoc:
+  
+    # AbstractTool is an interface to every transcoder tool class 
+    # (e.g. ffmpeg, flvtool2). Called by the Transcoder class.
+    class AbstractTool
+
+      def self.assign(cmd, options = {})
+        tool_name = cmd.split(" ").first
+        begin
+          tool = "RVideo::Tools::#{tool_name.underscore.classify}".constantize.send(:new, cmd, options)
+        # rescue NameError, /uninitialized constant/
+          # raise TranscoderError::UnknownTool, "The recipe tried to use the '#{tool_name}' tool, which does not exist."
+        rescue => e
+          RVideo.logger.info e.message
+          RVideo.logger.info e.backtrace.join("\n")
+          raise e
+        end
+      end
+  
+  
+      module InstanceMethods
+        # Defines abstract methods in the convention of "format_#{attribute}" 
+        # which are meant to be redefined by classes including this behavior.
+        def self.abstract_attribute_formatter(*names)
+          names.map { |n| "format_#{n}" }.each do |name|
+            class_eval %{
+              def #{name}(params = {})
+                raise ParameterError,
+                  "The #{self.class} tool has not implemented the :#{name} method."
+              end
+            }, __FILE__, __LINE__
+          end
+        end
+    
+        abstract_attribute_formatter :resolution, :deinterlace, :fps,
+          :video_bit_rate, :video_bit_rate_tolerance,
+          :video_bit_rate_min, :video_bit_rate_max,
+          :audio_channels, :audio_bit_rate, :audio_sample_rate
+    
+        ###
+    
+        attr_reader :options, :command, :raw_result, :progress
+        attr_writer :original
+    
+        def initialize(raw_command, options = {})
+          @raw_command = raw_command
+          @options = HashWithIndifferentAccess.new(options)
+          @command = interpolate_variables(raw_command)
+        end
+
+        def execute
+          @output_params = {}
+          if block_given? and self.respond_to?(:execute_with_progress)
+            execute_with_progress do |progress|
+              yield progress
+            end
+          else
+            # Dump the log output into a temp file
+            log_temp_file_name = "/tmp/transcode_output_#{Time.now.to_i}_#{rand(100)}.txt"
+
+            final_command = "#{@command} 2>#{log_temp_file_name}"
+            RVideo.logger.info("\nExecuting Command: #{final_command}\n")
+            
+            do_execute final_command
+            populate_raw_result(log_temp_file_name)
+          end
+      
+          RVideo.logger.info("Result: \n#{@raw_result}")
+          parse_result(@raw_result)
+      
+          # Cleanup log file
+          begin
+            File.delete(log_temp_file_name)
+          rescue Exception  => e
+            RVideo.logger.error("Failed to delete output log file: #{log_temp_file_name}, e=#{e}")
+          end
+        end
+    
+        # Wrapper around the system call, for whenever we need to 
+        # hook on or redefine this without messing with Kernel
+        def do_execute(command)
+          system command
+        end
+    
+        #
+        # Magic parameters
+        #
+        def temp_dir
+          if @options['output_file']
+            "#{File.dirname(@options['output_file'])}/"
+          else
+            ""
+          end
+        end
+    
+        ###
+        # FPS aka framerate
+    
+        def fps
+          format_fps(get_fps)
+        end
+    
+        def get_fps
+          inspect_original if @original.nil?
+          fps = @options['fps'] || ""
+          case fps
+          when "copy"
+            get_original_fps
+          else
+            get_specific_fps
+          end
+        end
+    
+        def get_original_fps
+          return {} if @original.fps.nil?
+          { :fps => @original.fps }
+        end
+    
+        def get_specific_fps
+          { :fps => @options['fps'] }
+        end
+    
+        ###
+        # Resolution
+
+        def deinterlace
+          format_deinterlace(get_deinterlace)
+        end
+
+        def get_deinterlace
+          { :deinterlace => @options['deinterlace'] ? true : false }
+        end
+
+        def resolution
+          format_resolution(get_resolution)
+        end
+
+        def get_resolution
+          inspect_original if @original.nil?
+      
+          case @options['resolution']
+          when "copy"      then get_original_resolution
+          when "width"     then get_fit_to_width_resolution
+          when "height"    then get_fit_to_height_resolution
+          when "letterbox" then get_letterbox_resolution
+          else
+            if @options["width"] and not @options["height"]
+              get_fit_to_width_resolution
+            elsif @options["height"] and not @options["width"]
+              get_fit_to_height_resolution
+            elsif @options["width"] and @options["height"]
+              get_specific_resolution
+            else
+              get_original_resolution
+            end
+          end
+        end
+
+        def get_fit_to_width_resolution
+          w = @options['width']
+      
+          raise TranscoderError::ParameterError,
+            "invalid width of '#{w}' for fit to width" unless valid_dimension?(w)
+      
+          h = calculate_height(@original.width, @original.height, w)
+      
+          { :scale => { :width => w, :height => h } }
+        end
+    
+        def get_fit_to_height_resolution
+          h = @options['height']
+      
+          raise TranscoderError::ParameterError,
+            "invalid height of '#{h}' for fit to height" unless valid_dimension?(h)
+      
+          w = calculate_width(@original.width, @original.height, h)
+      
+          { :scale => { :width => w, :height => h } }
+        end
+    
+        def get_letterbox_resolution
+          lw = @options['width'].to_i
+          lh = @options['height'].to_i
+      
+          raise TranscoderError::ParameterError,
+            "invalid width of '#{lw}' for letterbox" unless valid_dimension?(lw)
+          raise TranscoderError::ParameterError,
+            "invalid height of '#{lh}' for letterbox" unless valid_dimension?(lh)
+      
+          w = calculate_width(@original.width, @original.height, lh)
+          h = calculate_height(@original.width, @original.height, lw)
+      
+          if w > lw
+            w = lw
+            h = calculate_height(@original.width, @original.height, lw)
+          else
+            h = lh
+            w = calculate_width(@original.width, @original.height, lh)
+          end
+      
+          { :scale     => { :width => w,  :height => h  },
+            :letterbox => { :width => lw, :height => lh } }
+        end
+    
+        def get_original_resolution
+          { :scale => { :width => @original.width, :height => @original.height } }
+        end
+
+        def get_specific_resolution
+          w = @options['width']
+          h = @options['height']
+      
+          raise TranscoderError::ParameterError,
+            "invalid width of '#{w}' for specific resolution" unless valid_dimension?(w)
+          raise TranscoderError::ParameterError,
+            "invalid height of '#{h}' for specific resolution" unless valid_dimension?(h)
+      
+          { :scale => { :width => w, :height => h } }
+        end
+    
+        def calculate_width(ow, oh, h)
+          w = ((ow.to_f / oh.to_f) * h.to_f).to_i
+          (w.to_f / 16).round * 16
+        end
+
+        def calculate_height(ow, oh, w)
+          h = (w.to_f / (ow.to_f / oh.to_f)).to_i
+          (h.to_f / 16).round * 16
+        end
+    
+        def valid_dimension?(dim)
+          dim.to_i > 0
+        end
+    
+        ###
+        # Audio channels
+    
+        def audio_channels
+          format_audio_channels(get_audio_channels)
+        end
+
+        def get_audio_channels
+          channels = @options['audio_channels'] || ""
+          case channels
+          when "stereo"
+            get_stereo_audio
+          when "mono"
+            get_mono_audio
+          else
+            {}
+          end
+        end
+    
+        def get_stereo_audio
+          { :channels => "2" }
+        end
+    
+        def get_mono_audio
+          { :channels => "1" }
+        end
+    
+        def get_specific_audio_bit_rate
+          { :bit_rate => @options['audio_bit_rate'] }
+        end
+    
+        def get_specific_audio_sample_rate
+          { :sample_rate => @options['audio_sample_rate'] }
+        end
+    
+        ###
+        # Audio bit rate
+    
+        def audio_bit_rate
+          format_audio_bit_rate(get_audio_bit_rate)
+        end
+    
+        def get_audio_bit_rate
+          bit_rate = @options['audio_bit_rate'] || ""
+          case bit_rate
+          when ""
+            {}
+          else
+            get_specific_audio_bit_rate
+          end
+        end
+    
+        ###
+        # Audio sample rate
+    
+        def audio_sample_rate
+          format_audio_sample_rate(get_audio_sample_rate)
+        end
+    
+        def get_audio_sample_rate
+          sample_rate = @options['audio_sample_rate'] || ""
+          case sample_rate
+          when ""
+            {}
+          else
+            get_specific_audio_sample_rate
+          end
+        end
+    
+        ###
+        # Video quality
+    
+        def video_quality
+          format_video_quality(get_video_quality)
+        end
+    
+        def get_video_quality
+          quality = @options['video_quality'] || 'medium'
+          
+          { :video_quality => quality }.
+            merge!(get_fps).
+            merge!(get_resolution).
+            merge!(get_video_bit_rate)
+        end
+        
+        def video_bit_rate
+          format_video_bit_rate(get_video_bit_rate)
+        end
+        
+        def get_video_bit_rate
+          { :video_bit_rate => @options["video_bit_rate"] }
+        end
+        
+        def video_bit_rate_tolerance
+          format_video_bit_rate_tolerance(get_video_bit_rate_tolerance)
+        end
+        
+        def get_video_bit_rate_tolerance
+          { :video_bit_rate_tolerance => @options["video_bit_rate_tolerance"] }
+        end
+        
+        def video_bit_rate_min
+          format_video_bit_rate_min(get_video_bit_rate_min)
+        end
+        
+        def get_video_bit_rate_min
+          { :video_bit_rate_min => @options["video_bit_rate_min"] }
+        end
+        
+        def video_bit_rate_max
+          format_video_bit_rate_max(get_video_bit_rate_max)
+        end
+        
+        def get_video_bit_rate_max
+          { :video_bit_rate_max => @options["video_bit_rate_max"] }
+        end
+
+      private
+        
+        VARIABLE_INTERPOLATION_SCAN_PATTERN = /[^\\]\$[-_a-zA-Z]+\$/
+        
+        def interpolate_variables(raw_command)
+          raw_command.scan(VARIABLE_INTERPOLATION_SCAN_PATTERN).each do |match|
+            match = match[0..0] == "$" ? match : match[1..(match.size - 1)]
+            match.strip!
+            
+            value = if ["$input_file$", "$output_file$"].include?(match)
+              matched_variable(match).to_s.shell_quoted
+            else
+              matched_variable(match).to_s
+            end
+            
+            raw_command.gsub!(match, value)
+          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 self.respond_to? variable_name
+            self.send(variable_name)
+          elsif @options.key?(variable_name) 
+            @options[variable_name]
+          else
+            raise TranscoderError::ParameterError,
+              "command is looking for the #{variable_name} parameter, but it was not provided. (Command: #{@raw_command})"
+          end
+        end
+        
+    
+        def inspect_original
+          @original = Inspector.new(:file => options[:input_file])
+        end
+    
+        # Pulls the interesting bits of the temp log file into memory.  This is fairly tool-specific, so
+        # it's doubtful that this default version is going to work without being overridded.
+        def populate_raw_result(temp_file_name)
+          @raw_result = `tail -n 500 #{temp_file_name}`
+        end
+    
+      end # InstanceMethods
+    end
+
+  end
+end