github
/
mpv
mirror of https://github.com/mpv-player/mpv
1
Fork 0
Code Releases Activity

demux: refactor

This commit is contained in:
wm4 2013-07-11 19:20:25 +02:00
parent 6ede485e4b
commit 06281848de
3 changed files with 126 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

261
demux/demux.c
View File

@ -89,22 +89,32 @@ const demuxer_desc_t *const demuxer_list[] = {
NULL
};
typedef struct demux_stream {
enum stream_type stream_type;
struct demux_stream {
int selected; // user wants packets from this stream
int eof; // end of demuxed stream? (true if all buffer empty)
//---------------
int fill_count; // number of unsuccessful tries to get a packet
int packs; // number of packets in buffer
int bytes; // total bytes of packets in buffer
struct demux_packet *head;
struct demux_packet *tail;
struct demuxer *demuxer; // parent demuxer structure (stream handler)
// ---- stream header ----
struct sh_stream *gsh;
} demux_stream_t;
};
static void add_stream_chapters(struct demuxer *demuxer);
static void ds_free_packs(struct demux_stream *ds)
{
demux_packet_t *dp = ds->head;
while (dp) {
demux_packet_t *dn = dp->next;
free_demux_packet(dp);
dp = dn;
}
ds->head = ds->tail = NULL;
ds->packs = 0; // !!!!!
ds->bytes = 0;
ds->eof = 0;
}
static int packet_destroy(void *ptr)
{
struct demux_packet *dp = ptr;
@ -215,36 +225,6 @@ struct demux_packet *demux_copy_packet(struct demux_packet *dp)
return new;
}
static void ds_free_packs(demux_stream_t *ds)
{
demux_packet_t *dp = ds->head;
while (dp) {
demux_packet_t *dn = dp->next;
free_demux_packet(dp);
dp = dn;
}
ds->head = ds->tail = NULL;
ds->packs = 0; // !!!!!
ds->bytes = 0;
}
static void free_demuxer_stream(struct demux_stream *ds)
{
ds_free_packs(ds);
free(ds);
}
static struct demux_stream *new_demuxer_stream(struct demuxer *demuxer,
enum stream_type type)
{
demux_stream_t *ds = malloc(sizeof(demux_stream_t));
*ds = (demux_stream_t) {
.stream_type = type,
.demuxer = demuxer,
};
return ds;
}
/**
* Get demuxer description structure for a given demuxer type
*
@ -273,12 +253,6 @@ static demuxer_t *new_demuxer(struct MPOpts *opts, stream_t *stream, int type,
d->movi_end = stream->end_pos;
d->seekable = 1;
d->filepos = -1;
d->audio = new_demuxer_stream(d, STREAM_AUDIO);
d->video = new_demuxer_stream(d, STREAM_VIDEO);
d->sub = new_demuxer_stream(d, STREAM_SUB);
d->ds[STREAM_VIDEO] = d->video;
d->ds[STREAM_AUDIO] = d->audio;
d->ds[STREAM_SUB] = d->sub;
d->type = type;
d->opts = opts;
if (type)
@ -305,13 +279,15 @@ struct sh_stream *new_sh_stream(demuxer_t *demuxer, enum stream_type type)
demuxer_id++;
}
struct sh_stream *sh = talloc_struct(demuxer, struct sh_stream, {
struct sh_stream *sh = talloc_ptrtype(demuxer, sh);
*sh = (struct sh_stream) {
.type = type,
.demuxer = demuxer,
.index = demuxer->num_streams,
.demuxer_id = demuxer_id, // may be overwritten by demuxer
.opts = demuxer->opts,
});
.ds = talloc_zero(sh, struct demux_stream),
};
MP_TARRAY_APPEND(demuxer, demuxer->streams, demuxer->num_streams, sh);
switch (sh->type) {
case STREAM_VIDEO: {
@ -360,6 +336,8 @@ static void free_sh_video(sh_video_t *sh)
static void free_sh_stream(struct sh_stream *sh)
{
ds_free_packs(sh->ds);
switch (sh->type) {
case STREAM_AUDIO: free_sh_audio(sh->audio); break;
case STREAM_VIDEO: free_sh_video(sh->video); break;
@ -377,18 +355,47 @@ void free_demuxer(demuxer_t *demuxer)
// free streams:
for (int n = 0; n < demuxer->num_streams; n++)
free_sh_stream(demuxer->streams[n]);
// free demuxers:
free_demuxer_stream(demuxer->audio);
free_demuxer_stream(demuxer->video);
free_demuxer_stream(demuxer->sub);
free(demuxer->filename);
talloc_free(demuxer);
}
static void ds_add_packet(demux_stream_t *ds, demux_packet_t *dp)
static const char *stream_type_name(enum stream_type type)
{
// append packet to DS stream:
++ds->packs;
switch (type) {
case STREAM_VIDEO: return "video";
case STREAM_AUDIO: return "audio";
case STREAM_SUB: return "sub";
default: return "unknown";
}
}
static int count_packs(struct demuxer *demux, enum stream_type type)
{
int c = 0;
for (int n = 0; n < demux->num_streams; n++)
c += demux->streams[n]->type == type ? demux->streams[n]->ds->packs : 0;
return c;
}
static int count_bytes(struct demuxer *demux, enum stream_type type)
{
int c = 0;
for (int n = 0; n < demux->num_streams; n++)
c += demux->streams[n]->type == type ? demux->streams[n]->ds->bytes : 0;
return c;
}
// Returns the same value as demuxer->fill_buffer: 1 ok, 0 EOF/not selected.
int demuxer_add_packet(demuxer_t *demuxer, struct sh_stream *stream,
demux_packet_t *dp)
{
struct demux_stream *ds = stream ? stream->ds : NULL;
if (!ds || !ds->selected) {
talloc_free(dp);
return 0;
}
ds->packs++;
ds->bytes += dp->len;
if (ds->tail) {
// next packet in stream
@ -399,49 +406,48 @@ static void ds_add_packet(demux_stream_t *ds, demux_packet_t *dp)
ds->head = ds->tail = dp;
}
mp_dbg(MSGT_DEMUXER, MSGL_DBG2,
"DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%u [packs: A=%d V=%d]\n",
(ds == ds->demuxer->audio) ? "d_audio" : "d_video", dp->len,
dp->pts, (unsigned int) dp->pos, ds->demuxer->audio->packs,
ds->demuxer->video->packs);
}
// Returns the same value as demuxer->fill_buffer: 1 ok, 0 EOF/not selected.
int demuxer_add_packet(demuxer_t *demuxer, struct sh_stream *stream,
demux_packet_t *dp)
{
if (!dp || !demuxer_stream_is_selected(demuxer, stream)) {
free_demux_packet(dp);
return 0;
} else {
ds_add_packet(demuxer->ds[stream->type], dp);
return 1;
}
"DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%"PRIu64" "
"[packs: A=%d V=%d S=%d]\n", stream_type_name(stream->type),
dp->len, dp->pts, dp->pos, count_packs(demuxer, STREAM_AUDIO),
count_packs(demuxer, STREAM_VIDEO), count_packs(demuxer, STREAM_SUB));
return 1;
}
static bool demux_check_queue_full(demuxer_t *demux)
{
int apacks = demux->audio ? demux->audio->packs : 0;
int abytes = demux->audio ? demux->audio->bytes : 0;
int vpacks = demux->video ? demux->video->packs : 0;
int vbytes = demux->video ? demux->video->bytes : 0;
for (int n = 0; n < demux->num_streams; n++) {
struct sh_stream *sh = demux->streams[n];
if (sh->ds->packs > MAX_PACKS || sh->ds->bytes > MAX_PACK_BYTES)
goto overflow;
}
return false;
if (apacks < MAX_PACKS && abytes < MAX_PACK_BYTES &&
vpacks < MAX_PACKS && vbytes < MAX_PACK_BYTES)
return false;
overflow:
if (!demux->warned_queue_overflow) {
mp_tmsg(MSGT_DEMUXER, MSGL_ERR, "\nToo many packets in the demuxer "
"packet queue (video: %d packets in %d bytes, audio: %d "
"packets in %d bytes).\n", vpacks, vbytes, apacks, abytes);
"packets in %d bytes, sub: %d packets in %d bytes).\n",
count_packs(demux, STREAM_VIDEO), count_bytes(demux, STREAM_VIDEO),
count_packs(demux, STREAM_AUDIO), count_bytes(demux, STREAM_AUDIO),
count_packs(demux, STREAM_SUB), count_bytes(demux, STREAM_SUB));
mp_tmsg(MSGT_DEMUXER, MSGL_HINT, "Maybe you are playing a non-"
"interleaved stream/file or the codec failed?\n");
}
demux->warned_queue_overflow = true;
return true;
}
static bool need_coverart_hack(struct demuxer *demux)
{
for (int n = 0; n < demux->num_streams; n++) {
struct sh_stream *sh = demux->streams[n];
if (sh->attached_picture && sh->ds->selected)
return true;
}
return false;
}
// return value:
// 0 = EOF or no stream found or invalid type
// 1 = successfully read a packet
@ -451,21 +457,14 @@ static int demux_fill_buffer(demuxer_t *demux)
return demux->desc->fill_buffer ? demux->desc->fill_buffer(demux) : 0;
}
// return value:
// 0 = EOF
// 1 = successful
static int ds_get_packets(demux_stream_t *ds)
static void ds_get_packets(struct sh_stream *sh)
{
if (!ds)
return 0;
demuxer_t *demux = ds->demuxer;
struct demux_stream *ds = sh->ds;
demuxer_t *demux = sh->demuxer;
mp_dbg(MSGT_DEMUXER, MSGL_DBG3, "ds_get_packets (%s) called\n",
ds == demux->audio ? "d_audio" : ds == demux->video ? "d_video" :
ds == demux->sub ? "d_sub" : "unknown");
stream_type_name(sh->type));
while (1) {
int apacks = demux->audio ? demux->audio->packs : 0;
int vpacks = demux->video ? demux->video->packs : 0;
if (ds->packs) {
if (ds->head) {
/* The code below can set ds->eof to 1 when another stream runs
* out of buffer space. That makes sense because in that situation
* the calling code should not count on being able to demux more
@ -475,7 +474,7 @@ static int ds_get_packets(demux_stream_t *ds)
* weird behavior. */
ds->eof = 0;
ds->fill_count = 0;
return 1;
return;
}
// avoid buffering too far ahead in e.g. badly interleaved files
// or when one stream is shorter, without breaking large audio
@ -489,33 +488,20 @@ static int ds_get_packets(demux_stream_t *ds)
if (demux_check_queue_full(demux))
break;
if (!demux_fill_buffer(demux)) {
mp_dbg(MSGT_DEMUXER, MSGL_DBG2,
"ds_get_packets()->demux_fill_buffer() failed\n");
int apacks = count_packs(demux, STREAM_AUDIO);
int vpacks = count_packs(demux, STREAM_VIDEO);
if (!demux_fill_buffer(demux))
break; // EOF
}
if (demux->video->gsh && demux->video->gsh->attached_picture) {
if (demux->audio)
ds->fill_count += demux->audio->packs - apacks;
if (demux->video && demux->video->packs > vpacks)
ds->fill_count++;
if (need_coverart_hack(demux)) {
ds->fill_count += count_packs(demux, STREAM_AUDIO) - apacks;
ds->fill_count += count_packs(demux, STREAM_VIDEO) - vpacks;
}
}
mp_msg(MSGT_DEMUXER, MSGL_V,
"ds_get_packets: EOF reached (stream: %s) \n",
ds == demux->audio ? "audio" : "video");
mp_msg(MSGT_DEMUXER, MSGL_V, "ds_get_packets: EOF reached (stream: %s)\n",
stream_type_name(sh->type));
ds->eof = 1;
return 0;
}
static struct demux_stream *ds_from_sh(struct sh_stream *sh)
{
for (int n = 0; n < STREAM_TYPE_COUNT; n++) {
if (sh->demuxer->ds[n]->gsh == sh)
return sh->demuxer->ds[n];
}
return NULL;
}
// Read a packet from the given stream. The returned packet belongs to the
@ -523,9 +509,9 @@ static struct demux_stream *ds_from_sh(struct sh_stream *sh)
// on EOF.
struct demux_packet *demux_read_packet(struct sh_stream *sh)
{
struct demux_stream *ds = ds_from_sh(sh);
struct demux_stream *ds = sh ? sh->ds : NULL;
if (ds) {
ds_get_packets(ds);
ds_get_packets(sh);
struct demux_packet *pkt = ds->head;
if (pkt) {
ds->head = pkt->next;
@ -549,16 +535,18 @@ struct demux_packet *demux_read_packet(struct sh_stream *sh)
// packets from the queue.
double demux_get_next_pts(struct sh_stream *sh)
{
struct demux_stream *ds = ds_from_sh(sh);
ds_get_packets(ds);
return ds && ds->head ? ds->head->pts : MP_NOPTS_VALUE;
if (sh) {
ds_get_packets(sh);
if (sh->ds->head)
return sh->ds->head->pts;
}
return MP_NOPTS_VALUE;
}
// Return whether a packet is queued. Never blocks, never forces any reads.
bool demux_has_packet(struct sh_stream *sh)
{
struct demux_stream *ds = ds_from_sh(sh);
return ds && ds->head;
return sh && sh->ds->head;
}
// Same as demux_has_packet, but to be called internally by demuxers, as
@ -571,8 +559,7 @@ bool demuxer_stream_has_packets_queued(struct demuxer *d, struct sh_stream *stre
// Return whether EOF was returned with an earlier packet read.
bool demux_stream_eof(struct sh_stream *sh)
{
struct demux_stream *ds = ds_from_sh(sh);
return !ds || ds->eof;
return !sh || sh->ds->eof;
}
// ====================================================================
@ -762,9 +749,9 @@ struct demuxer *demux_open(struct MPOpts *opts, stream_t *vs, int file_format,
void demux_flush(demuxer_t *demuxer)
{
ds_free_packs(demuxer->video);
ds_free_packs(demuxer->audio);
ds_free_packs(demuxer->sub);
for (int n = 0; n < demuxer->num_streams; n++)
ds_free_packs(demuxer->streams[n]->ds);
demuxer->warned_queue_overflow = false;
}
int demux_seek(demuxer_t *demuxer, float rel_seek_secs, float audio_delay,
@ -780,10 +767,6 @@ int demux_seek(demuxer_t *demuxer, float rel_seek_secs, float audio_delay,
// clear demux buffers:
demux_flush(demuxer);
demuxer->video->eof = 0;
demuxer->audio->eof = 0;
demuxer->sub->eof = 0;
demuxer->warned_queue_overflow = false;
/* HACK: assume any demuxer used with these streams can cope with
* the stream layer suddenly seeking to a different position under it
@ -931,18 +914,20 @@ void demuxer_switch_track(struct demuxer *demuxer, enum stream_type type,
assert(!stream || stream->type == type);
// don't flush buffers if stream is already selected / none are selected
if (demuxer->ds[type]->gsh == stream)
return;
demuxer->ds[type]->gsh = stream;
ds_free_packs(demuxer->ds[type]);
demux_control(demuxer, DEMUXER_CTRL_SWITCHED_TRACKS, NULL);
for (int n = 0; n < demuxer->num_streams; n++) {
struct sh_stream *cur = demuxer->streams[n];
bool select = cur == stream;
if (cur->type == type && cur->ds->selected != select) {
cur->ds->selected = select;
ds_free_packs(cur->ds);
demux_control(demuxer, DEMUXER_CTRL_SWITCHED_TRACKS, NULL);
}
}
}
bool demuxer_stream_is_selected(struct demuxer *d, struct sh_stream *stream)
{
return stream && d->ds[stream->type]->gsh == stream;
return stream && stream->ds->selected;
}
int demuxer_add_attachment(demuxer_t *demuxer, struct bstr name,

7
demux/demux.h
View File

@ -183,13 +183,6 @@ typedef struct demuxer {
enum timestamp_type timestamp_type;
bool warned_queue_overflow;
struct demux_stream *ds[STREAM_TYPE_COUNT]; // video/audio/sub buffers
// These correspond to ds[], e.g.: audio == ds[STREAM_AUDIO]
struct demux_stream *audio; // audio buffer/demuxer
struct demux_stream *video; // video buffer/demuxer
struct demux_stream *sub; // dvd subtitle buffer/demuxer
struct sh_stream **streams;
int num_streams;

3
demux/stheader.h
View File

@ -68,6 +68,9 @@ struct sh_stream {
// shouldn't exist type of stuff
struct MPOpts *opts;
// Internal to demux.c
struct demux_stream *ds;
};
#define SH_COMMON \