Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Apple HTTP Live Streaming demuxer | ||
3 | * Copyright (c) 2010 Martin Storsjo | ||
4 | * Copyright (c) 2013 Anssi Hannula | ||
5 | * Copyright (c) 2021 Nachiket Tarate | ||
6 | * | ||
7 | * This file is part of FFmpeg. | ||
8 | * | ||
9 | * FFmpeg is free software; you can redistribute it and/or | ||
10 | * modify it under the terms of the GNU Lesser General Public | ||
11 | * License as published by the Free Software Foundation; either | ||
12 | * version 2.1 of the License, or (at your option) any later version. | ||
13 | * | ||
14 | * FFmpeg is distributed in the hope that it will be useful, | ||
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
17 | * Lesser General Public License for more details. | ||
18 | * | ||
19 | * You should have received a copy of the GNU Lesser General Public | ||
20 | * License along with FFmpeg; if not, write to the Free Software | ||
21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
22 | */ | ||
23 | |||
24 | /** | ||
25 | * @file | ||
26 | * Apple HTTP Live Streaming demuxer | ||
27 | * https://www.rfc-editor.org/rfc/rfc8216.txt | ||
28 | */ | ||
29 | |||
30 | #include "config_components.h" | ||
31 | |||
32 | #include "libavformat/http.h" | ||
33 | #include "libavutil/aes.h" | ||
34 | #include "libavutil/avstring.h" | ||
35 | #include "libavutil/avassert.h" | ||
36 | #include "libavutil/intreadwrite.h" | ||
37 | #include "libavutil/mathematics.h" | ||
38 | #include "libavutil/mem.h" | ||
39 | #include "libavutil/opt.h" | ||
40 | #include "libavutil/dict.h" | ||
41 | #include "libavutil/time.h" | ||
42 | #include "avformat.h" | ||
43 | #include "demux.h" | ||
44 | #include "internal.h" | ||
45 | #include "avio_internal.h" | ||
46 | #include "id3v2.h" | ||
47 | #include "url.h" | ||
48 | |||
49 | #include "hls_sample_encryption.h" | ||
50 | |||
51 | #define INITIAL_BUFFER_SIZE 32768 | ||
52 | |||
53 | #define MAX_FIELD_LEN 64 | ||
54 | #define MAX_CHARACTERISTICS_LEN 512 | ||
55 | |||
56 | #define MPEG_TIME_BASE 90000 | ||
57 | #define MPEG_TIME_BASE_Q (AVRational){1, MPEG_TIME_BASE} | ||
58 | |||
59 | /* | ||
60 | * An apple http stream consists of a playlist with media segment files, | ||
61 | * played sequentially. There may be several playlists with the same | ||
62 | * video content, in different bandwidth variants, that are played in | ||
63 | * parallel (preferably only one bandwidth variant at a time). In this case, | ||
64 | * the user supplied the url to a main playlist that only lists the variant | ||
65 | * playlists. | ||
66 | * | ||
67 | * If the main playlist doesn't point at any variants, we still create | ||
68 | * one anonymous toplevel variant for this, to maintain the structure. | ||
69 | */ | ||
70 | |||
71 | enum KeyType { | ||
72 | KEY_NONE, | ||
73 | KEY_AES_128, | ||
74 | KEY_SAMPLE_AES | ||
75 | }; | ||
76 | |||
77 | struct segment { | ||
78 | int64_t duration; | ||
79 | int64_t url_offset; | ||
80 | int64_t size; | ||
81 | char *url; | ||
82 | char *key; | ||
83 | enum KeyType key_type; | ||
84 | uint8_t iv[16]; | ||
85 | /* associated Media Initialization Section, treated as a segment */ | ||
86 | struct segment *init_section; | ||
87 | }; | ||
88 | |||
89 | struct rendition; | ||
90 | |||
91 | enum PlaylistType { | ||
92 | PLS_TYPE_UNSPECIFIED, | ||
93 | PLS_TYPE_EVENT, | ||
94 | PLS_TYPE_VOD | ||
95 | }; | ||
96 | |||
97 | /* | ||
98 | * Each playlist has its own demuxer. If it currently is active, | ||
99 | * it has an open AVIOContext too, and potentially an AVPacket | ||
100 | * containing the next packet from this stream. | ||
101 | */ | ||
102 | struct playlist { | ||
103 | char url[MAX_URL_SIZE]; | ||
104 | FFIOContext pb; | ||
105 | uint8_t* read_buffer; | ||
106 | AVIOContext *input; | ||
107 | int input_read_done; | ||
108 | AVIOContext *input_next; | ||
109 | int input_next_requested; | ||
110 | AVFormatContext *parent; | ||
111 | int index; | ||
112 | AVFormatContext *ctx; | ||
113 | AVPacket *pkt; | ||
114 | int has_noheader_flag; | ||
115 | |||
116 | /* main demuxer streams associated with this playlist | ||
117 | * indexed by the subdemuxer stream indexes */ | ||
118 | AVStream **main_streams; | ||
119 | int n_main_streams; | ||
120 | |||
121 | int finished; | ||
122 | enum PlaylistType type; | ||
123 | int64_t target_duration; | ||
124 | int64_t start_seq_no; | ||
125 | int time_offset_flag; | ||
126 | int64_t start_time_offset; | ||
127 | int n_segments; | ||
128 | struct segment **segments; | ||
129 | int needed; | ||
130 | int broken; | ||
131 | int64_t cur_seq_no; | ||
132 | int64_t last_seq_no; | ||
133 | int m3u8_hold_counters; | ||
134 | int64_t cur_seg_offset; | ||
135 | int64_t last_load_time; | ||
136 | |||
137 | /* Currently active Media Initialization Section */ | ||
138 | struct segment *cur_init_section; | ||
139 | uint8_t *init_sec_buf; | ||
140 | unsigned int init_sec_buf_size; | ||
141 | unsigned int init_sec_data_len; | ||
142 | unsigned int init_sec_buf_read_offset; | ||
143 | |||
144 | char key_url[MAX_URL_SIZE]; | ||
145 | uint8_t key[16]; | ||
146 | |||
147 | /* ID3 timestamp handling (elementary audio streams have ID3 timestamps | ||
148 | * (and possibly other ID3 tags) in the beginning of each segment) */ | ||
149 | int is_id3_timestamped; /* -1: not yet known */ | ||
150 | int64_t id3_mpegts_timestamp; /* in mpegts tb */ | ||
151 | int64_t id3_offset; /* in stream original tb */ | ||
152 | uint8_t* id3_buf; /* temp buffer for id3 parsing */ | ||
153 | unsigned int id3_buf_size; | ||
154 | AVDictionary *id3_initial; /* data from first id3 tag */ | ||
155 | int id3_found; /* ID3 tag found at some point */ | ||
156 | int id3_changed; /* ID3 tag data has changed at some point */ | ||
157 | ID3v2ExtraMeta *id3_deferred_extra; /* stored here until subdemuxer is opened */ | ||
158 | |||
159 | HLSAudioSetupInfo audio_setup_info; | ||
160 | |||
161 | int64_t seek_timestamp; | ||
162 | int seek_flags; | ||
163 | int seek_stream_index; /* into subdemuxer stream array */ | ||
164 | |||
165 | /* Renditions associated with this playlist, if any. | ||
166 | * Alternative rendition playlists have a single rendition associated | ||
167 | * with them, and variant main Media Playlists may have | ||
168 | * multiple (playlist-less) renditions associated with them. */ | ||
169 | int n_renditions; | ||
170 | struct rendition **renditions; | ||
171 | |||
172 | /* Media Initialization Sections (EXT-X-MAP) associated with this | ||
173 | * playlist, if any. */ | ||
174 | int n_init_sections; | ||
175 | struct segment **init_sections; | ||
176 | int is_subtitle; /* Indicates if it's a subtitle playlist */ | ||
177 | }; | ||
178 | |||
179 | /* | ||
180 | * Renditions are e.g. alternative subtitle or audio streams. | ||
181 | * The rendition may either be an external playlist or it may be | ||
182 | * contained in the main Media Playlist of the variant (in which case | ||
183 | * playlist is NULL). | ||
184 | */ | ||
185 | struct rendition { | ||
186 | enum AVMediaType type; | ||
187 | struct playlist *playlist; | ||
188 | char group_id[MAX_FIELD_LEN]; | ||
189 | char language[MAX_FIELD_LEN]; | ||
190 | char name[MAX_FIELD_LEN]; | ||
191 | int disposition; | ||
192 | }; | ||
193 | |||
194 | struct variant { | ||
195 | int bandwidth; | ||
196 | |||
197 | /* every variant contains at least the main Media Playlist in index 0 */ | ||
198 | int n_playlists; | ||
199 | struct playlist **playlists; | ||
200 | |||
201 | char audio_group[MAX_FIELD_LEN]; | ||
202 | char video_group[MAX_FIELD_LEN]; | ||
203 | char subtitles_group[MAX_FIELD_LEN]; | ||
204 | }; | ||
205 | |||
206 | typedef struct HLSContext { | ||
207 | AVClass *class; | ||
208 | AVFormatContext *ctx; | ||
209 | int n_variants; | ||
210 | struct variant **variants; | ||
211 | int n_playlists; | ||
212 | struct playlist **playlists; | ||
213 | int n_renditions; | ||
214 | struct rendition **renditions; | ||
215 | |||
216 | int64_t cur_seq_no; | ||
217 | int m3u8_hold_counters; | ||
218 | int live_start_index; | ||
219 | int prefer_x_start; | ||
220 | int first_packet; | ||
221 | int64_t first_timestamp; | ||
222 | int64_t cur_timestamp; | ||
223 | AVIOInterruptCB *interrupt_callback; | ||
224 | AVDictionary *avio_opts; | ||
225 | AVDictionary *seg_format_opts; | ||
226 | char *allowed_extensions; | ||
227 | char *allowed_segment_extensions; | ||
228 | int extension_picky; | ||
229 | int max_reload; | ||
230 | int http_persistent; | ||
231 | int http_multiple; | ||
232 | int http_seekable; | ||
233 | int seg_max_retry; | ||
234 | AVIOContext *playlist_pb; | ||
235 | HLSCryptoContext crypto_ctx; | ||
236 | } HLSContext; | ||
237 | |||
238 | 12 | static void free_segment_dynarray(struct segment **segments, int n_segments) | |
239 | { | ||
240 | int i; | ||
241 |
2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 12 times.
|
77 | for (i = 0; i < n_segments; i++) { |
242 | 65 | av_freep(&segments[i]->key); | |
243 | 65 | av_freep(&segments[i]->url); | |
244 | 65 | av_freep(&segments[i]); | |
245 | } | ||
246 | 12 | } | |
247 | |||
248 | 12 | static void free_segment_list(struct playlist *pls) | |
249 | { | ||
250 | 12 | free_segment_dynarray(pls->segments, pls->n_segments); | |
251 | 12 | av_freep(&pls->segments); | |
252 | 12 | pls->n_segments = 0; | |
253 | 12 | } | |
254 | |||
255 | 12 | static void free_init_section_list(struct playlist *pls) | |
256 | { | ||
257 | int i; | ||
258 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | for (i = 0; i < pls->n_init_sections; i++) { |
259 | ✗ | av_freep(&pls->init_sections[i]->key); | |
260 | ✗ | av_freep(&pls->init_sections[i]->url); | |
261 | ✗ | av_freep(&pls->init_sections[i]); | |
262 | } | ||
263 | 12 | av_freep(&pls->init_sections); | |
264 | 12 | pls->n_init_sections = 0; | |
265 | 12 | } | |
266 | |||
267 | 12 | static void free_playlist_list(HLSContext *c) | |
268 | { | ||
269 | int i; | ||
270 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (i = 0; i < c->n_playlists; i++) { |
271 | 12 | struct playlist *pls = c->playlists[i]; | |
272 | 12 | free_segment_list(pls); | |
273 | 12 | free_init_section_list(pls); | |
274 | 12 | av_freep(&pls->main_streams); | |
275 | 12 | av_freep(&pls->renditions); | |
276 | 12 | av_freep(&pls->id3_buf); | |
277 | 12 | av_dict_free(&pls->id3_initial); | |
278 | 12 | ff_id3v2_free_extra_meta(&pls->id3_deferred_extra); | |
279 | 12 | av_freep(&pls->init_sec_buf); | |
280 | 12 | av_packet_free(&pls->pkt); | |
281 | 12 | av_freep(&pls->pb.pub.buffer); | |
282 | 12 | ff_format_io_close(c->ctx, &pls->input); | |
283 | 12 | pls->input_read_done = 0; | |
284 | 12 | ff_format_io_close(c->ctx, &pls->input_next); | |
285 | 12 | pls->input_next_requested = 0; | |
286 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (pls->ctx) { |
287 | 12 | pls->ctx->pb = NULL; | |
288 | 12 | avformat_close_input(&pls->ctx); | |
289 | } | ||
290 | 12 | av_free(pls); | |
291 | } | ||
292 | 12 | av_freep(&c->playlists); | |
293 | 12 | c->n_playlists = 0; | |
294 | 12 | } | |
295 | |||
296 | 12 | static void free_variant_list(HLSContext *c) | |
297 | { | ||
298 | int i; | ||
299 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (i = 0; i < c->n_variants; i++) { |
300 | 12 | struct variant *var = c->variants[i]; | |
301 | 12 | av_freep(&var->playlists); | |
302 | 12 | av_free(var); | |
303 | } | ||
304 | 12 | av_freep(&c->variants); | |
305 | 12 | c->n_variants = 0; | |
306 | 12 | } | |
307 | |||
308 | 12 | static void free_rendition_list(HLSContext *c) | |
309 | { | ||
310 | int i; | ||
311 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | for (i = 0; i < c->n_renditions; i++) |
312 | ✗ | av_freep(&c->renditions[i]); | |
313 | 12 | av_freep(&c->renditions); | |
314 | 12 | c->n_renditions = 0; | |
315 | 12 | } | |
316 | |||
317 | 12 | static struct playlist *new_playlist(HLSContext *c, const char *url, | |
318 | const char *base) | ||
319 | { | ||
320 | 12 | struct playlist *pls = av_mallocz(sizeof(struct playlist)); | |
321 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!pls) |
322 | ✗ | return NULL; | |
323 | 12 | pls->pkt = av_packet_alloc(); | |
324 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!pls->pkt) { |
325 | ✗ | av_free(pls); | |
326 | ✗ | return NULL; | |
327 | } | ||
328 | 12 | ff_make_absolute_url(pls->url, sizeof(pls->url), base, url); | |
329 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!pls->url[0]) { |
330 | ✗ | av_packet_free(&pls->pkt); | |
331 | ✗ | av_free(pls); | |
332 | ✗ | return NULL; | |
333 | } | ||
334 | 12 | pls->seek_timestamp = AV_NOPTS_VALUE; | |
335 | |||
336 | 12 | pls->is_id3_timestamped = -1; | |
337 | 12 | pls->id3_mpegts_timestamp = AV_NOPTS_VALUE; | |
338 | |||
339 | 12 | dynarray_add(&c->playlists, &c->n_playlists, pls); | |
340 | 12 | return pls; | |
341 | } | ||
342 | |||
343 | struct variant_info { | ||
344 | char bandwidth[20]; | ||
345 | /* variant group ids: */ | ||
346 | char audio[MAX_FIELD_LEN]; | ||
347 | char video[MAX_FIELD_LEN]; | ||
348 | char subtitles[MAX_FIELD_LEN]; | ||
349 | }; | ||
350 | |||
351 | 12 | static struct variant *new_variant(HLSContext *c, struct variant_info *info, | |
352 | const char *url, const char *base) | ||
353 | { | ||
354 | struct variant *var; | ||
355 | struct playlist *pls; | ||
356 | |||
357 | 12 | pls = new_playlist(c, url, base); | |
358 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!pls) |
359 | ✗ | return NULL; | |
360 | |||
361 | 12 | var = av_mallocz(sizeof(struct variant)); | |
362 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!var) |
363 | ✗ | return NULL; | |
364 | |||
365 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (info) { |
366 | ✗ | var->bandwidth = atoi(info->bandwidth); | |
367 | ✗ | strcpy(var->audio_group, info->audio); | |
368 | ✗ | strcpy(var->video_group, info->video); | |
369 | ✗ | strcpy(var->subtitles_group, info->subtitles); | |
370 | } | ||
371 | |||
372 | 12 | dynarray_add(&c->variants, &c->n_variants, var); | |
373 | 12 | dynarray_add(&var->playlists, &var->n_playlists, pls); | |
374 | 12 | return var; | |
375 | } | ||
376 | |||
377 | ✗ | static void handle_variant_args(struct variant_info *info, const char *key, | |
378 | int key_len, char **dest, int *dest_len) | ||
379 | { | ||
380 | ✗ | if (!strncmp(key, "BANDWIDTH=", key_len)) { | |
381 | ✗ | *dest = info->bandwidth; | |
382 | ✗ | *dest_len = sizeof(info->bandwidth); | |
383 | ✗ | } else if (!strncmp(key, "AUDIO=", key_len)) { | |
384 | ✗ | *dest = info->audio; | |
385 | ✗ | *dest_len = sizeof(info->audio); | |
386 | ✗ | } else if (!strncmp(key, "VIDEO=", key_len)) { | |
387 | ✗ | *dest = info->video; | |
388 | ✗ | *dest_len = sizeof(info->video); | |
389 | ✗ | } else if (!strncmp(key, "SUBTITLES=", key_len)) { | |
390 | ✗ | *dest = info->subtitles; | |
391 | ✗ | *dest_len = sizeof(info->subtitles); | |
392 | } | ||
393 | ✗ | } | |
394 | |||
395 | struct key_info { | ||
396 | char uri[MAX_URL_SIZE]; | ||
397 | char method[11]; | ||
398 | char iv[35]; | ||
399 | }; | ||
400 | |||
401 | ✗ | static void handle_key_args(struct key_info *info, const char *key, | |
402 | int key_len, char **dest, int *dest_len) | ||
403 | { | ||
404 | ✗ | if (!strncmp(key, "METHOD=", key_len)) { | |
405 | ✗ | *dest = info->method; | |
406 | ✗ | *dest_len = sizeof(info->method); | |
407 | ✗ | } else if (!strncmp(key, "URI=", key_len)) { | |
408 | ✗ | *dest = info->uri; | |
409 | ✗ | *dest_len = sizeof(info->uri); | |
410 | ✗ | } else if (!strncmp(key, "IV=", key_len)) { | |
411 | ✗ | *dest = info->iv; | |
412 | ✗ | *dest_len = sizeof(info->iv); | |
413 | } | ||
414 | ✗ | } | |
415 | |||
416 | struct init_section_info { | ||
417 | char uri[MAX_URL_SIZE]; | ||
418 | char byterange[32]; | ||
419 | }; | ||
420 | |||
421 | ✗ | static struct segment *new_init_section(struct playlist *pls, | |
422 | struct init_section_info *info, | ||
423 | const char *url_base) | ||
424 | { | ||
425 | struct segment *sec; | ||
426 | ✗ | char tmp_str[MAX_URL_SIZE], *ptr = tmp_str; | |
427 | |||
428 | ✗ | if (!info->uri[0]) | |
429 | ✗ | return NULL; | |
430 | |||
431 | ✗ | sec = av_mallocz(sizeof(*sec)); | |
432 | ✗ | if (!sec) | |
433 | ✗ | return NULL; | |
434 | |||
435 | ✗ | if (!av_strncasecmp(info->uri, "data:", 5)) { | |
436 | ✗ | ptr = info->uri; | |
437 | } else { | ||
438 | ✗ | ff_make_absolute_url(tmp_str, sizeof(tmp_str), url_base, info->uri); | |
439 | ✗ | if (!tmp_str[0]) { | |
440 | ✗ | av_free(sec); | |
441 | ✗ | return NULL; | |
442 | } | ||
443 | } | ||
444 | ✗ | sec->url = av_strdup(ptr); | |
445 | ✗ | if (!sec->url) { | |
446 | ✗ | av_free(sec); | |
447 | ✗ | return NULL; | |
448 | } | ||
449 | |||
450 | ✗ | if (info->byterange[0]) { | |
451 | ✗ | sec->size = strtoll(info->byterange, NULL, 10); | |
452 | ✗ | ptr = strchr(info->byterange, '@'); | |
453 | ✗ | if (ptr) | |
454 | ✗ | sec->url_offset = strtoll(ptr+1, NULL, 10); | |
455 | } else { | ||
456 | /* the entire file is the init section */ | ||
457 | ✗ | sec->size = -1; | |
458 | } | ||
459 | |||
460 | ✗ | dynarray_add(&pls->init_sections, &pls->n_init_sections, sec); | |
461 | |||
462 | ✗ | return sec; | |
463 | } | ||
464 | |||
465 | ✗ | static void handle_init_section_args(struct init_section_info *info, const char *key, | |
466 | int key_len, char **dest, int *dest_len) | ||
467 | { | ||
468 | ✗ | if (!strncmp(key, "URI=", key_len)) { | |
469 | ✗ | *dest = info->uri; | |
470 | ✗ | *dest_len = sizeof(info->uri); | |
471 | ✗ | } else if (!strncmp(key, "BYTERANGE=", key_len)) { | |
472 | ✗ | *dest = info->byterange; | |
473 | ✗ | *dest_len = sizeof(info->byterange); | |
474 | } | ||
475 | ✗ | } | |
476 | |||
477 | struct rendition_info { | ||
478 | char type[16]; | ||
479 | char uri[MAX_URL_SIZE]; | ||
480 | char group_id[MAX_FIELD_LEN]; | ||
481 | char language[MAX_FIELD_LEN]; | ||
482 | char assoc_language[MAX_FIELD_LEN]; | ||
483 | char name[MAX_FIELD_LEN]; | ||
484 | char defaultr[4]; | ||
485 | char forced[4]; | ||
486 | char characteristics[MAX_CHARACTERISTICS_LEN]; | ||
487 | }; | ||
488 | |||
489 | ✗ | static struct rendition *new_rendition(HLSContext *c, struct rendition_info *info, | |
490 | const char *url_base) | ||
491 | { | ||
492 | struct rendition *rend; | ||
493 | ✗ | enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN; | |
494 | char *characteristic; | ||
495 | char *chr_ptr; | ||
496 | char *saveptr; | ||
497 | |||
498 | ✗ | if (!strcmp(info->type, "AUDIO")) | |
499 | ✗ | type = AVMEDIA_TYPE_AUDIO; | |
500 | ✗ | else if (!strcmp(info->type, "VIDEO")) | |
501 | ✗ | type = AVMEDIA_TYPE_VIDEO; | |
502 | ✗ | else if (!strcmp(info->type, "SUBTITLES")) | |
503 | ✗ | type = AVMEDIA_TYPE_SUBTITLE; | |
504 | ✗ | else if (!strcmp(info->type, "CLOSED-CAPTIONS")) | |
505 | /* CLOSED-CAPTIONS is ignored since we do not support CEA-608 CC in | ||
506 | * AVC SEI RBSP anyway */ | ||
507 | ✗ | return NULL; | |
508 | |||
509 | ✗ | if (type == AVMEDIA_TYPE_UNKNOWN) { | |
510 | ✗ | av_log(c->ctx, AV_LOG_WARNING, "Can't support the type: %s\n", info->type); | |
511 | ✗ | return NULL; | |
512 | } | ||
513 | |||
514 | /* URI is mandatory for subtitles as per spec */ | ||
515 | ✗ | if (type == AVMEDIA_TYPE_SUBTITLE && !info->uri[0]) { | |
516 | ✗ | av_log(c->ctx, AV_LOG_ERROR, "The URI tag is REQUIRED for subtitle.\n"); | |
517 | ✗ | return NULL; | |
518 | } | ||
519 | |||
520 | ✗ | rend = av_mallocz(sizeof(struct rendition)); | |
521 | ✗ | if (!rend) | |
522 | ✗ | return NULL; | |
523 | |||
524 | ✗ | dynarray_add(&c->renditions, &c->n_renditions, rend); | |
525 | |||
526 | ✗ | rend->type = type; | |
527 | ✗ | strcpy(rend->group_id, info->group_id); | |
528 | ✗ | strcpy(rend->language, info->language); | |
529 | ✗ | strcpy(rend->name, info->name); | |
530 | |||
531 | /* add the playlist if this is an external rendition */ | ||
532 | ✗ | if (info->uri[0]) { | |
533 | ✗ | rend->playlist = new_playlist(c, info->uri, url_base); | |
534 | ✗ | if (rend->playlist) { | |
535 | ✗ | if (type == AVMEDIA_TYPE_SUBTITLE) { | |
536 | ✗ | rend->playlist->is_subtitle = 1; | |
537 | ✗ | rend->playlist->is_id3_timestamped = 0; | |
538 | } | ||
539 | ✗ | dynarray_add(&rend->playlist->renditions, | |
540 | &rend->playlist->n_renditions, rend); | ||
541 | } | ||
542 | } | ||
543 | |||
544 | ✗ | if (info->assoc_language[0]) { | |
545 | ✗ | size_t langlen = strlen(rend->language); | |
546 | ✗ | if (langlen < sizeof(rend->language) - 3) { | |
547 | size_t assoc_len; | ||
548 | ✗ | rend->language[langlen] = ','; | |
549 | ✗ | assoc_len = av_strlcpy(rend->language + langlen + 1, | |
550 | ✗ | info->assoc_language, | |
551 | sizeof(rend->language) - langlen - 1); | ||
552 | ✗ | if (langlen + assoc_len + 2 > sizeof(rend->language)) // truncation occurred | |
553 | ✗ | av_log(c->ctx, AV_LOG_WARNING, "Truncated rendition language: %s\n", | |
554 | ✗ | info->assoc_language); | |
555 | } | ||
556 | } | ||
557 | |||
558 | ✗ | if (!strcmp(info->defaultr, "YES")) | |
559 | ✗ | rend->disposition |= AV_DISPOSITION_DEFAULT; | |
560 | ✗ | if (!strcmp(info->forced, "YES")) | |
561 | ✗ | rend->disposition |= AV_DISPOSITION_FORCED; | |
562 | |||
563 | ✗ | chr_ptr = info->characteristics; | |
564 | ✗ | while ((characteristic = av_strtok(chr_ptr, ",", &saveptr))) { | |
565 | ✗ | if (!strcmp(characteristic, "public.accessibility.describes-music-and-sound")) | |
566 | ✗ | rend->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; | |
567 | ✗ | else if (!strcmp(characteristic, "public.accessibility.describes-video")) | |
568 | ✗ | rend->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; | |
569 | |||
570 | ✗ | chr_ptr = NULL; | |
571 | } | ||
572 | |||
573 | ✗ | return rend; | |
574 | } | ||
575 | |||
576 | ✗ | static void handle_rendition_args(struct rendition_info *info, const char *key, | |
577 | int key_len, char **dest, int *dest_len) | ||
578 | { | ||
579 | ✗ | if (!strncmp(key, "TYPE=", key_len)) { | |
580 | ✗ | *dest = info->type; | |
581 | ✗ | *dest_len = sizeof(info->type); | |
582 | ✗ | } else if (!strncmp(key, "URI=", key_len)) { | |
583 | ✗ | *dest = info->uri; | |
584 | ✗ | *dest_len = sizeof(info->uri); | |
585 | ✗ | } else if (!strncmp(key, "GROUP-ID=", key_len)) { | |
586 | ✗ | *dest = info->group_id; | |
587 | ✗ | *dest_len = sizeof(info->group_id); | |
588 | ✗ | } else if (!strncmp(key, "LANGUAGE=", key_len)) { | |
589 | ✗ | *dest = info->language; | |
590 | ✗ | *dest_len = sizeof(info->language); | |
591 | ✗ | } else if (!strncmp(key, "ASSOC-LANGUAGE=", key_len)) { | |
592 | ✗ | *dest = info->assoc_language; | |
593 | ✗ | *dest_len = sizeof(info->assoc_language); | |
594 | ✗ | } else if (!strncmp(key, "NAME=", key_len)) { | |
595 | ✗ | *dest = info->name; | |
596 | ✗ | *dest_len = sizeof(info->name); | |
597 | ✗ | } else if (!strncmp(key, "DEFAULT=", key_len)) { | |
598 | ✗ | *dest = info->defaultr; | |
599 | ✗ | *dest_len = sizeof(info->defaultr); | |
600 | ✗ | } else if (!strncmp(key, "FORCED=", key_len)) { | |
601 | ✗ | *dest = info->forced; | |
602 | ✗ | *dest_len = sizeof(info->forced); | |
603 | ✗ | } else if (!strncmp(key, "CHARACTERISTICS=", key_len)) { | |
604 | ✗ | *dest = info->characteristics; | |
605 | ✗ | *dest_len = sizeof(info->characteristics); | |
606 | } | ||
607 | /* | ||
608 | * ignored: | ||
609 | * - AUTOSELECT: client may autoselect based on e.g. system language | ||
610 | * - INSTREAM-ID: EIA-608 closed caption number ("CC1".."CC4") | ||
611 | */ | ||
612 | ✗ | } | |
613 | |||
614 | /* used by parse_playlist to allocate a new variant+playlist when the | ||
615 | * playlist is detected to be a Media Playlist (not Master Playlist) | ||
616 | * and we have no parent Master Playlist (parsing of which would have | ||
617 | * allocated the variant and playlist already) | ||
618 | * *pls == NULL => Master Playlist or parentless Media Playlist | ||
619 | * *pls != NULL => parented Media Playlist, playlist+variant allocated */ | ||
620 | 89 | static int ensure_playlist(HLSContext *c, struct playlist **pls, const char *url) | |
621 | { | ||
622 |
2/2✓ Branch 0 taken 77 times.
✓ Branch 1 taken 12 times.
|
89 | if (*pls) |
623 | 77 | return 0; | |
624 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
|
12 | if (!new_variant(c, NULL, url, NULL)) |
625 | ✗ | return AVERROR(ENOMEM); | |
626 | 12 | *pls = c->playlists[c->n_playlists - 1]; | |
627 | 12 | return 0; | |
628 | } | ||
629 | |||
630 | ✗ | static int open_url_keepalive(AVFormatContext *s, AVIOContext **pb, | |
631 | const char *url, AVDictionary **options) | ||
632 | { | ||
633 | #if !CONFIG_HTTP_PROTOCOL | ||
634 | return AVERROR_PROTOCOL_NOT_FOUND; | ||
635 | #else | ||
636 | int ret; | ||
637 | ✗ | URLContext *uc = ffio_geturlcontext(*pb); | |
638 | ✗ | av_assert0(uc); | |
639 | ✗ | (*pb)->eof_reached = 0; | |
640 | ✗ | ret = ff_http_do_new_request2(uc, url, options); | |
641 | ✗ | if (ret < 0) { | |
642 | ✗ | ff_format_io_close(s, pb); | |
643 | } | ||
644 | ✗ | return ret; | |
645 | #endif | ||
646 | } | ||
647 | |||
648 | 61 | static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url, | |
649 | AVDictionary **opts, AVDictionary *opts2, int *is_http_out) | ||
650 | { | ||
651 | 61 | HLSContext *c = s->priv_data; | |
652 | 61 | AVDictionary *tmp = NULL; | |
653 | 61 | const char *proto_name = NULL; | |
654 | int ret; | ||
655 | 61 | int is_http = 0; | |
656 | |||
657 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 61 times.
|
61 | if (av_strstart(url, "crypto", NULL)) { |
658 | ✗ | if (url[6] == '+' || url[6] == ':') | |
659 | ✗ | proto_name = avio_find_protocol_name(url + 7); | |
660 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 61 times.
|
61 | } else if (av_strstart(url, "data", NULL)) { |
661 | ✗ | if (url[4] == '+' || url[4] == ':') | |
662 | ✗ | proto_name = avio_find_protocol_name(url + 5); | |
663 | } | ||
664 | |||
665 |
1/2✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
|
61 | if (!proto_name) |
666 | 61 | proto_name = avio_find_protocol_name(url); | |
667 | |||
668 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | if (!proto_name) |
669 | ✗ | return AVERROR_INVALIDDATA; | |
670 | |||
671 | // only http(s) & file are allowed | ||
672 |
1/2✓ Branch 1 taken 61 times.
✗ Branch 2 not taken.
|
61 | if (av_strstart(proto_name, "file", NULL)) { |
673 |
2/4✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 61 times.
|
61 | if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url, c->allowed_extensions)) { |
674 | ✗ | av_log(s, AV_LOG_ERROR, | |
675 | "Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n" | ||
676 | "If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n", | ||
677 | url); | ||
678 | ✗ | return AVERROR_INVALIDDATA; | |
679 | } | ||
680 | ✗ | } else if (av_strstart(proto_name, "http", NULL)) { | |
681 | ✗ | is_http = 1; | |
682 | ✗ | } else if (av_strstart(proto_name, "data", NULL)) { | |
683 | ; | ||
684 | } else | ||
685 | ✗ | return AVERROR_INVALIDDATA; | |
686 | |||
687 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
61 | if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] == ':') |
688 | ; | ||
689 |
1/6✗ Branch 1 not taken.
✓ Branch 2 taken 61 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
|
61 | else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':') |
690 | ; | ||
691 |
1/6✗ Branch 1 not taken.
✓ Branch 2 taken 61 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
|
61 | else if (av_strstart(url, "data", NULL) && !strncmp(proto_name, url + 5, strlen(proto_name)) && url[5 + strlen(proto_name)] == ':') |
692 | ; | ||
693 |
2/4✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 61 times.
|
61 | else if (strcmp(proto_name, "file") || !strncmp(url, "file,", 5)) |
694 | ✗ | return AVERROR_INVALIDDATA; | |
695 | |||
696 | 61 | av_dict_copy(&tmp, *opts, 0); | |
697 | 61 | av_dict_copy(&tmp, opts2, 0); | |
698 | |||
699 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
61 | if (is_http && c->http_persistent && *pb) { |
700 | ✗ | ret = open_url_keepalive(c->ctx, pb, url, &tmp); | |
701 | ✗ | if (ret == AVERROR_EXIT) { | |
702 | ✗ | av_dict_free(&tmp); | |
703 | ✗ | return ret; | |
704 | ✗ | } else if (ret < 0) { | |
705 | ✗ | if (ret != AVERROR_EOF) | |
706 | ✗ | av_log(s, AV_LOG_WARNING, | |
707 | "keepalive request failed for '%s' with error: '%s' when opening url, retrying with new connection\n", | ||
708 | ✗ | url, av_err2str(ret)); | |
709 | ✗ | av_dict_copy(&tmp, *opts, 0); | |
710 | ✗ | av_dict_copy(&tmp, opts2, 0); | |
711 | ✗ | ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp); | |
712 | } | ||
713 | } else { | ||
714 | 61 | ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp); | |
715 | } | ||
716 |
1/2✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
|
61 | if (ret >= 0) { |
717 | // update cookies on http response with setcookies. | ||
718 | 61 | char *new_cookies = NULL; | |
719 | |||
720 |
1/2✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
|
61 | if (!(s->flags & AVFMT_FLAG_CUSTOM_IO)) |
721 | 61 | av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies); | |
722 | |||
723 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | if (new_cookies) |
724 | ✗ | av_dict_set(opts, "cookies", new_cookies, AV_DICT_DONT_STRDUP_VAL); | |
725 | } | ||
726 | |||
727 | 61 | av_dict_free(&tmp); | |
728 | |||
729 |
1/2✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
|
61 | if (is_http_out) |
730 | 61 | *is_http_out = is_http; | |
731 | |||
732 | 61 | return ret; | |
733 | } | ||
734 | |||
735 | 130 | static int test_segment(AVFormatContext *s, const AVInputFormat *in_fmt, struct playlist *pls, struct segment *seg) | |
736 | { | ||
737 | 130 | HLSContext *c = s->priv_data; | |
738 | 130 | int matchA = 3; | |
739 | 130 | int matchF = 0; | |
740 | |||
741 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 130 times.
|
130 | if (!c->extension_picky) |
742 | ✗ | return 0; | |
743 | |||
744 |
1/2✓ Branch 0 taken 130 times.
✗ Branch 1 not taken.
|
130 | if (strcmp(c->allowed_segment_extensions, "ALL")) |
745 | 260 | matchA = av_match_ext (seg->url, c->allowed_segment_extensions) | |
746 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 130 times.
|
130 | + 2*(ff_match_url_ext(seg->url, c->allowed_segment_extensions) > 0); |
747 | |||
748 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 130 times.
|
130 | if (!matchA) { |
749 | ✗ | av_log(s, AV_LOG_ERROR, "URL %s is not in allowed_segment_extensions, consider updating hls.c and submitting a patch to ffmpeg-devel, if this should be added\n", seg->url); | |
750 | ✗ | return AVERROR_INVALIDDATA; | |
751 | } | ||
752 | |||
753 |
2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 65 times.
|
130 | if (in_fmt) { |
754 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 62 times.
|
65 | if (in_fmt->extensions) { |
755 | 3 | matchF = av_match_ext( seg->url, in_fmt->extensions) | |
756 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
|
3 | + 2*(ff_match_url_ext(seg->url, in_fmt->extensions) > 0); |
757 | // Youtube uses aac files with .ts extension | ||
758 |
2/4✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3 times.
|
3 | if(av_match_name("mp4", in_fmt->name) || av_match_name("aac", in_fmt->name)) { |
759 | ✗ | matchF |= av_match_ext( seg->url, "ts,m2t,m2ts,mts,mpg,m4s,mpeg,mpegts") | |
760 | ✗ | + 2*(ff_match_url_ext(seg->url, "ts,m2t,m2ts,mts,mpg,m4s,mpeg,mpegts") > 0); | |
761 | } | ||
762 |
1/2✓ Branch 0 taken 62 times.
✗ Branch 1 not taken.
|
62 | } else if (!strcmp(in_fmt->name, "mpegts")) { |
763 | 62 | const char *str = "ts,m2t,m2ts,mts,mpg,m4s,mpeg,mpegts" | |
764 | ",html" // https://flash1.bogulus.cfd/ | ||
765 | ; | ||
766 | 124 | matchF = av_match_ext( seg->url, str) | |
767 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 62 times.
|
62 | + 2*(ff_match_url_ext(seg->url, str) > 0); |
768 | ✗ | } else if (!strcmp(in_fmt->name, "webvtt")) { | |
769 | ✗ | matchF = av_match_ext( seg->url, "vtt,webvtt") | |
770 | ✗ | + 2*(ff_match_url_ext(seg->url, "vtt,webvtt") > 0); | |
771 | } | ||
772 | |||
773 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (!(matchA & matchF)) { |
774 | ✗ | av_log(s, AV_LOG_ERROR, "detected format %s extension %s mismatches allowed extensions in url %s\n", in_fmt->name, in_fmt->extensions ? in_fmt->extensions : "none", seg->url); | |
775 | ✗ | return AVERROR_INVALIDDATA; | |
776 | } | ||
777 | } | ||
778 | |||
779 | 130 | return 0; | |
780 | } | ||
781 | |||
782 | 12 | static int parse_playlist(HLSContext *c, const char *url, | |
783 | struct playlist *pls, AVIOContext *in) | ||
784 | { | ||
785 | 12 | int ret = 0, is_segment = 0, is_variant = 0; | |
786 | 12 | int64_t duration = 0; | |
787 | 12 | enum KeyType key_type = KEY_NONE; | |
788 | 12 | uint8_t iv[16] = ""; | |
789 | 12 | int has_iv = 0; | |
790 | 12 | char key[MAX_URL_SIZE] = ""; | |
791 | char line[MAX_URL_SIZE]; | ||
792 | const char *ptr; | ||
793 | 12 | int close_in = 0; | |
794 | 12 | int64_t seg_offset = 0; | |
795 | 12 | int64_t seg_size = -1; | |
796 | 12 | uint8_t *new_url = NULL; | |
797 | struct variant_info variant_info; | ||
798 | char tmp_str[MAX_URL_SIZE]; | ||
799 | 12 | struct segment *cur_init_section = NULL; | |
800 | 12 | int is_http = av_strstart(url, "http", NULL); | |
801 | 12 | struct segment **prev_segments = NULL; | |
802 | 12 | int prev_n_segments = 0; | |
803 | 12 | int64_t prev_start_seq_no = -1; | |
804 | |||
805 |
1/8✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
12 | if (is_http && !in && c->http_persistent && c->playlist_pb) { |
806 | ✗ | in = c->playlist_pb; | |
807 | ✗ | ret = open_url_keepalive(c->ctx, &c->playlist_pb, url, NULL); | |
808 | ✗ | if (ret == AVERROR_EXIT) { | |
809 | ✗ | return ret; | |
810 | ✗ | } else if (ret < 0) { | |
811 | ✗ | if (ret != AVERROR_EOF) | |
812 | ✗ | av_log(c->ctx, AV_LOG_WARNING, | |
813 | "keepalive request failed for '%s' with error: '%s' when parsing playlist\n", | ||
814 | ✗ | url, av_err2str(ret)); | |
815 | ✗ | in = NULL; | |
816 | } | ||
817 | } | ||
818 | |||
819 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!in) { |
820 | ✗ | AVDictionary *opts = NULL; | |
821 | ✗ | av_dict_copy(&opts, c->avio_opts, 0); | |
822 | |||
823 | ✗ | if (c->http_persistent) | |
824 | ✗ | av_dict_set(&opts, "multiple_requests", "1", 0); | |
825 | |||
826 | ✗ | ret = c->ctx->io_open(c->ctx, &in, url, AVIO_FLAG_READ, &opts); | |
827 | ✗ | av_dict_free(&opts); | |
828 | ✗ | if (ret < 0) | |
829 | ✗ | return ret; | |
830 | |||
831 | ✗ | if (is_http && c->http_persistent) | |
832 | ✗ | c->playlist_pb = in; | |
833 | else | ||
834 | ✗ | close_in = 1; | |
835 | } | ||
836 | |||
837 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
|
12 | if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, &new_url) >= 0) |
838 | ✗ | url = new_url; | |
839 | |||
840 | 12 | ff_get_chomp_line(in, line, sizeof(line)); | |
841 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (strcmp(line, "#EXTM3U")) { |
842 | ✗ | ret = AVERROR_INVALIDDATA; | |
843 | ✗ | goto fail; | |
844 | } | ||
845 | |||
846 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls) { |
847 | ✗ | prev_start_seq_no = pls->start_seq_no; | |
848 | ✗ | prev_segments = pls->segments; | |
849 | ✗ | prev_n_segments = pls->n_segments; | |
850 | ✗ | pls->segments = NULL; | |
851 | ✗ | pls->n_segments = 0; | |
852 | |||
853 | ✗ | pls->finished = 0; | |
854 | ✗ | pls->type = PLS_TYPE_UNSPECIFIED; | |
855 | } | ||
856 |
2/2✓ Branch 1 taken 213 times.
✓ Branch 2 taken 12 times.
|
225 | while (!avio_feof(in)) { |
857 | 213 | ff_get_chomp_line(in, line, sizeof(line)); | |
858 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 213 times.
|
213 | if (av_strstart(line, "#EXT-X-STREAM-INF:", &ptr)) { |
859 | ✗ | is_variant = 1; | |
860 | ✗ | memset(&variant_info, 0, sizeof(variant_info)); | |
861 | ✗ | ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_variant_args, | |
862 | &variant_info); | ||
863 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 213 times.
|
213 | } else if (av_strstart(line, "#EXT-X-KEY:", &ptr)) { |
864 | ✗ | struct key_info info = {{0}}; | |
865 | ✗ | ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_key_args, | |
866 | &info); | ||
867 | ✗ | key_type = KEY_NONE; | |
868 | ✗ | has_iv = 0; | |
869 | ✗ | if (!strcmp(info.method, "AES-128")) | |
870 | ✗ | key_type = KEY_AES_128; | |
871 | ✗ | if (!strcmp(info.method, "SAMPLE-AES")) | |
872 | ✗ | key_type = KEY_SAMPLE_AES; | |
873 | ✗ | if (!av_strncasecmp(info.iv, "0x", 2)) { | |
874 | ✗ | ff_hex_to_data(iv, info.iv + 2); | |
875 | ✗ | has_iv = 1; | |
876 | } | ||
877 | ✗ | av_strlcpy(key, info.uri, sizeof(key)); | |
878 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 213 times.
|
213 | } else if (av_strstart(line, "#EXT-X-MEDIA:", &ptr)) { |
879 | ✗ | struct rendition_info info = {{0}}; | |
880 | ✗ | ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_rendition_args, | |
881 | &info); | ||
882 | ✗ | new_rendition(c, &info, url); | |
883 |
2/2✓ Branch 1 taken 12 times.
✓ Branch 2 taken 201 times.
|
213 | } else if (av_strstart(line, "#EXT-X-TARGETDURATION:", &ptr)) { |
884 | int64_t t; | ||
885 | 12 | ret = ensure_playlist(c, &pls, url); | |
886 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (ret < 0) |
887 | ✗ | goto fail; | |
888 | 12 | t = strtoll(ptr, NULL, 10); | |
889 |
2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
|
12 | if (t < 0 || t >= INT64_MAX / AV_TIME_BASE) { |
890 | ✗ | ret = AVERROR_INVALIDDATA; | |
891 | ✗ | goto fail; | |
892 | } | ||
893 | 12 | pls->target_duration = t * AV_TIME_BASE; | |
894 |
2/2✓ Branch 1 taken 12 times.
✓ Branch 2 taken 189 times.
|
201 | } else if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) { |
895 | uint64_t seq_no; | ||
896 | 12 | ret = ensure_playlist(c, &pls, url); | |
897 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (ret < 0) |
898 | ✗ | goto fail; | |
899 | 12 | seq_no = strtoull(ptr, NULL, 10); | |
900 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (seq_no > INT64_MAX/2) { |
901 | ✗ | av_log(c->ctx, AV_LOG_DEBUG, "MEDIA-SEQUENCE higher than " | |
902 | "INT64_MAX/2, mask out the highest bit\n"); | ||
903 | ✗ | seq_no &= INT64_MAX/2; | |
904 | } | ||
905 | 12 | pls->start_seq_no = seq_no; | |
906 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 189 times.
|
189 | } else if (av_strstart(line, "#EXT-X-PLAYLIST-TYPE:", &ptr)) { |
907 | ✗ | ret = ensure_playlist(c, &pls, url); | |
908 | ✗ | if (ret < 0) | |
909 | ✗ | goto fail; | |
910 | ✗ | if (!strcmp(ptr, "EVENT")) | |
911 | ✗ | pls->type = PLS_TYPE_EVENT; | |
912 | ✗ | else if (!strcmp(ptr, "VOD")) | |
913 | ✗ | pls->type = PLS_TYPE_VOD; | |
914 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 189 times.
|
189 | } else if (av_strstart(line, "#EXT-X-MAP:", &ptr)) { |
915 | ✗ | struct init_section_info info = {{0}}; | |
916 | ✗ | ret = ensure_playlist(c, &pls, url); | |
917 | ✗ | if (ret < 0) | |
918 | ✗ | goto fail; | |
919 | ✗ | ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_init_section_args, | |
920 | &info); | ||
921 | ✗ | cur_init_section = new_init_section(pls, &info, url); | |
922 | ✗ | if (!cur_init_section) { | |
923 | ✗ | ret = AVERROR(ENOMEM); | |
924 | ✗ | goto fail; | |
925 | } | ||
926 | ✗ | cur_init_section->key_type = key_type; | |
927 | ✗ | if (has_iv) { | |
928 | ✗ | memcpy(cur_init_section->iv, iv, sizeof(iv)); | |
929 | } else { | ||
930 | ✗ | int64_t seq = pls->start_seq_no + pls->n_segments; | |
931 | ✗ | memset(cur_init_section->iv, 0, sizeof(cur_init_section->iv)); | |
932 | ✗ | AV_WB64(cur_init_section->iv + 8, seq); | |
933 | } | ||
934 | |||
935 | ✗ | if (key_type != KEY_NONE) { | |
936 | ✗ | ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, key); | |
937 | ✗ | if (!tmp_str[0]) { | |
938 | ✗ | av_free(cur_init_section); | |
939 | ✗ | ret = AVERROR_INVALIDDATA; | |
940 | ✗ | goto fail; | |
941 | } | ||
942 | ✗ | cur_init_section->key = av_strdup(tmp_str); | |
943 | ✗ | if (!cur_init_section->key) { | |
944 | ✗ | av_free(cur_init_section); | |
945 | ✗ | ret = AVERROR(ENOMEM); | |
946 | ✗ | goto fail; | |
947 | } | ||
948 | } else { | ||
949 | ✗ | cur_init_section->key = NULL; | |
950 | } | ||
951 | |||
952 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 189 times.
|
189 | } else if (av_strstart(line, "#EXT-X-START:", &ptr)) { |
953 | ✗ | const char *time_offset_value = NULL; | |
954 | ✗ | ret = ensure_playlist(c, &pls, url); | |
955 | ✗ | if (ret < 0) { | |
956 | ✗ | goto fail; | |
957 | } | ||
958 | ✗ | if (av_strstart(ptr, "TIME-OFFSET=", &time_offset_value)) { | |
959 | ✗ | float offset = strtof(time_offset_value, NULL); | |
960 | ✗ | pls->start_time_offset = offset * AV_TIME_BASE; | |
961 | ✗ | pls->time_offset_flag = 1; | |
962 | } else { | ||
963 | ✗ | av_log(c->ctx, AV_LOG_WARNING, "#EXT-X-START value is" | |
964 | "invalid, it will be ignored"); | ||
965 | ✗ | continue; | |
966 | } | ||
967 |
2/2✓ Branch 1 taken 11 times.
✓ Branch 2 taken 178 times.
|
189 | } else if (av_strstart(line, "#EXT-X-ENDLIST", &ptr)) { |
968 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | if (pls) |
969 | 11 | pls->finished = 1; | |
970 |
2/2✓ Branch 1 taken 65 times.
✓ Branch 2 taken 113 times.
|
178 | } else if (av_strstart(line, "#EXTINF:", &ptr)) { |
971 | 65 | is_segment = 1; | |
972 | 65 | duration = atof(ptr) * AV_TIME_BASE; | |
973 |
2/2✓ Branch 1 taken 20 times.
✓ Branch 2 taken 93 times.
|
113 | } else if (av_strstart(line, "#EXT-X-BYTERANGE:", &ptr)) { |
974 | 20 | seg_size = strtoll(ptr, NULL, 10); | |
975 | 20 | ptr = strchr(ptr, '@'); | |
976 |
1/2✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.
|
20 | if (ptr) |
977 | 20 | seg_offset = strtoll(ptr+1, NULL, 10); | |
978 |
2/2✓ Branch 1 taken 16 times.
✓ Branch 2 taken 77 times.
|
93 | } else if (av_strstart(line, "#", NULL)) { |
979 | 16 | av_log(c->ctx, AV_LOG_VERBOSE, "Skip ('%s')\n", line); | |
980 | 16 | continue; | |
981 |
2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 12 times.
|
77 | } else if (line[0]) { |
982 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (is_variant) { |
983 | ✗ | if (!new_variant(c, &variant_info, line, url)) { | |
984 | ✗ | ret = AVERROR(ENOMEM); | |
985 | ✗ | goto fail; | |
986 | } | ||
987 | ✗ | is_variant = 0; | |
988 | } | ||
989 |
1/2✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
|
65 | if (is_segment) { |
990 | struct segment *seg; | ||
991 | 65 | ret = ensure_playlist(c, &pls, url); | |
992 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (ret < 0) |
993 | ✗ | goto fail; | |
994 | 65 | seg = av_malloc(sizeof(struct segment)); | |
995 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (!seg) { |
996 | ✗ | ret = AVERROR(ENOMEM); | |
997 | ✗ | goto fail; | |
998 | } | ||
999 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (has_iv) { |
1000 | ✗ | memcpy(seg->iv, iv, sizeof(iv)); | |
1001 | } else { | ||
1002 | 65 | uint64_t seq = pls->start_seq_no + (uint64_t)pls->n_segments; | |
1003 | 65 | memset(seg->iv, 0, sizeof(seg->iv)); | |
1004 | 65 | AV_WB64(seg->iv + 8, seq); | |
1005 | } | ||
1006 | |||
1007 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (key_type != KEY_NONE) { |
1008 | ✗ | ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, key); | |
1009 | ✗ | if (!tmp_str[0]) { | |
1010 | ✗ | ret = AVERROR_INVALIDDATA; | |
1011 | ✗ | av_free(seg); | |
1012 | ✗ | goto fail; | |
1013 | } | ||
1014 | ✗ | seg->key = av_strdup(tmp_str); | |
1015 | ✗ | if (!seg->key) { | |
1016 | ✗ | av_free(seg); | |
1017 | ✗ | ret = AVERROR(ENOMEM); | |
1018 | ✗ | goto fail; | |
1019 | } | ||
1020 | } else { | ||
1021 | 65 | seg->key = NULL; | |
1022 | } | ||
1023 | |||
1024 | 65 | ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, line); | |
1025 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (!tmp_str[0]) { |
1026 | ✗ | ret = AVERROR_INVALIDDATA; | |
1027 | ✗ | if (seg->key) | |
1028 | ✗ | av_free(seg->key); | |
1029 | ✗ | av_free(seg); | |
1030 | ✗ | goto fail; | |
1031 | } | ||
1032 | 65 | seg->url = av_strdup(tmp_str); | |
1033 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (!seg->url) { |
1034 | ✗ | av_free(seg->key); | |
1035 | ✗ | av_free(seg); | |
1036 | ✗ | ret = AVERROR(ENOMEM); | |
1037 | ✗ | goto fail; | |
1038 | } | ||
1039 | |||
1040 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | ret = test_segment(c->ctx, pls->ctx ? pls->ctx->iformat : NULL, pls, seg); |
1041 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (ret < 0) { |
1042 | ✗ | av_free(seg->url); | |
1043 | ✗ | av_free(seg->key); | |
1044 | ✗ | av_free(seg); | |
1045 | ✗ | goto fail; | |
1046 | } | ||
1047 | |||
1048 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (duration < 0.001 * AV_TIME_BASE) { |
1049 | ✗ | av_log(c->ctx, AV_LOG_WARNING, "Cannot get correct #EXTINF value of segment %s," | |
1050 | " set to default value to 1ms.\n", seg->url); | ||
1051 | ✗ | duration = 0.001 * AV_TIME_BASE; | |
1052 | } | ||
1053 | 65 | seg->duration = duration; | |
1054 | 65 | seg->key_type = key_type; | |
1055 | 65 | dynarray_add(&pls->segments, &pls->n_segments, seg); | |
1056 | 65 | is_segment = 0; | |
1057 | |||
1058 | 65 | seg->size = seg_size; | |
1059 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 45 times.
|
65 | if (seg_size >= 0) { |
1060 | 20 | seg->url_offset = seg_offset; | |
1061 | 20 | seg_offset += seg_size; | |
1062 | 20 | seg_size = -1; | |
1063 | } else { | ||
1064 | 45 | seg->url_offset = 0; | |
1065 | 45 | seg_offset = 0; | |
1066 | } | ||
1067 | |||
1068 | 65 | seg->init_section = cur_init_section; | |
1069 | } | ||
1070 | } | ||
1071 | } | ||
1072 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (prev_segments) { |
1073 | ✗ | if (pls->start_seq_no > prev_start_seq_no && c->first_timestamp != AV_NOPTS_VALUE) { | |
1074 | ✗ | int64_t prev_timestamp = c->first_timestamp; | |
1075 | int i; | ||
1076 | ✗ | int64_t diff = pls->start_seq_no - prev_start_seq_no; | |
1077 | ✗ | for (i = 0; i < prev_n_segments && i < diff; i++) { | |
1078 | ✗ | c->first_timestamp += prev_segments[i]->duration; | |
1079 | } | ||
1080 | ✗ | av_log(c->ctx, AV_LOG_DEBUG, "Media sequence change (%"PRId64" -> %"PRId64")" | |
1081 | " reflected in first_timestamp: %"PRId64" -> %"PRId64"\n", | ||
1082 | ✗ | prev_start_seq_no, pls->start_seq_no, | |
1083 | prev_timestamp, c->first_timestamp); | ||
1084 | ✗ | } else if (pls->start_seq_no < prev_start_seq_no) { | |
1085 | ✗ | av_log(c->ctx, AV_LOG_WARNING, "Media sequence changed unexpectedly: %"PRId64" -> %"PRId64"\n", | |
1086 | ✗ | prev_start_seq_no, pls->start_seq_no); | |
1087 | } | ||
1088 | ✗ | free_segment_dynarray(prev_segments, prev_n_segments); | |
1089 | ✗ | av_freep(&prev_segments); | |
1090 | } | ||
1091 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls) |
1092 | 12 | pls->last_load_time = av_gettime_relative(); | |
1093 | |||
1094 | ✗ | fail: | |
1095 | 12 | av_free(new_url); | |
1096 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (close_in) |
1097 | ✗ | ff_format_io_close(c->ctx, &in); | |
1098 | 12 | c->ctx->ctx_flags = c->ctx->ctx_flags & ~(unsigned)AVFMTCTX_UNSEEKABLE; | |
1099 |
2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
|
12 | if (!c->n_variants || !c->variants[0]->n_playlists || |
1100 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 11 times.
|
12 | !(c->variants[0]->playlists[0]->finished || |
1101 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | c->variants[0]->playlists[0]->type == PLS_TYPE_EVENT)) |
1102 | 1 | c->ctx->ctx_flags |= AVFMTCTX_UNSEEKABLE; | |
1103 | 12 | return ret; | |
1104 | } | ||
1105 | |||
1106 | 7137 | static struct segment *current_segment(struct playlist *pls) | |
1107 | { | ||
1108 | 7137 | int64_t n = pls->cur_seq_no - pls->start_seq_no; | |
1109 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 7135 times.
|
7137 | if (n >= pls->n_segments) |
1110 | 2 | return NULL; | |
1111 | 7135 | return pls->segments[n]; | |
1112 | } | ||
1113 | |||
1114 | 366 | static struct segment *next_segment(struct playlist *pls) | |
1115 | { | ||
1116 | 366 | int64_t n = pls->cur_seq_no - pls->start_seq_no + 1; | |
1117 |
2/2✓ Branch 0 taken 72 times.
✓ Branch 1 taken 294 times.
|
366 | if (n >= pls->n_segments) |
1118 | 72 | return NULL; | |
1119 | 294 | return pls->segments[n]; | |
1120 | } | ||
1121 | |||
1122 | 366 | static int read_from_url(struct playlist *pls, struct segment *seg, | |
1123 | uint8_t *buf, int buf_size) | ||
1124 | { | ||
1125 | int ret; | ||
1126 | |||
1127 | /* limit read if the segment was only a part of a file */ | ||
1128 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 266 times.
|
366 | if (seg->size >= 0) |
1129 | 100 | buf_size = FFMIN(buf_size, seg->size - pls->cur_seg_offset); | |
1130 | |||
1131 | 366 | ret = avio_read(pls->input, buf, buf_size); | |
1132 |
2/2✓ Branch 0 taken 307 times.
✓ Branch 1 taken 59 times.
|
366 | if (ret > 0) |
1133 | 307 | pls->cur_seg_offset += ret; | |
1134 | |||
1135 | 366 | return ret; | |
1136 | } | ||
1137 | |||
1138 | /* Parse the raw ID3 data and pass contents to caller */ | ||
1139 | ✗ | static void parse_id3(AVFormatContext *s, AVIOContext *pb, | |
1140 | AVDictionary **metadata, int64_t *dts, HLSAudioSetupInfo *audio_setup_info, | ||
1141 | ID3v2ExtraMetaAPIC **apic, ID3v2ExtraMeta **extra_meta) | ||
1142 | { | ||
1143 | static const char id3_priv_owner_ts[] = "com.apple.streaming.transportStreamTimestamp"; | ||
1144 | static const char id3_priv_owner_audio_setup[] = "com.apple.streaming.audioDescription"; | ||
1145 | ID3v2ExtraMeta *meta; | ||
1146 | |||
1147 | ✗ | ff_id3v2_read_dict(pb, metadata, ID3v2_DEFAULT_MAGIC, extra_meta); | |
1148 | ✗ | for (meta = *extra_meta; meta; meta = meta->next) { | |
1149 | ✗ | if (!strcmp(meta->tag, "PRIV")) { | |
1150 | ✗ | ID3v2ExtraMetaPRIV *priv = &meta->data.priv; | |
1151 | ✗ | if (priv->datasize == 8 && !av_strncasecmp(priv->owner, id3_priv_owner_ts, 44)) { | |
1152 | /* 33-bit MPEG timestamp */ | ||
1153 | ✗ | int64_t ts = AV_RB64(priv->data); | |
1154 | ✗ | av_log(s, AV_LOG_DEBUG, "HLS ID3 audio timestamp %"PRId64"\n", ts); | |
1155 | ✗ | if ((ts & ~((1ULL << 33) - 1)) == 0) | |
1156 | ✗ | *dts = ts; | |
1157 | else | ||
1158 | ✗ | av_log(s, AV_LOG_ERROR, "Invalid HLS ID3 audio timestamp %"PRId64"\n", ts); | |
1159 | ✗ | } else if (priv->datasize >= 8 && !av_strncasecmp(priv->owner, id3_priv_owner_audio_setup, 36)) { | |
1160 | ✗ | ff_hls_senc_read_audio_setup_info(audio_setup_info, priv->data, priv->datasize); | |
1161 | } | ||
1162 | ✗ | } else if (!strcmp(meta->tag, "APIC") && apic) | |
1163 | ✗ | *apic = &meta->data.apic; | |
1164 | } | ||
1165 | ✗ | } | |
1166 | |||
1167 | /* Check if the ID3 metadata contents have changed */ | ||
1168 | ✗ | static int id3_has_changed_values(struct playlist *pls, AVDictionary *metadata, | |
1169 | ID3v2ExtraMetaAPIC *apic) | ||
1170 | { | ||
1171 | ✗ | const AVDictionaryEntry *entry = NULL; | |
1172 | const AVDictionaryEntry *oldentry; | ||
1173 | /* check that no keys have changed values */ | ||
1174 | ✗ | while ((entry = av_dict_iterate(metadata, entry))) { | |
1175 | ✗ | oldentry = av_dict_get(pls->id3_initial, entry->key, NULL, AV_DICT_MATCH_CASE); | |
1176 | ✗ | if (!oldentry || strcmp(oldentry->value, entry->value) != 0) | |
1177 | ✗ | return 1; | |
1178 | } | ||
1179 | |||
1180 | /* check if apic appeared */ | ||
1181 | ✗ | if (apic && (pls->ctx->nb_streams != 2 || !pls->ctx->streams[1]->attached_pic.data)) | |
1182 | ✗ | return 1; | |
1183 | |||
1184 | ✗ | if (apic) { | |
1185 | ✗ | int size = pls->ctx->streams[1]->attached_pic.size; | |
1186 | ✗ | if (size != apic->buf->size - AV_INPUT_BUFFER_PADDING_SIZE) | |
1187 | ✗ | return 1; | |
1188 | |||
1189 | ✗ | if (memcmp(apic->buf->data, pls->ctx->streams[1]->attached_pic.data, size) != 0) | |
1190 | ✗ | return 1; | |
1191 | } | ||
1192 | |||
1193 | ✗ | return 0; | |
1194 | } | ||
1195 | |||
1196 | /* Parse ID3 data and handle the found data */ | ||
1197 | ✗ | static void handle_id3(AVIOContext *pb, struct playlist *pls) | |
1198 | { | ||
1199 | ✗ | AVDictionary *metadata = NULL; | |
1200 | ✗ | ID3v2ExtraMetaAPIC *apic = NULL; | |
1201 | ✗ | ID3v2ExtraMeta *extra_meta = NULL; | |
1202 | ✗ | int64_t timestamp = AV_NOPTS_VALUE; | |
1203 | |||
1204 | ✗ | parse_id3(pls->ctx, pb, &metadata, ×tamp, &pls->audio_setup_info, &apic, &extra_meta); | |
1205 | |||
1206 | ✗ | if (timestamp != AV_NOPTS_VALUE) { | |
1207 | ✗ | pls->id3_mpegts_timestamp = timestamp; | |
1208 | ✗ | pls->id3_offset = 0; | |
1209 | } | ||
1210 | |||
1211 | ✗ | if (!pls->id3_found) { | |
1212 | /* initial ID3 tags */ | ||
1213 | ✗ | av_assert0(!pls->id3_deferred_extra); | |
1214 | ✗ | pls->id3_found = 1; | |
1215 | |||
1216 | /* get picture attachment and set text metadata */ | ||
1217 | ✗ | if (pls->ctx->nb_streams) | |
1218 | ✗ | ff_id3v2_parse_apic(pls->ctx, extra_meta); | |
1219 | else | ||
1220 | /* demuxer not yet opened, defer picture attachment */ | ||
1221 | ✗ | pls->id3_deferred_extra = extra_meta; | |
1222 | |||
1223 | ✗ | ff_id3v2_parse_priv_dict(&metadata, extra_meta); | |
1224 | ✗ | av_dict_copy(&pls->ctx->metadata, metadata, 0); | |
1225 | ✗ | pls->id3_initial = metadata; | |
1226 | |||
1227 | } else { | ||
1228 | ✗ | if (!pls->id3_changed && id3_has_changed_values(pls, metadata, apic)) { | |
1229 | ✗ | avpriv_report_missing_feature(pls->parent, "Changing ID3 metadata in HLS audio elementary stream"); | |
1230 | ✗ | pls->id3_changed = 1; | |
1231 | } | ||
1232 | ✗ | av_dict_free(&metadata); | |
1233 | } | ||
1234 | |||
1235 | ✗ | if (!pls->id3_deferred_extra) | |
1236 | ✗ | ff_id3v2_free_extra_meta(&extra_meta); | |
1237 | ✗ | } | |
1238 | |||
1239 | 12 | static void intercept_id3(struct playlist *pls, uint8_t *buf, | |
1240 | int buf_size, int *len) | ||
1241 | { | ||
1242 | /* intercept id3 tags, we do not want to pass them to the raw | ||
1243 | * demuxer on all segment switches */ | ||
1244 | int bytes; | ||
1245 | 12 | int id3_buf_pos = 0; | |
1246 | 12 | int fill_buf = 0; | |
1247 | 12 | struct segment *seg = current_segment(pls); | |
1248 | |||
1249 | /* gather all the id3 tags */ | ||
1250 | while (1) { | ||
1251 | /* see if we can retrieve enough data for ID3 header */ | ||
1252 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
12 | if (*len < ID3v2_HEADER_SIZE && buf_size >= ID3v2_HEADER_SIZE) { |
1253 | ✗ | bytes = read_from_url(pls, seg, buf + *len, ID3v2_HEADER_SIZE - *len); | |
1254 | ✗ | if (bytes > 0) { | |
1255 | |||
1256 | ✗ | if (bytes == ID3v2_HEADER_SIZE - *len) | |
1257 | /* no EOF yet, so fill the caller buffer again after | ||
1258 | * we have stripped the ID3 tags */ | ||
1259 | ✗ | fill_buf = 1; | |
1260 | |||
1261 | ✗ | *len += bytes; | |
1262 | |||
1263 | ✗ | } else if (*len <= 0) { | |
1264 | /* error/EOF */ | ||
1265 | ✗ | *len = bytes; | |
1266 | ✗ | fill_buf = 0; | |
1267 | } | ||
1268 | } | ||
1269 | |||
1270 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (*len < ID3v2_HEADER_SIZE) |
1271 | ✗ | break; | |
1272 | |||
1273 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
|
12 | if (ff_id3v2_match(buf, ID3v2_DEFAULT_MAGIC)) { |
1274 | ✗ | int64_t maxsize = seg->size >= 0 ? seg->size : 1024*1024; | |
1275 | ✗ | int taglen = ff_id3v2_tag_len(buf); | |
1276 | ✗ | int tag_got_bytes = FFMIN(taglen, *len); | |
1277 | ✗ | int remaining = taglen - tag_got_bytes; | |
1278 | |||
1279 | ✗ | if (taglen > maxsize) { | |
1280 | ✗ | av_log(pls->parent, AV_LOG_ERROR, "Too large HLS ID3 tag (%d > %"PRId64" bytes)\n", | |
1281 | taglen, maxsize); | ||
1282 | ✗ | break; | |
1283 | } | ||
1284 | |||
1285 | /* | ||
1286 | * Copy the id3 tag to our temporary id3 buffer. | ||
1287 | * We could read a small id3 tag directly without memcpy, but | ||
1288 | * we would still need to copy the large tags, and handling | ||
1289 | * both of those cases together with the possibility for multiple | ||
1290 | * tags would make the handling a bit complex. | ||
1291 | */ | ||
1292 | ✗ | pls->id3_buf = av_fast_realloc(pls->id3_buf, &pls->id3_buf_size, id3_buf_pos + taglen); | |
1293 | ✗ | if (!pls->id3_buf) | |
1294 | ✗ | break; | |
1295 | ✗ | memcpy(pls->id3_buf + id3_buf_pos, buf, tag_got_bytes); | |
1296 | ✗ | id3_buf_pos += tag_got_bytes; | |
1297 | |||
1298 | /* strip the intercepted bytes */ | ||
1299 | ✗ | *len -= tag_got_bytes; | |
1300 | ✗ | memmove(buf, buf + tag_got_bytes, *len); | |
1301 | ✗ | av_log(pls->parent, AV_LOG_DEBUG, "Stripped %d HLS ID3 bytes\n", tag_got_bytes); | |
1302 | |||
1303 | ✗ | if (remaining > 0) { | |
1304 | /* read the rest of the tag in */ | ||
1305 | ✗ | if (read_from_url(pls, seg, pls->id3_buf + id3_buf_pos, remaining) != remaining) | |
1306 | ✗ | break; | |
1307 | ✗ | id3_buf_pos += remaining; | |
1308 | ✗ | av_log(pls->parent, AV_LOG_DEBUG, "Stripped additional %d HLS ID3 bytes\n", remaining); | |
1309 | } | ||
1310 | |||
1311 | } else { | ||
1312 | /* no more ID3 tags */ | ||
1313 | 12 | break; | |
1314 | } | ||
1315 | } | ||
1316 | |||
1317 | /* re-fill buffer for the caller unless EOF */ | ||
1318 |
3/6✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 12 times.
|
12 | if (*len >= 0 && (fill_buf || *len == 0)) { |
1319 | ✗ | bytes = read_from_url(pls, seg, buf + *len, buf_size - *len); | |
1320 | |||
1321 | /* ignore error if we already had some data */ | ||
1322 | ✗ | if (bytes >= 0) | |
1323 | ✗ | *len += bytes; | |
1324 | ✗ | else if (*len == 0) | |
1325 | ✗ | *len = bytes; | |
1326 | } | ||
1327 | |||
1328 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls->id3_buf) { |
1329 | /* Now parse all the ID3 tags */ | ||
1330 | FFIOContext id3ioctx; | ||
1331 | ✗ | ffio_init_read_context(&id3ioctx, pls->id3_buf, id3_buf_pos); | |
1332 | ✗ | handle_id3(&id3ioctx.pub, pls); | |
1333 | } | ||
1334 | |||
1335 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (pls->is_id3_timestamped == -1) |
1336 | 12 | pls->is_id3_timestamped = (pls->id3_mpegts_timestamp != AV_NOPTS_VALUE); | |
1337 | 12 | } | |
1338 | |||
1339 | ✗ | static int read_key(HLSContext *c, struct playlist *pls, struct segment *seg) | |
1340 | { | ||
1341 | ✗ | AVIOContext *pb = NULL; | |
1342 | |||
1343 | ✗ | int ret = open_url(pls->parent, &pb, seg->key, &c->avio_opts, NULL, NULL); | |
1344 | ✗ | if (ret < 0) { | |
1345 | ✗ | av_log(pls->parent, AV_LOG_ERROR, "Unable to open key file %s, %s\n", | |
1346 | ✗ | seg->key, av_err2str(ret)); | |
1347 | ✗ | return ret; | |
1348 | } | ||
1349 | |||
1350 | ✗ | ret = avio_read(pb, pls->key, sizeof(pls->key)); | |
1351 | ✗ | ff_format_io_close(pls->parent, &pb); | |
1352 | ✗ | if (ret != sizeof(pls->key)) { | |
1353 | ✗ | if (ret < 0) { | |
1354 | ✗ | av_log(pls->parent, AV_LOG_ERROR, "Unable to read key file %s, %s\n", | |
1355 | ✗ | seg->key, av_err2str(ret)); | |
1356 | } else { | ||
1357 | ✗ | av_log(pls->parent, AV_LOG_ERROR, "Unable to read key file %s, read bytes %d != %zu\n", | |
1358 | seg->key, ret, sizeof(pls->key)); | ||
1359 | ✗ | ret = AVERROR_INVALIDDATA; | |
1360 | } | ||
1361 | |||
1362 | ✗ | return ret; | |
1363 | } | ||
1364 | |||
1365 | ✗ | av_strlcpy(pls->key_url, seg->key, sizeof(pls->key_url)); | |
1366 | |||
1367 | ✗ | return 0; | |
1368 | } | ||
1369 | |||
1370 | 61 | static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, AVIOContext **in) | |
1371 | { | ||
1372 | 61 | AVDictionary *opts = NULL; | |
1373 | int ret; | ||
1374 | 61 | int is_http = 0; | |
1375 | |||
1376 |
1/2✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
|
61 | if (c->http_persistent) |
1377 | 61 | av_dict_set(&opts, "multiple_requests", "1", 0); | |
1378 | |||
1379 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 41 times.
|
61 | if (seg->size >= 0) { |
1380 | /* try to restrict the HTTP request to the part we want | ||
1381 | * (if this is in fact a HTTP request) */ | ||
1382 | 20 | av_dict_set_int(&opts, "offset", seg->url_offset, 0); | |
1383 | 20 | av_dict_set_int(&opts, "end_offset", seg->url_offset + seg->size, 0); | |
1384 | } | ||
1385 | |||
1386 | 61 | av_log(pls->parent, AV_LOG_VERBOSE, "HLS request for url '%s', offset %"PRId64", playlist %d\n", | |
1387 | seg->url, seg->url_offset, pls->index); | ||
1388 | |||
1389 |
2/4✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 61 times.
|
61 | if (seg->key_type == KEY_AES_128 || seg->key_type == KEY_SAMPLE_AES) { |
1390 | ✗ | if (strcmp(seg->key, pls->key_url)) { | |
1391 | ✗ | ret = read_key(c, pls, seg); | |
1392 | ✗ | if (ret < 0) | |
1393 | ✗ | goto cleanup; | |
1394 | } | ||
1395 | } | ||
1396 | |||
1397 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | if (seg->key_type == KEY_AES_128) { |
1398 | char iv[33], key[33], url[MAX_URL_SIZE]; | ||
1399 | ✗ | ff_data_to_hex(iv, seg->iv, sizeof(seg->iv), 0); | |
1400 | ✗ | ff_data_to_hex(key, pls->key, sizeof(pls->key), 0); | |
1401 | ✗ | if (strstr(seg->url, "://")) | |
1402 | ✗ | snprintf(url, sizeof(url), "crypto+%s", seg->url); | |
1403 | else | ||
1404 | ✗ | snprintf(url, sizeof(url), "crypto:%s", seg->url); | |
1405 | |||
1406 | ✗ | av_dict_set(&opts, "key", key, 0); | |
1407 | ✗ | av_dict_set(&opts, "iv", iv, 0); | |
1408 | |||
1409 | ✗ | ret = open_url(pls->parent, in, url, &c->avio_opts, opts, &is_http); | |
1410 | ✗ | if (ret < 0) { | |
1411 | ✗ | goto cleanup; | |
1412 | } | ||
1413 | ✗ | ret = 0; | |
1414 | } else { | ||
1415 | 61 | ret = open_url(pls->parent, in, seg->url, &c->avio_opts, opts, &is_http); | |
1416 | } | ||
1417 | |||
1418 | /* Seek to the requested position. If this was a HTTP request, the offset | ||
1419 | * should already be where want it to, but this allows e.g. local testing | ||
1420 | * without a HTTP server. | ||
1421 | * | ||
1422 | * This is not done for HTTP at all as avio_seek() does internal bookkeeping | ||
1423 | * of file offset which is out-of-sync with the actual offset when "offset" | ||
1424 | * AVOption is used with http protocol, causing the seek to not be a no-op | ||
1425 | * as would be expected. Wrong offset received from the server will not be | ||
1426 | * noticed without the call, though. | ||
1427 | */ | ||
1428 |
4/6✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 61 times.
✓ Branch 4 taken 46 times.
✓ Branch 5 taken 15 times.
|
61 | if (ret == 0 && !is_http && seg->url_offset) { |
1429 | 15 | int64_t seekret = avio_seek(*in, seg->url_offset, SEEK_SET); | |
1430 |
1/2✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
|
15 | if (seekret < 0) { |
1431 | ✗ | av_log(pls->parent, AV_LOG_ERROR, "Unable to seek to offset %"PRId64" of HLS segment '%s'\n", seg->url_offset, seg->url); | |
1432 | ✗ | ret = seekret; | |
1433 | ✗ | ff_format_io_close(pls->parent, in); | |
1434 | } | ||
1435 | } | ||
1436 | |||
1437 | 61 | cleanup: | |
1438 | 61 | av_dict_free(&opts); | |
1439 | 61 | pls->cur_seg_offset = 0; | |
1440 | 61 | return ret; | |
1441 | } | ||
1442 | |||
1443 | 61 | static int update_init_section(struct playlist *pls, struct segment *seg) | |
1444 | { | ||
1445 | static const int max_init_section_size = 1024*1024; | ||
1446 | 61 | HLSContext *c = pls->parent->priv_data; | |
1447 | int64_t sec_size; | ||
1448 | int64_t urlsize; | ||
1449 | int ret; | ||
1450 | |||
1451 |
1/2✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
|
61 | if (seg->init_section == pls->cur_init_section) |
1452 | 61 | return 0; | |
1453 | |||
1454 | ✗ | pls->cur_init_section = NULL; | |
1455 | |||
1456 | ✗ | if (!seg->init_section) | |
1457 | ✗ | return 0; | |
1458 | |||
1459 | ✗ | ret = open_input(c, pls, seg->init_section, &pls->input); | |
1460 | ✗ | if (ret < 0) { | |
1461 | ✗ | av_log(pls->parent, AV_LOG_WARNING, | |
1462 | "Failed to open an initialization section in playlist %d\n", | ||
1463 | pls->index); | ||
1464 | ✗ | return ret; | |
1465 | } | ||
1466 | |||
1467 | ✗ | if (seg->init_section->size >= 0) | |
1468 | ✗ | sec_size = seg->init_section->size; | |
1469 | ✗ | else if ((urlsize = avio_size(pls->input)) >= 0) | |
1470 | ✗ | sec_size = urlsize; | |
1471 | else | ||
1472 | ✗ | sec_size = max_init_section_size; | |
1473 | |||
1474 | ✗ | av_log(pls->parent, AV_LOG_DEBUG, | |
1475 | "Downloading an initialization section of size %"PRId64"\n", | ||
1476 | sec_size); | ||
1477 | |||
1478 | ✗ | sec_size = FFMIN(sec_size, max_init_section_size); | |
1479 | |||
1480 | ✗ | av_fast_malloc(&pls->init_sec_buf, &pls->init_sec_buf_size, sec_size); | |
1481 | |||
1482 | ✗ | ret = read_from_url(pls, seg->init_section, pls->init_sec_buf, | |
1483 | ✗ | pls->init_sec_buf_size); | |
1484 | ✗ | ff_format_io_close(pls->parent, &pls->input); | |
1485 | |||
1486 | ✗ | if (ret < 0) | |
1487 | ✗ | return ret; | |
1488 | |||
1489 | ✗ | pls->cur_init_section = seg->init_section; | |
1490 | ✗ | pls->init_sec_data_len = ret; | |
1491 | ✗ | pls->init_sec_buf_read_offset = 0; | |
1492 | |||
1493 | /* spec says audio elementary streams do not have media initialization | ||
1494 | * sections, so there should be no ID3 timestamps */ | ||
1495 | ✗ | pls->is_id3_timestamped = 0; | |
1496 | |||
1497 | ✗ | return 0; | |
1498 | } | ||
1499 | |||
1500 | 95 | static int64_t default_reload_interval(struct playlist *pls) | |
1501 | { | ||
1502 | 95 | return pls->n_segments > 0 ? | |
1503 |
1/2✓ Branch 0 taken 95 times.
✗ Branch 1 not taken.
|
95 | pls->segments[pls->n_segments - 1]->duration : |
1504 | pls->target_duration; | ||
1505 | } | ||
1506 | |||
1507 | 6863 | static int playlist_needed(struct playlist *pls) | |
1508 | { | ||
1509 | 6863 | AVFormatContext *s = pls->parent; | |
1510 | int i, j; | ||
1511 | 6863 | int stream_needed = 0; | |
1512 | int first_st; | ||
1513 | |||
1514 | /* If there is no context or streams yet, the playlist is needed */ | ||
1515 |
4/6✓ Branch 0 taken 6863 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✓ Branch 3 taken 6839 times.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
|
6863 | if ((!pls->ctx || !pls->n_main_streams) && !pls->is_subtitle) |
1516 | 24 | return 1; | |
1517 | |||
1518 | /* check if any of the streams in the playlist are needed */ | ||
1519 |
1/2✓ Branch 0 taken 6839 times.
✗ Branch 1 not taken.
|
6839 | for (i = 0; i < pls->n_main_streams; i++) { |
1520 |
1/2✓ Branch 0 taken 6839 times.
✗ Branch 1 not taken.
|
6839 | if (pls->main_streams[i]->discard < AVDISCARD_ALL) { |
1521 | 6839 | stream_needed = 1; | |
1522 | 6839 | break; | |
1523 | } | ||
1524 | } | ||
1525 | |||
1526 | /* If all streams in the playlist were discarded, the playlist is not | ||
1527 | * needed (regardless of whether whole programs are discarded or not). */ | ||
1528 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6839 times.
|
6839 | if (!stream_needed) |
1529 | ✗ | return 0; | |
1530 | |||
1531 | /* Otherwise, check if all the programs (variants) this playlist is in are | ||
1532 | * discarded. Since all streams in the playlist are part of the same programs | ||
1533 | * we can just check the programs of the first stream. */ | ||
1534 | |||
1535 | 6839 | first_st = pls->main_streams[0]->index; | |
1536 | |||
1537 |
1/2✓ Branch 0 taken 6839 times.
✗ Branch 1 not taken.
|
6839 | for (i = 0; i < s->nb_programs; i++) { |
1538 | 6839 | AVProgram *program = s->programs[i]; | |
1539 |
1/2✓ Branch 0 taken 6839 times.
✗ Branch 1 not taken.
|
6839 | if (program->discard < AVDISCARD_ALL) { |
1540 |
1/2✓ Branch 0 taken 6839 times.
✗ Branch 1 not taken.
|
6839 | for (j = 0; j < program->nb_stream_indexes; j++) { |
1541 |
1/2✓ Branch 0 taken 6839 times.
✗ Branch 1 not taken.
|
6839 | if (program->stream_index[j] == first_st) { |
1542 | /* playlist is in an undiscarded program */ | ||
1543 | 6839 | return 1; | |
1544 | } | ||
1545 | } | ||
1546 | } | ||
1547 | } | ||
1548 | |||
1549 | /* some streams were not discarded but all the programs were */ | ||
1550 | ✗ | return 0; | |
1551 | } | ||
1552 | |||
1553 | 400 | static int reload_playlist(struct playlist *v, HLSContext *c) | |
1554 | { | ||
1555 | 400 | int ret = 0; | |
1556 | 400 | int reload_count = 0; | |
1557 | |||
1558 | 400 | v->needed = playlist_needed(v); | |
1559 | |||
1560 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
|
400 | if (!v->needed) |
1561 | ✗ | return AVERROR_EOF; | |
1562 | |||
1563 |
4/6✓ Branch 0 taken 305 times.
✓ Branch 1 taken 95 times.
✓ Branch 2 taken 305 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 305 times.
|
400 | if (!v->input || (c->http_persistent && v->input_read_done)) { |
1564 | int64_t reload_interval; | ||
1565 | |||
1566 | /* Check that the playlist is still needed before opening a new | ||
1567 | * segment. */ | ||
1568 | 95 | v->needed = playlist_needed(v); | |
1569 | |||
1570 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 95 times.
|
95 | if (!v->needed) { |
1571 | ✗ | av_log(v->parent, AV_LOG_INFO, "No longer receiving playlist %d ('%s')\n", | |
1572 | ✗ | v->index, v->url); | |
1573 | ✗ | return AVERROR_EOF; | |
1574 | } | ||
1575 | |||
1576 | /* If this is a live stream and the reload interval has elapsed since | ||
1577 | * the last playlist reload, reload the playlists now. */ | ||
1578 | 95 | reload_interval = default_reload_interval(v); | |
1579 | |||
1580 | 95 | reload: | |
1581 | 95 | reload_count++; | |
1582 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 95 times.
|
95 | if (reload_count > c->max_reload) |
1583 | ✗ | return AVERROR_EOF; | |
1584 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 92 times.
|
95 | if (!v->finished && |
1585 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
|
3 | av_gettime_relative() - v->last_load_time >= reload_interval) { |
1586 | ✗ | if ((ret = parse_playlist(c, v->url, v, NULL)) < 0) { | |
1587 | ✗ | if (ret != AVERROR_EXIT) | |
1588 | ✗ | av_log(v->parent, AV_LOG_WARNING, "Failed to reload playlist %d\n", | |
1589 | v->index); | ||
1590 | ✗ | return ret; | |
1591 | } | ||
1592 | /* If we need to reload the playlist again below (if | ||
1593 | * there's still no more segments), switch to a reload | ||
1594 | * interval of half the target duration. */ | ||
1595 | ✗ | reload_interval = v->target_duration / 2; | |
1596 | } | ||
1597 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 95 times.
|
95 | if (v->cur_seq_no < v->start_seq_no) { |
1598 | ✗ | av_log(v->parent, AV_LOG_WARNING, | |
1599 | "skipping %"PRId64" segments ahead, expired from playlists\n", | ||
1600 | ✗ | v->start_seq_no - v->cur_seq_no); | |
1601 | ✗ | v->cur_seq_no = v->start_seq_no; | |
1602 | } | ||
1603 |
2/2✓ Branch 0 taken 63 times.
✓ Branch 1 taken 32 times.
|
95 | if (v->cur_seq_no > v->last_seq_no) { |
1604 | 63 | v->last_seq_no = v->cur_seq_no; | |
1605 | 63 | v->m3u8_hold_counters = 0; | |
1606 |
1/2✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
|
32 | } else if (v->last_seq_no == v->cur_seq_no) { |
1607 | 32 | v->m3u8_hold_counters++; | |
1608 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (v->m3u8_hold_counters >= c->m3u8_hold_counters) { |
1609 | ✗ | return AVERROR_EOF; | |
1610 | } | ||
1611 | } else { | ||
1612 | ✗ | av_log(v->parent, AV_LOG_WARNING, "The m3u8 list sequence may have been wrapped.\n"); | |
1613 | } | ||
1614 |
2/2✓ Branch 0 taken 34 times.
✓ Branch 1 taken 61 times.
|
95 | if (v->cur_seq_no >= v->start_seq_no + v->n_segments) { |
1615 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
34 | if (v->finished || v->is_subtitle) |
1616 | 34 | return AVERROR_EOF; | |
1617 | ✗ | while (av_gettime_relative() - v->last_load_time < reload_interval) { | |
1618 | ✗ | if (ff_check_interrupt(c->interrupt_callback)) | |
1619 | ✗ | return AVERROR_EXIT; | |
1620 | ✗ | av_usleep(100*1000); | |
1621 | } | ||
1622 | /* Enough time has elapsed since the last reload */ | ||
1623 | ✗ | goto reload; | |
1624 | } | ||
1625 | |||
1626 | } | ||
1627 | 366 | return ret; | |
1628 | } | ||
1629 | |||
1630 | 341 | static int read_data_continuous(void *opaque, uint8_t *buf, int buf_size) | |
1631 | { | ||
1632 | 341 | struct playlist *v = opaque; | |
1633 | 341 | HLSContext *c = v->parent->priv_data; | |
1634 | int ret; | ||
1635 | 341 | int just_opened = 0; | |
1636 | 341 | int segment_retries = 0; | |
1637 | struct segment *seg; | ||
1638 | |||
1639 |
2/4✓ Branch 0 taken 341 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 341 times.
|
341 | if (c->http_persistent && v->input_read_done) { |
1640 | ✗ | ret = reload_playlist(v, c); | |
1641 | ✗ | if (ret < 0) | |
1642 | ✗ | return ret; | |
1643 | } | ||
1644 | |||
1645 | 341 | v->input_read_done = 0; | |
1646 | |||
1647 | 59 | restart: | |
1648 | 400 | ret = reload_playlist(v, c); | |
1649 |
2/2✓ Branch 0 taken 34 times.
✓ Branch 1 taken 366 times.
|
400 | if (ret < 0) |
1650 | 34 | return ret; | |
1651 | |||
1652 | 366 | seg = current_segment(v); | |
1653 | |||
1654 |
4/6✓ Branch 0 taken 305 times.
✓ Branch 1 taken 61 times.
✓ Branch 2 taken 305 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 305 times.
|
366 | if (!v->input || (c->http_persistent && v->input_read_done)) { |
1655 | /* load/update Media Initialization Section, if any */ | ||
1656 | 61 | ret = update_init_section(v, seg); | |
1657 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | if (ret) |
1658 | ✗ | return ret; | |
1659 | |||
1660 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
61 | if (c->http_multiple == 1 && v->input_next_requested) { |
1661 | ✗ | FFSWAP(AVIOContext *, v->input, v->input_next); | |
1662 | ✗ | v->cur_seg_offset = 0; | |
1663 | ✗ | v->input_next_requested = 0; | |
1664 | ✗ | ret = 0; | |
1665 | } else { | ||
1666 | 61 | ret = open_input(c, v, seg, &v->input); | |
1667 | } | ||
1668 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | if (ret < 0) { |
1669 | ✗ | if (ff_check_interrupt(c->interrupt_callback)) | |
1670 | ✗ | return AVERROR_EXIT; | |
1671 | ✗ | av_log(v->parent, AV_LOG_WARNING, "Failed to open segment %"PRId64" of playlist %d\n", | |
1672 | v->cur_seq_no, | ||
1673 | v->index); | ||
1674 | ✗ | if (segment_retries >= c->seg_max_retry) { | |
1675 | ✗ | av_log(v->parent, AV_LOG_WARNING, "Segment %"PRId64" of playlist %d failed too many times, skipping\n", | |
1676 | v->cur_seq_no, | ||
1677 | v->index); | ||
1678 | ✗ | v->cur_seq_no++; | |
1679 | ✗ | segment_retries = 0; | |
1680 | } else { | ||
1681 | ✗ | segment_retries++; | |
1682 | } | ||
1683 | ✗ | goto restart; | |
1684 | } | ||
1685 | 61 | segment_retries = 0; | |
1686 | 61 | just_opened = 1; | |
1687 | } | ||
1688 | |||
1689 |
1/2✓ Branch 0 taken 366 times.
✗ Branch 1 not taken.
|
366 | if (c->http_multiple == -1) { |
1690 | 366 | uint8_t *http_version_opt = NULL; | |
1691 | 366 | int r = av_opt_get(v->input, "http_version", AV_OPT_SEARCH_CHILDREN, &http_version_opt); | |
1692 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 366 times.
|
366 | if (r >= 0) { |
1693 | ✗ | c->http_multiple = (!strncmp((const char *)http_version_opt, "1.1", 3) || !strncmp((const char *)http_version_opt, "2.0", 3)); | |
1694 | ✗ | av_freep(&http_version_opt); | |
1695 | } | ||
1696 | } | ||
1697 | |||
1698 | 366 | seg = next_segment(v); | |
1699 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 366 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
366 | if (c->http_multiple == 1 && !v->input_next_requested && |
1700 | ✗ | seg && seg->key_type == KEY_NONE && av_strstart(seg->url, "http", NULL)) { | |
1701 | ✗ | ret = open_input(c, v, seg, &v->input_next); | |
1702 | ✗ | if (ret < 0) { | |
1703 | ✗ | if (ff_check_interrupt(c->interrupt_callback)) | |
1704 | ✗ | return AVERROR_EXIT; | |
1705 | ✗ | av_log(v->parent, AV_LOG_WARNING, "Failed to open segment %"PRId64" of playlist %d\n", | |
1706 | ✗ | v->cur_seq_no + 1, | |
1707 | v->index); | ||
1708 | } else { | ||
1709 | ✗ | v->input_next_requested = 1; | |
1710 | } | ||
1711 | } | ||
1712 | |||
1713 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 366 times.
|
366 | if (v->init_sec_buf_read_offset < v->init_sec_data_len) { |
1714 | /* Push init section out first before first actual segment */ | ||
1715 | ✗ | int copy_size = FFMIN(v->init_sec_data_len - v->init_sec_buf_read_offset, buf_size); | |
1716 | ✗ | memcpy(buf, v->init_sec_buf, copy_size); | |
1717 | ✗ | v->init_sec_buf_read_offset += copy_size; | |
1718 | ✗ | return copy_size; | |
1719 | } | ||
1720 | |||
1721 | 366 | seg = current_segment(v); | |
1722 | 366 | ret = read_from_url(v, seg, buf, buf_size); | |
1723 |
2/2✓ Branch 0 taken 307 times.
✓ Branch 1 taken 59 times.
|
366 | if (ret > 0) { |
1724 |
4/4✓ Branch 0 taken 61 times.
✓ Branch 1 taken 246 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 49 times.
|
307 | if (just_opened && v->is_id3_timestamped != 0) { |
1725 | /* Intercept ID3 tags here, elementary audio streams are required | ||
1726 | * to convey timestamps using them in the beginning of each segment. */ | ||
1727 | 12 | intercept_id3(v, buf, buf_size, &ret); | |
1728 | } | ||
1729 | |||
1730 | 307 | return ret; | |
1731 | } | ||
1732 |
1/2✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
|
59 | if (c->http_persistent && |
1733 |
2/4✓ Branch 0 taken 59 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 59 times.
|
59 | seg->key_type == KEY_NONE && av_strstart(seg->url, "http", NULL)) { |
1734 | ✗ | v->input_read_done = 1; | |
1735 | } else { | ||
1736 | 59 | ff_format_io_close(v->parent, &v->input); | |
1737 | } | ||
1738 | 59 | v->cur_seq_no++; | |
1739 | |||
1740 | 59 | c->cur_seq_no = v->cur_seq_no; | |
1741 | |||
1742 | 59 | goto restart; | |
1743 | } | ||
1744 | |||
1745 | ✗ | static int read_data_subtitle_segment(void *opaque, uint8_t *buf, int buf_size) | |
1746 | { | ||
1747 | ✗ | struct playlist *v = opaque; | |
1748 | ✗ | HLSContext *c = v->parent->priv_data; | |
1749 | int ret; | ||
1750 | struct segment *seg; | ||
1751 | |||
1752 | ✗ | if (!v->needed || v->cur_seq_no - v->start_seq_no >= v->n_segments) { | |
1753 | ✗ | return AVERROR_EOF; | |
1754 | } else { | ||
1755 | ✗ | seg = current_segment(v); | |
1756 | } | ||
1757 | |||
1758 | ✗ | if (!v->input) { | |
1759 | ✗ | ret = open_input(c, v, seg, &v->input); | |
1760 | ✗ | if (ret < 0) { | |
1761 | ✗ | if (ff_check_interrupt(c->interrupt_callback)) | |
1762 | ✗ | return AVERROR_EXIT; | |
1763 | ✗ | av_log(v->parent, AV_LOG_WARNING, "Failed to open segment of playlist %d\n", | |
1764 | v->index); | ||
1765 | ✗ | return ret; | |
1766 | } | ||
1767 | } | ||
1768 | |||
1769 | ✗ | return read_from_url(v, seg, buf, buf_size); | |
1770 | } | ||
1771 | |||
1772 | ✗ | static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url, | |
1773 | int flags, AVDictionary **opts) | ||
1774 | { | ||
1775 | ✗ | av_log(s, AV_LOG_ERROR, | |
1776 | "A HLS playlist item '%s' referred to an external file '%s'. " | ||
1777 | "Opening this file was forbidden for security reasons\n", | ||
1778 | s->url, url); | ||
1779 | ✗ | return AVERROR(EPERM); | |
1780 | } | ||
1781 | |||
1782 | ✗ | static int init_subtitle_context(struct playlist *pls) | |
1783 | { | ||
1784 | ✗ | HLSContext *c = pls->parent->priv_data; | |
1785 | const AVInputFormat *in_fmt; | ||
1786 | ✗ | AVDictionary *opts = NULL; | |
1787 | int ret; | ||
1788 | |||
1789 | ✗ | if (!(pls->ctx = avformat_alloc_context())) | |
1790 | ✗ | return AVERROR(ENOMEM); | |
1791 | |||
1792 | ✗ | pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE); | |
1793 | ✗ | if (!pls->read_buffer) { | |
1794 | ✗ | avformat_free_context(pls->ctx); | |
1795 | ✗ | pls->ctx = NULL; | |
1796 | ✗ | return AVERROR(ENOMEM); | |
1797 | } | ||
1798 | |||
1799 | ✗ | ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls, | |
1800 | read_data_subtitle_segment, NULL, NULL); | ||
1801 | ✗ | pls->pb.pub.seekable = 0; | |
1802 | ✗ | pls->ctx->pb = &pls->pb.pub; | |
1803 | ✗ | pls->ctx->io_open = nested_io_open; | |
1804 | |||
1805 | ✗ | ret = ff_copy_whiteblacklists(pls->ctx, pls->parent); | |
1806 | ✗ | if (ret < 0) | |
1807 | ✗ | return ret; | |
1808 | |||
1809 | ✗ | in_fmt = av_find_input_format("webvtt"); | |
1810 | ✗ | av_dict_copy(&opts, c->seg_format_opts, 0); | |
1811 | ✗ | ret = avformat_open_input(&pls->ctx, current_segment(pls)->url, in_fmt, &opts); | |
1812 | ✗ | av_dict_free(&opts); | |
1813 | |||
1814 | ✗ | return ret; | |
1815 | } | ||
1816 | |||
1817 | ✗ | static int read_subtitle_packet(struct playlist *v, AVPacket *pkt) | |
1818 | { | ||
1819 | ✗ | HLSContext *c = v->parent->priv_data; | |
1820 | int ret; | ||
1821 | |||
1822 | ✗ | restart: | |
1823 | ✗ | ret = reload_playlist(v, c); | |
1824 | ✗ | if (ret < 0) | |
1825 | ✗ | return ret; | |
1826 | |||
1827 | ✗ | if (v->input && !v->ctx) | |
1828 | ✗ | ff_format_io_close(v->parent, &v->input); | |
1829 | |||
1830 | ✗ | if (!v->input && !v->ctx) { | |
1831 | ✗ | ret = init_subtitle_context(v); | |
1832 | ✗ | if (ret < 0) | |
1833 | ✗ | return ret; | |
1834 | } | ||
1835 | |||
1836 | ✗ | ret = av_read_frame(v->ctx, v->pkt); | |
1837 | ✗ | if (!ret) { | |
1838 | ✗ | return ret; | |
1839 | } | ||
1840 | ✗ | ff_format_io_close(v->parent, &v->input); | |
1841 | ✗ | v->cur_seq_no++; | |
1842 | ✗ | c->cur_seq_no = v->cur_seq_no; | |
1843 | |||
1844 | ✗ | avformat_close_input(&v->ctx); | |
1845 | |||
1846 | ✗ | goto restart; | |
1847 | } | ||
1848 | |||
1849 | ✗ | static void add_renditions_to_variant(HLSContext *c, struct variant *var, | |
1850 | enum AVMediaType type, const char *group_id) | ||
1851 | { | ||
1852 | int i; | ||
1853 | |||
1854 | ✗ | for (i = 0; i < c->n_renditions; i++) { | |
1855 | ✗ | struct rendition *rend = c->renditions[i]; | |
1856 | |||
1857 | ✗ | if (rend->type == type && !strcmp(rend->group_id, group_id)) { | |
1858 | |||
1859 | ✗ | if (rend->playlist) | |
1860 | /* rendition is an external playlist | ||
1861 | * => add the playlist to the variant */ | ||
1862 | ✗ | dynarray_add(&var->playlists, &var->n_playlists, rend->playlist); | |
1863 | else | ||
1864 | /* rendition is part of the variant main Media Playlist | ||
1865 | * => add the rendition to the main Media Playlist */ | ||
1866 | ✗ | dynarray_add(&var->playlists[0]->renditions, | |
1867 | &var->playlists[0]->n_renditions, | ||
1868 | rend); | ||
1869 | } | ||
1870 | } | ||
1871 | ✗ | } | |
1872 | |||
1873 | 36 | static void add_metadata_from_renditions(AVFormatContext *s, struct playlist *pls, | |
1874 | enum AVMediaType type) | ||
1875 | { | ||
1876 | 36 | int rend_idx = 0; | |
1877 | int i; | ||
1878 | |||
1879 |
2/2✓ Branch 0 taken 36 times.
✓ Branch 1 taken 24 times.
|
60 | for (i = 0; i < pls->n_main_streams; i++) { |
1880 | 36 | AVStream *st = pls->main_streams[i]; | |
1881 | |||
1882 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 12 times.
|
36 | if (st->codecpar->codec_type != type) |
1883 | 24 | continue; | |
1884 | |||
1885 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | for (; rend_idx < pls->n_renditions; rend_idx++) { |
1886 | ✗ | struct rendition *rend = pls->renditions[rend_idx]; | |
1887 | |||
1888 | ✗ | if (rend->type != type) | |
1889 | ✗ | continue; | |
1890 | |||
1891 | ✗ | if (rend->language[0]) | |
1892 | ✗ | av_dict_set(&st->metadata, "language", rend->language, 0); | |
1893 | ✗ | if (rend->name[0]) | |
1894 | ✗ | av_dict_set(&st->metadata, "comment", rend->name, 0); | |
1895 | |||
1896 | ✗ | st->disposition |= rend->disposition; | |
1897 | } | ||
1898 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (rend_idx >=pls->n_renditions) |
1899 | 12 | break; | |
1900 | } | ||
1901 | 36 | } | |
1902 | |||
1903 | /* if timestamp was in valid range: returns 1 and sets seq_no | ||
1904 | * if not: returns 0 and sets seq_no to closest segment */ | ||
1905 | ✗ | static int find_timestamp_in_playlist(HLSContext *c, struct playlist *pls, | |
1906 | int64_t timestamp, int64_t *seq_no, | ||
1907 | int64_t *seg_start_ts) | ||
1908 | { | ||
1909 | int i; | ||
1910 | ✗ | int64_t pos = c->first_timestamp == AV_NOPTS_VALUE ? | |
1911 | ✗ | 0 : c->first_timestamp; | |
1912 | |||
1913 | ✗ | if (timestamp < pos) { | |
1914 | ✗ | *seq_no = pls->start_seq_no; | |
1915 | ✗ | return 0; | |
1916 | } | ||
1917 | |||
1918 | ✗ | for (i = 0; i < pls->n_segments; i++) { | |
1919 | ✗ | int64_t diff = pos + pls->segments[i]->duration - timestamp; | |
1920 | ✗ | if (diff > 0) { | |
1921 | ✗ | *seq_no = pls->start_seq_no + i; | |
1922 | ✗ | if (seg_start_ts) { | |
1923 | ✗ | *seg_start_ts = pos; | |
1924 | } | ||
1925 | ✗ | return 1; | |
1926 | } | ||
1927 | ✗ | pos += pls->segments[i]->duration; | |
1928 | } | ||
1929 | |||
1930 | ✗ | *seq_no = pls->start_seq_no + pls->n_segments - 1; | |
1931 | |||
1932 | ✗ | return 0; | |
1933 | } | ||
1934 | |||
1935 | 12 | static int64_t select_cur_seq_no(HLSContext *c, struct playlist *pls) | |
1936 | { | ||
1937 | int64_t seq_no; | ||
1938 | |||
1939 |
3/6✓ Branch 0 taken 1 times.
✓ Branch 1 taken 11 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
12 | if (!pls->finished && !c->first_packet && |
1940 | ✗ | av_gettime_relative() - pls->last_load_time >= default_reload_interval(pls)) | |
1941 | /* reload the playlist since it was suspended */ | ||
1942 | ✗ | parse_playlist(c, pls->url, pls, NULL); | |
1943 | |||
1944 | /* If playback is already in progress (we are just selecting a new | ||
1945 | * playlist) and this is a complete file, find the matching segment | ||
1946 | * by counting durations. */ | ||
1947 |
3/4✓ Branch 0 taken 11 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
|
12 | if (pls->finished && c->cur_timestamp != AV_NOPTS_VALUE) { |
1948 | ✗ | find_timestamp_in_playlist(c, pls, c->cur_timestamp, &seq_no, NULL); | |
1949 | ✗ | return seq_no; | |
1950 | } | ||
1951 | |||
1952 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 11 times.
|
12 | if (!pls->finished) { |
1953 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!c->first_packet && /* we are doing a segment selection during playback */ |
1954 | ✗ | c->cur_seq_no >= pls->start_seq_no && | |
1955 | ✗ | c->cur_seq_no < pls->start_seq_no + pls->n_segments) | |
1956 | /* While spec 3.4.3 says that we cannot assume anything about the | ||
1957 | * content at the same sequence number on different playlists, | ||
1958 | * in practice this seems to work and doing it otherwise would | ||
1959 | * require us to download a segment to inspect its timestamps. */ | ||
1960 | ✗ | return c->cur_seq_no; | |
1961 | |||
1962 | /* If this is a live stream, start live_start_index segments from the | ||
1963 | * start or end */ | ||
1964 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (c->live_start_index < 0) |
1965 | 1 | seq_no = pls->start_seq_no + FFMAX(pls->n_segments + | |
1966 | c->live_start_index, 0); | ||
1967 | else | ||
1968 | ✗ | seq_no = pls->start_seq_no + FFMIN(c->live_start_index, | |
1969 | pls->n_segments - 1); | ||
1970 | |||
1971 | /* If #EXT-X-START in playlist, need to recalculate */ | ||
1972 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
1 | if (pls->time_offset_flag && c->prefer_x_start) { |
1973 | int64_t start_timestamp; | ||
1974 | ✗ | int64_t playlist_duration = 0; | |
1975 | ✗ | int64_t cur_timestamp = c->cur_timestamp == AV_NOPTS_VALUE ? 0 : | |
1976 | c->cur_timestamp; | ||
1977 | |||
1978 | ✗ | for (int i = 0; i < pls->n_segments; i++) | |
1979 | ✗ | playlist_duration += pls->segments[i]->duration; | |
1980 | |||
1981 | /* If the absolute value of TIME-OFFSET exceeds | ||
1982 | * the duration of the playlist, it indicates either the end of the | ||
1983 | * playlist (if positive) or the beginning of the playlist (if | ||
1984 | * negative). */ | ||
1985 | ✗ | if (pls->start_time_offset >=0 && | |
1986 | ✗ | pls->start_time_offset > playlist_duration) | |
1987 | ✗ | start_timestamp = cur_timestamp + playlist_duration; | |
1988 | ✗ | else if (pls->start_time_offset >= 0 && | |
1989 | ✗ | pls->start_time_offset <= playlist_duration) | |
1990 | ✗ | start_timestamp = cur_timestamp + pls->start_time_offset; | |
1991 | ✗ | else if (pls->start_time_offset < 0 && | |
1992 | ✗ | pls->start_time_offset < -playlist_duration) | |
1993 | ✗ | start_timestamp = cur_timestamp; | |
1994 | ✗ | else if (pls->start_time_offset < 0 && | |
1995 | ✗ | pls->start_time_offset > -playlist_duration) | |
1996 | ✗ | start_timestamp = cur_timestamp + playlist_duration + | |
1997 | ✗ | pls->start_time_offset; | |
1998 | else | ||
1999 | ✗ | start_timestamp = cur_timestamp; | |
2000 | |||
2001 | ✗ | find_timestamp_in_playlist(c, pls, start_timestamp, &seq_no, NULL); | |
2002 | } | ||
2003 | 1 | return seq_no; | |
2004 | } | ||
2005 | |||
2006 | /* Otherwise just start on the first segment. */ | ||
2007 | 11 | return pls->start_seq_no; | |
2008 | } | ||
2009 | |||
2010 | 12 | static void add_stream_to_programs(AVFormatContext *s, struct playlist *pls, AVStream *stream) | |
2011 | { | ||
2012 | 12 | HLSContext *c = s->priv_data; | |
2013 | int i, j; | ||
2014 | 12 | int bandwidth = -1; | |
2015 | |||
2016 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (i = 0; i < c->n_variants; i++) { |
2017 | 12 | struct variant *v = c->variants[i]; | |
2018 | |||
2019 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (j = 0; j < v->n_playlists; j++) { |
2020 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (v->playlists[j] != pls) |
2021 | ✗ | continue; | |
2022 | |||
2023 | 12 | av_program_add_stream_index(s, i, stream->index); | |
2024 | |||
2025 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (bandwidth < 0) |
2026 | 12 | bandwidth = v->bandwidth; | |
2027 | ✗ | else if (bandwidth != v->bandwidth) | |
2028 | ✗ | bandwidth = -1; /* stream in multiple variants with different bandwidths */ | |
2029 | } | ||
2030 | } | ||
2031 | |||
2032 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (bandwidth >= 0) |
2033 | 12 | av_dict_set_int(&stream->metadata, "variant_bitrate", bandwidth, 0); | |
2034 | 12 | } | |
2035 | |||
2036 | 22 | static int set_stream_info_from_input_stream(AVStream *st, struct playlist *pls, AVStream *ist) | |
2037 | { | ||
2038 | int err; | ||
2039 | |||
2040 | 22 | err = avcodec_parameters_copy(st->codecpar, ist->codecpar); | |
2041 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (err < 0) |
2042 | ✗ | return err; | |
2043 | |||
2044 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (pls->is_id3_timestamped) /* custom timestamps via id3 */ |
2045 | ✗ | avpriv_set_pts_info(st, 33, 1, MPEG_TIME_BASE); | |
2046 | else | ||
2047 | 22 | avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den); | |
2048 | |||
2049 | // copy disposition | ||
2050 | 22 | st->disposition = ist->disposition; | |
2051 | |||
2052 | 22 | av_dict_copy(&st->metadata, ist->metadata, 0); | |
2053 | |||
2054 | 22 | ffstream(st)->need_context_update = 1; | |
2055 | |||
2056 | 22 | return 0; | |
2057 | } | ||
2058 | |||
2059 | /* add new subdemuxer streams to our context, if any */ | ||
2060 | 6369 | static int update_streams_from_subdemuxer(AVFormatContext *s, struct playlist *pls) | |
2061 | { | ||
2062 | int err; | ||
2063 | |||
2064 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 6369 times.
|
6381 | while (pls->n_main_streams < pls->ctx->nb_streams) { |
2065 | 12 | int ist_idx = pls->n_main_streams; | |
2066 | 12 | AVStream *st = avformat_new_stream(s, NULL); | |
2067 | 12 | AVStream *ist = pls->ctx->streams[ist_idx]; | |
2068 | |||
2069 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!st) |
2070 | ✗ | return AVERROR(ENOMEM); | |
2071 | |||
2072 | 12 | st->id = pls->index; | |
2073 | 12 | dynarray_add(&pls->main_streams, &pls->n_main_streams, st); | |
2074 | |||
2075 | 12 | add_stream_to_programs(s, pls, st); | |
2076 | |||
2077 | 12 | err = set_stream_info_from_input_stream(st, pls, ist); | |
2078 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (err < 0) |
2079 | ✗ | return err; | |
2080 | } | ||
2081 | |||
2082 | 6369 | return 0; | |
2083 | } | ||
2084 | |||
2085 | 23 | static void update_noheader_flag(AVFormatContext *s) | |
2086 | { | ||
2087 | 23 | HLSContext *c = s->priv_data; | |
2088 | 23 | int flag_needed = 0; | |
2089 | int i; | ||
2090 | |||
2091 |
2/2✓ Branch 0 taken 23 times.
✓ Branch 1 taken 12 times.
|
35 | for (i = 0; i < c->n_playlists; i++) { |
2092 | 23 | struct playlist *pls = c->playlists[i]; | |
2093 | |||
2094 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 12 times.
|
23 | if (pls->has_noheader_flag) { |
2095 | 11 | flag_needed = 1; | |
2096 | 11 | break; | |
2097 | } | ||
2098 | } | ||
2099 | |||
2100 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 12 times.
|
23 | if (flag_needed) |
2101 | 11 | s->ctx_flags |= AVFMTCTX_NOHEADER; | |
2102 | else | ||
2103 | 12 | s->ctx_flags &= ~AVFMTCTX_NOHEADER; | |
2104 | 23 | } | |
2105 | |||
2106 | 12 | static int hls_close(AVFormatContext *s) | |
2107 | { | ||
2108 | 12 | HLSContext *c = s->priv_data; | |
2109 | |||
2110 | 12 | free_playlist_list(c); | |
2111 | 12 | free_variant_list(c); | |
2112 | 12 | free_rendition_list(c); | |
2113 | |||
2114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (c->crypto_ctx.aes_ctx) |
2115 | ✗ | av_free(c->crypto_ctx.aes_ctx); | |
2116 | |||
2117 | 12 | av_dict_free(&c->avio_opts); | |
2118 | 12 | ff_format_io_close(c->ctx, &c->playlist_pb); | |
2119 | |||
2120 | 12 | return 0; | |
2121 | } | ||
2122 | |||
2123 | 12 | static int hls_read_header(AVFormatContext *s) | |
2124 | { | ||
2125 | 12 | HLSContext *c = s->priv_data; | |
2126 | 12 | int ret = 0, i; | |
2127 | 12 | int64_t highest_cur_seq_no = 0; | |
2128 | |||
2129 | 12 | c->ctx = s; | |
2130 | 12 | c->interrupt_callback = &s->interrupt_callback; | |
2131 | |||
2132 | 12 | c->first_packet = 1; | |
2133 | 12 | c->first_timestamp = AV_NOPTS_VALUE; | |
2134 | 12 | c->cur_timestamp = AV_NOPTS_VALUE; | |
2135 | |||
2136 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
|
12 | if ((ret = ffio_copy_url_options(s->pb, &c->avio_opts)) < 0) |
2137 | ✗ | return ret; | |
2138 | |||
2139 | /* XXX: Some HLS servers don't like being sent the range header, | ||
2140 | in this case, need to setting http_seekable = 0 to disable | ||
2141 | the range header */ | ||
2142 | 12 | av_dict_set_int(&c->avio_opts, "seekable", c->http_seekable, 0); | |
2143 | |||
2144 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
|
12 | if ((ret = parse_playlist(c, s->url, NULL, s->pb)) < 0) |
2145 | ✗ | return ret; | |
2146 | |||
2147 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (c->n_variants == 0) { |
2148 | ✗ | av_log(s, AV_LOG_WARNING, "Empty playlist\n"); | |
2149 | ✗ | return AVERROR_EOF; | |
2150 | } | ||
2151 | /* If the playlist only contained playlists (Master Playlist), | ||
2152 | * parse each individual playlist. */ | ||
2153 |
2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
|
12 | if (c->n_playlists > 1 || c->playlists[0]->n_segments == 0) { |
2154 | ✗ | for (i = 0; i < c->n_playlists; i++) { | |
2155 | ✗ | struct playlist *pls = c->playlists[i]; | |
2156 | ✗ | pls->m3u8_hold_counters = 0; | |
2157 | ✗ | if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0) { | |
2158 | ✗ | av_log(s, AV_LOG_WARNING, "parse_playlist error %s [%s]\n", av_err2str(ret), pls->url); | |
2159 | ✗ | pls->broken = 1; | |
2160 | ✗ | if (c->n_playlists > 1) | |
2161 | ✗ | continue; | |
2162 | ✗ | return ret; | |
2163 | } | ||
2164 | } | ||
2165 | } | ||
2166 | |||
2167 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (i = 0; i < c->n_variants; i++) { |
2168 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (c->variants[i]->playlists[0]->n_segments == 0) { |
2169 | ✗ | av_log(s, AV_LOG_WARNING, "Empty segment [%s]\n", c->variants[i]->playlists[0]->url); | |
2170 | ✗ | c->variants[i]->playlists[0]->broken = 1; | |
2171 | } | ||
2172 | } | ||
2173 | |||
2174 | /* If this isn't a live stream, calculate the total duration of the | ||
2175 | * stream. */ | ||
2176 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 1 times.
|
12 | if (c->variants[0]->playlists[0]->finished) { |
2177 | 11 | int64_t duration = 0; | |
2178 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 11 times.
|
71 | for (i = 0; i < c->variants[0]->playlists[0]->n_segments; i++) |
2179 | 60 | duration += c->variants[0]->playlists[0]->segments[i]->duration; | |
2180 | 11 | s->duration = duration; | |
2181 | } | ||
2182 | |||
2183 | /* Associate renditions with variants */ | ||
2184 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (i = 0; i < c->n_variants; i++) { |
2185 | 12 | struct variant *var = c->variants[i]; | |
2186 | |||
2187 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (var->audio_group[0]) |
2188 | ✗ | add_renditions_to_variant(c, var, AVMEDIA_TYPE_AUDIO, var->audio_group); | |
2189 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (var->video_group[0]) |
2190 | ✗ | add_renditions_to_variant(c, var, AVMEDIA_TYPE_VIDEO, var->video_group); | |
2191 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (var->subtitles_group[0]) |
2192 | ✗ | add_renditions_to_variant(c, var, AVMEDIA_TYPE_SUBTITLE, var->subtitles_group); | |
2193 | } | ||
2194 | |||
2195 | /* Create a program for each variant */ | ||
2196 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (i = 0; i < c->n_variants; i++) { |
2197 | 12 | struct variant *v = c->variants[i]; | |
2198 | AVProgram *program; | ||
2199 | |||
2200 | 12 | program = av_new_program(s, i); | |
2201 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!program) |
2202 | ✗ | return AVERROR(ENOMEM); | |
2203 | 12 | av_dict_set_int(&program->metadata, "variant_bitrate", v->bandwidth, 0); | |
2204 | } | ||
2205 | |||
2206 | /* Select the starting segments */ | ||
2207 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (i = 0; i < c->n_playlists; i++) { |
2208 | 12 | struct playlist *pls = c->playlists[i]; | |
2209 | |||
2210 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls->n_segments == 0) |
2211 | ✗ | continue; | |
2212 | |||
2213 | 12 | pls->cur_seq_no = select_cur_seq_no(c, pls); | |
2214 | 12 | highest_cur_seq_no = FFMAX(highest_cur_seq_no, pls->cur_seq_no); | |
2215 | } | ||
2216 | |||
2217 | 12 | av_dict_set(&c->seg_format_opts, "prefer_hls_mpegts_pts", "1", 0); | |
2218 | |||
2219 | /* Open the demuxer for each playlist */ | ||
2220 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
|
24 | for (i = 0; i < c->n_playlists; i++) { |
2221 | 12 | struct playlist *pls = c->playlists[i]; | |
2222 | 12 | const AVInputFormat *in_fmt = NULL; | |
2223 | char *url; | ||
2224 | 12 | AVDictionary *options = NULL; | |
2225 | 12 | struct segment *seg = NULL; | |
2226 | |||
2227 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
|
12 | if (!(pls->ctx = avformat_alloc_context())) |
2228 | ✗ | return AVERROR(ENOMEM); | |
2229 | |||
2230 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls->n_segments == 0) |
2231 | ✗ | continue; | |
2232 | |||
2233 | 12 | pls->index = i; | |
2234 | 12 | pls->needed = 1; | |
2235 | 12 | pls->parent = s; | |
2236 | |||
2237 | /* | ||
2238 | * If this is a live stream and this playlist looks like it is one segment | ||
2239 | * behind, try to sync it up so that every substream starts at the same | ||
2240 | * time position (so e.g. avformat_find_stream_info() will see packets from | ||
2241 | * all active streams within the first few seconds). This is not very generic, | ||
2242 | * though, as the sequence numbers are technically independent. | ||
2243 | */ | ||
2244 |
3/4✓ Branch 0 taken 1 times.
✓ Branch 1 taken 11 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
|
12 | if (!pls->finished && pls->cur_seq_no == highest_cur_seq_no - 1 && |
2245 | ✗ | highest_cur_seq_no < pls->start_seq_no + pls->n_segments) { | |
2246 | ✗ | pls->cur_seq_no = highest_cur_seq_no; | |
2247 | } | ||
2248 | |||
2249 | 12 | pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE); | |
2250 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!pls->read_buffer){ |
2251 | ✗ | avformat_free_context(pls->ctx); | |
2252 | ✗ | pls->ctx = NULL; | |
2253 | ✗ | return AVERROR(ENOMEM); | |
2254 | } | ||
2255 | |||
2256 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls->is_subtitle) |
2257 | ✗ | ffio_init_context(&pls->pb, (unsigned char*)av_strdup("WEBVTT\n"), (int)strlen("WEBVTT\n"), 0, pls, | |
2258 | NULL, NULL, NULL); | ||
2259 | else | ||
2260 | 12 | ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls, | |
2261 | read_data_continuous, NULL, NULL); | ||
2262 | |||
2263 | /* | ||
2264 | * If encryption scheme is SAMPLE-AES, try to read ID3 tags of | ||
2265 | * external audio track that contains audio setup information | ||
2266 | */ | ||
2267 | 12 | seg = current_segment(pls); | |
2268 |
2/6✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
12 | if (seg && seg->key_type == KEY_SAMPLE_AES && pls->n_renditions > 0 && |
2269 | ✗ | pls->renditions[0]->type == AVMEDIA_TYPE_AUDIO) { | |
2270 | uint8_t buf[HLS_MAX_ID3_TAGS_DATA_LEN]; | ||
2271 | ✗ | if ((ret = avio_read(&pls->pb.pub, buf, HLS_MAX_ID3_TAGS_DATA_LEN)) < 0) { | |
2272 | /* Fail if error was not end of file */ | ||
2273 | ✗ | if (ret != AVERROR_EOF) { | |
2274 | ✗ | avformat_free_context(pls->ctx); | |
2275 | ✗ | pls->ctx = NULL; | |
2276 | ✗ | return ret; | |
2277 | } | ||
2278 | } | ||
2279 | ✗ | ret = 0; | |
2280 | /* Reset reading */ | ||
2281 | ✗ | ff_format_io_close(pls->parent, &pls->input); | |
2282 | ✗ | pls->input = NULL; | |
2283 | ✗ | pls->input_read_done = 0; | |
2284 | ✗ | ff_format_io_close(pls->parent, &pls->input_next); | |
2285 | ✗ | pls->input_next = NULL; | |
2286 | ✗ | pls->input_next_requested = 0; | |
2287 | ✗ | pls->cur_seg_offset = 0; | |
2288 | ✗ | pls->cur_init_section = NULL; | |
2289 | /* Reset EOF flag */ | ||
2290 | ✗ | pls->pb.pub.eof_reached = 0; | |
2291 | /* Clear any buffered data */ | ||
2292 | ✗ | pls->pb.pub.buf_end = pls->pb.pub.buf_ptr = pls->pb.pub.buffer; | |
2293 | /* Reset the position */ | ||
2294 | ✗ | pls->pb.pub.pos = 0; | |
2295 | } | ||
2296 | |||
2297 | /* | ||
2298 | * If encryption scheme is SAMPLE-AES and audio setup information is present in external audio track, | ||
2299 | * use that information to find the media format, otherwise probe input data | ||
2300 | */ | ||
2301 | 12 | seg = current_segment(pls); | |
2302 |
2/6✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
12 | if (seg && seg->key_type == KEY_SAMPLE_AES && pls->is_id3_timestamped && |
2303 | ✗ | pls->audio_setup_info.codec_id != AV_CODEC_ID_NONE) { | |
2304 | av_assert1(pls->audio_setup_info.codec_id == AV_CODEC_ID_AAC || | ||
2305 | pls->audio_setup_info.codec_id == AV_CODEC_ID_AC3 || | ||
2306 | pls->audio_setup_info.codec_id == AV_CODEC_ID_EAC3); | ||
2307 | // Keep this list in sync with ff_hls_senc_read_audio_setup_info() | ||
2308 | ✗ | in_fmt = av_find_input_format(pls->audio_setup_info.codec_id == AV_CODEC_ID_AAC ? "aac" : | |
2309 | ✗ | pls->audio_setup_info.codec_id == AV_CODEC_ID_AC3 ? "ac3" : "eac3"); | |
2310 | } else { | ||
2311 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | pls->ctx->probesize = s->probesize > 0 ? s->probesize : 1024 * 4; |
2312 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | pls->ctx->max_analyze_duration = s->max_analyze_duration > 0 ? s->max_analyze_duration : 4 * AV_TIME_BASE; |
2313 | 12 | pls->ctx->interrupt_callback = s->interrupt_callback; | |
2314 | 12 | url = av_strdup(pls->segments[0]->url); | |
2315 | 12 | ret = av_probe_input_buffer(&pls->pb.pub, &in_fmt, url, NULL, 0, 0); | |
2316 | |||
2317 |
2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 12 times.
|
77 | for (int n = 0; n < pls->n_segments; n++) |
2318 |
1/2✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
|
65 | if (ret >= 0) |
2319 | 65 | ret = test_segment(s, in_fmt, pls, pls->segments[n]); | |
2320 | |||
2321 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (ret < 0) { |
2322 | /* Free the ctx - it isn't initialized properly at this point, | ||
2323 | * so avformat_close_input shouldn't be called. If | ||
2324 | * avformat_open_input fails below, it frees and zeros the | ||
2325 | * context, so it doesn't need any special treatment like this. */ | ||
2326 | ✗ | av_log(s, AV_LOG_ERROR, "Error when loading first segment '%s'\n", url); | |
2327 | ✗ | avformat_free_context(pls->ctx); | |
2328 | ✗ | pls->ctx = NULL; | |
2329 | ✗ | av_free(url); | |
2330 | ✗ | return ret; | |
2331 | } | ||
2332 | 12 | av_free(url); | |
2333 | } | ||
2334 | |||
2335 | 12 | seg = current_segment(pls); | |
2336 |
2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
|
12 | if (seg && seg->key_type == KEY_SAMPLE_AES) { |
2337 | ✗ | if (strstr(in_fmt->name, "mov")) { | |
2338 | char key[33]; | ||
2339 | ✗ | ff_data_to_hex(key, pls->key, sizeof(pls->key), 0); | |
2340 | ✗ | av_dict_set(&options, "decryption_key", key, 0); | |
2341 | ✗ | } else if (!c->crypto_ctx.aes_ctx) { | |
2342 | ✗ | c->crypto_ctx.aes_ctx = av_aes_alloc(); | |
2343 | ✗ | if (!c->crypto_ctx.aes_ctx) { | |
2344 | ✗ | avformat_free_context(pls->ctx); | |
2345 | ✗ | pls->ctx = NULL; | |
2346 | ✗ | return AVERROR(ENOMEM); | |
2347 | } | ||
2348 | } | ||
2349 | } | ||
2350 | |||
2351 | 12 | pls->ctx->pb = &pls->pb.pub; | |
2352 | 12 | pls->ctx->io_open = nested_io_open; | |
2353 | 12 | pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO; | |
2354 | |||
2355 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
|
12 | if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0) |
2356 | ✗ | return ret; | |
2357 | |||
2358 | 12 | av_dict_copy(&options, c->seg_format_opts, 0); | |
2359 | |||
2360 | 12 | ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, &options); | |
2361 | 12 | av_dict_free(&options); | |
2362 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (ret < 0) |
2363 | ✗ | return ret; | |
2364 | |||
2365 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
12 | if (pls->id3_deferred_extra && pls->ctx->nb_streams == 1) { |
2366 | ✗ | ff_id3v2_parse_apic(pls->ctx, pls->id3_deferred_extra); | |
2367 | ✗ | avformat_queue_attached_pictures(pls->ctx); | |
2368 | ✗ | ff_id3v2_parse_priv(pls->ctx, pls->id3_deferred_extra); | |
2369 | ✗ | ff_id3v2_free_extra_meta(&pls->id3_deferred_extra); | |
2370 | } | ||
2371 | |||
2372 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls->is_id3_timestamped == -1) |
2373 | ✗ | av_log(s, AV_LOG_WARNING, "No expected HTTP requests have been made\n"); | |
2374 | |||
2375 | /* | ||
2376 | * For ID3 timestamped raw audio streams we need to detect the packet | ||
2377 | * durations to calculate timestamps in fill_timing_for_id3_timestamped_stream(), | ||
2378 | * but for other streams we can rely on our user calling avformat_find_stream_info() | ||
2379 | * on us if they want to. | ||
2380 | */ | ||
2381 |
2/6✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
12 | if (pls->is_id3_timestamped || (pls->n_renditions > 0 && pls->renditions[0]->type == AVMEDIA_TYPE_AUDIO)) { |
2382 | ✗ | seg = current_segment(pls); | |
2383 | ✗ | if (seg && seg->key_type == KEY_SAMPLE_AES && pls->audio_setup_info.setup_data_length > 0 && | |
2384 | ✗ | pls->ctx->nb_streams == 1) | |
2385 | ✗ | ret = ff_hls_senc_parse_audio_setup_info(pls->ctx->streams[0], &pls->audio_setup_info); | |
2386 | else | ||
2387 | ✗ | ret = avformat_find_stream_info(pls->ctx, NULL); | |
2388 | |||
2389 | ✗ | if (ret < 0) | |
2390 | ✗ | return ret; | |
2391 | } | ||
2392 | |||
2393 | 12 | pls->has_noheader_flag = !!(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER); | |
2394 | |||
2395 | /* Create new AVStreams for each stream in this playlist */ | ||
2396 | 12 | ret = update_streams_from_subdemuxer(s, pls); | |
2397 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (ret < 0) |
2398 | ✗ | return ret; | |
2399 | |||
2400 | /* | ||
2401 | * Copy any metadata from playlist to main streams, but do not set | ||
2402 | * event flags. | ||
2403 | */ | ||
2404 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (pls->n_main_streams) |
2405 | 12 | av_dict_copy(&pls->main_streams[0]->metadata, pls->ctx->metadata, 0); | |
2406 | |||
2407 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls->is_subtitle) { |
2408 | ✗ | avformat_free_context(pls->ctx); | |
2409 | ✗ | pls->ctx = NULL; | |
2410 | ✗ | pls->needed = 0; | |
2411 | ✗ | pls->main_streams[0]->discard = AVDISCARD_ALL; | |
2412 | } | ||
2413 | |||
2414 | 12 | add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_AUDIO); | |
2415 | 12 | add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_VIDEO); | |
2416 | 12 | add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_SUBTITLE); | |
2417 | } | ||
2418 | |||
2419 | 12 | update_noheader_flag(s); | |
2420 | |||
2421 | 12 | return 0; | |
2422 | } | ||
2423 | |||
2424 | 6368 | static int recheck_discard_flags(AVFormatContext *s, int first) | |
2425 | { | ||
2426 | 6368 | HLSContext *c = s->priv_data; | |
2427 | 6368 | int i, changed = 0; | |
2428 | int cur_needed; | ||
2429 | |||
2430 | /* Check if any new streams are needed */ | ||
2431 |
2/2✓ Branch 0 taken 6368 times.
✓ Branch 1 taken 6368 times.
|
12736 | for (i = 0; i < c->n_playlists; i++) { |
2432 | 6368 | struct playlist *pls = c->playlists[i]; | |
2433 | |||
2434 | 6368 | cur_needed = playlist_needed(c->playlists[i]); | |
2435 | |||
2436 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6368 times.
|
6368 | if (pls->broken) { |
2437 | ✗ | continue; | |
2438 | } | ||
2439 |
2/4✓ Branch 0 taken 6368 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6368 times.
|
6368 | if (cur_needed && !pls->needed) { |
2440 | ✗ | pls->needed = 1; | |
2441 | ✗ | changed = 1; | |
2442 | ✗ | pls->cur_seq_no = select_cur_seq_no(c, pls); | |
2443 | ✗ | pls->pb.pub.eof_reached = 0; | |
2444 | ✗ | if (c->cur_timestamp != AV_NOPTS_VALUE) { | |
2445 | /* catch up */ | ||
2446 | ✗ | pls->seek_timestamp = c->cur_timestamp; | |
2447 | ✗ | pls->seek_flags = AVSEEK_FLAG_ANY; | |
2448 | ✗ | pls->seek_stream_index = -1; | |
2449 | } | ||
2450 | ✗ | av_log(s, AV_LOG_INFO, "Now receiving playlist %d, segment %"PRId64"\n", i, pls->cur_seq_no); | |
2451 |
3/6✓ Branch 0 taken 12 times.
✓ Branch 1 taken 6356 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
6368 | } else if (first && !cur_needed && pls->needed) { |
2452 | ✗ | ff_format_io_close(pls->parent, &pls->input); | |
2453 | ✗ | pls->input_read_done = 0; | |
2454 | ✗ | ff_format_io_close(pls->parent, &pls->input_next); | |
2455 | ✗ | pls->input_next_requested = 0; | |
2456 | ✗ | if (pls->is_subtitle) | |
2457 | ✗ | avformat_close_input(&pls->ctx); | |
2458 | ✗ | pls->needed = 0; | |
2459 | ✗ | changed = 1; | |
2460 | ✗ | av_log(s, AV_LOG_INFO, "No longer receiving playlist %d\n", i); | |
2461 | } | ||
2462 | } | ||
2463 | 6368 | return changed; | |
2464 | } | ||
2465 | |||
2466 | ✗ | static void fill_timing_for_id3_timestamped_stream(struct playlist *pls) | |
2467 | { | ||
2468 | ✗ | if (pls->id3_offset >= 0) { | |
2469 | ✗ | pls->pkt->dts = pls->id3_mpegts_timestamp + | |
2470 | ✗ | av_rescale_q(pls->id3_offset, | |
2471 | ✗ | pls->ctx->streams[pls->pkt->stream_index]->time_base, | |
2472 | ✗ | MPEG_TIME_BASE_Q); | |
2473 | ✗ | if (pls->pkt->duration) | |
2474 | ✗ | pls->id3_offset += pls->pkt->duration; | |
2475 | else | ||
2476 | ✗ | pls->id3_offset = -1; | |
2477 | } else { | ||
2478 | /* there have been packets with unknown duration | ||
2479 | * since the last id3 tag, should not normally happen */ | ||
2480 | ✗ | pls->pkt->dts = AV_NOPTS_VALUE; | |
2481 | } | ||
2482 | |||
2483 | ✗ | if (pls->pkt->duration) | |
2484 | ✗ | pls->pkt->duration = av_rescale_q(pls->pkt->duration, | |
2485 | ✗ | pls->ctx->streams[pls->pkt->stream_index]->time_base, | |
2486 | ✗ | MPEG_TIME_BASE_Q); | |
2487 | |||
2488 | ✗ | pls->pkt->pts = AV_NOPTS_VALUE; | |
2489 | ✗ | } | |
2490 | |||
2491 | 12 | static AVRational get_timebase(struct playlist *pls) | |
2492 | { | ||
2493 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (pls->is_id3_timestamped) |
2494 | ✗ | return MPEG_TIME_BASE_Q; | |
2495 | |||
2496 | 12 | return pls->ctx->streams[pls->pkt->stream_index]->time_base; | |
2497 | } | ||
2498 | |||
2499 | ✗ | static int compare_ts_with_wrapdetect(int64_t ts_a, struct playlist *pls_a, | |
2500 | int64_t ts_b, struct playlist *pls_b) | ||
2501 | { | ||
2502 | ✗ | int64_t scaled_ts_a = av_rescale_q(ts_a, get_timebase(pls_a), MPEG_TIME_BASE_Q); | |
2503 | ✗ | int64_t scaled_ts_b = av_rescale_q(ts_b, get_timebase(pls_b), MPEG_TIME_BASE_Q); | |
2504 | |||
2505 | ✗ | return av_compare_mod(scaled_ts_a, scaled_ts_b, 1LL << 33); | |
2506 | } | ||
2507 | |||
2508 | 6368 | static int hls_read_packet(AVFormatContext *s, AVPacket *pkt) | |
2509 | { | ||
2510 | 6368 | HLSContext *c = s->priv_data; | |
2511 | 6368 | int ret, i, minplaylist = -1; | |
2512 | |||
2513 | 6368 | recheck_discard_flags(s, c->first_packet); | |
2514 | 6368 | c->first_packet = 0; | |
2515 | |||
2516 |
2/2✓ Branch 0 taken 6368 times.
✓ Branch 1 taken 6368 times.
|
12736 | for (i = 0; i < c->n_playlists; i++) { |
2517 | 6368 | struct playlist *pls = c->playlists[i]; | |
2518 | /* Make sure we've got one buffered packet from each open playlist | ||
2519 | * stream */ | ||
2520 |
2/4✓ Branch 0 taken 6368 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6368 times.
✗ Branch 3 not taken.
|
6368 | if (pls->needed && !pls->pkt->data) { |
2521 | ✗ | while (1) { | |
2522 | int64_t ts_diff; | ||
2523 | AVRational tb; | ||
2524 | 6368 | struct segment *seg = NULL; | |
2525 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6368 times.
|
6368 | if (pls->is_subtitle) |
2526 | ✗ | ret = read_subtitle_packet(pls, pls->pkt); | |
2527 | else | ||
2528 | 6368 | ret = av_read_frame(pls->ctx, pls->pkt); | |
2529 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 6357 times.
|
6368 | if (ret < 0) { |
2530 |
1/4✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
11 | if (!avio_feof(&pls->pb.pub) && ret != AVERROR_EOF) |
2531 | ✗ | return ret; | |
2532 | 6368 | break; | |
2533 | } else { | ||
2534 | /* stream_index check prevents matching picture attachments etc. */ | ||
2535 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 6357 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
6357 | if (pls->is_id3_timestamped && pls->pkt->stream_index == 0) { |
2536 | /* audio elementary streams are id3 timestamped */ | ||
2537 | ✗ | fill_timing_for_id3_timestamped_stream(pls); | |
2538 | } | ||
2539 | |||
2540 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 6345 times.
|
6357 | if (c->first_timestamp == AV_NOPTS_VALUE && |
2541 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | pls->pkt->dts != AV_NOPTS_VALUE) |
2542 | 12 | c->first_timestamp = av_rescale_q(pls->pkt->dts, | |
2543 | 12 | get_timebase(pls), AV_TIME_BASE_Q); | |
2544 | } | ||
2545 | |||
2546 | 6357 | seg = current_segment(pls); | |
2547 |
3/6✓ Branch 0 taken 6355 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6355 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
6357 | if (seg && seg->key_type == KEY_SAMPLE_AES && !strstr(pls->ctx->iformat->name, "mov")) { |
2548 | ✗ | enum AVCodecID codec_id = pls->ctx->streams[pls->pkt->stream_index]->codecpar->codec_id; | |
2549 | ✗ | memcpy(c->crypto_ctx.iv, seg->iv, sizeof(seg->iv)); | |
2550 | ✗ | memcpy(c->crypto_ctx.key, pls->key, sizeof(pls->key)); | |
2551 | ✗ | ff_hls_senc_decrypt_frame(codec_id, &c->crypto_ctx, pls->pkt); | |
2552 | } | ||
2553 | |||
2554 |
1/2✓ Branch 0 taken 6357 times.
✗ Branch 1 not taken.
|
6357 | if (pls->seek_timestamp == AV_NOPTS_VALUE) |
2555 | 6357 | break; | |
2556 | |||
2557 | ✗ | if (pls->seek_stream_index < 0 || | |
2558 | ✗ | pls->seek_stream_index == pls->pkt->stream_index) { | |
2559 | |||
2560 | ✗ | if (pls->pkt->dts == AV_NOPTS_VALUE) { | |
2561 | ✗ | pls->seek_timestamp = AV_NOPTS_VALUE; | |
2562 | ✗ | break; | |
2563 | } | ||
2564 | |||
2565 | ✗ | tb = get_timebase(pls); | |
2566 | ✗ | ts_diff = av_rescale_rnd(pls->pkt->dts, AV_TIME_BASE, | |
2567 | ✗ | tb.den, AV_ROUND_DOWN) - | |
2568 | ✗ | pls->seek_timestamp; | |
2569 | ✗ | if (ts_diff >= 0 && (pls->seek_flags & AVSEEK_FLAG_ANY || | |
2570 | ✗ | pls->pkt->flags & AV_PKT_FLAG_KEY)) { | |
2571 | ✗ | pls->seek_timestamp = AV_NOPTS_VALUE; | |
2572 | ✗ | break; | |
2573 | } | ||
2574 | } | ||
2575 | ✗ | av_packet_unref(pls->pkt); | |
2576 | } | ||
2577 | } | ||
2578 | /* Check if this stream has the packet with the lowest dts */ | ||
2579 |
2/2✓ Branch 0 taken 6357 times.
✓ Branch 1 taken 11 times.
|
6368 | if (pls->pkt->data) { |
2580 | 6357 | struct playlist *minpls = minplaylist < 0 ? | |
2581 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6357 times.
|
6357 | NULL : c->playlists[minplaylist]; |
2582 |
1/2✓ Branch 0 taken 6357 times.
✗ Branch 1 not taken.
|
6357 | if (minplaylist < 0) { |
2583 | 6357 | minplaylist = i; | |
2584 | } else { | ||
2585 | ✗ | int64_t dts = pls->pkt->dts; | |
2586 | ✗ | int64_t mindts = minpls->pkt->dts; | |
2587 | |||
2588 | ✗ | if (dts == AV_NOPTS_VALUE || | |
2589 | ✗ | (mindts != AV_NOPTS_VALUE && compare_ts_with_wrapdetect(dts, pls, mindts, minpls) < 0)) | |
2590 | ✗ | minplaylist = i; | |
2591 | } | ||
2592 | } | ||
2593 | } | ||
2594 | |||
2595 | /* If we got a packet, return it */ | ||
2596 |
2/2✓ Branch 0 taken 6357 times.
✓ Branch 1 taken 11 times.
|
6368 | if (minplaylist >= 0) { |
2597 | 6357 | struct playlist *pls = c->playlists[minplaylist]; | |
2598 | AVStream *ist; | ||
2599 | AVStream *st; | ||
2600 | |||
2601 | 6357 | ret = update_streams_from_subdemuxer(s, pls); | |
2602 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6357 times.
|
6357 | if (ret < 0) { |
2603 | ✗ | av_packet_unref(pls->pkt); | |
2604 | ✗ | return ret; | |
2605 | } | ||
2606 | |||
2607 | // If sub-demuxer reports updated metadata, copy it to the first stream | ||
2608 | // and set its AVSTREAM_EVENT_FLAG_METADATA_UPDATED flag. | ||
2609 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6357 times.
|
6357 | if (pls->ctx->event_flags & AVFMT_EVENT_FLAG_METADATA_UPDATED) { |
2610 | ✗ | if (pls->n_main_streams) { | |
2611 | ✗ | st = pls->main_streams[0]; | |
2612 | ✗ | av_dict_copy(&st->metadata, pls->ctx->metadata, 0); | |
2613 | ✗ | st->event_flags |= AVSTREAM_EVENT_FLAG_METADATA_UPDATED; | |
2614 | } | ||
2615 | ✗ | pls->ctx->event_flags &= ~AVFMT_EVENT_FLAG_METADATA_UPDATED; | |
2616 | } | ||
2617 | |||
2618 | /* check if noheader flag has been cleared by the subdemuxer */ | ||
2619 |
3/4✓ Branch 0 taken 11 times.
✓ Branch 1 taken 6346 times.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
|
6357 | if (pls->has_noheader_flag && !(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER)) { |
2620 | 11 | pls->has_noheader_flag = 0; | |
2621 | 11 | update_noheader_flag(s); | |
2622 | } | ||
2623 | |||
2624 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6357 times.
|
6357 | if (pls->pkt->stream_index >= pls->n_main_streams) { |
2625 | ✗ | av_log(s, AV_LOG_ERROR, "stream index inconsistency: index %d, %d main streams, %d subdemuxer streams\n", | |
2626 | ✗ | pls->pkt->stream_index, pls->n_main_streams, pls->ctx->nb_streams); | |
2627 | ✗ | av_packet_unref(pls->pkt); | |
2628 | ✗ | return AVERROR_BUG; | |
2629 | } | ||
2630 | |||
2631 | 6357 | ist = pls->ctx->streams[pls->pkt->stream_index]; | |
2632 | 6357 | st = pls->main_streams[pls->pkt->stream_index]; | |
2633 | |||
2634 | 6357 | av_packet_move_ref(pkt, pls->pkt); | |
2635 | 6357 | pkt->stream_index = st->index; | |
2636 | |||
2637 |
1/2✓ Branch 0 taken 6357 times.
✗ Branch 1 not taken.
|
6357 | if (pkt->dts != AV_NOPTS_VALUE) |
2638 | 6357 | c->cur_timestamp = av_rescale_q(pkt->dts, | |
2639 | ist->time_base, | ||
2640 | 6357 | AV_TIME_BASE_Q); | |
2641 | |||
2642 | /* There may be more situations where this would be useful, but this at least | ||
2643 | * handles newly probed codecs properly (i.e. request_probe by mpegts). */ | ||
2644 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 6347 times.
|
6357 | if (ist->codecpar->codec_id != st->codecpar->codec_id) { |
2645 | 10 | ret = set_stream_info_from_input_stream(st, pls, ist); | |
2646 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | if (ret < 0) { |
2647 | ✗ | return ret; | |
2648 | } | ||
2649 | } | ||
2650 | |||
2651 | 6357 | return 0; | |
2652 | } | ||
2653 | 11 | return AVERROR_EOF; | |
2654 | } | ||
2655 | |||
2656 | ✗ | static int hls_read_seek(AVFormatContext *s, int stream_index, | |
2657 | int64_t timestamp, int flags) | ||
2658 | { | ||
2659 | ✗ | HLSContext *c = s->priv_data; | |
2660 | ✗ | struct playlist *seek_pls = NULL; | |
2661 | int i, j; | ||
2662 | int stream_subdemuxer_index; | ||
2663 | int64_t first_timestamp, seek_timestamp, duration; | ||
2664 | int64_t seq_no, seg_start_ts; | ||
2665 | |||
2666 | ✗ | if ((flags & AVSEEK_FLAG_BYTE) || (c->ctx->ctx_flags & AVFMTCTX_UNSEEKABLE)) | |
2667 | ✗ | return AVERROR(ENOSYS); | |
2668 | |||
2669 | ✗ | first_timestamp = c->first_timestamp == AV_NOPTS_VALUE ? | |
2670 | ✗ | 0 : c->first_timestamp; | |
2671 | |||
2672 | ✗ | seek_timestamp = av_rescale_rnd(timestamp, AV_TIME_BASE, | |
2673 | ✗ | s->streams[stream_index]->time_base.den, | |
2674 | AV_ROUND_DOWN); | ||
2675 | |||
2676 | ✗ | duration = s->duration == AV_NOPTS_VALUE ? | |
2677 | ✗ | 0 : s->duration; | |
2678 | |||
2679 | ✗ | if (0 < duration && duration < seek_timestamp - first_timestamp) | |
2680 | ✗ | return AVERROR(EIO); | |
2681 | |||
2682 | /* find the playlist with the specified stream */ | ||
2683 | ✗ | for (i = 0; i < c->n_playlists; i++) { | |
2684 | ✗ | struct playlist *pls = c->playlists[i]; | |
2685 | ✗ | for (j = 0; j < pls->n_main_streams; j++) { | |
2686 | ✗ | if (pls->main_streams[j] == s->streams[stream_index]) { | |
2687 | ✗ | seek_pls = pls; | |
2688 | ✗ | stream_subdemuxer_index = j; | |
2689 | ✗ | break; | |
2690 | } | ||
2691 | } | ||
2692 | } | ||
2693 | /* check if the timestamp is valid for the playlist with the | ||
2694 | * specified stream index */ | ||
2695 | ✗ | if (!seek_pls || !find_timestamp_in_playlist(c, seek_pls, seek_timestamp, &seq_no, &seg_start_ts)) | |
2696 | ✗ | return AVERROR(EIO); | |
2697 | |||
2698 | ✗ | if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && | |
2699 | ✗ | flags & AVSEEK_FLAG_BACKWARD && !(flags & AVSEEK_FLAG_ANY)) { | |
2700 | /* Seeking to start of segment ensures we seek to a keyframe located | ||
2701 | * before the given timestamp. */ | ||
2702 | ✗ | seek_timestamp = seg_start_ts; | |
2703 | } | ||
2704 | |||
2705 | /* set segment now so we do not need to search again below */ | ||
2706 | ✗ | seek_pls->cur_seq_no = seq_no; | |
2707 | ✗ | seek_pls->seek_stream_index = stream_subdemuxer_index; | |
2708 | |||
2709 | ✗ | for (i = 0; i < c->n_playlists; i++) { | |
2710 | /* Reset reading */ | ||
2711 | ✗ | struct playlist *pls = c->playlists[i]; | |
2712 | ✗ | AVIOContext *const pb = &pls->pb.pub; | |
2713 | ✗ | ff_format_io_close(pls->parent, &pls->input); | |
2714 | ✗ | pls->input_read_done = 0; | |
2715 | ✗ | ff_format_io_close(pls->parent, &pls->input_next); | |
2716 | ✗ | pls->input_next_requested = 0; | |
2717 | ✗ | av_packet_unref(pls->pkt); | |
2718 | ✗ | pb->eof_reached = 0; | |
2719 | /* Clear any buffered data */ | ||
2720 | ✗ | pb->buf_end = pb->buf_ptr = pb->buffer; | |
2721 | /* Reset the pos, to let the mpegts/mov demuxer know we've seeked. */ | ||
2722 | ✗ | pb->pos = 0; | |
2723 | /* Flush the packet queue of the subdemuxer. */ | ||
2724 | ✗ | if (pls->ctx) | |
2725 | ✗ | ff_read_frame_flush(pls->ctx); | |
2726 | ✗ | if (pls->is_subtitle) | |
2727 | ✗ | avformat_close_input(&pls->ctx); | |
2728 | |||
2729 | /* Reset the init segment so it's re-fetched and served appropiately */ | ||
2730 | ✗ | pls->cur_init_section = NULL; | |
2731 | |||
2732 | ✗ | pls->seek_timestamp = seek_timestamp; | |
2733 | ✗ | pls->seek_flags = flags; | |
2734 | |||
2735 | ✗ | if (pls != seek_pls) { | |
2736 | /* set closest segment seq_no for playlists not handled above */ | ||
2737 | ✗ | find_timestamp_in_playlist(c, pls, seek_timestamp, &pls->cur_seq_no, NULL); | |
2738 | /* seek the playlist to the given position without taking | ||
2739 | * keyframes into account since this playlist does not have the | ||
2740 | * specified stream where we should look for the keyframes */ | ||
2741 | ✗ | pls->seek_stream_index = -1; | |
2742 | ✗ | pls->seek_flags |= AVSEEK_FLAG_ANY; | |
2743 | } | ||
2744 | } | ||
2745 | |||
2746 | ✗ | c->cur_timestamp = seek_timestamp; | |
2747 | |||
2748 | ✗ | return 0; | |
2749 | } | ||
2750 | |||
2751 | 7233 | static int hls_probe(const AVProbeData *p) | |
2752 | { | ||
2753 | /* Require #EXTM3U at the start, and either one of the ones below | ||
2754 | * somewhere for a proper match. */ | ||
2755 |
2/2✓ Branch 0 taken 7221 times.
✓ Branch 1 taken 12 times.
|
7233 | if (strncmp(p->buf, "#EXTM3U", 7)) |
2756 | 7221 | return 0; | |
2757 | |||
2758 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (strstr(p->buf, "#EXT-X-STREAM-INF:") || |
2759 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | strstr(p->buf, "#EXT-X-TARGETDURATION:") || |
2760 | ✗ | strstr(p->buf, "#EXT-X-MEDIA-SEQUENCE:")) { | |
2761 | |||
2762 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
12 | int mime_ok = p->mime_type && !( |
2763 | ✗ | av_strcasecmp(p->mime_type, "application/vnd.apple.mpegurl") && | |
2764 | ✗ | av_strcasecmp(p->mime_type, "audio/mpegurl") | |
2765 | ); | ||
2766 | |||
2767 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
12 | int mime_x = p->mime_type && !( |
2768 | ✗ | av_strcasecmp(p->mime_type, "audio/x-mpegurl") && | |
2769 | ✗ | av_strcasecmp(p->mime_type, "application/x-mpegurl") | |
2770 | ); | ||
2771 | |||
2772 |
2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
|
12 | if (!mime_ok && |
2773 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | !mime_x && |
2774 |
0/2✗ Branch 1 not taken.
✗ Branch 2 not taken.
|
12 | !av_match_ext (p->filename, "m3u8,m3u") && |
2775 | ✗ | ff_match_url_ext(p->filename, "m3u8,m3u") <= 0) { | |
2776 | ✗ | av_log(NULL, AV_LOG_ERROR, "Not detecting m3u8/hls with non standard extension and non standard mime type\n"); | |
2777 | ✗ | return 0; | |
2778 | } | ||
2779 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (mime_x) |
2780 | ✗ | av_log(NULL, AV_LOG_WARNING, "mime type is not rfc8216 compliant\n"); | |
2781 | |||
2782 | 12 | return AVPROBE_SCORE_MAX; | |
2783 | } | ||
2784 | ✗ | return 0; | |
2785 | } | ||
2786 | |||
2787 | #define OFFSET(x) offsetof(HLSContext, x) | ||
2788 | #define FLAGS AV_OPT_FLAG_DECODING_PARAM | ||
2789 | static const AVOption hls_options[] = { | ||
2790 | {"live_start_index", "segment index to start live streams at (negative values are from the end)", | ||
2791 | OFFSET(live_start_index), AV_OPT_TYPE_INT, {.i64 = -3}, INT_MIN, INT_MAX, FLAGS}, | ||
2792 | {"prefer_x_start", "prefer to use #EXT-X-START if it's in playlist instead of live_start_index", | ||
2793 | OFFSET(prefer_x_start), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS}, | ||
2794 | {"allowed_extensions", "List of file extensions that hls is allowed to access", | ||
2795 | OFFSET(allowed_extensions), AV_OPT_TYPE_STRING, | ||
2796 | {.str = "3gp,aac,avi,ac3,eac3,flac,mkv,m3u8,m4a,m4s,m4v,mpg,mov,mp2,mp3,mp4,mpeg,mpegts,ogg,ogv,oga,ts,vob,vtt,wav,webvtt" | ||
2797 | ",cmfv,cmfa" // Ticket11526 www.nicovideo.jp | ||
2798 | ",ec3" // part of Ticket11435 (Elisa Viihde (Finnish online recording service)) | ||
2799 | ",fmp4" // https://github.com/yt-dlp/yt-dlp/issues/12700 | ||
2800 | }, | ||
2801 | INT_MIN, INT_MAX, FLAGS}, | ||
2802 | {"allowed_segment_extensions", "List of file extensions that hls is allowed to access", | ||
2803 | OFFSET(allowed_segment_extensions), AV_OPT_TYPE_STRING, | ||
2804 | {.str = "3gp,aac,avi,ac3,eac3,flac,mkv,m3u8,m4a,m4s,m4v,mpg,mov,mp2,mp3,mp4,mpeg,mpegts,ogg,ogv,oga,ts,vob,vtt,wav,webvtt" | ||
2805 | ",cmfv,cmfa" // Ticket11526 www.nicovideo.jp | ||
2806 | ",ec3" // part of Ticket11435 (Elisa Viihde (Finnish online recording service)) | ||
2807 | ",fmp4" // https://github.com/yt-dlp/yt-dlp/issues/12700 | ||
2808 | ",html" // https://flash1.bogulus.cfd/ | ||
2809 | }, | ||
2810 | INT_MIN, INT_MAX, FLAGS}, | ||
2811 | {"extension_picky", "Be picky with all extensions matching", | ||
2812 | OFFSET(extension_picky), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS}, | ||
2813 | {"max_reload", "Maximum number of times a insufficient list is attempted to be reloaded", | ||
2814 | OFFSET(max_reload), AV_OPT_TYPE_INT, {.i64 = 100}, 0, INT_MAX, FLAGS}, | ||
2815 | {"m3u8_hold_counters", "The maximum number of times to load m3u8 when it refreshes without new segments", | ||
2816 | OFFSET(m3u8_hold_counters), AV_OPT_TYPE_INT, {.i64 = 1000}, 0, INT_MAX, FLAGS}, | ||
2817 | {"http_persistent", "Use persistent HTTP connections", | ||
2818 | OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS }, | ||
2819 | {"http_multiple", "Use multiple HTTP connections for fetching segments", | ||
2820 | OFFSET(http_multiple), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, FLAGS}, | ||
2821 | {"http_seekable", "Use HTTP partial requests, 0 = disable, 1 = enable, -1 = auto", | ||
2822 | OFFSET(http_seekable), AV_OPT_TYPE_BOOL, { .i64 = -1}, -1, 1, FLAGS}, | ||
2823 | {"seg_format_options", "Set options for segment demuxer", | ||
2824 | OFFSET(seg_format_opts), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, FLAGS}, | ||
2825 | {"seg_max_retry", "Maximum number of times to reload a segment on error.", | ||
2826 | OFFSET(seg_max_retry), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS}, | ||
2827 | {NULL} | ||
2828 | }; | ||
2829 | |||
2830 | static const AVClass hls_class = { | ||
2831 | .class_name = "hls demuxer", | ||
2832 | .item_name = av_default_item_name, | ||
2833 | .option = hls_options, | ||
2834 | .version = LIBAVUTIL_VERSION_INT, | ||
2835 | }; | ||
2836 | |||
2837 | const FFInputFormat ff_hls_demuxer = { | ||
2838 | .p.name = "hls", | ||
2839 | .p.long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"), | ||
2840 | .p.priv_class = &hls_class, | ||
2841 | .p.flags = AVFMT_NOGENSEARCH | AVFMT_TS_DISCONT | AVFMT_NO_BYTE_SEEK, | ||
2842 | .priv_data_size = sizeof(HLSContext), | ||
2843 | .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP, | ||
2844 | .read_probe = hls_probe, | ||
2845 | .read_header = hls_read_header, | ||
2846 | .read_packet = hls_read_packet, | ||
2847 | .read_close = hls_close, | ||
2848 | .read_seek = hls_read_seek, | ||
2849 | }; | ||
2850 |