m3uzi 0.2.1 → 0.4.2

data/lib/m3uzi.rb

@@ -1,24 +1,20 @@
 $:<< File.dirname(__FILE__)
+require 'm3uzi/item'
 require 'm3uzi/tag'
 require 'm3uzi/file'
 require 'm3uzi/stream'
+require 'm3uzi/comment'
 require 'm3uzi/version'
 
 class M3Uzi
 
-  # Unsupported: PROGRAM-DATE-TIME DISCONTINUITY
-  VALID_TAGS = %w{TARGETDURATION MEDIA-SEQUENCE ALLOW-CACHE ENDLIST KEY}
-
-  attr_accessor :files, :streams
-  attr_accessor :tags, :comments
+  attr_accessor :header_tags, :playlist_items
   attr_accessor :final_media_file
   attr_accessor :version
 
   def initialize
-    @files = []
-    @streams = []
-    @tags = []
-    @comments = []
+    @header_tags = {}
+    @playlist_items = []
     @final_media_file = true
     @version = 1
   end
@@ -28,78 +24,161 @@ class M3Uzi
   # Read/Write M3U8 Files
   #-------------------------------------
 
-  def self.read(path)
-    m3u = self.new
-    lines = ::File.readlines(path)
-    lines.each_with_index do |line, i|
-      case type(line)
-      when :tag
-        name, value = parse_general_tag(line)
-        m3u.add_tag do |tag|
-          tag.name = name
-          tag.value = value
-        end
-      when :info
-        duration, description = parse_file_tag(line)
-        m3u.add_file do |file|
-          file.path = lines[i+1].strip
-          file.duration = duration
-          file.description = description
-        end
-        m3u.final_media_file = false
-      when :stream
-        attributes = parse_stream_tag(line)
-        m3u.add_stream do |stream|
-          stream.path = lines[i+1].strip
-          attributes.each_pair do |k,v|
-            k = k.to_s.downcase.sub('-','_')
-            next unless [:bandwidth, :program_id, :codecs, :resolution].include?(k)
-            v = $1 if v.to_s =~ /^"(.*)"$/
-            stream.send("#{k}=", v)
-          end
-        end
-      when :final
-        m3u.final_media_file = true
-      else
-        next
-      end
-    end
-    m3u
-  end
+  ##
+  ## For now, reading m3u8 files is not keeping up to date with writing, so we're
+  ## disabling it in this version.  (Possibly to be re-introduced in the future.)
+  ##
+  # def self.read(path)
+  #   m3u = self.new
+  #   lines = ::File.readlines(path)
+  #   lines.each_with_index do |line, i|
+  #     case type(line)
+  #     when :tag
+  #       name, value = parse_general_tag(line)
+  #       m3u.add_tag do |tag|
+  #         tag.name = name
+  #         tag.value = value
+  #       end
+  #     when :info
+  #       duration, description = parse_file_tag(line)
+  #       m3u.add_file do |file|
+  #         file.path = lines[i+1].strip
+  #         file.duration = duration
+  #         file.description = description
+  #       end
+  #       m3u.final_media_file = false
+  #     when :stream
+  #       attributes = parse_stream_tag(line)
+  #       m3u.add_stream do |stream|
+  #         stream.path = lines[i+1].strip
+  #         attributes.each_pair do |k,v|
+  #           k = k.to_s.downcase.sub('-','_')
+  #           next unless [:bandwidth, :program_id, :codecs, :resolution].include?(k)
+  #           v = $1 if v.to_s =~ /^"(.*)"$/
+  #           stream.send("#{k}=", v)
+  #         end
+  #       end
+  #     when :final
+  #       m3u.final_media_file = true
+  #     else
+  #       next
+  #     end
+  #   end
+  #   m3u
+  # end
 
   def write_to_io(io_stream)
+    reset_encryption_key_history
+    reset_byterange_history
+
     check_version_restrictions
     io_stream << "#EXTM3U\n"
     io_stream << "#EXT-X-VERSION:#{@version.to_i}\n" if @version > 1
-    comments.each do |comment|
-      io_stream << "##{comment}\n"
+
+    if items(File).length > 0
+      max_duration = valid_items(File).map { |f| f.duration.to_f }.max || 10.0
+      io_stream << "#EXT-X-TARGETDURATION:#{max_duration.ceil}\n"
     end
-    tags.each do |tag|
-      next if %w{M3U ENDLIST}.include?(tag.name.to_s.upcase)
-      if VALID_TAGS.include?(tag.name.to_s.upcase)
-        io_stream << "#EXT-X-#{tag.name.to_s.upcase}"
-      else
-        io_stream << "##{tag.name.to_s.upcase}"
+
+    @header_tags.each do |item|
+      io_stream << (item.format + "\n") if item.valid?
+    end
+
+    @playlist_items.each do |item|
+      next unless item.valid?
+
+      if item.kind_of?(File)
+        encryption_key_line = generate_encryption_key_line(item)
+        io_stream << (encryption_key_line + "\n") if encryption_key_line
+
+        byterange_line = generate_byterange_line(item)
+        io_stream << (byterange_line + "\n") if byterange_line
       end
-      tag.value && io_stream << ":#{tag.value}"
-      io_stream << "\n"
+
+      io_stream << (item.format + "\n")
     end
-    files.each do |file|
-      io_stream << "#EXTINF:#{file.attribute_string}"
-      io_stream << "\n#{file.path}\n"
+
+    io_stream << "#EXT-X-ENDLIST\n" if items(File).length > 0 && @final_media_file
+  end
+
+  def write(path)
+    ::File.open(path, "w") { |f| write_to_io(f) }
+  end
+
+  def items(kind)
+    @playlist_items.select { |item| item.kind_of?(kind) }
+  end
+
+  def valid_items(kind)
+    @playlist_items.select { |item| item.kind_of?(kind) && item.valid? }
+  end
+
+  #-------------------------------------
+  # Playlist generation helpers.
+  #-------------------------------------
+
+  def reset_encryption_key_history
+    @encryption_key_url = nil
+    @encryption_iv = nil
+    @encryption_sequence = 0
+  end
+
+  def generate_encryption_key_line(file)
+    generate_line = false
+
+    default_iv = @encryption_iv || format_iv(@encryption_sequence)
+
+    if (file.encryption_key_url != :unset) && (file.encryption_key_url != @encryption_key_url)
+      @encryption_key_url = file.encryption_key_url
+      generate_line = true
     end
-    streams.each do |stream|
-      io_stream << "#EXT-X-STREAM-INF:#{stream.attribute_string}"
-      io_stream << "\n#{stream.path}\n"
+
+    if @encryption_key_url && file.encryption_iv != @encryption_iv
+      @encryption_iv = file.encryption_iv
+      generate_line = true
+    end
+
+    @encryption_sequence += 1
+
+    if generate_line
+      if @encryption_key_url.nil?
+        "#EXT-X-KEY:METHOD=NONE"
+      else
+        attrs = ['METHOD=AES-128']
+        attrs << 'URI="' + @encryption_key_url.gsub('"','%22').gsub(/[\r\n]/,'').strip + '"'
+        attrs << "IV=#{@encryption_iv}" if @encryption_iv
+        '#EXT-X-KEY:' + attrs.join(',')
+      end
+    else
+      nil
     end
-    io_stream << "#EXT-X-ENDLIST\n" if files.length > 0 && final_media_file
   end
 
-  def write(path)
-    check_version_restrictions
-    f = ::File.open(path, "w")
-    write_to_io(f)
-    f.close()
+  def reset_byterange_history
+    @prev_byterange_endpoint = nil
+  end
+
+  def generate_byterange_line(file)
+    line = nil
+
+    if file.byterange
+      if file.byterange_offset && file.byterange_offset != @prev_byterange_endpoint
+        offset = file.byterange_offset
+      elsif @prev_byterange_endpoint.nil?
+        offset = 0
+      else
+        offset = nil
+      end
+
+      line = "#EXT-X-BYTERANGE:#{file.byterange_offset.to_i}"
+      line += "@#{offset}" if offset
+
+      @prev_byterange_endpoint = offset + file.byterange
+    else
+      @prev_byterange_endpoint = nil
+    end
+
+    line
   end
 
 
@@ -107,14 +186,16 @@ class M3Uzi
   # Files
   #-------------------------------------
 
-  def add_file(&block)
+  def add_file(path = nil, duration = nil)
     new_file = M3Uzi::File.new
-    yield(new_file)
-    @files << new_file
+    new_file.path = path if path
+    new_file.duration = duration if duration
+    yield(new_file) if block_given?
+    @playlist_items << new_file
   end
 
   def filenames
-    files.map { |file| file.path }
+    items(File).map { |file| file.path }
   end
 
 
@@ -122,14 +203,16 @@ class M3Uzi
   # Streams
   #-------------------------------------
 
-  def add_stream(&block)
+  def add_stream(path = nil, bandwidth = nil)
     new_stream = M3Uzi::Stream.new
-    yield(new_stream)
-    @streams << new_stream
+    new_stream.path = path
+    new_stream.bandwidth = bandwidth
+    yield(new_stream) if block_given?
+    @playlist_items << new_stream
   end
 
   def stream_names
-    streams.map { |stream| stream.path }
+    items(Stream).map { |stream| stream.path }
   end
 
 
@@ -137,56 +220,65 @@ class M3Uzi
   # Tags
   #-------------------------------------
 
-  def add_tag(&block)
+  def add_tag(name = nil, value = nil)
     new_tag = M3Uzi::Tag.new
-    yield(new_tag)
-    @tags << new_tag
-  end
-
-  def [](key)
-    tag_name = key.to_s.upcase.gsub("_", "-")
-    obj = tags.detect { |tag| tag.name == tag_name }
-    obj && obj.value
+    new_tag.name = name
+    new_tag.value = value
+    yield(new_tag) if block_given?
+    @header_tags[new_tag.name] = new_tag
   end
 
-  def []=(key, value)
-    add_tag do |tag|
-      tag.name = key
-      tag.value = value
-    end
-  end
+  # def [](key)
+  #   tag_name = key.to_s.upcase.gsub("_", "-")
+  #   obj = tags.detect { |tag| tag.name == tag_name }
+  #   obj && obj.value
+  # end
+  #
+  # def []=(key, value)
+  #   add_tag do |tag|
+  #     tag.name = key
+  #     tag.value = value
+  #   end
+  # end
 
 
   #-------------------------------------
   # Comments
   #-------------------------------------
 
-  def add_comment(comment)
-    @comments << comment
+  def add_comment(comment = nil)
+    new_comment = M3Uzi::Comment.new
+    new_comment.text = comment
+    yield(new_comment) if block_given?
+    @playlist_items << new_comment
   end
 
-  def <<(comment)
-    add_comment(comment)
-  end
+  # def <<(comment)
+  #   add_comment(comment)
+  # end
 
   def check_version_restrictions
     @version = 1
 
+    #
     # Version 2 Features
-    if @tags.detect { |tag| tag.name == 'KEY' && tag.value.to_s =~ /,IV=/ }
+    #
+
+    # Check for custom IV
+    if valid_items(File).detect { |item| item.encryption_key_url && item.encryption_iv }
       @version = 2 if @version < 2
     end
 
     # Version 3 Features
-    if @files.detect { |file| file.duration.kind_of?(Float) }
+    if valid_items(File).detect { |item| item.duration.kind_of?(Float) }
       @version = 3 if @version < 3
     end
 
     # Version 4 Features
-    if @files.detect { |file| file.byterange }
+    if valid_items(File).detect { |item| item.byterange }
       @version = 4 if @version < 4
     end
-    if @tags.detect { |tag| ['MEDIA','I-FRAMES-ONLY'].include?(tag.name) }
+    if valid_items(Tag).detect { |item| ['MEDIA','I-FRAMES-ONLY'].include?(item.name) }
       @version = 4 if @version < 4
     end
 
@@ -199,36 +291,43 @@ class M3Uzi
 
 protected
 
-  def self.type(line)
-    case line
-    when /^\s*$/
-      :whitespace
-    when /^#(?!EXT)/
-      :comment
-    when /^#EXTINF/
-      :info
-    when /^#EXT(-X)?-STREAM-INF/
-      :stream
-    when /^#EXT(-X)?-ENDLIST/
-      :final
-    when /^#EXT(?!INF)/
-      :tag
-    else
-      :file
-    end
-  end
-
-  def self.parse_general_tag(line)
-    line.match(/^#EXT(?:-X-)?(?!STREAM-INF)([^:\n]+)(:([^\n]+))?$/).values_at(1, 3)
+  # def self.type(line)
+  #   case line
+  #   when /^\s*$/
+  #     :whitespace
+  #   when /^#(?!EXT)/
+  #     :comment
+  #   when /^#EXTINF/
+  #     :info
+  #   when /^#EXT(-X)?-STREAM-INF/
+  #     :stream
+  #   when /^#EXT(-X)?-ENDLIST/
+  #     :final
+  #   when /^#EXT(?!INF)/
+  #     :tag
+  #   else
+  #     :file
+  #   end
+  # end
+  #
+  # def self.parse_general_tag(line)
+  #   line.match(/^#EXT(?:-X-)?(?!STREAM-INF)([^:\n]+)(:([^\n]+))?$/).values_at(1, 3)
+  # end
+  #
+  # def self.parse_file_tag(line)
+  #   line.match(/^#EXTINF:[ \t]*(\d+),?[ \t]*(.*)$/).values_at(1, 2)
+  # end
+  #
+  # def self.parse_stream_tag(line)
+  #   match = line.match(/^#EXT-X-STREAM-INF:(.*)$/)[1]
+  #   match.scan(/([A-Z-]+)\s*=\s*("[^"]*"|[^,]*)/) # return attributes as array of arrays
+  # end
+
+  def self.format_iv(num)
+    '0x' + num.to_s(16).rjust(32,'0')
   end
 
-  def self.parse_file_tag(line)
-    line.match(/^#EXTINF:[ \t]*(\d+),?[ \t]*(.*)$/).values_at(1, 2)
+  def format_iv(num)
+    self.class.format_iv(num)
   end
-
-  def self.parse_stream_tag(line)
-    match = line.match(/^#EXT-X-STREAM-INF:(.*)$/)[1]
-    match.scan(/([A-Z-]+)\s*=\s*("[^"]*"|[^,]*)/) # return attributes as array of arrays
-  end
-
 end

data/lib/m3uzi/comment.rb

@@ -0,0 +1,10 @@
+class M3Uzi
+  class Comment < Item
+
+    attr_accessor :text
+
+    def format
+      "##{text}"
+    end
+  end
+end

data/lib/m3uzi/file.rb

@@ -1,15 +1,41 @@
 class M3Uzi
-  class File
+  class File < Item
 
-    attr_accessor :path, :duration, :description, :byterange
+    attr_accessor :path, :duration, :description, :byterange, :byterange_offset, :encryption_key_url, :encryption_iv
+
+    # Unsupported tags: PROGRAM-DATE-TIME, DISCONTINUITY, I-FRAMES-ONLY
+    # Autogenerated tags: EXTINF, BYTERANGE, KEY, VERSION, TARGETDURATION, ENDLIST
+
+    def initialize
+      @encryption_key_url = :unset
+    end
 
     def attribute_string
       if duration.kind_of?(Float)
-        "#{sprintf('%0.4f',duration)},#{description}"
+        "#{sprintf('%0.4f',duration)}," + description.to_s.gsub(/[\r\n]/,' ').strip
       else
-        "#{duration},#{description}"
+        "#{duration.to_i.round}," + description.to_s.gsub(/[\r\n]/,' ').strip
       end
     end
 
+    def format
+      # Need to add key info if appropriate?
+      "#EXTINF:#{attribute_string}\n#{path}"
+    end
+
+    def encryption_iv=(value)
+      if value.to_s =~ /^0x/i
+        value = $'
+      end
+
+      if value.kind_of?(String)
+        raise "Invalid encryption_iv given" unless value.length <= 32 && value =~ /^[0-9a-f]+$/i
+        @encryption_iv = '0x' + value.downcase.rjust(32,'0')
+      elsif value.nil?
+        @encryption_iv = nil
+      else
+        @encryption_iv = M3Uzi.format_iv(value.to_i)
+      end
+    end
   end
 end

data/lib/m3uzi/item.rb

@@ -0,0 +1,9 @@
+class M3Uzi
+  class Item
+
+    def valid?
+      true
+    end
+
+  end
+end

data/lib/m3uzi/stream.rb

@@ -1,17 +1,27 @@
 class M3Uzi
-
-  class Stream
+  class Stream < Item
 
     attr_accessor :path, :bandwidth, :program_id, :codecs, :resolution
 
+    # Unsupported tags: EXT-X-MEDIA, EXT-X-I-FRAME-STREAM-INF
+    # Unsupported attributes of EXT-X-STREAM-INF: AUDIO, VIDEO
+
     def attribute_string
       s = []
-      s << "PROGRAM-ID=#{program_id || 1}"
-      s << "BANDWIDTH=#{bandwidth}" if bandwidth
+      s << "PROGRAM-ID=#{program_id.to_i || 1}"
+      s << "BANDWIDTH=#{bandwidth.to_i}"
       s << "CODECS=\"#{codecs}\"" if codecs
       s << "RESOLUTION=#{resolution}" if resolution
       s.join(',')
     end
+
+    def format
+      "#EXT-X-STREAM-INF:#{attribute_string}\n#{path}"
+    end
+
+    def valid?
+      !!(path && bandwidth)
+    end
   end
 
 end

data/lib/m3uzi/tag.rb

@@ -1,14 +1,34 @@
 class M3Uzi
-
-  class Tag
+  class Tag < Item
 
     attr_reader :name
     attr_accessor :value
 
+    VALID_TAGS = %w{PLAYLIST-TYPE ALLOW-CACHE}
+
+    # Unsupported tags: MEDIA-SEQUENCE, I-FRAMES-ONLY, PLAYLIST-TYPE
+    # Autogenerated tags: EXTM3U, VERSION, ENDLIST, BYTERANGE, TARGETDURATION
+
     def name=(n)
       @name = n.to_s.upcase.gsub("_", "-")
     end
 
+    def format
+      string << "#EXT-X-#{name}"
+      string << ":#{value}" if value
+      string
+    end
+
+    def valid?
+      case name
+      when 'PLAYLIST-TYPE'
+        ['EVENT','VOD'].include?(value)
+      when 'ALLOW-CACHE'
+        ['YES','NO'].include?(value)
+      else
+        true
+      end
+    end
   end
 
 end

data/lib/m3uzi/version.rb

@@ -1,3 +1,3 @@
 class M3Uzi
-  VERSION = '0.2.1'
+  VERSION = '0.4.2'
 end

data/test/m3uzi_test.rb

@@ -12,18 +12,18 @@ class M3UziTest < Test::Unit::TestCase
       assert_equal M3Uzi, m3u.class
     end
 
-    should "read in an index file" do
-      m3u = M3Uzi.read(File.join(File.dirname(__FILE__), "fixtures/index.m3u8"))
-      assert_equal M3Uzi, m3u.class
-    end
+    # should "read in an index file" do
+    #   m3u = M3Uzi.read(File.join(File.dirname(__FILE__), "fixtures/index.m3u8"))
+    #   assert_equal M3Uzi, m3u.class
+    # end
   end
 
   context "with protocol versions" do
     should "set version 2 for encryption IV" do
       m3u = M3Uzi.new
-      m3u['KEY'] = "0x1234567890abcdef1234567890abcdef"
+      m3u.add_file('1.ts',10) { |f| f.encryption_key_url = "key.dat" }
       assert_equal 1, m3u.check_version_restrictions
-      m3u['KEY'] = "0x1234567890abcdef1234567890abcdef,IV=0x1234567890abcdef1234567890abcdef"
+      m3u.add_file('1.ts',10) { |f| f.encryption_key_url = "key.dat"; f.encryption_iv = "0x1234567890abcdef1234567890abcdef" }
       assert_equal 2, m3u.check_version_restrictions
 
       output_stream = StringIO.new
@@ -53,7 +53,7 @@ class M3UziTest < Test::Unit::TestCase
 
       output_stream = StringIO.new
       m3u.write_to_io(output_stream)
-      assert output_stream.string =~ /:10\.000,/
+      assert output_stream.string =~ /:10\.0000,/
       assert output_stream.string !~ /:10,/
     end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 4
   - 2
-  - 1
-  version: 0.2.1
+  version: 0.4.2
 platform: ruby
 authors: 
 - Brandon Arbini
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-26 00:00:00 -05:00
+date: 2011-12-12 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -30,7 +30,9 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/m3uzi/comment.rb
 - lib/m3uzi/file.rb
+- lib/m3uzi/item.rb
 - lib/m3uzi/stream.rb
 - lib/m3uzi/tag.rb
 - lib/m3uzi/version.rb