Something went wrong. Try again.
🎥 Command line media player
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574/* * 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 <stdlib.h>#include <stdbool.h>#include <string.h>#include <math.h>#include <assert.h>#include <limits.h>
#include "demux/demux.h"#include "demux/packet_pool.h"#include "sd.h"#include "dec_sub.h"#include "options/m_config.h"#include "options/options.h"#include "common/global.h"#include "common/msg.h"#include "common/recorder.h"#include "misc/dispatch.h"#include "osdep/threads.h"
extern const struct sd_functions sd_ass;extern const struct sd_functions sd_lavc;
static const struct sd_functions *const sd_list[] = { &sd_lavc, &sd_ass, NULL};
struct dec_sub { mp_mutex lock;
struct mp_log *log; struct mpv_global *global; struct demux_packet_pool *packet_pool; struct mp_subtitle_opts *opts; struct mp_subtitle_shared_opts *shared_opts; struct m_config_cache *opts_cache; struct m_config_cache *shared_opts_cache;
struct mp_recorder_sink *recorder_sink;
struct attachment_list *attachments;
struct sh_stream *sh; int play_dir; int order; double last_pkt_pts; bool preload_attempted; double video_fps; double sub_speed; bool sub_visible;
struct mp_codec_params *codec; double start, end;
double last_vo_pts; struct sd *sd;
struct demux_packet *new_segment; struct demux_packet **cached_pkts; int cached_pkt_pos; int num_cached_pkts;};
static void update_subtitle_speed(struct dec_sub *sub){ struct mp_subtitle_opts *opts = sub->opts; sub->sub_speed = 1.0;
if (sub->video_fps > 0 && sub->codec->frame_based > 0) { MP_VERBOSE(sub, "Frame based format, dummy FPS: %f, video FPS: %f\n", sub->codec->frame_based, sub->video_fps); sub->sub_speed *= sub->codec->frame_based / sub->video_fps; }
if (opts->sub_fps && sub->video_fps) sub->sub_speed *= opts->sub_fps / sub->video_fps;
sub->sub_speed *= opts->sub_speed;}
// Return the subtitle PTS used for a given video PTS.static double pts_to_subtitle(struct dec_sub *sub, double pts){ struct mp_subtitle_shared_opts *opts = sub->shared_opts; float delay = sub->order < 0 ? 0.0f : opts->sub_delay[sub->order];
if (pts != MP_NOPTS_VALUE) pts = (pts * sub->play_dir - delay) / sub->sub_speed;
return pts;}
static double pts_from_subtitle(struct dec_sub *sub, double pts){ struct mp_subtitle_shared_opts *opts = sub->shared_opts; float delay = sub->order < 0 ? 0.0f : opts->sub_delay[sub->order];
if (pts != MP_NOPTS_VALUE) pts = (pts * sub->sub_speed + delay) * sub->play_dir;
return pts;}
static void wakeup_demux(void *ctx){ struct mp_dispatch_queue *q = ctx; mp_dispatch_interrupt(q);}
static void destroy_cached_pkts(struct dec_sub *sub){ int index = 0; while (index < sub->num_cached_pkts) { demux_packet_pool_push(sub->packet_pool, sub->cached_pkts[index]); sub->cached_pkts[index] = NULL; ++index; } sub->cached_pkt_pos = 0; sub->num_cached_pkts = 0;}
void sub_destroy(struct dec_sub *sub){ if (!sub) return; demux_set_stream_wakeup_cb(sub->sh, NULL, NULL); if (sub->sd) { sub_reset(sub); sub->sd->driver->uninit(sub->sd); } talloc_free(sub->sd); mp_mutex_destroy(&sub->lock); talloc_free(sub);}
static struct sd *init_decoder(struct dec_sub *sub){ for (int n = 0; sd_list[n]; n++) { const struct sd_functions *driver = sd_list[n]; struct sd *sd = talloc(NULL, struct sd); *sd = (struct sd){ .global = sub->global, .log = mp_log_new(sd, sub->log, driver->name), .opts = sub->opts, .shared_opts = sub->shared_opts, .driver = driver, .order = sub->order, .attachments = sub->attachments, .codec = sub->codec, .preload_ok = true, };
if (sd->driver->init(sd) >= 0) return sd;
talloc_free(sd); }
MP_ERR(sub, "Could not find subtitle decoder for format '%s'.\n", sub->codec->codec); return NULL;}
// Thread-safety of the returned object: all functions are thread-safe,// except sub_get_bitmaps() and sub_get_text(). Decoder backends (sd_*)// do not need to acquire locks.// Ownership of attachments goes to the callee, and is released with// talloc_free() (even on failure).struct dec_sub *sub_create(struct mpv_global *global, struct track *track, struct attachment_list *attachments, int order){ assert(track->stream && track->stream->type == STREAM_SUB);
struct dec_sub *sub = talloc(NULL, struct dec_sub); *sub = (struct dec_sub){ .log = mp_log_new(sub, global->log, "sub"), .global = global, .packet_pool = demux_packet_pool_get(global), .opts_cache = m_config_cache_alloc(sub, global, &mp_subtitle_sub_opts), .shared_opts_cache = m_config_cache_alloc(sub, global, &mp_subtitle_shared_sub_opts), .sh = track->stream, .codec = track->stream->codec, .attachments = talloc_steal(sub, attachments), .play_dir = 1, .order = order, .last_pkt_pts = MP_NOPTS_VALUE, .last_vo_pts = MP_NOPTS_VALUE, .start = MP_NOPTS_VALUE, .end = MP_NOPTS_VALUE, }; sub->opts = sub->opts_cache->opts; sub->shared_opts = sub->shared_opts_cache->opts; mp_mutex_init(&sub->lock);
sub->sd = init_decoder(sub); if (sub->sd) { update_subtitle_speed(sub); return sub; }
sub_destroy(sub); 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) { MP_VERBOSE(sub, "Switch segment: %f at %f\n", sub->new_segment->start, sub->last_vo_pts);
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; update_subtitle_speed(sub); } 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; }}
bool sub_can_preload(struct dec_sub *sub){ bool r; mp_mutex_lock(&sub->lock); r = sub->sd->driver->accept_packets_in_advance && !sub->preload_attempted; mp_mutex_unlock(&sub->lock); return r;}
void sub_preload(struct dec_sub *sub){ mp_mutex_lock(&sub->lock);
struct mp_dispatch_queue *demux_waiter = mp_dispatch_create(NULL); demux_set_stream_wakeup_cb(sub->sh, wakeup_demux, demux_waiter);
sub->preload_attempted = true;
for (;;) { struct demux_packet *pkt = NULL; int r = demux_read_packet_async(sub->sh, &pkt); if (r == 0) { mp_dispatch_queue_process(demux_waiter, INFINITY); continue; } if (!pkt) break; sub->sd->driver->decode(sub->sd, pkt); MP_TARRAY_APPEND(sub, sub->cached_pkts, sub->num_cached_pkts, pkt); }
demux_set_stream_wakeup_cb(sub->sh, NULL, NULL); talloc_free(demux_waiter);
mp_mutex_unlock(&sub->lock);}
static bool is_new_segment(struct dec_sub *sub, struct demux_packet *p){ return p->segmented && (p->start != sub->start || p->end != sub->end || p->codec != sub->codec);}
static bool is_packet_visible(struct demux_packet *p, double video_pts){ return p && p->pts <= video_pts && (video_pts <= p->pts + p->sub_duration || p->sub_duration < 0);}
static bool update_pkt_cache(struct dec_sub *sub, double video_pts){ if (!sub->cached_pkts[sub->cached_pkt_pos]) return false;
struct demux_packet *pkt = sub->cached_pkts[sub->cached_pkt_pos]; struct demux_packet *next_pkt = sub->cached_pkt_pos + 1 < sub->num_cached_pkts ? sub->cached_pkts[sub->cached_pkt_pos + 1] : NULL; if (!pkt) return false;
double pts = video_pts + sub->shared_opts->sub_delay[sub->order]; double next_pts = next_pkt ? next_pkt->pts : INT_MAX; double end_pts = pkt->sub_duration >= 0 ? pkt->pts + pkt->sub_duration : INT_MAX;
if (next_pts < pts || end_pts < pts) { if (sub->cached_pkt_pos + 1 < sub->num_cached_pkts) { TA_FREEP(&sub->cached_pkts[sub->cached_pkt_pos]); pkt = NULL; sub->cached_pkt_pos++; } if (next_pts < pts) return true; }
if (pkt && pkt->animated == 1) return true;
return false;}
// Read packets from the demuxer stream passed to sub_create(). Signals if// enough packets were read and if the subtitle state updated in anyway. If// packets_read is false, the player should wait until the demuxer signals new// packets and retry.void sub_read_packets(struct dec_sub *sub, double video_pts, bool force, bool *packets_read, bool *sub_updated){ *packets_read = true; mp_mutex_lock(&sub->lock); video_pts = pts_to_subtitle(sub, video_pts); while (1) { bool read_more = true; if (sub->sd->driver->accepts_packet) read_more = sub->sd->driver->accepts_packet(sub->sd, video_pts);
if (!read_more) break;
if (sub->new_segment && sub->new_segment->start < video_pts) { sub->last_vo_pts = video_pts; update_segment(sub); }
if (sub->new_segment) break;
// (Use this mechanism only if sub_delay matters to avoid corner cases.) float delay = sub->order < 0 ? 0.0f : sub->shared_opts->sub_delay[sub->order]; double min_pts = delay < 0 || force ? video_pts : MP_NOPTS_VALUE;
struct demux_packet *pkt; int st = demux_read_packet_async_until(sub->sh, min_pts, &pkt); // Note: "wait" (st==0) happens with non-interleaved streams only, and // then we should stop the playloop until a new enough packet has been // seen (or the subtitle decoder's queue is full). This usually does not // happen for interleaved subtitle streams, which never return "wait" // when reading, unless min_pts is set. if (st <= 0) { *packets_read = st < 0 || (sub->last_pkt_pts != MP_NOPTS_VALUE && sub->last_pkt_pts > video_pts); break; }
if (sub->recorder_sink) mp_recorder_feed_packet(sub->recorder_sink, pkt);
sub->last_pkt_pts = pkt->pts; MP_TARRAY_APPEND(sub, sub->cached_pkts, sub->num_cached_pkts, pkt);
if (is_new_segment(sub, pkt)) { sub->new_segment = demux_copy_packet(sub->packet_pool, pkt); // Note that this can be delayed to a much later point in time. update_segment(sub); break; }
if (!(sub->preload_attempted && sub->sd->preload_ok)) sub->sd->driver->decode(sub->sd, pkt); } if (sub->cached_pkts && sub->num_cached_pkts) { bool visible = is_packet_visible(sub->cached_pkts[sub->cached_pkt_pos], video_pts); *sub_updated = update_pkt_cache(sub, video_pts) || sub->sub_visible != visible; sub->sub_visible = visible; } mp_mutex_unlock(&sub->lock);}
// Redecode all cached packets if needed.// Used with UPDATE_SUB_HARD and UPDATE_SUB_FILT.void sub_redecode_cached_packets(struct dec_sub *sub){ mp_mutex_lock(&sub->lock); int index = sub->cached_pkt_pos; while (index < sub->num_cached_pkts) { sub->sd->driver->decode(sub->sd, sub->cached_pkts[index]); ++index; } mp_mutex_unlock(&sub->lock);}
// Unref sub_bitmaps.rc to free the result. May return NULL.struct sub_bitmaps *sub_get_bitmaps(struct dec_sub *sub, struct mp_osd_res dim, int format, double pts){ mp_mutex_lock(&sub->lock);
pts = pts_to_subtitle(sub, pts);
sub->last_vo_pts = pts; update_segment(sub);
struct sub_bitmaps *res = NULL;
if (!(sub->end != MP_NOPTS_VALUE && pts >= sub->end) && sub->sd->driver->get_bitmaps) res = sub->sd->driver->get_bitmaps(sub->sd, dim, format, pts);
mp_mutex_unlock(&sub->lock); return res;}
// The returned string is talloc'ed.char *sub_get_text(struct dec_sub *sub, double pts, enum sd_text_type type){ mp_mutex_lock(&sub->lock); char *text = NULL;
pts = pts_to_subtitle(sub, pts);
sub->last_vo_pts = pts; update_segment(sub);
if (sub->sd->driver->get_text) text = sub->sd->driver->get_text(sub->sd, pts, type); mp_mutex_unlock(&sub->lock); return text;}
char *sub_ass_get_extradata(struct dec_sub *sub){ char *data = NULL; mp_mutex_lock(&sub->lock); if (strcmp(sub->sd->codec->codec, "ass") != 0) goto done; char *extradata = sub->sd->codec->extradata; int extradata_size = sub->sd->codec->extradata_size; data = talloc_strndup(NULL, extradata, extradata_size);done: mp_mutex_unlock(&sub->lock); return data;}
struct sd_times sub_get_times(struct dec_sub *sub, double pts){ mp_mutex_lock(&sub->lock); struct sd_times res = { .start = MP_NOPTS_VALUE, .end = MP_NOPTS_VALUE };
pts = pts_to_subtitle(sub, pts);
sub->last_vo_pts = pts; update_segment(sub);
if (sub->sd->driver->get_times) res = sub->sd->driver->get_times(sub->sd, pts);
mp_mutex_unlock(&sub->lock); return res;}
void sub_reset(struct dec_sub *sub){ mp_mutex_lock(&sub->lock); if (sub->sd->driver->reset) sub->sd->driver->reset(sub->sd); sub->last_pkt_pts = MP_NOPTS_VALUE; sub->last_vo_pts = MP_NOPTS_VALUE; destroy_cached_pkts(sub); demux_packet_pool_push(sub->packet_pool, sub->new_segment); sub->new_segment = NULL; mp_mutex_unlock(&sub->lock);}
void sub_select(struct dec_sub *sub, bool selected){ mp_mutex_lock(&sub->lock); if (sub->sd->driver->select) sub->sd->driver->select(sub->sd, selected); mp_mutex_unlock(&sub->lock);}
int sub_control(struct dec_sub *sub, enum sd_ctrl cmd, void *arg){ int r = CONTROL_UNKNOWN; mp_mutex_lock(&sub->lock); bool propagate = false; switch (cmd) { case SD_CTRL_SET_VIDEO_DEF_FPS: sub->video_fps = *(double *)arg; update_subtitle_speed(sub); break; case SD_CTRL_SUB_STEP: { double *a = arg; double arg2[2] = {a[0], a[1]}; arg2[0] = pts_to_subtitle(sub, arg2[0]); if (sub->sd->driver->control) r = sub->sd->driver->control(sub->sd, cmd, arg2); if (r == CONTROL_OK) a[0] = pts_from_subtitle(sub, arg2[0]); break; } case SD_CTRL_UPDATE_OPTS: { int flags = (uintptr_t)arg; if (m_config_cache_update(sub->opts_cache)) update_subtitle_speed(sub); m_config_cache_update(sub->shared_opts_cache); propagate = true; if (flags & UPDATE_SUB_HARD) { // forget about the previous preload because // UPDATE_SUB_HARD will cause a sub reinit // that clears all preloaded sub packets sub->preload_attempted = false; } break; } default: propagate = true; } if (propagate && sub->sd->driver->control) r = sub->sd->driver->control(sub->sd, cmd, arg); mp_mutex_unlock(&sub->lock); return r;}
void sub_set_recorder_sink(struct dec_sub *sub, struct mp_recorder_sink *sink){ mp_mutex_lock(&sub->lock); sub->recorder_sink = sink; mp_mutex_unlock(&sub->lock);}
void sub_set_play_dir(struct dec_sub *sub, int dir){ mp_mutex_lock(&sub->lock); sub->play_dir = dir; mp_mutex_unlock(&sub->lock);}
bool sub_is_primary_visible(struct dec_sub *sub){ mp_mutex_lock(&sub->lock); bool ret = sub->shared_opts->sub_visibility[0]; mp_mutex_unlock(&sub->lock); return ret;}
bool sub_is_secondary_visible(struct dec_sub *sub){ mp_mutex_lock(&sub->lock); bool ret = sub->shared_opts->sub_visibility[1]; mp_mutex_unlock(&sub->lock); return ret;}