enum AVMediaType type;
char id[20];
+ char *lang;
int bandwidth;
AVRational framerate;
AVStream *assoc_stream; /* demuxer stream associated with this representation */
typedef struct DASHContext {
const AVClass *class;
char *base_url;
- char *adaptionset_contenttype_val;
- char *adaptionset_par_val;
- char *adaptionset_lang_val;
- char *adaptionset_minbw_val;
- char *adaptionset_maxbw_val;
- char *adaptionset_minwidth_val;
- char *adaptionset_maxwidth_val;
- char *adaptionset_minheight_val;
- char *adaptionset_maxheight_val;
- char *adaptionset_minframerate_val;
- char *adaptionset_maxframerate_val;
- char *adaptionset_segmentalignment_val;
- char *adaptionset_bitstreamswitching_val;
int n_videos;
struct representation **videos;
uint64_t period_duration;
uint64_t period_start;
+ /* AdaptationSet Attribute */
+ char *adaptionset_lang;
+
int is_live;
AVIOInterruptCB *interrupt_callback;
char *allowed_extensions;
free_fragment(&pls->init_section);
av_freep(&pls->init_sec_buf);
av_freep(&pls->pb.buffer);
- if (pls->input)
- ff_format_io_close(pls->parent, &pls->input);
+ ff_format_io_close(pls->parent, &pls->input);
if (pls->ctx) {
pls->ctx->pb = NULL;
avformat_close_input(&pls->ctx);
continue;
}
text = xmlNodeGetContent(baseurl_nodes[i]);
- if (text) {
+ if (text && !av_strstart(text, "/", NULL)) {
memset(tmp_str, 0, strlen(tmp_str));
if (!ishttp(text) && isRootHttp) {
av_strlcpy(tmp_str, root_url, size + 1);
}
start = (text[0] == token);
+ if (start && av_stristr(tmp_str, text)) {
+ char *p = tmp_str;
+ if (!av_strncasecmp(tmp_str, "http://", 7)) {
+ p += 7;
+ } else if (!av_strncasecmp(tmp_str, "https://", 8)) {
+ p += 8;
+ }
+ p = strchr(p, '/');
+ memset(p + 1, 0, strlen(p));
+ }
av_strlcat(tmp_str, text + start, tmp_max_url_size);
xmlNodeSetContent(baseurl_nodes[i], tmp_str);
updated = 1;
ret = AVERROR(ENOMEM);
goto end;
}
+ if (c->adaptionset_lang) {
+ rep->lang = av_strdup(c->adaptionset_lang);
+ if (!rep->lang) {
+ av_log(s, AV_LOG_ERROR, "alloc language memory failure\n");
+ av_freep(&rep);
+ ret = AVERROR(ENOMEM);
+ goto end;
+ }
+ }
+ rep->parent = s;
representation_segmenttemplate_node = find_child_node_by_name(representation_node, "SegmentTemplate");
representation_baseurl_node = find_child_node_by_name(representation_node, "BaseURL");
representation_segmentlist_node = find_child_node_by_name(representation_node, "SegmentList");
xmlFree(timescale_val);
}
if (startnumber_val) {
- rep->first_seq_no = (int64_t) strtoll(startnumber_val, NULL, 10);
+ rep->start_number = rep->first_seq_no = (int64_t) strtoll(startnumber_val, NULL, 10);
av_log(s, AV_LOG_TRACE, "rep->first_seq_no = [%"PRId64"]\n", rep->first_seq_no);
xmlFree(startnumber_val);
}
duration_val = get_val_from_nodes_tab(segmentlists_tab, 3, "duration");
timescale_val = get_val_from_nodes_tab(segmentlists_tab, 3, "timescale");
+ startnumber_val = get_val_from_nodes_tab(segmentlists_tab, 3, "startNumber");
if (duration_val) {
rep->fragment_duration = (int64_t) strtoll(duration_val, NULL, 10);
av_log(s, AV_LOG_TRACE, "rep->fragment_duration = [%"PRId64"]\n", rep->fragment_duration);
av_log(s, AV_LOG_TRACE, "rep->fragment_timescale = [%"PRId64"]\n", rep->fragment_timescale);
xmlFree(timescale_val);
}
+ if (startnumber_val) {
+ rep->start_number = rep->first_seq_no = (int64_t) strtoll(startnumber_val, NULL, 10);
+ av_log(s, AV_LOG_TRACE, "rep->first_seq_no = [%"PRId64"]\n", rep->first_seq_no);
+ xmlFree(startnumber_val);
+ }
+
fragmenturl_node = xmlFirstElementChild(representation_segmentlist_node);
while (fragmenturl_node) {
ret = parse_manifest_segmenturlnode(s, rep, fragmenturl_node,
return ret;
}
+static int parse_manifest_adaptationset_attr(AVFormatContext *s, xmlNodePtr adaptionset_node)
+{
+ DASHContext *c = s->priv_data;
+
+ if (!adaptionset_node) {
+ av_log(s, AV_LOG_WARNING, "Cannot get AdaptionSet\n");
+ return AVERROR(EINVAL);
+ }
+ c->adaptionset_lang = xmlGetProp(adaptionset_node, "lang");
+
+ return 0;
+}
+
static int parse_manifest_adaptationset(AVFormatContext *s, const char *url,
xmlNodePtr adaptionset_node,
xmlNodePtr mpd_baseurl_node,
xmlNodePtr adaptionset_segmentlist_node = NULL;
xmlNodePtr adaptionset_supplementalproperty_node = NULL;
xmlNodePtr node = NULL;
- c->adaptionset_contenttype_val = xmlGetProp(adaptionset_node, "contentType");
- c->adaptionset_par_val = xmlGetProp(adaptionset_node, "par");
- c->adaptionset_lang_val = xmlGetProp(adaptionset_node, "lang");
- c->adaptionset_minbw_val = xmlGetProp(adaptionset_node, "minBandwidth");
- c->adaptionset_maxbw_val = xmlGetProp(adaptionset_node, "maxBandwidth");
- c->adaptionset_minwidth_val = xmlGetProp(adaptionset_node, "minWidth");
- c->adaptionset_maxwidth_val = xmlGetProp(adaptionset_node, "maxWidth");
- c->adaptionset_minheight_val = xmlGetProp(adaptionset_node, "minHeight");
- c->adaptionset_maxheight_val = xmlGetProp(adaptionset_node, "maxHeight");
- c->adaptionset_minframerate_val = xmlGetProp(adaptionset_node, "minFrameRate");
- c->adaptionset_maxframerate_val = xmlGetProp(adaptionset_node, "maxFrameRate");
- c->adaptionset_segmentalignment_val = xmlGetProp(adaptionset_node, "segmentAlignment");
- c->adaptionset_bitstreamswitching_val = xmlGetProp(adaptionset_node, "bitstreamSwitching");
+
+ ret = parse_manifest_adaptationset_attr(s, adaptionset_node);
+ if (ret < 0)
+ return ret;
node = xmlFirstElementChild(adaptionset_node);
while (node) {
adaptionset_baseurl_node,
adaptionset_segmentlist_node,
adaptionset_supplementalproperty_node);
- if (ret < 0) {
- return ret;
- }
+ if (ret < 0)
+ goto err;
}
node = xmlNextElementSibling(node);
}
- return 0;
+
+err:
+ av_freep(&c->adaptionset_lang);
+ return ret;
}
static int parse_programinformation(AVFormatContext *s, xmlNodePtr node)
}
node = xmlNextElementSibling(node);
xmlFree(val);
+ val = NULL;
}
return 0;
}
} else {
LIBXML_TEST_VERSION
- doc = xmlReadMemory(buffer, filesize, c->base_url, NULL, 0);
+ doc = xmlReadMemory(buffer, filesize, c->base_url, NULL, 0);
root_element = xmlDocGetRootElement(doc);
node = root_element;
{
DASHContext *c = s->priv_data;
const char *opts[] = {
- "headers", "user_agent", "cookies", "http_proxy", "referer", "rw_timeout", NULL };
+ "headers", "user_agent", "cookies", "http_proxy", "referer", "rw_timeout", "icy", NULL };
const char **opt = opts;
uint8_t *buf = NULL;
int ret = 0;
goto fail;
pls->ctx->flags = AVFMT_FLAG_CUSTOM_IO;
- pls->ctx->probesize = 1024 * 4;
- pls->ctx->max_analyze_duration = 4 * AV_TIME_BASE;
+ 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, "", NULL, 0, 0);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Error when loading first fragment, playlist %d\n", (int)pls->rep_idx);
av_dict_set_int(&rep->assoc_stream->metadata, "variant_bitrate", rep->bandwidth, 0);
if (rep->id[0])
av_dict_set(&rep->assoc_stream->metadata, "id", rep->id, 0);
+ if (rep->lang) {
+ av_dict_set(&rep->assoc_stream->metadata, "language", rep->lang, 0);
+ av_freep(&rep->lang);
+ }
}
for (i = 0; i < c->n_subtitles; i++) {
rep = c->subtitles[i];
rep->assoc_stream = s->streams[rep->stream_index];
if (rep->id[0])
av_dict_set(&rep->assoc_stream->metadata, "id", rep->id, 0);
+ if (rep->lang) {
+ av_dict_set(&rep->assoc_stream->metadata, "language", rep->lang, 0);
+ av_freep(&rep->lang);
+ }
}
}
av_log(s, AV_LOG_INFO, "Now receiving stream_index %d\n", pls->stream_index);
} else if (!needed && pls->ctx) {
close_demux_for_component(pls);
- if (pls->input)
- ff_format_io_close(pls->parent, &pls->input);
+ ff_format_io_close(pls->parent, &pls->input);
av_log(s, AV_LOG_INFO, "No longer receiving stream_index %d\n", pls->stream_index);
}
}
if (cur->is_restart_needed) {
cur->cur_seg_offset = 0;
cur->init_sec_buf_read_offset = 0;
- if (cur->input)
- ff_format_io_close(cur->parent, &cur->input);
+ ff_format_io_close(cur->parent, &cur->input);
ret = reopen_demux_for_component(s, cur);
cur->is_restart_needed = 0;
}
return av_seek_frame(pls->ctx, -1, seek_pos_msec * 1000, flags);
}
- if (pls->input)
- ff_format_io_close(pls->parent, &pls->input);
+ ff_format_io_close(pls->parent, &pls->input);
// find the nearest fragment
if (pls->n_timelines > 0 && pls->fragment_timescale > 0) {
if (av_stristr(p->buf, "dash:profile:isoff-on-demand:2011") ||
av_stristr(p->buf, "dash:profile:isoff-live:2011") ||
av_stristr(p->buf, "dash:profile:isoff-live:2012") ||
- av_stristr(p->buf, "dash:profile:isoff-main:2011")) {
+ av_stristr(p->buf, "dash:profile:isoff-main:2011") ||
+ av_stristr(p->buf, "3GPP:PSS:profile:DASH1")) {
return AVPROBE_SCORE_MAX;
}
if (av_stristr(p->buf, "dash:profile")) {
static const AVOption dash_options[] = {
{"allowed_extensions", "List of file extensions that dash is allowed to access",
OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,
- {.str = "aac,m4a,m4s,m4v,mov,mp4,webm"},
+ {.str = "aac,m4a,m4s,m4v,mov,mp4,webm,ts"},
INT_MIN, INT_MAX, FLAGS},
{NULL}
};
projects / ffmpeg / blobdiff