X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Fhls.c;h=fc45719d1c0171415a459f5e59a486a716f29309;hb=de0b04551da4e1470ce1c99321a768887df8c650;hp=8ad08baaed41c5af1f7c0551ddd507069c5eb935;hpb=27e30c73d722ec13e59753dea91be00859c72bf2;p=ffmpeg diff --git a/libavformat/hls.c b/libavformat/hls.c index 8ad08baaed4..fc45719d1c0 100644 --- a/libavformat/hls.c +++ b/libavformat/hls.c @@ -116,7 +116,10 @@ struct playlist { int n_segments; struct segment **segments; int needed; + int broken; int cur_seq_no; + int last_seq_no; + int m3u8_hold_counters; int64_t cur_seg_offset; int64_t last_load_time; @@ -197,17 +200,18 @@ typedef struct HLSContext { struct rendition **renditions; int cur_seq_no; + int m3u8_hold_counters; int live_start_index; int first_packet; int64_t first_timestamp; int64_t cur_timestamp; AVIOInterruptCB *interrupt_callback; AVDictionary *avio_opts; - int strict_std_compliance; char *allowed_extensions; int max_reload; int http_persistent; int http_multiple; + int http_seekable; AVIOContext *playlist_pb; } HLSContext; @@ -223,9 +227,9 @@ static void free_segment_dynarray(struct segment **segments, int n_segments) static void free_segment_list(struct playlist *pls) { - free_segment_dynarray(pls->segments, pls->n_segments); - av_freep(&pls->segments); - pls->n_segments = 0; + free_segment_dynarray(pls->segments, pls->n_segments); + av_freep(&pls->segments); + pls->n_segments = 0; } static void free_init_section_list(struct playlist *pls) @@ -254,11 +258,9 @@ static void free_playlist_list(HLSContext *c) av_freep(&pls->init_sec_buf); av_packet_unref(&pls->pkt); av_freep(&pls->pb.buffer); - if (pls->input) - ff_format_io_close(c->ctx, &pls->input); + ff_format_io_close(c->ctx, &pls->input); pls->input_read_done = 0; - if (pls->input_next) - ff_format_io_close(c->ctx, &pls->input_next); + ff_format_io_close(c->ctx, &pls->input_next); pls->input_next_requested = 0; if (pls->ctx) { pls->ctx->pb = NULL; @@ -292,7 +294,7 @@ static void free_rendition_list(HLSContext *c) } /* - * Used to reset a statically allocated AVPacket to a clean slate, + * Used to reset a statically allocated AVPacket to a clean state, * containing no data. */ static void reset_packet(AVPacket *pkt) @@ -401,8 +403,7 @@ static struct segment *new_init_section(struct playlist *pls, const char *url_base) { struct segment *sec; - char *ptr; - char tmp_str[MAX_URL_SIZE]; + char tmp_str[MAX_URL_SIZE], *ptr = tmp_str; if (!info->uri[0]) return NULL; @@ -411,8 +412,12 @@ static struct segment *new_init_section(struct playlist *pls, if (!sec) return NULL; - ff_make_absolute_url(tmp_str, sizeof(tmp_str), url_base, info->uri); - sec->url = av_strdup(tmp_str); + if (!av_strncasecmp(info->uri, "data:", 5)) { + ptr = info->uri; + } else { + ff_make_absolute_url(tmp_str, sizeof(tmp_str), url_base, info->uri); + } + sec->url = av_strdup(ptr); if (!sec->url) { av_free(sec); return NULL; @@ -477,17 +482,23 @@ static struct rendition *new_rendition(HLSContext *c, struct rendition_info *inf * AVC SEI RBSP anyway */ return NULL; - if (type == AVMEDIA_TYPE_UNKNOWN) + if (type == AVMEDIA_TYPE_UNKNOWN) { + av_log(c->ctx, AV_LOG_WARNING, "Can't support the type: %s\n", info->type); return NULL; + } /* URI is mandatory for subtitles as per spec */ - if (type == AVMEDIA_TYPE_SUBTITLE && !info->uri[0]) + if (type == AVMEDIA_TYPE_SUBTITLE && !info->uri[0]) { + av_log(c->ctx, AV_LOG_ERROR, "The URI tag is REQUIRED for subtitle.\n"); return NULL; + } /* TODO: handle subtitles (each segment has to parsed separately) */ - if (c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) - if (type == AVMEDIA_TYPE_SUBTITLE) + if (c->ctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) + if (type == AVMEDIA_TYPE_SUBTITLE) { + av_log(c->ctx, AV_LOG_WARNING, "Can't support the subtitle(uri: %s)\n", info->uri); return NULL; + } rend = av_mallocz(sizeof(struct rendition)); if (!rend) @@ -590,7 +601,7 @@ static int ensure_playlist(HLSContext *c, struct playlist **pls, const char *url } static int open_url_keepalive(AVFormatContext *s, AVIOContext **pb, - const char *url) + const char *url, AVDictionary **options) { #if !CONFIG_HTTP_PROTOCOL return AVERROR_PROTOCOL_NOT_FOUND; @@ -599,7 +610,7 @@ static int open_url_keepalive(AVFormatContext *s, AVIOContext **pb, URLContext *uc = ffio_geturlcontext(*pb); av_assert0(uc); (*pb)->eof_reached = 0; - ret = ff_http_do_new_request(uc, url); + ret = ff_http_do_new_request2(uc, url, options); if (ret < 0) { ff_format_io_close(s, pb); } @@ -616,12 +627,12 @@ static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url, int ret; int is_http = 0; - av_dict_copy(&tmp, opts, 0); - av_dict_copy(&tmp, opts2, 0); - if (av_strstart(url, "crypto", NULL)) { if (url[6] == '+' || url[6] == ':') proto_name = avio_find_protocol_name(url + 7); + } else if (av_strstart(url, "data", NULL)) { + if (url[4] == '+' || url[4] == ':') + proto_name = avio_find_protocol_name(url + 5); } if (!proto_name) @@ -641,6 +652,8 @@ static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url, } } else if (av_strstart(proto_name, "http", NULL)) { is_http = 1; + } else if (av_strstart(proto_name, "data", NULL)) { + ; } else return AVERROR_INVALIDDATA; @@ -648,17 +661,23 @@ static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url, ; else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':') ; + else if (av_strstart(url, "data", NULL) && !strncmp(proto_name, url + 5, strlen(proto_name)) && url[5 + strlen(proto_name)] == ':') + ; else if (strcmp(proto_name, "file") || !strncmp(url, "file,", 5)) return AVERROR_INVALIDDATA; + av_dict_copy(&tmp, opts, 0); + av_dict_copy(&tmp, opts2, 0); + if (is_http && c->http_persistent && *pb) { - ret = open_url_keepalive(c->ctx, pb, url); + ret = open_url_keepalive(c->ctx, pb, url, &tmp); if (ret == AVERROR_EXIT) { + av_dict_free(&tmp); return ret; } else if (ret < 0) { if (ret != AVERROR_EOF) av_log(s, AV_LOG_WARNING, - "keepalive request failed for '%s', retrying with new connection: %s\n", + "keepalive request failed for '%s' with error: '%s' when opening url, retrying with new connection\n", url, av_err2str(ret)); ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp); } @@ -709,13 +728,13 @@ static int parse_playlist(HLSContext *c, const char *url, if (is_http && !in && c->http_persistent && c->playlist_pb) { in = c->playlist_pb; - ret = open_url_keepalive(c->ctx, &c->playlist_pb, url); + ret = open_url_keepalive(c->ctx, &c->playlist_pb, url, NULL); if (ret == AVERROR_EXIT) { return ret; } else if (ret < 0) { if (ret != AVERROR_EOF) av_log(c->ctx, AV_LOG_WARNING, - "keepalive request failed for '%s', retrying with new connection: %s\n", + "keepalive request failed for '%s' with error: '%s' when parsing playlist\n", url, av_err2str(ret)); in = NULL; } @@ -844,6 +863,7 @@ static int parse_playlist(HLSContext *c, const char *url, if (ptr) seg_offset = strtoll(ptr+1, NULL, 10); } else if (av_strstart(line, "#", NULL)) { + av_log(c->ctx, AV_LOG_INFO, "Skip ('%s')\n", line); continue; } else if (line[0]) { if (is_variant) { @@ -855,13 +875,9 @@ static int parse_playlist(HLSContext *c, const char *url, } if (is_segment) { struct segment *seg; - if (!pls) { - if (!new_variant(c, 0, url, NULL)) { - ret = AVERROR(ENOMEM); - goto fail; - } - pls = c->playlists[c->n_playlists - 1]; - } + ret = ensure_playlist(c, &pls, url); + if (ret < 0) + goto fail; seg = av_malloc(sizeof(struct segment)); if (!seg) { ret = AVERROR(ENOMEM); @@ -931,6 +947,7 @@ static int parse_playlist(HLSContext *c, const char *url, prev_start_seq_no, pls->start_seq_no); } free_segment_dynarray(prev_segments, prev_n_segments); + av_freep(&prev_segments); } if (pls) pls->last_load_time = av_gettime_relative(); @@ -1064,7 +1081,7 @@ static void handle_id3(AVIOContext *pb, struct playlist *pls) } else { if (!pls->id3_changed && id3_has_changed_values(pls, metadata, apic)) { - avpriv_report_missing_feature(pls->ctx, "Changing ID3 metadata in HLS audio elementary stream"); + avpriv_report_missing_feature(pls->parent, "Changing ID3 metadata in HLS audio elementary stream"); pls->id3_changed = 1; } av_dict_free(&metadata); @@ -1115,7 +1132,7 @@ static void intercept_id3(struct playlist *pls, uint8_t *buf, int remaining = taglen - tag_got_bytes; if (taglen > maxsize) { - av_log(pls->ctx, AV_LOG_ERROR, "Too large HLS ID3 tag (%d > %"PRId64" bytes)\n", + av_log(pls->parent, AV_LOG_ERROR, "Too large HLS ID3 tag (%d > %"PRId64" bytes)\n", taglen, maxsize); break; } @@ -1136,14 +1153,14 @@ static void intercept_id3(struct playlist *pls, uint8_t *buf, /* strip the intercepted bytes */ *len -= tag_got_bytes; memmove(buf, buf + tag_got_bytes, *len); - av_log(pls->ctx, AV_LOG_DEBUG, "Stripped %d HLS ID3 bytes\n", tag_got_bytes); + av_log(pls->parent, AV_LOG_DEBUG, "Stripped %d HLS ID3 bytes\n", tag_got_bytes); if (remaining > 0) { /* read the rest of the tag in */ if (read_from_url(pls, seg, pls->id3_buf + id3_buf_pos, remaining) != remaining) break; id3_buf_pos += remaining; - av_log(pls->ctx, AV_LOG_DEBUG, "Stripped additional %d HLS ID3 bytes\n", remaining); + av_log(pls->parent, AV_LOG_DEBUG, "Stripped additional %d HLS ID3 bytes\n", remaining); } } else { @@ -1202,12 +1219,12 @@ static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, if (open_url(pls->parent, &pb, seg->key, c->avio_opts, opts, NULL) == 0) { ret = avio_read(pb, pls->key, sizeof(pls->key)); if (ret != sizeof(pls->key)) { - av_log(NULL, AV_LOG_ERROR, "Unable to read key file %s\n", + av_log(pls->parent, AV_LOG_ERROR, "Unable to read key file %s\n", seg->key); } ff_format_io_close(pls->parent, &pb); } else { - av_log(NULL, AV_LOG_ERROR, "Unable to open key file %s\n", + av_log(pls->parent, AV_LOG_ERROR, "Unable to open key file %s\n", seg->key); } av_strlcpy(pls->key_url, seg->key, sizeof(pls->key_url)); @@ -1392,8 +1409,8 @@ restart: v->needed = playlist_needed(v); if (!v->needed) { - av_log(v->parent, AV_LOG_INFO, "No longer receiving playlist %d\n", - v->index); + av_log(v->parent, AV_LOG_INFO, "No longer receiving playlist %d ('%s')\n", + v->index, v->url); return AVERROR_EOF; } @@ -1419,11 +1436,22 @@ reload: reload_interval = v->target_duration / 2; } if (v->cur_seq_no < v->start_seq_no) { - av_log(NULL, AV_LOG_WARNING, + av_log(v->parent, AV_LOG_WARNING, "skipping %d segments ahead, expired from playlists\n", v->start_seq_no - v->cur_seq_no); v->cur_seq_no = v->start_seq_no; } + if (v->cur_seq_no > v->last_seq_no) { + v->last_seq_no = v->cur_seq_no; + v->m3u8_hold_counters = 0; + } else if (v->last_seq_no == v->cur_seq_no) { + v->m3u8_hold_counters++; + if (v->m3u8_hold_counters >= c->m3u8_hold_counters) { + return AVERROR_EOF; + } + } else { + av_log(v->parent, AV_LOG_WARNING, "maybe the m3u8 list sequence have been wraped.\n"); + } if (v->cur_seq_no >= v->start_seq_no + v->n_segments) { if (v->finished) return AVERROR_EOF; @@ -1446,6 +1474,7 @@ reload: if (c->http_multiple == 1 && v->input_next_requested) { FFSWAP(AVIOContext *, v->input, v->input_next); + v->cur_seg_offset = 0; v->input_next_requested = 0; ret = 0; } else { @@ -1467,7 +1496,7 @@ reload: uint8_t *http_version_opt = NULL; int r = av_opt_get(v->input, "http_version", AV_OPT_SEARCH_CHILDREN, &http_version_opt); if (r >= 0) { - c->http_multiple = strncmp((const char *)http_version_opt, "1.1", 3) == 0; + c->http_multiple = (!strncmp((const char *)http_version_opt, "1.1", 3) || !strncmp((const char *)http_version_opt, "2.0", 3)); av_freep(&http_version_opt); } } @@ -1479,7 +1508,7 @@ reload: if (ret < 0) { if (ff_check_interrupt(c->interrupt_callback)) return AVERROR_EXIT; - av_log(v->parent, AV_LOG_WARNING, "Failed to open segment %d of playlist %d\n", + av_log(v->parent, AV_LOG_WARNING, "Failed to open next segment %d of playlist %d\n", v->cur_seq_no + 1, v->index); } else { @@ -1644,7 +1673,7 @@ static int save_avio_options(AVFormatContext *s) { HLSContext *c = s->priv_data; static const char * const opts[] = { - "headers", "http_proxy", "user_agent", "cookies", "referer", "rw_timeout", NULL }; + "headers", "http_proxy", "user_agent", "cookies", "referer", "rw_timeout", "icy", NULL }; const char * const * opt = opts; uint8_t *buf; int ret = 0; @@ -1785,7 +1814,6 @@ static int hls_read_header(AVFormatContext *s) c->ctx = s; c->interrupt_callback = &s->interrupt_callback; - c->strict_std_compliance = s->strict_std_compliance; c->first_packet = 1; c->first_timestamp = AV_NOPTS_VALUE; @@ -1794,14 +1822,16 @@ static int hls_read_header(AVFormatContext *s) if ((ret = save_avio_options(s)) < 0) goto fail; - /* Some HLS servers don't like being sent the range header */ - av_dict_set(&c->avio_opts, "seekable", "0", 0); + /* XXX: Some HLS servers don't like being sent the range header, + in this case, need to setting http_seekable = 0 to disable + the range header */ + av_dict_set_int(&c->avio_opts, "seekable", c->http_seekable, 0); if ((ret = parse_playlist(c, s->url, NULL, s->pb)) < 0) goto fail; if (c->n_variants == 0) { - av_log(NULL, AV_LOG_WARNING, "Empty playlist\n"); + av_log(s, AV_LOG_WARNING, "Empty playlist\n"); ret = AVERROR_EOF; goto fail; } @@ -1810,15 +1840,22 @@ static int hls_read_header(AVFormatContext *s) if (c->n_playlists > 1 || c->playlists[0]->n_segments == 0) { for (i = 0; i < c->n_playlists; i++) { struct playlist *pls = c->playlists[i]; - if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0) + pls->m3u8_hold_counters = 0; + if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0) { + av_log(s, AV_LOG_WARNING, "parse_playlist error %s [%s]\n", av_err2str(ret), pls->url); + pls->broken = 1; + if (c->n_playlists > 1) + continue; goto fail; + } } } - if (c->variants[0]->playlists[0]->n_segments == 0) { - av_log(NULL, AV_LOG_WARNING, "Empty playlist\n"); - ret = AVERROR_EOF; - goto fail; + for (i = 0; i < c->n_variants; i++) { + if (c->variants[i]->playlists[0]->n_segments == 0) { + av_log(s, AV_LOG_WARNING, "Empty segment [%s]\n", c->variants[i]->playlists[0]->url); + c->variants[i]->playlists[0]->broken = 1; + } } /* If this isn't a live stream, calculate the total duration of the @@ -1867,7 +1904,7 @@ static int hls_read_header(AVFormatContext *s) /* Open the demuxer for each playlist */ for (i = 0; i < c->n_playlists; i++) { struct playlist *pls = c->playlists[i]; - AVInputFormat *in_fmt = NULL; + ff_const59 AVInputFormat *in_fmt = NULL; if (!(pls->ctx = avformat_alloc_context())) { ret = AVERROR(ENOMEM); @@ -1902,7 +1939,8 @@ static int hls_read_header(AVFormatContext *s) } ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls, read_data, NULL, NULL); - pls->pb.seekable = 0; + pls->ctx->probesize = s->probesize > 0 ? s->probesize : 1024 * 4; + pls->ctx->max_analyze_duration = s->max_analyze_duration > 0 ? s->max_analyze_duration : 4 * AV_TIME_BASE; ret = av_probe_input_buffer(&pls->pb, &in_fmt, pls->segments[0]->url, NULL, 0, 0); if (ret < 0) { @@ -1943,7 +1981,7 @@ static int hls_read_header(AVFormatContext *s) * but for other streams we can rely on our user calling avformat_find_stream_info() * on us if they want to. */ - if (pls->is_id3_timestamped) { + if (pls->is_id3_timestamped || (pls->n_renditions > 0 && pls->renditions[0]->type == AVMEDIA_TYPE_AUDIO)) { ret = avformat_find_stream_info(pls->ctx, NULL); if (ret < 0) goto fail; @@ -1988,6 +2026,9 @@ static int recheck_discard_flags(AVFormatContext *s, int first) cur_needed = playlist_needed(c->playlists[i]); + if (pls->broken) { + continue; + } if (cur_needed && !pls->needed) { pls->needed = 1; changed = 1; @@ -2001,11 +2042,9 @@ static int recheck_discard_flags(AVFormatContext *s, int first) } av_log(s, AV_LOG_INFO, "Now receiving playlist %d, segment %d\n", i, pls->cur_seq_no); } else if (first && !cur_needed && pls->needed) { - if (pls->input) - ff_format_io_close(pls->parent, &pls->input); + ff_format_io_close(pls->parent, &pls->input); pls->input_read_done = 0; - if (pls->input_next) - ff_format_io_close(pls->parent, &pls->input_next); + ff_format_io_close(pls->parent, &pls->input_next); pls->input_next_requested = 0; pls->needed = 0; changed = 1; @@ -2114,7 +2153,6 @@ static int hls_read_packet(AVFormatContext *s, AVPacket *pkt) } } av_packet_unref(&pls->pkt); - reset_packet(&pls->pkt); } } /* Check if this stream has the packet with the lowest dts */ @@ -2143,7 +2181,6 @@ static int hls_read_packet(AVFormatContext *s, AVPacket *pkt) ret = update_streams_from_subdemuxer(s, pls); if (ret < 0) { av_packet_unref(&pls->pkt); - reset_packet(&pls->pkt); return ret; } @@ -2168,16 +2205,14 @@ static int hls_read_packet(AVFormatContext *s, AVPacket *pkt) av_log(s, AV_LOG_ERROR, "stream index inconsistency: index %d, %d main streams, %d subdemuxer streams\n", pls->pkt.stream_index, pls->n_main_streams, pls->ctx->nb_streams); av_packet_unref(&pls->pkt); - reset_packet(&pls->pkt); return AVERROR_BUG; } ist = pls->ctx->streams[pls->pkt.stream_index]; st = pls->main_streams[pls->pkt.stream_index]; - *pkt = pls->pkt; + av_packet_move_ref(pkt, &pls->pkt); pkt->stream_index = st->index; - reset_packet(&c->playlists[minplaylist]->pkt); if (pkt->dts != AV_NOPTS_VALUE) c->cur_timestamp = av_rescale_q(pkt->dts, @@ -2189,7 +2224,6 @@ static int hls_read_packet(AVFormatContext *s, AVPacket *pkt) if (ist->codecpar->codec_id != st->codecpar->codec_id) { ret = set_stream_info_from_input_stream(st, pls, ist); if (ret < 0) { - av_packet_unref(pkt); return ret; } } @@ -2249,14 +2283,11 @@ static int hls_read_seek(AVFormatContext *s, int stream_index, for (i = 0; i < c->n_playlists; i++) { /* Reset reading */ struct playlist *pls = c->playlists[i]; - if (pls->input) - ff_format_io_close(pls->parent, &pls->input); + ff_format_io_close(pls->parent, &pls->input); pls->input_read_done = 0; - if (pls->input_next) - ff_format_io_close(pls->parent, &pls->input_next); + ff_format_io_close(pls->parent, &pls->input_next); pls->input_next_requested = 0; av_packet_unref(&pls->pkt); - reset_packet(&pls->pkt); pls->pb.eof_reached = 0; /* Clear any buffered data */ pls->pb.buf_end = pls->pb.buf_ptr = pls->pb.buffer; @@ -2284,7 +2315,7 @@ static int hls_read_seek(AVFormatContext *s, int stream_index, return 0; } -static int hls_probe(AVProbeData *p) +static int hls_probe(const AVProbeData *p) { /* Require #EXTM3U at the start, and either one of the ones below * somewhere for a proper match. */ @@ -2309,26 +2340,30 @@ static const AVOption hls_options[] = { INT_MIN, INT_MAX, FLAGS}, {"max_reload", "Maximum number of times a insufficient list is attempted to be reloaded", OFFSET(max_reload), AV_OPT_TYPE_INT, {.i64 = 1000}, 0, INT_MAX, FLAGS}, + {"m3u8_hold_counters", "The maximum number of times to load m3u8 when it refreshes without new segments", + OFFSET(m3u8_hold_counters), AV_OPT_TYPE_INT, {.i64 = 1000}, 0, INT_MAX, FLAGS}, {"http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS }, {"http_multiple", "Use multiple HTTP connections for fetching segments", OFFSET(http_multiple), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, FLAGS}, + {"http_seekable", "Use HTTP partial requests, 0 = disable, 1 = enable, -1 = auto", + OFFSET(http_seekable), AV_OPT_TYPE_BOOL, { .i64 = -1}, -1, 1, FLAGS}, {NULL} }; static const AVClass hls_class = { - .class_name = "hls,applehttp", + .class_name = "hls demuxer", .item_name = av_default_item_name, .option = hls_options, .version = LIBAVUTIL_VERSION_INT, }; AVInputFormat ff_hls_demuxer = { - .name = "hls,applehttp", + .name = "hls", .long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"), .priv_class = &hls_class, .priv_data_size = sizeof(HLSContext), - .flags = AVFMT_NOGENSEARCH, + .flags = AVFMT_NOGENSEARCH | AVFMT_TS_DISCONT, .read_probe = hls_probe, .read_header = hls_read_header, .read_packet = hls_read_packet,