FFmpeg coverage

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