mirror of
https://github.com/mpv-player/mpv
synced 2024-12-17 20:34:58 +00:00
4c3f042777
Do so by using mp_subprocess(). Although this uses completely different code on Unix too, you shouldn't notice a difference. A less ncie thing is that this reserves an entire thread while the command is running (which wastes some memory for stack, at least). But this is probably still the simplest way, and the fork() trick is apparently not implementable with posix_subprocess().
4762 lines
155 KiB
C
4762 lines
155 KiB
C
/*
|
|
* This file is part of MPlayer.
|
|
*
|
|
* MPlayer is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* MPlayer 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <inttypes.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <assert.h>
|
|
#include <time.h>
|
|
#include <math.h>
|
|
#include <pthread.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <libavutil/avstring.h>
|
|
#include <libavutil/common.h>
|
|
|
|
#include "config.h"
|
|
#include "talloc.h"
|
|
#include "client.h"
|
|
#include "common/msg.h"
|
|
#include "common/msg_control.h"
|
|
#include "command.h"
|
|
#include "osdep/timer.h"
|
|
#include "common/common.h"
|
|
#include "input/input.h"
|
|
#include "stream/stream.h"
|
|
#include "demux/demux.h"
|
|
#include "demux/stheader.h"
|
|
#include "common/playlist.h"
|
|
#include "sub/osd.h"
|
|
#include "sub/dec_sub.h"
|
|
#include "options/m_option.h"
|
|
#include "options/m_property.h"
|
|
#include "options/m_config.h"
|
|
#include "video/filter/vf.h"
|
|
#include "video/decode/vd.h"
|
|
#include "video/out/vo.h"
|
|
#include "video/csputils.h"
|
|
#include "audio/mixer.h"
|
|
#include "audio/audio_buffer.h"
|
|
#include "audio/out/ao.h"
|
|
#include "audio/filter/af.h"
|
|
#include "video/decode/dec_video.h"
|
|
#include "audio/decode/dec_audio.h"
|
|
#include "options/path.h"
|
|
#include "screenshot.h"
|
|
|
|
#include "osdep/io.h"
|
|
#include "osdep/subprocess.h"
|
|
|
|
#include "core.h"
|
|
|
|
struct command_ctx {
|
|
bool is_idle;
|
|
|
|
double last_seek_time;
|
|
double last_seek_pts;
|
|
double marked_pts;
|
|
|
|
double prev_pts;
|
|
|
|
struct cycle_counter *cycle_counters;
|
|
int num_cycle_counters;
|
|
|
|
struct overlay *overlays;
|
|
int num_overlays;
|
|
// One of these is in use by the OSD; the other one exists so that the
|
|
// bitmap list can be manipulated without additional synchronization.
|
|
struct sub_bitmaps overlay_osd[2];
|
|
struct sub_bitmaps *overlay_osd_current;
|
|
|
|
struct hook_handler **hooks;
|
|
int num_hooks;
|
|
int64_t hook_seq; // for hook_handler.seq
|
|
|
|
struct ao_device_list *cached_ao_devices;
|
|
};
|
|
|
|
struct overlay {
|
|
void *map_start;
|
|
size_t map_size;
|
|
struct sub_bitmap osd;
|
|
};
|
|
|
|
struct hook_handler {
|
|
char *client; // client API user name
|
|
char *type; // kind of hook, e.g. "on_load"
|
|
char *user_id; // numeric user-chosen ID, printed as string
|
|
int priority; // priority for global hook order
|
|
int64_t seq; // unique ID (also age -> fixed order for equal priorities)
|
|
bool active; // hook is currently in progress (only 1 at a time for now)
|
|
};
|
|
|
|
static int edit_filters(struct MPContext *mpctx, enum stream_type mediatype,
|
|
const char *cmd, const char *arg);
|
|
static int set_filters(struct MPContext *mpctx, enum stream_type mediatype,
|
|
struct m_obj_settings *new_chain);
|
|
|
|
static void hook_remove(struct MPContext *mpctx, int index)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
assert(index >= 0 && index < cmd->num_hooks);
|
|
talloc_free(cmd->hooks[index]);
|
|
MP_TARRAY_REMOVE_AT(cmd->hooks, cmd->num_hooks, index);
|
|
}
|
|
|
|
bool mp_hook_test_completion(struct MPContext *mpctx, char *type)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
for (int n = 0; n < cmd->num_hooks; n++) {
|
|
struct hook_handler *h = cmd->hooks[n];
|
|
if (h->active && strcmp(h->type, type) == 0) {
|
|
if (!mp_client_exists(mpctx, h->client)) {
|
|
hook_remove(mpctx, n);
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool send_hook_msg(struct MPContext *mpctx, struct hook_handler *h,
|
|
char *cmd)
|
|
{
|
|
mpv_event_client_message *m = talloc_ptrtype(NULL, m);
|
|
*m = (mpv_event_client_message){0};
|
|
MP_TARRAY_APPEND(m, m->args, m->num_args, cmd);
|
|
MP_TARRAY_APPEND(m, m->args, m->num_args, talloc_strdup(m, h->user_id));
|
|
MP_TARRAY_APPEND(m, m->args, m->num_args, talloc_strdup(m, h->type));
|
|
bool r =
|
|
mp_client_send_event(mpctx, h->client, MPV_EVENT_CLIENT_MESSAGE, m) >= 0;
|
|
if (!r)
|
|
MP_WARN(mpctx, "Sending hook command failed.\n");
|
|
return r;
|
|
}
|
|
|
|
// client==NULL means start the hook chain
|
|
void mp_hook_run(struct MPContext *mpctx, char *client, char *type)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
bool found_current = !client;
|
|
int index = -1;
|
|
for (int n = 0; n < cmd->num_hooks; n++) {
|
|
struct hook_handler *h = cmd->hooks[n];
|
|
if (!found_current) {
|
|
if (h->active && strcmp(h->type, type) == 0) {
|
|
h->active = false;
|
|
found_current = true;
|
|
}
|
|
} else if (strcmp(h->type, type) == 0) {
|
|
index = n;
|
|
break;
|
|
}
|
|
}
|
|
if (index < 0)
|
|
return;
|
|
struct hook_handler *next = cmd->hooks[index];
|
|
MP_VERBOSE(mpctx, "Running hook: %s/%s\n", next->client, type);
|
|
next->active = true;
|
|
if (!send_hook_msg(mpctx, next, "hook_run")) {
|
|
hook_remove(mpctx, index);
|
|
mp_input_wakeup(mpctx->input); // repeat next iteration to finish
|
|
}
|
|
}
|
|
|
|
static int compare_hook(const void *pa, const void *pb)
|
|
{
|
|
struct hook_handler **h1 = (void *)pa;
|
|
struct hook_handler **h2 = (void *)pb;
|
|
if ((*h1)->priority != (*h2)->priority)
|
|
return (*h1)->priority - (*h2)->priority;
|
|
return (*h1)->seq - (*h2)->seq;
|
|
}
|
|
|
|
static void mp_hook_add(struct MPContext *mpctx, char *client, char *name,
|
|
int id, int pri)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
struct hook_handler *h = talloc_ptrtype(cmd, h);
|
|
int64_t seq = cmd->hook_seq++;
|
|
*h = (struct hook_handler){
|
|
.client = talloc_strdup(h, client),
|
|
.type = talloc_strdup(h, name),
|
|
.user_id = talloc_asprintf(h, "%d", id),
|
|
.priority = pri,
|
|
.seq = seq,
|
|
};
|
|
MP_TARRAY_APPEND(cmd, cmd->hooks, cmd->num_hooks, h);
|
|
qsort(cmd->hooks, cmd->num_hooks, sizeof(cmd->hooks[0]), compare_hook);
|
|
}
|
|
|
|
// Call before a seek, in order to allow revert_seek to undo the seek.
|
|
static void mark_seek(struct MPContext *mpctx)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
double now = mp_time_sec();
|
|
if (now > cmd->last_seek_time + 2.0 || cmd->last_seek_pts == MP_NOPTS_VALUE)
|
|
cmd->last_seek_pts = get_current_time(mpctx);
|
|
cmd->last_seek_time = now;
|
|
}
|
|
|
|
static char *format_bitrate(int rate)
|
|
{
|
|
if (rate < 1024 * 1024)
|
|
return talloc_asprintf(NULL, "%.3f kbps", rate / 1000.0);
|
|
|
|
return talloc_asprintf(NULL, "%.3f mbps", rate / 1000000.0);
|
|
}
|
|
|
|
static char *format_file_size(int64_t size)
|
|
{
|
|
double s = size;
|
|
if (size < 1024)
|
|
return talloc_asprintf(NULL, "%.0f", s);
|
|
|
|
if (size < (1024 * 1024))
|
|
return talloc_asprintf(NULL, "%.3f Kb", s / (1024.0));
|
|
|
|
if (size < (1024 * 1024 * 1024))
|
|
return talloc_asprintf(NULL, "%.3f Mb", s / (1024.0 * 1024.0));
|
|
|
|
if (size < (1024LL * 1024LL * 1024LL * 1024LL))
|
|
return talloc_asprintf(NULL, "%.3f Gb", s / (1024.0 * 1024.0 * 1024.0));
|
|
|
|
return talloc_asprintf(NULL, "%.3f Tb", s / (1024.0 * 1024.0 * 1024.0 * 1024.0));
|
|
}
|
|
|
|
static char *format_delay(double time)
|
|
{
|
|
return talloc_asprintf(NULL, "%d ms", ROUND(time * 1000));
|
|
}
|
|
|
|
// Property-option bridge. (Maps the property to the option with the same name.)
|
|
static int mp_property_generic_option(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
const char *optname = prop->name;
|
|
struct m_config_option *opt = m_config_get_co(mpctx->mconfig,
|
|
bstr0(optname));
|
|
|
|
if (!opt)
|
|
return M_PROPERTY_UNKNOWN;
|
|
|
|
void *valptr = opt->data;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = *(opt->opt);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET:
|
|
m_option_copy(opt->opt, arg, valptr);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET:
|
|
m_option_copy(opt->opt, valptr, arg);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/// Playback speed (RW)
|
|
static int mp_property_playback_speed(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
double speed = mpctx->opts->playback_speed;
|
|
switch (action) {
|
|
case M_PROPERTY_SET: {
|
|
double new_speed = *(double *)arg;
|
|
if (speed != new_speed)
|
|
set_playback_speed(mpctx, new_speed);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_PRINT:
|
|
*(char **)arg = talloc_asprintf(NULL, "%.2f", speed);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
/// filename with path (RO)
|
|
static int mp_property_path(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->filename)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_strdup_ro(action, arg, mpctx->filename);
|
|
}
|
|
|
|
static int mp_property_filename(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->filename)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
char *filename = talloc_strdup(NULL, mpctx->filename);
|
|
if (mp_is_url(bstr0(filename)))
|
|
mp_url_unescape_inplace(filename);
|
|
char *f = (char *)mp_basename(filename);
|
|
int r = m_property_strdup_ro(action, arg, f[0] ? f : filename);
|
|
talloc_free(filename);
|
|
return r;
|
|
}
|
|
|
|
static int mp_property_stream_open_filename(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->stream_open_filename || !mpctx->playing)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
switch (action) {
|
|
case M_PROPERTY_SET: {
|
|
if (mpctx->stream)
|
|
return M_PROPERTY_ERROR;
|
|
mpctx->stream_open_filename =
|
|
talloc_strdup(mpctx->stream_open_filename, *(char **)arg);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET_TYPE:
|
|
case M_PROPERTY_GET:
|
|
return m_property_strdup_ro(action, arg, mpctx->stream_open_filename);
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_file_size(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int64_t size;
|
|
if (demux_stream_control(mpctx->demuxer, STREAM_CTRL_GET_SIZE, &size) < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
if (action == M_PROPERTY_PRINT) {
|
|
*(char **)arg = format_file_size(size);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_int64_ro(action, arg, size);
|
|
}
|
|
|
|
static int mp_property_media_title(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
char *name = NULL;
|
|
if (mpctx->opts->media_title)
|
|
name = mpctx->opts->media_title;
|
|
if (name && name[0])
|
|
return m_property_strdup_ro(action, arg, name);
|
|
if (name && name[0])
|
|
return m_property_strdup_ro(action, arg, name);
|
|
if (mpctx->master_demuxer) {
|
|
name = mp_tags_get_str(mpctx->master_demuxer->metadata, "title");
|
|
if (name && name[0])
|
|
return m_property_strdup_ro(action, arg, name);
|
|
name = mp_tags_get_str(mpctx->master_demuxer->metadata, "icy-title");
|
|
if (name && name[0])
|
|
return m_property_strdup_ro(action, arg, name);
|
|
}
|
|
return mp_property_filename(ctx, prop, action, arg);
|
|
}
|
|
|
|
static int mp_property_stream_path(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
// demuxer->stream as well as stream->url are immutable -> ok to access
|
|
struct stream *stream = mpctx->demuxer ? mpctx->demuxer->stream : NULL;
|
|
if (!stream || !stream->url)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_strdup_ro(action, arg, stream->url);
|
|
}
|
|
|
|
static int mp_property_stream_capture(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
if (action == M_PROPERTY_SET) {
|
|
char *filename = *(char **)arg;
|
|
demux_pause(mpctx->demuxer);
|
|
stream_set_capture_file(mpctx->demuxer->stream, filename);
|
|
demux_unpause(mpctx->demuxer);
|
|
// fall through to mp_property_generic_option
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
/// Demuxer name (RO)
|
|
static int mp_property_demuxer(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_strdup_ro(action, arg, demuxer->desc->name);
|
|
}
|
|
|
|
/// Position in the stream (RW)
|
|
static int mp_property_stream_pos(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
demux_pause(demuxer);
|
|
int r;
|
|
if (action == M_PROPERTY_SET) {
|
|
stream_seek(demuxer->stream, *(int64_t *) arg);
|
|
r = M_PROPERTY_OK;
|
|
} else {
|
|
r = m_property_int64_ro(action, arg, stream_tell(demuxer->stream));
|
|
}
|
|
demux_unpause(demuxer);
|
|
return r;
|
|
}
|
|
|
|
/// Stream end offset (RO)
|
|
static int mp_property_stream_end(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return mp_property_file_size(ctx, prop, action, arg);
|
|
}
|
|
|
|
// Does some magic to handle "<name>/full" as time formatted with milliseconds.
|
|
// Assumes prop is the type of the actual property.
|
|
static int property_time(int action, void *arg, double time)
|
|
{
|
|
const struct m_option time_type = {.type = CONF_TYPE_TIME};
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(double *)arg = time;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = time_type;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_KEY_ACTION: {
|
|
struct m_property_action_arg *ka = arg;
|
|
|
|
if (strcmp(ka->key, "full") != 0)
|
|
return M_PROPERTY_UNKNOWN;
|
|
|
|
switch (ka->action) {
|
|
case M_PROPERTY_GET:
|
|
*(double *)ka->arg = time;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_PRINT:
|
|
*(char **)ka->arg = mp_format_time(time, true);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)ka->arg = time_type;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/// Media length in seconds (RO)
|
|
static int mp_property_length(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
double len = get_time_length(mpctx);
|
|
|
|
if (len < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return property_time(action, arg, len);
|
|
}
|
|
|
|
static int mp_property_avsync(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_audio || !mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (mpctx->last_av_difference == MP_NOPTS_VALUE)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (action == M_PROPERTY_PRINT) {
|
|
*(char **)arg = talloc_asprintf(NULL, "%7.3f", mpctx->last_av_difference);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_double_ro(action, arg, mpctx->last_av_difference);
|
|
}
|
|
|
|
static int mp_property_total_avsync_change(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_audio || !mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (mpctx->total_avsync_change == MP_NOPTS_VALUE)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_double_ro(action, arg, mpctx->total_avsync_change);
|
|
}
|
|
|
|
|
|
/// Late frames
|
|
static int mp_property_drop_frame_cnt(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return m_property_int_ro(action, arg, mpctx->dropped_frames_total);
|
|
}
|
|
|
|
static int mp_property_vo_drop_frame_count(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return m_property_int_ro(action, arg, vo_get_drop_count(mpctx->video_out));
|
|
}
|
|
|
|
/// Current position in percent (RW)
|
|
static int mp_property_percent_pos(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_SET: {
|
|
double pos = *(double *)arg;
|
|
queue_seek(mpctx, MPSEEK_FACTOR, pos / 100.0, 0, true);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET: {
|
|
double pos = get_current_pos_ratio(mpctx, false) * 100.0;
|
|
if (pos < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
*(double *)arg = pos;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_DOUBLE,
|
|
.flags = M_OPT_RANGE,
|
|
.min = 0,
|
|
.max = 100,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_PRINT: {
|
|
int pos = get_percent_pos(mpctx);
|
|
if (pos < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
*(char **)arg = talloc_asprintf(NULL, "%d", pos);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_time_start(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
double start = get_start_time(mpctx);
|
|
if (start < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return property_time(action, arg, start);
|
|
}
|
|
|
|
/// Current position in seconds (RW)
|
|
static int mp_property_time_pos(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
if (action == M_PROPERTY_SET) {
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, *(double *)arg, 0, true);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return property_time(action, arg, get_current_time(mpctx));
|
|
}
|
|
|
|
static bool time_remaining(MPContext *mpctx, double *remaining)
|
|
{
|
|
double len = get_time_length(mpctx);
|
|
double playback = get_playback_time(mpctx);
|
|
|
|
*remaining = len - playback;
|
|
|
|
return len >= 0;
|
|
}
|
|
|
|
static int mp_property_remaining(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
double remaining;
|
|
if (!time_remaining(ctx, &remaining))
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return property_time(action, arg, remaining);
|
|
}
|
|
|
|
static int mp_property_playtime_remaining(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
double remaining;
|
|
if (!time_remaining(mpctx, &remaining))
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
double speed = mpctx->opts->playback_speed;
|
|
return property_time(action, arg, remaining / speed);
|
|
}
|
|
|
|
static int mp_property_playback_time(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return property_time(action, arg, get_playback_time(mpctx));
|
|
}
|
|
|
|
/// Current BD/DVD title (RW)
|
|
static int mp_property_disc_title(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *d = mpctx->master_demuxer;
|
|
if (!d)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
unsigned int title = -1;
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
if (demux_stream_control(d, STREAM_CTRL_GET_CURRENT_TITLE, &title) < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
*(int*)arg = title;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_INT,
|
|
.flags = M_OPT_MIN,
|
|
.min = -1,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET:
|
|
title = *(int*)arg;
|
|
if (demux_stream_control(d, STREAM_CTRL_SET_CURRENT_TITLE, &title) < 0)
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
mpctx->stop_play = PT_RELOAD_DEMUXER;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_disc_menu(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
int state = mp_nav_in_menu(mpctx);
|
|
if (state < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_flag_ro(action, arg, !!state);
|
|
}
|
|
|
|
/// Current chapter (RW)
|
|
static int mp_property_chapter(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
int chapter = get_current_chapter(mpctx);
|
|
if (chapter < -1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(int *) arg = chapter;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_INT,
|
|
.flags = M_OPT_MIN | M_OPT_MAX,
|
|
.min = -1,
|
|
.max = get_chapter_count(mpctx) - 1,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_PRINT: {
|
|
*(char **) arg = chapter_display_name(mpctx, chapter);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_SWITCH:
|
|
case M_PROPERTY_SET: ;
|
|
mark_seek(mpctx);
|
|
int step_all;
|
|
if (action == M_PROPERTY_SWITCH) {
|
|
struct m_property_switch_arg *sarg = arg;
|
|
step_all = ROUND(sarg->inc);
|
|
// Check threshold for relative backward seeks
|
|
if (mpctx->opts->chapter_seek_threshold >= 0 && step_all < 0) {
|
|
double current_chapter_start =
|
|
chapter_start_time(mpctx, chapter);
|
|
// If we are far enough into a chapter, seek back to the
|
|
// beginning of current chapter instead of previous one
|
|
if (current_chapter_start != MP_NOPTS_VALUE &&
|
|
get_current_time(mpctx) - current_chapter_start >
|
|
mpctx->opts->chapter_seek_threshold)
|
|
step_all++;
|
|
}
|
|
} else // Absolute set
|
|
step_all = *(int *)arg - chapter;
|
|
chapter += step_all;
|
|
if (chapter < -1)
|
|
chapter = -1;
|
|
if (chapter >= get_chapter_count(mpctx) && step_all > 0) {
|
|
if (mpctx->opts->keep_open) {
|
|
seek_to_last_frame(mpctx);
|
|
} else {
|
|
mpctx->stop_play = PT_NEXT_ENTRY;
|
|
}
|
|
} else {
|
|
mp_seek_chapter(mpctx, chapter);
|
|
}
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int get_chapter_entry(int item, int action, void *arg, void *ctx)
|
|
{
|
|
struct MPContext *mpctx = ctx;
|
|
char *name = chapter_name(mpctx, item);
|
|
double time = chapter_start_time(mpctx, item);
|
|
struct m_sub_property props[] = {
|
|
{"title", SUB_PROP_STR(name)},
|
|
{"time", {.type = CONF_TYPE_TIME}, {.time = time}},
|
|
{0}
|
|
};
|
|
|
|
int r = m_property_read_sub(props, action, arg);
|
|
talloc_free(name);
|
|
return r;
|
|
}
|
|
|
|
static int mp_property_list_chapters(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
int count = get_chapter_count(mpctx);
|
|
if (action == M_PROPERTY_PRINT) {
|
|
int cur = mpctx->num_sources ? get_current_chapter(mpctx) : -1;
|
|
char *res = NULL;
|
|
int n;
|
|
|
|
if (count < 1) {
|
|
res = talloc_asprintf_append(res, "No chapters.");
|
|
}
|
|
|
|
for (n = 0; n < count; n++) {
|
|
char *name = chapter_display_name(mpctx, n);
|
|
double t = chapter_start_time(mpctx, n);
|
|
char* time = mp_format_time(t, false);
|
|
res = talloc_asprintf_append(res, "%s", time);
|
|
talloc_free(time);
|
|
char *m1 = "> ", *m2 = " <";
|
|
if (n != cur)
|
|
m1 = m2 = "";
|
|
res = talloc_asprintf_append(res, " %s%s%s\n", m1, name, m2);
|
|
talloc_free(name);
|
|
}
|
|
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_read_list(action, arg, count, get_chapter_entry, mpctx);
|
|
}
|
|
|
|
static int mp_property_edition(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct MPOpts *opts = mpctx->opts;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (demuxer->num_editions <= 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int edition = demuxer->edition;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(int *)arg = edition;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET: {
|
|
edition = *(int *)arg;
|
|
if (edition != demuxer->edition) {
|
|
opts->edition_id = edition;
|
|
mpctx->stop_play = PT_RELOAD_DEMUXER;
|
|
}
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET_TYPE: {
|
|
struct m_option opt = {
|
|
.type = CONF_TYPE_INT,
|
|
.flags = CONF_RANGE,
|
|
.min = 0,
|
|
.max = demuxer->num_editions - 1,
|
|
};
|
|
*(struct m_option *)arg = opt;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int get_edition_entry(int item, int action, void *arg, void *ctx)
|
|
{
|
|
struct MPContext *mpctx = ctx;
|
|
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
struct demux_edition *ed = &demuxer->editions[item];
|
|
|
|
char *title = mp_tags_get_str(ed->metadata, "title");
|
|
|
|
struct m_sub_property props[] = {
|
|
{"id", SUB_PROP_INT(item)},
|
|
{"title", SUB_PROP_STR(title),
|
|
.unavailable = !title},
|
|
{"default", SUB_PROP_FLAG(ed->default_edition)},
|
|
{0}
|
|
};
|
|
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
|
|
static int property_list_editions(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
if (action == M_PROPERTY_PRINT) {
|
|
char *res = NULL;
|
|
|
|
struct demux_edition *editions = demuxer->editions;
|
|
int num_editions = demuxer->num_editions;
|
|
int current = demuxer->edition;
|
|
|
|
if (!num_editions)
|
|
res = talloc_asprintf_append(res, "No editions.");
|
|
|
|
for (int n = 0; n < num_editions; n++) {
|
|
struct demux_edition *ed = &editions[n];
|
|
|
|
if (n == current)
|
|
res = talloc_asprintf_append(res, "> ");
|
|
res = talloc_asprintf_append(res, "%d: ", n);
|
|
char *title = mp_tags_get_str(ed->metadata, "title");
|
|
if (!title)
|
|
title = "unnamed";
|
|
res = talloc_asprintf_append(res, "'%s' ", title);
|
|
if (n == current)
|
|
res = talloc_asprintf_append(res, "<");
|
|
res = talloc_asprintf_append(res, "\n");
|
|
}
|
|
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_read_list(action, arg, demuxer->num_editions,
|
|
get_edition_entry, mpctx);
|
|
}
|
|
|
|
/// Number of titles in BD/DVD
|
|
static int mp_property_disc_titles(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
unsigned int num_titles;
|
|
if (!demuxer || demux_stream_control(demuxer, STREAM_CTRL_GET_NUM_TITLES,
|
|
&num_titles) < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_int_ro(action, arg, num_titles);
|
|
}
|
|
|
|
static int get_disc_title_entry(int item, int action, void *arg, void *ctx)
|
|
{
|
|
struct MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
|
|
double len = item;
|
|
if (demux_stream_control(demuxer, STREAM_CTRL_GET_TITLE_LENGTH, &len) < 1)
|
|
len = -1;
|
|
|
|
struct m_sub_property props[] = {
|
|
{"id", SUB_PROP_INT(item)},
|
|
{"length", {.type = CONF_TYPE_TIME}, {.time = len},
|
|
.unavailable = len < 0},
|
|
{0}
|
|
};
|
|
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
|
|
static int mp_property_list_disc_titles(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
unsigned int num_titles;
|
|
if (!demuxer || demux_stream_control(demuxer, STREAM_CTRL_GET_NUM_TITLES,
|
|
&num_titles) < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_read_list(action, arg, num_titles,
|
|
get_disc_title_entry, mpctx);
|
|
}
|
|
|
|
/// Number of chapters in file
|
|
static int mp_property_chapters(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
int count = get_chapter_count(mpctx);
|
|
return m_property_int_ro(action, arg, count);
|
|
}
|
|
|
|
static int mp_property_editions(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (demuxer->num_editions <= 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_int_ro(action, arg, demuxer->num_editions);
|
|
}
|
|
|
|
/// Current dvd angle (RW)
|
|
static int mp_property_angle(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int ris, angles = -1, angle = 1;
|
|
|
|
ris = demux_stream_control(demuxer, STREAM_CTRL_GET_NUM_ANGLES, &angles);
|
|
if (ris == STREAM_UNSUPPORTED)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
ris = demux_stream_control(demuxer, STREAM_CTRL_GET_ANGLE, &angle);
|
|
if (ris == STREAM_UNSUPPORTED)
|
|
return -1;
|
|
|
|
if (angle < 0 || angles <= 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(int *) arg = angle;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_PRINT: {
|
|
*(char **) arg = talloc_asprintf(NULL, "%d/%d", angle, angles);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_SET:
|
|
angle = *(int *)arg;
|
|
if (angle < 0 || angle > angles)
|
|
return M_PROPERTY_ERROR;
|
|
|
|
demux_pause(demuxer);
|
|
demux_flush(demuxer);
|
|
ris = demux_stream_control(demuxer, STREAM_CTRL_SET_ANGLE, &angle);
|
|
demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);
|
|
demux_unpause(demuxer);
|
|
|
|
reset_audio_state(mpctx);
|
|
reset_video_state(mpctx);
|
|
|
|
return ris == STREAM_OK ? M_PROPERTY_OK : M_PROPERTY_ERROR;
|
|
case M_PROPERTY_GET_TYPE: {
|
|
struct m_option opt = {
|
|
.type = CONF_TYPE_INT,
|
|
.flags = CONF_RANGE,
|
|
.min = 1,
|
|
.max = angles,
|
|
};
|
|
*(struct m_option *)arg = opt;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int get_tag_entry(int item, int action, void *arg, void *ctx)
|
|
{
|
|
struct mp_tags *tags = ctx;
|
|
|
|
struct m_sub_property props[] = {
|
|
{"key", SUB_PROP_STR(tags->keys[item])},
|
|
{"value", SUB_PROP_STR(tags->values[item])},
|
|
{0}
|
|
};
|
|
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
|
|
static int tag_property(int action, void *arg, struct mp_tags *tags)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_GET: {
|
|
mpv_node_list *list = talloc_zero(NULL, mpv_node_list);
|
|
mpv_node node = {
|
|
.format = MPV_FORMAT_NODE_MAP,
|
|
.u.list = list,
|
|
};
|
|
list->num = tags->num_keys;
|
|
list->values = talloc_array(list, mpv_node, list->num);
|
|
list->keys = talloc_array(list, char*, list->num);
|
|
for (int n = 0; n < tags->num_keys; n++) {
|
|
list->keys[n] = talloc_strdup(list, tags->keys[n]);
|
|
list->values[n] = (struct mpv_node){
|
|
.format = MPV_FORMAT_STRING,
|
|
.u.string = talloc_strdup(list, tags->values[n]),
|
|
};
|
|
}
|
|
*(mpv_node*)arg = node;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET_TYPE: {
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_NODE};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_PRINT: {
|
|
char *res = NULL;
|
|
for (int n = 0; n < tags->num_keys; n++) {
|
|
res = talloc_asprintf_append_buffer(res, "%s: %s\n",
|
|
tags->keys[n], tags->values[n]);
|
|
}
|
|
if (!res)
|
|
res = talloc_strdup(NULL, "(empty)");
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_KEY_ACTION: {
|
|
struct m_property_action_arg *ka = arg;
|
|
bstr key;
|
|
char *rem;
|
|
m_property_split_path(ka->key, &key, &rem);
|
|
if (bstr_equals0(key, "list")) {
|
|
struct m_property_action_arg nka = *ka;
|
|
nka.key = rem;
|
|
return m_property_read_list(action, &nka, tags->num_keys,
|
|
get_tag_entry, tags);
|
|
}
|
|
// Direct access without this prefix is allowed for compatibility.
|
|
bstr k = bstr0(ka->key);
|
|
bstr_eatstart0(&k, "by-key/");
|
|
char *meta = mp_tags_get_bstr(tags, k);
|
|
if (!meta)
|
|
return M_PROPERTY_UNKNOWN;
|
|
switch (ka->action) {
|
|
case M_PROPERTY_GET:
|
|
*(char **)ka->arg = talloc_strdup(NULL, meta);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)ka->arg = (struct m_option){
|
|
.type = CONF_TYPE_STRING,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/// Demuxer meta data
|
|
static int mp_property_metadata(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return tag_property(action, arg, demuxer->metadata);
|
|
}
|
|
|
|
static int mp_property_filtered_metadata(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->filtered_tags)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return tag_property(action, arg, mpctx->filtered_tags);
|
|
}
|
|
|
|
static int mp_property_chapter_metadata(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
int chapter = get_current_chapter(mpctx);
|
|
if (chapter < 0 || chapter >= mpctx->num_chapters)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (!mpctx->chapters[chapter].metadata)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return tag_property(action, arg, mpctx->chapters[chapter].metadata);
|
|
}
|
|
|
|
static int mp_property_vf_metadata(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!(mpctx->d_video && mpctx->d_video->vfilter))
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
struct vf_chain *vf = mpctx->d_video->vfilter;
|
|
|
|
if (action == M_PROPERTY_KEY_ACTION) {
|
|
struct m_property_action_arg *ka = arg;
|
|
bstr key;
|
|
char *rem;
|
|
m_property_split_path(ka->key, &key, &rem);
|
|
struct mp_tags vf_metadata = {0};
|
|
switch (vf_control_by_label(vf, VFCTRL_GET_METADATA, &vf_metadata, key)) {
|
|
case CONTROL_UNKNOWN:
|
|
return M_PROPERTY_UNKNOWN;
|
|
case CONTROL_NA: // empty
|
|
case CONTROL_OK:
|
|
if (strlen(rem)) {
|
|
struct m_property_action_arg next_ka = *ka;
|
|
next_ka.key = rem;
|
|
return tag_property(M_PROPERTY_KEY_ACTION, &next_ka, &vf_metadata);
|
|
} else {
|
|
return tag_property(ka->action, ka->arg, &vf_metadata);
|
|
}
|
|
return M_PROPERTY_OK;
|
|
default:
|
|
return M_PROPERTY_ERROR;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_pause(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
|
|
if (action == M_PROPERTY_SET) {
|
|
if (*(int *)arg) {
|
|
pause_player(mpctx);
|
|
} else {
|
|
unpause_player(mpctx);
|
|
}
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
static int mp_property_core_idle(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
bool idle = mpctx->paused || !mpctx->restart_complete || !mpctx->playing;
|
|
return m_property_flag_ro(action, arg, idle);
|
|
}
|
|
|
|
static int mp_property_idle(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
return m_property_flag_ro(action, arg, cmd->is_idle);
|
|
}
|
|
|
|
static int mp_property_eof_reached(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
bool eof = mpctx->video_status == STATUS_EOF &&
|
|
mpctx->audio_status == STATUS_EOF;
|
|
return m_property_flag_ro(action, arg, eof);
|
|
}
|
|
|
|
static int mp_property_seeking(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_flag_ro(action, arg, !mpctx->restart_complete);
|
|
}
|
|
|
|
static int mp_property_playback_abort(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
return m_property_flag_ro(action, arg, !mpctx->playing || mpctx->stop_play);
|
|
}
|
|
|
|
static int mp_property_cache(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
float cache = mp_get_cache_percent(mpctx);
|
|
if (cache < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
if (action == M_PROPERTY_PRINT) {
|
|
*(char **)arg = talloc_asprintf(NULL, "%d", (int)cache);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
|
|
return m_property_float_ro(action, arg, cache);
|
|
}
|
|
|
|
static int property_int_kb_size(int kb_size, int action, void *arg)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(int *)arg = kb_size;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_PRINT:
|
|
*(char **)arg = format_file_size(kb_size * 1024LL);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_INT};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_cache_size(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct demuxer *demuxer = mpctx->demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
case M_PROPERTY_PRINT: {
|
|
int64_t size = -1;
|
|
demux_stream_control(demuxer, STREAM_CTRL_GET_CACHE_SIZE, &size);
|
|
if (size <= 0)
|
|
break;
|
|
return property_int_kb_size(size / 1024, action, arg);
|
|
}
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_INT,
|
|
.flags = M_OPT_MIN,
|
|
.min = 0,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET: {
|
|
int64_t size = *(int *)arg * 1024LL;
|
|
int r = demux_stream_control(demuxer, STREAM_CTRL_SET_CACHE_SIZE, &size);
|
|
if (r == STREAM_UNSUPPORTED)
|
|
break;
|
|
if (r == STREAM_OK)
|
|
return M_PROPERTY_OK;
|
|
return M_PROPERTY_ERROR;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_cache_used(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int64_t size = -1;
|
|
demux_stream_control(mpctx->demuxer, STREAM_CTRL_GET_CACHE_FILL, &size);
|
|
if (size < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return property_int_kb_size(size / 1024, action, arg);
|
|
}
|
|
|
|
static int mp_property_cache_free(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int64_t size_used = -1;
|
|
demux_stream_control(mpctx->demuxer, STREAM_CTRL_GET_CACHE_FILL, &size_used);
|
|
if (size_used < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int64_t size = -1;
|
|
demux_stream_control(mpctx->demuxer, STREAM_CTRL_GET_CACHE_SIZE, &size);
|
|
if (size <= 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return property_int_kb_size((size - size_used) / 1024, action, arg);
|
|
}
|
|
|
|
static int mp_property_cache_idle(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
int idle = -1;
|
|
if (mpctx->demuxer)
|
|
demux_stream_control(mpctx->demuxer, STREAM_CTRL_GET_CACHE_IDLE, &idle);
|
|
if (idle < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_flag_ro(action, arg, !!idle);
|
|
}
|
|
|
|
static int mp_property_demuxer_cache_duration(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
struct demux_ctrl_reader_state s;
|
|
if (demux_control(mpctx->demuxer, DEMUXER_CTRL_GET_READER_STATE, &s) < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
if (s.ts_duration < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return m_property_double_ro(action, arg, s.ts_duration);
|
|
}
|
|
|
|
static int mp_property_demuxer_cache_idle(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
struct demux_ctrl_reader_state s;
|
|
if (demux_control(mpctx->demuxer, DEMUXER_CTRL_GET_READER_STATE, &s) < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return m_property_flag_ro(action, arg, s.idle);
|
|
}
|
|
|
|
static int mp_property_paused_for_cache(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_flag_ro(action, arg, mpctx->paused_for_cache);
|
|
}
|
|
|
|
static int mp_property_cache_buffering(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
double state = get_cache_buffering_percentage(mpctx);
|
|
if (state < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_int_ro(action, arg, state * 100);
|
|
}
|
|
|
|
static int mp_property_clock(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
char outstr[6];
|
|
time_t t = time(NULL);
|
|
struct tm *tmp = localtime(&t);
|
|
|
|
if ((tmp != NULL) && (strftime(outstr, sizeof(outstr), "%H:%M", tmp) == 5))
|
|
return m_property_strdup_ro(action, arg, outstr);
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
}
|
|
|
|
static int mp_property_seekable(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
return m_property_flag_ro(action, arg, mpctx->demuxer->seekable);
|
|
}
|
|
|
|
/// Volume (RW)
|
|
static int mp_property_volume(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mixer_audio_initialized(mpctx->mixer))
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
mixer_getbothvolume(mpctx->mixer, arg);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_FLOAT,
|
|
.flags = M_OPT_RANGE,
|
|
.min = 0,
|
|
.max = 100,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_NEUTRAL:
|
|
*(float *)arg = mixer_getneutralvolume(mpctx->mixer);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_PRINT: {
|
|
float val;
|
|
mixer_getbothvolume(mpctx->mixer, &val);
|
|
*(char **)arg = talloc_asprintf(NULL, "%i", (int)val);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_SET:
|
|
mixer_setvolume(mpctx->mixer, *(float *) arg, *(float *) arg);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SWITCH: {
|
|
struct m_property_switch_arg *sarg = arg;
|
|
mixer_addvolume(mpctx->mixer, sarg->inc);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/// Mute (RW)
|
|
static int mp_property_mute(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mixer_audio_initialized(mpctx->mixer))
|
|
return M_PROPERTY_ERROR;
|
|
switch (action) {
|
|
case M_PROPERTY_SET:
|
|
mixer_setmute(mpctx->mixer, *(int *) arg);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET:
|
|
*(int *)arg = mixer_getmute(mpctx->mixer);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_FLAG};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_volrestore(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
switch (action) {
|
|
case M_PROPERTY_GET: {
|
|
char *s = mixer_get_volume_restore_data(mpctx->mixer);
|
|
*(char **)arg = s;
|
|
return s ? M_PROPERTY_OK : M_PROPERTY_UNAVAILABLE;
|
|
}
|
|
case M_PROPERTY_SET:
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
static int get_device_entry(int item, int action, void *arg, void *ctx)
|
|
{
|
|
struct ao_device_list *list = ctx;
|
|
struct ao_device_desc *entry = &list->devices[item];
|
|
|
|
struct m_sub_property props[] = {
|
|
{"name", SUB_PROP_STR(entry->name)},
|
|
{"description", SUB_PROP_STR(entry->desc)},
|
|
{0}
|
|
};
|
|
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
|
|
static void reload_audio_output(struct MPContext *mpctx)
|
|
{
|
|
if (!mpctx->ao)
|
|
return;
|
|
ao_request_reload(mpctx->ao);
|
|
}
|
|
|
|
static int mp_property_audio_device(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
struct MPContext *mpctx = ctx;
|
|
int r = mp_property_generic_option(mpctx, prop, action, arg);
|
|
if (action == M_PROPERTY_SET)
|
|
reload_audio_output(mpctx);
|
|
return r;
|
|
}
|
|
|
|
static int mp_property_audio_devices(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
struct MPContext *mpctx = ctx;
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
if (!cmd->cached_ao_devices)
|
|
cmd->cached_ao_devices = ao_get_device_list(mpctx->global);
|
|
if (!cmd->cached_ao_devices)
|
|
return M_PROPERTY_ERROR;
|
|
talloc_steal(cmd, cmd->cached_ao_devices);
|
|
|
|
return m_property_read_list(action, arg, cmd->cached_ao_devices->num_devices,
|
|
get_device_entry, cmd->cached_ao_devices);
|
|
}
|
|
|
|
/// Audio delay (RW)
|
|
static int mp_property_audio_delay(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!(mpctx->d_audio && mpctx->d_video))
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
float delay = mpctx->opts->audio_delay;
|
|
switch (action) {
|
|
case M_PROPERTY_PRINT:
|
|
*(char **)arg = format_delay(delay);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET:
|
|
mpctx->audio_delay = mpctx->opts->audio_delay = *(float *)arg;
|
|
mpctx->delay += mpctx->audio_delay - delay;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
/// Audio codec tag (RO)
|
|
static int mp_property_audio_format(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
const char *c = mpctx->d_audio ? mpctx->d_audio->header->codec : NULL;
|
|
return m_property_strdup_ro(action, arg, c);
|
|
}
|
|
|
|
/// Audio codec name (RO)
|
|
static int mp_property_audio_codec(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
const char *c = mpctx->d_audio ? mpctx->d_audio->decoder_desc : NULL;
|
|
return m_property_strdup_ro(action, arg, c);
|
|
}
|
|
|
|
/// Audio bitrate (RO)
|
|
static int mp_property_audio_bitrate(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_audio)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (action == M_PROPERTY_PRINT) {
|
|
*(char **)arg = format_bitrate(mpctx->d_audio->bitrate);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_int_ro(action, arg, mpctx->d_audio->bitrate);
|
|
}
|
|
|
|
/// Samplerate (RO)
|
|
static int mp_property_samplerate(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct mp_audio fmt = {0};
|
|
if (mpctx->d_audio)
|
|
fmt = mpctx->d_audio->decode_format;
|
|
if (!fmt.rate)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (action == M_PROPERTY_PRINT) {
|
|
*(char **)arg = talloc_asprintf(NULL, "%d kHz", fmt.rate / 1000);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_int_ro(action, arg, fmt.rate);
|
|
}
|
|
|
|
/// Number of channels (RO)
|
|
static int mp_property_channels(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct mp_audio fmt = {0};
|
|
if (mpctx->d_audio)
|
|
fmt = mpctx->d_audio->decode_format;
|
|
if (!fmt.channels.num)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
switch (action) {
|
|
case M_PROPERTY_PRINT:
|
|
*(char **) arg = talloc_strdup(NULL, mp_chmap_to_str(&fmt.channels));
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET:
|
|
*(int *)arg = fmt.channels.num;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_INT};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/// Balance (RW)
|
|
static int mp_property_balance(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
float bal;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
mixer_getbalance(mpctx->mixer, arg);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_FLOAT,
|
|
.flags = M_OPT_RANGE,
|
|
.min = -1,
|
|
.max = 1,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_PRINT: {
|
|
char **str = arg;
|
|
mixer_getbalance(mpctx->mixer, &bal);
|
|
if (bal == 0.f)
|
|
*str = talloc_strdup(NULL, "center");
|
|
else if (bal == -1.f)
|
|
*str = talloc_strdup(NULL, "left only");
|
|
else if (bal == 1.f)
|
|
*str = talloc_strdup(NULL, "right only");
|
|
else {
|
|
unsigned right = (bal + 1.f) / 2.f * 100.f;
|
|
*str = talloc_asprintf(NULL, "left %d%%, right %d%%",
|
|
100 - right, right);
|
|
}
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_SET:
|
|
mixer_setbalance(mpctx->mixer, *(float *)arg);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static struct track* track_next(struct MPContext *mpctx, int order,
|
|
enum stream_type type, int direction,
|
|
struct track *track)
|
|
{
|
|
assert(direction == -1 || direction == +1);
|
|
struct track *prev = NULL, *next = NULL;
|
|
bool seen = track == NULL;
|
|
for (int n = 0; n < mpctx->num_tracks; n++) {
|
|
struct track *cur = mpctx->tracks[n];
|
|
// One track can be selected only one time - pretend already selected
|
|
// tracks don't exist.
|
|
for (int r = 0; r < NUM_PTRACKS; r++) {
|
|
if (r != order && mpctx->current_track[r][type] == cur)
|
|
cur = NULL;
|
|
}
|
|
if (!cur)
|
|
continue;
|
|
if (cur->type == type) {
|
|
if (cur == track) {
|
|
seen = true;
|
|
} else {
|
|
if (seen && !next) {
|
|
next = cur;
|
|
}
|
|
if (!seen || !track) {
|
|
prev = cur;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return direction > 0 ? next : prev;
|
|
}
|
|
|
|
static int property_switch_track(struct m_property *prop, int action, void *arg,
|
|
MPContext *mpctx, int order,
|
|
enum stream_type type)
|
|
{
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
struct track *track = mpctx->current_track[order][type];
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(int *) arg = track ? track->user_tid : -2;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_PRINT:
|
|
if (!track)
|
|
*(char **) arg = talloc_strdup(NULL, "no");
|
|
else {
|
|
char *lang = track->lang;
|
|
if (!lang)
|
|
lang = "unknown";
|
|
|
|
if (track->title)
|
|
*(char **)arg = talloc_asprintf(NULL, "(%d) %s (\"%s\")",
|
|
track->user_tid, lang, track->title);
|
|
else
|
|
*(char **)arg = talloc_asprintf(NULL, "(%d) %s",
|
|
track->user_tid, lang);
|
|
}
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_SWITCH: {
|
|
struct m_property_switch_arg *sarg = arg;
|
|
mp_switch_track_n(mpctx, order, type,
|
|
track_next(mpctx, order, type, sarg->inc >= 0 ? +1 : -1, track));
|
|
mp_mark_user_track_selection(mpctx, order, type);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_SET:
|
|
track = mp_track_by_tid(mpctx, type, *(int *)arg);
|
|
mp_switch_track_n(mpctx, order, type, track);
|
|
mp_mark_user_track_selection(mpctx, order, type);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
// Similar, less featured, for selecting by ff-index.
|
|
static int property_switch_track_ff(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
enum stream_type type = (intptr_t)prop->priv;
|
|
if (!mpctx->num_sources)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
struct track *track = mpctx->current_track[0][type];
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(int *) arg = track ? track->ff_index : -2;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET: {
|
|
int id = *(int *)arg;
|
|
track = NULL;
|
|
for (int n = 0; n < mpctx->num_tracks; n++) {
|
|
struct track *cur = mpctx->tracks[n];
|
|
if (cur->type == type && cur->ff_index == id) {
|
|
track = cur;
|
|
break;
|
|
}
|
|
}
|
|
if (!track && id >= 0)
|
|
return M_PROPERTY_ERROR;
|
|
mp_switch_track_n(mpctx, 0, type, track);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
static int get_track_entry(int item, int action, void *arg, void *ctx)
|
|
{
|
|
struct MPContext *mpctx = ctx;
|
|
struct track *track = mpctx->tracks[item];
|
|
|
|
const char *codec = track->stream ? track->stream->codec : NULL;
|
|
|
|
struct m_sub_property props[] = {
|
|
{"id", SUB_PROP_INT(track->user_tid)},
|
|
{"type", SUB_PROP_STR(stream_type_name(track->type)),
|
|
.unavailable = !stream_type_name(track->type)},
|
|
{"src-id", SUB_PROP_INT(track->demuxer_id),
|
|
.unavailable = track->demuxer_id == -1},
|
|
{"title", SUB_PROP_STR(track->title),
|
|
.unavailable = !track->title},
|
|
{"lang", SUB_PROP_STR(track->lang),
|
|
.unavailable = !track->lang},
|
|
{"albumart", SUB_PROP_FLAG(track->attached_picture)},
|
|
{"default", SUB_PROP_FLAG(track->default_track)},
|
|
{"external", SUB_PROP_FLAG(track->is_external)},
|
|
{"selected", SUB_PROP_FLAG(track->selected)},
|
|
{"external-filename", SUB_PROP_STR(track->external_filename),
|
|
.unavailable = !track->external_filename},
|
|
{"codec", SUB_PROP_STR(codec),
|
|
.unavailable = !codec},
|
|
{"ff-index", SUB_PROP_INT(track->ff_index)},
|
|
{0}
|
|
};
|
|
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
|
|
static const char *track_type_name(enum stream_type t)
|
|
{
|
|
switch (t) {
|
|
case STREAM_VIDEO: return "Video";
|
|
case STREAM_AUDIO: return "Audio";
|
|
case STREAM_SUB: return "Sub";
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int property_list_tracks(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (action == M_PROPERTY_PRINT) {
|
|
char *res = NULL;
|
|
|
|
for (int type = 0; type < STREAM_TYPE_COUNT; type++) {
|
|
for (int n = 0; n < mpctx->num_tracks; n++) {
|
|
struct track *track = mpctx->tracks[n];
|
|
if (track->type != type)
|
|
continue;
|
|
|
|
res = talloc_asprintf_append(res, "%s: ",
|
|
track_type_name(track->type));
|
|
if (track->selected)
|
|
res = talloc_asprintf_append(res, "> ");
|
|
res = talloc_asprintf_append(res, "(%d) ", track->user_tid);
|
|
if (track->title)
|
|
res = talloc_asprintf_append(res, "'%s' ", track->title);
|
|
if (track->lang)
|
|
res = talloc_asprintf_append(res, "(%s) ", track->lang);
|
|
if (track->is_external)
|
|
res = talloc_asprintf_append(res, "(external) ");
|
|
if (track->selected)
|
|
res = talloc_asprintf_append(res, "<");
|
|
res = talloc_asprintf_append(res, "\n");
|
|
}
|
|
|
|
res = talloc_asprintf_append(res, "\n");
|
|
}
|
|
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
if (demuxer && demuxer->num_editions > 1)
|
|
res = talloc_asprintf_append(res, "\nEdition: %d of %d\n",
|
|
demuxer->edition + 1,
|
|
demuxer->num_editions);
|
|
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_read_list(action, arg, mpctx->num_tracks,
|
|
get_track_entry, mpctx);
|
|
}
|
|
|
|
/// Selected audio id (RW)
|
|
static int mp_property_audio(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return property_switch_track(prop, action, arg, ctx, 0, STREAM_AUDIO);
|
|
}
|
|
|
|
/// Selected video id (RW)
|
|
static int mp_property_video(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return property_switch_track(prop, action, arg, ctx, 0, STREAM_VIDEO);
|
|
}
|
|
|
|
static struct track *find_track_by_demuxer_id(MPContext *mpctx,
|
|
enum stream_type type,
|
|
int demuxer_id)
|
|
{
|
|
for (int n = 0; n < mpctx->num_tracks; n++) {
|
|
struct track *track = mpctx->tracks[n];
|
|
if (track->type == type && track->demuxer_id == demuxer_id)
|
|
return track;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int mp_property_program(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
demux_program_t prog;
|
|
|
|
struct demuxer *demuxer = mpctx->master_demuxer;
|
|
if (!demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_SWITCH:
|
|
case M_PROPERTY_SET:
|
|
if (action == M_PROPERTY_SET && arg)
|
|
prog.progid = *((int *) arg);
|
|
else
|
|
prog.progid = -1;
|
|
if (demux_control(demuxer, DEMUXER_CTRL_IDENTIFY_PROGRAM, &prog) ==
|
|
DEMUXER_CTRL_NOTIMPL)
|
|
return M_PROPERTY_ERROR;
|
|
|
|
if (prog.aid < 0 && prog.vid < 0) {
|
|
MP_ERR(mpctx, "Selected program contains no audio or video streams!\n");
|
|
return M_PROPERTY_ERROR;
|
|
}
|
|
mp_switch_track(mpctx, STREAM_VIDEO,
|
|
find_track_by_demuxer_id(mpctx, STREAM_VIDEO, prog.vid));
|
|
mp_switch_track(mpctx, STREAM_AUDIO,
|
|
find_track_by_demuxer_id(mpctx, STREAM_AUDIO, prog.aid));
|
|
mp_switch_track(mpctx, STREAM_SUB,
|
|
find_track_by_demuxer_id(mpctx, STREAM_VIDEO, prog.sid));
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_INT,
|
|
.flags = CONF_RANGE,
|
|
.min = -1,
|
|
.max = (1 << 16) - 1,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_hwdec(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct MPOpts *opts = mpctx->opts;
|
|
struct dec_video *vd = mpctx->d_video;
|
|
if (!vd)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int current = 0;
|
|
video_vd_control(vd, VDCTRL_GET_HWDEC, ¤t);
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(int *)arg = current;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET: {
|
|
int new = *(int *)arg;
|
|
if (current == new)
|
|
return M_PROPERTY_OK;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_ERROR;
|
|
double last_pts = mpctx->last_vo_pts;
|
|
uninit_video_chain(mpctx);
|
|
opts->hwdec_api = new;
|
|
reinit_video_chain(mpctx);
|
|
if (last_pts != MP_NOPTS_VALUE)
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, last_pts, 1, true);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
/// Fullscreen state (RW)
|
|
static int mp_property_fullscreen(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->video_out)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
struct mp_vo_opts *opts = mpctx->video_out->opts;
|
|
|
|
if (action == M_PROPERTY_SET) {
|
|
int val = *(int *)arg;
|
|
opts->fullscreen = val;
|
|
if (mpctx->video_out->config_ok)
|
|
vo_control(mpctx->video_out, VOCTRL_FULLSCREEN, 0);
|
|
return opts->fullscreen == val ? M_PROPERTY_OK : M_PROPERTY_ERROR;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
#define VF_DEINTERLACE_LABEL "deinterlace"
|
|
|
|
static bool probe_deint_filter(struct MPContext *mpctx, const char *filt)
|
|
{
|
|
char filter[80];
|
|
// add a label so that removing the filter is easier
|
|
snprintf(filter, sizeof(filter), "@%s:%s", VF_DEINTERLACE_LABEL, filt);
|
|
return edit_filters(mpctx, STREAM_VIDEO, "pre", filter) >= 0;
|
|
}
|
|
|
|
static bool check_output_format(struct MPContext *mpctx, int imgfmt)
|
|
{
|
|
struct dec_video *vd = mpctx->d_video;
|
|
if (!vd)
|
|
return false;
|
|
return vd->vfilter->allowed_output_formats[imgfmt - IMGFMT_START];
|
|
}
|
|
|
|
static int probe_deint_filters(struct MPContext *mpctx)
|
|
{
|
|
if (check_output_format(mpctx, IMGFMT_VDPAU)) {
|
|
char filter[80] = "vdpaupp:deint=yes";
|
|
int pref = 0;
|
|
vo_control(mpctx->video_out, VOCTRL_GET_PREF_DEINT, &pref);
|
|
pref = pref < 0 ? -pref : pref;
|
|
if (pref > 0 && pref <= 4) {
|
|
const char *types[] =
|
|
{"", "first-field", "bob", "temporal", "temporal-spatial"};
|
|
mp_snprintf_cat(filter, sizeof(filter), ":deint-mode=%s",
|
|
types[pref]);
|
|
}
|
|
|
|
probe_deint_filter(mpctx, filter);
|
|
return 0;
|
|
}
|
|
if (check_output_format(mpctx, IMGFMT_VAAPI) &&
|
|
probe_deint_filter(mpctx, "vavpp"))
|
|
return 0;
|
|
if (probe_deint_filter(mpctx, "yadif"))
|
|
return 0;
|
|
return -1;
|
|
}
|
|
|
|
static int get_deinterlacing(struct MPContext *mpctx)
|
|
{
|
|
struct dec_video *vd = mpctx->d_video;
|
|
int enabled = 0;
|
|
if (video_vf_vo_control(vd, VFCTRL_GET_DEINTERLACE, &enabled) != CONTROL_OK)
|
|
enabled = -1;
|
|
if (enabled < 0) {
|
|
// vf_lavfi doesn't support VFCTRL_GET_DEINTERLACE
|
|
if (vf_find_by_label(vd->vfilter, VF_DEINTERLACE_LABEL))
|
|
enabled = 1;
|
|
}
|
|
return enabled;
|
|
}
|
|
|
|
static void set_deinterlacing(struct MPContext *mpctx, bool enable)
|
|
{
|
|
struct dec_video *vd = mpctx->d_video;
|
|
if (vf_find_by_label(vd->vfilter, VF_DEINTERLACE_LABEL)) {
|
|
if (!enable)
|
|
edit_filters(mpctx, STREAM_VIDEO, "del", "@" VF_DEINTERLACE_LABEL);
|
|
} else {
|
|
if ((get_deinterlacing(mpctx) > 0) != enable) {
|
|
int arg = enable;
|
|
if (video_vf_vo_control(vd, VFCTRL_SET_DEINTERLACE, &arg) != CONTROL_OK)
|
|
probe_deint_filters(mpctx);
|
|
}
|
|
}
|
|
mpctx->opts->deinterlace = get_deinterlacing(mpctx) > 0;
|
|
}
|
|
|
|
static int mp_property_deinterlace(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video || !mpctx->d_video->vfilter)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
switch (action) {
|
|
case M_PROPERTY_GET:
|
|
*(int *)arg = get_deinterlacing(mpctx) > 0;
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_FLAG};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET:
|
|
set_deinterlacing(mpctx, *(int *)arg);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
// Generic option + requires hard refresh to make changes take effect.
|
|
static int video_refresh_property_helper(struct m_property *prop, int action,
|
|
void *arg, MPContext *mpctx)
|
|
{
|
|
int r = mp_property_generic_option(mpctx, prop, action, arg);
|
|
if (action == M_PROPERTY_SET) {
|
|
if (mpctx->d_video) {
|
|
reinit_video_filters(mpctx);
|
|
mp_force_video_refresh(mpctx);
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static int video_simple_refresh_property(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
int r = mp_property_generic_option(mpctx, prop, action, arg);
|
|
if (action == M_PROPERTY_SET && r == M_PROPERTY_OK)
|
|
mp_force_video_refresh(mpctx);
|
|
return r;
|
|
}
|
|
|
|
static void append_csp(char **ptr, const char *name, const char *const *names,
|
|
int value)
|
|
{
|
|
const char *cspname = names[value];
|
|
if (name[0] == '*') {
|
|
name++;
|
|
} else if (value == 0) {
|
|
cspname = "unknown";
|
|
}
|
|
*ptr = talloc_asprintf_append(*ptr, "%s: %s\n", name, cspname);
|
|
}
|
|
|
|
static int mp_property_colormatrix(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (action != M_PROPERTY_PRINT)
|
|
return video_refresh_property_helper(prop, action, arg, mpctx);
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
struct mp_image_params vo_csp = {0};
|
|
if (mpctx->video_out)
|
|
vo_control(mpctx->video_out, VOCTRL_GET_COLORSPACE, &vo_csp);
|
|
|
|
struct mp_image_params vd_csp = {0};
|
|
if (mpctx->d_video)
|
|
vd_csp = mpctx->d_video->decoder_output;
|
|
|
|
char *res = talloc_strdup(NULL, "");
|
|
append_csp(&res, "*Requested", mp_csp_names, opts->requested_colorspace);
|
|
append_csp(&res, "Video decoder", mp_csp_names, vd_csp.colorspace);
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
|
|
static int mp_property_colormatrix_input_range(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (action != M_PROPERTY_PRINT)
|
|
return video_refresh_property_helper(prop, action, arg, mpctx);
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
struct mp_image_params vo_csp = {0};
|
|
if (mpctx->video_out)
|
|
vo_control(mpctx->video_out, VOCTRL_GET_COLORSPACE, &vo_csp);
|
|
|
|
struct mp_image_params vd_csp = {0};
|
|
if (mpctx->d_video)
|
|
vd_csp = mpctx->d_video->decoder_output;
|
|
|
|
char *res = talloc_strdup(NULL, "");
|
|
append_csp(&res, "*Requested", mp_csp_levels_names,
|
|
opts->requested_input_range);
|
|
append_csp(&res, "Video decoder", mp_csp_levels_names, vd_csp.colorlevels);
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
|
|
static int mp_property_colormatrix_output_range(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (action != M_PROPERTY_PRINT)
|
|
return video_refresh_property_helper(prop, action, arg, mpctx);
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
struct mp_image_params actual = {0};
|
|
if (mpctx->video_out)
|
|
vo_control(mpctx->video_out, VOCTRL_GET_COLORSPACE, &actual);
|
|
|
|
char *res = talloc_strdup(NULL, "");
|
|
append_csp(&res, "*Requested", mp_csp_levels_names,
|
|
opts->requested_output_range);
|
|
append_csp(&res, "Video output", mp_csp_levels_names, actual.outputlevels);
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
|
|
static int mp_property_primaries(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (action != M_PROPERTY_PRINT)
|
|
return video_refresh_property_helper(prop, action, arg, mpctx);
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
struct mp_image_params vo_csp = {0};
|
|
if (mpctx->video_out)
|
|
vo_control(mpctx->video_out, VOCTRL_GET_COLORSPACE, &vo_csp);
|
|
|
|
struct mp_image_params vd_csp = {0};
|
|
if (mpctx->d_video)
|
|
vd_csp = mpctx->d_video->decoder_output;
|
|
|
|
char *res = talloc_strdup(NULL, "");
|
|
append_csp(&res, "*Requested", mp_csp_prim_names, opts->requested_primaries);
|
|
append_csp(&res, "Video decoder", mp_csp_prim_names, vd_csp.primaries);
|
|
append_csp(&res, "Video output", mp_csp_prim_names, vo_csp.primaries);
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
|
|
// Update options which are managed through VOCTRL_GET/SET_PANSCAN.
|
|
static int panscan_property_helper(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->video_out
|
|
|| vo_control(mpctx->video_out, VOCTRL_GET_PANSCAN, NULL) != VO_TRUE)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int r = mp_property_generic_option(mpctx, prop, action, arg);
|
|
if (action == M_PROPERTY_SET)
|
|
vo_control(mpctx->video_out, VOCTRL_SET_PANSCAN, NULL);
|
|
return r;
|
|
}
|
|
|
|
/// Helper to set vo flags.
|
|
/** \ingroup PropertyImplHelper
|
|
*/
|
|
static int mp_property_vo_flag(struct m_property *prop, int action, void *arg,
|
|
int vo_ctrl, int *vo_var, MPContext *mpctx)
|
|
{
|
|
if (!mpctx->video_out)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
if (action == M_PROPERTY_SET) {
|
|
if (*vo_var == !!*(int *) arg)
|
|
return M_PROPERTY_OK;
|
|
if (mpctx->video_out->config_ok)
|
|
vo_control(mpctx->video_out, vo_ctrl, 0);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
/// Window always on top (RW)
|
|
static int mp_property_ontop(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
return mp_property_vo_flag(prop, action, arg, VOCTRL_ONTOP,
|
|
&mpctx->opts->vo.ontop, mpctx);
|
|
}
|
|
|
|
/// Show window borders (RW)
|
|
static int mp_property_border(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
return mp_property_vo_flag(prop, action, arg, VOCTRL_BORDER,
|
|
&mpctx->opts->vo.border, mpctx);
|
|
}
|
|
|
|
static int get_frame_count(struct MPContext *mpctx)
|
|
{
|
|
struct demuxer *demuxer = mpctx->demuxer;
|
|
if (!demuxer)
|
|
return 0;
|
|
if (!mpctx->d_video)
|
|
return 0;
|
|
double len = get_time_length(mpctx);
|
|
double fps = mpctx->d_video->fps;
|
|
if (len < 0 || fps <= 0)
|
|
return 0;
|
|
|
|
return len * fps;
|
|
}
|
|
|
|
static int mp_property_frame_number(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int frame_number = ROUND(get_current_pos_ratio(mpctx, false) *
|
|
(double)get_frame_count(mpctx));
|
|
return m_property_int_ro(action, arg, frame_number);
|
|
}
|
|
|
|
static int mp_property_frame_count(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return m_property_int_ro(action, arg, get_frame_count(mpctx));
|
|
}
|
|
|
|
static int mp_property_framedrop(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
static int mp_property_video_color(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_SET: {
|
|
if (video_set_colors(mpctx->d_video, prop->name, *(int *) arg) <= 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
break;
|
|
}
|
|
case M_PROPERTY_GET:
|
|
if (video_get_colors(mpctx->d_video, prop->name, (int *)arg) <= 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
// Write new value to option variable
|
|
mp_property_generic_option(mpctx, prop, M_PROPERTY_SET, arg);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET_NEUTRAL:
|
|
*(int *)arg = 0;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
/// Video codec tag (RO)
|
|
static int mp_property_video_format(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
const char *c = mpctx->d_video ? mpctx->d_video->header->codec : NULL;
|
|
return m_property_strdup_ro(action, arg, c);
|
|
}
|
|
|
|
/// Video codec name (RO)
|
|
static int mp_property_video_codec(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
const char *c = mpctx->d_video ? mpctx->d_video->decoder_desc : NULL;
|
|
return m_property_strdup_ro(action, arg, c);
|
|
}
|
|
|
|
|
|
/// Video bitrate (RO)
|
|
static int mp_property_video_bitrate(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (action == M_PROPERTY_PRINT) {
|
|
*(char **)arg = format_bitrate(mpctx->d_video->bitrate);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_int_ro(action, arg, mpctx->d_video->bitrate);
|
|
}
|
|
|
|
static int property_imgparams(struct mp_image_params p, int action, void *arg)
|
|
{
|
|
if (!p.imgfmt)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
double dar = p.d_w / (double)p.d_h;
|
|
double sar = p.w / (double)p.h;
|
|
|
|
struct m_sub_property props[] = {
|
|
{"pixelformat", SUB_PROP_STR(mp_imgfmt_to_name(p.imgfmt))},
|
|
{"w", SUB_PROP_INT(p.w)},
|
|
{"h", SUB_PROP_INT(p.h)},
|
|
{"dw", SUB_PROP_INT(p.d_w)},
|
|
{"dh", SUB_PROP_INT(p.d_h)},
|
|
{"aspect", SUB_PROP_FLOAT(dar)},
|
|
{"par", SUB_PROP_FLOAT(dar / sar)},
|
|
{"colormatrix", SUB_PROP_STR(mp_csp_names[p.colorspace])},
|
|
{"colorlevels", SUB_PROP_STR(mp_csp_levels_names[p.colorlevels])},
|
|
{"primaries", SUB_PROP_STR(mp_csp_prim_names[p.primaries])},
|
|
{"chroma-location", SUB_PROP_STR(mp_chroma_names[p.chroma_location])},
|
|
{"rotate", SUB_PROP_INT(p.rotate)},
|
|
{0}
|
|
};
|
|
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
|
|
static struct mp_image_params get_video_out_params(struct MPContext *mpctx)
|
|
{
|
|
if (!mpctx->d_video || !mpctx->d_video->vfilter ||
|
|
mpctx->d_video->vfilter->initialized < 1)
|
|
return (struct mp_image_params){0};
|
|
|
|
return mpctx->d_video->vfilter->output_params;
|
|
}
|
|
|
|
static int mp_property_vo_imgparams(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return property_imgparams(get_video_out_params(ctx), action, arg);
|
|
}
|
|
|
|
static int mp_property_vd_imgparams(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct dec_video *vd = mpctx->d_video;
|
|
if (!vd)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
struct sh_video *sh = vd->header->video;
|
|
if (vd->vfilter->override_params.imgfmt) {
|
|
return property_imgparams(vd->vfilter->override_params, action, arg);
|
|
} else if (sh->disp_w && sh->disp_h) {
|
|
// Simplistic fallback for stupid scripts querying "width"/"height"
|
|
// before the first frame is decoded.
|
|
struct m_sub_property props[] = {
|
|
{"w", SUB_PROP_INT(sh->disp_w)},
|
|
{"h", SUB_PROP_INT(sh->disp_h)},
|
|
{0}
|
|
};
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
}
|
|
|
|
static int mp_property_window_scale(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct vo *vo = mpctx->video_out;
|
|
if (!vo)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
struct mp_image_params params = get_video_out_params(mpctx);
|
|
int vid_w = params.d_w;
|
|
int vid_h = params.d_h;
|
|
if (vid_w < 1 || vid_h < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_SET: {
|
|
double scale = *(double *)arg;
|
|
int s[2] = {vid_w * scale, vid_h * scale};
|
|
if (s[0] > 0 && s[1] > 0 &&
|
|
vo_control(vo, VOCTRL_SET_UNFS_WINDOW_SIZE, s) > 0)
|
|
return M_PROPERTY_OK;
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
}
|
|
case M_PROPERTY_GET: {
|
|
int s[2];
|
|
if (vo_control(vo, VOCTRL_GET_UNFS_WINDOW_SIZE, s) <= 0 ||
|
|
s[0] < 1 || s[1] < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
double xs = (double)s[0] / vid_w;
|
|
double ys = (double)s[1] / vid_h;
|
|
*(double *)arg = (xs + ys) / 2;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_DOUBLE,
|
|
.flags = CONF_RANGE,
|
|
.min = 0.125,
|
|
.max = 8,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_win_minimized(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct vo *vo = mpctx->video_out;
|
|
if (!vo)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
int state = 0;
|
|
if (vo_control(vo, VOCTRL_GET_WIN_STATE, &state) < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
return m_property_flag_ro(action, arg, state & VO_WIN_STATE_MINIMIZED);
|
|
}
|
|
|
|
static int mp_property_display_names(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct vo *vo = mpctx->video_out;
|
|
if (!vo)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET: {
|
|
char** display_names;
|
|
if (vo_control(vo, VOCTRL_GET_DISPLAY_NAMES, &display_names) < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
*(char ***)arg = display_names;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_vo_configured(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
return m_property_flag_ro(action, arg,
|
|
mpctx->video_out && mpctx->video_out->config_ok);
|
|
}
|
|
|
|
static int mp_property_osd_w(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct mp_osd_res vo_res = osd_get_vo_res(mpctx->osd, OSDTYPE_OSD);
|
|
return m_property_int_ro(action, arg, vo_res.w);
|
|
}
|
|
|
|
static int mp_property_osd_h(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct mp_osd_res vo_res = osd_get_vo_res(mpctx->osd, OSDTYPE_OSD);
|
|
return m_property_int_ro(action, arg, vo_res.h);
|
|
}
|
|
|
|
static int mp_property_osd_par(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct mp_osd_res vo_res = osd_get_vo_res(mpctx->osd, OSDTYPE_OSD);
|
|
return m_property_double_ro(action, arg, vo_res.display_par);
|
|
}
|
|
|
|
static int mp_property_osd_sym(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
char temp[20];
|
|
get_current_osd_sym(mpctx, temp, sizeof(temp));
|
|
return m_property_strdup_ro(action, arg, temp);
|
|
}
|
|
|
|
static int mp_property_osd_ass(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
struct m_sub_property props[] = {
|
|
{"0", SUB_PROP_STR(osd_ass_0)},
|
|
{"1", SUB_PROP_STR(osd_ass_1)},
|
|
{0}
|
|
};
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
|
|
/// Video fps (RO)
|
|
static int mp_property_fps(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
float fps = mpctx->d_video ? mpctx->d_video->fps : 0;
|
|
if (fps < 0.1 || !isfinite(fps))
|
|
return M_PROPERTY_UNAVAILABLE;;
|
|
return m_property_float_ro(action, arg, fps);
|
|
}
|
|
|
|
static int mp_property_vf_fps(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
double next_pts = mpctx->vo_pts_history_pts[0];
|
|
if (mpctx->vo_pts_history_seek[0] != mpctx->vo_pts_history_seek_ts)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (next_pts == MP_NOPTS_VALUE)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
int num_samples = 10;
|
|
assert(num_samples + 1 <= MAX_NUM_VO_PTS);
|
|
double duration = 0;
|
|
for (int n = 1; n < 1 + num_samples; n++) {
|
|
double frame_pts = mpctx->vo_pts_history_pts[n];
|
|
// Discontinuity -> refuse to return a value.
|
|
if (mpctx->vo_pts_history_seek[n] != mpctx->vo_pts_history_seek_ts)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (frame_pts == MP_NOPTS_VALUE)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
duration += next_pts - frame_pts;
|
|
next_pts = frame_pts;
|
|
}
|
|
return m_property_double_ro(action, arg, num_samples / duration);
|
|
}
|
|
|
|
/// Video aspect (RO)
|
|
static int mp_property_aspect(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (!mpctx->d_video)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
struct dec_video *d_video = mpctx->d_video;
|
|
struct sh_video *sh_video = d_video->header->video;
|
|
switch (action) {
|
|
case M_PROPERTY_SET: {
|
|
mpctx->opts->movie_aspect = *(float *)arg;
|
|
reinit_video_filters(mpctx);
|
|
mp_force_video_refresh(mpctx);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET: {
|
|
float aspect = -1;
|
|
struct mp_image_params *params = &d_video->vfilter->override_params;
|
|
if (params && params->d_w && params->d_h) {
|
|
aspect = (float)params->d_w / params->d_h;
|
|
} else if (sh_video->disp_w && sh_video->disp_h) {
|
|
aspect = (float)sh_video->disp_w / sh_video->disp_h;
|
|
}
|
|
if (aspect <= 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
*(float *)arg = aspect;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_FLOAT,
|
|
.flags = CONF_RANGE,
|
|
.min = -1,
|
|
.max = 10,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
// For OSD and subtitle related properties using the generic option bridge.
|
|
// - Fail as unavailable if no video is active
|
|
// - Trigger OSD state update when property is set
|
|
static int property_osd_helper(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (action == M_PROPERTY_SET)
|
|
osd_changed_all(mpctx->osd);
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
/// Selected subtitles (RW)
|
|
static int mp_property_sub(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return property_switch_track(prop, action, arg, ctx, 0, STREAM_SUB);
|
|
}
|
|
|
|
static int mp_property_sub2(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return property_switch_track(prop, action, arg, ctx, 1, STREAM_SUB);
|
|
}
|
|
|
|
/// Subtitle delay (RW)
|
|
static int mp_property_sub_delay(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct MPOpts *opts = mpctx->opts;
|
|
if (!mpctx->video_out)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
switch (action) {
|
|
case M_PROPERTY_PRINT:
|
|
*(char **)arg = format_delay(opts->sub_delay);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return property_osd_helper(mpctx, prop, action, arg);
|
|
}
|
|
|
|
static int mp_property_sub_pos(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct MPOpts *opts = mpctx->opts;
|
|
if (!mpctx->video_out)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
if (action == M_PROPERTY_PRINT) {
|
|
*(char **)arg = talloc_asprintf(NULL, "%d/100", opts->sub_pos);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return property_osd_helper(mpctx, prop, action, arg);
|
|
}
|
|
|
|
static int mp_property_cursor_autohide(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct MPOpts *opts = mpctx->opts;
|
|
int old_value = opts->cursor_autohide_delay;
|
|
int r = mp_property_generic_option(mpctx, prop, action, arg);
|
|
if (opts->cursor_autohide_delay != old_value)
|
|
mpctx->mouse_timer = 0;
|
|
return r;
|
|
}
|
|
|
|
static int prop_stream_ctrl(struct MPContext *mpctx, int ctrl, void *arg)
|
|
{
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
int r = demux_stream_control(mpctx->demuxer, ctrl, arg);
|
|
switch (r) {
|
|
case STREAM_OK: return M_PROPERTY_OK;
|
|
case STREAM_UNSUPPORTED: return M_PROPERTY_UNAVAILABLE;
|
|
default: return M_PROPERTY_ERROR;
|
|
}
|
|
}
|
|
|
|
static int mp_property_tv_norm(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_SET:
|
|
return prop_stream_ctrl(ctx, STREAM_CTRL_TV_SET_NORM, *(char **)arg);
|
|
case M_PROPERTY_SWITCH:
|
|
return prop_stream_ctrl(ctx, STREAM_CTRL_TV_STEP_NORM, NULL);
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_tv_scan(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_SET:
|
|
return prop_stream_ctrl(ctx, STREAM_CTRL_TV_SET_SCAN, arg);
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_FLAG};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/// TV color settings (RW)
|
|
static int mp_property_tv_color(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
int req[2] = {(intptr_t)prop->priv};
|
|
switch (action) {
|
|
case M_PROPERTY_SET:
|
|
req[1] = *(int *)arg;
|
|
return prop_stream_ctrl(ctx, STREAM_CTRL_SET_TV_COLORS, req);
|
|
case M_PROPERTY_GET: {
|
|
int r = prop_stream_ctrl(ctx, STREAM_CTRL_GET_TV_COLORS, req);
|
|
if (r == M_PROPERTY_OK)
|
|
*(int *)arg = req[1];
|
|
return r;
|
|
}
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){
|
|
.type = CONF_TYPE_INT,
|
|
.flags = M_OPT_RANGE,
|
|
.min = -100,
|
|
.max = 100,
|
|
};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_tv_freq(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_SET:
|
|
return prop_stream_ctrl(ctx, STREAM_CTRL_SET_TV_FREQ, arg);
|
|
case M_PROPERTY_GET:
|
|
return prop_stream_ctrl(ctx, STREAM_CTRL_GET_TV_FREQ, arg);
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_FLOAT};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_tv_channel(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET:
|
|
return prop_stream_ctrl(ctx, STREAM_CTRL_TV_SET_CHAN, *(char **)arg);
|
|
case M_PROPERTY_SWITCH: {
|
|
struct m_property_switch_arg *sa = arg;
|
|
int dir = sa->inc >= 0 ? 1 : -1;
|
|
return prop_stream_ctrl(ctx, STREAM_CTRL_TV_STEP_CHAN, &dir);
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_dvb_channel(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
int r;
|
|
switch (action) {
|
|
case M_PROPERTY_SET:
|
|
mpctx->last_dvb_step = 1;
|
|
r = prop_stream_ctrl(mpctx, STREAM_CTRL_DVB_SET_CHANNEL, arg);
|
|
if (r == M_PROPERTY_OK)
|
|
mpctx->stop_play = PT_RELOAD_DEMUXER;
|
|
return r;
|
|
case M_PROPERTY_SWITCH: {
|
|
struct m_property_switch_arg *sa = arg;
|
|
int dir = sa->inc >= 0 ? 1 : -1;
|
|
mpctx->last_dvb_step = dir;
|
|
r = prop_stream_ctrl(mpctx, STREAM_CTRL_DVB_STEP_CHANNEL, &dir);
|
|
if (r == M_PROPERTY_OK)
|
|
mpctx->stop_play = PT_RELOAD_DEMUXER;
|
|
return r;
|
|
}
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = &m_option_type_intpair};
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int mp_property_playlist_pos(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
struct playlist *pl = mpctx->playlist;
|
|
if (!pl->first)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (action) {
|
|
case M_PROPERTY_GET: {
|
|
int pos = playlist_entry_to_index(pl, pl->current);
|
|
if (pos < 0)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
*(int *)arg = pos;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_SET: {
|
|
struct playlist_entry *e = playlist_entry_from_index(pl, *(int *)arg);
|
|
if (!e)
|
|
return M_PROPERTY_ERROR;
|
|
mp_set_playlist_entry(mpctx, e);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET_TYPE: {
|
|
struct m_option opt = {
|
|
.type = CONF_TYPE_INT,
|
|
.flags = CONF_RANGE,
|
|
.min = 0,
|
|
.max = playlist_entry_count(pl) - 1,
|
|
};
|
|
*(struct m_option *)arg = opt;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int get_playlist_entry(int item, int action, void *arg, void *ctx)
|
|
{
|
|
struct MPContext *mpctx = ctx;
|
|
struct playlist_entry *e = playlist_entry_from_index(mpctx->playlist, item);
|
|
if (!e)
|
|
return M_PROPERTY_ERROR;
|
|
|
|
bool current = mpctx->playlist->current == e;
|
|
bool playing = mpctx->playing == e;
|
|
struct m_sub_property props[] = {
|
|
{"filename", SUB_PROP_STR(e->filename)},
|
|
{"current", SUB_PROP_FLAG(1), .unavailable = !current},
|
|
{"playing", SUB_PROP_FLAG(1), .unavailable = !playing},
|
|
{0}
|
|
};
|
|
|
|
return m_property_read_sub(props, action, arg);
|
|
}
|
|
|
|
static int mp_property_playlist(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
if (action == M_PROPERTY_PRINT) {
|
|
char *res = talloc_strdup(NULL, "");
|
|
|
|
for (struct playlist_entry *e = mpctx->playlist->first; e; e = e->next)
|
|
{
|
|
char *p = e->filename;
|
|
if (!mp_is_url(bstr0(p))) {
|
|
char *s = mp_basename(e->filename);
|
|
if (s[0])
|
|
p = s;
|
|
}
|
|
if (mpctx->playlist->current == e) {
|
|
res = talloc_asprintf_append(res, "> %s <\n", p);
|
|
} else {
|
|
res = talloc_asprintf_append(res, "%s\n", p);
|
|
}
|
|
}
|
|
|
|
*(char **)arg = res;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return m_property_read_list(action, arg, playlist_entry_count(mpctx->playlist),
|
|
get_playlist_entry, mpctx);
|
|
}
|
|
|
|
static char *print_obj_osd_list(struct m_obj_settings *list)
|
|
{
|
|
char *res = NULL;
|
|
for (int n = 0; list && list[n].name; n++) {
|
|
res = talloc_asprintf_append(res, "%s [", list[n].name);
|
|
for (int i = 0; list[n].attribs && list[n].attribs[i]; i += 2) {
|
|
res = talloc_asprintf_append(res, "%s%s=%s", i > 0 ? " " : "",
|
|
list[n].attribs[i],
|
|
list[n].attribs[i + 1]);
|
|
}
|
|
res = talloc_asprintf_append(res, "]\n");
|
|
}
|
|
if (!res)
|
|
res = talloc_strdup(NULL, "(empty)");
|
|
return res;
|
|
}
|
|
|
|
static int property_filter(struct m_property *prop, int action, void *arg,
|
|
MPContext *mpctx, enum stream_type mt)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_PRINT: {
|
|
struct m_config_option *opt = m_config_get_co(mpctx->mconfig,
|
|
bstr0(prop->name));
|
|
*(char **)arg = print_obj_osd_list(*(struct m_obj_settings **)opt->data);
|
|
return M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_SET:
|
|
return set_filters(mpctx, mt, *(struct m_obj_settings **)arg) >= 0
|
|
? M_PROPERTY_OK : M_PROPERTY_ERROR;
|
|
}
|
|
return mp_property_generic_option(mpctx, prop, action, arg);
|
|
}
|
|
|
|
static int mp_property_vf(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return property_filter(prop, action, arg, ctx, STREAM_VIDEO);
|
|
}
|
|
|
|
static int mp_property_af(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return property_filter(prop, action, arg, ctx, STREAM_AUDIO);
|
|
}
|
|
|
|
static int mp_property_ab_loop(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
struct MPContext *mpctx = ctx;
|
|
struct MPOpts *opts = mpctx->opts;
|
|
if (action == M_PROPERTY_KEY_ACTION) {
|
|
double val;
|
|
if (mp_property_generic_option(mpctx, prop, M_PROPERTY_GET, &val) < 1)
|
|
return M_PROPERTY_ERROR;
|
|
|
|
return property_time(action, arg, val);
|
|
}
|
|
int r = mp_property_generic_option(mpctx, prop, action, arg);
|
|
if (r > 0 && action == M_PROPERTY_SET) {
|
|
if (strcmp(prop->name, "ab-loop-b") == 0) {
|
|
double now = mpctx->playback_pts;
|
|
if (now != MP_NOPTS_VALUE && opts->ab_loop[0] != MP_NOPTS_VALUE &&
|
|
opts->ab_loop[1] != MP_NOPTS_VALUE && now >= opts->ab_loop[1])
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, opts->ab_loop[0], 1, false);
|
|
}
|
|
// Update if visible
|
|
set_osd_bar_chapters(mpctx, OSD_BAR_SEEK);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static int mp_property_packet_bitrate(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
int type = (intptr_t)prop->priv;
|
|
|
|
if (!mpctx->demuxer)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
double r[STREAM_TYPE_COUNT];
|
|
if (demux_control(mpctx->demuxer, DEMUXER_CTRL_GET_BITRATE_STATS, &r) < 1)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
// r[type] is in bytes/second -> kilobits
|
|
return m_property_int64_ro(action, arg, r[type] * 8 / 1000.0 + 0.5);
|
|
}
|
|
|
|
static int mp_property_version(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return m_property_strdup_ro(action, arg, mpv_version);
|
|
}
|
|
|
|
static int mp_property_configuration(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
return m_property_strdup_ro(action, arg, CONFIGURATION);
|
|
}
|
|
|
|
static int mp_property_alias(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
const char *real_property = prop->priv;
|
|
return mp_property_do(real_property, action, arg, ctx);
|
|
}
|
|
|
|
static int access_options(struct m_property_action_arg *ka, bool local,
|
|
MPContext *mpctx)
|
|
{
|
|
struct m_config_option *opt = m_config_get_co(mpctx->mconfig,
|
|
bstr0(ka->key));
|
|
if (!opt)
|
|
return M_PROPERTY_UNKNOWN;
|
|
if (!opt->data)
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
switch (ka->action) {
|
|
case M_PROPERTY_GET:
|
|
m_option_copy(opt->opt, ka->arg, opt->data);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_SET: {
|
|
if (local && !mpctx->playing)
|
|
return M_PROPERTY_ERROR;
|
|
int flags = M_SETOPT_RUNTIME | (local ? M_SETOPT_BACKUP : 0);
|
|
int r = m_config_set_option_raw(mpctx->mconfig, opt, ka->arg, flags);
|
|
return r < 0 ? M_PROPERTY_ERROR : M_PROPERTY_OK;
|
|
}
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)ka->arg = *opt->opt;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int access_option_list(int action, void *arg, bool local, MPContext *mpctx)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET:
|
|
*(char ***)arg = m_config_list_options(NULL, mpctx->mconfig);
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_KEY_ACTION:
|
|
return access_options(arg, local, mpctx);
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
|
|
static int mp_property_options(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
return access_option_list(action, arg, false, mpctx);
|
|
}
|
|
|
|
static int mp_property_local_options(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
return access_option_list(action, arg, true, mpctx);
|
|
}
|
|
|
|
static int mp_property_option_info(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
MPContext *mpctx = ctx;
|
|
switch (action) {
|
|
case M_PROPERTY_KEY_ACTION: {
|
|
struct m_property_action_arg *ka = arg;
|
|
bstr key;
|
|
char *rem;
|
|
m_property_split_path(ka->key, &key, &rem);
|
|
struct m_config_option *co = m_config_get_co(mpctx->mconfig, key);
|
|
if (!co)
|
|
return M_PROPERTY_UNKNOWN;
|
|
|
|
union m_option_value def = {0};
|
|
if (co->default_data)
|
|
memcpy(&def, co->default_data, co->opt->type->size);
|
|
|
|
const struct m_option *opt = co->opt;
|
|
bool has_minmax =
|
|
opt->type == &m_option_type_int ||
|
|
opt->type == &m_option_type_int64 ||
|
|
opt->type == &m_option_type_float ||
|
|
opt->type == &m_option_type_double;
|
|
char **choices = NULL;
|
|
|
|
if (opt->type == &m_option_type_choice) {
|
|
has_minmax = true;
|
|
struct m_opt_choice_alternatives *alt = opt->priv;
|
|
int num = 0;
|
|
for ( ; alt->name; alt++)
|
|
MP_TARRAY_APPEND(NULL, choices, num, alt->name);
|
|
MP_TARRAY_APPEND(NULL, choices, num, NULL);
|
|
}
|
|
if (opt->type == &m_option_type_obj_settings_list) {
|
|
struct m_obj_list *objs = opt->priv;
|
|
int num = 0;
|
|
for (int n = 0; ; n++) {
|
|
struct m_obj_desc desc = {0};
|
|
if (!objs->get_desc(&desc, n))
|
|
break;
|
|
MP_TARRAY_APPEND(NULL, choices, num, (char *)desc.name);
|
|
}
|
|
MP_TARRAY_APPEND(NULL, choices, num, NULL);
|
|
}
|
|
|
|
struct m_sub_property props[] = {
|
|
{"name", SUB_PROP_STR(co->name)},
|
|
{"type", SUB_PROP_STR(opt->type->name)},
|
|
{"set-from-commandline", SUB_PROP_FLAG(co->is_set_from_cmdline)},
|
|
{"default-value", *opt, def},
|
|
{"min", SUB_PROP_DOUBLE(opt->min),
|
|
.unavailable = !(has_minmax && (opt->flags & M_OPT_MIN))},
|
|
{"max", SUB_PROP_DOUBLE(opt->max),
|
|
.unavailable = !(has_minmax && (opt->flags & M_OPT_MAX))},
|
|
{"choices", .type = {.type = CONF_TYPE_STRING_LIST},
|
|
.value = {.string_list = choices}, .unavailable = !choices},
|
|
{0}
|
|
};
|
|
|
|
struct m_property_action_arg next_ka = *ka;
|
|
next_ka.key = rem;
|
|
int r = m_property_read_sub(props, M_PROPERTY_KEY_ACTION, &next_ka);
|
|
talloc_free(choices);
|
|
return r;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static const struct m_property mp_properties[];
|
|
|
|
static int mp_property_list(void *ctx, struct m_property *prop,
|
|
int action, void *arg)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_GET_TYPE:
|
|
*(struct m_option *)arg = (struct m_option){.type = CONF_TYPE_STRING_LIST};
|
|
return M_PROPERTY_OK;
|
|
case M_PROPERTY_GET: {
|
|
char **list = NULL;
|
|
int num = 0;
|
|
for (int n = 0; mp_properties[n].name; n++) {
|
|
MP_TARRAY_APPEND(NULL, list, num,
|
|
talloc_strdup(NULL, mp_properties[n].name));
|
|
}
|
|
MP_TARRAY_APPEND(NULL, list, num, NULL);
|
|
*(char ***)arg = list;
|
|
return M_PROPERTY_OK;
|
|
}
|
|
}
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
// Redirect a property name to another
|
|
#define M_PROPERTY_ALIAS(name, real_property) \
|
|
{(name), mp_property_alias, .priv = (real_property)}
|
|
|
|
/// All properties available in MPlayer.
|
|
/** \ingroup Properties
|
|
*/
|
|
static const struct m_property mp_properties[] = {
|
|
// General
|
|
{"osd-level", mp_property_generic_option},
|
|
{"osd-scale", property_osd_helper},
|
|
{"loop", mp_property_generic_option},
|
|
{"loop-file", mp_property_generic_option},
|
|
{"speed", mp_property_playback_speed},
|
|
{"filename", mp_property_filename},
|
|
{"stream-open-filename", mp_property_stream_open_filename},
|
|
{"file-size", mp_property_file_size},
|
|
{"path", mp_property_path},
|
|
{"media-title", mp_property_media_title},
|
|
{"stream-path", mp_property_stream_path},
|
|
{"stream-capture", mp_property_stream_capture},
|
|
{"demuxer", mp_property_demuxer},
|
|
{"stream-pos", mp_property_stream_pos},
|
|
{"stream-end", mp_property_stream_end},
|
|
{"length", mp_property_length},
|
|
{"avsync", mp_property_avsync},
|
|
{"total-avsync-change", mp_property_total_avsync_change},
|
|
{"drop-frame-count", mp_property_drop_frame_cnt},
|
|
{"vo-drop-frame-count", mp_property_vo_drop_frame_count},
|
|
{"percent-pos", mp_property_percent_pos},
|
|
{"time-start", mp_property_time_start},
|
|
{"time-pos", mp_property_time_pos},
|
|
{"time-remaining", mp_property_remaining},
|
|
{"playtime-remaining", mp_property_playtime_remaining},
|
|
{"playback-time", mp_property_playback_time},
|
|
{"disc-title", mp_property_disc_title},
|
|
{"disc-menu-active", mp_property_disc_menu},
|
|
{"chapter", mp_property_chapter},
|
|
{"edition", mp_property_edition},
|
|
{"disc-titles", mp_property_disc_titles},
|
|
{"chapters", mp_property_chapters},
|
|
{"editions", mp_property_editions},
|
|
{"angle", mp_property_angle},
|
|
{"metadata", mp_property_metadata},
|
|
{"filtered-metadata", mp_property_filtered_metadata},
|
|
{"chapter-metadata", mp_property_chapter_metadata},
|
|
{"vf-metadata", mp_property_vf_metadata},
|
|
{"pause", mp_property_pause},
|
|
{"core-idle", mp_property_core_idle},
|
|
{"eof-reached", mp_property_eof_reached},
|
|
{"seeking", mp_property_seeking},
|
|
{"playback-abort", mp_property_playback_abort},
|
|
{"cache", mp_property_cache},
|
|
{"cache-free", mp_property_cache_free},
|
|
{"cache-used", mp_property_cache_used},
|
|
{"cache-size", mp_property_cache_size},
|
|
{"cache-idle", mp_property_cache_idle},
|
|
{"demuxer-cache-duration", mp_property_demuxer_cache_duration},
|
|
{"demuxer-cache-idle", mp_property_demuxer_cache_idle},
|
|
{"cache-buffering-state", mp_property_cache_buffering},
|
|
{"paused-for-cache", mp_property_paused_for_cache},
|
|
{"pts-association-mode", mp_property_generic_option},
|
|
{"hr-seek", mp_property_generic_option},
|
|
{"clock", mp_property_clock},
|
|
{"seekable", mp_property_seekable},
|
|
{"idle", mp_property_idle},
|
|
|
|
{"chapter-list", mp_property_list_chapters},
|
|
{"track-list", property_list_tracks},
|
|
{"edition-list", property_list_editions},
|
|
{"disc-title-list", mp_property_list_disc_titles},
|
|
|
|
{"playlist", mp_property_playlist},
|
|
{"playlist-pos", mp_property_playlist_pos},
|
|
M_PROPERTY_ALIAS("playlist-count", "playlist/count"),
|
|
|
|
// Audio
|
|
{"volume", mp_property_volume},
|
|
{"mute", mp_property_mute},
|
|
{"audio-delay", mp_property_audio_delay},
|
|
{"audio-format", mp_property_audio_format},
|
|
{"audio-codec", mp_property_audio_codec},
|
|
{"audio-bitrate", mp_property_audio_bitrate},
|
|
{"audio-samplerate", mp_property_samplerate},
|
|
{"audio-channels", mp_property_channels},
|
|
{"aid", mp_property_audio},
|
|
{"balance", mp_property_balance},
|
|
{"volume-restore-data", mp_property_volrestore},
|
|
{"audio-device", mp_property_audio_device},
|
|
{"audio-device-list", mp_property_audio_devices},
|
|
|
|
// Video
|
|
{"fullscreen", mp_property_fullscreen},
|
|
{"deinterlace", mp_property_deinterlace},
|
|
{"field-dominance", mp_property_generic_option},
|
|
{"colormatrix", mp_property_colormatrix},
|
|
{"colormatrix-input-range", mp_property_colormatrix_input_range},
|
|
{"colormatrix-output-range", mp_property_colormatrix_output_range},
|
|
{"colormatrix-primaries", mp_property_primaries},
|
|
{"ontop", mp_property_ontop},
|
|
{"border", mp_property_border},
|
|
{"framedrop", mp_property_framedrop},
|
|
{"gamma", mp_property_video_color},
|
|
{"brightness", mp_property_video_color},
|
|
{"contrast", mp_property_video_color},
|
|
{"saturation", mp_property_video_color},
|
|
{"hue", mp_property_video_color},
|
|
{"panscan", panscan_property_helper},
|
|
{"video-zoom", panscan_property_helper},
|
|
{"video-align-x", panscan_property_helper},
|
|
{"video-align-y", panscan_property_helper},
|
|
{"video-pan-x", panscan_property_helper},
|
|
{"video-pan-y", panscan_property_helper},
|
|
{"video-unscaled", panscan_property_helper},
|
|
{"video-out-params", mp_property_vo_imgparams},
|
|
{"video-params", mp_property_vd_imgparams},
|
|
{"video-format", mp_property_video_format},
|
|
{"video-codec", mp_property_video_codec},
|
|
{"video-bitrate", mp_property_video_bitrate},
|
|
M_PROPERTY_ALIAS("dwidth", "video-out-params/dw"),
|
|
M_PROPERTY_ALIAS("dheight", "video-out-params/dh"),
|
|
M_PROPERTY_ALIAS("width", "video-params/w"),
|
|
M_PROPERTY_ALIAS("height", "video-params/h"),
|
|
{"window-scale", mp_property_window_scale},
|
|
{"vo-configured", mp_property_vo_configured},
|
|
{"fps", mp_property_fps},
|
|
{"estimated-vf-fps", mp_property_vf_fps},
|
|
{"video-aspect", mp_property_aspect},
|
|
{"vid", mp_property_video},
|
|
{"program", mp_property_program},
|
|
{"hwdec", mp_property_hwdec},
|
|
|
|
{"estimated-frame-count", mp_property_frame_count},
|
|
{"estimated-frame-number", mp_property_frame_number},
|
|
|
|
{"osd-width", mp_property_osd_w},
|
|
{"osd-height", mp_property_osd_h},
|
|
{"osd-par", mp_property_osd_par},
|
|
|
|
{"osd-sym-cc", mp_property_osd_sym},
|
|
{"osd-ass-cc", mp_property_osd_ass},
|
|
|
|
// Subs
|
|
{"sid", mp_property_sub},
|
|
{"secondary-sid", mp_property_sub2},
|
|
{"sub-delay", mp_property_sub_delay},
|
|
{"sub-pos", mp_property_sub_pos},
|
|
{"sub-visibility", property_osd_helper},
|
|
{"sub-forced-only", property_osd_helper},
|
|
{"sub-scale", property_osd_helper},
|
|
{"ass-use-margins", property_osd_helper},
|
|
{"ass-vsfilter-aspect-compat", property_osd_helper},
|
|
{"ass-style-override", property_osd_helper},
|
|
|
|
{"vf", mp_property_vf},
|
|
{"af", mp_property_af},
|
|
|
|
{"video-rotate", video_simple_refresh_property},
|
|
|
|
{"ab-loop-a", mp_property_ab_loop},
|
|
{"ab-loop-b", mp_property_ab_loop},
|
|
|
|
#define PROPERTY_BITRATE(name, type) \
|
|
{name, mp_property_packet_bitrate, (void *)(intptr_t)type}
|
|
PROPERTY_BITRATE("packet-video-bitrate", STREAM_VIDEO),
|
|
PROPERTY_BITRATE("packet-audio-bitrate", STREAM_AUDIO),
|
|
PROPERTY_BITRATE("packet-sub-bitrate", STREAM_SUB),
|
|
|
|
#define PROPERTY_TV_COLOR(name, type) \
|
|
{name, mp_property_tv_color, (void *)(intptr_t)type}
|
|
PROPERTY_TV_COLOR("tv-brightness", TV_COLOR_BRIGHTNESS),
|
|
PROPERTY_TV_COLOR("tv-contrast", TV_COLOR_CONTRAST),
|
|
PROPERTY_TV_COLOR("tv-saturation", TV_COLOR_SATURATION),
|
|
PROPERTY_TV_COLOR("tv-hue", TV_COLOR_HUE),
|
|
{"tv-freq", mp_property_tv_freq},
|
|
{"tv-norm", mp_property_tv_norm},
|
|
{"tv-scan", mp_property_tv_scan},
|
|
{"tv-channel", mp_property_tv_channel},
|
|
{"dvb-channel", mp_property_dvb_channel},
|
|
|
|
{"cursor-autohide", mp_property_cursor_autohide},
|
|
|
|
#define TRACK_FF(name, type) \
|
|
{name, property_switch_track_ff, (void *)(intptr_t)type}
|
|
TRACK_FF("ff-vid", STREAM_VIDEO),
|
|
TRACK_FF("ff-aid", STREAM_AUDIO),
|
|
TRACK_FF("ff-sid", STREAM_SUB),
|
|
|
|
M_PROPERTY_ALIAS("video", "vid"),
|
|
M_PROPERTY_ALIAS("audio", "aid"),
|
|
M_PROPERTY_ALIAS("sub", "sid"),
|
|
|
|
{"window-minimized", mp_property_win_minimized},
|
|
{"display-names", mp_property_display_names},
|
|
|
|
{"mpv-version", mp_property_version},
|
|
{"mpv-configuration", mp_property_configuration},
|
|
|
|
{"options", mp_property_options},
|
|
{"file-local-options", mp_property_local_options},
|
|
{"option-info", mp_property_option_info},
|
|
{"property-list", mp_property_list},
|
|
|
|
{0},
|
|
};
|
|
|
|
// Each entry describes which properties an event (possibly) changes.
|
|
#define E(x, ...) [x] = (const char*const[]){__VA_ARGS__, NULL}
|
|
static const char *const *const mp_event_property_change[] = {
|
|
E(MPV_EVENT_START_FILE, "*"),
|
|
E(MPV_EVENT_END_FILE, "*"),
|
|
E(MPV_EVENT_FILE_LOADED, "*"),
|
|
E(MPV_EVENT_TRACKS_CHANGED, "track-list"),
|
|
E(MPV_EVENT_TRACK_SWITCHED, "vid", "video", "aid", "audio", "sid", "sub",
|
|
"secondary-sid"),
|
|
E(MPV_EVENT_IDLE, "*"),
|
|
E(MPV_EVENT_PAUSE, "pause", "paused-on-cache", "core-idle", "eof-reached"),
|
|
E(MPV_EVENT_UNPAUSE, "pause", "paused-on-cache", "core-idle", "eof-reached"),
|
|
E(MPV_EVENT_TICK, "time-pos", "stream-pos", "stream-time-pos", "avsync",
|
|
"percent-pos", "time-remaining", "playtime-remaining", "playback-time",
|
|
"estimated-vf-fps"),
|
|
E(MPV_EVENT_VIDEO_RECONFIG, "video-out-params", "video-params",
|
|
"video-format", "video-codec", "video-bitrate", "dwidth", "dheight",
|
|
"width", "height", "fps", "aspect", "vo-configured"),
|
|
E(MPV_EVENT_AUDIO_RECONFIG, "audio-format", "audio-codec", "audio-bitrate",
|
|
"samplerate", "channels", "audio"),
|
|
E(MPV_EVENT_SEEK, "seeking"),
|
|
E(MPV_EVENT_PLAYBACK_RESTART, "seeking"),
|
|
E(MPV_EVENT_METADATA_UPDATE, "metadata", "filtered-metadata"),
|
|
E(MPV_EVENT_CHAPTER_CHANGE, "chapter", "chapter-metadata"),
|
|
E(MP_EVENT_CACHE_UPDATE, "cache", "cache-free", "cache-used", "cache-idle",
|
|
"demuxer-cache-duration", "demuxer-cache-idle"),
|
|
E(MP_EVENT_WIN_RESIZE, "window-scale"),
|
|
E(MP_EVENT_WIN_STATE, "window-minimized"),
|
|
};
|
|
#undef E
|
|
|
|
static int prefix_len(const char *p)
|
|
{
|
|
const char *end = strchr(p, '/');
|
|
return end ? end - p : strlen(p);
|
|
}
|
|
|
|
static bool match_property(const char *a, const char *b)
|
|
{
|
|
if (strcmp(a, "*") == 0)
|
|
return true;
|
|
int len_a = prefix_len(a);
|
|
int len_b = prefix_len(b);
|
|
return strncmp(a, b, MPMIN(len_a, len_b)) == 0;
|
|
}
|
|
|
|
// Return a bitset of events which change the property.
|
|
uint64_t mp_get_property_event_mask(const char *name)
|
|
{
|
|
uint64_t mask = 0;
|
|
for (int n = 0; n < MP_ARRAY_SIZE(mp_event_property_change); n++) {
|
|
const char *const *const list = mp_event_property_change[n];
|
|
for (int i = 0; list && list[i]; i++) {
|
|
if (match_property(list[i], name))
|
|
mask |= 1ULL << n;
|
|
}
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
// Return an ID for the property. It might not be unique, but is good enough
|
|
// for property change handling. Return -1 if property unknown.
|
|
int mp_get_property_id(const char *name)
|
|
{
|
|
for (int n = 0; mp_properties[n].name; n++) {
|
|
if (match_property(mp_properties[n].name, name))
|
|
return n;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static bool is_property_set(int action, void *val)
|
|
{
|
|
switch (action) {
|
|
case M_PROPERTY_SET:
|
|
case M_PROPERTY_SWITCH:
|
|
case M_PROPERTY_SET_STRING:
|
|
case M_PROPERTY_SET_NODE:
|
|
return true;
|
|
case M_PROPERTY_KEY_ACTION: {
|
|
struct m_property_action_arg *key = val;
|
|
return is_property_set(key->action, key->arg);
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int mp_property_do(const char *name, int action, void *val,
|
|
struct MPContext *ctx)
|
|
{
|
|
int r = m_property_do(ctx->log, mp_properties, name, action, val, ctx);
|
|
if (r == M_PROPERTY_OK && is_property_set(action, val))
|
|
mp_notify_property(ctx, (char *)name);
|
|
return r;
|
|
}
|
|
|
|
char *mp_property_expand_string(struct MPContext *mpctx, const char *str)
|
|
{
|
|
return m_properties_expand_string(mp_properties, str, mpctx);
|
|
}
|
|
|
|
// Before expanding properties, parse C-style escapes like "\n"
|
|
char *mp_property_expand_escaped_string(struct MPContext *mpctx, const char *str)
|
|
{
|
|
void *tmp = talloc_new(NULL);
|
|
bstr strb = bstr0(str);
|
|
bstr dst = {0};
|
|
while (strb.len) {
|
|
if (!mp_append_escaped_string(tmp, &dst, &strb)) {
|
|
talloc_free(tmp);
|
|
return talloc_strdup(NULL, "(broken escape sequences)");
|
|
}
|
|
// pass " through literally
|
|
if (!bstr_eatstart0(&strb, "\""))
|
|
break;
|
|
bstr_xappend(tmp, &dst, bstr0("\""));
|
|
}
|
|
char *r = mp_property_expand_string(mpctx, dst.start);
|
|
talloc_free(tmp);
|
|
return r;
|
|
}
|
|
|
|
void property_print_help(struct mp_log *log)
|
|
{
|
|
m_properties_print_help_list(log, mp_properties);
|
|
}
|
|
|
|
|
|
/* List of default ways to show a property on OSD.
|
|
*
|
|
* If osd_progbar is set, a bar showing the current position between min/max
|
|
* values of the property is shown. In this case osd_msg is only used for
|
|
* terminal output if there is no video; it'll be a label shown together with
|
|
* percentage.
|
|
*/
|
|
static const struct property_osd_display {
|
|
// property name
|
|
const char *name;
|
|
// name used on OSD
|
|
const char *osd_name;
|
|
// progressbar type
|
|
int osd_progbar;
|
|
// Needs special ways to display the new value (seeks are delayed)
|
|
int seek_msg, seek_bar;
|
|
// Free-form message (if NULL, osd_name or the property name is used)
|
|
const char *msg;
|
|
} property_osd_display[] = {
|
|
// general
|
|
{ "loop", "Loop" },
|
|
{ "chapter", .seek_msg = OSD_SEEK_INFO_CHAPTER_TEXT,
|
|
.seek_bar = OSD_SEEK_INFO_BAR },
|
|
{ "edition", .seek_msg = OSD_SEEK_INFO_EDITION },
|
|
{ "pts-association-mode", "PTS association mode" },
|
|
{ "hr-seek", "hr-seek" },
|
|
{ "speed", "Speed" },
|
|
{ "clock", "Clock" },
|
|
// audio
|
|
{ "volume", "Volume",
|
|
.msg = "Volume: ${?volume:${volume}% ${?mute==yes:(Muted)}}${!volume:${volume}}",
|
|
.osd_progbar = OSD_VOLUME },
|
|
{ "mute", "Mute" },
|
|
{ "audio-delay", "A-V delay" },
|
|
{ "audio", "Audio" },
|
|
{ "balance", "Balance", .osd_progbar = OSD_BALANCE },
|
|
// video
|
|
{ "panscan", "Panscan", .osd_progbar = OSD_PANSCAN },
|
|
{ "ontop", "Stay on top" },
|
|
{ "border", "Border" },
|
|
{ "framedrop", "Framedrop" },
|
|
{ "deinterlace", "Deinterlace" },
|
|
{ "colormatrix",
|
|
.msg = "YUV colormatrix:\n${colormatrix}" },
|
|
{ "colormatrix-input-range",
|
|
.msg = "YUV input range:\n${colormatrix-input-range}" },
|
|
{ "colormatrix-output-range",
|
|
.msg = "RGB output range:\n${colormatrix-output-range}" },
|
|
{ "colormatrix-primaries",
|
|
.msg = "Colorspace primaries:\n${colormatrix-primaries}", },
|
|
{ "gamma", "Gamma", .osd_progbar = OSD_BRIGHTNESS },
|
|
{ "brightness", "Brightness", .osd_progbar = OSD_BRIGHTNESS },
|
|
{ "contrast", "Contrast", .osd_progbar = OSD_CONTRAST },
|
|
{ "saturation", "Saturation", .osd_progbar = OSD_SATURATION },
|
|
{ "hue", "Hue", .osd_progbar = OSD_HUE },
|
|
{ "angle", "Angle" },
|
|
// subs
|
|
{ "sub", "Subtitles" },
|
|
{ "secondary-sid", "Secondary subtitles" },
|
|
{ "sub-pos", "Sub position" },
|
|
{ "sub-delay", "Sub delay" },
|
|
{ "sub-visibility", "Subtitles" },
|
|
{ "sub-forced-only", "Forced sub only" },
|
|
{ "sub-scale", "Sub Scale"},
|
|
{ "ass-vsfilter-aspect-compat", "Subtitle VSFilter aspect compat"},
|
|
{ "ass-style-override", "ASS subtitle style override"},
|
|
{ "vf", "Video filters", .msg = "Video filters:\n${vf}"},
|
|
{ "af", "Audio filters", .msg = "Audio filters:\n${af}"},
|
|
{ "tv-brightness", "Brightness", .osd_progbar = OSD_BRIGHTNESS },
|
|
{ "tv-hue", "Hue", .osd_progbar = OSD_HUE},
|
|
{ "tv-saturation", "Saturation", .osd_progbar = OSD_SATURATION },
|
|
{ "tv-contrast", "Contrast", .osd_progbar = OSD_CONTRAST },
|
|
{ "ab-loop-a", "A-B loop point A"},
|
|
{ "ab-loop-b", "A-B loop point B"},
|
|
// By default, don't display the following properties on OSD
|
|
{ "pause", NULL },
|
|
{ "fullscreen", NULL },
|
|
{0}
|
|
};
|
|
|
|
static void show_property_osd(MPContext *mpctx, const char *name, int osd_mode)
|
|
{
|
|
struct MPOpts *opts = mpctx->opts;
|
|
struct property_osd_display disp = { .name = name, .osd_name = name };
|
|
|
|
if (!osd_mode)
|
|
return;
|
|
|
|
// look for the command
|
|
for (const struct property_osd_display *p = property_osd_display; p->name; p++)
|
|
{
|
|
if (!strcmp(p->name, name)) {
|
|
disp = *p;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (osd_mode == MP_ON_OSD_AUTO) {
|
|
osd_mode =
|
|
((disp.msg || disp.osd_name || disp.seek_msg) ? MP_ON_OSD_MSG : 0) |
|
|
((disp.osd_progbar || disp.seek_bar) ? MP_ON_OSD_BAR : 0);
|
|
}
|
|
|
|
if (!disp.osd_progbar)
|
|
disp.osd_progbar = ' ';
|
|
|
|
if (!disp.osd_name)
|
|
disp.osd_name = name;
|
|
|
|
if (disp.seek_msg || disp.seek_bar) {
|
|
mpctx->add_osd_seek_info |=
|
|
(osd_mode & MP_ON_OSD_MSG ? disp.seek_msg : 0) |
|
|
(osd_mode & MP_ON_OSD_BAR ? disp.seek_bar : 0);
|
|
return;
|
|
}
|
|
|
|
struct m_option prop = {0};
|
|
mp_property_do(name, M_PROPERTY_GET_TYPE, &prop, mpctx);
|
|
if ((osd_mode & MP_ON_OSD_BAR) && (prop.flags & CONF_RANGE) == CONF_RANGE) {
|
|
if (prop.type == CONF_TYPE_INT) {
|
|
int n = prop.min;
|
|
mp_property_do(name, M_PROPERTY_GET_NEUTRAL, &n, mpctx);
|
|
int i;
|
|
if (mp_property_do(name, M_PROPERTY_GET, &i, mpctx) > 0)
|
|
set_osd_bar(mpctx, disp.osd_progbar, prop.min, prop.max, n, i);
|
|
} else if (prop.type == CONF_TYPE_FLOAT) {
|
|
float n = prop.min;
|
|
mp_property_do(name, M_PROPERTY_GET_NEUTRAL, &n, mpctx);
|
|
float f;
|
|
if (mp_property_do(name, M_PROPERTY_GET, &f, mpctx) > 0)
|
|
set_osd_bar(mpctx, disp.osd_progbar, prop.min, prop.max, n, f);
|
|
}
|
|
}
|
|
|
|
if (osd_mode & MP_ON_OSD_MSG) {
|
|
void *tmp = talloc_new(NULL);
|
|
|
|
const char *msg = disp.msg;
|
|
if (!msg)
|
|
msg = talloc_asprintf(tmp, "%s: ${%s}", disp.osd_name, name);
|
|
|
|
char *osd_msg = talloc_steal(tmp, mp_property_expand_string(mpctx, msg));
|
|
|
|
if (osd_msg && osd_msg[0])
|
|
set_osd_msg(mpctx, 1, opts->osd_duration, "%s", osd_msg);
|
|
|
|
talloc_free(tmp);
|
|
}
|
|
}
|
|
|
|
static const char *property_error_string(int error_value)
|
|
{
|
|
switch (error_value) {
|
|
case M_PROPERTY_ERROR:
|
|
return "ERROR";
|
|
case M_PROPERTY_UNAVAILABLE:
|
|
return "PROPERTY_UNAVAILABLE";
|
|
case M_PROPERTY_NOT_IMPLEMENTED:
|
|
return "NOT_IMPLEMENTED";
|
|
case M_PROPERTY_UNKNOWN:
|
|
return "PROPERTY_UNKNOWN";
|
|
}
|
|
return "UNKNOWN";
|
|
}
|
|
|
|
static bool reinit_filters(MPContext *mpctx, enum stream_type mediatype)
|
|
{
|
|
switch (mediatype) {
|
|
case STREAM_VIDEO:
|
|
return reinit_video_filters(mpctx) >= 0;
|
|
case STREAM_AUDIO:
|
|
clear_audio_output_buffers(mpctx);
|
|
return reinit_audio_filters(mpctx) >= 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static const char *const filter_opt[STREAM_TYPE_COUNT] = {
|
|
[STREAM_VIDEO] = "vf",
|
|
[STREAM_AUDIO] = "af",
|
|
};
|
|
|
|
static int set_filters(struct MPContext *mpctx, enum stream_type mediatype,
|
|
struct m_obj_settings *new_chain)
|
|
{
|
|
bstr option = bstr0(filter_opt[mediatype]);
|
|
struct m_config_option *co = m_config_get_co(mpctx->mconfig, option);
|
|
if (!co)
|
|
return -1;
|
|
|
|
struct m_obj_settings **list = co->data;
|
|
struct m_obj_settings *old_settings = *list;
|
|
*list = NULL;
|
|
m_option_copy(co->opt, list, &new_chain);
|
|
|
|
bool success = reinit_filters(mpctx, mediatype);
|
|
|
|
if (success) {
|
|
m_option_free(co->opt, &old_settings);
|
|
mp_notify_property(mpctx, filter_opt[mediatype]);
|
|
} else {
|
|
m_option_free(co->opt, list);
|
|
*list = old_settings;
|
|
reinit_filters(mpctx, mediatype);
|
|
}
|
|
|
|
if (mediatype == STREAM_VIDEO)
|
|
mp_force_video_refresh(mpctx);
|
|
|
|
return success ? 0 : -1;
|
|
}
|
|
|
|
static int edit_filters(struct MPContext *mpctx, enum stream_type mediatype,
|
|
const char *cmd, const char *arg)
|
|
{
|
|
bstr option = bstr0(filter_opt[mediatype]);
|
|
struct m_config_option *co = m_config_get_co(mpctx->mconfig, option);
|
|
if (!co)
|
|
return -1;
|
|
|
|
// The option parser is used to modify the filter list itself.
|
|
char optname[20];
|
|
snprintf(optname, sizeof(optname), "%.*s-%s", BSTR_P(option), cmd);
|
|
|
|
struct m_obj_settings *new_chain = NULL;
|
|
m_option_copy(co->opt, &new_chain, co->data);
|
|
|
|
int r = m_option_parse(mpctx->log, co->opt, bstr0(optname), bstr0(arg),
|
|
&new_chain);
|
|
if (r >= 0)
|
|
r = set_filters(mpctx, mediatype, new_chain);
|
|
|
|
m_option_free(co->opt, &new_chain);
|
|
|
|
return r >= 0 ? 0 : -1;
|
|
}
|
|
|
|
static int edit_filters_osd(struct MPContext *mpctx, enum stream_type mediatype,
|
|
const char *cmd, const char *arg, bool on_osd)
|
|
{
|
|
int r = edit_filters(mpctx, mediatype, cmd, arg);
|
|
if (on_osd) {
|
|
if (r >= 0) {
|
|
const char *prop = filter_opt[mediatype];
|
|
show_property_osd(mpctx, prop, MP_ON_OSD_MSG);
|
|
} else {
|
|
set_osd_msg(mpctx, 1, mpctx->opts->osd_duration,
|
|
"Changing filters failed!");
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static void recreate_overlays(struct MPContext *mpctx)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
struct sub_bitmaps *new = &cmd->overlay_osd[0];
|
|
if (new == cmd->overlay_osd_current)
|
|
new += 1; // pick the unused one
|
|
new->format = SUBBITMAP_RGBA;
|
|
new->bitmap_id = new->bitmap_pos_id = 1;
|
|
// overlay array can have unused entries, but parts list must be "packed"
|
|
new->num_parts = 0;
|
|
for (int n = 0; n < cmd->num_overlays; n++) {
|
|
struct overlay *o = &cmd->overlays[n];
|
|
if (o->osd.bitmap)
|
|
MP_TARRAY_APPEND(cmd, new->parts, new->num_parts, o->osd);
|
|
}
|
|
cmd->overlay_osd_current = new;
|
|
osd_set_external2(mpctx->osd, cmd->overlay_osd_current);
|
|
}
|
|
|
|
// Set overlay with the given ID to the contents as described by "new".
|
|
static void replace_overlay(struct MPContext *mpctx, int id, struct overlay *new)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
assert(id >= 0);
|
|
if (id >= cmd->num_overlays) {
|
|
MP_TARRAY_GROW(cmd, cmd->overlays, id);
|
|
while (cmd->num_overlays <= id)
|
|
cmd->overlays[cmd->num_overlays++] = (struct overlay){0};
|
|
}
|
|
|
|
struct overlay *ptr = &cmd->overlays[id];
|
|
struct overlay old = *ptr;
|
|
|
|
if (!ptr->osd.bitmap && !new->osd.bitmap)
|
|
return; // don't need to recreate or unmap
|
|
|
|
*ptr = *new;
|
|
recreate_overlays(mpctx);
|
|
|
|
// Do this afterwards, so we never unmap while the OSD is using it.
|
|
if (old.map_start && old.map_size)
|
|
munmap(old.map_start, old.map_size);
|
|
}
|
|
|
|
static int overlay_add(struct MPContext *mpctx, int id, int x, int y,
|
|
char *file, int offset, char *fmt, int w, int h,
|
|
int stride)
|
|
{
|
|
int r = -1;
|
|
if (strcmp(fmt, "bgra") != 0) {
|
|
MP_ERR(mpctx, "overlay_add: unsupported OSD format '%s'\n", fmt);
|
|
goto error;
|
|
}
|
|
if (id < 0 || id >= 64) { // arbitrary upper limit
|
|
MP_ERR(mpctx, "overlay_add: invalid id %d\n", id);
|
|
goto error;
|
|
}
|
|
if (w < 0 || h < 0 || stride < w * 4 || (stride % 4)) {
|
|
MP_ERR(mpctx, "overlay_add: inconsistent parameters\n");
|
|
goto error;
|
|
}
|
|
struct overlay overlay = {
|
|
.osd = {
|
|
.stride = stride,
|
|
.x = x, .y = y,
|
|
.w = w, .h = h,
|
|
.dw = w, .dh = h,
|
|
},
|
|
};
|
|
int fd = -1;
|
|
bool close_fd = true;
|
|
void *p = NULL;
|
|
if (file[0] == '@') {
|
|
char *end;
|
|
fd = strtol(&file[1], &end, 10);
|
|
if (!file[1] || end[0])
|
|
fd = -1;
|
|
close_fd = false;
|
|
} else if (file[0] == '&') {
|
|
char *end;
|
|
unsigned long long addr = strtoull(&file[1], &end, 0);
|
|
if (!file[1] || end[0])
|
|
addr = 0;
|
|
p = (void *)(uintptr_t)addr;
|
|
} else {
|
|
fd = open(file, O_RDONLY | O_BINARY | O_CLOEXEC);
|
|
}
|
|
if (fd >= 0) {
|
|
overlay.map_size = offset + h * stride;
|
|
void *m = mmap(NULL, overlay.map_size, PROT_READ, MAP_SHARED, fd, 0);
|
|
if (close_fd)
|
|
close(fd);
|
|
if (m && m != MAP_FAILED) {
|
|
overlay.map_start = m;
|
|
p = m;
|
|
}
|
|
}
|
|
if (!p) {
|
|
MP_ERR(mpctx, "overlay_add: could not open or map '%s'\n", file);
|
|
goto error;
|
|
}
|
|
overlay.osd.bitmap = (char *)p + offset;
|
|
replace_overlay(mpctx, id, &overlay);
|
|
r = 0;
|
|
error:
|
|
return r;
|
|
}
|
|
|
|
static void overlay_remove(struct MPContext *mpctx, int id)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
if (id >= 0 && id < cmd->num_overlays)
|
|
replace_overlay(mpctx, id, &(struct overlay){0});
|
|
}
|
|
|
|
static void overlay_uninit(struct MPContext *mpctx)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
if (!mpctx->osd)
|
|
return;
|
|
for (int id = 0; id < cmd->num_overlays; id++)
|
|
overlay_remove(mpctx, id);
|
|
osd_set_external2(mpctx->osd, NULL);
|
|
}
|
|
|
|
struct subprocess_args {
|
|
struct mp_log *log;
|
|
char **args;
|
|
};
|
|
|
|
static void *run_subprocess(void *ptr)
|
|
{
|
|
struct subprocess_args *p = ptr;
|
|
pthread_detach(pthread_self());
|
|
|
|
mp_msg_flush_status_line(p->log);
|
|
|
|
char *err = NULL;
|
|
if (mp_subprocess(p->args, NULL, NULL, NULL, NULL, &err) < 0)
|
|
mp_err(p->log, "Running subprocess failed: %s\n", err);
|
|
|
|
talloc_free(p);
|
|
return NULL;
|
|
}
|
|
|
|
static void subprocess_detached(struct mp_log *log, char **args)
|
|
{
|
|
struct subprocess_args *p = talloc_zero(NULL, struct subprocess_args);
|
|
p->log = mp_log_new(p, log, NULL);
|
|
int num_args = 0;
|
|
for (int n = 0; args[n]; n++)
|
|
MP_TARRAY_APPEND(p, p->args, num_args, talloc_strdup(p, args[n]));
|
|
MP_TARRAY_APPEND(p, p->args, num_args, NULL);
|
|
pthread_t thread;
|
|
if (pthread_create(&thread, NULL, run_subprocess, p))
|
|
talloc_free(p);
|
|
}
|
|
|
|
struct cycle_counter {
|
|
char **args;
|
|
int counter;
|
|
};
|
|
|
|
static bool stringlist_equals(char **l1, char **l2)
|
|
{
|
|
assert(l1 && l2);
|
|
for (int i = 0; ; i++) {
|
|
if (!l1[i] && !l2[i])
|
|
return true;
|
|
if (!l1[i] || !l2[i])
|
|
return false;
|
|
if (strcmp(l1[i], l2[i]) != 0)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static char **stringlist_dup(void *talloc_ctx, char **list)
|
|
{
|
|
int num = 0;
|
|
char **res = NULL;
|
|
for (int i = 0; list && list[i]; i++)
|
|
MP_TARRAY_APPEND(talloc_ctx, res, num, talloc_strdup(talloc_ctx, list[i]));
|
|
MP_TARRAY_APPEND(talloc_ctx, res, num, NULL);
|
|
return res;
|
|
}
|
|
|
|
static int *get_cmd_cycle_counter(struct MPContext *mpctx, char **args)
|
|
{
|
|
struct command_ctx *cmd = mpctx->command_ctx;
|
|
for (int n = 0; n < cmd->num_cycle_counters; n++) {
|
|
struct cycle_counter *ctr = &cmd->cycle_counters[n];
|
|
if (stringlist_equals(ctr->args, args))
|
|
return &ctr->counter;
|
|
}
|
|
struct cycle_counter ctr = {stringlist_dup(cmd, args), -1};
|
|
MP_TARRAY_APPEND(cmd, cmd->cycle_counters, cmd->num_cycle_counters, ctr);
|
|
return &cmd->cycle_counters[cmd->num_cycle_counters - 1].counter;
|
|
}
|
|
|
|
static int mp_property_multiply(char *property, double f, struct MPContext *mpctx)
|
|
{
|
|
union m_option_value val = {0};
|
|
struct m_option opt = {0};
|
|
int r;
|
|
|
|
r = mp_property_do(property, M_PROPERTY_GET_TYPE, &opt, mpctx);
|
|
if (r != M_PROPERTY_OK)
|
|
return r;
|
|
assert(opt.type);
|
|
|
|
if (!opt.type->multiply)
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
r = mp_property_do(property, M_PROPERTY_GET, &val, mpctx);
|
|
if (r != M_PROPERTY_OK)
|
|
return r;
|
|
opt.type->multiply(&opt, &val, f);
|
|
r = mp_property_do(property, M_PROPERTY_SET, &val, mpctx);
|
|
m_option_free(&opt, &val);
|
|
return r;
|
|
}
|
|
|
|
static struct track *find_track_with_url(struct MPContext *mpctx, int type,
|
|
const char *url)
|
|
{
|
|
for (int n = 0; n < mpctx->num_tracks; n++) {
|
|
struct track *track = mpctx->tracks[n];
|
|
if (track && track->type == type && track->is_external &&
|
|
strcmp(track->external_filename, url) == 0)
|
|
return track;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// Whether this property should react to key events generated by auto-repeat.
|
|
static bool check_property_autorepeat(char *property, struct MPContext *mpctx)
|
|
{
|
|
struct m_option prop = {0};
|
|
if (mp_property_do(property, M_PROPERTY_GET_TYPE, &prop, mpctx) <= 0)
|
|
return true;
|
|
|
|
// This is a heuristic at best.
|
|
if (prop.type == &m_option_type_flag || prop.type == &m_option_type_choice)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
int run_command(MPContext *mpctx, mp_cmd_t *cmd)
|
|
{
|
|
struct command_ctx *cmdctx = mpctx->command_ctx;
|
|
struct MPOpts *opts = mpctx->opts;
|
|
int osd_duration = opts->osd_duration;
|
|
int on_osd = cmd->flags & MP_ON_OSD_FLAGS;
|
|
bool auto_osd = on_osd == MP_ON_OSD_AUTO;
|
|
bool msg_osd = auto_osd || (on_osd & MP_ON_OSD_MSG);
|
|
bool bar_osd = auto_osd || (on_osd & MP_ON_OSD_BAR);
|
|
bool msg_or_nobar_osd = msg_osd && !(auto_osd && opts->osd_bar_visible);
|
|
int osdl = msg_osd ? 1 : OSD_LEVEL_INVISIBLE;
|
|
|
|
mp_cmd_dump(mpctx->log, MSGL_V, "Run command:", cmd);
|
|
|
|
if (cmd->flags & MP_EXPAND_PROPERTIES) {
|
|
for (int n = 0; n < cmd->nargs; n++) {
|
|
if (cmd->args[n].type->type == CONF_TYPE_STRING) {
|
|
char *s = mp_property_expand_string(mpctx, cmd->args[n].v.s);
|
|
if (!s)
|
|
return -1;
|
|
talloc_free(cmd->args[n].v.s);
|
|
cmd->args[n].v.s = s;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (cmd->id) {
|
|
case MP_CMD_SEEK: {
|
|
double v = cmd->args[0].v.d * cmd->scale;
|
|
int abs = cmd->args[1].v.i;
|
|
int exact = cmd->args[2].v.i;
|
|
if (!mpctx->num_sources)
|
|
return -1;
|
|
mark_seek(mpctx);
|
|
if (abs == 2) { // Absolute seek to a timestamp in seconds
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, v, exact, false);
|
|
set_osd_function(mpctx,
|
|
v > get_current_time(mpctx) ? OSD_FFW : OSD_REW);
|
|
} else if (abs) { /* Absolute seek by percentage */
|
|
queue_seek(mpctx, MPSEEK_FACTOR, v / 100.0, exact, false);
|
|
set_osd_function(mpctx, OSD_FFW); // Direction isn't set correctly
|
|
} else {
|
|
queue_seek(mpctx, MPSEEK_RELATIVE, v, exact, false);
|
|
set_osd_function(mpctx, (v > 0) ? OSD_FFW : OSD_REW);
|
|
}
|
|
if (bar_osd)
|
|
mpctx->add_osd_seek_info |= OSD_SEEK_INFO_BAR;
|
|
if (msg_or_nobar_osd)
|
|
mpctx->add_osd_seek_info |= OSD_SEEK_INFO_TEXT;
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_REVERT_SEEK: {
|
|
if (!mpctx->num_sources)
|
|
return -1;
|
|
double oldpts = cmdctx->last_seek_pts;
|
|
if (cmdctx->marked_pts != MP_NOPTS_VALUE)
|
|
oldpts = cmdctx->marked_pts;
|
|
if (cmd->args[0].v.i == 1) {
|
|
cmdctx->marked_pts = get_current_time(mpctx);
|
|
} else if (oldpts != MP_NOPTS_VALUE) {
|
|
cmdctx->last_seek_pts = get_current_time(mpctx);
|
|
cmdctx->marked_pts = MP_NOPTS_VALUE;
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, oldpts, 1, false);
|
|
set_osd_function(mpctx, OSD_REW);
|
|
if (bar_osd)
|
|
mpctx->add_osd_seek_info |= OSD_SEEK_INFO_BAR;
|
|
if (msg_or_nobar_osd)
|
|
mpctx->add_osd_seek_info |= OSD_SEEK_INFO_TEXT;
|
|
} else {
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_SET: {
|
|
int r = mp_property_do(cmd->args[0].v.s, M_PROPERTY_SET_STRING,
|
|
cmd->args[1].v.s, mpctx);
|
|
if (r == M_PROPERTY_OK || r == M_PROPERTY_UNAVAILABLE) {
|
|
show_property_osd(mpctx, cmd->args[0].v.s, on_osd);
|
|
} else if (r == M_PROPERTY_UNKNOWN) {
|
|
set_osd_msg(mpctx, osdl, osd_duration,
|
|
"Unknown property: '%s'", cmd->args[0].v.s);
|
|
return -1;
|
|
} else if (r <= 0) {
|
|
set_osd_msg(mpctx, osdl, osd_duration,
|
|
"Failed to set property '%s' to '%s'",
|
|
cmd->args[0].v.s, cmd->args[1].v.s);
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_ADD:
|
|
case MP_CMD_CYCLE:
|
|
{
|
|
struct m_property_switch_arg s = {
|
|
.inc = 1,
|
|
.wrap = cmd->id == MP_CMD_CYCLE,
|
|
};
|
|
if (cmd->args[1].v.d)
|
|
s.inc = cmd->args[1].v.d * cmd->scale;
|
|
char *property = cmd->args[0].v.s;
|
|
if (cmd->repeated && !check_property_autorepeat(property, mpctx)) {
|
|
MP_VERBOSE(mpctx, "Dropping command '%.*s' from auto-repeated key.\n",
|
|
BSTR_P(cmd->original));
|
|
break;
|
|
}
|
|
int r = mp_property_do(property, M_PROPERTY_SWITCH, &s, mpctx);
|
|
if (r == M_PROPERTY_OK || r == M_PROPERTY_UNAVAILABLE) {
|
|
show_property_osd(mpctx, property, on_osd);
|
|
} else if (r == M_PROPERTY_UNKNOWN) {
|
|
set_osd_msg(mpctx, osdl, osd_duration,
|
|
"Unknown property: '%s'", property);
|
|
return -1;
|
|
} else if (r <= 0) {
|
|
set_osd_msg(mpctx, osdl, osd_duration,
|
|
"Failed to increment property '%s' by %g",
|
|
property, s.inc);
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_MULTIPLY: {
|
|
char *property = cmd->args[0].v.s;
|
|
double f = cmd->args[1].v.d;
|
|
int r = mp_property_multiply(property, f, mpctx);
|
|
|
|
if (r == M_PROPERTY_OK || r == M_PROPERTY_UNAVAILABLE) {
|
|
show_property_osd(mpctx, property, on_osd);
|
|
} else if (r == M_PROPERTY_UNKNOWN) {
|
|
set_osd_msg(mpctx, osdl, osd_duration,
|
|
"Unknown property: '%s'", property);
|
|
return -1;
|
|
} else if (r <= 0) {
|
|
set_osd_msg(mpctx, osdl, osd_duration,
|
|
"Failed to multiply property '%s' by %g", property, f);
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_CYCLE_VALUES: {
|
|
char *args[MP_CMD_MAX_ARGS + 1] = {0};
|
|
for (int n = 0; n < cmd->nargs; n++)
|
|
args[n] = cmd->args[n].v.s;
|
|
int first = 1, dir = 1;
|
|
if (strcmp(args[0], "!reverse") == 0) {
|
|
first += 1;
|
|
dir = -1;
|
|
}
|
|
int *ptr = get_cmd_cycle_counter(mpctx, &args[first - 1]);
|
|
int count = cmd->nargs - first;
|
|
if (ptr && count > 0) {
|
|
*ptr = *ptr < 0 ? (dir > 0 ? 0 : -1) : *ptr + dir;
|
|
if (*ptr >= count)
|
|
*ptr = 0;
|
|
if (*ptr < 0)
|
|
*ptr = count - 1;
|
|
char *property = args[first - 1];
|
|
char *value = args[first + *ptr];
|
|
int r = mp_property_do(property, M_PROPERTY_SET_STRING, value, mpctx);
|
|
if (r == M_PROPERTY_OK || r == M_PROPERTY_UNAVAILABLE) {
|
|
show_property_osd(mpctx, property, on_osd);
|
|
} else if (r == M_PROPERTY_UNKNOWN) {
|
|
set_osd_msg(mpctx, osdl, osd_duration,
|
|
"Unknown property: '%s'", property);
|
|
return -1;
|
|
} else if (r <= 0) {
|
|
set_osd_msg(mpctx, osdl, osd_duration,
|
|
"Failed to set property '%s' to '%s'",
|
|
property, value);
|
|
return -1;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_GET_PROPERTY: {
|
|
char *tmp;
|
|
int r = mp_property_do(cmd->args[0].v.s, M_PROPERTY_GET_STRING,
|
|
&tmp, mpctx);
|
|
if (r <= 0) {
|
|
MP_WARN(mpctx, "Failed to get value of property '%s'.\n",
|
|
cmd->args[0].v.s);
|
|
MP_INFO(mpctx, "ANS_ERROR=%s\n", property_error_string(r));
|
|
return -1;
|
|
}
|
|
MP_INFO(mpctx, "ANS_%s=%s\n", cmd->args[0].v.s, tmp);
|
|
talloc_free(tmp);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_FRAME_STEP:
|
|
if (!mpctx->num_sources)
|
|
return -1;
|
|
if (cmd->is_up_down) {
|
|
if (cmd->is_up) {
|
|
if (mpctx->step_frames < 1)
|
|
pause_player(mpctx);
|
|
} else {
|
|
if (cmd->repeated) {
|
|
unpause_player(mpctx);
|
|
} else {
|
|
add_step_frame(mpctx, 1);
|
|
}
|
|
}
|
|
} else {
|
|
add_step_frame(mpctx, 1);
|
|
}
|
|
break;
|
|
|
|
case MP_CMD_FRAME_BACK_STEP:
|
|
if (!mpctx->num_sources)
|
|
return -1;
|
|
add_step_frame(mpctx, -1);
|
|
break;
|
|
|
|
case MP_CMD_QUIT:
|
|
case MP_CMD_QUIT_WATCH_LATER:
|
|
if (cmd->id == MP_CMD_QUIT_WATCH_LATER || opts->position_save_on_quit)
|
|
mp_write_watch_later_conf(mpctx);
|
|
mpctx->stop_play = PT_QUIT;
|
|
mpctx->quit_custom_rc = cmd->args[0].v.i;
|
|
mpctx->has_quit_custom_rc = true;
|
|
break;
|
|
|
|
case MP_CMD_PLAYLIST_NEXT:
|
|
case MP_CMD_PLAYLIST_PREV:
|
|
{
|
|
int dir = cmd->id == MP_CMD_PLAYLIST_PREV ? -1 : +1;
|
|
int force = cmd->args[0].v.i;
|
|
|
|
struct playlist_entry *e = mp_next_file(mpctx, dir, force);
|
|
if (!e && !force)
|
|
return -1;
|
|
mpctx->playlist->current = e;
|
|
mpctx->playlist->current_was_replaced = false;
|
|
mpctx->stop_play = PT_CURRENT_ENTRY;
|
|
if (on_osd & MP_ON_OSD_MSG)
|
|
mpctx->add_osd_seek_info |= OSD_SEEK_INFO_CURRENT_FILE;
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_SUB_STEP:
|
|
case MP_CMD_SUB_SEEK: {
|
|
if (!mpctx->num_sources)
|
|
return -1;
|
|
struct osd_sub_state state;
|
|
update_osd_sub_state(mpctx, 0, &state);
|
|
double refpts = get_current_time(mpctx);
|
|
if (state.dec_sub && refpts != MP_NOPTS_VALUE) {
|
|
double a[2];
|
|
a[0] = refpts - state.video_offset - opts->sub_delay;
|
|
a[1] = cmd->args[0].v.i;
|
|
if (sub_control(state.dec_sub, SD_CTRL_SUB_STEP, a) > 0) {
|
|
if (cmd->id == MP_CMD_SUB_STEP) {
|
|
opts->sub_delay -= a[0];
|
|
osd_changed_all(mpctx->osd);
|
|
show_property_osd(mpctx, "sub-delay", on_osd);
|
|
} else {
|
|
// We can easily get stuck by failing to seek to the video
|
|
// frame which actually shows the sub first (because video
|
|
// frame PTS and sub PTS rarely match exactly). Add some
|
|
// rounding for the mess of it.
|
|
a[0] += 0.01 * (a[1] > 0 ? 1 : -1);
|
|
mark_seek(mpctx);
|
|
queue_seek(mpctx, MPSEEK_RELATIVE, a[0], 1, false);
|
|
set_osd_function(mpctx, (a[0] > 0) ? OSD_FFW : OSD_REW);
|
|
if (bar_osd)
|
|
mpctx->add_osd_seek_info |= OSD_SEEK_INFO_BAR;
|
|
if (msg_or_nobar_osd)
|
|
mpctx->add_osd_seek_info |= OSD_SEEK_INFO_TEXT;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_OSD: {
|
|
int v = cmd->args[0].v.i;
|
|
if (opts->osd_level > MAX_OSD_LEVEL)
|
|
opts->osd_level = MAX_OSD_LEVEL;
|
|
if (v < 0)
|
|
opts->osd_level = (opts->osd_level + 1) % (MAX_OSD_LEVEL + 1);
|
|
else
|
|
opts->osd_level = MPCLAMP(v, 0, MAX_OSD_LEVEL);
|
|
if (opts->osd_level > 0 && (on_osd & MP_ON_OSD_MSG))
|
|
set_osd_msg(mpctx, osdl, osd_duration, "OSD level: %d", opts->osd_level);
|
|
if (opts->osd_level == 0)
|
|
set_osd_msg(mpctx, 0, 0, "");
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_PRINT_TEXT: {
|
|
MP_INFO(mpctx, "%s\n", cmd->args[0].v.s);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_SHOW_TEXT: {
|
|
// if no argument supplied use default osd_duration, else <arg> ms.
|
|
set_osd_msg(mpctx, cmd->args[2].v.i,
|
|
(cmd->args[1].v.i < 0 ? osd_duration : cmd->args[1].v.i),
|
|
"%s", cmd->args[0].v.s);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_LOADFILE: {
|
|
char *filename = cmd->args[0].v.s;
|
|
int append = cmd->args[1].v.i;
|
|
|
|
if (!append)
|
|
playlist_clear(mpctx->playlist);
|
|
|
|
struct playlist_entry *entry = playlist_entry_new(filename);
|
|
if (cmd->args[2].v.str_list) {
|
|
char **pairs = cmd->args[2].v.str_list;
|
|
for (int i = 0; pairs[i] && pairs[i + 1]; i += 2) {
|
|
playlist_entry_add_param(entry, bstr0(pairs[i]),
|
|
bstr0(pairs[i + 1]));
|
|
}
|
|
}
|
|
playlist_add(mpctx->playlist, entry);
|
|
|
|
if (!append || (append == 2 && !mpctx->playlist->current)) {
|
|
if (opts->position_save_on_quit) // requested in issue #1148
|
|
mp_write_watch_later_conf(mpctx);
|
|
mp_set_playlist_entry(mpctx, entry);
|
|
}
|
|
mp_notify_property(mpctx, "playlist");
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_LOADLIST: {
|
|
char *filename = cmd->args[0].v.s;
|
|
bool append = cmd->args[1].v.i;
|
|
struct playlist *pl = playlist_parse_file(filename, mpctx->global);
|
|
if (pl) {
|
|
prepare_playlist(mpctx, pl);
|
|
struct playlist_entry *new = pl->current;
|
|
if (!append)
|
|
playlist_clear(mpctx->playlist);
|
|
playlist_append_entries(mpctx->playlist, pl);
|
|
talloc_free(pl);
|
|
|
|
if (!append && mpctx->playlist->first)
|
|
mp_set_playlist_entry(mpctx, new ? new : mpctx->playlist->first);
|
|
|
|
mp_notify_property(mpctx, "playlist");
|
|
} else {
|
|
MP_ERR(mpctx, "Unable to load playlist %s.\n", filename);
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_PLAYLIST_CLEAR: {
|
|
// Supposed to clear the playlist, except the currently played item.
|
|
if (mpctx->playlist->current_was_replaced)
|
|
mpctx->playlist->current = NULL;
|
|
while (mpctx->playlist->first) {
|
|
struct playlist_entry *e = mpctx->playlist->first;
|
|
if (e == mpctx->playlist->current) {
|
|
e = e->next;
|
|
if (!e)
|
|
break;
|
|
}
|
|
playlist_remove(mpctx->playlist, e);
|
|
}
|
|
mp_notify_property(mpctx, "playlist");
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_PLAYLIST_REMOVE: {
|
|
struct playlist_entry *e = playlist_entry_from_index(mpctx->playlist,
|
|
cmd->args[0].v.i);
|
|
if (cmd->args[0].v.i < 0)
|
|
e = mpctx->playlist->current;
|
|
if (!e)
|
|
return -1;
|
|
// Can't play a removed entry
|
|
if (mpctx->playlist->current == e)
|
|
mpctx->stop_play = PT_CURRENT_ENTRY;
|
|
playlist_remove(mpctx->playlist, e);
|
|
mp_notify_property(mpctx, "playlist");
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_PLAYLIST_MOVE: {
|
|
struct playlist_entry *e1 = playlist_entry_from_index(mpctx->playlist,
|
|
cmd->args[0].v.i);
|
|
struct playlist_entry *e2 = playlist_entry_from_index(mpctx->playlist,
|
|
cmd->args[1].v.i);
|
|
if (!e1)
|
|
return -1;
|
|
playlist_move(mpctx->playlist, e1, e2);
|
|
mp_notify_property(mpctx, "playlist");
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_STOP:
|
|
playlist_clear(mpctx->playlist);
|
|
mpctx->stop_play = PT_STOP;
|
|
break;
|
|
|
|
case MP_CMD_SHOW_PROGRESS:
|
|
mpctx->add_osd_seek_info |=
|
|
(msg_osd ? OSD_SEEK_INFO_TEXT : 0) |
|
|
(bar_osd ? OSD_SEEK_INFO_BAR : 0);
|
|
break;
|
|
|
|
case MP_CMD_TV_LAST_CHANNEL: {
|
|
if (!mpctx->demuxer)
|
|
return -1;
|
|
demux_stream_control(mpctx->demuxer, STREAM_CTRL_TV_LAST_CHAN, NULL);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_SUB_ADD: {
|
|
if (!mpctx->playing)
|
|
return -1;
|
|
if (cmd->args[1].v.i == 2) {
|
|
struct track *sub = find_track_with_url(mpctx, STREAM_SUB,
|
|
cmd->args[0].v.s);
|
|
if (sub) {
|
|
mp_switch_track(mpctx, sub->type, sub);
|
|
mp_mark_user_track_selection(mpctx, 0, sub->type);
|
|
return 0;
|
|
}
|
|
}
|
|
struct track *sub = mp_add_subtitles(mpctx, cmd->args[0].v.s);
|
|
if (!sub)
|
|
return -1;
|
|
if (cmd->args[1].v.i == 1) {
|
|
sub->no_default = true;
|
|
} else {
|
|
mp_switch_track(mpctx, sub->type, sub);
|
|
mp_mark_user_track_selection(mpctx, 0, sub->type);
|
|
}
|
|
char *title = cmd->args[2].v.s;
|
|
if (title && title[0])
|
|
sub->title = talloc_strdup(sub, title);
|
|
char *lang = cmd->args[3].v.s;
|
|
if (lang && lang[0])
|
|
sub->lang = talloc_strdup(sub, lang);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_SUB_REMOVE: {
|
|
struct track *sub = mp_track_by_tid(mpctx, STREAM_SUB, cmd->args[0].v.i);
|
|
if (!sub)
|
|
return -1;
|
|
mp_remove_track(mpctx, sub);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_SUB_RELOAD: {
|
|
struct track *sub = mp_track_by_tid(mpctx, STREAM_SUB, cmd->args[0].v.i);
|
|
if (sub && sub->is_external && sub->external_filename) {
|
|
struct track *nsub = mp_add_subtitles(mpctx, sub->external_filename);
|
|
if (nsub) {
|
|
mp_remove_track(mpctx, sub);
|
|
mp_switch_track(mpctx, nsub->type, nsub);
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
case MP_CMD_SCREENSHOT:
|
|
screenshot_request(mpctx, cmd->args[0].v.i, cmd->args[1].v.i, msg_osd);
|
|
break;
|
|
|
|
case MP_CMD_SCREENSHOT_TO_FILE:
|
|
screenshot_to_file(mpctx, cmd->args[0].v.s, cmd->args[1].v.i, msg_osd);
|
|
break;
|
|
|
|
case MP_CMD_RUN: {
|
|
char *args[MP_CMD_MAX_ARGS + 1] = {0};
|
|
for (int n = 0; n < cmd->nargs; n++)
|
|
args[n] = cmd->args[n].v.s;
|
|
subprocess_detached(mpctx->log, args);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_ENABLE_INPUT_SECTION:
|
|
mp_input_enable_section(mpctx->input, cmd->args[0].v.s,
|
|
cmd->args[1].v.i == 1 ? MP_INPUT_EXCLUSIVE : 0);
|
|
break;
|
|
|
|
case MP_CMD_DISABLE_INPUT_SECTION:
|
|
mp_input_disable_section(mpctx->input, cmd->args[0].v.s);
|
|
break;
|
|
|
|
case MP_CMD_DISCNAV:
|
|
mp_nav_user_input(mpctx, cmd->args[0].v.s);
|
|
break;
|
|
|
|
case MP_CMD_AB_LOOP: {
|
|
double now = get_current_time(mpctx);
|
|
int r = 0;
|
|
if (opts->ab_loop[0] == MP_NOPTS_VALUE) {
|
|
r = mp_property_do("ab-loop-a", M_PROPERTY_SET, &now, mpctx);
|
|
show_property_osd(mpctx, "ab-loop-a", on_osd);
|
|
} else if (opts->ab_loop[1] == MP_NOPTS_VALUE) {
|
|
r = mp_property_do("ab-loop-b", M_PROPERTY_SET, &now, mpctx);
|
|
show_property_osd(mpctx, "ab-loop-b", on_osd);
|
|
} else {
|
|
now = MP_NOPTS_VALUE;
|
|
r = mp_property_do("ab-loop-a", M_PROPERTY_SET, &now, mpctx);
|
|
r = mp_property_do("ab-loop-b", M_PROPERTY_SET, &now, mpctx);
|
|
set_osd_msg(mpctx, osdl, osd_duration, "Clear A-B loop");
|
|
}
|
|
return r > 0;
|
|
}
|
|
|
|
case MP_CMD_DROP_BUFFERS: {
|
|
reset_audio_state(mpctx);
|
|
reset_video_state(mpctx);
|
|
|
|
if (mpctx->demuxer)
|
|
demux_flush(mpctx->demuxer);
|
|
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_VO_CMDLINE:
|
|
if (mpctx->video_out) {
|
|
char *s = cmd->args[0].v.s;
|
|
MP_INFO(mpctx, "Setting vo cmd line to '%s'.\n", s);
|
|
if (vo_control(mpctx->video_out, VOCTRL_SET_COMMAND_LINE, s) > 0) {
|
|
set_osd_msg(mpctx, osdl, osd_duration, "vo='%s'", s);
|
|
} else {
|
|
set_osd_msg(mpctx, osdl, osd_duration, "Failed!");
|
|
return -1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MP_CMD_AO_RELOAD:
|
|
reload_audio_output(mpctx);
|
|
break;
|
|
|
|
case MP_CMD_AF:
|
|
return edit_filters_osd(mpctx, STREAM_AUDIO, cmd->args[0].v.s,
|
|
cmd->args[1].v.s, msg_osd);
|
|
|
|
case MP_CMD_VF:
|
|
return edit_filters_osd(mpctx, STREAM_VIDEO, cmd->args[0].v.s,
|
|
cmd->args[1].v.s, msg_osd);
|
|
|
|
case MP_CMD_SCRIPT_BINDING: {
|
|
mpv_event_client_message event = {0};
|
|
char *name = cmd->args[0].v.s;
|
|
if (!name || !name[0])
|
|
return -1;
|
|
char *sep = strchr(name, '/');
|
|
char *target = NULL;
|
|
char space[MAX_CLIENT_NAME];
|
|
if (sep) {
|
|
snprintf(space, sizeof(space), "%.*s", (int)(sep - name), name);
|
|
target = space;
|
|
name = sep + 1;
|
|
}
|
|
char state[3] = {'p', cmd->is_mouse_button ? 'm' : '-'};
|
|
if (cmd->is_up_down)
|
|
state[0] = cmd->repeated ? 'r' : (cmd->is_up ? 'u' : 'd');
|
|
event.num_args = 3;
|
|
event.args = (const char*[3]){"key-binding", name, state};
|
|
if (mp_client_send_event_dup(mpctx, target,
|
|
MPV_EVENT_CLIENT_MESSAGE, &event) < 0)
|
|
{
|
|
MP_VERBOSE(mpctx, "Can't find script '%s' when handling input.\n",
|
|
target ? target : "-");
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_SCRIPT_MESSAGE_TO: {
|
|
mpv_event_client_message *event = talloc_ptrtype(NULL, event);
|
|
*event = (mpv_event_client_message){0};
|
|
for (int n = 1; n < cmd->nargs; n++) {
|
|
MP_TARRAY_APPEND(event, event->args, event->num_args,
|
|
talloc_strdup(event, cmd->args[n].v.s));
|
|
}
|
|
if (mp_client_send_event(mpctx, cmd->args[0].v.s,
|
|
MPV_EVENT_CLIENT_MESSAGE, event) < 0)
|
|
{
|
|
MP_VERBOSE(mpctx, "Can't find script '%s' for %s.\n",
|
|
cmd->args[0].v.s, cmd->name);
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
case MP_CMD_SCRIPT_MESSAGE: {
|
|
const char *args[MP_CMD_MAX_ARGS];
|
|
mpv_event_client_message event = {.args = args};
|
|
for (int n = 0; n < cmd->nargs; n++)
|
|
event.args[event.num_args++] = cmd->args[n].v.s;
|
|
mp_client_broadcast_event(mpctx, MPV_EVENT_CLIENT_MESSAGE, &event);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_OVERLAY_ADD:
|
|
overlay_add(mpctx,
|
|
cmd->args[0].v.i, cmd->args[1].v.i, cmd->args[2].v.i,
|
|
cmd->args[3].v.s, cmd->args[4].v.i, cmd->args[5].v.s,
|
|
cmd->args[6].v.i, cmd->args[7].v.i, cmd->args[8].v.i);
|
|
break;
|
|
|
|
case MP_CMD_OVERLAY_REMOVE:
|
|
overlay_remove(mpctx, cmd->args[0].v.i);
|
|
break;
|
|
|
|
case MP_CMD_COMMAND_LIST: {
|
|
for (struct mp_cmd *sub = cmd->args[0].v.p; sub; sub = sub->queue_next)
|
|
run_command(mpctx, sub);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_IGNORE:
|
|
break;
|
|
|
|
case MP_CMD_WRITE_WATCH_LATER_CONFIG: {
|
|
mp_write_watch_later_conf(mpctx);
|
|
break;
|
|
}
|
|
|
|
case MP_CMD_HOOK_ADD:
|
|
if (!cmd->sender) {
|
|
MP_ERR(mpctx, "Can be used from client API only.\n");
|
|
return -1;
|
|
}
|
|
mp_hook_add(mpctx, cmd->sender, cmd->args[0].v.s, cmd->args[1].v.i,
|
|
cmd->args[2].v.i);
|
|
break;
|
|
case MP_CMD_HOOK_ACK:
|
|
if (!cmd->sender) {
|
|
MP_ERR(mpctx, "Can be used from client API only.\n");
|
|
return -1;
|
|
}
|
|
mp_hook_run(mpctx, cmd->sender, cmd->args[0].v.s);
|
|
break;
|
|
|
|
default:
|
|
MP_VERBOSE(mpctx, "Received unknown cmd %s\n", cmd->name);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void command_uninit(struct MPContext *mpctx)
|
|
{
|
|
overlay_uninit(mpctx);
|
|
talloc_free(mpctx->command_ctx);
|
|
mpctx->command_ctx = NULL;
|
|
}
|
|
|
|
void command_init(struct MPContext *mpctx)
|
|
{
|
|
mpctx->command_ctx = talloc(NULL, struct command_ctx);
|
|
*mpctx->command_ctx = (struct command_ctx){
|
|
.last_seek_pts = MP_NOPTS_VALUE,
|
|
.prev_pts = MP_NOPTS_VALUE,
|
|
};
|
|
}
|
|
|
|
static void command_event(struct MPContext *mpctx, int event, void *arg)
|
|
{
|
|
struct command_ctx *ctx = mpctx->command_ctx;
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
if (event == MPV_EVENT_START_FILE) {
|
|
ctx->last_seek_pts = MP_NOPTS_VALUE;
|
|
ctx->marked_pts = MP_NOPTS_VALUE;
|
|
}
|
|
|
|
if (event == MPV_EVENT_TICK) {
|
|
double now =
|
|
mpctx->restart_complete ? mpctx->playback_pts : MP_NOPTS_VALUE;
|
|
if (now != MP_NOPTS_VALUE && opts->ab_loop[0] != MP_NOPTS_VALUE &&
|
|
opts->ab_loop[1] != MP_NOPTS_VALUE)
|
|
{
|
|
if (ctx->prev_pts >= opts->ab_loop[0] &&
|
|
ctx->prev_pts < opts->ab_loop[1] &&
|
|
now >= opts->ab_loop[1])
|
|
{
|
|
mark_seek(mpctx);
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, opts->ab_loop[0], 1, false);
|
|
}
|
|
}
|
|
ctx->prev_pts = now;
|
|
}
|
|
if (event == MPV_EVENT_SEEK)
|
|
ctx->prev_pts = MP_NOPTS_VALUE;
|
|
if (event == MPV_EVENT_IDLE)
|
|
ctx->is_idle = true;
|
|
if (event == MPV_EVENT_START_FILE)
|
|
ctx->is_idle = false;
|
|
if (event == MPV_EVENT_END_FILE || event == MPV_EVENT_FILE_LOADED) {
|
|
// Update chapters - does nothing if something else is visible.
|
|
set_osd_bar_chapters(mpctx, OSD_BAR_SEEK);
|
|
}
|
|
}
|
|
|
|
void mp_notify(struct MPContext *mpctx, int event, void *arg)
|
|
{
|
|
command_event(mpctx, event, arg);
|
|
|
|
mp_client_broadcast_event(mpctx, event, arg);
|
|
}
|
|
|
|
void mp_notify_property(struct MPContext *mpctx, const char *property)
|
|
{
|
|
mp_client_property_change(mpctx, property);
|
|
}
|