m3u8 0.8.2 → 1.8.1

data/spec/lib/m3u8/reader_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe M3u8::Reader do
@@ -6,9 +7,10 @@ describe M3u8::Reader do
 
   describe '#read' do
     it 'parses master playlist' do
-      file = File.open('spec/fixtures/master.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/master.m3u8')
+      )
       expect(playlist.master?).to be true
       expect(playlist.discontinuity_sequence).to be_nil
       expect(playlist.independent_segments).to be true
@@ -53,9 +55,10 @@ describe M3u8::Reader do
     end
 
     it 'parses master playlist with I-Frames' do
-      file = File.open('spec/fixtures/master_iframes.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/master_iframes.m3u8')
+      )
       expect(playlist.master?).to be true
 
       expect(playlist.items.size).to eq(7)
@@ -68,9 +71,10 @@ describe M3u8::Reader do
     end
 
     it 'parses media playlist' do
-      file = File.open('spec/fixtures/playlist.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/playlist.m3u8')
+      )
       expect(playlist.master?).to be false
       expect(playlist.version).to eq(4)
       expect(playlist.sequence).to eq(1)
@@ -78,6 +82,7 @@ describe M3u8::Reader do
       expect(playlist.cache).to be false
       expect(playlist.target).to eq(12)
       expect(playlist.type).to eq('VOD')
+      expect(playlist.live?).to be false
 
       item = playlist.items[0]
       expect(item).to be_a(M3u8::SegmentItem)
@@ -92,9 +97,10 @@ describe M3u8::Reader do
     end
 
     it 'parses I-Frame playlist' do
-      file = File.open('spec/fixtures/iframes.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/iframes.m3u8')
+      )
 
       expect(playlist.iframes_only).to be true
       expect(playlist.items.size).to eq(3)
@@ -112,9 +118,10 @@ describe M3u8::Reader do
     end
 
     it 'parses segment playlist with comments' do
-      file = File.open('spec/fixtures/playlist_with_comments.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/playlist_with_comments.m3u8')
+      )
       expect(playlist.master?).to be false
       expect(playlist.version).to eq(4)
       expect(playlist.sequence).to eq(1)
@@ -134,9 +141,10 @@ describe M3u8::Reader do
     end
 
     it 'parses variant playlist with audio options and groups' do
-      file = File.open('spec/fixtures/variant_audio.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/variant_audio.m3u8')
+      )
 
       expect(playlist.master?).to be true
       expect(playlist.items.size).to eq(10)
@@ -155,9 +163,10 @@ describe M3u8::Reader do
     end
 
     it 'parses variant playlist with camera angles' do
-      file = File.open('spec/fixtures/variant_angles.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/variant_angles.m3u8')
+      )
 
       expect(playlist.master?).to be true
       expect(playlist.items.size).to eq(11)
@@ -181,22 +190,22 @@ describe M3u8::Reader do
     end
 
     it 'processes multiple reads as separate playlists' do
-      file = File.open('spec/fixtures/master.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      content = File.read('spec/fixtures/master.m3u8')
+      playlist = reader.read(content)
 
       expect(playlist.items.size).to eq(8)
 
-      file = File.open('spec/fixtures/master.m3u8')
-      playlist = reader.read(file)
+      playlist = reader.read(content)
 
       expect(playlist.items.size).to eq(8)
     end
 
     it 'parses playlist with session data' do
-      file = File.open('spec/fixtures/session_data.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/session_data.m3u8')
+      )
 
       expect(playlist.items.size).to eq(3)
 
@@ -207,9 +216,10 @@ describe M3u8::Reader do
     end
 
     it 'parses encrypted playlist' do
-      file = File.open('spec/fixtures/encrypted.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/encrypted.m3u8')
+      )
 
       expect(playlist.items.size).to eq(6)
 
@@ -220,9 +230,10 @@ describe M3u8::Reader do
     end
 
     it 'parses map (media intialization section) playlists' do
-      file = File.open('spec/fixtures/map_playlist.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/map_playlist.m3u8')
+      )
 
       expect(playlist.items.size).to eq(1)
 
@@ -234,9 +245,10 @@ describe M3u8::Reader do
     end
 
     it 'reads segment with timestamp' do
-      file = File.open('spec/fixtures/timestamp_playlist.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/timestamp_playlist.m3u8')
+      )
       expect(playlist.items.count).to eq(6)
 
       item_date_time = playlist.items.first.program_date_time
@@ -245,9 +257,10 @@ describe M3u8::Reader do
     end
 
     it 'parses playlist with daterange' do
-      file = File.open('spec/fixtures/date_range_scte35.m3u8')
       reader = M3u8::Reader.new
-      playlist = reader.read(file)
+      playlist = reader.read(
+        File.read('spec/fixtures/date_range_scte35.m3u8')
+      )
       expect(playlist.items.count).to eq(5)
 
       item = playlist.items[0]
@@ -257,10 +270,344 @@ describe M3u8::Reader do
       expect(item).to be_a(M3u8::DateRangeItem)
     end
 
+    it 'parses master playlist with v13 attributes' do
+      reader = M3u8::Reader.new
+      playlist = reader.read(
+        File.read('spec/fixtures/master_v13.m3u8')
+      )
+      expect(playlist.master?).to be true
+      expect(playlist.version).to eq(13)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::MediaItem)
+      expect(item.stable_rendition_id).to eq('audio-en')
+      expect(item.bit_depth).to eq(16)
+      expect(item.sample_rate).to eq(44_100)
+
+      item = playlist.items[1]
+      expect(item).to be_a(M3u8::PlaylistItem)
+      expect(item.stable_variant_id).to eq('hd-1080')
+      expect(item.video_range).to eq('SDR')
+      expect(item.pathway_id).to eq('CDN-A')
+      expect(item.score).to eq(12.5)
+      expect(item.supplemental_codecs).to eq('dvh1.05.06/db4g')
+      expect(item.allowed_cpc).to eq('com.example.drm:SMART-TV/PC')
+      expect(item.req_video_layout).to eq('CH-MONO')
+
+      item = playlist.items[2]
+      expect(item).to be_a(M3u8::PlaylistItem)
+      expect(item.stable_variant_id).to eq('hd-720')
+    end
+
+    it 'parses playlist with content steering and defines' do
+      reader = M3u8::Reader.new
+      playlist = reader.read(
+        File.read('spec/fixtures/content_steering.m3u8')
+      )
+      expect(playlist.master?).to be true
+      expect(playlist.items.size).to eq(5)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::DefineItem)
+      expect(item.name).to eq('base_url')
+      expect(item.value).to eq('https://example.com')
+
+      item = playlist.items[1]
+      expect(item).to be_a(M3u8::DefineItem)
+      expect(item.import).to eq('token')
+
+      item = playlist.items[2]
+      expect(item).to be_a(M3u8::ContentSteeringItem)
+      expect(item.server_uri).to eq('https://example.com/steering')
+      expect(item.pathway_id).to eq('CDN-A')
+    end
+
+    it 'parses LL-HLS playlist' do
+      reader = M3u8::Reader.new
+      playlist = reader.read(
+        File.read('spec/fixtures/ll_hls_playlist.m3u8')
+      )
+      expect(playlist.master?).to be false
+      expect(playlist.live?).to be true
+      expect(playlist.version).to eq(9)
+
+      expect(playlist.server_control).to be_a(M3u8::ServerControlItem)
+      expect(playlist.server_control.can_skip_until).to eq(24.0)
+      expect(playlist.server_control.can_block_reload).to be true
+      expect(playlist.server_control.part_hold_back).to eq(1.0)
+
+      expect(playlist.part_inf).to be_a(M3u8::PartInfItem)
+      expect(playlist.part_inf.part_target).to eq(0.5)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::SkipItem)
+      expect(item.skipped_segments).to eq(5)
+
+      item = playlist.items[1]
+      expect(item).to be_a(M3u8::MapItem)
+
+      item = playlist.items[3]
+      expect(item).to be_a(M3u8::PartItem)
+      expect(item.duration).to eq(0.5)
+      expect(item.uri).to eq('segment101.0.mp4')
+      expect(item.independent).to be true
+
+      item = playlist.items[4]
+      expect(item).to be_a(M3u8::PartItem)
+      expect(item.independent).to be false
+
+      item = playlist.items[8]
+      expect(item).to be_a(M3u8::PartItem)
+      expect(item.uri).to eq('segment102.0.mp4')
+
+      item = playlist.items[9]
+      expect(item).to be_a(M3u8::PreloadHintItem)
+      expect(item.type).to eq('PART')
+      expect(item.uri).to eq('segment102.1.mp4')
+
+      item = playlist.items[10]
+      expect(item).to be_a(M3u8::RenditionReportItem)
+      expect(item.uri).to eq('../720p/stream.m3u8')
+      expect(item.last_msn).to eq(101)
+      expect(item.last_part).to eq(3)
+
+      expect(playlist.items.size).to eq(12)
+    end
+
+    it 'parses playlist with gap and bitrate tags' do
+      reader = M3u8::Reader.new
+      playlist = reader.read(
+        File.read('spec/fixtures/gap_playlist.m3u8')
+      )
+      expect(playlist.master?).to be false
+      expect(playlist.items.size).to eq(6)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::BitrateItem)
+      expect(item.bitrate).to eq(128)
+
+      item = playlist.items[2]
+      expect(item).to be_a(M3u8::GapItem)
+
+      item = playlist.items[3]
+      expect(item).to be_a(M3u8::SegmentItem)
+
+      item = playlist.items[4]
+      expect(item).to be_a(M3u8::BitrateItem)
+      expect(item.bitrate).to eq(256)
+    end
+
+    it 'parses event playlist with byterange and map change' do
+      playlist = reader.read(
+        File.read('spec/fixtures/event_playlist.m3u8')
+      )
+      expect(playlist.master?).to be false
+      expect(playlist.live?).to be false
+      expect(playlist.type).to eq('EVENT')
+      expect(playlist.version).to eq(7)
+      expect(playlist.independent_segments).to be true
+      expect(playlist.items.size).to eq(6)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::MapItem)
+      expect(item.uri).to eq('init.mp4')
+      expect(item.byterange).to be_nil
+
+      item = playlist.items[1]
+      expect(item).to be_a(M3u8::SegmentItem)
+      expect(item.duration).to eq(6.0)
+      expect(item.byterange.length).to eq(75_232)
+      expect(item.byterange.start).to eq(0)
+
+      item = playlist.items[2]
+      expect(item).to be_a(M3u8::SegmentItem)
+      expect(item.byterange.length).to eq(82_112)
+      expect(item.byterange.start).to eq(75_232)
+
+      item = playlist.items[3]
+      expect(item).to be_a(M3u8::DiscontinuityItem)
+
+      item = playlist.items[4]
+      expect(item).to be_a(M3u8::MapItem)
+      expect(item.uri).to eq('init2.mp4')
+    end
+
+    it 'parses daterange playlist' do
+      playlist = reader.read(
+        File.read('spec/fixtures/daterange_playlist.m3u8')
+      )
+      expect(playlist.master?).to be false
+      expect(playlist.items.size).to eq(6)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::DateRangeItem)
+      expect(item.id).to eq('ad-1')
+      expect(item.class_name).to eq('com.example.ad')
+      expect(item.start_date).to eq('2024-01-01T00:00:00Z')
+      expect(item.end_date).to eq('2024-01-01T00:00:30Z')
+      expect(item.duration).to eq(30.0)
+      expect(item.client_attributes['X-AD-ID']).to eq('ad-123')
+      expect(item.client_attributes['X-AD-URL'])
+        .to eq('https://example.com/ad')
+
+      item = playlist.items[2]
+      expect(item).to be_a(M3u8::DateRangeItem)
+      expect(item.id).to eq('ad-2')
+      expect(item.planned_duration).to eq(15.0)
+
+      item = playlist.items[4]
+      expect(item).to be_a(M3u8::DateRangeItem)
+      expect(item.id).to eq('ch-1')
+      expect(item.end_on_next).to be true
+    end
+
+    it 'parses full master playlist' do
+      playlist = reader.read(
+        File.read('spec/fixtures/master_full.m3u8')
+      )
+      expect(playlist.master?).to be true
+      expect(playlist.version).to eq(13)
+      expect(playlist.independent_segments).to be true
+      expect(playlist.items.size).to eq(9)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::DefineItem)
+      expect(item.queryparam).to eq('token')
+
+      item = playlist.items[1]
+      expect(item).to be_a(M3u8::PlaybackStart)
+      expect(item.time_offset).to eq(10.5)
+      expect(item.precise).to be true
+
+      item = playlist.items[2]
+      expect(item).to be_a(M3u8::SessionKeyItem)
+      expect(item.method).to eq('SAMPLE-AES')
+      expect(item.key_format)
+        .to eq('com.apple.streamingkeydelivery')
+
+      item = playlist.items[3]
+      expect(item).to be_a(M3u8::SessionDataItem)
+      expect(item.data_id).to eq('com.example.title')
+      expect(item.language).to eq('en')
+
+      item = playlist.items[4]
+      expect(item).to be_a(M3u8::ContentSteeringItem)
+      expect(item.server_uri)
+        .to eq('https://example.com/steering')
+
+      item = playlist.items[5]
+      expect(item).to be_a(M3u8::MediaItem)
+      expect(item.type).to eq('AUDIO')
+      expect(item.language).to eq('en')
+
+      item = playlist.items[7]
+      expect(item).to be_a(M3u8::PlaylistItem)
+      expect(item.bandwidth).to eq(5_000_000)
+      expect(item.average_bandwidth).to eq(4_500_000)
+    end
+
+    it 'parses encrypted playlist with discontinuities' do
+      playlist = reader.read(
+        File.read('spec/fixtures/encrypted_discontinuity.m3u8')
+      )
+      expect(playlist.master?).to be false
+      expect(playlist.live?).to be false
+      expect(playlist.items.size).to eq(8)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::KeyItem)
+      expect(item.method).to eq('AES-128')
+      expect(item.uri).to eq('https://example.com/key1.bin')
+      expect(item.iv)
+        .to eq('0x00000000000000000000000000000001')
+
+      item = playlist.items[3]
+      expect(item).to be_a(M3u8::DiscontinuityItem)
+
+      item = playlist.items[4]
+      expect(item).to be_a(M3u8::KeyItem)
+      expect(item.uri).to eq('https://example.com/key2.bin')
+
+      item = playlist.items[6]
+      expect(item).to be_a(M3u8::KeyItem)
+      expect(item.method).to eq('NONE')
+    end
+
+    it 'parses advanced LL-HLS playlist' do
+      playlist = reader.read(
+        File.read('spec/fixtures/ll_hls_advanced.m3u8')
+      )
+      expect(playlist.master?).to be false
+      expect(playlist.live?).to be true
+      expect(playlist.version).to eq(9)
+
+      sc = playlist.server_control
+      expect(sc.can_skip_until).to eq(24.0)
+      expect(sc.can_skip_dateranges).to be true
+      expect(sc.hold_back).to eq(12.0)
+      expect(sc.part_hold_back).to eq(1.0)
+
+      skip = playlist.items[0]
+      expect(skip).to be_a(M3u8::SkipItem)
+      expect(skip.skipped_segments).to eq(10)
+      expect(skip.recently_removed_dateranges).to eq('dr-1')
+
+      item = playlist.items[4]
+      expect(item).to be_a(M3u8::PartItem)
+      expect(item.independent).to be true
+
+      item = playlist.items[5]
+      expect(item).to be_a(M3u8::PartItem)
+      expect(item.byterange.length).to eq(1024)
+      expect(item.byterange.start).to eq(0)
+      expect(item.gap).to be true
+
+      hint = playlist.items[8]
+      expect(hint).to be_a(M3u8::PreloadHintItem)
+      expect(hint.type).to eq('MAP')
+      expect(hint.uri).to eq('init2.mp4')
+
+      report = playlist.items[9]
+      expect(report).to be_a(M3u8::RenditionReportItem)
+      expect(report.last_msn).to eq(101)
+    end
+
+    it 'parses playlist with \\r line endings' do
+      text = "#EXTM3U\r" \
+             "#EXT-X-VERSION:4\r" \
+             "#EXT-X-TARGETDURATION:10\r" \
+             "#EXT-X-MEDIA-SEQUENCE:0\r" \
+             "#EXTINF:10.0,\r" \
+             "segment0.ts\r" \
+             "#EXT-X-ENDLIST\r"
+      playlist = reader.read(text)
+      expect(playlist.master?).to be false
+      expect(playlist.version).to eq(4)
+      expect(playlist.items.size).to eq(1)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::SegmentItem)
+      expect(item.segment).to eq('segment0.ts')
+    end
+
+    it 'returns a frozen master playlist' do
+      playlist = reader.read(
+        File.read('spec/fixtures/master.m3u8')
+      )
+      expect(playlist).to be_frozen
+    end
+
+    it 'returns a frozen media playlist' do
+      playlist = reader.read(
+        File.read('spec/fixtures/playlist.m3u8')
+      )
+      expect(playlist).to be_frozen
+    end
+
     context 'when playlist source is invalid' do
       it 'raises error with message' do
         message = 'Playlist must start with a #EXTM3U tag, line read ' \
-          'contained the value: /path/to/file'
+                  'contained the value: /path/to/file'
         expect { reader.read('/path/to/file') }
           .to raise_error(M3u8::InvalidPlaylistError, message)
       end

data/spec/lib/m3u8/rendition_report_item_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe M3u8::RenditionReportItem do
+  describe '.new' do
+    it 'assigns attributes from options' do
+      options = { uri: '../720p/stream.m3u8', last_msn: 100,
+                  last_part: 3 }
+      item = described_class.new(options)
+      expect(item.uri).to eq('../720p/stream.m3u8')
+      expect(item.last_msn).to eq(100)
+      expect(item.last_part).to eq(3)
+    end
+  end
+
+  describe '.parse' do
+    it 'parses tag with all attributes' do
+      tag = '#EXT-X-RENDITION-REPORT:URI="../720p/stream.m3u8",' \
+            'LAST-MSN=100,LAST-PART=3'
+      item = described_class.parse(tag)
+      expect(item.uri).to eq('../720p/stream.m3u8')
+      expect(item.last_msn).to eq(100)
+      expect(item.last_part).to eq(3)
+    end
+
+    it 'parses tag without optional attributes' do
+      tag = '#EXT-X-RENDITION-REPORT:URI="../720p/stream.m3u8",' \
+            'LAST-MSN=100'
+      item = described_class.parse(tag)
+      expect(item.uri).to eq('../720p/stream.m3u8')
+      expect(item.last_msn).to eq(100)
+      expect(item.last_part).to be_nil
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns tag with all attributes' do
+      options = { uri: '../720p/stream.m3u8', last_msn: 100,
+                  last_part: 3 }
+      item = described_class.new(options)
+      expected = '#EXT-X-RENDITION-REPORT:' \
+                 'URI="../720p/stream.m3u8",' \
+                 'LAST-MSN=100,LAST-PART=3'
+      expect(item.to_s).to eq(expected)
+    end
+
+    it 'returns tag without optional attributes' do
+      options = { uri: '../720p/stream.m3u8', last_msn: 100 }
+      item = described_class.new(options)
+      expected = '#EXT-X-RENDITION-REPORT:' \
+                 'URI="../720p/stream.m3u8",LAST-MSN=100'
+      expect(item.to_s).to eq(expected)
+    end
+  end
+end