jeeves-pvr 0.2.0

data/lib/jeeves/tags.rb

@@ -0,0 +1,329 @@
+#
+# Author:: R.J.Sharp
+# Email:: robert(a)osburn-sharp.ath.cx
+# Copyright:: Copyright (c) 2013
+# License:: Open Software Licence v3.0
+#
+# This software is licensed for use under the Open Software Licence v. 3.0
+# The terms of this licence can be found at http://www.opensource.org/licenses/osl-3.0.php
+# and in the file LICENCE. Under the terms of this licence, all derivative works
+# must themselves be licensed under the Open Software Licence v. 3.0
+#
+# 
+# [requires go here]
+# ffmpeg  -itsoffset -4  -i test.avi -vcodec mjpeg -vframes 1 -an -f rawvideo -s 320x240 test.jpg
+# 
+require 'jeeves/errors'
+require 'jeeves/utils'
+
+require 'nokogiri'
+require 'open-uri'
+
+# = Jetags
+#
+# Helper class to create and manipulate tag data to be included in or extracted from matroska files
+#
+module Jeeves
+  
+  class Tagger
+    
+    Fingerprint = "JeevesTags"
+  
+  # create a tags objects
+    def initialize(options = {})
+      
+      #@jeeves_tv_url = options[:jeeves_tv_url] || raise(MissingOption, "Need to have a jeeves tv url")
+      
+      @tag_data = nil
+      @tag_hash = Hash.new
+      @tag_hash[:fingerprint] = Fingerprint
+      
+    end
+    
+    # provided for backward compatibility - use new_from_remote_id
+    def self.new_from_prog_id(prog_id, listing_url)
+      
+      tags = self.new
+      
+      tags.load_tags_from_prog(prog_id, listing_url)
+      
+      return tags
+      
+    end
+    
+    # get tags from a remote service with the id, route and url
+    #   #{url}/#{route}/#{id}.xml
+    # which should provide an XML document with Simple nodes and
+    # Name and String node contents.
+    #
+    # <Tags>
+    #  <Tag>
+    #   <Simple>
+    #    <Name>name</Name>
+    #    <String>value</String>
+    #   </Simple>
+    #   <Simple>
+    #    ...
+    #   </Simple>
+    #  </Tag>
+    # </Tags>
+    #
+    def self.new_from_remote_id(id, route, url)
+      
+      tags = self.new
+      
+      tags.load_tags_from_remote(id, route, url)
+      
+      return tags
+      
+    end
+    
+    def self.new_from_file(pathname)
+      tags = self.new
+      
+      tags.load_tags_from_file(pathname)
+      
+      return tags
+    end
+    
+    # get tags for the given programme from jeeves-tv and
+    # embed them in the given video file, which incidentally becomes an mkv
+    # WARNING - mkvmerge, used here to tag stuff, makes a big hash of mpegts
+    # and often seems to screw the audio up completely. Probably not worth trying this one!
+    #
+    def write_to_file(path)
+      
+      # check that the path exists and get its basename
+      unless File.readable?(path)
+        raise FileError, "Cannot read: #{path}"
+      end
+      dirname = File.expand_path(File.dirname(path))
+      bname = File.basename(path, File.extname(path))
+      mkv_path = File.join(dirname, bname + '.mkv')
+      unless mkv_path != path
+        raise FileError, "Source file is already matroska"
+      end
+      
+      xml_path = File.join(dirname, bname + '.xml')
+      
+      # get the tags from jeeves-tv, wherever that might be and save to a hidden file
+      
+      cmd = "/usr/bin/wget #{@jeeves_tv_url}/pid/#{prog_id}.xml -O #{xml_path}"
+      unless system(cmd)
+        raise XMLError, "Failed to get xml data: #{$?}. Command line was: #{cmd}"
+      end
+      
+      
+      unless File.exists?(xml_path)
+        raise XMLError, "XML file: #{xml_path} was not created"
+      end
+      
+      # merge the tags with the video file to create a matroska file
+      
+      cmd = "/usr/bin/mkvmerge --global-tags #{xml_path} #{path} -o #{mkv_path}"
+      
+      unless system(cmd)
+        raise MkvError, "Failed to create mkv: #{$?}, Command line was: #{cmd}"
+      end
+      return true
+    end
+    
+    
+    # provide all tag data as key, value pairs
+    def each_tag(&block)
+      @tag_hash.each do |tag, value|
+        block.call(tag, value)
+      end
+    end
+    
+    # return all the tags as a string of key=value pairs
+    def to_a
+      
+      tags_to_exclude = %w[priority tuner]
+      
+      tag_ary = Array.new
+      
+      @tag_hash.each do |tag, value|
+        next if tags_to_exclude.include?(tag)
+        tag_ary << tag.to_s + '=' + value
+      end
+      
+      return tag_ary
+    end
+    
+    def to_s
+      strings = ''
+      each_tag do |tag, value|
+        strings << "  #{tag}: #{value}\n"
+      end
+      return strings
+    end
+    
+    alias :metadata :to_a
+    
+    # return the value of a given tag
+    def [](tag)
+      return @tag_hash[tag]
+    end
+    
+    # create a new tag
+    def []=(tag, value)
+      @tag_hash[tag] = value
+    end
+    
+    def delete(tag)
+      @tag_hash.delete(tag)
+    end
+    
+    def has_tag?(tag)
+      @tag_hash.has_key?(tag)
+    end
+    
+    def jeeves?
+      @tag_hash.has_key?(:fingerprint) && @tag_hash[:fingerprint] == Fingerprint
+    end
+    
+    #protected
+    
+    # get tags direct from programme listing
+    def load_tags_from_prog(prog_id, url)
+      @tag_data = String.new
+      my_url = "#{url}/pid/#{prog_id}.xml"
+      open(my_url) do |xml|
+        xml.each_line {|line| @tag_data << line}
+      end
+      self.xml_to_hash
+    #rescue
+      #raise UrlError, "Url failed to open: #{my_url}"
+    end
+    
+    # get tags from a remote service on the given url and route
+    # #{url}/#{route}/#{id}.xml
+    #
+    # should replace load_tags_from_prog
+    def load_tags_from_remote(id, route, url)
+      @tag_data = String.new
+      my_url = "#{url}/#{route}/#{id}.xml"
+      #puts "URL: #{my_url}"
+      open(my_url) do |xml|
+        xml.each_line do |line| 
+          #puts line
+          @tag_data << line
+        end
+      end
+      self.xml_to_hash
+      #puts @tag_hash.inspect
+    end
+    
+    # extract tags from an mkv video and return as an xml string
+    def load_tags_from_file(path)
+      unless File.readable?(path)
+        raise FileError, "Cannot read: #{path}"
+      end
+      dirname = File.expand_path(File.dirname(path))
+      bname = File.basename(path, File.extname(path))
+      xml_path = File.join(dirname, bname + '.xml')
+      
+      @tag_data = `/usr/bin/mkvextract tags #{path}`
+      
+      self.xml_to_hash
+
+      # unless system(cmd)
+      #   raise MkvError, "Failed to extract tags: #{$?}, command line: #{cmd}"
+      # end
+      # 
+      # unless File.exists?(xml_path)
+      #   raise XMLError, "XML file: #{xml_path} was not created"
+      # end
+      # 
+      # @tag_data = File.readlines(xml_path)
+      
+    end
+    
+    def load_tags_from_imdb(url)
+      doc = Nokogiri::HTML(open(url))
+      
+      name = doc.at_css('*[itemprop="name"]').content
+      @tag_hash[:programme] = name.gsub("\n", '').gsub(/\([0-9]+\)/, '')
+      @tag_hash[:duration] = doc.at_css('*[itemprop="duration"]').content.to_i * 60
+      @tag_hash[:date] = doc.at_css('*[itemprop="datePublished"]').content.match(/.*([0-9]{4,4})/)[1]
+      @tag_hash[:description] = doc.at_css('*[itemprop="description"]').content.gsub("\n", '')
+      @tag_hash[:source] = 'IMDB'
+      @tag_hash[:category] = 'Film'
+
+    end
+    
+    # copy a file and apply the given tags to it
+    def apply_tags_to_file(filename)
+      if FileTest.exists?(filename) then
+        source = funique(filename)
+        FileUtils.mv(filename, source)
+        dn, bn, en = fsplit(filename)
+        target = File.join(dn, bn + ".mkv")
+        ffargs = "-i #{source} -c:v copy -c:a copy -f matroska -y".split(' ')
+        self.metadata.each do |tag|
+          ffargs << "-metadata"
+          ffargs << tag
+        end
+        ffargs << target
+        system("/usr/bin/ffmpeg", *ffargs)
+        
+      end
+        
+    end
+    
+    # copy a bit of a file and apply the given tags to it
+    def apply_to_proxy(filename)
+      if FileTest.exists?(filename) then
+        self['path'] = filename
+        target = Jeeves.rename(filename)
+        dn, bn, en = fsplit(target)
+        target = File.join(dn, bn + ".mkv")
+        ffargs = "-i #{filename} -v quiet -t 10 -f matroska -y".split(' ')
+        self.metadata.each do |tag|
+          ffargs << "-metadata"
+          ffargs << tag
+        end
+        ffargs << target
+        unless system("/usr/bin/ffmpeg", *ffargs)
+          raise Jeeves::MkvError, "ffmpeg failed with args: #{ffargs.join(' ')}"
+        end
+        return target
+      end
+        
+    end
+    
+    def xml_to_hash
+      xml_tags = Nokogiri::XML(@tag_data)
+      
+      @tag_hash = Hash.new # ensure you are not assuming this comes from Jeeves
+      
+      xml_tags.xpath('//Simple').each do |tag|
+        @tag_hash[tag.at_xpath('Name').content.downcase] = tag.at_xpath('String').content
+      end
+      
+    end
+    
+    def funique(filename)
+      dirname, basename, extname = fsplit(filename)
+      newfilename = File.join(dirname, basename + extname)
+      while FileTest.exists?(newfilename)
+        # oh dear, got one already. need to add something to the name
+        randname = (rand * 10000).to_i.to_s
+        basename = basename + '_' + randname + extname
+        newfilename = File.join(dirname, basename)
+      end
+      
+      return newfilename
+
+    end
+    
+    def fsplit(filename)
+      dname = File.dirname(filename)
+      extname = File.extname(filename)
+      basename = File.basename(filename, extname)
+      return [dname, basename, extname]
+    end
+    
+  end
+end

data/lib/jeeves/utils.rb

@@ -0,0 +1,124 @@
+#
+#
+# = Utilities for Jeeves
+#
+# == human_size etc
+#
+# Author:: Robert Sharp
+# Copyright:: Copyright (c) 2013 Robert Sharp
+# License:: Open Software Licence v3.0
+#
+# This software is licensed for use under the Open Software Licence v. 3.0
+# The terms of this licence can be found at http://www.opensource.org/licenses/osl-3.0.php
+# and in the file copyright.txt. Under the terms of this licence, all derivative works
+# must themselves be licensed under the Open Software Licence v. 3.0
+#
+# 
+#
+require 'colored'
+
+module Jeeves
+  
+    Kb = 1 * 1000
+    Mb = Kb * Kb
+    Gb = Mb * Kb
+    Tb = Gb * Kb
+  
+  def Jeeves.human_size(size_in_k)
+    size = size_in_k * Kb
+    case
+      when size < Mb then '%.1f KB'  % (size_in_k)
+      when size < Gb then '%.1f MB'  % (size_in_k / Kb)
+      when size < Tb then '%.1f GB'  % (size_in_k / Mb)
+      else                  
+        '%.1f TB'  % (size_in_k / Gb)
+    end.sub('.0', '')
+  rescue
+    nil
+  end
+  
+  def Jeeves.hrs_mins(secs)
+    mins = secs / 60
+    hours = mins /60
+    mins -= hours * 60
+    mstr = "%02d" % mins
+    units = hours > 1 ? 'hrs' : 'hr'
+    return "#{hours}#{units}#{mstr}"
+  end
+   
+  
+  def Jeeves.tabulate(cols, header, data, colours=nil)
+    
+    data_s = Array.new
+    data.each do |row|
+      row_s = []
+      row.each do |cell|
+        row_s << cell.to_s
+      end
+      data_s << row_s
+    end
+    
+    data = data_s
+    
+    methods = Array.new(cols.length, :ljust)
+    method_lup = {'l'=>:ljust, 'r'=>:rjust, 'c'=>:center}
+    
+    col_re = /^(\*|[0-9]+)([lrc]{0,1})$/
+
+    # need to get column widths from header and data
+    cols.each_index do |col_index|
+      if tokens = col_re.match(cols[col_index]) then
+        if tokens[1] == '*' then
+          # work out the column width
+          cols[col_index] = header[col_index].length
+          data.each do |row|
+            cols[col_index] = row[col_index].length if row[col_index].length >= cols[col_index]
+          end
+        else
+          cols[col_index] = tokens[1].to_i
+        end
+        # and add the justification method
+        #puts tokens.inspect
+        methods[col_index] = method_lup[tokens[2]] unless tokens[2] == ''
+      end # if
+    end # cols.each_index block
+    
+    #puts cols.inspect
+    fstr = String.new
+    header.each_index {|hdi| fstr << (sprintf header[hdi].send(methods[hdi], cols[hdi]).bold + '  ')}
+    puts fstr
+    
+    data.each_index do |row_ind|
+      fstr = String.new
+      row = data[row_ind]
+      row.each_index {|ri| fstr << (sprintf row[ri].send(methods[ri], cols[ri]) + '  ')}
+      fstr = fstr.send(colours[row_ind]) unless colours.nil? || colours[row_ind].nil?
+      puts fstr
+    end
+    
+  end
+  
+  # rename a file by appending a random string to the basename
+  #
+  def Jeeves.rename(path)
+    dir_name = File.dirname(path)
+    extname = File.extname(path)
+    root_basename = File.basename(path, extname)
+    
+    loop_count = 0 # catch a loop
+    
+    while block_given? ? yield(path) : FileTest.exists?(path)
+      loop_count += 1
+      path = nil
+      break if loop_count > 10
+      # oh dear, got one already. need to add something to the name
+      randname = Kernel.rand(10000).to_s
+      basename = root_basename + '_' + randname + extname
+      path = File.join(dir_name, basename)
+    end
+    
+    return path
+    
+  end
+  
+end