apple-tv-converter 0.2.0 → 0.3.0

data/gems/streamio-ffmpeg/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler.require
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+desc "Push a new version to Rubygems"
+task :publish do
+  require 'ffmpeg/version'
+
+  sh "gem build streamio-ffmpeg.gemspec"
+  sh "gem push streamio-ffmpeg-#{FFMPEG::VERSION}.gem"
+  sh "git tag v#{FFMPEG::VERSION}"
+  sh "git push origin v#{FFMPEG::VERSION}"
+  sh "git push origin master"
+  sh "rm streamio-ffmpeg-#{FFMPEG::VERSION}.gem"
+end

data/gems/streamio-ffmpeg/lib/ffmpeg/encoding_options.rb

@@ -0,0 +1,139 @@
+module FFMPEG
+  class EncodingOptions < Hash
+    def initialize(options = {})
+      merge!(options)
+    end
+
+    def to_s
+      params = collect do |key, value|
+        send("convert_#{key}", value) if value && supports_option?(key)
+      end
+
+      # codecs should go before the presets so that the files will be matched successfully
+      # all other parameters go after so that we can override whatever is in the preset
+      codecs = params.select { |p| p =~ /codec/ }
+      presets = params.select { |p| p =~ /\-.pre/ }
+      other = params - codecs - presets
+      params = codecs + presets + other
+
+      params_string = params.join(" ")
+      params_string << " #{convert_aspect(calculate_aspect)}" if calculate_aspect?
+      params_string
+    end
+
+    def width
+      self[:resolution].split("x").first.to_i rescue nil
+    end
+
+    def height
+      self[:resolution].split("x").last.to_i rescue nil
+    end
+
+    private
+    def supports_option?(option)
+      option = RUBY_VERSION < "1.9" ? "convert_#{option}" : "convert_#{option}".to_sym
+      private_methods.include?(option)
+    end
+
+    def convert_aspect(value)
+      "-aspect #{value}"
+    end
+
+    def calculate_aspect
+      width, height = self[:resolution].split("x")
+      width.to_f / height.to_f
+    end
+
+    def calculate_aspect?
+      self[:aspect].nil? && self[:resolution]
+    end
+
+    def convert_video_codec(value)
+      "-vcodec #{value}"
+    end
+
+    def convert_frame_rate(value)
+      "-r #{value}"
+    end
+
+    def convert_resolution(value)
+      "-s #{value}"
+    end
+
+    def convert_video_bitrate(value)
+      "-b:v #{k_format(value)}"
+    end
+
+    def convert_audio_codec(value)
+      "-acodec #{value}"
+    end
+
+    def convert_audio_bitrate(value)
+      "-b:a #{k_format(value)}"
+    end
+
+    def convert_audio_sample_rate(value)
+      "-ar #{value}"
+    end
+
+    def convert_audio_channels(value)
+      "-ac #{value}"
+    end
+
+    def convert_video_max_bitrate(value)
+      "-maxrate #{k_format(value)}"
+    end
+
+    def convert_video_min_bitrate(value)
+      "-minrate #{k_format(value)}"
+    end
+
+    def convert_buffer_size(value)
+      "-bufsize #{k_format(value)}"
+    end
+
+    def convert_video_bitrate_tolerance(value)
+      "-bt #{k_format(value)}"
+    end
+
+    def convert_threads(value)
+      "-threads #{value}"
+    end
+
+    def convert_duration(value)
+      "-t #{value}"
+    end
+
+    def convert_video_preset(value)
+      "-vpre #{value}"
+    end
+
+    def convert_audio_preset(value)
+      "-apre #{value}"
+    end
+
+    def convert_file_preset(value)
+      "-fpre #{value}"
+    end
+
+    def convert_keyframe_interval(value)
+      "-g #{value}"
+    end
+
+    def convert_seek_time(value)
+      "-ss #{value}"
+    end
+
+    def convert_screenshot(value)
+      value ? "-vframes 1 -f image2" : ""
+    end
+
+    def convert_custom(value)
+      value
+    end
+
+    def k_format(value)
+      value.to_s.include?("k") ? value : "#{value}k"
+    end
+  end
+end

data/gems/streamio-ffmpeg/lib/ffmpeg/errors.rb

@@ -0,0 +1,4 @@
+module FFMPEG
+  class Error < StandardError
+  end
+end

data/gems/streamio-ffmpeg/lib/ffmpeg/io_monkey.rb

@@ -0,0 +1,42 @@
+require 'timeout'
+require 'thread'
+if RUBY_PLATFORM =~ /(win|w)(32|64)$/
+  begin
+    require 'win32/process'
+  rescue LoadError
+    "Warning: streamio-ffmpeg is missing the win32-process gem to properly handle hung transcodings. Install the gem (in Gemfile if using bundler) to avoid errors."
+  end
+end
+
+#
+# Monkey Patch timeout support into the IO class
+#
+class IO
+  def each_with_timeout(pid, seconds, sep_string=$/)
+    last_update = Time.now
+
+    current_thread = Thread.current
+    check_update_thread = Thread.new do
+      loop do
+        sleep 0.1
+        if last_update - Time.now < -seconds
+          current_thread.raise Timeout::Error.new('output wait time expired')
+        end
+      end
+    end
+
+    each(sep_string) do |buffer|
+      last_update = Time.now
+      yield buffer
+    end
+  rescue Timeout::Error
+    if RUBY_PLATFORM =~ /(win|w)(32|64)$/
+      Process.kill(1, pid)
+    else
+      Process.kill('SIGKILL', pid)
+    end
+    raise
+  ensure
+    check_update_thread.kill
+  end
+end

data/gems/streamio-ffmpeg/lib/ffmpeg/movie.rb

@@ -0,0 +1,206 @@
+require 'time'
+
+module FFMPEG
+  class Movie
+    attr_reader :path, :duration, :time, :bitrate, :rotation, :creation_time
+    attr_reader :video_stream, :video_codec, :video_bitrate, :colorspace, :resolution, :dar
+    attr_reader :audio_stream, :audio_codec, :audio_bitrate, :audio_sample_rate
+    attr_reader :container
+    attr_reader :streams
+
+    def initialize(path)
+      raise Errno::ENOENT, "the file '#{path}' does not exist" unless File.exists?(path)
+
+      @path = path
+
+      # ffmpeg will output to stderr
+      if RUBY_PLATFORM =~ /(win|w)(32|64)$/
+        command = %Q[#{FFMPEG.ffmpeg_binary}" -i "#{path}]
+      else
+        command = "#{FFMPEG.ffmpeg_binary} -i #{Shellwords.escape(path)}"
+      end
+
+      output = Open3.popen3(command) { |stdin, stdout, stderr| stderr.read }
+
+      fix_encoding(output)
+
+      output[/Input \#\d+\,\s*(\S+),\s*from/]
+      @container = $1
+
+      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
+
+      if video_stream
+        @video_codec, @colorspace, resolution, video_bitrate = video_stream.split(/\s?,\s?/)
+        @video_bitrate = video_bitrate =~ %r(\A(\d+) kb/s\Z) ? $1.to_i : nil
+        @resolution = resolution.split(" ").first rescue nil # get rid of [PAR 1:1 DAR 16:9]
+        @dar = $1 if video_stream[/DAR (\d+:\d+)/]
+      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(?: \(default\))?\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")
+
+      load_all_streams output if valid?
+    end
+
+    def valid?
+      not @invalid
+    end
+
+    def width
+      resolution.split("x")[0].to_i rescue nil
+    end
+
+    def height
+      resolution.split("x")[1].to_i rescue nil
+    end
+
+    def calculated_aspect_ratio
+      aspect_from_dar || aspect_from_dimensions
+    end
+
+    def size
+      File.size(@path)
+    end
+
+    def audio_channels
+      return nil unless @audio_channels
+      return @audio_channels[/\d*/].to_i if @audio_channels["channels"]
+      return 1 if @audio_channels["mono"]
+      return 2 if @audio_channels["stereo"]
+      return 6 if @audio_channels["5.1"]
+    end
+
+    def frame_rate
+      return nil unless video_stream
+      video_stream[/(\d*\.?\d*)\s?fps/] ? $1.to_f : nil
+    end
+
+    def transcode(output_file, options = EncodingOptions.new, transcoder_options = {}, &block)
+      Transcoder.new(self, output_file, options, transcoder_options).run &block
+    end
+
+    def screenshot(output_file, options = EncodingOptions.new, transcoder_options = {}, &block)
+      Transcoder.new(self, output_file, options.merge(screenshot: true), transcoder_options).run &block
+    end
+
+    protected
+    def aspect_from_dar
+      return nil unless dar
+      w, h = dar.split(":")
+      aspect = w.to_f / h.to_f
+      aspect.zero? ? nil : aspect
+    end
+
+    def aspect_from_dimensions
+      aspect = width.to_f / height.to_f
+      aspect.nan? ? nil : aspect
+    end
+
+    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
+
+    def load_all_streams(ffmpeg_output)
+      @streams = ffmpeg_output.split(/.*? (?=(?:Chapter|Stream))/).map do |line|
+        if line =~ /^Stream #\d+:\d+/
+          begin
+            stream = FFMPEG::Stream.new
+            bogus, input_number, stream_number, language, type = line.match(/Stream #(\d+):(\d+)(?:\((.*?)\))?:\s*(\w+):(.*)\n/).to_a
+
+            stream.send(:input_number=, input_number)
+            stream.send(:stream_number=, stream_number)
+            if language
+              language_code = language.match(/(?<=\[)\w+(?=\])/)
+              if language_code
+                stream.send(:language=, language_code.to_a.first)
+              else
+                stream.send(:language=, language)
+              end
+            # else
+            #   stream.send(:language=, :unk)
+            end
+            stream.send(:type=, type.downcase.gsub(/s$/, '').to_sym)
+
+            build_audio_stream stream, line if stream.type == :audio
+            build_video_stream stream, line if stream.type == :video
+            build_subtitle_stream stream, line if stream.type == :subtitle
+          rescue => e
+            ap [
+              e,
+              ffmpeg_output.split(/.*? (?=(?:Chapter|Stream))/),
+             line,
+             input_number, stream_number, language, type
+           ]
+
+            exit!
+          end
+          stream
+        else
+          nil
+        end
+      end
+
+      @streams = @streams.compact
+    end
+
+    def build_audio_stream(stream, line)
+      audio_codec, audio_sample_rate, audio_channels, unused, audio_bitrate = line.gsub(/^.*?Audio:\s/, '').split(/\s?,\s?/)
+      audio_bitrate = audio_bitrate =~ %r(\A(\d+) kb/s(?: \(default\))\Z) ? $1.to_i : nil
+      audio_sample_rate = audio_sample_rate[/\d*/].to_i
+
+      stream.send :audio_codec=, audio_codec
+      stream.send :audio_sample_rate=, audio_sample_rate
+      stream.send :audio_channels=, audio_channels
+      stream.send :audio_bitrate=, audio_bitrate
+    end
+
+    def build_video_stream(stream, line)
+      video_codec, colorspace, resolution, video_bitrate = line.gsub(/^.*?Video:\s/, '').split(/\s?,\s?/)
+      video_bitrate = video_bitrate =~ %r(\A(\d+) kb/s\Z) ? $1.to_i : nil
+      resolution = resolution.split(" ").first rescue nil # get rid of [PAR 1:1 DAR 16:9]
+      dar = $1 if video_stream[/DAR (\d+:\d+)/]
+
+      stream.send :video_codec=, video_codec
+      stream.send :colorspace=, colorspace
+      stream.send :resolution=, resolution
+      stream.send :video_bitrate=, video_bitrate
+      stream.send :dar=, dar
+    end
+
+    def build_subtitle_stream(stream, line)
+      subtitle_codec = line.split("\n").first.gsub(/^.*?Subtitles?:\s/, '').strip
+      subtitle_format = subtitle_codec.split(/\s+/).first
+
+      stream.send :subtitle_codec=, subtitle_codec
+      stream.send :subtitle_format=, subtitle_format
+    end
+  end
+end

data/gems/streamio-ffmpeg/lib/ffmpeg/stream.rb

@@ -0,0 +1,15 @@
+module FFMPEG
+  class Stream
+    attr_reader :input_number, :stream_number, :language, :type
+    attr_reader :video_codec, :video_bitrate, :colorspace, :resolution, :dar
+    attr_reader :audio_channels, :audio_codec, :audio_bitrate, :audio_sample_rate
+    attr_reader :subtitle_codec, :subtitle_format
+
+    private
+
+      attr_writer :input_number, :stream_number, :language, :type
+      attr_writer :video_codec, :video_bitrate, :colorspace, :resolution, :dar
+      attr_writer :audio_channels, :audio_codec, :audio_bitrate, :audio_sample_rate
+      attr_writer :subtitle_codec, :subtitle_format
+  end
+end

data/gems/streamio-ffmpeg/lib/ffmpeg/transcoder.rb

@@ -0,0 +1,120 @@
+require 'open3'
+require 'shellwords'
+
+module FFMPEG
+  class Transcoder
+    @@timeout = 30
+
+    def self.timeout=(time)
+      @@timeout = time
+    end
+
+    def self.timeout
+      @@timeout
+    end
+
+    def initialize(movie, output_file, options = EncodingOptions.new, transcoder_options = {})
+      @movie = movie
+      @output_file = output_file
+      @validate_output = transcoder_options[:validate_output] != false
+
+      if options.is_a?(String) || options.is_a?(EncodingOptions)
+        @raw_options = options
+      elsif options.is_a?(Hash)
+        @raw_options = EncodingOptions.new(options)
+      else
+        raise ArgumentError, "Unknown options format '#{options.class}', should be either EncodingOptions, Hash or String."
+      end
+
+      @transcoder_options = transcoder_options
+      @errors = []
+
+      apply_transcoder_options
+    end
+
+    # frame= 4855 fps= 46 q=31.0 size=   45306kB time=00:02:42.28 bitrate=2287.0kbits/
+    def run
+
+      if RUBY_PLATFORM =~ /(win|w)(32|64)$/
+        command = %Q["#{FFMPEG.ffmpeg_binary}" -y -i "#{@movie.path}" #{@raw_options} "#{@output_file}"]
+      else
+        command = "#{FFMPEG.ffmpeg_binary} -y -i #{Shellwords.escape(@movie.path)} #{@raw_options} #{Shellwords.escape(@output_file)}"
+      end
+
+      FFMPEG.logger.info("Running transcoding...\n#{command}\n")
+      output = ""
+      Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+        begin
+          yield(0.0) if block_given?
+          next_line = Proc.new do |line|
+            fix_encoding(line)
+            output << line
+            if line.include?("time=")
+              if line =~ /time=(\d+):(\d+):(\d+.\d+)/ # ffmpeg 0.8 and above style
+                time = ($1.to_i * 3600) + ($2.to_i * 60) + $3.to_f
+              else # better make sure it wont blow up in case of unexpected output
+                time = 0.0
+              end
+              progress = time / @movie.duration
+              yield(progress) if block_given?
+            end
+          end
+
+          if @@timeout
+            stderr.each_with_timeout(wait_thr.pid, @@timeout, 'size=', &next_line)
+          else
+            stderr.each('size=', &next_line)
+          end
+
+        rescue Timeout::Error => e
+          FFMPEG.logger.error "Process hung...\nCommand\n#{command}\nOutput\n#{output}\n"
+          raise Error, "Process hung. Full output: #{output}"
+        end
+      end
+
+      if encoding_succeeded?
+        yield(1.0) if block_given?
+        FFMPEG.logger.info "Transcoding of #{@movie.path} to #{@output_file} succeeded\n"
+      else
+        errors = "Errors: #{@errors.join(", ")}. "
+        FFMPEG.logger.error "Failed encoding...\n#{command}\n\n#{output}\n#{errors}\n"
+        raise Error, "Failed encoding.#{errors}Full output: #{output}"
+      end
+
+      encoded
+    end
+
+    def encoding_succeeded?
+      @errors << "no output file created" and return false unless File.exists?(@output_file)
+      (@errors << "encoded file is invalid" and return false unless encoded.valid?) if @validate_output
+      true
+    end
+
+    def encoded
+      @encoded ||= Movie.new(@output_file)
+    end
+
+    private
+    def apply_transcoder_options
+      return if @movie.calculated_aspect_ratio.nil?
+      case @transcoder_options[:preserve_aspect_ratio].to_s
+      when "width"
+        new_height = @raw_options.width / @movie.calculated_aspect_ratio
+        new_height = new_height.ceil.even? ? new_height.ceil : new_height.floor
+        new_height += 1 if new_height.odd? # needed if new_height ended up with no decimals in the first place
+        @raw_options[:resolution] = "#{@raw_options.width}x#{new_height}"
+      when "height"
+        new_width = @raw_options.height * @movie.calculated_aspect_ratio
+        new_width = new_width.ceil.even? ? new_width.ceil : new_width.floor
+        new_width += 1 if new_width.odd?
+        @raw_options[:resolution] = "#{new_width}x#{@raw_options.height}"
+      end
+    end
+
+    def fix_encoding(output)
+      output[/test/]
+    rescue ArgumentError
+      output.force_encoding("ISO-8859-1")
+    end
+  end
+end