m3u8 0.7.1 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (25) hide show
  1. checksums.yaml +4 -4
  2. data/.gitignore +5 -14
  3. data/.travis.yml +3 -3
  4. data/CHANGELOG.md +11 -2
  5. data/README.md +26 -58
  6. data/lib/m3u8/byte_range.rb +2 -2
  7. data/lib/m3u8/discontinuity_item.rb +0 -2
  8. data/lib/m3u8/error.rb +4 -1
  9. data/lib/m3u8/map_item.rb +2 -2
  10. data/lib/m3u8/media_item.rb +39 -14
  11. data/lib/m3u8/playlist.rb +26 -15
  12. data/lib/m3u8/playlist_item.rb +13 -7
  13. data/lib/m3u8/reader.rb +22 -3
  14. data/lib/m3u8/time_item.rb +1 -1
  15. data/lib/m3u8/version.rb +1 -1
  16. data/lib/m3u8/writer.rb +20 -9
  17. data/spec/fixtures/playlist.m3u8 +1 -0
  18. data/spec/fixtures/session_data.m3u8 +1 -0
  19. data/spec/lib/m3u8/discontinuity_item_spec.rb +1 -3
  20. data/spec/lib/m3u8/media_item_spec.rb +80 -33
  21. data/spec/lib/m3u8/playlist_item_spec.rb +105 -79
  22. data/spec/lib/m3u8/playlist_spec.rb +211 -190
  23. data/spec/lib/m3u8/reader_spec.rb +33 -23
  24. data/spec/lib/m3u8/writer_spec.rb +221 -147
  25. metadata +3 -3
data/spec/lib/m3u8/writer_spec.rb CHANGED
@@ -3,177 +3,251 @@ require 'spec_helper'
3
3
 
4
4
  describe M3u8::Writer do
5
5
  describe '#write' do
6
- it 'should render master playlist' do
7
- options = { uri: 'playlist_url', bandwidth: 6400,
8
- audio_codec: 'mp3' }
9
- item = M3u8::PlaylistItem.new(options)
10
- playlist = M3u8::Playlist.new(version: 6, independent_segments: true)
11
- playlist.items << item
12
-
13
- output = "#EXTM3U\n" \
14
- "#EXT-X-VERSION:6\n" \
15
- "#EXT-X-INDEPENDENT-SEGMENTS\n" +
16
- %(#EXT-X-STREAM-INF:CODECS="mp4a.40.34") +
17
- ",BANDWIDTH=6400\nplaylist_url\n"
18
-
19
- io = StringIO.open
20
- writer = M3u8::Writer.new(io)
21
- writer.write(playlist)
22
- expect(io.string).to eq(output)
6
+ context 'when playlist is a master playlist' do
7
+ it 'writes playlist to io' do
8
+ playlist = M3u8::Playlist.new
9
+ options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
10
+ audio_codec: 'mp3' }
11
+ item = M3u8::PlaylistItem.new(options)
12
+ playlist.items << item
13
+ options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
14
+ width: 1920, height: 1080, profile: 'high', level: 4.1,
15
+ audio_codec: 'aac-lc' }
16
+ item = M3u8::PlaylistItem.new(options)
17
+ playlist.items << item
18
+ options = { data_id: 'com.test.movie.title', value: 'Test',
19
+ uri: 'http://test', language: 'en' }
20
+ item = M3u8::SessionDataItem.new(options)
21
+ playlist.items << item
22
+
23
+ expected = "#EXTM3U\n" +
24
+ %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34") +
25
+ ",BANDWIDTH=6400\nplaylist_url\n" \
26
+ '#EXT-X-STREAM-INF:PROGRAM-ID=2,' +
27
+ %(RESOLUTION=1920x1080,CODECS="avc1.640029,mp4a.40.2") +
28
+ ",BANDWIDTH=50000\nplaylist_url\n" +
29
+ %(#EXT-X-SESSION-DATA:DATA-ID="com.test.movie.title",) +
30
+ %(VALUE="Test",URI="http://test",LANGUAGE="en"\n)
31
+
32
+ io = StringIO.open
33
+ writer = described_class.new(io)
34
+ writer.write(playlist)
35
+ expect(io.string).to eq(expected)
36
+ end
37
+ end
23
38
 
24
- options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
25
- audio_codec: 'mp3' }
26
- item = M3u8::PlaylistItem.new(options)
27
- playlist = M3u8::Playlist.new
28
- playlist.items << item
39
+ context 'when playlist is a master playlist with single stream' do
40
+ it 'writes playlist to io' do
41
+ options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
42
+ audio_codec: 'mp3' }
43
+ item = M3u8::PlaylistItem.new(options)
44
+ playlist = M3u8::Playlist.new
45
+ playlist.items << item
46
+
47
+ expected = "#EXTM3U\n" +
48
+ %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34") +
49
+ ",BANDWIDTH=6400\nplaylist_url\n"
50
+
51
+ io = StringIO.open
52
+ writer = described_class.new(io)
53
+ writer.write(playlist)
54
+ expect(io.string).to eq(expected)
55
+ end
56
+ end
29
57
 
30
- output = "#EXTM3U\n" +
31
- %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34") +
32
- ",BANDWIDTH=6400\nplaylist_url\n"
58
+ context 'when playlist is a master playlist with header options' do
59
+ it 'writes playlist to io' do
60
+ options = { uri: 'playlist_url', bandwidth: 6400,
61
+ audio_codec: 'mp3' }
62
+ item = M3u8::PlaylistItem.new(options)
63
+ playlist = M3u8::Playlist.new(version: 6, independent_segments: true)
64
+ playlist.items << item
65
+
66
+ expected = "#EXTM3U\n" \
67
+ "#EXT-X-VERSION:6\n" \
68
+ "#EXT-X-INDEPENDENT-SEGMENTS\n" +
69
+ %(#EXT-X-STREAM-INF:CODECS="mp4a.40.34") +
70
+ ",BANDWIDTH=6400\nplaylist_url\n"
71
+
72
+ io = StringIO.open
73
+ writer = described_class.new(io)
74
+ writer.write(playlist)
75
+ expect(io.string).to eq(expected)
76
+ end
77
+ end
33
78
 
34
- io = StringIO.open
35
- writer = M3u8::Writer.new(io)
36
- writer.write(playlist)
37
- expect(io.string).to eq(output)
79
+ context 'when playlist is a new master playlist' do
80
+ it 'writes playlist to io' do
81
+ io = StringIO.open
82
+ writer = described_class.new(io)
83
+ playlist = M3u8::Playlist.new(master: true)
84
+ writer.write(playlist)
85
+ expect(io.string).to eq("#EXTM3U\n")
86
+ end
87
+ end
38
88
 
39
- options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
40
- width: 1920, height: 1080, profile: 'high', level: 4.1,
41
- audio_codec: 'aac-lc' }
42
- item = M3u8::PlaylistItem.new(options)
43
- playlist = M3u8::Playlist.new
44
- playlist.items << item
89
+ context 'when playlist is a new media playlist' do
90
+ it 'writes playlist to io' do
91
+ io = StringIO.open
92
+ writer = described_class.new(io)
93
+ writer.write(M3u8::Playlist.new)
94
+
95
+ expected = "#EXTM3U\n" \
96
+ "#EXT-X-MEDIA-SEQUENCE:0\n" \
97
+ "#EXT-X-TARGETDURATION:10\n" \
98
+ "#EXT-X-ENDLIST\n"
99
+ expect(io.string).to eq(expected)
100
+ end
101
+ end
45
102
 
46
- output = "#EXTM3U\n" \
47
- '#EXT-X-STREAM-INF:PROGRAM-ID=2,RESOLUTION=1920x1080,' +
48
- %(CODECS="avc1.640029,mp4a.40.2",BANDWIDTH=50000\n) +
49
- "playlist_url\n"
103
+ context 'when playlist is a media playlist' do
104
+ it 'writes playlist to io' do
105
+ options = { version: 4, cache: false, target: 6.2, sequence: 1,
106
+ discontinuity_sequence: 10, type: 'EVENT',
107
+ iframes_only: true }
108
+ playlist = M3u8::Playlist.new(options)
109
+ options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
110
+ item = M3u8::SegmentItem.new(options)
111
+ playlist.items << item
112
+
113
+ expected = "#EXTM3U\n" \
114
+ "#EXT-X-PLAYLIST-TYPE:EVENT\n" \
115
+ "#EXT-X-VERSION:4\n" \
116
+ "#EXT-X-I-FRAMES-ONLY\n" \
117
+ "#EXT-X-MEDIA-SEQUENCE:1\n" \
118
+ "#EXT-X-DISCONTINUITY-SEQUENCE:10\n" \
119
+ "#EXT-X-ALLOW-CACHE:NO\n" \
120
+ "#EXT-X-TARGETDURATION:6\n" \
121
+ "#EXTINF:11.344644,\n" \
122
+ "1080-7mbps00000.ts\n" \
123
+ "#EXT-X-ENDLIST\n"
124
+
125
+ io = StringIO.open
126
+ writer = described_class.new(io)
127
+ writer.write(playlist)
128
+ expect(io.string).to eq(expected)
129
+ end
130
+ end
50
131
 
51
- io = StringIO.open
52
- writer = M3u8::Writer.new(io)
53
- writer.write(playlist)
54
- expect(io.string).to eq(output)
132
+ context 'when playlist is media playlist with keys' do
133
+ it 'writes playlist to io' do
134
+ options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
135
+ item = M3u8::SegmentItem.new(options)
136
+ playlist = M3u8::Playlist.new(version: 7)
137
+ playlist.items << item
138
+
139
+ options = { method: 'AES-128', uri: 'http://test.key',
140
+ iv: 'D512BBF', key_format: 'identity',
141
+ key_format_versions: '1/3' }
142
+ item = M3u8::KeyItem.new(options)
143
+ playlist.items << item
144
+
145
+ options = { duration: 11.261233, segment: '1080-7mbps00001.ts' }
146
+ item = M3u8::SegmentItem.new(options)
147
+ playlist.items << item
148
+
149
+ expected = "#EXTM3U\n" \
150
+ "#EXT-X-VERSION:7\n" \
151
+ "#EXT-X-MEDIA-SEQUENCE:0\n" \
152
+ "#EXT-X-TARGETDURATION:10\n" \
153
+ "#EXTINF:11.344644,\n" \
154
+ "1080-7mbps00000.ts\n" +
155
+ %(#EXT-X-KEY:METHOD=AES-128,URI="http://test.key",) +
156
+ %(IV=D512BBF,KEYFORMAT="identity",) +
157
+ %(KEYFORMATVERSIONS="1/3"\n) +
158
+ "#EXTINF:11.261233,\n" \
159
+ "1080-7mbps00001.ts\n" \
160
+ "#EXT-X-ENDLIST\n"
161
+
162
+ io = StringIO.open
163
+ writer = described_class.new(io)
164
+ writer.write(playlist)
165
+ expect(io.string).to eq(expected)
166
+ end
167
+ end
55
168
 
169
+ it 'raises error if item types are mixed' do
56
170
  playlist = M3u8::Playlist.new
57
- options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
58
- audio_codec: 'mp3' }
171
+ options = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
172
+ bandwidth: 540, playlist: 'test.url' }
59
173
  item = M3u8::PlaylistItem.new(options)
60
174
  playlist.items << item
61
- options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
62
- width: 1920, height: 1080, profile: 'high', level: 4.1,
63
- audio_codec: 'aac-lc' }
64
- item = M3u8::PlaylistItem.new(options)
65
- playlist.items << item
66
- options = { data_id: 'com.test.movie.title', value: 'Test',
67
- uri: 'http://test', language: 'en' }
68
- item = M3u8::SessionDataItem.new(options)
175
+
176
+ options = { duration: 10.991, segment: 'test.ts' }
177
+ item = M3u8::SegmentItem.new(options)
69
178
  playlist.items << item
70
179
 
71
- output = "#EXTM3U\n" +
72
- %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34") +
73
- ",BANDWIDTH=6400\nplaylist_url\n#EXT-X-STREAM-INF:PROGRAM-ID=2," +
74
- %(RESOLUTION=1920x1080,CODECS="avc1.640029,mp4a.40.2") +
75
- ",BANDWIDTH=50000\nplaylist_url\n" +
76
- %(#EXT-X-SESSION-DATA:DATA-ID="com.test.movie.title",) +
77
- %(VALUE="Test",URI="http://test",LANGUAGE="en"\n)
78
-
79
- io = StringIO.open
80
- writer = M3u8::Writer.new(io)
81
- writer.write(playlist)
82
- expect(io.string).to eq(output)
180
+ message = 'Playlist is invalid.'
181
+ io = StringIO.new
182
+ writer = described_class.new(io)
183
+ expect { writer.write(playlist) }
184
+ .to raise_error(M3u8::PlaylistTypeError, message)
83
185
  end
186
+ end
84
187
 
85
- it 'should render playlist' do
86
- options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
87
- item = M3u8::SegmentItem.new(options)
88
- playlist = M3u8::Playlist.new(version: 7)
89
- playlist.items << item
188
+ describe '#write_footer' do
189
+ context 'when playlist is a master playlist' do
190
+ it 'does nothing' do
191
+ io = StringIO.open
192
+ writer = described_class.new(io)
193
+ playlist = M3u8::Playlist.new(master: true)
194
+ writer.write_footer(playlist)
90
195
 
91
- output = "#EXTM3U\n" \
92
- "#EXT-X-VERSION:7\n" \
93
- "#EXT-X-MEDIA-SEQUENCE:0\n" \
94
- "#EXT-X-TARGETDURATION:10\n" \
95
- "#EXTINF:11.344644,\n" \
96
- "1080-7mbps00000.ts\n" \
97
- "#EXT-X-ENDLIST\n"
98
- io = StringIO.open
99
- writer = M3u8::Writer.new(io)
100
- writer.write(playlist)
101
- expect(io.string).to eq(output)
102
-
103
- options = { method: 'AES-128', uri: 'http://test.key',
104
- iv: 'D512BBF', key_format: 'identity',
105
- key_format_versions: '1/3' }
106
- item = M3u8::KeyItem.new(options)
107
- playlist.items << item
196
+ expect(io.string).to be_empty
197
+ end
198
+ end
108
199
 
109
- options = { duration: 11.261233, segment: '1080-7mbps00001.ts' }
110
- item = M3u8::SegmentItem.new(options)
111
- playlist.items << item
200
+ context 'when playlist is a media playlist' do
201
+ it 'writes end list tag' do
202
+ io = StringIO.open
203
+ writer = described_class.new(io)
204
+ playlist = M3u8::Playlist.new(master: false)
205
+ writer.write_footer(playlist)
112
206
 
113
- output = "#EXTM3U\n" \
114
- "#EXT-X-VERSION:7\n" \
115
- "#EXT-X-MEDIA-SEQUENCE:0\n" \
116
- "#EXT-X-TARGETDURATION:10\n" \
117
- "#EXTINF:11.344644,\n" \
118
- "1080-7mbps00000.ts\n" +
119
- %(#EXT-X-KEY:METHOD=AES-128,URI="http://test.key",) +
120
- %(IV=D512BBF,KEYFORMAT="identity",KEYFORMATVERSIONS="1/3"\n) +
121
- "#EXTINF:11.261233,\n" \
122
- "1080-7mbps00001.ts\n" \
123
- "#EXT-X-ENDLIST\n"
124
- io = StringIO.open
125
- writer = M3u8::Writer.new(io)
126
- writer.write(playlist)
127
- expect(io.string).to eq(output)
128
-
129
- options = { version: 4, cache: false, target: 12, sequence: 1,
130
- type: 'EVENT', iframes_only: true }
131
- playlist = M3u8::Playlist.new(options)
132
- options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
133
- item = M3u8::SegmentItem.new(options)
134
- playlist.items << item
135
-
136
- output = "#EXTM3U\n" \
137
- "#EXT-X-PLAYLIST-TYPE:EVENT\n" \
138
- "#EXT-X-VERSION:4\n" \
139
- "#EXT-X-I-FRAMES-ONLY\n" \
140
- "#EXT-X-MEDIA-SEQUENCE:1\n" \
141
- "#EXT-X-ALLOW-CACHE:NO\n" \
142
- "#EXT-X-TARGETDURATION:12\n" \
143
- "#EXTINF:11.344644,\n" \
144
- "1080-7mbps00000.ts\n" \
145
- "#EXT-X-ENDLIST\n"
146
- io = StringIO.open
147
- writer = M3u8::Writer.new(io)
148
- writer.write(playlist)
149
- expect(io.string).to eq(output)
207
+ expect(io.string).to eq("#EXT-X-ENDLIST\n")
208
+ end
150
209
  end
210
+ end
151
211
 
152
- it 'should render the target duration as a decimal-integer' do
153
- playlist = M3u8::Playlist.new(target: 6.2)
154
- io = StringIO.open
155
- writer = M3u8::Writer.new(io)
156
- writer.write(playlist)
157
- expect(io.string).to include('#EXT-X-TARGETDURATION:6')
212
+ describe '#write_header' do
213
+ context 'when playlist is a master playlist' do
214
+ it 'writes header content only' do
215
+ playlist = M3u8::Playlist.new(version: 6, independent_segments: true)
216
+ options = { uri: 'playlist_url', bandwidth: 6400,
217
+ audio_codec: 'mp3' }
218
+ item = M3u8::PlaylistItem.new(options)
219
+ playlist.items << item
220
+ expect(playlist.master?).to be true
221
+
222
+ expected = "#EXTM3U\n" \
223
+ "#EXT-X-VERSION:6\n" \
224
+ "#EXT-X-INDEPENDENT-SEGMENTS\n"
225
+
226
+ io = StringIO.open
227
+ writer = described_class.new(io)
228
+ writer.write_header(playlist)
229
+ expect(io.string).to eq(expected)
230
+ end
158
231
  end
159
232
 
160
- it 'should raise error on write if item types are mixed' do
161
- playlist = M3u8::Playlist.new
233
+ context 'when playlist is a media playlist' do
234
+ it 'writes header content only' do
235
+ playlist = M3u8::Playlist.new(version: 7)
236
+ options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
237
+ item = M3u8::SegmentItem.new(options)
238
+ playlist.items << item
162
239
 
163
- hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
164
- bandwidth: 540, playlist: 'test.url' }
165
- item = M3u8::PlaylistItem.new(hash)
166
- playlist.items << item
240
+ io = StringIO.open
241
+ writer = described_class.new(io)
242
+ writer.write_header(playlist)
167
243
 
168
- hash = { duration: 10.991, segment: 'test.ts' }
169
- item = M3u8::SegmentItem.new(hash)
170
- playlist.items << item
244
+ expected = "#EXTM3U\n" \
245
+ "#EXT-X-VERSION:7\n" \
246
+ "#EXT-X-MEDIA-SEQUENCE:0\n" \
247
+ "#EXT-X-TARGETDURATION:10\n"
171
248
 
172
- message = 'Playlist is invalid.'
173
- io = StringIO.new
174
- writer = M3u8::Writer.new(io)
175
- expect { writer.write(playlist) }
176
- .to raise_error(M3u8::PlaylistTypeError, message)
249
+ expect(io.string).to eq(expected)
250
+ end
177
251
  end
178
252
  end
179
253
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: m3u8
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.7.1
4
+ version: 0.8.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Seth Deckard
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2017-02-23 00:00:00.000000000 Z
11
+ date: 2017-04-13 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: bundler
@@ -195,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
195
195
  version: '0'
196
196
  requirements: []
197
197
  rubyforge_project:
198
- rubygems_version: 2.5.2
198
+ rubygems_version: 2.6.11
199
199
  signing_key:
200
200
  specification_version: 4
201
201
  summary: Generate and parse m3u8 playlists for HTTP Live Streaming (HLS).