m3u8 0.7.1 → 0.8.0

data/lib/m3u8/reader.rb

@@ -14,8 +14,9 @@ module M3u8
     end
 
     def read(input)
-      self.playlist = Playlist.new
-      input.each_line do |line|
+      @playlist = Playlist.new
+      input.each_line.with_index do |line, index|
+        validate_file_format(line) if index.zero?
         parse_line(line)
       end
       playlist
@@ -42,6 +43,9 @@ module M3u8
     def media_playlist_tags
       {
         '#EXT-X-MEDIA-SEQUENCE' => ->(line) { parse_sequence(line) },
+        '#EXT-X-DISCONTINUITY-SEQUENCE' => lambda do |line|
+          parse_discontinuity_sequence(line)
+        end,
         '#EXT-X-ALLOW-CACHE' => ->(line) { parse_cache(line) },
         '#EXT-X-TARGETDURATION' => ->(line) { parse_target(line) },
         '#EXT-X-I-FRAMES-ONLY' => proc { playlist.iframes_only = true },
@@ -74,7 +78,10 @@ module M3u8
     end
 
     def match_tag(line)
-      tag = @tags.select { |key| line.start_with? key }
+      tag = @tags.select do |key|
+        line.start_with?(key) && !line.start_with?("#{key}-")
+      end
+
       return unless tag.values.first
       tag.values.first.call(line)
       true
@@ -125,6 +132,11 @@ module M3u8
       playlist.items << item
     end
 
+    def parse_discontinuity_sequence(line)
+      value = line.gsub('#EXT-X-DISCONTINUITY-SEQUENCE:', '').strip
+      playlist.discontinuity_sequence = Integer(value)
+    end
+
     def parse_key(line)
       item = M3u8::KeyItem.parse(line)
       playlist.items << item
@@ -197,5 +209,12 @@ module M3u8
       playlist.items << item
       self.open = false
     end
+
+    def validate_file_format(line)
+      return if line.rstrip == '#EXTM3U'
+      message = 'Playlist must start with a #EXTM3U tag, line read ' \
+                "contained the value: #{line}"
+      raise InvalidPlaylistError, message
+    end
   end
 end

data/lib/m3u8/time_item.rb

@@ -14,7 +14,7 @@ module M3u8
     def self.parse(text)
       time = text.gsub('#EXT-X-PROGRAM-DATE-TIME:', '')
       options = { time: Time.parse(time) }
-      TimeItem.new options
+      TimeItem.new(options)
     end
 
     def to_s

data/lib/m3u8/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 # M3u8 provides parsing, generation, and validation of m3u8 playlists
 module M3u8
-  VERSION = '0.7.1'
+  VERSION = '0.8.0'
 end

data/lib/m3u8/writer.rb

@@ -5,7 +5,7 @@ module M3u8
     attr_accessor :io
 
     def initialize(io)
-      self.io = io
+      @io = io
     end
 
     def write(playlist)
@@ -16,10 +16,23 @@ module M3u8
         io.puts item.to_s
       end
 
-      return if playlist.master?
+      write_footer(playlist)
+    end
+
+    def write_footer(playlist)
+      return if playlist.live? || playlist.master?
       io.puts '#EXT-X-ENDLIST'
     end
 
+    def write_header(playlist)
+      io.puts '#EXTM3U'
+      if playlist.master?
+        write_master_playlist_header(playlist)
+      else
+        write_media_playlist_header(playlist)
+      end
+    end
+
     private
 
     def target_duration_format(playlist)
@@ -37,13 +50,10 @@ module M3u8
       io.puts "#EXT-X-ALLOW-CACHE:#{cache ? 'YES' : 'NO'}"
     end
 
-    def write_header(playlist)
-      io.puts '#EXTM3U'
-      if playlist.master?
-        write_master_playlist_header(playlist)
-      else
-        write_media_playlist_header(playlist)
-      end
+    def write_discontinuity_sequence_tag(sequence)
+      return if sequence.nil?
+
+      io.puts "#EXT-X-DISCONTINUITY-SEQUENCE:#{sequence}"
     end
 
     def write_independent_segments_tag(independent_segments)
@@ -63,6 +73,7 @@ module M3u8
       write_independent_segments_tag(playlist.independent_segments)
       io.puts '#EXT-X-I-FRAMES-ONLY' if playlist.iframes_only
       io.puts "#EXT-X-MEDIA-SEQUENCE:#{playlist.sequence}"
+      write_discontinuity_sequence_tag(playlist.discontinuity_sequence)
       write_cache_tag(playlist.cache)
       io.puts target_duration_format(playlist)
     end

data/spec/fixtures/playlist.m3u8

@@ -2,6 +2,7 @@
 #EXT-X-PLAYLIST-TYPE:VOD
 #EXT-X-VERSION:4
 #EXT-X-MEDIA-SEQUENCE:1
+#EXT-X-DISCONTINUITY-SEQUENCE:8
 #EXT-X-ALLOW-CACHE:NO
 #EXT-X-TARGETDURATION:12
 #EXTINF:11.344644,

data/spec/fixtures/session_data.m3u8

@@ -1,3 +1,4 @@
+#EXTM3U
 #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"

data/spec/lib/m3u8/discontinuity_item_spec.rb

@@ -4,8 +4,6 @@ require 'spec_helper'
 describe M3u8::DiscontinuityItem do
   it 'should provide m3u8 format representation' do
     item = M3u8::DiscontinuityItem.new
-    output = item.to_s
-    expected = "#EXT-X-DISCONTINUITY\n"
-    expect(output).to eq expected
+    expect(item.to_s).to eq("#EXT-X-DISCONTINUITY\n")
   end
 end

data/spec/lib/m3u8/media_item_spec.rb

@@ -2,42 +2,89 @@
 require 'spec_helper'
 
 describe M3u8::MediaItem do
-  it 'should provide m3u8 format representation' do
-    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)
-    output = item.to_s
-    expected = '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="fre",' \
-               'NAME="Francais",AUTOSELECT=YES,DEFAULT=NO,' \
-               'URI="frelo/prog_index.m3u8"'
-    expect(output).to eq expected
+  describe '.new' do
+    it 'assigns attributes from options' do
+      options = { type: 'AUDIO', group_id: 'audio-lo', language: 'fre',
+                  assoc_language: 'spoken', name: 'Francais', autoselect: true,
+                  default: false, forced: true, uri: 'frelo/prog_index.m3u8',
+                  instream_id: 'SERVICE3', characteristics: 'public.html',
+                  channels: '6' }
+      item = described_class.new(options)
 
-    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)
-    output = item.to_s
-    expected = '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="fre",' \
-               'ASSOC-LANGUAGE="spoken",NAME="Francais",AUTOSELECT=YES,' \
-               'DEFAULT=NO,URI="frelo/prog_index.m3u8",FORCED=YES'
-    expect(output).to eq expected
+      expect(item.type).to eq('AUDIO')
+      expect(item.group_id).to eq('audio-lo')
+      expect(item.language).to eq('fre')
+      expect(item.assoc_language).to eq('spoken')
+      expect(item.name).to eq('Francais')
+      expect(item.autoselect).to be true
+      expect(item.default).to be false
+      expect(item.uri).to eq('frelo/prog_index.m3u8')
+      expect(item.forced).to be true
+      expect(item.instream_id).to eq('SERVICE3')
+      expect(item.characteristics).to eq('public.html')
+      expect(item.channels).to eq('6')
+    end
   end
 
-  it 'should parse m3u8 text into instance' do
-    format = '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="fre",' \
-             'ASSOC-LANGUAGE="spoken",NAME="Francais",AUTOSELECT=YES,' +
-             %("DEFAULT=NO,URI="frelo/prog_index.m3u8",FORCED=YES\n")
-    item = M3u8::MediaItem.parse format
+  describe '.parse' do
+    it 'returns instance from parsed tag' do
+      tag = '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",LANGUAGE="fre",' \
+            'ASSOC-LANGUAGE="spoken",NAME="Francais",AUTOSELECT=YES,' \
+            'INSTREAM-ID="SERVICE3",CHARACTERISTICS="public.html",' \
+            'CHANNELS="6",' +
+            %("DEFAULT=NO,URI="frelo/prog_index.m3u8",FORCED=YES\n")
+      item = described_class.parse(tag)
 
-    expect(item.type).to eq 'AUDIO'
-    expect(item.group_id).to eq 'audio-lo'
-    expect(item.language).to eq 'fre'
-    expect(item.assoc_language).to eq 'spoken'
-    expect(item.name).to eq 'Francais'
-    expect(item.autoselect).to be true
-    expect(item.default).to be false
-    expect(item.uri).to eq 'frelo/prog_index.m3u8'
-    expect(item.forced).to be true
+      expect(item.type).to eq('AUDIO')
+      expect(item.group_id).to eq('audio-lo')
+      expect(item.language).to eq('fre')
+      expect(item.assoc_language).to eq('spoken')
+      expect(item.name).to eq('Francais')
+      expect(item.autoselect).to be true
+      expect(item.default).to be false
+      expect(item.uri).to eq('frelo/prog_index.m3u8')
+      expect(item.forced).to be true
+      expect(item.instream_id).to eq('SERVICE3')
+      expect(item.characteristics).to eq('public.html')
+      expect(item.channels).to eq('6')
+    end
+  end
+
+  describe '#to_s' do
+    context 'when no attributes are assigned' do
+      it 'returns default tag text' do
+        item = described_class.new
+        expected = '#EXT-X-MEDIA:TYPE=,GROUP-ID="",NAME=""'
+        expect(item.to_s).to eq(expected)
+      end
+    end
+
+    context 'when only required attributes are assigned' do
+      it 'returns tag text' do
+        options = { type: 'AUDIO', group_id: 'audio-lo', name: 'Francais' }
+        item = described_class.new(options)
+        expected = '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",NAME="Francais"'
+        expect(item.to_s).to eq(expected)
+      end
+    end
+
+    context 'when all attributes are assigned' do
+      it 'returns tag text' do
+        options = { type: 'AUDIO', group_id: 'audio-lo', language: 'fre',
+                    assoc_language: 'spoken', name: 'Francais',
+                    autoselect: true, default: false, forced: true,
+                    uri: 'frelo/prog_index.m3u8', instream_id: 'SERVICE3',
+                    characteristics: 'public.html', channels: '6' }
+        item = M3u8::MediaItem.new(options)
+        output = item.to_s
+        expected = '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio-lo",' \
+                   'LANGUAGE="fre",ASSOC-LANGUAGE="spoken",' \
+                   'NAME="Francais",AUTOSELECT=YES,' \
+                   'DEFAULT=NO,URI="frelo/prog_index.m3u8",FORCED=YES,' \
+                   'INSTREAM-ID="SERVICE3",CHARACTERISTICS="public.html",' \
+                   'CHANNELS="6"'
+        expect(output).to eq(expected)
+      end
+    end
   end
 end

data/spec/lib/m3u8/playlist_item_spec.rb

@@ -2,27 +2,58 @@
 require 'spec_helper'
 
 describe M3u8::PlaylistItem do
-  it 'should initialize with hash' do
-    hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             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.bandwidth).to eq 540
-    expect(item.uri).to eq 'test.url'
-    expect(item.iframe).to be false
+  describe '.new' do
+    it 'assigns attributes from options' do
+      options = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
+                  bandwidth: 540, audio_codec: 'mp3', level: '2',
+                  profile: 'baseline', video: 'test_video', audio: 'test_a',
+                  uri: 'test.url', average_bandwidth: 500, subtitles: 'subs',
+                  closed_captions: 'cc', iframe: true, frame_rate: 24.6,
+                  name: 'test_name', hdcp_level: 'TYPE-0' }
+      item = described_class.new(options)
+
+      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.bandwidth).to eq(540)
+      expect(item.audio_codec).to eq('mp3')
+      expect(item.level).to eq('2')
+      expect(item.profile).to eq('baseline')
+      expect(item.video).to eq('test_video')
+      expect(item.audio).to eq('test_a')
+      expect(item.uri).to eq('test.url')
+      expect(item.average_bandwidth).to eq(500)
+      expect(item.subtitles).to eq('subs')
+      expect(item.closed_captions).to eq('cc')
+      expect(item.iframe).to be true
+      expect(item.frame_rate).to eq(24.6)
+      expect(item.name).to eq('test_name')
+      expect(item.hdcp_level).to eq('TYPE-0')
+    end
+  end
+
+  describe '.parse' do
+    it 'returns new instance from parsed tag' do
+      tag = %(#EXT-X-STREAM-INF:CODECS="avc",BANDWIDTH=540,) +
+            %(PROGRAM-ID=1,RESOLUTION=1920x1080,FRAME-RATE=23.976,) +
+            %(AVERAGE-BANDWIDTH=550,AUDIO="test",VIDEO="test2",) +
+            %(SUBTITLES="subs",CLOSED-CAPTIONS="caps",URI="test.url",) +
+            %(NAME="1080p",HDCP-LEVEL=TYPE-0)
+      expect_any_instance_of(described_class).to receive(:parse).with(tag)
+      item = described_class.parse(tag)
+      expect(item).to be_a(described_class)
+    end
   end
 
-  describe 'parse' do
-    it 'should parse m3u8 text into instance' do
+  describe '#parse' do
+    it 'assigns values from parsed tag' do
       input = %(#EXT-X-STREAM-INF:CODECS="avc",BANDWIDTH=540,) +
               %(PROGRAM-ID=1,RESOLUTION=1920x1080,FRAME-RATE=23.976,) +
               %(AVERAGE-BANDWIDTH=550,AUDIO="test",VIDEO="test2",) +
               %(SUBTITLES="subs",CLOSED-CAPTIONS="caps",URI="test.url",) +
-              %(NAME="1080p")
+              %(NAME="1080p",HDCP-LEVEL=TYPE-0)
       item = M3u8::PlaylistItem.parse(input)
       expect(item.program_id).to eq '1'
       expect(item.codecs).to eq 'avc'
@@ -37,70 +68,72 @@ describe M3u8::PlaylistItem do
       expect(item.closed_captions).to eq 'caps'
       expect(item.uri).to eq 'test.url'
       expect(item.name).to eq '1080p'
+      expect(item.iframe).to be false
+      expect(item.hdcp_level).to eq('TYPE-0')
     end
+  end
 
-    it 'should parse m3u8 into current instance' do
-      input = %(#EXT-X-STREAM-INF:CODECS="avc",BANDWIDTH=540,) +
-              %(PROGRAM-ID=1,AUDIO="test",VIDEO="test2",) +
-              %(SUBTITLES="subs",CLOSED-CAPTIONS="caps",URI="test.url",) +
-              %(NAME="SD")
-      item = M3u8::PlaylistItem.new
-      item.parse(input)
-      expect(item.program_id).to eq '1'
-      expect(item.codecs).to eq 'avc'
-      expect(item.bandwidth).to eq 540
-      expect(item.average_bandwidth).to be_nil
-      expect(item.width).to be_nil
-      expect(item.height).to be_nil
-      expect(item.audio).to eq 'test'
-      expect(item.video).to eq 'test2'
-      expect(item.subtitles).to eq 'subs'
-      expect(item.closed_captions).to eq 'caps'
-      expect(item.uri).to eq 'test.url'
-      expect(item.name).to eq 'SD'
+  describe '#to_s' do
+    context 'when codecs is missing' do
+      it 'raises error' do
+        params = { 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)
+      end
     end
-  end
 
-  it 'should provide m3u8 format representation' do
-    hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bandwidth: 540, uri: 'test.url', closed_captions: 'NONE' }
-    item = M3u8::PlaylistItem.new(hash)
-    output = item.to_s
-    expected = '#EXT-X-STREAM-INF:PROGRAM-ID=1,RESOLUTION=1920x1080,' +
-               %(CODECS="avc",BANDWIDTH=540,CLOSED-CAPTIONS=NONE\ntest.url)
-    expect(output).to eq expected
-
-    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', bandwidth: 540, uri: 'test.url', audio: 'test',
-             video: 'test2', average_bandwidth: 500, subtitles: 'subs',
-             frame_rate: 30, closed_captions: 'caps', name: 'SD' }
-    item = M3u8::PlaylistItem.new(hash)
-    output = item.to_s
-    expected = %(#EXT-X-STREAM-INF:CODECS="avc",BANDWIDTH=540,) +
-               %(AVERAGE-BANDWIDTH=500,FRAME-RATE=30.000,) +
-               %(AUDIO="test",VIDEO="test2",SUBTITLES="subs",) +
-               %(CLOSED-CAPTIONS="caps",NAME="SD"\ntest.url)
-    expect(output).to eq expected
-  end
+    context 'when only required attributes are present' do
+      it 'returns tag' do
+        options = { codecs: 'avc', bandwidth: 540,
+                    uri: 'test.url' }
+        item = described_class.new(options)
+        expected = %(#EXT-X-STREAM-INF:CODECS="avc",BANDWIDTH=540) +
+                   "\ntest.url"
+        expect(item.to_s).to eq(expected)
+      end
+    end
+
+    context 'when all attributes are present' do
+      it 'returns tag' do
+        options = { codecs: 'avc', bandwidth: 540, uri: 'test.url',
+                    audio: 'test', video: 'test2', average_bandwidth: 500,
+                    subtitles: 'subs', frame_rate: 30, closed_captions: 'caps',
+                    name: 'SD', hdcp_level: 'TYPE-0', program_id: '1' }
+        item = described_class.new(options)
+        expected = %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="avc",BANDWIDTH=540,) +
+                   %(AVERAGE-BANDWIDTH=500,FRAME-RATE=30.000,) +
+                   'HDCP-LEVEL=TYPE-0,' +
+                   %(AUDIO="test",VIDEO="test2",SUBTITLES="subs",) +
+                   %(CLOSED-CAPTIONS="caps",NAME="SD"\ntest.url)
+        expect(item.to_s).to eq(expected)
+      end
+    end
+
+    context 'when closed captions is NONE' do
+      it 'returns tag' do
+        options = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
+                    bandwidth: 540, uri: 'test.url', closed_captions: 'NONE' }
+        item = described_class.new(options)
+        expected = '#EXT-X-STREAM-INF:PROGRAM-ID=1,RESOLUTION=1920x1080,' +
+                   %(CODECS="avc",BANDWIDTH=540,CLOSED-CAPTIONS=NONE\ntest.url)
+        expect(item.to_s).to eq(expected)
+      end
+    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
+    context 'when iframe is enabled' do
+      it 'returns EXT-X-I-FRAME-STREAM-INF tag' do
+        options = { codecs: 'avc', bandwidth: 540, uri: 'test.url',
+                    iframe: true, video: 'test2', average_bandwidth: 550 }
+        item = described_class.new(options)
+        expected = %(#EXT-X-I-FRAME-STREAM-INF:CODECS="avc",BANDWIDTH=540,) +
+                   %(AVERAGE-BANDWIDTH=550,VIDEO="test2",URI="test.url")
+        expect(item.to_s).to eq(expected)
+      end
+    end
   end
 
-  it 'should generate codecs string' do
+  it 'generates codecs string' do
     item = M3u8::PlaylistItem.new
     expect(item.codecs).to be_nil
 
@@ -180,11 +213,4 @@ describe M3u8::PlaylistItem do
     item = M3u8::PlaylistItem.new options
     expect(item.codecs).to eq 'avc1.640029'
   end
-
-  it 'should raise error if codecs are missing' do
-    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)
-  end
 end