diff options
Diffstat (limited to 'demux/demux_timeline.c')
| -rw-r--r-- | demux/demux_timeline.c | 646 |
1 files changed, 455 insertions, 191 deletions
diff --git a/demux/demux_timeline.c b/demux/demux_timeline.c index 1eb73956c3..5572fb53bf 100644 --- a/demux/demux_timeline.c +++ b/demux/demux_timeline.c @@ -27,17 +27,18 @@ #include "stream/stream.h" struct segment { - int index; + int index; // index into virtual_source.segments[] (and timeline.parts[]) double start, end; double d_start; char *url; bool lazy; struct demuxer *d; - // stream_map[sh_stream.index] = index into priv.streams, where sh_stream - // is a stream from the source d. It's used to map the streams of the + // stream_map[sh_stream.index] = virtual_stream, where sh_stream is a stream + // from the source d, and virtual_stream is a streamexported by the + // timeline demuxer (virtual_stream.sh). It's used to map the streams of the // source onto the set of streams of the virtual timeline. - // Uses -1 for streams that do not appear in the virtual timeline. - int *stream_map; + // Uses NULL for streams that do not appear in the virtual timeline. + struct virtual_stream **stream_map; int num_stream_map; }; @@ -47,68 +48,99 @@ struct virtual_stream { struct sh_stream *sh; // stream exported by demux_timeline bool selected; // ==demux_stream_is_selected(sh) int eos_packets; // deal with b-frame delay + struct virtual_source *src; // group this stream is part of }; -struct priv { - struct timeline *tl; +// This represents a single timeline source. (See timeline.pars[]. For each +// timeline_par struct there is a virtual_source.) +struct virtual_source { + struct timeline_par *tl; - double duration; - bool dash; + bool dash, no_clip, delay_open; struct segment **segments; int num_segments; struct segment *current; - // As the demuxer user sees it. struct virtual_stream **streams; int num_streams; // Total number of packets received past end of segment. Used // to be clever about determining when to switch segments. int eos_packets; + + bool eof_reached; + double dts; // highest read DTS (or PTS if no DTS available) + bool any_selected; // at least one stream is actually selected + + struct demux_packet *next; }; -static bool target_stream_used(struct segment *seg, int target_index) +struct priv { + struct timeline *tl; + bool owns_tl; + + double duration; + + // As the demuxer user sees it. + struct virtual_stream **streams; + int num_streams; + + struct virtual_source **sources; + int num_sources; +}; + +static void update_slave_stats(struct demuxer *demuxer, struct demuxer *slave) +{ + demux_report_unbuffered_read_bytes(demuxer, demux_get_bytes_read_hack(slave)); +} + +static bool target_stream_used(struct segment *seg, struct virtual_stream *vs) { for (int n = 0; n < seg->num_stream_map; n++) { - if (seg->stream_map[n] == target_index) + if (seg->stream_map[n] == vs) return true; } return false; } // Create mapping from segment streams to virtual timeline streams. -static void associate_streams(struct demuxer *demuxer, struct segment *seg) +static void associate_streams(struct demuxer *demuxer, + struct virtual_source *src, + struct segment *seg) { - struct priv *p = demuxer->priv; - if (!seg->d || seg->stream_map) return; - int counts[STREAM_TYPE_COUNT] = {0}; - int num_streams = demux_get_num_stream(seg->d); for (int n = 0; n < num_streams; n++) { struct sh_stream *sh = demux_get_stream(seg->d, n); - // Try associating by demuxer ID (supposedly useful for ordered chapters). - struct sh_stream *other = - demuxer_stream_by_demuxer_id(demuxer, sh->type, sh->demuxer_id); - if (!other || !target_stream_used(seg, other->index)) { - // Try to associate the first unused stream with matching media type. - for (int i = 0; i < p->num_streams; i++) { - struct sh_stream *cur = p->streams[i]->sh; - if (cur->type == sh->type && !target_stream_used(seg, cur->index)) - { - other = cur; - break; - } - } + struct virtual_stream *other = NULL; + + for (int i = 0; i < src->num_streams; i++) { + struct virtual_stream *vs = src->streams[i]; + + // The stream must always have the same media type. Also, a stream + // can't be assigned multiple times. + if (sh->type != vs->sh->type || target_stream_used(seg, vs)) + continue; + + // By default pick the first matching stream. + if (!other) + other = vs; + + // Matching by demuxer ID is supposedly useful and preferable for + // ordered chapters. + if (sh->demuxer_id >= 0 && sh->demuxer_id == vs->sh->demuxer_id) + other = vs; } - MP_TARRAY_APPEND(seg, seg->stream_map, seg->num_stream_map, - other ? other->index : -1); + if (!other) { + MP_WARN(demuxer, "Source stream %d (%s) unused and hidden.\n", + n, stream_type_name(sh->type)); + } - counts[sh->type] += 1; + MP_TARRAY_APPEND(seg, seg->stream_map, seg->num_stream_map, other); } } @@ -121,130 +153,140 @@ static void reselect_streams(struct demuxer *demuxer) vs->selected = demux_stream_is_selected(vs->sh); } - for (int n = 0; n < p->num_segments; n++) { - struct segment *seg = p->segments[n]; - for (int i = 0; i < seg->num_stream_map; i++) { + for (int x = 0; x < p->num_sources; x++) { + struct virtual_source *src = p->sources[x]; + + for (int n = 0; n < src->num_segments; n++) { + struct segment *seg = src->segments[n]; + if (!seg->d) continue; - struct sh_stream *sh = demux_get_stream(seg->d, i); - bool selected = false; - if (seg->stream_map[i] >= 0) - selected = p->streams[seg->stream_map[i]]->selected; - // This stops demuxer readahead for inactive segments. - if (!p->current || seg->d != p->current->d) - selected = false; - demuxer_select_track(seg->d, sh, MP_NOPTS_VALUE, selected); + for (int i = 0; i < seg->num_stream_map; i++) { + bool selected = + seg->stream_map[i] && seg->stream_map[i]->selected; + + // This stops demuxer readahead for inactive segments. + if (!src->current || seg->d != src->current->d) + selected = false; + struct sh_stream *sh = demux_get_stream(seg->d, i); + demuxer_select_track(seg->d, sh, MP_NOPTS_VALUE, selected); + + update_slave_stats(demuxer, seg->d); + } + } + + bool was_selected = src->any_selected; + src->any_selected = false; + + for (int n = 0; n < src->num_streams; n++) + src->any_selected |= src->streams[n]->selected; + + if (!was_selected && src->any_selected) { + src->eof_reached = false; + src->dts = MP_NOPTS_VALUE; + TA_FREEP(&src->next); } } } -static void close_lazy_segments(struct demuxer *demuxer) +static void close_lazy_segments(struct demuxer *demuxer, + struct virtual_source *src) { - struct priv *p = demuxer->priv; - // unload previous segment - for (int n = 0; n < p->num_segments; n++) { - struct segment *seg = p->segments[n]; - if (seg != p->current && seg->d && seg->lazy) { + for (int n = 0; n < src->num_segments; n++) { + struct segment *seg = src->segments[n]; + if (seg != src->current && seg->d && seg->lazy) { + TA_FREEP(&src->next); // might depend on one of the sub-demuxers demux_free(seg->d); seg->d = NULL; } } } -static void reopen_lazy_segments(struct demuxer *demuxer) +static void reopen_lazy_segments(struct demuxer *demuxer, + struct virtual_source *src) { - struct priv *p = demuxer->priv; - - if (p->current->d) + if (src->current->d) return; - close_lazy_segments(demuxer); + // Note: in delay_open mode, we must _not_ close segments during demuxing, + // because demuxed packets have demux_packet.codec set to objects owned + // by the segments. Closing them would create dangling pointers. + if (!src->delay_open) + close_lazy_segments(demuxer, src); struct demuxer_params params = { - .init_fragment = p->tl->init_fragment, - .skip_lavf_probing = true, + .init_fragment = src->tl->init_fragment, + .skip_lavf_probing = src->tl->dash, + .stream_flags = demuxer->stream_origin, }; - p->current->d = demux_open_url(p->current->url, ¶ms, - demuxer->cancel, demuxer->global); - if (!p->current->d && !demux_cancel_test(demuxer)) + src->current->d = demux_open_url(src->current->url, ¶ms, + demuxer->cancel, demuxer->global); + if (!src->current->d && !demux_cancel_test(demuxer)) MP_ERR(demuxer, "failed to load segment\n"); - if (p->current->d) - demux_disable_cache(p->current->d); - associate_streams(demuxer, p->current); + if (src->current->d) + update_slave_stats(demuxer, src->current->d); + associate_streams(demuxer, src, src->current); } -static void switch_segment(struct demuxer *demuxer, struct segment *new, - double start_pts, int flags, bool init) +static void switch_segment(struct demuxer *demuxer, struct virtual_source *src, + struct segment *new, double start_pts, int flags, + bool init) { - struct priv *p = demuxer->priv; - if (!(flags & SEEK_FORWARD)) flags |= SEEK_HR; MP_VERBOSE(demuxer, "switch to segment %d\n", new->index); - p->current = new; - reopen_lazy_segments(demuxer); + if (src->current && src->current->d) + update_slave_stats(demuxer, src->current->d); + + src->current = new; + reopen_lazy_segments(demuxer, src); if (!new->d) return; reselect_streams(demuxer); - if (!p->dash) + if (!src->no_clip) demux_set_ts_offset(new->d, new->start - new->d_start); - if (!p->dash || !init) + if (!src->no_clip || !init) demux_seek(new->d, start_pts, flags); - for (int n = 0; n < p->num_streams; n++) { - struct virtual_stream *vs = p->streams[n]; + for (int n = 0; n < src->num_streams; n++) { + struct virtual_stream *vs = src->streams[n]; vs->eos_packets = 0; } - p->eos_packets = 0; + src->eof_reached = false; + src->eos_packets = 0; } -static void d_seek(struct demuxer *demuxer, double seek_pts, int flags) +static void do_read_next_packet(struct demuxer *demuxer, + struct virtual_source *src) { - struct priv *p = demuxer->priv; - - double pts = seek_pts * ((flags & SEEK_FACTOR) ? p->duration : 1); - - flags &= SEEK_FORWARD | SEEK_HR; + if (src->next) + return; - struct segment *new = p->segments[p->num_segments - 1]; - for (int n = 0; n < p->num_segments; n++) { - if (pts < p->segments[n]->end) { - new = p->segments[n]; - break; - } + struct segment *seg = src->current; + if (!seg || !seg->d) { + src->eof_reached = true; + return; } - switch_segment(demuxer, new, pts, flags, false); -} - -static int d_fill_buffer(struct demuxer *demuxer) -{ - struct priv *p = demuxer->priv; - - if (!p->current) - switch_segment(demuxer, p->segments[0], 0, 0, true); - - struct segment *seg = p->current; - if (!seg || !seg->d) - return 0; - struct demux_packet *pkt = demux_read_any_packet(seg->d); - if (!pkt || pkt->pts >= seg->end) - p->eos_packets += 1; + if (!pkt || (!src->no_clip && pkt->pts >= seg->end)) + src->eos_packets += 1; + + update_slave_stats(demuxer, seg->d); // Test for EOF. Do this here to properly run into EOF even if other // streams are disabled etc. If it somehow doesn't manage to reach the end // after demuxing a high (bit arbitrary) number of packets, assume one of // the streams went EOF early. - bool eos_reached = p->eos_packets > 0; - if (eos_reached && p->eos_packets < 100) { - for (int n = 0; n < p->num_streams; n++) { - struct virtual_stream *vs = p->streams[n]; + bool eos_reached = src->eos_packets > 0; + if (eos_reached && src->eos_packets < 100) { + for (int n = 0; n < src->num_streams; n++) { + struct virtual_stream *vs = src->streams[n]; if (vs->selected) { int max_packets = 0; if (vs->sh->type == STREAM_AUDIO) @@ -256,37 +298,43 @@ static int d_fill_buffer(struct demuxer *demuxer) } } + src->eof_reached = false; + if (eos_reached || !pkt) { talloc_free(pkt); struct segment *next = NULL; - for (int n = 0; n < p->num_segments - 1; n++) { - if (p->segments[n] == seg) { - next = p->segments[n + 1]; + for (int n = 0; n < src->num_segments - 1; n++) { + if (src->segments[n] == seg) { + next = src->segments[n + 1]; break; } } - if (!next) - return 0; - switch_segment(demuxer, next, next->start, 0, true); - return 1; // reader will retry + if (!next) { + src->eof_reached = true; + return; + } + switch_segment(demuxer, src, next, next->start, 0, true); + return; // reader will retry } - if (pkt->stream < 0 || pkt->stream > seg->num_stream_map) + if (pkt->stream < 0 || pkt->stream >= seg->num_stream_map) goto drop; - if (!p->dash) { + if (!src->no_clip || src->delay_open) { pkt->segmented = true; if (!pkt->codec) pkt->codec = demux_get_stream(seg->d, pkt->stream)->codec; + } + if (!src->no_clip) { if (pkt->start == MP_NOPTS_VALUE || pkt->start < seg->start) pkt->start = seg->start; if (pkt->end == MP_NOPTS_VALUE || pkt->end > seg->end) pkt->end = seg->end; } - pkt->stream = seg->stream_map[pkt->stream]; - if (pkt->stream < 0) + struct virtual_stream *vs = seg->stream_map[pkt->stream]; + if (!vs) goto drop; // for refresh seeks, demux.c prefers monotonically increasing packet pos @@ -294,9 +342,7 @@ static int d_fill_buffer(struct demuxer *demuxer) if (pkt->pos >= 0) pkt->pos |= (seg->index & 0x7FFFULL) << 48; - struct virtual_stream *vs = p->streams[pkt->stream]; - - if (pkt->pts != MP_NOPTS_VALUE && pkt->pts >= seg->end) { + if (pkt->pts != MP_NOPTS_VALUE && !src->no_clip && pkt->pts >= seg->end) { // Trust the keyframe flag. Might not always be a good idea, but will // be sufficient at least with mkv. The problem is that this flag is // not well-defined in libavformat and is container-dependent. @@ -308,12 +354,120 @@ static int d_fill_buffer(struct demuxer *demuxer) } } - demux_add_packet(vs->sh, pkt); - return 1; + double dts = pkt->dts != MP_NOPTS_VALUE ? pkt->dts : pkt->pts; + if (src->dts == MP_NOPTS_VALUE || (dts != MP_NOPTS_VALUE && dts > src->dts)) + src->dts = dts; + + pkt->stream = vs->sh->index; + src->next = pkt; + return; drop: talloc_free(pkt); - return 1; +} + +static bool d_read_packet(struct demuxer *demuxer, struct demux_packet **out_pkt) +{ + struct priv *p = demuxer->priv; + struct virtual_source *src = NULL; + + for (int x = 0; x < p->num_sources; x++) { + struct virtual_source *cur = p->sources[x]; + + if (!cur->any_selected || cur->eof_reached) + continue; + + if (!cur->current) + switch_segment(demuxer, cur, cur->segments[0], 0, 0, true); + + if (!cur->any_selected || !cur->current || !cur->current->d) + continue; + + if (!src || cur->dts == MP_NOPTS_VALUE || + (src->dts != MP_NOPTS_VALUE && cur->dts < src->dts)) + src = cur; + } + + if (!src) + return false; + + do_read_next_packet(demuxer, src); + *out_pkt = src->next; + src->next = NULL; + return true; +} + +static void seek_source(struct demuxer *demuxer, struct virtual_source *src, + double pts, int flags) +{ + struct segment *new = src->segments[src->num_segments - 1]; + for (int n = 0; n < src->num_segments; n++) { + if (pts < src->segments[n]->end) { + new = src->segments[n]; + break; + } + } + + switch_segment(demuxer, src, new, pts, flags, false); + + src->dts = MP_NOPTS_VALUE; + TA_FREEP(&src->next); +} + +static void d_seek(struct demuxer *demuxer, double seek_pts, int flags) +{ + struct priv *p = demuxer->priv; + + seek_pts = seek_pts * ((flags & SEEK_FACTOR) ? p->duration : 1); + flags &= SEEK_FORWARD | SEEK_HR; + + // The intention is to seek audio streams to the same target as video + // streams if they are separate streams. Video streams usually have more + // coarse keyframe snapping, which could leave video without audio. + struct virtual_source *master = NULL; + bool has_slaves = false; + for (int x = 0; x < p->num_sources; x++) { + struct virtual_source *src = p->sources[x]; + + bool any_audio = false, any_video = false; + for (int i = 0; i < src->num_streams; i++) { + struct virtual_stream *str = src->streams[i]; + if (str->selected) { + if (str->sh->type == STREAM_VIDEO) + any_video = true; + if (str->sh->type == STREAM_AUDIO) + any_audio = true; + } + } + + if (any_video) + master = src; + // A true slave stream is audio-only; this also prevents that the master + // stream is considered a slave stream. + if (any_audio && !any_video) + has_slaves = true; + } + + if (!has_slaves) + master = NULL; + + if (master) { + seek_source(demuxer, master, seek_pts, flags); + do_read_next_packet(demuxer, master); + if (master->next && master->next->pts != MP_NOPTS_VALUE) { + // Assume we got a seek target. Actually apply the heuristic. + MP_VERBOSE(demuxer, "adjust seek target from %f to %f\n", seek_pts, + master->next->pts); + seek_pts = master->next->pts; + flags &= ~(unsigned)SEEK_FORWARD; + } + } + + for (int x = 0; x < p->num_sources; x++) { + struct virtual_source *src = p->sources[x]; + if (src != master && src->any_selected) + seek_source(demuxer, src, seek_pts, flags); + } } static void print_timeline(struct demuxer *demuxer) @@ -321,135 +475,245 @@ static void print_timeline(struct demuxer *demuxer) struct priv *p = demuxer->priv; MP_VERBOSE(demuxer, "Timeline segments:\n"); - for (int n = 0; n < p->num_segments; n++) { - struct segment *seg = p->segments[n]; - int src_num = n; - for (int i = 0; i < n - 1; i++) { - if (seg->d && p->segments[i]->d == seg->d) { - src_num = i; - break; + for (int x = 0; x < p->num_sources; x++) { + struct virtual_source *src = p->sources[x]; + + if (x >= 1) + MP_VERBOSE(demuxer, " --- new parallel stream ---\n"); + + for (int n = 0; n < src->num_segments; n++) { + struct segment *seg = src->segments[n]; + int src_num = n; + for (int i = 0; i < n; i++) { + if (seg->d && src->segments[i]->d == seg->d) { + src_num = i; + break; + } + } + MP_VERBOSE(demuxer, " %2d: %12f - %12f [%12f] (", + n, seg->start, seg->end, seg->d_start); + for (int i = 0; i < seg->num_stream_map; i++) { + struct virtual_stream *vs = seg->stream_map[i]; + MP_VERBOSE(demuxer, "%s%d", i ? " " : "", + vs ? vs->sh->index : -1); } + MP_VERBOSE(demuxer, ")\n source %d:'%s'\n", src_num, seg->url); } - MP_VERBOSE(demuxer, " %2d: %12f [%12f] (", n, seg->start, seg->d_start); - for (int i = 0; i < seg->num_stream_map; i++) - MP_VERBOSE(demuxer, "%s%d", i ? " " : "", seg->stream_map[i]); - MP_VERBOSE(demuxer, ") %d:'%s'\n", src_num, seg->url); + + if (src->dash) + MP_VERBOSE(demuxer, " (Using pseudo-DASH mode.)\n"); } MP_VERBOSE(demuxer, "Total duration: %f\n", p->duration); +} - if (p->dash) - MP_VERBOSE(demuxer, "Durations and offsets are non-authoritative.\n"); +// Copy various (not all) metadata fields from src to dst, but try not to +// overwrite fields in dst that are unset in src. +// May keep data from src by reference. +// Imperfect and arbitrary, only suited for EDL stuff. +static void apply_meta(struct sh_stream *dst, struct sh_stream *src) +{ + if (src->demuxer_id >= 0) + dst->demuxer_id = src->demuxer_id; + if (src->title) + dst->title = src->title; + if (src->lang) + dst->lang = src->lang; + dst->default_track = src->default_track; + dst->forced_track = src->forced_track; + if (src->hls_bitrate) + dst->hls_bitrate = src->hls_bitrate; + dst->missing_timestamps = src->missing_timestamps; + if (src->attached_picture) + dst->attached_picture = src->attached_picture; + dst->image = src->image; } -static int d_open(struct demuxer *demuxer, enum demux_check check) +// This is mostly for EDL user-defined metadata. +static struct sh_stream *find_matching_meta(struct timeline_par *tl, int index) { - struct priv *p = demuxer->priv = talloc_zero(demuxer, struct priv); - p->tl = demuxer->params ? demuxer->params->timeline : NULL; - if (!p->tl || p->tl->num_parts < 1) - return -1; + for (int n = 0; n < tl->num_sh_meta; n++) { + struct sh_stream *sh = tl->sh_meta[n]; + if (sh->index == index || sh->index < 0) + return sh; + } + return NULL; +} - p->duration = p->tl->parts[p->tl->num_parts].start; +static bool add_tl(struct demuxer *demuxer, struct timeline_par *tl) +{ + struct priv *p = demuxer->priv; - demuxer->chapters = p->tl->chapters; - demuxer->num_chapters = p->tl->num_chapters; + struct virtual_source *src = talloc_ptrtype(p, src); + *src = (struct virtual_source){ + .tl = tl, + .dash = tl->dash, + .delay_open = tl->delay_open, + .no_clip = tl->no_clip || tl->dash, + .dts = MP_NOPTS_VALUE, + }; - struct demuxer *meta = p->tl->track_layout; - demuxer->metadata = meta->metadata; - demuxer->attachments = meta->attachments; - demuxer->num_attachments = meta->num_attachments; - demuxer->editions = meta->editions; - demuxer->num_editions = meta->num_editions; - demuxer->edition = meta->edition; - demuxer->duration = p->duration; + if (!tl->num_parts) + return false; + + MP_TARRAY_APPEND(p, p->sources, p->num_sources, src); + + p->duration = MPMAX(p->duration, tl->parts[tl->num_parts - 1].end); + + struct demuxer *meta = tl->track_layout; - int num_streams = demux_get_num_stream(meta); + // delay_open streams normally have meta==NULL, and 1 virtual stream + int num_streams = 0; + if (tl->delay_open) { + num_streams = tl->num_sh_meta; + } else if (meta) { + num_streams = demux_get_num_stream(meta); + } for (int n = 0; n < num_streams; n++) { - struct sh_stream *sh = demux_get_stream(meta, n); - struct sh_stream *new = demux_alloc_sh_stream(sh->type); - new->demuxer_id = sh->demuxer_id; - new->codec = sh->codec; - new->title = sh->title; - new->lang = sh->lang; - new->default_track = sh->default_track; - new->forced_track = sh->forced_track; - new->hls_bitrate = sh->hls_bitrate; - new->missing_timestamps = sh->missing_timestamps; - new->attached_picture = sh->attached_picture; + struct sh_stream *new = NULL; + + if (tl->delay_open) { + struct sh_stream *tsh = tl->sh_meta[n]; + new = demux_alloc_sh_stream(tsh->type); + new->codec = tsh->codec; + apply_meta(new, tsh); + demuxer->is_network = true; + demuxer->is_streaming = true; + } else { + struct sh_stream *sh = demux_get_stream(meta, n); + new = demux_alloc_sh_stream(sh->type); + apply_meta(new, sh); + new->codec = sh->codec; + struct sh_stream *tsh = find_matching_meta(tl, n); + if (tsh) + apply_meta(new, tsh); + } + demux_add_sh_stream(demuxer, new); struct virtual_stream *vs = talloc_ptrtype(p, vs); *vs = (struct virtual_stream){ + .src = src, .sh = new, }; MP_TARRAY_APPEND(p, p->streams, p->num_streams, vs); + assert(demux_get_stream(demuxer, p->num_streams - 1) == new); + MP_TARRAY_APPEND(src, src->streams, src->num_streams, vs); } - for (int n = 0; n < p->tl->num_parts; n++) { - struct timeline_part *part = &p->tl->parts[n]; - struct timeline_part *next = &p->tl->parts[n + 1]; + for (int n = 0; n < tl->num_parts; n++) { + struct timeline_part *part = &tl->parts[n]; // demux_timeline already does caching, doing it for the sub-demuxers // would be pointless and wasteful. - if (part->source) - demux_disable_cache(part->source); + if (part->source) { + demuxer->is_network |= part->source->is_network; + demuxer->is_streaming |= part->source->is_streaming; + } - struct segment *seg = talloc_ptrtype(p, seg); + if (!part->source) + assert(tl->dash || tl->delay_open); + + struct segment *seg = talloc_ptrtype(src, seg); *seg = (struct segment){ .d = part->source, .url = part->source ? part->source->filename : part->url, .lazy = !part->source, .d_start = part->source_start, .start = part->start, - .end = next->start, + .end = part->end, }; - associate_streams(demuxer, seg); + associate_streams(demuxer, src, seg); seg->index = n; - MP_TARRAY_APPEND(p, p->segments, p->num_segments, seg); + MP_TARRAY_APPEND(src, src->segments, src->num_segments, seg); } - p->dash = p->tl->dash; + if (tl->track_layout) { + demuxer->is_network |= tl->track_layout->is_network; + demuxer->is_streaming |= tl->track_layout->is_streaming; + } + return true; +} + +static int d_open(struct demuxer *demuxer, enum demux_check check) +{ + struct priv *p = demuxer->priv = talloc_zero(demuxer, struct priv); + p->tl = demuxer->params ? demuxer->params->timeline : NULL; + if (!p->tl || p->tl->num_pars < 1) + return -1; + + demuxer->chapters = p->tl->chapters; + demuxer->num_chapters = p->tl->num_chapters; + + struct demuxer *meta = p->tl->meta; + if (meta) { + demuxer->metadata = meta->metadata; + demuxer->attachments = meta->attachments; + demuxer->num_attachments = meta->num_attachments; + demuxer->editions = meta->editions; + demuxer->num_editions = meta->num_editions; + demuxer->edition = meta->edition; + } + + for (int n = 0; n < p->tl->num_pars; n++) { + if (!add_tl(demuxer, p->tl->pars[n])) + return -1; + } + + if (!p->num_sources) + return -1; + + demuxer->is_network |= p->tl->is_network; + demuxer->is_streaming |= p->tl->is_streaming; + + demuxer->duration = p->duration; print_timeline(demuxer); demuxer->seekable = true; demuxer->partially_seekable = false; - demuxer->filetype = meta->filetype ? meta->filetype : meta->desc->name; - - demuxer->is_network = p->tl->demuxer->is_network; + const char *format_name = "unknown"; + if (meta) + format_name = meta->filetype ? meta->filetype : meta->desc->name; + demuxer->filetype = talloc_asprintf(p, "%s/%s", p->tl->format, format_name); reselect_streams(demuxer); + p->owns_tl = true; return 0; } static void d_close(struct demuxer *demuxer) { struct priv *p = demuxer->priv; - struct demuxer *master = p->tl->demuxer; - p->current = NULL; - close_lazy_segments(demuxer); - timeline_destroy(p->tl); - demux_free(master); -} -static int d_control(struct demuxer *demuxer, int cmd, void *arg) -{ - if (cmd == DEMUXER_CTRL_SWITCHED_TRACKS) { - reselect_streams(demuxer); - return CONTROL_OK; + for (int x = 0; x < p->num_sources; x++) { + struct virtual_source *src = p->sources[x]; + + src->current = NULL; + TA_FREEP(&src->next); + close_lazy_segments(demuxer, src); } - return CONTROL_UNKNOWN; + if (p->owns_tl) { + struct demuxer *master = p->tl->demuxer; + timeline_destroy(p->tl); + demux_free(master); + } +} + +static void d_switched_tracks(struct demuxer *demuxer) +{ + reselect_streams(demuxer); } const demuxer_desc_t demuxer_desc_timeline = { .name = "timeline", .desc = "timeline segments", - .fill_buffer = d_fill_buffer, + .read_packet = d_read_packet, .open = d_open, .close = d_close, .seek = d_seek, - .control = d_control, + .switched_tracks = d_switched_tracks, }; |