m3u8 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b76853323b76f301feb3e6c92d787b8b961d22a
-  data.tar.gz: 1edfa96734f62f346022af27459486337eeb8e85
+  metadata.gz: 3797c5f6de3b71d0ea5974be7aef7dc416cf0977
+  data.tar.gz: cf67c30e9e26e611a55d5908de78497453181947
 SHA512:
-  metadata.gz: 5f7687b04510afe4354969801d1367b2a7ac403895f42d17a8990a2eb79fbad59a1c07e2a1594976d55656a264ef81d1712ac51038eff8cd2f5b7d03451759df
-  data.tar.gz: ff17446d9b23074e4db0cf8b6aa735f7f5c76f8e406aaef17172c1ebb83e7ad25a94f9cf9e6ee8bb222f068150bcd89eaa3c1ae826d2c902e11ac756ed42795e
+  metadata.gz: 000f3f17395510b0af051895793cb0a48019e5848b5419dc6c771c987f597cc9da68aab90e0ae7eb031fbde014ab032a78361e3ae638c567797ab2cd1acd6b27
+  data.tar.gz: b1320f06d435c05b174aa19113fe41bc75b11150f6ca097e6dd38bf518ebe3a94b273e2fd8ae59fc305e361610862a315d0b36a72e6b1948cc435c7dc8412aeb

data/CHANGELOG.md

@@ -1,3 +1,5 @@
+### 0.5.0 (2/10/2015) - BREAKING: renamed PlaylistItem.playlist to PlaylistItem.uri, MediaItem.group to MediaItem.group_id, and PlaylistItem.bitrate to PlaylistItem.bandwidth so attributes more closely match the spec. Added support for EXT-X-I-FRAME-STREAM-INF, EXT-X-I-FRAMES-ONLY, EXT-X-BYTERANGE, and EXT-X-SESSION-DATA.
+
 ### 0.4.0 (1/20/2015) - BREAKING: Playlist.audio is now Playlist.audio_codec, audio now represents the newly supported AUDIO attribute, please update your code accordingly. Added support for all EXT-X-MEDIA attributes as well as the following EXT-X-STREAM-INF attributes: AVERAGE-BANDWIDTH, AUDIO, VIDEO, SUBTILES, and CLOSED-CAPTIONS. This means the library now supports alternate audio / camera angles as well as subtitles and closed captions. The EXT-X-PLAYLIST-TYPE attribute is now supported as Playlist.type. SegmentItems now support comments (Thanks @elsurudo). A bug was also fixed in Reader that prevented reuse of the instance.
 
 ### 0.3.2 (1/16/2015) - PROGRAM-ID was removed in protocol version 6, if not provided it will now be omitted. Thanks @elsurudo

data/README.md

@@ -24,100 +24,116 @@ Or install it yourself as:
 
     $ gem install m3u8
 
-## Usage (Generation)
-
-
-	require 'm3u8'
-	
-	#create a master playlist and add child playlists for adaptive bitrate streaming:
-	playlist = M3u8::Playlist.new
-    #create a new playlist item with options
-    options = { program_id: 1, width: 1920, height: 1080, width: 1920, height: 1080, 
-                profile: 'high', level: 4.1, audio_codec: 'aac-lc', bitrate: 540, 
-                playlist: 'test.url' }
-    item = M3u8::PlaylistItem.new options
-    playlist.items.push item
-
-    #alternatively you can set codecs rather than having it generated automatically:
-    options = { program_id: 1, width: 1920, height: 1080, width: 1920, height: 1080, 
-                codecs: 'avc1.66.30,mp4a.40.2', bitrate: 540, playlist: 'test.url' }
-    item = M3u8::PlaylistItem.new options
+## Usage (creating playlists)
     
-    #create a standard playlist and add MPEG-TS segments:
-    playlist = M3u8::Playlist.new
-    #create a new segment item with options
-    item = M3u8::SegmentItem.new duration: 11, segment: 'test.ts'
-    playlist.items.push item
-    
-    #just get the codec string for custom use
-    options = { profile: 'baseline', level: 3.0, audio_codec: 'aac-lc' }
-    codecs = M3u8::Playlist.codecs options
-    # => "avc1.66.30,mp4a.40.2"
-	
-	#specify options for playlist, these are ignored if playlist becomes a master playlist
-    # (child playlist added):
-	options = { version: 1, cache: false, target: 12, sequence: 1 }
-    playlist = M3u8::Playlist.new options
-    
-    #You can pass an IO object to the write method
-    require 'tempfile'
-    f = Tempfile.new 'test'
-    playlist.write f
-   
-  	#You can also access the playlist as a string
-  	playlist.to_s
-
-    #There is a M3u8::Writer class if you want more control over the write process
-    
-    #values for :audio_codec (Codec name)
-    #aac-lc, he-aac, mp3
-    
-    #values for :profile (H.264 Profile)
-    #baseline, main, high
-    
-    #values for :level
-    #3.0, 3.1, 4.0, 4.1
-    
-    #not all Levels and Profiles can be combined, consult H.264 documentation
+Create a master playlist and add child playlists for adaptive bitrate streaming:
+```ruby
+require 'm3u8'
+playlist = M3u8::Playlist.new
+```
 
-## Parsing Usage (new in v.2.0)
+Create a new playlist item with options:
+```ruby
+options = { program_id: 1, width: 1920, height: 1080, width: 1920, height: 1080, 
+            profile: 'high', level: 4.1, audio_codec: 'aac-lc', bandwidth: 540, 
+            playlist: 'test.url' }
+item = M3u8::PlaylistItem.new options
+playlist.items.push item
+```    
+ 
+Add alternate audio, camera angles, closed captions and subtitles by creating MediaItem instances and adding them to the Playlist:
 
-    file = File.open 'spec/fixtures/master.m3u8'
-    playlist = M3u8::Playlist.read file
-    playlist.master?
-    # => true
+```ruby
+hash = { type: 'AUDIO', group_id: 'audio-lo', language: 'fre',
+         assoc_language: 'spoken', name: 'Francais', autoselect: true,
+         default: false, forced: true, uri: 'frelo/prog_index.m3u8' }
+item = M3u8::MediaItem.new(hash)
+playlist.items.push item
+```
+  
+Create a standard playlist and add MPEG-TS segments via SegmentItem. You can also specify options for this type of playlist, however these options are ignored if playlist becomes a master playlist (anything but segments added):
+```ruby
+options = { version: 1, cache: false, target: 12, sequence: 1 }
+playlist = M3u8::Playlist.new options
+
+item = M3u8::SegmentItem.new duration: 11, segment: 'test.ts'
+playlist.items.push item
+```
+    
+You can pass an IO object to the write method:
+```ruby
+require 'tempfile'
+f = Tempfile.new 'test'
+playlist.write f
+```
+You can also access the playlist as a string:
+```ruby
+playlist.to_s
+``` 
+M3u8::Writer is the class that handles generating the playlist output.
 
-    #acess items in playlist:
-    playlist.items
+Alternatively you can set codecs rather than having it generated automatically:
+```ruby
+options = { program_id: 1, width: 1920, height: 1080, width: 1920, height: 1080, 
+            codecs: 'avc1.66.30,mp4a.40.2', bandwidth: 540, playlist: 'test.url' }
+item = M3u8::PlaylistItem.new options
+```
+Just get the codec string for custom use:
+```ruby
+options = { profile: 'baseline', level: 3.0, audio_codec: 'aac-lc' }
+codecs = M3u8::Playlist.codecs options
+# => "avc1.66.30,mp4a.40.2"
+```        
+Values for audio_codec (codec name): aac-lc, he-aac, mp3
+    
+Possible values for profile (H.264 Profile): baseline, main, high.
+    
+Possible values for level (H.264 Level): 3.0, 3.1, 4.0, 4.1. 
 
-    playlist.items.first
-    #  => #<M3u8::PlaylistItem:0x007fa569bc7698 @program_id="1", @resolution="1920x1080", 
-    #  @codecs="avc1.640028,mp4a.40.2", @bandwidth="5042000", 
-    #  @playlist="hls/1080-7mbps/1080-7mbps.m3u8">
+Not all Levels and Profiles can be combined, consult H.264 documentation
 
-    #create a new playlist item with options
-    options = { program_id: 1, width: 1920, height: 1080, width: 1920, height: 1080, 
-                profile: 'high', level: 4.1, audio_codec: 'aac-lc', bitrate: 540, 
-                playlist: 'test.url' }
-    item = M3u8::PlaylistItem.new options
-    #add it to the top of the playlist
-    playlist.items.insert 0, item
+## Parsing Usage
 
-    #There is a M3u8::Reader class if you want more control over parsing
-	
+```ruby
+file = File.open 'spec/fixtures/master.m3u8'
+playlist = M3u8::Playlist.read file
+playlist.master?
+# => true
+```
+Acess items in playlist:
+```ruby
+playlist.items.first
+#  => #<M3u8::PlaylistItem:0x007fa569bc7698 @program_id="1", @resolution="1920x1080", 
+#  @codecs="avc1.640028,mp4a.40.2", @bandwidth="5042000", 
+#  @playlist="hls/1080-7mbps/1080-7mbps.m3u8">
+```
+Create a new playlist item with options:
+```ruby
+options = { program_id: 1, width: 1920, height: 1080, width: 1920, height: 1080, 
+            profile: 'high', level: 4.1, audio_codec: 'aac-lc', bandwidth: 540, 
+            playlist: 'test.url' }
+item = M3u8::PlaylistItem.new options
+#add it to the top of the playlist
+playlist.items.insert 0, item
+```
+M3u8::Reader is the class handles parsing if you want more control over the process.
+    
 ## Features
 * Distinction between segment and master playlists is handled automatically (no need to use a different class).
 * Automatically generates the audio/video codec string based on names and options you are familar with.
 * Provides validation of input when adding playlists or segments.
 * Allows all options to be configured on a playlist (caching, version, etc.)
+* Supports I-Frames (Intra frames) and Byte Ranges in Segments.
+* Supports subtitles, closed captions, alternate audio and video, and comments.
+# Supports Session Data in master playlists.
 * Can write playlist to an IO object (StringIO/File, etc) or access string via to_s.
 * Can read playlists into a model (Playlist and Items) from an IO object.
+* Any tag or attribute supported by the object model is supported both parsing and generation of m3u8 playlists.
 
 ## Missing (but planned) Features 
-* Support for encryption keys and DRM.
-* Support I-Frame and Byte-Range.
-* Validation of all attributes to match the spec completely.
-* Support for all additional attributes in the latest version of the spec.
+* Support for encrypted segments.
+* Validation of all attributes and their values to match the rules defined in the spec.
+* Still missing support for a few tags and attributes.
 
 ## Contributing
 

data/lib/m3u8.rb

@@ -4,9 +4,15 @@ require 'm3u8/playlist'
 require 'm3u8/playlist_item'
 require 'm3u8/segment_item'
 require 'm3u8/media_item'
+require 'm3u8/session_data_item'
 require 'm3u8/reader'
 require 'm3u8/writer'
 require 'm3u8/error'
 
 module M3u8
+
+  def parse_attributes(line)
+    array = line.scan(/([A-z-]+)\s*=\s*("[^"]*"|[^,]*)/)
+    Hash[array.map { |key, value| [key, value.gsub('"', '')] }]
+  end
 end

data/lib/m3u8/media_item.rb

@@ -1,7 +1,7 @@
 module M3u8
   # MediaItem represents a set of EXT-X-MEDIA attributes
   class MediaItem
-    attr_accessor :type, :group, :language, :assoc_language, :name,
+    attr_accessor :type, :group_id, :language, :assoc_language, :name,
                   :autoselect, :default, :uri, :forced
 
     def initialize(params = {})
@@ -12,7 +12,7 @@ module M3u8
 
     def to_s
       attributes = [type_format,
-                    group_format,
+                    group_id_format,
                     language_format,
                     assoc_language_format,
                     name_format,
@@ -29,8 +29,8 @@ module M3u8
       "TYPE=#{type}"
     end
 
-    def group_format
-      %(GROUP-ID="#{group}")
+    def group_id_format
+      %(GROUP-ID="#{group_id}")
     end
 
     def language_format

data/lib/m3u8/playlist.rb

@@ -2,7 +2,8 @@ module M3u8
   # Playlist represents an m3u8 playlist, it can be a master playlist or a set
   # of media segments
   class Playlist
-    attr_accessor :items, :version, :cache, :target, :sequence, :type
+    attr_accessor :items, :version, :cache, :target, :sequence, :type,
+                  :iframes_only
 
     def initialize(options = {})
       assign_options options
@@ -55,7 +56,8 @@ module M3u8
         version: 3,
         sequence: 0,
         cache: true,
-        target: 10
+        target: 10,
+        iframes_only: false
       }.merge options
 
       self.version = options[:version]
@@ -63,6 +65,7 @@ module M3u8
       self.cache = options[:cache]
       self.target = options[:target]
       self.type = options[:type]
+      self.iframes_only = options[:iframes_only]
     end
 
     def playlist_size

data/lib/m3u8/playlist_item.rb

@@ -1,12 +1,14 @@
 module M3u8
-  # PlaylistItem represents a set of EXT-X-STREAM-INF attributes
+  # PlaylistItem represents a set of EXT-X-STREAM-INF or
+  # EXT-X-I-FRAME-STREAM-INF attributes
   class PlaylistItem
-    attr_accessor :program_id, :width, :height, :codecs, :bitrate, :playlist,
-                  :audio_codec, :level, :profile, :video, :audio,
-                  :average_bandwidth, :subtitles, :closed_captions
+    attr_accessor :program_id, :width, :height, :codecs, :bandwidth,
+                  :audio_codec, :level, :profile, :video, :audio, :uri,
+                  :average_bandwidth, :subtitles, :closed_captions, :iframe
     MISSING_CODEC_MESSAGE = 'Audio or video codec info should be provided.'
 
     def initialize(params = {})
+      self.iframe = false
       params.each do |key, value|
         instance_variable_set("@#{key}", value)
       end
@@ -36,16 +38,7 @@ module M3u8
     def to_s
       validate
 
-      attributes = [program_id_format,
-                    resolution_format,
-                    codecs_format,
-                    bandwidth_format,
-                    average_bandwidth_format,
-                    audio_format,
-                    video_format,
-                    subtitles_format,
-                    closed_captions_format].compact.join(',')
-      "#EXT-X-STREAM-INF:#{attributes}\n#{playlist}"
+      m3u8_format
     end
 
     private
@@ -54,6 +47,24 @@ module M3u8
       fail MissingCodecError, MISSING_CODEC_MESSAGE if codecs.nil?
     end
 
+    def m3u8_format
+      return %(#EXT-X-I-FRAME-STREAM-INF:#{attributes},URI="#{uri}") if iframe
+
+      "#EXT-X-STREAM-INF:#{attributes}\n#{uri}"
+    end
+
+    def attributes
+      [program_id_format,
+       resolution_format,
+       codecs_format,
+       bandwidth_format,
+       average_bandwidth_format,
+       audio_format,
+       video_format,
+       subtitles_format,
+       closed_captions_format].compact.join(',')
+    end
+
     def program_id_format
       return if program_id.nil?
       "PROGRAM-ID=#{program_id}"
@@ -69,7 +80,7 @@ module M3u8
     end
 
     def bandwidth_format
-      "BANDWIDTH=#{bitrate}"
+      "BANDWIDTH=#{bandwidth}"
     end
 
     def average_bandwidth_format

data/lib/m3u8/reader.rb

@@ -7,28 +7,18 @@ module M3u8
     SEQUENCE_START = '#EXT-X-MEDIA-SEQUENCE:'
     CACHE_START = '#EXT-X-ALLOW-CACHE:'
     TARGET_START = '#EXT-X-TARGETDURATION:'
+    IFRAME_START = '#EXT-X-I-FRAMES-ONLY'
     STREAM_START = '#EXT-X-STREAM-INF:'
+    STREAM_IFRAME_START = '#EXT-X-I-FRAME-STREAM-INF:'
     MEDIA_START = '#EXT-X-MEDIA:'
+    SESSION_DATA_START = '#EXT-X-SESSION-DATA:'
     SEGMENT_START = '#EXTINF:'
-    # EXT-X-STREAM-INF:
-    PROGRAM_ID = 'PROGRAM-ID'
+    BYTERANGE_START = '#EXT-X-BYTERANGE:'
     RESOLUTION = 'RESOLUTION'
-    CODECS = 'CODECS'
     BANDWIDTH = 'BANDWIDTH'
     AVERAGE_BANDWIDTH = 'AVERAGE-BANDWIDTH'
-    VIDEO = 'VIDEO'
-    AUDIO = 'AUDIO'
-    SUBTITLES = 'SUBTITLES'
-    CLOSED_CAPTIONS = 'CLOSED-CAPTIONS'
-    # EXT-X-MEDIA:
-    TYPE = 'TYPE'
-    GROUP_ID = 'GROUP-ID'
-    LANGUAGE = 'LANGUAGE'
-    ASSOC_LANGUAGE = 'ASSOC-LANGUAGE'
-    NAME = 'NAME'
     AUTOSELECT = 'AUTOSELECT'
     DEFAULT = 'DEFAULT'
-    URI = 'URI'
     FORCED = 'FORCED'
 
     def read(input)
@@ -44,6 +34,26 @@ module M3u8
     def parse_line(line)
       return if line.start_with? PLAYLIST_START
 
+      if line.start_with? STREAM_START
+        parse_stream line
+      elsif line.start_with? STREAM_IFRAME_START
+        parse_iframe_stream line
+      elsif line.start_with? SEGMENT_START
+        parse_segment line
+      elsif line.start_with? MEDIA_START
+        parse_media line
+      elsif line.start_with? BYTERANGE_START
+        parse_byterange line
+      elsif line.start_with? SESSION_DATA_START
+        parse_session_data line
+      elsif !item.nil? && open
+        parse_next_line line
+      else
+        parse_header line
+      end
+    end
+
+    def parse_header(line)
       if line.start_with? PLAYLIST_TYPE_START
         parse_playlist_type line
       elsif line.start_with? VERSION_START
@@ -54,14 +64,8 @@ module M3u8
         parse_cache line
       elsif line.start_with? TARGET_START
         parse_target line
-      elsif line.start_with? STREAM_START
-        parse_stream line
-      elsif line.start_with? SEGMENT_START
-        parse_segment line
-      elsif line.start_with? MEDIA_START
-        parse_media line
-      elsif !item.nil? && open
-        parse_value(line)
+      elsif line.start_with? IFRAME_START
+        playlist.iframes_only = true
       end
     end
 
@@ -82,10 +86,6 @@ module M3u8
       playlist.cache = parse_yes_no(line)
     end
 
-    def parse_yes_no(string)
-      string == 'YES' ? true : false
-    end
-
     def parse_target(line)
       playlist.target = line.gsub(TARGET_START, '').to_i
     end
@@ -96,88 +96,117 @@ module M3u8
 
       self.item = M3u8::PlaylistItem.new
       line = line.gsub STREAM_START, ''
-      attributes = line.scan(/([A-z-]+)\s*=\s*("[^"]*"|[^,]*)/)
+      attributes = parse_attributes line
+      parse_stream_attributes attributes
+    end
+
+    def parse_iframe_stream(line)
+      self.master = true
+      self.open = false
+
+      self.item = M3u8::PlaylistItem.new
+      item.iframe = true
+      line = line.gsub STREAM_IFRAME_START, ''
+      attributes = parse_attributes line
+      parse_stream_attributes attributes
+      playlist.items.push item
+    end
+
+    def parse_stream_attributes(attributes)
       attributes.each do |pair|
-        value = pair[1].gsub("\n", '').gsub('"', '')
-        case pair[0]
-        when PROGRAM_ID
-          item.program_id = value
+        name = pair[0]
+        value = parse_value pair[1]
+        case name
         when RESOLUTION
           parse_resolution value
-        when CODECS
-          item.codecs = value
         when BANDWIDTH
-          item.bitrate = value.to_i
+          item.bandwidth = value.to_i
         when AVERAGE_BANDWIDTH
           item.average_bandwidth = value.to_i
-        when AUDIO
-          item.audio = value
-        when VIDEO
-          item.video = value
-        when SUBTITLES
-          item.subtitles = value
-        when CLOSED_CAPTIONS
-          item.closed_captions = value
+        else
+          set_value name, value
         end
       end
     end
 
+    def parse_resolution(resolution)
+      item.width = resolution.split('x')[0].to_i
+      item.height = resolution.split('x')[1].to_i
+    end
+
     def parse_segment(line)
+      self.item = M3u8::SegmentItem.new
+      values = line.gsub(SEGMENT_START, '').gsub("\n", ',').split(',')
+      item.duration = values[0].to_f
+      item.comment = values[1] unless values[1].nil?
+
       self.master = false
       self.open = true
+    end
 
-      values = line.gsub(SEGMENT_START, '').gsub("\n", ',').split(',')
+    def parse_byterange(line)
+      values = line.gsub(BYTERANGE_START, '').gsub("\n", ',').split '@'
+      item.byterange_length = values[0].to_i
+      item.byterange_start = values[1].to_i unless values[1].nil?
+    end
 
-      self.item = M3u8::SegmentItem.new
-      item.duration = values[0].to_f
-      item.comment = values[1] unless values[1].nil?
+    def parse_session_data(line)
+      item = M3u8::SessionDataItem.parse line
+      playlist.items.push item
     end
 
     def parse_media(line)
       self.open = false
       self.item = M3u8::MediaItem.new
       line = line.gsub MEDIA_START, ''
-      attributes = line.scan(/([A-z-]+)\s*=\s*("[^"]*"|[^,]*)/)
+      attributes = parse_attributes line
+      parse_media_attributes attributes
+      playlist.items.push item
+    end
+
+    def parse_media_attributes(attributes)
       attributes.each do |pair|
-        value = pair[1].gsub("\n", '').gsub('"', '')
-        case pair[0]
-        when TYPE
-          item.type = value
-        when GROUP_ID
-          item.group = value
-        when LANGUAGE
-          item.language = value
-        when ASSOC_LANGUAGE
-          item.assoc_language = value
-        when NAME
-          item.name = value
+        name = pair[0]
+        value = parse_value pair[1]
+        case name
         when AUTOSELECT
           item.autoselect = parse_yes_no value
         when DEFAULT
           item.default = parse_yes_no value
-        when URI
-          item.uri = value
         when FORCED
           item.forced = parse_yes_no value
+        else
+          set_value name, value
         end
       end
-      playlist.items.push item
-    end
-
-    def parse_resolution(resolution)
-      item.width = resolution.split('x')[0].to_i
-      item.height = resolution.split('x')[1].to_i
     end
 
-    def parse_value(line)
+    def parse_next_line(line)
       value = line.gsub "\n", ''
       if master
-        item.playlist = value
+        item.uri = value
       else
         item.segment = value
       end
       playlist.items.push item
       self.open = false
     end
+
+    def parse_yes_no(string)
+      string == 'YES' ? true : false
+    end
+
+    def parse_attributes(line)
+      line.scan(/([A-z-]+)\s*=\s*("[^"]*"|[^,]*)/)
+    end
+
+    def parse_value(value)
+      value.gsub("\n", '').gsub('"', '')
+    end
+
+    def set_value(name, value)
+      name = name.downcase.gsub('-', '_')
+      item.instance_variable_set("@#{name}", value)
+    end
   end
 end

data/lib/m3u8/segment_item.rb

@@ -1,6 +1,7 @@
 module M3u8
   class SegmentItem
-    attr_accessor :duration, :segment, :comment
+    attr_accessor :duration, :segment, :comment, :byterange_length,
+                  :byterange_start
 
     def initialize(params = {})
       params.each do |key, value|
@@ -9,7 +10,19 @@ module M3u8
     end
 
     def to_s
-      "#EXTINF:#{duration},#{comment}\n#{segment}"
+      "#EXTINF:#{duration},#{comment}#{byterange_format}\n#{segment}"
+    end
+
+    private
+
+    def byterange_format
+      return if byterange_length.nil?
+      "\n#EXT-X-BYTERANGE:#{byterange_length}#{byterange_start_format}"
+    end
+
+    def byterange_start_format
+      return if byterange_start.nil?
+      "@#{byterange_start}"
     end
   end
 end

data/lib/m3u8/session_data_item.rb

@@ -0,0 +1,52 @@
+module M3u8
+  # SessionDataItem represents a set of EXT-X-SESSION-DATA attributes
+  class SessionDataItem
+    extend M3u8
+    attr_accessor :data_id, :value, :uri, :language
+
+    def initialize(params = {})
+      params.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def self.parse(text)
+      attributes = parse_attributes text
+      options = { data_id: attributes['DATA-ID'], value: attributes['VALUE'],
+                  uri: attributes['URI'], language: attributes['LANGUAGE'] }
+      M3u8::SessionDataItem.new options
+    end
+
+    def to_s
+      attributes = [data_id_format,
+                    value_format,
+                    uri_format,
+                    language_format].compact.join(',')
+      "#EXT-X-SESSION-DATA:#{attributes}"
+    end
+
+    private
+
+    def data_id_format
+      %(DATA-ID="#{data_id}")
+    end
+
+    def value_format
+      return if value.nil?
+
+      %(VALUE="#{value}")
+    end
+
+    def uri_format
+      return if uri.nil?
+
+      %(URI="#{uri}")
+    end
+
+    def language_format
+      return if language.nil?
+
+      %(LANGUAGE="#{language}")
+    end
+  end
+end

data/lib/m3u8/version.rb

@@ -1,3 +1,3 @@
 module M3u8
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/m3u8/writer.rb

@@ -30,6 +30,7 @@ module M3u8
     def write_header(playlist)
       io.puts "#EXT-X-PLAYLIST-TYPE:#{playlist.type}" unless playlist.type.nil?
       io.puts "#EXT-X-VERSION:#{playlist.version}"
+      io.puts '#EXT-X-I-FRAMES-ONLY' if playlist.iframes_only
       io.puts "#EXT-X-MEDIA-SEQUENCE:#{playlist.sequence}"
       io.puts "#EXT-X-ALLOW-CACHE:#{cache(playlist)}"
       io.puts "#EXT-X-TARGETDURATION:#{playlist.target}"

data/spec/fixtures/iframes.m3u8

@@ -0,0 +1,12 @@
+#EXTM3U
+#EXT-X-VERSION:4
+#EXT-X-I-FRAMES-ONLY
+#EXTINF:4.12,
+#EXT-X-BYTERANGE:9400@376
+segment1.ts
+#EXTINF:3.56,
+#EXT-X-BYTERANGE:7144
+segment1.ts
+#EXTINF:3.82,
+#EXT-X-BYTERANGE:10340@1880
+segment2.ts

data/spec/fixtures/master_iframes.m3u8

@@ -0,0 +1,12 @@
+#EXTM3U
+#EXT-X-STREAM-INF:BANDWIDTH=1280000
+low/audio-video.m3u8
+#EXT-X-I-FRAME-STREAM-INF:BANDWIDTH=86000,URI="low/iframe.m3u8"
+#EXT-X-STREAM-INF:BANDWIDTH=2560000
+mid/audio-video.m3u8
+#EXT-X-I-FRAME-STREAM-INF:BANDWIDTH=150000,URI="mid/iframe.m3u8"
+#EXT-X-STREAM-INF:BANDWIDTH=7680000
+hi/audio-video.m3u8
+#EXT-X-I-FRAME-STREAM-INF:BANDWIDTH=550000,URI="hi/iframe.m3u8"
+#EXT-X-STREAM-INF:BANDWIDTH=65000,CODECS="mp4a.40.5"
+audio-only.m3u8

data/spec/fixtures/session_data.m3u8

@@ -0,0 +1,4 @@
+#EXT-X-SESSION-DATA:DATA-ID="com.example.lyrics",URI="lyrics.json"
+
+#EXT-X-SESSION-DATA:DATA-ID="com.example.title",LANGUAGE="en",VALUE="This is an example"
+#EXT-X-SESSION-DATA:DATA-ID="com.example.title",LANGUAGE="sp",VALUE="Este es un ejemplo"

data/spec/m3u8_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe do
+  let(:test_class) { Class.new { extend M3u8 } }
+
+  it 'should parse attributes to hash' do
+    line = %(TEST-ID="Help",URI="http://test",ID=33)
+    hash = test_class.parse_attributes line
+    expect(hash['TEST-ID']).to eq 'Help'
+    expect(hash['URI']).to eq 'http://test'
+    expect(hash['ID']).to eq '33'
+  end
+end

data/spec/media_item_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe M3u8::MediaItem do
   it 'should provide m3u8 format representation' do
-    hash = { type: 'AUDIO', group: 'audio-lo', language: 'fre',
+    hash = { type: 'AUDIO', group_id: 'audio-lo', language: 'fre',
              name: 'Francais', autoselect: true, default: false,
              uri: 'frelo/prog_index.m3u8' }
     item = M3u8::MediaItem.new(hash)
@@ -12,7 +12,7 @@ describe M3u8::MediaItem do
                'URI="frelo/prog_index.m3u8"'
     expect(output).to eq expected
 
-    hash = { type: 'AUDIO', group: 'audio-lo', language: 'fre',
+    hash = { type: 'AUDIO', group_id: 'audio-lo', language: 'fre',
              assoc_language: 'spoken', name: 'Francais', autoselect: true,
              default: false, forced: true, uri: 'frelo/prog_index.m3u8' }
     item = M3u8::MediaItem.new(hash)

data/spec/playlist_item_spec.rb

@@ -3,34 +3,36 @@ require 'spec_helper'
 describe M3u8::PlaylistItem do
   it 'should initialize with hash' do
     hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bitrate: 540, playlist: 'test.url' }
+             bandwidth: 540, uri: 'test.url' }
     item = M3u8::PlaylistItem.new(hash)
     expect(item.program_id).to eq 1
     expect(item.width).to eq 1920
     expect(item.height).to eq 1080
     expect(item.resolution).to eq '1920x1080'
     expect(item.codecs).to eq 'avc'
-    expect(item.bitrate).to eq 540
-    expect(item.playlist).to eq 'test.url'
+    expect(item.bandwidth).to eq 540
+    expect(item.uri).to eq 'test.url'
+    expect(item.iframe).to be false
   end
 
   it 'should provide m3u8 format representation' do
     hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bitrate: 540, playlist: 'test.url' }
+             bandwidth: 540, uri: 'test.url' }
     item = M3u8::PlaylistItem.new(hash)
     output = item.to_s
     expected = '#EXT-X-STREAM-INF:PROGRAM-ID=1,RESOLUTION=1920x1080,' +
                %(CODECS="avc",BANDWIDTH=540\ntest.url)
     expect(output).to eq expected
 
-    hash = { program_id: 1, codecs: 'avc', bitrate: 540, playlist: 'test.url' }
+    hash = { program_id: 1, codecs: 'avc', bandwidth: 540,
+             uri: 'test.url' }
     item = M3u8::PlaylistItem.new(hash)
     output = item.to_s
     expected = '#EXT-X-STREAM-INF:PROGRAM-ID=1,' +
                %(CODECS="avc",BANDWIDTH=540\ntest.url)
     expect(output).to eq expected
 
-    hash = { codecs: 'avc', bitrate: 540, playlist: 'test.url', audio: 'test',
+    hash = { codecs: 'avc', bandwidth: 540, uri: 'test.url', audio: 'test',
              video: 'test2', average_bandwidth: 550, subtitles: 'subs',
              closed_captions: 'caps' }
     item = M3u8::PlaylistItem.new(hash)
@@ -41,6 +43,16 @@ describe M3u8::PlaylistItem do
     expect(output).to eq expected
   end
 
+  it 'should provided m3u8 format with I-Frame option' do
+    hash = { codecs: 'avc', bandwidth: 540, uri: 'test.url', iframe: true,
+             video: 'test2', average_bandwidth: 550 }
+    item = M3u8::PlaylistItem.new(hash)
+    output = item.to_s
+    expected = %(#EXT-X-I-FRAME-STREAM-INF:CODECS="avc",BANDWIDTH=540,) +
+               %(AVERAGE-BANDWIDTH=550,VIDEO="test2",URI="test.url")
+    expect(output).to eq expected
+  end
+
   it 'should generate codecs string' do
     item = M3u8::PlaylistItem.new
     expect(item.codecs).to be_nil
@@ -119,7 +131,7 @@ describe M3u8::PlaylistItem do
   end
 
   it 'should raise error if codecs are missing' do
-    params = { program_id: 1, bitrate: 540, playlist: 'test.url' }
+    params = { program_id: 1, bandwidth: 540, uri: 'test.url' }
     item = M3u8::PlaylistItem.new params
     message = 'Audio or video codec info should be provided.'
     expect { item.to_s }.to raise_error(M3u8::MissingCodecError, message)

data/spec/playlist_spec.rb

@@ -8,7 +8,7 @@ describe M3u8::Playlist do
   end
 
   it 'should render master playlist' do
-    options = { playlist: 'playlist_url', bitrate: 6400,
+    options = { uri: 'playlist_url', bandwidth: 6400,
                 audio_codec: 'mp3' }
     item = M3u8::PlaylistItem.new options
     playlist = M3u8::Playlist.new
@@ -19,7 +19,7 @@ describe M3u8::Playlist do
              ",BANDWIDTH=6400\nplaylist_url\n"
     expect(playlist.to_s).to eq output
 
-    options = { program_id: '1', playlist: 'playlist_url', bitrate: 6400,
+    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
                 audio_codec: 'mp3' }
     item = M3u8::PlaylistItem.new options
     playlist = M3u8::Playlist.new
@@ -30,7 +30,7 @@ describe M3u8::Playlist do
              ",BANDWIDTH=6400\nplaylist_url\n"
     expect(playlist.to_s).to eq output
 
-    options = { program_id: '2', playlist: 'playlist_url', bitrate: 50_000,
+    options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
                 width: 1920, height: 1080, profile: 'high', level: 4.1,
                 audio_codec: 'aac-lc' }
     item = M3u8::PlaylistItem.new options
@@ -45,11 +45,11 @@ describe M3u8::Playlist do
     expect(playlist.to_s).to eq output
 
     playlist = M3u8::Playlist.new
-    options = { program_id: '1', playlist: 'playlist_url', bitrate: 6400,
+    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
                 audio_codec: 'mp3' }
     item = M3u8::PlaylistItem.new options
     playlist.items.push item
-    options = { program_id: '2', playlist: 'playlist_url', bitrate: 50_000,
+    options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
                 width: 1920, height: 1080, profile: 'high', level: 4.1,
                 audio_codec: 'aac-lc' }
     item = M3u8::PlaylistItem.new options
@@ -118,7 +118,7 @@ describe M3u8::Playlist do
   it 'should write playlist to io' do
     test_io = StringIO.new
     playlist = M3u8::Playlist.new
-    options = { program_id: '1', playlist: 'playlist_url', bitrate: 6400,
+    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
                 audio_codec: 'mp3' }
     item = M3u8::PlaylistItem.new options
     playlist.items.push item
@@ -143,7 +143,7 @@ describe M3u8::Playlist do
   it 'should report if it is a master playlist' do
     playlist = M3u8::Playlist.new
     expect(playlist.master?).to be false
-    options = { program_id: '1', playlist: 'playlist_url', bitrate: 6400,
+    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
                 audio_codec: 'mp3' }
     item = M3u8::PlaylistItem.new options
     playlist.items.push item
@@ -155,7 +155,7 @@ describe M3u8::Playlist do
     playlist = M3u8::Playlist.new
 
     hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bitrate: 540, playlist: 'test.url' }
+             bandwidth: 540, uri: 'test.url' }
     item = M3u8::PlaylistItem.new(hash)
     playlist.items.push item
 
@@ -174,13 +174,13 @@ describe M3u8::Playlist do
     expect(playlist.valid?).to be true
 
     hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bitrate: 540, playlist: 'test.url' }
+             bandwidth: 540, uri: 'test.url' }
     item = M3u8::PlaylistItem.new(hash)
     playlist.items.push item
     expect(playlist.valid?).to be true
 
     hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bitrate: 540, playlist: 'test.url' }
+             bandwidth: 540, uri: 'test.url' }
     item = M3u8::PlaylistItem.new(hash)
     playlist.items.push item
     expect(playlist.valid?).to be true
@@ -201,6 +201,7 @@ describe M3u8::Playlist do
     expect(playlist.target).to be 12
     expect(playlist.sequence).to be 1
     expect(playlist.type).to eq('VOD')
+    expect(playlist.iframes_only).to be false
   end
 
   it 'should allow reading of playlists' do

data/spec/reader_spec.rb

@@ -9,13 +9,14 @@ describe M3u8::Reader do
 
     item = playlist.items[0]
     expect(item).to be_a(M3u8::PlaylistItem)
-    expect(item.playlist).to eq('hls/1080-7mbps/1080-7mbps.m3u8')
+    expect(item.uri).to eq('hls/1080-7mbps/1080-7mbps.m3u8')
     expect(item.program_id).to eq('1')
     expect(item.width).to eq(1920)
     expect(item.height).to eq(1080)
     expect(item.resolution).to eq('1920x1080')
     expect(item.codecs).to eq('avc1.640028,mp4a.40.2')
-    expect(item.bitrate).to eq(5_042_000)
+    expect(item.bandwidth).to eq(5_042_000)
+    expect(item.iframe).to be false
 
     expect(playlist.items.size).to eq 6
 
@@ -23,6 +24,21 @@ describe M3u8::Reader do
     expect(item.resolution).to be_nil
   end
 
+  it 'should parse master playlist with I-Frames' do
+    file = File.open 'spec/fixtures/master_iframes.m3u8'
+    reader = M3u8::Reader.new
+    playlist = reader.read file
+    expect(playlist.master?).to be true
+
+    expect(playlist.items.size).to eq 7
+
+    item = playlist.items[1]
+    expect(item).to be_a(M3u8::PlaylistItem)
+    expect(item.bandwidth).to eq(86_000)
+    expect(item.iframe).to be true
+    expect(item.uri).to eq 'low/iframe.m3u8'
+  end
+
   it 'should parse segment playlist' do
     file = File.open 'spec/fixtures/playlist.m3u8'
     reader = M3u8::Reader.new
@@ -42,6 +58,26 @@ describe M3u8::Reader do
     expect(playlist.items.size).to eq 138
   end
 
+  it 'should parse I-Frame playlist' do
+    file = File.open 'spec/fixtures/iframes.m3u8'
+    reader = M3u8::Reader.new
+    playlist = reader.read file
+
+    expect(playlist.iframes_only).to be true
+    expect(playlist.items.size).to eq 3
+
+    item = playlist.items[0]
+    expect(item).to be_a(M3u8::SegmentItem)
+    expect(item.duration).to eq 4.12
+    expect(item.byterange_length).to eq 9400
+    expect(item.byterange_start).to eq 376
+    expect(item.segment).to eq 'segment1.ts'
+
+    item = playlist.items[1]
+    expect(item.byterange_length).to eq 7144
+    expect(item.byterange_start).to be_nil
+  end
+
   it 'should parse segment playlist with comments' do
     file = File.open 'spec/fixtures/playlist_with_comments.m3u8'
     reader = M3u8::Reader.new
@@ -72,7 +108,7 @@ describe M3u8::Reader do
     item = playlist.items[0]
     expect(item).to be_a M3u8::MediaItem
     expect(item.type).to eq 'AUDIO'
-    expect(item.group).to eq 'audio-lo'
+    expect(item.group_id).to eq 'audio-lo'
     expect(item.language).to eq 'eng'
     expect(item.assoc_language).to eq 'spoken'
     expect(item.name).to eq 'English'
@@ -93,7 +129,7 @@ describe M3u8::Reader do
     item = playlist.items[1]
     expect(item).to be_a M3u8::MediaItem
     expect(item.type).to eq 'VIDEO'
-    expect(item.group).to eq '200kbs'
+    expect(item.group_id).to eq '200kbs'
     expect(item.language).to be_nil
     expect(item.name).to eq 'Angle2'
     expect(item.autoselect).to be true
@@ -120,4 +156,17 @@ describe M3u8::Reader do
 
     expect(playlist.items.size).to eq 6
   end
+
+  it 'should parse playlist with session data' do
+    file = File.open 'spec/fixtures/session_data.m3u8'
+    reader = M3u8::Reader.new
+    playlist = reader.read file
+
+    expect(playlist.items.size).to eq 3
+
+    item = playlist.items[0]
+    expect(item).to be_a M3u8::SessionDataItem
+    expect(item.data_id).to eq 'com.example.lyrics'
+    expect(item.uri).to eq 'lyrics.json'
+  end
 end

data/spec/segment_item_spec.rb

@@ -8,9 +8,12 @@ describe M3u8::SegmentItem do
     expect(item.segment).to eq 'test.ts'
     expect(item.comment).to be_nil
 
-    hash = { duration: 10.991, segment: 'test.ts', comment: 'anything' }
+    hash = { duration: 10.991, segment: 'test.ts', comment: 'anything',
+             byterange_length: 4500, byterange_start: 600 }
     item = M3u8::SegmentItem.new(hash)
     expect(item.duration).to eq 10.991
+    expect(item.byterange_length).to eq 4500
+    expect(item.byterange_start).to eq 600
     expect(item.segment).to eq 'test.ts'
     expect(item.comment).to eq 'anything'
   end
@@ -27,5 +30,19 @@ describe M3u8::SegmentItem do
     output = item.to_s
     expected = "#EXTINF:10.991,anything\ntest.ts"
     expect(output).to eq expected
+
+    hash = { duration: 10.991, segment: 'test.ts', comment: 'anything',
+             byterange_length: 4500, byterange_start: 600 }
+    item = M3u8::SegmentItem.new(hash)
+    output = item.to_s
+    expected = "#EXTINF:10.991,anything\n#EXT-X-BYTERANGE:4500@600\ntest.ts"
+    expect(output).to eq expected
+
+    hash = { duration: 10.991, segment: 'test.ts', comment: 'anything',
+             byterange_length: 4500 }
+    item = M3u8::SegmentItem.new(hash)
+    output = item.to_s
+    expected = "#EXTINF:10.991,anything\n#EXT-X-BYTERANGE:4500\ntest.ts"
+    expect(output).to eq expected
   end
 end

data/spec/session_data_item_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe M3u8::SessionDataItem do
+  it 'should initialize with hash' do
+    hash = { data_id: 'com.test.movie.title', value: 'Test',
+             uri: 'http://test', language: 'en' }
+    item = M3u8::SessionDataItem.new(hash)
+    expect(item.data_id).to eq 'com.test.movie.title'
+    expect(item.value).to eq 'Test'
+    expect(item.uri).to eq 'http://test'
+    expect(item.language).to eq 'en'
+  end
+
+  it 'should provide m3u8 format representation' do
+    hash = { data_id: 'com.test.movie.title', value: 'Test',
+             language: 'en' }
+    item = M3u8::SessionDataItem.new(hash)
+    output = item.to_s
+    expected = %(#EXT-X-SESSION-DATA:DATA-ID="com.test.movie.title",) +
+               %(VALUE="Test",LANGUAGE="en")
+    expect(output).to eq expected
+
+    hash = { data_id: 'com.test.movie.title', uri: 'http://test',
+             language: 'en' }
+    item = M3u8::SessionDataItem.new(hash)
+    output = item.to_s
+    expected = %(#EXT-X-SESSION-DATA:DATA-ID="com.test.movie.title",) +
+               %(URI="http://test",LANGUAGE="en")
+    expect(output).to eq expected
+  end
+
+  it 'should parse m3u8 format into instance' do
+    format = %(#EXT-X-SESSION-DATA:DATA-ID="com.test.movie.title",) +
+             %(VALUE="Test",LANGUAGE="en")
+    item = M3u8::SessionDataItem.parse format
+    expect(item.data_id).to eq 'com.test.movie.title'
+    expect(item.value).to eq 'Test'
+    expect(item.uri).to be_nil
+    expect(item.language).to eq 'en'
+
+    format = %(#EXT-X-SESSION-DATA:DATA-ID="com.test.movie.title",) +
+             %(URI="http://test",LANGUAGE="en")
+    item = M3u8::SessionDataItem.parse format
+    expect(item.data_id).to eq 'com.test.movie.title'
+    expect(item.value).to be_nil
+    expect(item.uri).to eq 'http://test'
+    expect(item.language).to eq 'en'
+  end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,4 @@
-require 'm3u8/playlist'
-require 'm3u8/playlist_item'
-require 'm3u8/segment_item'
-require 'm3u8/media_item'
-require 'm3u8/reader'
-require 'm3u8/writer'
-require 'm3u8/error'
+require 'm3u8'
 
 require 'coveralls'
 Coveralls.wear!

data/spec/writer_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe M3u8::Writer do
   it 'should render master playlist' do
-    options = { playlist: 'playlist_url', bitrate: 6400,
+    options = { uri: 'playlist_url', bandwidth: 6400,
                 audio_codec: 'mp3' }
     item = M3u8::PlaylistItem.new options
     playlist = M3u8::Playlist.new
@@ -17,7 +17,7 @@ describe M3u8::Writer do
     writer.write playlist
     expect(io.string).to eq output
 
-    options = { program_id: '1', playlist: 'playlist_url', bitrate: 6400,
+    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
                 audio_codec: 'mp3' }
     item = M3u8::PlaylistItem.new options
     playlist = M3u8::Playlist.new
@@ -32,7 +32,7 @@ describe M3u8::Writer do
     writer.write playlist
     expect(io.string).to eq output
 
-    options = { program_id: '2', playlist: 'playlist_url', bitrate: 50_000,
+    options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
                 width: 1920, height: 1080, profile: 'high', level: 4.1,
                 audio_codec: 'aac-lc' }
     item = M3u8::PlaylistItem.new options
@@ -50,21 +50,27 @@ describe M3u8::Writer do
     expect(io.string).to eq output
 
     playlist = M3u8::Playlist.new
-    options = { program_id: '1', playlist: 'playlist_url', bitrate: 6400,
+    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
                 audio_codec: 'mp3' }
     item = M3u8::PlaylistItem.new options
     playlist.items.push item
-    options = { program_id: '2', playlist: 'playlist_url', bitrate: 50_000,
+    options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
                 width: 1920, height: 1080, profile: 'high', level: 4.1,
                 audio_codec: 'aac-lc' }
     item = M3u8::PlaylistItem.new options
     playlist.items.push item
+    options = { data_id: 'com.test.movie.title', value: 'Test',
+                uri: 'http://test', language: 'en' }
+    item = M3u8::SessionDataItem.new(options)
+    playlist.items.push item
 
     output = "#EXTM3U\n" +
              %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34") +
              ",BANDWIDTH=6400\nplaylist_url\n#EXT-X-STREAM-INF:PROGRAM-ID=2," +
              %(RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2") +
-             ",BANDWIDTH=50000\nplaylist_url\n"
+             ",BANDWIDTH=50000\nplaylist_url\n" +
+             %(#EXT-X-SESSION-DATA:DATA-ID="com.test.movie.title",) +
+             %(VALUE="Test",URI="http://test",LANGUAGE="en"\n)
 
     io = StringIO.open
     writer = M3u8::Writer.new io
@@ -110,8 +116,8 @@ describe M3u8::Writer do
     writer.write playlist
     expect(io.string).to eq output
 
-    options = { version: 1, cache: false, target: 12, sequence: 1,
-                type: 'EVENT' }
+    options = { version: 4, cache: false, target: 12, sequence: 1,
+                type: 'EVENT', iframes_only: true }
     playlist = M3u8::Playlist.new options
     options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
     item =  M3u8::SegmentItem.new options
@@ -119,7 +125,8 @@ describe M3u8::Writer do
 
     output = "#EXTM3U\n" \
       "#EXT-X-PLAYLIST-TYPE:EVENT\n" \
-      "#EXT-X-VERSION:1\n" \
+      "#EXT-X-VERSION:4\n" \
+      "#EXT-X-I-FRAMES-ONLY\n" \
       "#EXT-X-MEDIA-SEQUENCE:1\n" \
       "#EXT-X-ALLOW-CACHE:NO\n" \
       "#EXT-X-TARGETDURATION:12\n" \
@@ -136,7 +143,7 @@ describe M3u8::Writer do
     playlist = M3u8::Playlist.new
 
     hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bitrate: 540, playlist: 'test.url' }
+             bandwidth: 540, playlist: 'test.url' }
     item = M3u8::PlaylistItem.new(hash)
     playlist.items.push item
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: m3u8
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Seth Deckard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-20 00:00:00.000000000 Z
+date: 2015-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,19 +76,25 @@ files:
 - lib/m3u8/playlist_item.rb
 - lib/m3u8/reader.rb
 - lib/m3u8/segment_item.rb
+- lib/m3u8/session_data_item.rb
 - lib/m3u8/version.rb
 - lib/m3u8/writer.rb
 - m3u8.gemspec
+- spec/fixtures/iframes.m3u8
 - spec/fixtures/master.m3u8
+- spec/fixtures/master_iframes.m3u8
 - spec/fixtures/playlist.m3u8
 - spec/fixtures/playlist_with_comments.m3u8
+- spec/fixtures/session_data.m3u8
 - spec/fixtures/variant_angles.m3u8
 - spec/fixtures/variant_audio.m3u8
+- spec/m3u8_spec.rb
 - spec/media_item_spec.rb
 - spec/playlist_item_spec.rb
 - spec/playlist_spec.rb
 - spec/reader_spec.rb
 - spec/segment_item_spec.rb
+- spec/session_data_item_spec.rb
 - spec/spec_helper.rb
 - spec/writer_spec.rb
 homepage: https://github.com/sethdeckard/m3u8
@@ -116,15 +122,20 @@ signing_key:
 specification_version: 4
 summary: Generate and parse m3u8 playlists for HTTP Live Streaming (HLS).
 test_files:
+- spec/fixtures/iframes.m3u8
 - spec/fixtures/master.m3u8
+- spec/fixtures/master_iframes.m3u8
 - spec/fixtures/playlist.m3u8
 - spec/fixtures/playlist_with_comments.m3u8
+- spec/fixtures/session_data.m3u8
 - spec/fixtures/variant_angles.m3u8
 - spec/fixtures/variant_audio.m3u8
+- spec/m3u8_spec.rb
 - spec/media_item_spec.rb
 - spec/playlist_item_spec.rb
 - spec/playlist_spec.rb
 - spec/reader_spec.rb
 - spec/segment_item_spec.rb
+- spec/session_data_item_spec.rb
 - spec/spec_helper.rb
 - spec/writer_spec.rb