c->n_renditions = 0;
}
-/*
- * Used to reset a statically allocated AVPacket to a clean state,
- * containing no data.
- */
-static void reset_packet(AVPacket *pkt)
-{
- av_init_packet(pkt);
- pkt->data = NULL;
-}
-
static struct playlist *new_playlist(HLSContext *c, const char *url,
const char *base)
{
struct playlist *pls = av_mallocz(sizeof(struct playlist));
if (!pls)
return NULL;
- reset_packet(&pls->pkt);
ff_make_absolute_url(pls->url, sizeof(pls->url), base, url);
+ if (!pls->url[0]) {
+ av_free(pls);
+ return NULL;
+ }
+ av_init_packet(&pls->pkt);
pls->seek_timestamp = AV_NOPTS_VALUE;
pls->is_id3_timestamped = -1;
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;
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);
+ if (!tmp_str[0]) {
+ av_free(sec);
+ return NULL;
+ }
+ }
+ sec->url = av_strdup(ptr);
if (!sec->url) {
av_free(sec);
return NULL;
}
static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
- AVDictionary *opts, AVDictionary *opts2, int *is_http_out)
+ AVDictionary **opts, AVDictionary *opts2, int *is_http_out)
{
HLSContext *c = s->priv_data;
AVDictionary *tmp = NULL;
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)
}
} else if (av_strstart(proto_name, "http", NULL)) {
is_http = 1;
+ } else if (av_strstart(proto_name, "data", NULL)) {
+ ;
} else
return AVERROR_INVALIDDATA;
;
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, *opts, 0);
av_dict_copy(&tmp, opts2, 0);
if (is_http && c->http_persistent && *pb) {
av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);
if (new_cookies)
- av_dict_set(&opts, "cookies", new_cookies, AV_DICT_DONT_STRDUP_VAL);
+ av_dict_set(opts, "cookies", new_cookies, AV_DICT_DONT_STRDUP_VAL);
}
av_dict_free(&tmp);
if (key_type != KEY_NONE) {
ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, key);
+ if (!tmp_str[0]) {
+ av_free(cur_init_section);
+ ret = AVERROR_INVALIDDATA;
+ goto fail;
+ }
cur_init_section->key = av_strdup(tmp_str);
if (!cur_init_section->key) {
av_free(cur_init_section);
ret = AVERROR(ENOMEM);
goto fail;
}
- seg->duration = duration;
- seg->key_type = key_type;
if (has_iv) {
memcpy(seg->iv, iv, sizeof(iv));
} else {
if (key_type != KEY_NONE) {
ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, key);
+ if (!tmp_str[0]) {
+ ret = AVERROR_INVALIDDATA;
+ av_free(seg);
+ goto fail;
+ }
seg->key = av_strdup(tmp_str);
if (!seg->key) {
av_free(seg);
}
ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, line);
+ if (!tmp_str[0]) {
+ ret = AVERROR_INVALIDDATA;
+ if (seg->key)
+ av_free(seg->key);
+ av_free(seg);
+ goto fail;
+ }
seg->url = av_strdup(tmp_str);
if (!seg->url) {
av_free(seg->key);
goto fail;
}
+ if (duration < 0.001 * AV_TIME_BASE) {
+ av_log(c->ctx, AV_LOG_WARNING, "Cannot get correct #EXTINF value of segment %s,"
+ " set to default value to 1ms.\n", seg->url);
+ duration = 0.001 * AV_TIME_BASE;
+ }
+ seg->duration = duration;
+ seg->key_type = key_type;
dynarray_add(&pls->segments, &pls->n_segments, seg);
is_segment = 0;
ff_id3v2_read_dict(pb, metadata, ID3v2_DEFAULT_MAGIC, extra_meta);
for (meta = *extra_meta; meta; meta = meta->next) {
if (!strcmp(meta->tag, "PRIV")) {
- ID3v2ExtraMetaPRIV *priv = meta->data;
+ ID3v2ExtraMetaPRIV *priv = &meta->data.priv;
if (priv->datasize == 8 && !strcmp(priv->owner, id3_priv_owner_ts)) {
/* 33-bit MPEG timestamp */
int64_t ts = AV_RB64(priv->data);
av_log(s, AV_LOG_ERROR, "Invalid HLS ID3 audio timestamp %"PRId64"\n", ts);
}
} else if (!strcmp(meta->tag, "APIC") && apic)
- *apic = meta->data;
+ *apic = &meta->data.apic;
}
}
/* get picture attachment and set text metadata */
if (pls->ctx->nb_streams)
- ff_id3v2_parse_apic(pls->ctx, &extra_meta);
+ ff_id3v2_parse_apic(pls->ctx, extra_meta);
else
/* demuxer not yet opened, defer picture attachment */
pls->id3_deferred_extra = extra_meta;
- ff_id3v2_parse_priv_dict(&metadata, &extra_meta);
+ ff_id3v2_parse_priv_dict(&metadata, extra_meta);
av_dict_copy(&pls->ctx->metadata, metadata, 0);
pls->id3_initial = metadata;
seg->url, seg->url_offset, pls->index);
if (seg->key_type == KEY_NONE) {
- ret = open_url(pls->parent, in, seg->url, c->avio_opts, opts, &is_http);
+ ret = open_url(pls->parent, in, seg->url, &c->avio_opts, opts, &is_http);
} else if (seg->key_type == KEY_AES_128) {
char iv[33], key[33], url[MAX_URL_SIZE];
if (strcmp(seg->key, pls->key_url)) {
AVIOContext *pb = NULL;
- if (open_url(pls->parent, &pb, seg->key, c->avio_opts, opts, NULL) == 0) {
+ 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(pls->parent, AV_LOG_ERROR, "Unable to read key file %s\n",
av_dict_set(&opts, "key", key, 0);
av_dict_set(&opts, "iv", iv, 0);
- ret = open_url(pls->parent, in, url, c->avio_opts, opts, &is_http);
+ ret = open_url(pls->parent, in, url, &c->avio_opts, opts, &is_http);
if (ret < 0) {
goto cleanup;
}
* as would be expected. Wrong offset received from the server will not be
* noticed without the call, though.
*/
- if (ret == 0 && !is_http && seg->key_type == KEY_NONE && seg->url_offset) {
+ if (ret == 0 && !is_http && seg->url_offset) {
int64_t seekret = avio_seek(*in, seg->url_offset, SEEK_SET);
if (seekret < 0) {
av_log(pls->parent, AV_LOG_ERROR, "Unable to seek to offset %"PRId64" of HLS segment '%s'\n", seg->url_offset, seg->url);
{
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;
else
avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
+ // copy disposition
+ st->disposition = ist->disposition;
+
+ // copy side data
+ for (int i = 0; i < ist->nb_side_data; i++) {
+ const AVPacketSideData *sd_src = &ist->side_data[i];
+ uint8_t *dst_data;
+
+ dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
+ if (!dst_data)
+ return AVERROR(ENOMEM);
+ memcpy(dst_data, sd_src->data, sd_src->size);
+ }
+
st->internal->need_context_update = 1;
return 0;
/* Open the demuxer for each playlist */
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
+ char *url;
ff_const59 AVInputFormat *in_fmt = NULL;
if (!(pls->ctx = avformat_alloc_context())) {
read_data, NULL, NULL);
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);
+ pls->ctx->interrupt_callback = s->interrupt_callback;
+ url = av_strdup(pls->segments[0]->url);
+ ret = av_probe_input_buffer(&pls->pb, &in_fmt, url, NULL, 0, 0);
if (ret < 0) {
/* Free the ctx - it isn't initialized properly at this point,
* so avformat_close_input shouldn't be called. If
* avformat_open_input fails below, it frees and zeros the
* context, so it doesn't need any special treatment like this. */
- av_log(s, AV_LOG_ERROR, "Error when loading first segment '%s'\n", pls->segments[0]->url);
+ av_log(s, AV_LOG_ERROR, "Error when loading first segment '%s'\n", url);
avformat_free_context(pls->ctx);
pls->ctx = NULL;
+ av_free(url);
goto fail;
}
+ av_free(url);
pls->ctx->pb = &pls->pb;
pls->ctx->io_open = nested_io_open;
pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
goto fail;
if (pls->id3_deferred_extra && pls->ctx->nb_streams == 1) {
- ff_id3v2_parse_apic(pls->ctx, &pls->id3_deferred_extra);
+ ff_id3v2_parse_apic(pls->ctx, pls->id3_deferred_extra);
avformat_queue_attached_pictures(pls->ctx);
- ff_id3v2_parse_priv(pls->ctx, &pls->id3_deferred_extra);
+ ff_id3v2_parse_priv(pls->ctx, pls->id3_deferred_extra);
ff_id3v2_free_extra_meta(&pls->id3_deferred_extra);
- pls->id3_deferred_extra = NULL;
}
if (pls->is_id3_timestamped == -1)
if (ret < 0) {
if (!avio_feof(&pls->pb) && ret != AVERROR_EOF)
return ret;
- reset_packet(&pls->pkt);
break;
} else {
/* stream_index check prevents matching picture attachments etc. */
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,
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;
}
}
OFFSET(live_start_index), AV_OPT_TYPE_INT, {.i64 = -3}, INT_MIN, INT_MAX, FLAGS},
{"allowed_extensions", "List of file extensions that hls is allowed to access",
OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,
- {.str = "3gp,aac,avi,flac,mkv,m3u8,m4a,m4s,m4v,mpg,mov,mp2,mp3,mp4,mpeg,mpegts,ogg,ogv,oga,ts,vob,wav"},
+ {.str = "3gp,aac,avi,ac3,eac3,flac,mkv,m3u8,m4a,m4s,m4v,mpg,mov,mp2,mp3,mp4,mpeg,mpegts,ogg,ogv,oga,ts,vob,wav"},
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", "Maximum number of times requests when the m3u8 file not be refresh",
+ {"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 },