diff options
Diffstat (limited to 'demux/demux_timeline.c')
-rw-r--r-- | demux/demux_timeline.c | 392 |
1 files changed, 392 insertions, 0 deletions
diff --git a/demux/demux_timeline.c b/demux/demux_timeline.c new file mode 100644 index 0000000000..9dbbff2158 --- /dev/null +++ b/demux/demux_timeline.c @@ -0,0 +1,392 @@ +/* + * This file is part of mpv. + * + * mpv is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * mpv is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with mpv. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <assert.h> +#include <limits.h> + +#include "common/common.h" +#include "common/msg.h" + +#include "demux.h" +#include "timeline.h" +#include "stheader.h" + +struct segment { + int index; + double start, end; + double d_start; + 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 + // 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; + int num_stream_map; +}; + +// Information for each stream on the virtual timeline. (Mirrors streams +// exposed by demux_timeline.) +struct virtual_stream { + struct sh_stream *sh; // stream exported by demux_timeline + bool selected; // ==demux_stream_is_selected(sh) + bool new_segment; // whether a new segment needs to be signaled + int eos_packets; // deal with b-frame delay +}; + +struct priv { + struct timeline *tl; + + double duration; + + 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; + + double seek_pts; +}; + +static void switch_segment(struct demuxer *demuxer, struct segment *new, + double start_pts, int flags) +{ + struct priv *p = demuxer->priv; + + if (p->current == new) + return; + + if (!(flags & (SEEK_FORWARD | SEEK_BACKWARD))) + flags |= SEEK_BACKWARD; + + MP_VERBOSE(demuxer, "switch to segment %d\n", new->index); + + p->current = new; + demux_set_ts_offset(new->d, new->start - new->d_start); + demux_seek(new->d, start_pts, flags | SEEK_ABSOLUTE); + + for (int n = 0; n < p->num_streams; n++) { + struct virtual_stream *vs = &p->streams[n]; + vs->new_segment = true; + vs->eos_packets = 0; + } + + p->eos_packets = 0; +} + +static void d_seek(struct demuxer *demuxer, double rel_seek_secs, int flags) +{ + struct priv *p = demuxer->priv; + + double pts = p->seek_pts; + if (flags & SEEK_ABSOLUTE) + pts = 0.0f; + + if (flags & SEEK_FACTOR) { + pts += p->duration * rel_seek_secs; + } else { + pts += rel_seek_secs; + } + + flags &= SEEK_FORWARD | SEEK_BACKWARD | SEEK_HR; + + 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; + } + } + + p->current = NULL; // force seek + switch_segment(demuxer, new, pts, flags); + + p->seek_pts = pts; +} + +static int d_fill_buffer(struct demuxer *demuxer) +{ + struct priv *p = demuxer->priv; + + if (!p->current) + switch_segment(demuxer, p->segments[0], 0, 0); + + struct segment *seg = p->current; + + struct demux_packet *pkt = demux_read_any_packet(seg->d); + if (!pkt || pkt->pts >= seg->end) + p->eos_packets += 1; + + // 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]; + if (vs->selected) { + int max_packets = 0; + if (vs->sh->type == STREAM_AUDIO) + max_packets = 1; + if (vs->sh->type == STREAM_VIDEO) + max_packets = 16; + eos_reached &= vs->eos_packets >= max_packets; + } + } + } + + 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]; + break; + } + } + if (!next) + return 0; + switch_segment(demuxer, next, next->start, 0); + return 1; // reader will retry + } + + if (pkt->stream < 0 || pkt->stream > seg->num_stream_map) + goto drop; + + if (!pkt->codec) + pkt->codec = demux_get_stream(seg->d, pkt->stream)->codec; + + 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) + goto drop; + + struct virtual_stream *vs = &p->streams[pkt->stream]; + + if (pkt->pts != MP_NOPTS_VALUE && 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. + if (pkt->keyframe || vs->eos_packets == INT_MAX) { + vs->eos_packets = INT_MAX; + goto drop; + } else { + vs->eos_packets += 1; + } + } + + pkt->new_segment = vs->new_segment; + vs->new_segment = false; + + demux_add_packet(vs->sh, pkt); + return 1; + +drop: + talloc_free(pkt); + return 1; +} + +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 = -1; + for (int i = 0; i < p->tl->num_sources; i++) { + if (p->tl->sources[i] == seg->d) { + src_num = i; + break; + } + } + 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->d->filename); + } + MP_VERBOSE(demuxer, "Total duration: %f\n", p->duration); +} + +static bool target_stream_used(struct segment *seg, int target_index) +{ + for (int n = 0; n < seg->num_stream_map; n++) { + if (seg->stream_map[n] == target_index) + return true; + } + return false; +} + +// Create mapping from segment streams to virtual timeline streams. +static void associate_streams(struct demuxer *demuxer, struct segment *seg) +{ + struct priv *p = demuxer->priv; + + 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; + } + } + } + + MP_TARRAY_APPEND(seg, seg->stream_map, seg->num_stream_map, + other ? other->index : -1); + + counts[sh->type] += 1; + } +} + +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_parts < 1) + return -1; + + p->duration = p->tl->parts[p->tl->num_parts].start; + + demuxer->chapters = p->tl->chapters; + demuxer->num_chapters = p->tl->num_chapters; + + struct demuxer *meta = p->tl->track_layout; + demuxer->metadata = meta->metadata; + demuxer->attachments = meta->attachments; + demuxer->num_attachments = meta->num_attachments; + + int 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; + demux_add_sh_stream(demuxer, new); + struct virtual_stream vs = { + .sh = new, + }; + MP_TARRAY_APPEND(p, p->streams, p->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]; + + struct segment *seg = talloc_ptrtype(p, seg); + *seg = (struct segment){ + .d = part->source, + .d_start = part->source_start, + .start = part->start, + .end = next->start, + }; + + associate_streams(demuxer, seg); + + seg->index = n; + MP_TARRAY_APPEND(p, p->segments, p->num_segments, seg); + } + + print_timeline(demuxer); + + demuxer->seekable = true; + demuxer->partially_seekable = true; + + return 0; +} + +static void d_close(struct demuxer *demuxer) +{ + struct priv *p = demuxer->priv; + struct demuxer *master = p->tl->demuxer; + timeline_destroy(p->tl); + free_demuxer(master); +} + +static void reselect_streams(struct demuxer *demuxer) +{ + struct priv *p = demuxer->priv; + + for (int n = 0; n < p->num_streams; n++) { + struct virtual_stream *vs = &p->streams[n]; + 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++) { + 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; + demuxer_select_track(seg->d, sh, selected); + } + } +} + +static int d_control(struct demuxer *demuxer, int cmd, void *arg) +{ + struct priv *p = demuxer->priv; + + switch (cmd) { + case DEMUXER_CTRL_GET_TIME_LENGTH: { + *(double *)arg = p->duration; + return DEMUXER_CTRL_OK; + } + case DEMUXER_CTRL_SWITCHED_TRACKS: + reselect_streams(demuxer); + return DEMUXER_CTRL_OK; + } + return DEMUXER_CTRL_NOTIMPL; +} + +const demuxer_desc_t demuxer_desc_timeline = { + .name = "timeline", + .desc = "timeline segment merging wrapper", + .fill_buffer = d_fill_buffer, + .open = d_open, + .close = d_close, + .seek = d_seek, + .control = d_control, +}; |