github/mpv
1
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2024-11-03 03:19:24 +01:00
Code Releases Activity

Rewrite ordered chapters and timeline stuff

Browse Source 
This uses a different method to piece segments together. The old
approach basically changes to a new file (with a new start offset) any
time a segment ends. This meant waiting for audio/video end on segment
end, and then changing to the new segment all at once. It had a very
weird impact on the playback core, and some things (like truly gapless
segment transitions, or frame backstepping) just didn't work.

The new approach adds the demux_timeline pseudo-demuxer, which presents
an uniform packet stream from the many segments. This is pretty similar
to how ordered chapters are implemented everywhere else. It also reminds
of the FFmpeg concat pseudo-demuxer.

The "pure" version of this approach doesn't work though. Segments can
actually have different codec configurations (different extradata), and
subtitles are most likely broken too. (Subtitles have multiple corner
cases which break the pure stream-concatenation approach completely.)

To counter this, we do two things:
- Reinit the decoder with each segment. We go as far as allowing
  concatenating files with completely different codecs for the sake
  of EDL (which also uses the timeline infrastructure). A "lighter"
  approach would try to make use of decoder mechanism to update e.g.
  the extradata, but that seems fragile.
- Clip decoded data to segment boundaries. This is equivalent to
  normal playback core mechanisms like hr-seek, but now the playback
  core doesn't need to care about these things.

These two mechanisms are equivalent to what happened in the old
implementation, except they don't happen in the playback core anymore.
In other words, the playback core is completely relieved from timeline
implementation details. (Which honestly is exactly what I'm trying to
do here. I don't think ordered chapter behavior deserves improvement,
even if it's bad - but I want to get it out from the playback core.)

There is code duplication between audio and video decoder common code.
This is awful and could be shareable - but this will happen later.

Note that the audio path has some code to clip audio frames for the
purpose of codec preroll/gapless handling, but it's not shared as
sharing it would cause more pain than it would help.
This commit is contained in:
wm4 2016-02-15 21:04:07 +01:00
parent ae55896f42
commit 0af5335383
11 changed files with 618 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
audio/decode/dec_audio.c
View File

@ -168,6 +168,9 @@ void audio_reset_decoding(struct dec_audio *d_audio)
d_audio->current_frame = NULL;
talloc_free(d_audio->packet);
d_audio->packet = NULL;
talloc_free(d_audio->new_segment);
d_audio->new_segment = NULL;
d_audio->start = d_audio->end = MP_NOPTS_VALUE;
}
static void fix_audio_pts(struct dec_audio *da)
@ -192,6 +195,38 @@ static void fix_audio_pts(struct dec_audio *da)
da->pts += da->current_frame->samples / (double)da->current_frame->rate;
}
static bool clip_frame(struct mp_audio *f, double start, double end)
{
if (f->pts == MP_NOPTS_VALUE)
return false;
double f_end = f->pts + f->samples / (double)f->rate;
bool ended = false;
if (end != MP_NOPTS_VALUE) {
if (f_end >= end) {
if (f->pts >= end) {
f->samples = 0;
ended = true;
} else {
int new = (end - f->pts) * f->rate;
f->samples = MPCLAMP(new, 0, f->samples);
}
}
}
if (start != MP_NOPTS_VALUE) {
if (f->pts < start) {
if (f_end <= start) {
f->samples = 0;
} else {
int skip = (start - f->pts) * f->rate;
skip = MPCLAMP(skip, 0, f->samples);
mp_audio_skip_samples(f, skip);
f->pts += skip / (double)f->rate;
}
}
}
return ended;
}
void audio_work(struct dec_audio *da)
{
if (da->current_frame)
@ -202,7 +237,13 @@ void audio_work(struct dec_audio *da)
return;
}
bool had_packet = !!da->packet;
if (da->packet && da->packet->new_segment) {
assert(!da->new_segment);
da->new_segment = da->packet;
da->packet = NULL;
}
bool had_packet = da->packet || da->new_segment;
int ret = da->ad_driver->decode_packet(da, da->packet, &da->current_frame);
if (ret < 0 || (da->packet && da->packet->len == 0)) {
@ -223,6 +264,37 @@ void audio_work(struct dec_audio *da)
}
fix_audio_pts(da);
bool segment_end = true;
if (da->current_frame) {
segment_end = clip_frame(da->current_frame, da->start, da->end);
if (da->current_frame->samples == 0) {
talloc_free(da->current_frame);
da->current_frame = NULL;
}
}
// If there's a new segment, start it as soon as we're drained/finished.
if (segment_end && da->new_segment) {
struct demux_packet *new_segment = da->new_segment;
da->new_segment = NULL;
// Could avoid decoder reinit; would still need flush.
da->codec = new_segment->codec;
if (da->ad_driver)
da->ad_driver->uninit(da);
da->ad_driver = NULL;
audio_init_best_codec(da);
da->start = new_segment->start;
da->end = new_segment->end;
new_segment->new_segment = false;
da->packet = new_segment;
da->current_state = DATA_AGAIN;
}
}
// Fetch an audio frame decoded with audio_work(). Returns one of:

2
audio/decode/dec_audio.h
View File

@ -43,7 +43,9 @@ struct dec_audio {
// Strictly internal (dec_audio.c).
double pts; // endpts of previous frame
double start, end;
struct demux_packet *packet;
struct demux_packet *new_segment;
struct mp_audio *current_frame;
int current_state;
};

17
demux/demux.c
View File

@ -36,6 +36,7 @@
#include "stream/stream.h"
#include "demux.h"
#include "timeline.h"
#include "stheader.h"
#include "cue.h"
@ -52,6 +53,7 @@ extern const demuxer_desc_t demuxer_desc_playlist;
extern const demuxer_desc_t demuxer_desc_disc;
extern const demuxer_desc_t demuxer_desc_rar;
extern const demuxer_desc_t demuxer_desc_libarchive;
extern const demuxer_desc_t demuxer_desc_timeline;
/* Please do not add any new demuxers here. If you want to implement a new
* demuxer, add it to libavformat, except for wrappers around external
@ -782,7 +784,7 @@ bool demux_has_packet(struct sh_stream *sh)
return has_packet;
}
// Read and return any packet we find.
// Read and return any packet we find. NULL means EOF.
struct demux_packet *demux_read_any_packet(struct demuxer *demuxer)
{
struct demux_internal *in = demuxer->in;
@ -1082,7 +1084,8 @@ static struct demuxer *open_given_type(struct mpv_global *global,
mp_dbg(log, "Trying demuxer: %s (force-level: %s)\n",
desc->name, d_level(check));
if (stream->seekable) // not for DVD/BD/DVB in particular
// not for DVD/BD/DVB in particular
if (stream->seekable && (!params || !params->timeline))
stream_seek(stream, 0);
// Peek this much data to avoid that stream_read() run by some demuxers
@ -1110,6 +1113,16 @@ static struct demuxer *open_given_type(struct mpv_global *global,
demux_changed(in->d_thread, DEMUX_EVENT_ALL);
demux_update(demuxer);
stream_control(demuxer->stream, STREAM_CTRL_SET_READAHEAD, &(int){false});
struct timeline *tl = timeline_load(global, log, demuxer);
if (tl) {
struct demuxer_params params2 = {0};
params2.timeline = tl;
struct demuxer *sub = open_given_type(global, log,
&demuxer_desc_timeline, stream,
&params2, DEMUX_CHECK_FORCE);
if (sub)
return sub;
}
return demuxer;
}

1
demux/demux.h
View File

@ -160,6 +160,7 @@ struct demuxer_params {
struct matroska_segment_uid *matroska_wanted_uids;
int matroska_wanted_segment;
bool *matroska_was_valid;
struct timeline *timeline;
// -- demux_open_url() only
int stream_flags;
bool allow_capture;

392
demux/demux_timeline.c Normal file
View File

@ -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,
};

5
demux/packet.c
View File

@ -49,6 +49,8 @@ struct demux_packet *new_demux_packet_from_avpacket(struct AVPacket *avpkt)
.dts = MP_NOPTS_VALUE,
.duration = -1,
.pos = -1,
.start = MP_NOPTS_VALUE,
.end = MP_NOPTS_VALUE,
.stream = -1,
.avpacket = talloc_zero(dp, AVPacket),
};
@ -106,6 +108,9 @@ void demux_packet_copy_attribs(struct demux_packet *dst, struct demux_packet *sr
dst->dts = src->dts;
dst->duration = src->duration;
dst->pos = src->pos;
dst->start = src->start;
dst->end = src->end;
dst->new_segment = src->new_segment;
dst->keyframe = src->keyframe;
dst->stream = src->stream;
}

5
demux/packet.h
View File

@ -35,6 +35,11 @@ typedef struct demux_packet {
int64_t pos; // position in source file byte stream
int stream; // source stream index
// segmentation (ordered chapters, EDL)
struct mp_codec_params *codec;
double start, end;
bool new_segment;
// private
struct demux_packet *next;
struct AVPacket *avpacket; // keep the buffer allocation and sidedata

59
sub/dec_sub.c
View File

@ -50,12 +50,17 @@ struct dec_sub {
struct MPOpts *opts;
struct demuxer *demuxer;
struct mp_codec_params *codec;
struct sh_stream *sh;
double last_pkt_pts;
struct mp_codec_params *codec;
double start, end;
double last_vo_pts;
struct sd *sd;
struct demux_packet *new_segment;
};
void sub_lock(struct dec_sub *sub)
@ -121,6 +126,9 @@ struct dec_sub *sub_create(struct mpv_global *global, struct demuxer *demuxer,
.codec = sh->codec,
.demuxer = demuxer,
.last_pkt_pts = MP_NOPTS_VALUE,
.last_vo_pts = MP_NOPTS_VALUE,
.start = MP_NOPTS_VALUE,
.end = MP_NOPTS_VALUE,
};
mpthread_mutex_init_recursive(&sub->lock);
@ -132,6 +140,31 @@ struct dec_sub *sub_create(struct mpv_global *global, struct demuxer *demuxer,
return NULL;
}
// Called locked.
static void update_segment(struct dec_sub *sub)
{
if (sub->new_segment && sub->last_vo_pts != MP_NOPTS_VALUE &&
sub->last_vo_pts >= sub->new_segment->start)
{
sub->codec = sub->new_segment->codec;
sub->start = sub->new_segment->start;
sub->end = sub->new_segment->end;
struct sd *new = init_decoder(sub);
if (new) {
sub->sd->driver->uninit(sub->sd);
talloc_free(sub->sd);
sub->sd = new;
} else {
// We'll just keep the current decoder, and feed it possibly
// invalid data (not our fault if it crashes or something).
MP_ERR(sub, "Can't change to new codec.\n");
}
sub->sd->driver->decode(sub->sd, sub->new_segment);
talloc_free(sub->new_segment);
sub->new_segment = NULL;
}
}
// Read all packets from the demuxer and decode/add them. Returns false if
// there are circumstances which makes this not possible.
bool sub_read_all_packets(struct dec_sub *sub)
@ -170,6 +203,9 @@ bool sub_read_packets(struct dec_sub *sub, double video_pts)
if (!read_more)
break;
if (sub->new_segment)
break;
struct demux_packet *pkt;
int st = demux_read_packet_async(sub->sh, &pkt);
// Note: "wait" (st==0) happens with non-interleaved streams only, and
@ -183,8 +219,16 @@ bool sub_read_packets(struct dec_sub *sub, double video_pts)
break;
}
sub->sd->driver->decode(sub->sd, pkt);
sub->last_pkt_pts = pkt->pts;
if (pkt->new_segment) {
sub->new_segment = pkt;
// Note that this can be delayed to a much later point in time.
update_segment(sub);
break;
}
sub->sd->driver->decode(sub->sd, pkt);
talloc_free(pkt);
}
pthread_mutex_unlock(&sub->lock);
@ -199,6 +243,9 @@ void sub_get_bitmaps(struct dec_sub *sub, struct mp_osd_res dim, double pts,
{
struct MPOpts *opts = sub->opts;
sub->last_vo_pts = pts;
update_segment(sub);
*res = (struct sub_bitmaps) {0};
if (opts->sub_visibility && sub->sd->driver->get_bitmaps)
sub->sd->driver->get_bitmaps(sub->sd, dim, pts, res);
@ -212,6 +259,10 @@ char *sub_get_text(struct dec_sub *sub, double pts)
pthread_mutex_lock(&sub->lock);
struct MPOpts *opts = sub->opts;
char *text = NULL;
sub->last_vo_pts = pts;
update_segment(sub);
if (opts->sub_visibility && sub->sd->driver->get_text)
text = sub->sd->driver->get_text(sub->sd, pts);
pthread_mutex_unlock(&sub->lock);
@ -224,6 +275,10 @@ void sub_reset(struct dec_sub *sub)
if (sub->sd->driver->reset)
sub->sd->driver->reset(sub->sd);
sub->last_pkt_pts = MP_NOPTS_VALUE;
sub->start = sub->end = MP_NOPTS_VALUE;
sub->last_vo_pts = MP_NOPTS_VALUE;
talloc_free(sub->new_segment);
sub->new_segment = NULL;
pthread_mutex_unlock(&sub->lock);
}

71
video/decode/dec_video.c
View File

@ -68,6 +68,11 @@ void video_reset(struct dec_video *d_video)
d_video->dropped_frames = 0;
d_video->current_state = DATA_AGAIN;
mp_image_unrefp(&d_video->current_mpi);
talloc_free(d_video->packet);
d_video->packet = NULL;
talloc_free(d_video->new_segment);
d_video->new_segment = NULL;
d_video->start = d_video->end = MP_NOPTS_VALUE;
}
int video_vd_control(struct dec_video *d_video, int cmd, void *arg)
@ -88,6 +93,8 @@ void video_uninit(struct dec_video *d_video)
MP_VERBOSE(d_video, "Uninit video.\n");
d_video->vd_driver->uninit(d_video);
}
talloc_free(d_video->packet);
talloc_free(d_video->new_segment);
talloc_free(d_video);
}
@ -243,6 +250,9 @@ static struct mp_image *decode_packet(struct dec_video *d_video,
struct MPOpts *opts = d_video->opts;
bool avi_pts = d_video->codec->avi_dts && opts->correct_pts;
if (!d_video->vd_driver)
return NULL;
struct demux_packet packet_copy;
if (packet && packet->dts == MP_NOPTS_VALUE && !avi_pts) {
packet_copy = *packet;
@ -371,22 +381,37 @@ void video_work(struct dec_video *d_video)
return;
}
struct demux_packet *pkt;
if (demux_read_packet_async(d_video->header, &pkt) == 0) {
if (!d_video->packet && !d_video->new_segment &&
demux_read_packet_async(d_video->header, &d_video->packet) == 0)
{
d_video->current_state = DATA_WAIT;
return;
}
if (d_video->packet && d_video->packet->new_segment) {
assert(!d_video->new_segment);
d_video->new_segment = d_video->packet;
d_video->packet = NULL;
}
bool had_input_packet = !!d_video->packet;
bool had_packet = had_input_packet || d_video->new_segment;
double start_pts = d_video->start_pts;
if (d_video->start != MP_NOPTS_VALUE && (start_pts == MP_NOPTS_VALUE ||
d_video->start > start_pts))
start_pts = d_video->start;
int framedrop_type = d_video->framedrop_enabled ? 1 : 0;
if (d_video->start_pts != MP_NOPTS_VALUE && pkt &&
pkt->pts < d_video->start_pts - .005 &&
if (start_pts != MP_NOPTS_VALUE && d_video->packet &&
d_video->packet->pts < start_pts - .005 &&
!d_video->has_broken_packet_pts)
{
framedrop_type = 2;
}
d_video->current_mpi = decode_packet(d_video, pkt, framedrop_type);
bool had_packet = !!pkt;
talloc_free(pkt);
d_video->current_mpi = decode_packet(d_video, d_video->packet, framedrop_type);
talloc_free(d_video->packet); // always fully consumed
d_video->packet = NULL;
d_video->current_state = DATA_OK;
if (!d_video->current_mpi) {
@ -397,6 +422,38 @@ void video_work(struct dec_video *d_video)
d_video->current_state = DATA_AGAIN;
}
}
bool segment_ended = !d_video->current_mpi && !had_input_packet;
if (d_video->current_mpi && d_video->current_mpi->pts != MP_NOPTS_VALUE) {
double vpts = d_video->current_mpi->pts;
segment_ended = d_video->end != MP_NOPTS_VALUE && vpts >= d_video->end;
if ((start_pts != MP_NOPTS_VALUE && vpts < start_pts) || segment_ended) {
talloc_free(d_video->current_mpi);
d_video->current_mpi = NULL;
}
}
// If there's a new segment, start it as soon as we're drained/finished.
if (segment_ended && d_video->new_segment) {
struct demux_packet *new_segment = d_video->new_segment;
d_video->new_segment = NULL;
// Could avoid decoder reinit; would still need flush.
d_video->codec = new_segment->codec;
if (d_video->vd_driver)
d_video->vd_driver->uninit(d_video);
d_video->vd_driver = NULL;
video_init_best_codec(d_video);
d_video->start = new_segment->start;
d_video->end = new_segment->end;
new_segment->new_segment = false;
d_video->packet = new_segment;
d_video->current_state = DATA_AGAIN;
}
}
// Fetch an image decoded with video_work(). Returns one of:

3
video/decode/dec_video.h
View File

@ -69,6 +69,9 @@ struct dec_video {
float initial_decoder_aspect;
double start_pts;
double start, end;
struct demux_packet *new_segment;
struct demux_packet *packet;
bool framedrop_enabled;
struct mp_image *cover_art_mpi;
struct mp_image *current_mpi;

1
wscript_build.py
View File

@ -177,6 +177,7 @@ def build(ctx):
( "demux/demux_playlist.c" ),
( "demux/demux_raw.c" ),
( "demux/demux_rar.c" ),
( "demux/demux_timeline.c" ),
( "demux/demux_tv.c", "tv" ),
( "demux/ebml.c" ),
( "demux/packet.c" ),