Something went wrong. Try again.
🎥 Command line media player
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376/* * 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 <libavutil/buffer.h>
#include "common/common.h"#include "filters/f_autoconvert.h"#include "filters/filter_internal.h"#include "video/mp_image.h"
#include "refqueue.h"
struct mp_refqueue { struct mp_filter *filter; struct mp_autoconvert *conv; struct mp_pin *in, *out;
struct mp_image *in_format;
// Buffered frame in case of format changes. struct mp_image *next;
int needed_past_frames; int needed_future_frames; int flags; int field_parity;
bool second_field; // current frame has to output a second field yet bool eof;
// Queue of input frames, used to determine past/current/future frames. // queue[0] is the newest frame, queue[num_queue - 1] the oldest. struct mp_image **queue; int num_queue; // queue[pos] is the current frame, unless pos is an invalid index. int pos;};
static bool mp_refqueue_has_output(struct mp_refqueue *q);
static void refqueue_dtor(void *p){ struct mp_refqueue *q = p; mp_refqueue_flush(q); mp_image_unrefp(&q->in_format); talloc_free(q->conv->f);}
struct mp_refqueue *mp_refqueue_alloc(struct mp_filter *f){ struct mp_refqueue *q = talloc_zero(f, struct mp_refqueue); talloc_set_destructor(q, refqueue_dtor); q->filter = f;
q->conv = mp_autoconvert_create(f); MP_HANDLE_OOM(q->conv);
q->in = q->conv->f->pins[1]; mp_pin_connect(q->conv->f->pins[0], f->ppins[0]); q->out = f->ppins[1];
mp_refqueue_flush(q); return q;}
void mp_refqueue_add_in_format(struct mp_refqueue *q, int fmt, int subfmt){ mp_autoconvert_add_imgfmt(q->conv, fmt, subfmt);}
// The minimum number of frames required before and after the current frame.void mp_refqueue_set_refs(struct mp_refqueue *q, int past, int future){ mp_assert(past >= 0 && future >= 0); q->needed_past_frames = past; q->needed_future_frames = MPMAX(future, 1); // at least 1 for determining PTS}
// MP_MODE_* flagsvoid mp_refqueue_set_mode(struct mp_refqueue *q, int flags){ q->flags = flags;}
void mp_refqueue_set_parity(struct mp_refqueue *q, int parity){ q->field_parity = parity;}
// Whether the current frame should be deinterlaced.bool mp_refqueue_should_deint(struct mp_refqueue *q){ if (!mp_refqueue_has_output(q) || !(q->flags & MP_MODE_DEINT)) return false;
return (q->queue[q->pos]->fields & MP_IMGFIELD_INTERLACED) || !(q->flags & MP_MODE_INTERLACED_ONLY);}
// Whether the current output frame (field) is the top field, bottom field// otherwise. (Assumes the caller forces deinterlacing.)bool mp_refqueue_is_top_field(struct mp_refqueue *q){ if (!mp_refqueue_has_output(q)) return false;
bool tff = q->field_parity == MP_FIELD_PARITY_TFF; bool bff = q->field_parity == MP_FIELD_PARITY_BFF; bool ret = (!!(q->queue[q->pos]->fields & MP_IMGFIELD_TOP_FIRST) ^ q->second_field && !tff && !bff); // Default parity ret = ret || (tff && !q->second_field); // Check if top field is forced ret = ret || (bff && q->second_field); // Check if bottom field is forced return ret;}
// Whether top-field-first mode is enabled.bool mp_refqueue_top_field_first(struct mp_refqueue *q){ if (!mp_refqueue_has_output(q)) return false;
bool tff = q->field_parity == MP_FIELD_PARITY_TFF; bool bff = q->field_parity == MP_FIELD_PARITY_BFF; return ((q->queue[q->pos]->fields & MP_IMGFIELD_TOP_FIRST) || tff) && !bff;}
// Discard all state.void mp_refqueue_flush(struct mp_refqueue *q){ for (int n = 0; n < q->num_queue; n++) talloc_free(q->queue[n]); q->num_queue = 0; q->pos = -1; q->second_field = false; q->eof = false; mp_image_unrefp(&q->next);}
static void mp_refqueue_add_input(struct mp_refqueue *q, struct mp_image *img){ mp_assert(img);
MP_TARRAY_INSERT_AT(q, q->queue, q->num_queue, 0, img); q->pos++;
mp_assert(q->pos >= 0 && q->pos < q->num_queue);}
static bool mp_refqueue_need_input(struct mp_refqueue *q){ return q->pos < q->needed_future_frames && !q->eof;}
static bool mp_refqueue_has_output(struct mp_refqueue *q){ return q->pos >= 0 && !mp_refqueue_need_input(q);}
static bool output_next_field(struct mp_refqueue *q){ if (q->second_field) return false; if (!mp_refqueue_output_fields(q)) return false; if (!mp_refqueue_should_deint(q)) return false;
mp_assert(q->pos >= 0);
// If there's no (reasonable) timestamp, also skip the field. if (q->pos == 0) return false;
double pts = q->queue[q->pos]->pts; double next_pts = q->queue[q->pos - 1]->pts; if (pts == MP_NOPTS_VALUE || next_pts == MP_NOPTS_VALUE) return false;
double frametime = next_pts - pts; if (frametime <= 0.0 || frametime >= 1.0) return false;
q->queue[q->pos]->pts = pts + frametime / 2; q->second_field = true; return true;}
// Advance to next input frame (skips fields even in field output mode).static void mp_refqueue_next(struct mp_refqueue *q){ if (!mp_refqueue_has_output(q)) return;
q->pos--; q->second_field = false;
mp_assert(q->pos >= -1 && q->pos < q->num_queue);
// Discard unneeded past frames. while (q->num_queue - (q->pos + 1) > q->needed_past_frames) { mp_assert(q->num_queue > 0); talloc_free(q->queue[q->num_queue - 1]); q->num_queue--; }
mp_assert(q->pos >= -1 && q->pos < q->num_queue);}
// Advance current field, depending on interlace flags.static void mp_refqueue_next_field(struct mp_refqueue *q){ if (!mp_refqueue_has_output(q)) return;
if (!output_next_field(q)) mp_refqueue_next(q);}
// Return a frame by relative position:// -1: first past frame// 0: current frame// 1: first future frame// Caller doesn't get ownership. Return NULL if unavailable.struct mp_image *mp_refqueue_get(struct mp_refqueue *q, int pos){ int i = q->pos - pos; return i >= 0 && i < q->num_queue ? q->queue[i] : NULL;}
// Same as mp_refqueue_get(), but return the frame which contains a field// relative to the current field's position.struct mp_image *mp_refqueue_get_field(struct mp_refqueue *q, int pos){ // If the current field is the second field (conceptually), then pos=1 // needs to get the next frame. Similarly, pos=-1 needs to get the current // frame, so round towards negative infinity. int round = mp_refqueue_top_field_first(q) != mp_refqueue_is_top_field(q); int frame = (pos < 0 ? pos - (1 - round) : pos + round) / 2; return mp_refqueue_get(q, frame);}
bool mp_refqueue_is_second_field(struct mp_refqueue *q){ return mp_refqueue_has_output(q) && q->second_field;}
// Return non-NULL if a format change happened. A format change is defined by// a change in image parameters, using broad enough checks that happen to be// sufficient for all users of refqueue.// On format change, the refqueue transparently drains remaining frames, and// once that is done, this function returns a mp_image reference of the new// frame. Reinit the low level video processor based on it, and then leave the// reference alone and continue normally.// All frames returned in the future will have a compatible format.struct mp_image *mp_refqueue_execute_reinit(struct mp_refqueue *q){ if (mp_refqueue_has_output(q) || !q->next) return NULL;
struct mp_image *cur = q->next; q->next = NULL;
mp_image_unrefp(&q->in_format); mp_refqueue_flush(q);
q->in_format = mp_image_new_ref(cur); mp_image_unref_data(q->in_format);
mp_refqueue_add_input(q, cur); return cur;}
// Main processing function. Call this in the filter process function.// Returns if enough input frames are available for filtering, and output pin// needs data; in other words, if this returns true, you render a frame and// output it.// If this returns true, you must call mp_refqueue_write_out_pin() to make// progress.bool mp_refqueue_can_output(struct mp_refqueue *q){ if (!mp_pin_in_needs_data(q->out)) return false;
// Strictly return any output first to reduce latency. if (mp_refqueue_has_output(q)) return true;
if (q->next) { // Make it call again for mp_refqueue_execute_reinit(). mp_filter_internal_mark_progress(q->filter); return false; }
struct mp_frame frame = mp_pin_out_read(q->in); if (frame.type == MP_FRAME_NONE) return false;
if (frame.type == MP_FRAME_EOF) { q->eof = true; if (mp_refqueue_has_output(q)) { mp_pin_out_unread(q->in, frame); return true; } mp_pin_in_write(q->out, frame); mp_refqueue_flush(q); return false; }
if (frame.type != MP_FRAME_VIDEO) { MP_ERR(q->filter, "unsupported frame type\n"); mp_frame_unref(&frame); mp_filter_internal_mark_failed(q->filter); return false; }
struct mp_image *img = frame.data;
if (!q->in_format || !!q->in_format->hwctx != !!img->hwctx || (img->hwctx && img->hwctx->data != q->in_format->hwctx->data) || !mp_image_params_static_equal(&q->in_format->params, &img->params)) { q->next = img; q->eof = true; mp_filter_internal_mark_progress(q->filter); return false; }
mp_refqueue_add_input(q, img);
if (mp_refqueue_has_output(q)) return true;
mp_pin_out_request_data(q->in); return false;}
// (Accepts NULL for generic errors.)void mp_refqueue_write_out_pin(struct mp_refqueue *q, struct mp_image *mpi){ if (mpi) { mp_pin_in_write(q->out, MAKE_FRAME(MP_FRAME_VIDEO, mpi)); } else { MP_WARN(q->filter, "failed to output frame\n"); mp_filter_internal_mark_failed(q->filter); } mp_refqueue_next_field(q);}
// Return frame for current format (without data). Reference is owned by q,// might go away on further queue accesses. NULL if none yet.struct mp_image *mp_refqueue_get_format(struct mp_refqueue *q){ return q->in_format;}
bool mp_refqueue_output_fields(struct mp_refqueue *q){ return q->flags & MP_MODE_OUTPUT_FIELDS;}