m3u8 0.8.2 → 1.8.1

data/spec/lib/m3u8/playlist_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 describe M3u8::Playlist do
@@ -43,12 +44,25 @@ describe M3u8::Playlist do
       codecs = described_class.codecs(options)
       expect(codecs).to eq('avc1.66.30,mp4a.40.2')
     end
+
+    it 'generates HEVC codecs string' do
+      options = { profile: 'hevc-main', level: 4.0, audio_codec: 'ac-3' }
+      codecs = described_class.codecs(options)
+      expect(codecs).to eq('hvc1.1.6.L120.B0,ac-3')
+    end
+
+    it 'generates AV1 codecs string' do
+      options = { profile: 'av1-main', level: 5.0, audio_codec: 'opus' }
+      codecs = described_class.codecs(options)
+      expect(codecs).to eq('av01.0.12M.08,Opus')
+    end
   end
 
   describe '.read' do
     it 'returns new playlist from content' do
-      file = File.open('spec/fixtures/master.m3u8')
-      playlist = described_class.read(file)
+      playlist = described_class.read(
+        File.read('spec/fixtures/master.m3u8')
+      )
       expect(playlist.master?).to be true
       expect(playlist.items.size).to eq(8)
     end
@@ -168,6 +182,7 @@ describe M3u8::Playlist do
     end
 
     it 'returns media playlist text' do
+      playlist = described_class.new(target: 12)
       options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
       item =  M3u8::SegmentItem.new(options)
       playlist.items << item
@@ -177,13 +192,13 @@ describe M3u8::Playlist do
       playlist.items << item
 
       expected = "#EXTM3U\n" \
-        "#EXT-X-MEDIA-SEQUENCE:0\n" \
-        "#EXT-X-TARGETDURATION:10\n" \
-        "#EXTINF:11.344644,\n" \
-        "1080-7mbps00000.ts\n" \
-        "#EXTINF:11.261233,\n" \
-        "1080-7mbps00001.ts\n" \
-        "#EXT-X-ENDLIST\n"
+                 "#EXT-X-MEDIA-SEQUENCE:0\n" \
+                 "#EXT-X-TARGETDURATION:12\n" \
+                 "#EXTINF:11.344644,\n" \
+                 "1080-7mbps00000.ts\n" \
+                 "#EXTINF:11.261233,\n" \
+                 "1080-7mbps00001.ts\n" \
+                 "#EXT-X-ENDLIST\n"
       expect(playlist.to_s).to eq(expected)
     end
   end
@@ -223,6 +238,524 @@ describe M3u8::Playlist do
     end
   end
 
+  describe '#errors' do
+    context 'when playlist is empty' do
+      it 'returns no errors' do
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when playlist has only master items' do
+      it 'returns no errors' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when playlist has only media items' do
+      it 'returns no errors' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.0, segment: 'test.ts'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when segment duration exceeds target duration' do
+      it 'returns target duration error' do
+        playlist = described_class.new(target: 10)
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 12.1, segment: 'test.ts'
+        )
+        expect(playlist.errors).to include(
+          'Target duration 10 is less than segment duration of 12'
+        )
+      end
+    end
+
+    context 'when segment duration rounds to target' do
+      it 'returns no errors' do
+        playlist = described_class.new(target: 11)
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.5, segment: 'test.ts'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when playlist is master' do
+      it 'skips target duration check' do
+        playlist = described_class.new(master: true)
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when segment has no URI' do
+      it 'returns missing segment error' do
+        playlist.items << M3u8::SegmentItem.new(duration: 10.0)
+        expect(playlist.errors).to include(
+          'Segment item requires a segment URI'
+        )
+      end
+    end
+
+    context 'when segment has negative duration' do
+      it 'returns negative duration error' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: -1.0, segment: 'test.ts'
+        )
+        expect(playlist.errors).to include(
+          'Segment item has negative duration'
+        )
+      end
+    end
+
+    context 'when segment has zero duration' do
+      it 'returns no errors' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 0.0, segment: 'test.ts'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when multiple segments are invalid' do
+      it 'accumulates errors' do
+        playlist.items << M3u8::SegmentItem.new(duration: 10.0)
+        playlist.items << M3u8::SegmentItem.new(
+          duration: -1.0, segment: 'test.ts'
+        )
+        errors = playlist.errors
+        expect(errors).to include(
+          'Segment item requires a segment URI'
+        )
+        expect(errors).to include(
+          'Segment item has negative duration'
+        )
+      end
+    end
+
+    context 'when playlist item has no bandwidth' do
+      it 'returns missing bandwidth error' do
+        playlist.items << M3u8::PlaylistItem.new(uri: 'test.url')
+        expect(playlist.errors).to include(
+          'Playlist item requires a bandwidth'
+        )
+      end
+    end
+
+    context 'when playlist item has no URI and is not iframe' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::PlaylistItem.new(bandwidth: 540)
+        expect(playlist.errors).to include(
+          'Playlist item requires a URI'
+        )
+      end
+    end
+
+    context 'when playlist item has zero bandwidth' do
+      it 'returns missing bandwidth error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 0, uri: 'test.url'
+        )
+        expect(playlist.errors).to include(
+          'Playlist item requires a bandwidth'
+        )
+      end
+    end
+
+    context 'when iframe playlist item has no URI' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, iframe: true
+        )
+        expect(playlist.errors).to include(
+          'Playlist item requires a URI'
+        )
+      end
+    end
+
+    context 'when media item is missing type' do
+      it 'returns missing type error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::MediaItem.new(
+          group_id: 'audio', name: 'English'
+        )
+        expect(playlist.errors).to include(
+          'Media item requires a type'
+        )
+      end
+    end
+
+    context 'when media item is missing group_id' do
+      it 'returns missing group_id error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::MediaItem.new(
+          type: 'AUDIO', name: 'English'
+        )
+        expect(playlist.errors).to include(
+          'Media item requires a group ID'
+        )
+      end
+    end
+
+    context 'when media item is missing name' do
+      it 'returns missing name error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::MediaItem.new(
+          type: 'AUDIO', group_id: 'audio'
+        )
+        expect(playlist.errors).to include(
+          'Media item requires a name'
+        )
+      end
+    end
+
+    context 'when key item has method but no URI' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.0, segment: 'test.ts'
+        )
+        playlist.items << M3u8::KeyItem.new(method: 'AES-128')
+        expect(playlist.errors).to include(
+          'Key item requires a URI when method is not NONE'
+        )
+      end
+    end
+
+    context 'when key item method is NONE' do
+      it 'returns no errors' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.0, segment: 'test.ts'
+        )
+        playlist.items << M3u8::KeyItem.new(method: 'NONE')
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when session key item has method but no URI' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionKeyItem.new(
+          method: 'AES-128'
+        )
+        expect(playlist.errors).to include(
+          'Session key item requires a URI when method is not NONE'
+        )
+      end
+    end
+
+    context 'when session data item has no data_id' do
+      it 'returns missing data_id error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionDataItem.new(
+          value: 'Test'
+        )
+        expect(playlist.errors).to include(
+          'Session data item requires a data ID'
+        )
+      end
+    end
+
+    context 'when session data item has both value and uri' do
+      it 'returns conflict error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionDataItem.new(
+          data_id: 'com.test', value: 'Test',
+          uri: 'http://test'
+        )
+        expect(playlist.errors).to include(
+          'Session data item cannot have both value and URI'
+        )
+      end
+    end
+
+    context 'when session data item has neither value nor uri' do
+      it 'returns missing value error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionDataItem.new(
+          data_id: 'com.test'
+        )
+        expect(playlist.errors).to include(
+          'Session data item requires a value or URI'
+        )
+      end
+    end
+
+    context 'when session data item has only value' do
+      it 'returns no session data errors' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionDataItem.new(
+          data_id: 'com.test', value: 'Test'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when part item has no URI' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 4.0, segment: 'seg.mp4'
+        )
+        playlist.items << M3u8::PartItem.new(duration: 0.5)
+        expect(playlist.errors).to include(
+          'Part item requires a URI'
+        )
+      end
+    end
+
+    context 'when part item has no duration' do
+      it 'returns missing duration error' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 4.0, segment: 'seg.mp4'
+        )
+        playlist.items << M3u8::PartItem.new(uri: 'seg.0.mp4')
+        expect(playlist.errors).to include(
+          'Part item requires a duration'
+        )
+      end
+    end
+
+    context 'when part item is valid' do
+      it 'returns no part errors' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 4.0, segment: 'seg.mp4'
+        )
+        playlist.items << M3u8::PartItem.new(
+          duration: 0.5, uri: 'seg.0.mp4'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when playlist has mixed items' do
+      it 'returns mixed items error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.0, segment: 'test.ts'
+        )
+        expect(playlist.errors).to include(
+          'Playlist contains both master and media items'
+        )
+      end
+    end
+  end
+
+  describe '#segments' do
+    it 'returns only segment items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/playlist.m3u8')
+      )
+      expect(playlist.segments).to all be_a(M3u8::SegmentItem)
+      expect(playlist.segments.size).to eq(138)
+    end
+  end
+
+  describe '#playlists' do
+    it 'returns only playlist items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/master.m3u8')
+      )
+      expect(playlist.playlists).to all be_a(M3u8::PlaylistItem)
+      expect(playlist.playlists.size).to eq(6)
+    end
+  end
+
+  describe '#media_items' do
+    it 'returns only media items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/variant_audio.m3u8')
+      )
+      expect(playlist.media_items).to all be_a(M3u8::MediaItem)
+      expect(playlist.media_items.size).to eq(6)
+    end
+  end
+
+  describe '#keys' do
+    it 'returns only key items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/encrypted.m3u8')
+      )
+      expect(playlist.keys).to all be_a(M3u8::KeyItem)
+      expect(playlist.keys.size).to eq(2)
+    end
+  end
+
+  describe '#maps' do
+    it 'returns only map items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/map_playlist.m3u8')
+      )
+      expect(playlist.maps).to all be_a(M3u8::MapItem)
+      expect(playlist.maps.size).to eq(1)
+    end
+  end
+
+  describe '#date_ranges' do
+    it 'returns only date range items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/daterange_playlist.m3u8')
+      )
+      expect(playlist.date_ranges)
+        .to all be_a(M3u8::DateRangeItem)
+      expect(playlist.date_ranges.size).to eq(3)
+    end
+  end
+
+  describe '#parts' do
+    it 'returns only part items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/ll_hls_playlist.m3u8')
+      )
+      expect(playlist.parts).to all be_a(M3u8::PartItem)
+      expect(playlist.parts.size).to eq(5)
+    end
+  end
+
+  describe '#session_data' do
+    it 'returns only session data items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/session_data.m3u8')
+      )
+      expect(playlist.session_data)
+        .to all be_a(M3u8::SessionDataItem)
+      expect(playlist.session_data.size).to eq(3)
+    end
+  end
+
+  describe '#session_keys' do
+    it 'returns only session key items' do
+      playlist = described_class.read(
+        File.read('spec/fixtures/master.m3u8')
+      )
+      expect(playlist.session_keys)
+        .to all be_a(M3u8::SessionKeyItem)
+      expect(playlist.session_keys.size).to eq(1)
+    end
+  end
+
+  describe '#freeze' do
+    it 'freezes the playlist' do
+      playlist.freeze
+      expect(playlist).to be_frozen
+    end
+
+    it 'freezes the items array' do
+      playlist.freeze
+      expect(playlist.items).to be_frozen
+    end
+
+    it 'freezes each item' do
+      item = M3u8::SegmentItem.new(duration: 10.0, segment: 'test.ts')
+      playlist.items << item
+      playlist.freeze
+      expect(item).to be_frozen
+    end
+
+    it 'freezes nested byterange on items' do
+      item = M3u8::SegmentItem.new(
+        duration: 10.0, segment: 'test.ts',
+        byterange: { length: 4500, start: 600 }
+      )
+      playlist.items << item
+      playlist.freeze
+      expect(item.byterange).to be_frozen
+    end
+
+    it 'freezes nested program_date_time on items' do
+      time = M3u8::TimeItem.new(time: '2024-06-01T12:00:00Z')
+      item = M3u8::SegmentItem.new(
+        duration: 10.0, segment: 'test.ts',
+        program_date_time: time
+      )
+      playlist.items << item
+      playlist.freeze
+      expect(item.program_date_time).to be_frozen
+    end
+
+    it 'freezes nested client_attributes on items' do
+      item = M3u8::DateRangeItem.new(
+        id: 'ad-1', start_date: '2024-01-01T00:00:00Z',
+        client_attributes: { 'X-AD-ID' => '"foo"' }
+      )
+      playlist.items << item
+      playlist.freeze
+      expect(item.client_attributes).to be_frozen
+    end
+
+    it 'freezes part_inf' do
+      playlist.part_inf = M3u8::PartInfItem.new(part_target: 0.5)
+      playlist.freeze
+      expect(playlist.part_inf).to be_frozen
+    end
+
+    it 'freezes server_control' do
+      playlist.server_control = M3u8::ServerControlItem.new(
+        can_skip_until: 24.0
+      )
+      playlist.freeze
+      expect(playlist.server_control).to be_frozen
+    end
+
+    it 'raises FrozenError on attribute set' do
+      playlist.freeze
+      expect { playlist.version = 7 }
+        .to raise_error(FrozenError)
+    end
+
+    it 'raises FrozenError on items append' do
+      playlist.freeze
+      item = M3u8::SegmentItem.new(
+        duration: 10.0, segment: 'test.ts'
+      )
+      expect { playlist.items << item }
+        .to raise_error(FrozenError)
+    end
+
+    it 'raises FrozenError on item mutation' do
+      item = M3u8::SegmentItem.new(
+        duration: 10.0, segment: 'test.ts'
+      )
+      playlist.items << item
+      playlist.freeze
+      expect { item.duration = 5.0 }
+        .to raise_error(FrozenError)
+    end
+
+    it 'still supports to_s' do
+      item = M3u8::SegmentItem.new(
+        duration: 10.0, segment: 'test.ts'
+      )
+      playlist.items << item
+      playlist.freeze
+      expect(playlist.to_s).to include('#EXTM3U')
+    end
+
+    it 'returns self' do
+      expect(playlist.freeze).to equal(playlist)
+    end
+  end
+
   describe '#write' do
     context 'when playlist is valid' do
       it 'returns playlist text' do
@@ -233,9 +766,7 @@ describe M3u8::Playlist do
 
         io = StringIO.new
         playlist.write(io)
-        expected = "#EXTM3U\n" +
-                   %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34",) +
-                   "BANDWIDTH=6400\nplaylist_url\n"
+        expected = "#EXTM3U\n#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS=\"mp4a.40.34\",BANDWIDTH=6400\nplaylist_url\n"
         expect(io.string).to eq(expected)
       end
     end
@@ -251,7 +782,8 @@ describe M3u8::Playlist do
         item = M3u8::SegmentItem.new(options)
         playlist.items << item
 
-        message = 'Playlist is invalid.'
+        message = 'Playlist is invalid: Playlist contains both ' \
+                  'master and media items'
         io = StringIO.new
         expect { playlist.write(io) }
           .to raise_error(M3u8::PlaylistTypeError, message)

data/spec/lib/m3u8/preload_hint_item_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe M3u8::PreloadHintItem do
+  describe '.new' do
+    it 'assigns attributes from options' do
+      options = { type: 'PART', uri: 'next_part.ts',
+                  byterange_start: 0, byterange_length: 5000 }
+      item = described_class.new(options)
+      expect(item.type).to eq('PART')
+      expect(item.uri).to eq('next_part.ts')
+      expect(item.byterange_start).to eq(0)
+      expect(item.byterange_length).to eq(5000)
+    end
+  end
+
+  describe '.parse' do
+    it 'parses tag with all attributes' do
+      tag = '#EXT-X-PRELOAD-HINT:TYPE=PART,URI="next_part.ts",' \
+            'BYTERANGE-START=0,BYTERANGE-LENGTH=5000'
+      item = described_class.parse(tag)
+      expect(item.type).to eq('PART')
+      expect(item.uri).to eq('next_part.ts')
+      expect(item.byterange_start).to eq(0)
+      expect(item.byterange_length).to eq(5000)
+    end
+
+    it 'parses tag without optional attributes' do
+      tag = '#EXT-X-PRELOAD-HINT:TYPE=PART,URI="next_part.ts"'
+      item = described_class.parse(tag)
+      expect(item.type).to eq('PART')
+      expect(item.uri).to eq('next_part.ts')
+      expect(item.byterange_start).to be_nil
+      expect(item.byterange_length).to be_nil
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns tag with all attributes' do
+      options = { type: 'PART', uri: 'next_part.ts',
+                  byterange_start: 0, byterange_length: 5000 }
+      item = described_class.new(options)
+      expected = '#EXT-X-PRELOAD-HINT:TYPE=PART,' \
+                 'URI="next_part.ts",' \
+                 'BYTERANGE-START=0,BYTERANGE-LENGTH=5000'
+      expect(item.to_s).to eq(expected)
+    end
+
+    it 'returns tag without optional attributes' do
+      options = { type: 'PART', uri: 'next_part.ts' }
+      item = described_class.new(options)
+      expected = '#EXT-X-PRELOAD-HINT:TYPE=PART,URI="next_part.ts"'
+      expect(item.to_s).to eq(expected)
+    end
+  end
+end