tivohmo 0.1.0

data/lib/tivohmo/adapters/streamio/transcoder.rb

@@ -0,0 +1,239 @@
+module TivoHMO
+  module Adapters
+    module StreamIO
+
+
+      # Transcodes video to tivo format using the streamio gem (ffmpeg)
+      class Transcoder
+        include TivoHMO::API::Transcoder
+        include GemLogger::LoggerSupport
+
+        # TODO: add ability to pass through data (copy codec)
+        # for files that are already (partially?) in the right
+        # format for tivo.  Check against a mapping of
+        # tivo serial->allowed_formats
+        # https://code.google.com/p/streambaby/wiki/video_compatibility
+
+        def transcode(writeable_io, format="video/x-tivo-mpeg")
+          tmpfile = Tempfile.new('tivohmo_transcode')
+          begin
+            transcode_thread = run_transcode(tmpfile.path, format)
+
+            # give the transcode thread a chance to start up before we
+            # start copying from it.  Not strictly necessary, but makes
+            # the log messages show up in the right order
+            sleep 0.1
+
+            run_copy(tmpfile.path, writeable_io, transcode_thread)
+          ensure
+            tmpfile.close
+            tmpfile.unlink
+          end
+
+          nil
+        end
+
+        def transcoder_options(format="video/x-tivo-mpeg")
+          opts = {
+              video_max_bitrate: 30000,
+              buffer_size: 4096,
+              audio_bitrate: 448,
+              format: format,
+              custom: []
+          }
+
+          opts = select_video_frame_rate(opts)
+          opts = select_video_dimensions(opts)
+          opts = select_video_codec(opts)
+          opts = select_video_bitrate(opts)
+          opts = select_audio_codec(opts)
+          opts = select_audio_sample_rate(opts)
+          opts = select_container(opts)
+
+          opts[:custom] = opts[:custom].join(" ") if opts[:custom]
+          opts.delete(:format)
+
+          opts
+        end
+
+        protected
+
+        def movie
+          @movie ||= FFMPEG::Movie.new(source_filename)
+        end
+
+        def video_info
+          @video_info ||= begin
+            info_attrs = %w[
+              path duration time bitrate rotation creation_time
+              video_stream video_codec video_bitrate colorspace dar
+              audio_stream audio_codec audio_bitrate audio_sample_rate
+              calculated_aspect_ratio size audio_channels frame_rate container
+              resolution width height
+            ]
+            Hash[info_attrs.collect {|attr| [attr.to_sym, movie.send(attr)] }]
+          end
+        end
+
+        def select_container(opts)
+          if opts[:format] == 'video/x-tivo-mpeg-ts'
+            opts[:custom] << "-f mpegts"
+          else
+            opts[:custom] << "-f vob"
+          end
+          opts
+        end
+
+        def select_audio_sample_rate(opts)
+          if video_info[:audio_sample_rate]
+            if AUDIO_SAMPLE_RATES.include?(video_info[:audio_sample_rate])
+              opts[:audio_sample_rate] = video_info[:audio_sample_rate]
+            else
+              opts[:audio_sample_rate] = 48000
+            end
+          end
+          opts
+        end
+
+        def select_audio_codec(opts)
+          if video_info[:audio_codec]
+            if AUDIO_CODECS.any? { |ac| video_info[:audio_codec] =~ /#{ac}/ }
+              opts[:audio_codec] = 'copy'
+              if video_info[:video_codec] =~ /mpeg2video/
+                opts[:custom] << "-copyts"
+              end
+            else
+              opts[:audio_codec] = 'ac3'
+            end
+          end
+          opts
+        end
+
+        def select_video_bitrate(opts)
+          if video_info[:video_bitrate].to_i >= opts[:video_max_bitrate]
+            opts[:video_bitrate] = (video_info[:video_max_bitrate] * 0.95).to_i
+          end
+          opts
+        end
+
+        def select_video_codec(opts)
+          if VIDEO_CODECS.any? { |vc| video_info[:video_codec] =~ /#{vc}/ }
+            opts[:video_codec] = 'copy'
+            if video_info[:video_codec] =~ /h264/
+              opts[:custom] << "-bsf h264_mp4toannexb"
+            end
+          else
+            opts[:video_codec] = 'mpeg2video'
+            opts[:custom] << "-pix_fmt yuv420p"
+          end
+          opts
+        end
+
+        def select_video_dimensions(opts)
+          preserve_aspect = nil
+          video_width = video_info[:width].to_i
+          VIDEO_WIDTHS.each do |w|
+            w = w.to_i
+            if video_width >= w
+              video_width = w
+              opts[:preserve_aspect_ratio] = :width
+              break
+            end
+          end
+          video_width = VIDEO_WIDTHS.last.to_i unless video_width
+
+          video_height = video_info[:height].to_i
+          VIDEO_WIDTHS.each do |h|
+            h = h.to_i
+            if video_height >= h
+              video_height = h
+              opts[:preserve_aspect_ratio] = :height
+              break
+            end
+          end
+          video_height = VIDEO_HEIGHTS.last.to_i unless video_height
+          opts[:resolution] = "#{video_width}x#{video_height}"
+          opts[:preserve_aspect_ratio] = :height unless opts[:preserve_aspect_ratio]
+          opts
+        end
+
+        def select_video_frame_rate(opts)
+          if !VIDEO_FRAME_RATES.include?(video_info[:frame_rate])
+            opts[:frame_rate] = 29.97
+          end
+          opts
+        end
+
+        def run_transcode(output_filename, format)
+
+          logger.debug "Movie Info: " +
+                          video_info.collect {|k, v| "#{k}='#{v}'"}.join(' ')
+
+          opts = transcoder_options(format)
+
+          logger.debug "Transcoding options: " +
+                           opts.collect {|k, v| "#{k}='#{v}'"}.join(' ')
+
+
+          aspect_opt = opts.delete(:preserve_aspect_ratio)
+          t_opts = {}
+          t_opts[:preserve_aspect_ratio] = aspect_opt if aspect_opt
+
+
+          transcode_thread = Thread.new do
+            begin
+              logger.info "Starting transcode to: #{output_filename}"
+              transcoded_movie = movie.transcode(output_filename, opts, t_opts) do |progress|
+                logger.info "Trancoding #{item}: #{progress}"
+                raise "Halted" if Thread.current[:halt]
+              end
+              logger.info "Transcoding completed, transcoded file size: #{File.size(output_filename)}"
+            rescue => e
+              logger.error ("Transcode failed: #{e}")
+            end
+          end
+
+          return transcode_thread
+        end
+
+        # we could avoid this if streamio-ffmpeg had a way to output to an IO, but
+        # it only supports file based output for now, so have to manually copy the
+        # file's bytes to our output stream
+        def run_copy(transcoded_filename, writeable_io, transcode_thread)
+          logger.info "Starting stream copy from: #{transcoded_filename}"
+          file = File.open(transcoded_filename, 'rb')
+          begin
+            bytes_copied = 0
+
+            # copying the IO from transcoded file to web output
+            # stream is faster than the transcoding, and thus we
+            # hit eof before transcode is done.  Therefore we need
+            # to keep retrying while the transcode thread is alive,
+            # then to avoid a race condition at the end, we keep
+            # going till we've copied all the bytes
+            while transcode_thread.alive? || bytes_copied < File.size(transcoded_filename)
+              # sleep a bit at start of thread so we don't have a
+              # wasteful tight loop when transcoding is really slow
+              sleep 0.2
+
+              while data = file.read(4096)
+                break unless data.size > 0
+                writeable_io << data
+                bytes_copied += data.size
+                end
+              end
+
+            logger.info "Stream copy completed, #{bytes_copied} bytes copied"
+          rescue => e
+            logger.error ("Stream copy failed: #{e}")
+            transcode_thread[:halt] = true
+          ensure
+            file.close
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/tivohmo/adapters/streamio.rb

@@ -0,0 +1,17 @@
+require 'streamio-ffmpeg'
+require_relative 'streamio/transcoder'
+require_relative 'streamio/metadata'
+
+module TivoHMO
+  module BasicAdapter
+
+    class StreamIO
+      include GemLogger::LoggerSupport
+
+      FFMPEG.logger = self.logger
+      # FFMPEG.ffmpeg_binary =
+
+    end
+
+  end
+end

data/lib/tivohmo/api/application.rb

@@ -0,0 +1,35 @@
+module TivoHMO
+  module API
+
+    # Represents the tivo concept of a Server (i.e. the root node
+    # which contains the top level containers).  The identifier
+    # passed to the ctor should be a string that makes sense
+    # for initializing a subclass of app, e.g. a directory,
+    # a hostname:port, etc
+    module Application
+      extend ActiveSupport::Concern
+      include Container
+      include GemLogger::LoggerSupport
+
+      attr_accessor :transcoder_class,
+                    :metadata_class
+
+      def initialize(identifier)
+        super(identifier)
+        self.app = self
+        self.content_type = "x-container/tivo-videos"
+        self.source_format = "x-container/folder"
+      end
+
+      def metadata_for(item)
+        metadata_class.new(item) if metadata_class
+      end
+
+      def transcoder_for(item)
+        transcoder_class.new(item) if transcoder_class
+      end
+
+    end
+
+  end
+end

data/lib/tivohmo/api/container.rb

@@ -0,0 +1,31 @@
+require 'securerandom'
+
+module TivoHMO
+  module API
+
+    # Represents the tivo concept of a Container (i.e. a directory that contains
+    # files or other containers)
+    module Container
+      extend ActiveSupport::Concern
+      include Node
+      include GemLogger::LoggerSupport
+
+      attr_accessor :uuid
+
+
+      def initialize(identifier)
+        super(identifier)
+        self.uuid = SecureRandom.uuid
+
+        self.content_type = "x-tivo-container/tivo-videos"
+        self.source_format = "x-tivo-container/folder"
+      end
+
+      def refresh
+        self.children = []
+      end
+
+    end
+
+  end
+end

data/lib/tivohmo/api/item.rb

@@ -0,0 +1,32 @@
+module TivoHMO
+  module API
+
+    # Represents the tivo concept of an Item (i.e. a file that can be
+    # displayed), and is always a leaf node in the tree.
+    module Item
+      extend ActiveSupport::Concern
+      include Node
+      include GemLogger::LoggerSupport
+
+      def initialize(identifier)
+        super(identifier)
+        self.content_type = "video/x-tivo-mpeg"
+        self.source_format = "video/x-tivo-mpeg"
+      end
+
+      def metadata
+        @metadata ||= app.metadata_for(self)
+      end
+
+      def transcoder
+        @transcoder ||= app.transcoder_for(self)
+      end
+
+      def to_s
+        "<#{self.class.name}: #{self.identifier}>"
+      end
+
+    end
+
+  end
+end

data/lib/tivohmo/api/metadata.rb

@@ -0,0 +1,98 @@
+module TivoHMO
+  module API
+
+    # Metadata abstraction for containing and displaying supplemental info about an Item
+    module Metadata
+      extend ActiveSupport::Concern
+      include GemLogger::LoggerSupport
+
+      attr_accessor :item,
+
+                    :title,
+                    :description,
+
+                    :time, # Time
+                    :start_time, # Time
+                    :stop_time, # Time
+                    :source_size, # int, bytes
+
+                    :actual_showing,
+                    :bookmark,
+                    :recording_quality, # hash of :name, :value
+                    :duration, # int, seconds
+
+                    :showing_bits,
+                    :part_count,
+                    :part_index,
+
+                    :actors,
+                    :choreographers,
+                    :directors,
+                    :producers,
+                    :executive_producers,
+                    :writers,
+                    :hosts,
+                    :guest_stars,
+                    :program_genres,
+
+                    :original_air_date,
+                    :movie_year,
+                    :advisory,
+                    :color_code, # hash of :name, :value
+                    :show_type, # hash of :name, :value
+                    :program_id,
+                    :mpaa_rating, # hash of :name, :value
+                    :star_rating, # hash of :name, :value
+                    :tv_rating, # hash of :name, :value
+
+                    :is_episode,
+                    :episode_number,
+                    :episode_title,
+
+                    :series_genres,
+                    :series_title,
+                    :series_id,
+
+                    :channel # hash of :major_number, :minor_number, :callsign
+
+
+      def initialize(item)
+        self.item = item
+        self.duration = 0
+        self.showing_bits = 4096
+        self.is_episode = true
+        self.recording_quality = {name: "HIGH", value: "75"}
+        self.color_code = {name: 'COLOR', value: '4'}
+        self.show_type = {name: 'SERIES', value: '5'}
+        self.channel = {major_number: '0', minor_number: '0', callsign: ''}
+      end
+
+      def time
+        @time ||= Time.now
+      end
+
+      def start_time
+        @start_time ||= time
+      end
+
+      def stop_time
+        @stop_time ||= time + duration
+      end
+
+      def source_size
+        @source_size ||= estimate_source_size
+      end
+
+      def estimate_source_size
+        # This is needed so that we can give tivo an estimate of transcoded size
+        # so transfer doesn't abort half way through.  Using the max audio and
+        # video bit rates for a max estimate
+        opts = item.transcoder.transcoder_options
+        vbr = (opts[:video_bitrate] || opts[:video_max_bitrate] || 30000) * 1000
+        abr = (opts[:audio_bitrate] || 448) * 1000
+        (self.duration * ((abr + vbr) * 1.02 / 8)).to_i
+      end
+    end
+
+  end
+end

data/lib/tivohmo/api/node.rb

@@ -0,0 +1,115 @@
+module TivoHMO
+  module API
+
+    # A tree node.  Nodes have a parent, children and a root, with the tree
+    # itself representing the app/container/items heirarchy
+    module Node
+      extend ActiveSupport::Concern
+      # We could have used https://github.com/evolve75/RubyTree here instead of
+      # hand coding a tree, but since this is part of the 'api' I figured it
+      # was better not to have any external dependencies
+
+      include GemLogger::LoggerSupport
+
+      attr_accessor :identifier,
+                    :parent,
+                    :children,
+                    :root,
+                    :app,
+                    :title,
+                    :content_type,
+                    :source_format,
+                    :modified_at,
+                    :created_at
+
+      def initialize(identifier)
+        self.identifier = identifier
+        self.title = identifier.to_s
+        self.created_at = Time.now
+        self.modified_at = Time.now
+        @children = []
+      end
+
+      def add_child(child)
+        raise ArgumentError, "Not a node: #{child}" unless child.is_a?(Node)
+        child.parent = self
+        child.root = self.root if self.root
+        child.app = self.app if self.app
+        @children << child
+        child
+      end
+
+      alias << add_child
+
+      def root?
+        self == self.root
+      end
+
+      def app?
+        self == self.app
+      end
+
+      def find(title_path)
+
+        unless title_path.is_a?(Array)
+          title_path = title_path.split('/')
+          return root if title_path.blank?
+          if title_path.first == ""
+            return root.find(title_path[1..-1])
+          end
+        end
+
+        next_title, rest = title_path[0], title_path[1..-1]
+
+        self.children.find do |c|
+          if c.title == next_title
+            if rest.blank?
+              return c
+            else
+              return c.find(rest)
+            end
+          end
+        end
+
+        return nil
+      end
+
+      def title_path
+        if self == root
+          "/"
+        else
+          if parent == root
+            "/#{self.title}"
+          else
+            "#{parent.title_path}/#{self.title}"
+          end
+        end
+      end
+
+      def tree_string
+        result = ""
+        if self.root
+          n = root
+        else
+          result << "(no root)\n"
+          n = self
+        end
+        queue = [n]
+        queue.each do |node|
+          ident = node.title_path
+          result << ident << "\n"
+          if node.children.present?
+            queue.concat(node.children)
+          end
+        end
+        result
+      end
+
+      def to_s
+        "<#{self.class.name}: #{self.identifier}>"
+      end
+
+    end
+
+  end
+end

data/lib/tivohmo/api/server.rb

@@ -0,0 +1,24 @@
+require 'socket'
+
+module TivoHMO
+  module API
+
+    # Represents the tivo concept of a Server (i.e. the root node
+    # which contains the top level applications)
+    class Server
+      include Container
+      include GemLogger::LoggerSupport
+
+      def initialize
+        super('TivoHMO Server')
+        self.root = self
+        self.title = Socket.gethostname.split('.').first
+        self.content_type = "x-container/tivo-server"
+        self.source_format = "x-container/folder"
+      end
+
+    end
+
+  end
+end
+

data/lib/tivohmo/api/transcoder.rb

@@ -0,0 +1,39 @@
+
+module TivoHMO
+  module API
+
+    # Transcoder abstraction for reading in the data from an Item and
+    # transcoding it into a format suitable for display on a tivo
+    module Transcoder
+      extend ActiveSupport::Concern
+      include GemLogger::LoggerSupport
+
+      # https://code.google.com/p/streambaby/wiki/video_compatibility
+      VIDEO_FRAME_RATES = %w[23.98 24.00 25.00 29.97
+                             30.00 50.00 59.94 60.00]
+      VIDEO_CODECS = %w[mpeg2video] # h264 only for push?
+      VIDEO_WIDTHS = %w[1920 1440 1280 720 704 544 480 352]
+      VIDEO_HEIGHTS = %w[1080 720 480 240]
+
+      AUDIO_CODECS = %w[ac3 liba52 mp2]
+      AUDIO_SAMPLE_RATES = %w[44100 48000]
+
+      attr_accessor :item,
+                    :source_filename
+
+      def initialize(item)
+        self.item = item
+        self.source_filename = item.identifier
+      end
+
+      def transcode(writeable_io, format)
+        raise NotImplementedError
+      end
+
+      def transcoder_options(format="video/x-tivo-mpeg")
+        raise NotImplementedError
+      end
+    end
+
+  end
+end

data/lib/tivohmo/api.rb

@@ -0,0 +1,7 @@
+require 'tivohmo/api/node'
+require 'tivohmo/api/item'
+require 'tivohmo/api/container'
+require 'tivohmo/api/transcoder'
+require 'tivohmo/api/metadata'
+require 'tivohmo/api/application'
+require 'tivohmo/api/server'