2010-01-31 00:24:23 +01:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <unistd.h>
|
2007-03-09 15:04:07 +01:00
|
|
|
#include <string.h>
|
2008-11-29 07:09:57 +01:00
|
|
|
#include <stdbool.h>
|
2012-02-10 19:03:24 +01:00
|
|
|
#include <assert.h>
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
#include "config.h"
|
2009-04-02 04:00:22 +02:00
|
|
|
#include "talloc.h"
|
2008-03-28 02:07:59 +01:00
|
|
|
#include "command.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "input/input.h"
|
|
|
|
#include "stream/stream.h"
|
|
|
|
#include "libmpdemux/demuxer.h"
|
|
|
|
#include "libmpdemux/stheader.h"
|
2007-05-30 00:14:41 +02:00
|
|
|
#include "codec-cfg.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "mplayer.h"
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
#include "playlist.h"
|
|
|
|
#include "playlist_parser.h"
|
2011-01-26 18:40:52 +01:00
|
|
|
#include "sub/sub.h"
|
2011-01-16 19:03:08 +01:00
|
|
|
#include "sub/dec_sub.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "m_option.h"
|
|
|
|
#include "m_property.h"
|
2010-12-18 07:02:48 +01:00
|
|
|
#include "m_config.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "metadata.h"
|
|
|
|
#include "libmpcodecs/vf.h"
|
|
|
|
#include "libmpcodecs/vd.h"
|
2008-04-23 08:49:25 +02:00
|
|
|
#include "mp_osd.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "libvo/video_out.h"
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
#include "libvo/csputils.h"
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
#include "playlist.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "libao2/audio_out.h"
|
|
|
|
#include "mpcommon.h"
|
|
|
|
#include "mixer.h"
|
|
|
|
#include "libmpcodecs/dec_video.h"
|
2010-04-23 19:14:59 +02:00
|
|
|
#include "libmpcodecs/dec_audio.h"
|
2011-04-28 15:45:16 +02:00
|
|
|
#include "osdep/strsep.h"
|
2011-01-26 18:40:52 +01:00
|
|
|
#include "sub/vobsub.h"
|
|
|
|
#include "sub/spudec.h"
|
2010-03-21 00:38:27 +01:00
|
|
|
#include "path.h"
|
2011-01-26 18:40:52 +01:00
|
|
|
#include "sub/ass_mp.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "stream/tv.h"
|
|
|
|
#include "stream/stream_radio.h"
|
2007-05-08 14:20:46 +02:00
|
|
|
#include "stream/pvr.h"
|
2008-08-03 17:21:40 +02:00
|
|
|
#ifdef CONFIG_DVBIN
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "stream/dvbin.h"
|
|
|
|
#endif
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_DVDREAD
|
2007-02-21 01:49:24 +01:00
|
|
|
#include "stream/stream_dvd.h"
|
|
|
|
#endif
|
|
|
|
#include "stream/stream_dvdnav.h"
|
2007-12-22 07:14:38 +01:00
|
|
|
#include "m_struct.h"
|
2011-10-06 20:46:01 +02:00
|
|
|
#include "screenshot.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
#include "mp_core.h"
|
2007-08-25 18:03:02 +02:00
|
|
|
#include "mp_fifo.h"
|
2008-02-29 18:44:54 +01:00
|
|
|
#include "libavutil/avstring.h"
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2008-04-20 22:29:28 +02:00
|
|
|
static void rescale_input_coordinates(struct MPContext *mpctx, int ix, int iy,
|
|
|
|
double *dx, double *dy)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2008-04-21 01:18:28 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2008-04-20 22:29:28 +02:00
|
|
|
struct vo *vo = mpctx->video_out;
|
2007-02-21 01:49:24 +01:00
|
|
|
//remove the borders, if any, and rescale to the range [0,1],[0,1]
|
2010-05-04 01:34:38 +02:00
|
|
|
if (vo_fs) { //we are in full-screen mode
|
2011-08-07 03:45:40 +02:00
|
|
|
if (opts->vo_screenwidth > vo->dwidth)
|
|
|
|
// there are borders along the x axis
|
2010-05-07 21:02:47 +02:00
|
|
|
ix -= (opts->vo_screenwidth - vo->dwidth) / 2;
|
2011-08-07 03:45:40 +02:00
|
|
|
if (opts->vo_screenheight > vo->dheight)
|
|
|
|
// there are borders along the y axis (usual way)
|
2010-05-07 21:02:47 +02:00
|
|
|
iy -= (opts->vo_screenheight - vo->dheight) / 2;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2010-05-07 21:02:47 +02:00
|
|
|
if (ix < 0 || ix > vo->dwidth) {
|
2010-05-04 01:34:38 +02:00
|
|
|
*dx = *dy = -1.0;
|
|
|
|
return;
|
|
|
|
} //we are on one of the borders
|
2010-05-07 21:02:47 +02:00
|
|
|
if (iy < 0 || iy > vo->dheight) {
|
2010-05-04 01:34:38 +02:00
|
|
|
*dx = *dy = -1.0;
|
|
|
|
return;
|
|
|
|
} //we are on one of the borders
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2008-04-20 22:29:28 +02:00
|
|
|
*dx = (double) ix / (double) vo->dwidth;
|
|
|
|
*dy = (double) iy / (double) vo->dheight;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_V,
|
2010-05-07 21:02:47 +02:00
|
|
|
"\r\nrescaled coordinates: %.3f, %.3f, screen (%d x %d), vodisplay: (%d, %d), fullscreen: %d\r\n",
|
|
|
|
*dx, *dy, opts->vo_screenwidth, opts->vo_screenheight, vo->dwidth,
|
|
|
|
vo->dheight, vo_fs);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2010-07-10 22:48:50 +02:00
|
|
|
static int sub_pos_by_source(MPContext *mpctx, int src)
|
|
|
|
{
|
|
|
|
int i, cnt = 0;
|
|
|
|
if (src >= SUB_SOURCES || mpctx->sub_counts[src] == 0)
|
|
|
|
return -1;
|
|
|
|
for (i = 0; i < src; i++)
|
|
|
|
cnt += mpctx->sub_counts[i];
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sub_source_and_index_by_pos(MPContext *mpctx, int *pos)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2010-07-10 22:48:50 +02:00
|
|
|
int start = 0;
|
2007-02-21 01:49:24 +01:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < SUB_SOURCES; i++) {
|
2010-07-10 22:48:50 +02:00
|
|
|
int cnt = mpctx->sub_counts[i];
|
|
|
|
if (*pos >= start && *pos < start + cnt) {
|
|
|
|
*pos -= start;
|
|
|
|
return i;
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2010-07-10 22:48:50 +02:00
|
|
|
start += cnt;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
2010-07-10 22:48:50 +02:00
|
|
|
*pos = -1;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sub_source_by_pos(MPContext *mpctx, int pos)
|
|
|
|
{
|
|
|
|
return sub_source_and_index_by_pos(mpctx, &pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sub_source_pos(MPContext *mpctx)
|
|
|
|
{
|
|
|
|
int pos = mpctx->global_sub_pos;
|
|
|
|
sub_source_and_index_by_pos(mpctx, &pos);
|
|
|
|
return pos;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2008-04-25 04:04:41 +02:00
|
|
|
static int sub_source(MPContext *mpctx)
|
2007-11-25 05:09:04 +01:00
|
|
|
{
|
|
|
|
return sub_source_by_pos(mpctx, mpctx->global_sub_pos);
|
|
|
|
}
|
|
|
|
|
2010-07-10 22:48:50 +02:00
|
|
|
static void update_global_sub_size(MPContext *mpctx)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
|
|
|
int i;
|
|
|
|
int cnt = 0;
|
|
|
|
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (!mpctx->demuxer) {
|
|
|
|
mpctx->global_sub_size = -1;
|
|
|
|
mpctx->global_sub_pos = -1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-07-10 22:48:50 +02:00
|
|
|
// update number of demuxer sub streams
|
|
|
|
for (i = 0; i < MAX_S_STREAMS; i++)
|
2010-11-08 01:38:51 +01:00
|
|
|
if (mpctx->d_sub->demuxer->s_streams[i])
|
2010-07-10 22:48:50 +02:00
|
|
|
cnt++;
|
|
|
|
if (cnt > mpctx->sub_counts[SUB_SOURCE_DEMUX])
|
|
|
|
mpctx->sub_counts[SUB_SOURCE_DEMUX] = cnt;
|
|
|
|
|
|
|
|
// update global size
|
|
|
|
mpctx->global_sub_size = 0;
|
|
|
|
for (i = 0; i < SUB_SOURCES; i++)
|
|
|
|
mpctx->global_sub_size += mpctx->sub_counts[i];
|
|
|
|
|
|
|
|
// update global_sub_pos if we auto-detected a demuxer sub
|
|
|
|
if (mpctx->global_sub_pos == -1) {
|
|
|
|
int sub_id = -1;
|
|
|
|
if (mpctx->demuxer->sub)
|
|
|
|
sub_id = mpctx->demuxer->sub->id;
|
|
|
|
if (sub_id < 0)
|
|
|
|
sub_id = opts->sub_id;
|
|
|
|
if (sub_id >= 0 && sub_id < mpctx->sub_counts[SUB_SOURCE_DEMUX])
|
|
|
|
mpctx->global_sub_pos = sub_pos_by_source(mpctx, SUB_SOURCE_DEMUX) +
|
|
|
|
sub_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/**
|
|
|
|
* \brief Log the currently displayed subtitle to a file
|
|
|
|
*
|
|
|
|
* Logs the current or last displayed subtitle together with filename
|
|
|
|
* and time information to ~/.mplayer/subtitle_log
|
|
|
|
*
|
|
|
|
* Intended purpose is to allow convenient marking of bogus subtitles
|
|
|
|
* which need to be fixed while watching the movie.
|
|
|
|
*/
|
|
|
|
|
2008-04-26 14:17:51 +02:00
|
|
|
static void log_sub(struct MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
char *fname;
|
|
|
|
FILE *f;
|
|
|
|
int i;
|
2011-01-11 16:48:45 +01:00
|
|
|
struct subtitle *vo_sub_last = mpctx->vo_sub_last;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-01-11 16:48:45 +01:00
|
|
|
if (mpctx->subdata == NULL || vo_sub_last == NULL)
|
2010-05-04 01:34:38 +02:00
|
|
|
return;
|
2007-02-21 01:49:24 +01:00
|
|
|
fname = get_path("subtitle_log");
|
|
|
|
f = fopen(fname, "a");
|
|
|
|
if (!f)
|
2010-05-04 01:34:38 +02:00
|
|
|
return;
|
2007-02-21 01:49:24 +01:00
|
|
|
fprintf(f, "----------------------------------------------------------\n");
|
2011-01-11 16:48:45 +01:00
|
|
|
if (mpctx->subdata->sub_uses_time) {
|
2010-05-04 01:34:38 +02:00
|
|
|
fprintf(f,
|
|
|
|
"N: %s S: %02ld:%02ld:%02ld.%02ld E: %02ld:%02ld:%02ld.%02ld\n",
|
2008-04-26 14:17:51 +02:00
|
|
|
mpctx->filename, vo_sub_last->start / 360000,
|
2010-05-04 01:34:38 +02:00
|
|
|
(vo_sub_last->start / 6000) % 60,
|
|
|
|
(vo_sub_last->start / 100) % 60, vo_sub_last->start % 100,
|
|
|
|
vo_sub_last->end / 360000, (vo_sub_last->end / 6000) % 60,
|
|
|
|
(vo_sub_last->end / 100) % 60, vo_sub_last->end % 100);
|
2007-02-21 01:49:24 +01:00
|
|
|
} else {
|
2008-04-26 14:17:51 +02:00
|
|
|
fprintf(f, "N: %s S: %ld E: %ld\n", mpctx->filename,
|
|
|
|
vo_sub_last->start, vo_sub_last->end);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
for (i = 0; i < vo_sub_last->lines; i++)
|
2010-05-04 01:34:38 +02:00
|
|
|
fprintf(f, "%s\n", vo_sub_last->text[i]);
|
2007-02-21 01:49:24 +01:00
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-18 07:02:48 +01:00
|
|
|
static int mp_property_generic_option(struct m_option *prop, int action,
|
|
|
|
void *arg, MPContext *mpctx)
|
|
|
|
{
|
|
|
|
char *optname = prop->priv;
|
2011-07-28 10:07:47 +02:00
|
|
|
const struct m_option *opt = m_config_get_option(mpctx->mconfig,
|
2012-07-28 23:47:42 +02:00
|
|
|
bstr0(optname));
|
2010-12-18 07:02:48 +01:00
|
|
|
void *valptr = m_option_get_ptr(opt, &mpctx->opts);
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET_TYPE:
|
|
|
|
*(const struct m_option **)arg = opt;
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_GET:
|
|
|
|
m_option_copy(opt, arg, valptr);
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_SET:
|
|
|
|
m_option_copy(opt, valptr, arg);
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
if (opt->type == &m_option_type_choice) {
|
|
|
|
int v = *(int *) valptr;
|
|
|
|
int best = v;
|
|
|
|
struct m_opt_choice_alternatives *alt;
|
|
|
|
for (alt = opt->priv; alt->name; alt++)
|
|
|
|
if ((unsigned) alt->value - v - 1 < (unsigned) best - v - 1)
|
|
|
|
best = alt->value;
|
|
|
|
*(int *) valptr = best;
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// OSD level (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_osdlevel(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2009-03-30 01:06:58 +02:00
|
|
|
return m_property_choice(prop, action, arg, &mpctx->opts.osd_level);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2007-07-09 16:52:46 +02:00
|
|
|
/// Loop (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_loop(m_option_t *prop, int action, void *arg,
|
|
|
|
MPContext *mpctx)
|
2007-07-09 16:52:46 +02:00
|
|
|
{
|
2008-04-21 04:18:40 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2007-07-09 16:52:46 +02:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_PRINT:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2008-04-21 04:18:40 +02:00
|
|
|
if (opts->loop_times < 0)
|
2011-08-07 03:45:40 +02:00
|
|
|
*(char **)arg = talloc_strdup(NULL, "off");
|
2008-04-21 04:18:40 +02:00
|
|
|
else if (opts->loop_times == 0)
|
2011-08-07 03:45:40 +02:00
|
|
|
*(char **)arg = talloc_strdup(NULL, "inf");
|
2007-07-09 16:52:46 +02:00
|
|
|
else
|
|
|
|
break;
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
2008-04-21 04:18:40 +02:00
|
|
|
return m_property_int_range(prop, action, arg, &opts->loop_times);
|
2007-07-09 16:52:46 +02:00
|
|
|
}
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Playback speed (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_playback_speed(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2008-04-21 05:55:23 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2011-12-06 01:46:37 +01:00
|
|
|
double orig_speed = opts->playback_speed;
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2010-05-07 21:02:47 +02:00
|
|
|
opts->playback_speed = *(float *) arg;
|
2011-12-06 01:46:37 +01:00
|
|
|
goto set;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-07 21:02:47 +02:00
|
|
|
opts->playback_speed += (arg ? *(float *) arg : 0.1) *
|
2011-08-07 03:45:40 +02:00
|
|
|
(action == M_PROPERTY_STEP_DOWN ? -1 : 1);
|
2011-12-06 01:46:37 +01:00
|
|
|
set:
|
2010-05-07 21:02:47 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, opts->playback_speed);
|
2011-12-06 01:46:37 +01:00
|
|
|
// Adjust time until next frame flip for nosound mode
|
|
|
|
mpctx->time_frame *= orig_speed / opts->playback_speed;
|
2010-11-26 21:52:35 +01:00
|
|
|
reinit_audio_chain(mpctx);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
2008-04-21 05:55:23 +02:00
|
|
|
return m_property_float_range(prop, action, arg, &opts->playback_speed);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// filename with path (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_path(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2008-04-26 14:17:51 +02:00
|
|
|
return m_property_string_ro(prop, action, arg, mpctx->filename);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// filename without path (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_filename(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
char *f;
|
2008-04-26 14:17:51 +02:00
|
|
|
if (!mpctx->filename)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2010-12-04 11:24:42 +01:00
|
|
|
f = (char *)mp_basename(mpctx->filename);
|
|
|
|
if (!*f)
|
2008-04-26 14:17:51 +02:00
|
|
|
f = mpctx->filename;
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_string_ro(prop, action, arg, f);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Demuxer name (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_demuxer(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->demuxer)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_string_ro(prop, action, arg,
|
2010-05-04 01:34:38 +02:00
|
|
|
(char *) mpctx->demuxer->desc->name);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Position in the stream (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_stream_pos(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->demuxer || !mpctx->demuxer->stream)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
if (!arg)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_ERROR;
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
*(off_t *) arg = stream_tell(mpctx->demuxer->stream);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, *(off_t *) arg);
|
|
|
|
stream_seek(mpctx->demuxer->stream, *(off_t *) arg);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Stream start offset (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_stream_start(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->demuxer || !mpctx->demuxer->stream)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
*(off_t *) arg = mpctx->demuxer->stream->start_pos;
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Stream end offset (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_stream_end(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->demuxer || !mpctx->demuxer->stream)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
*(off_t *) arg = mpctx->demuxer->stream->end_pos;
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Stream length (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_stream_length(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->demuxer || !mpctx->demuxer->stream)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
*(off_t *) arg =
|
|
|
|
mpctx->demuxer->stream->end_pos - mpctx->demuxer->stream->start_pos;
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
2010-07-25 11:06:37 +02:00
|
|
|
/// Current stream position in seconds (RO)
|
|
|
|
static int mp_property_stream_time_pos(m_option_t *prop, int action,
|
|
|
|
void *arg, MPContext *mpctx)
|
|
|
|
{
|
|
|
|
if (!mpctx->demuxer || mpctx->demuxer->stream_pts == MP_NOPTS_VALUE)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
|
|
|
return m_property_time_ro(prop, action, arg, mpctx->demuxer->stream_pts);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Media length in seconds (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_length(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
double len;
|
|
|
|
|
|
|
|
if (!mpctx->demuxer ||
|
2010-11-07 23:54:32 +01:00
|
|
|
!(int) (len = get_time_length(mpctx)))
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2007-05-31 14:42:02 +02:00
|
|
|
return m_property_time_ro(prop, action, arg, len);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2007-05-31 15:07:52 +02:00
|
|
|
/// Current position in percent (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_percent_pos(m_option_t *prop, int action,
|
2011-08-07 03:45:40 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
|
|
|
{
|
2007-05-31 15:07:52 +02:00
|
|
|
int pos;
|
|
|
|
|
|
|
|
if (!mpctx->demuxer)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-05-31 15:07:52 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
switch (action) {
|
2007-05-31 15:07:52 +02:00
|
|
|
case M_PROPERTY_SET:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(int *)arg);
|
|
|
|
pos = *(int *)arg;
|
2007-05-31 15:07:52 +02:00
|
|
|
break;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-11-07 23:54:32 +01:00
|
|
|
pos = get_percent_pos(mpctx);
|
2011-08-07 03:45:40 +02:00
|
|
|
pos += (arg ? *(int *)arg : 10) *
|
|
|
|
(action == M_PROPERTY_STEP_UP ? 1 : -1);
|
2007-05-31 15:07:52 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, pos);
|
|
|
|
break;
|
|
|
|
default:
|
2010-11-07 23:54:32 +01:00
|
|
|
return m_property_int_ro(prop, action, arg, get_percent_pos(mpctx));
|
2007-05-31 15:07:52 +02:00
|
|
|
}
|
|
|
|
|
2010-12-18 09:13:45 +01:00
|
|
|
queue_seek(mpctx, MPSEEK_FACTOR, pos / 100.0, 0);
|
2007-05-31 15:07:52 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Current position in seconds (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_time_pos(m_option_t *prop, int action,
|
2011-08-07 03:45:40 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
|
|
|
{
|
2011-04-09 02:03:22 +02:00
|
|
|
if (!(mpctx->sh_video || mpctx->sh_audio))
|
2007-05-31 15:07:52 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
switch (action) {
|
2007-05-31 15:07:52 +02:00
|
|
|
case M_PROPERTY_SET:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(double *)arg);
|
|
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, *(double *)arg, 0);
|
2007-05-31 15:07:52 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2011-08-07 03:45:40 +02:00
|
|
|
queue_seek(mpctx, MPSEEK_RELATIVE, (arg ? *(double *)arg : 10.0) *
|
2010-12-18 09:13:45 +01:00
|
|
|
(action == M_PROPERTY_STEP_UP ? 1.0 : -1.0), 0);
|
2007-05-31 15:07:52 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
2010-11-07 23:54:32 +01:00
|
|
|
return m_property_time_ro(prop, action, arg, get_current_time(mpctx));
|
2007-05-31 15:07:52 +02:00
|
|
|
}
|
|
|
|
|
2007-12-14 09:33:11 +01:00
|
|
|
/// Current chapter (RW)
|
|
|
|
static int mp_property_chapter(m_option_t *prop, int action, void *arg,
|
|
|
|
MPContext *mpctx)
|
|
|
|
{
|
2009-03-30 01:06:58 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2008-08-04 15:35:14 +02:00
|
|
|
int chapter = -1;
|
2007-12-14 09:33:11 +01:00
|
|
|
int step_all;
|
|
|
|
char *chapter_name = NULL;
|
|
|
|
|
2008-08-04 15:35:14 +02:00
|
|
|
if (mpctx->demuxer)
|
2009-04-02 04:00:22 +02:00
|
|
|
chapter = get_current_chapter(mpctx);
|
2010-04-24 19:46:54 +02:00
|
|
|
if (chapter < -1)
|
2007-12-22 07:20:48 +01:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
2007-12-14 09:33:11 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-12-17 04:42:54 +01:00
|
|
|
*(int *) arg = chapter;
|
2007-12-14 09:33:11 +01:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_PRINT: {
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2009-04-02 04:00:22 +02:00
|
|
|
chapter_name = chapter_display_name(mpctx, chapter);
|
2007-12-14 09:33:11 +01:00
|
|
|
if (!chapter_name)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
*(char **) arg = chapter_name;
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
case M_PROPERTY_SET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2011-08-07 03:45:40 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, *(int *)arg);
|
2009-06-28 15:17:42 +02:00
|
|
|
step_all = *(int *)arg - chapter;
|
2007-12-14 09:33:11 +01:00
|
|
|
chapter += step_all;
|
|
|
|
break;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN: {
|
2011-08-07 03:45:40 +02:00
|
|
|
step_all = (arg && *(int *)arg != 0 ? *(int *)arg : 1)
|
2007-12-14 09:33:11 +01:00
|
|
|
* (action == M_PROPERTY_STEP_UP ? 1 : -1);
|
|
|
|
chapter += step_all;
|
|
|
|
if (chapter < 0)
|
|
|
|
chapter = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
2009-04-01 18:55:26 +02:00
|
|
|
|
|
|
|
double next_pts = 0;
|
2010-12-18 09:13:45 +01:00
|
|
|
queue_seek(mpctx, MPSEEK_NONE, 0, 0);
|
2011-10-23 04:51:44 +02:00
|
|
|
chapter = seek_chapter(mpctx, chapter, &next_pts);
|
2007-12-14 09:33:11 +01:00
|
|
|
if (chapter >= 0) {
|
2010-12-18 09:13:45 +01:00
|
|
|
if (next_pts > -1.0)
|
|
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, next_pts, 0);
|
2011-10-23 04:51:44 +02:00
|
|
|
chapter_name = chapter_display_name(mpctx, chapter);
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, OSD_MSG_TEXT, 1, opts->osd_duration,
|
2011-10-23 04:51:44 +02:00
|
|
|
"Chapter: %s", chapter_name);
|
2010-12-18 09:13:45 +01:00
|
|
|
} else if (step_all > 0)
|
2012-08-07 03:00:06 +02:00
|
|
|
mpctx->stop_play = PT_NEXT_ENTRY;
|
2007-12-14 09:33:11 +01:00
|
|
|
else
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, OSD_MSG_TEXT, 1, opts->osd_duration,
|
2010-01-12 11:17:41 +01:00
|
|
|
"Chapter: (%d) %s", 0, mp_gtext("unknown"));
|
2010-11-07 13:47:40 +01:00
|
|
|
talloc_free(chapter_name);
|
2007-12-14 09:33:11 +01:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
|
2011-12-31 13:20:08 +01:00
|
|
|
/// Number of titles in file
|
|
|
|
static int mp_property_titles(m_option_t *prop, int action, void *arg,
|
|
|
|
MPContext *mpctx)
|
|
|
|
{
|
|
|
|
if (!mpctx->demuxer)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
if (mpctx->demuxer->num_titles == 0)
|
|
|
|
stream_control(mpctx->demuxer->stream, STREAM_CTRL_GET_NUM_TITLES, &mpctx->demuxer->num_titles);
|
|
|
|
return m_property_int_ro(prop, action, arg, mpctx->demuxer->num_titles);
|
|
|
|
}
|
|
|
|
|
2008-09-26 23:17:01 +02:00
|
|
|
/// Number of chapters in file
|
|
|
|
static int mp_property_chapters(m_option_t *prop, int action, void *arg,
|
2011-08-07 03:45:40 +02:00
|
|
|
MPContext *mpctx)
|
2008-09-26 23:17:01 +02:00
|
|
|
{
|
|
|
|
if (!mpctx->demuxer)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2011-10-23 04:51:44 +02:00
|
|
|
int count = get_chapter_count(mpctx);
|
|
|
|
return m_property_int_ro(prop, action, arg, count);
|
2008-09-26 23:17:01 +02:00
|
|
|
}
|
|
|
|
|
2008-01-05 15:32:39 +01:00
|
|
|
/// Current dvd angle (RW)
|
|
|
|
static int mp_property_angle(m_option_t *prop, int action, void *arg,
|
2011-08-07 03:45:40 +02:00
|
|
|
MPContext *mpctx)
|
2008-01-05 15:32:39 +01:00
|
|
|
{
|
2009-03-30 01:06:58 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2008-08-04 15:33:22 +02:00
|
|
|
int angle = -1;
|
2008-01-05 15:32:39 +01:00
|
|
|
int angles;
|
|
|
|
|
2008-08-04 15:33:22 +02:00
|
|
|
if (mpctx->demuxer)
|
2008-08-04 15:34:10 +02:00
|
|
|
angle = demuxer_get_current_angle(mpctx->demuxer);
|
2008-01-05 15:32:39 +01:00
|
|
|
if (angle < 0)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
angles = demuxer_angles_count(mpctx->demuxer);
|
|
|
|
if (angles <= 1)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(int *) arg = angle;
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_PRINT: {
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_asprintf(NULL, "%d/%d", angle, angles);
|
2008-01-05 15:32:39 +01:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
case M_PROPERTY_SET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
angle = *(int *)arg;
|
|
|
|
M_PROPERTY_CLAMP(prop, angle);
|
|
|
|
break;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN: {
|
|
|
|
int step = 0;
|
2011-08-07 03:45:40 +02:00
|
|
|
if (arg)
|
|
|
|
step = *(int *)arg;
|
|
|
|
if (!step)
|
2008-01-05 15:32:39 +01:00
|
|
|
step = 1;
|
|
|
|
step *= (action == M_PROPERTY_STEP_UP ? 1 : -1);
|
|
|
|
angle += step;
|
|
|
|
if (angle < 1) //cycle
|
|
|
|
angle = angles;
|
2011-04-23 18:48:36 +02:00
|
|
|
else if (angle > angles)
|
|
|
|
angle = 1;
|
2008-01-05 15:32:39 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
angle = demuxer_set_angle(mpctx->demuxer, angle);
|
2010-04-23 19:14:59 +02:00
|
|
|
if (angle >= 0) {
|
|
|
|
struct sh_video *sh_video = mpctx->demuxer->video->sh;
|
|
|
|
if (sh_video)
|
|
|
|
resync_video_stream(sh_video);
|
|
|
|
|
|
|
|
struct sh_audio *sh_audio = mpctx->demuxer->audio->sh;
|
|
|
|
if (sh_audio)
|
|
|
|
resync_audio_stream(sh_audio);
|
|
|
|
}
|
|
|
|
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, OSD_MSG_TEXT, 1, opts->osd_duration,
|
2010-01-12 11:17:41 +01:00
|
|
|
"Angle: %d/%d", angle, angles);
|
2008-01-05 15:32:39 +01:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
|
2007-05-30 00:14:41 +02:00
|
|
|
/// Demuxer meta data
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_metadata(m_option_t *prop, int action, void *arg,
|
2011-08-07 03:45:40 +02:00
|
|
|
MPContext *mpctx)
|
|
|
|
{
|
|
|
|
m_property_action_t *ka;
|
|
|
|
char *meta;
|
2008-04-26 15:35:40 +02:00
|
|
|
static const m_option_t key_type =
|
2011-08-07 03:45:40 +02:00
|
|
|
{
|
|
|
|
"metadata", NULL, CONF_TYPE_STRING, 0, 0, 0, NULL
|
|
|
|
};
|
2007-05-30 00:14:41 +02:00
|
|
|
if (!mpctx->demuxer)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-05-30 00:14:41 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
switch (action) {
|
2007-05-30 00:14:41 +02:00
|
|
|
case M_PROPERTY_GET:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(char ***)arg = mpctx->demuxer->info;
|
2007-05-30 00:14:41 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_KEY_ACTION:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-05-30 00:14:41 +02:00
|
|
|
ka = arg;
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!(meta = demux_info_get(mpctx->demuxer, ka->key)))
|
2007-05-30 00:14:41 +02:00
|
|
|
return M_PROPERTY_UNKNOWN;
|
2011-08-07 03:45:40 +02:00
|
|
|
switch (ka->action) {
|
2007-05-30 00:14:41 +02:00
|
|
|
case M_PROPERTY_GET:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!ka->arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(char **)ka->arg = meta;
|
2007-05-30 00:14:41 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_GET_TYPE:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!ka->arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(const m_option_t **)ka->arg = &key_type;
|
2007-05-30 00:14:41 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
2008-11-29 07:09:57 +01:00
|
|
|
static int mp_property_pause(m_option_t *prop, int action, void *arg,
|
|
|
|
void *ctx)
|
2008-10-01 19:05:30 +02:00
|
|
|
{
|
2008-11-29 07:09:57 +01:00
|
|
|
MPContext *mpctx = ctx;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-07 21:02:47 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2011-08-07 03:45:40 +02:00
|
|
|
if (mpctx->paused == (bool) * (int *)arg)
|
2010-05-07 21:02:47 +02:00
|
|
|
return M_PROPERTY_OK;
|
2008-11-29 07:09:57 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2008-12-01 18:53:57 +01:00
|
|
|
if (mpctx->paused) {
|
2008-11-29 07:09:57 +01:00
|
|
|
unpause_player(mpctx);
|
2011-08-07 03:45:40 +02:00
|
|
|
} else {
|
2008-11-29 07:09:57 +01:00
|
|
|
pause_player(mpctx);
|
2008-12-01 18:53:57 +01:00
|
|
|
}
|
2010-05-07 21:02:47 +02:00
|
|
|
return M_PROPERTY_OK;
|
2008-11-29 07:09:57 +01:00
|
|
|
default:
|
2010-05-07 21:02:47 +02:00
|
|
|
return m_property_flag(prop, action, arg, &mpctx->paused);
|
2008-11-29 07:09:57 +01:00
|
|
|
}
|
2008-10-01 19:05:30 +02:00
|
|
|
}
|
|
|
|
|
2007-05-30 00:14:41 +02:00
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Volume (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_volume(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
if (!mpctx->sh_audio)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
mixer_getbothvolume(&mpctx->mixer, arg);
|
|
|
|
return M_PROPERTY_OK;
|
2011-08-07 03:45:40 +02:00
|
|
|
case M_PROPERTY_PRINT: {
|
|
|
|
float vol;
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
mixer_getbothvolume(&mpctx->mixer, &vol);
|
|
|
|
return m_property_float_range(prop, action, arg, &vol);
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(float *) arg);
|
|
|
|
mixer_setvolume(&mpctx->mixer, *(float *) arg, *(float *) arg);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (arg && *(float *) arg <= 0)
|
|
|
|
mixer_decvolume(&mpctx->mixer);
|
|
|
|
else
|
|
|
|
mixer_incvolume(&mpctx->mixer);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (arg && *(float *) arg <= 0)
|
|
|
|
mixer_incvolume(&mpctx->mixer);
|
|
|
|
else
|
|
|
|
mixer_decvolume(&mpctx->mixer);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Mute (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_mute(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
if (!mpctx->sh_audio)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2012-04-09 16:39:01 +02:00
|
|
|
mixer_setmute(&mpctx->mixer, *(int *) arg);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2012-04-09 16:39:01 +02:00
|
|
|
mixer_setmute(&mpctx->mixer, !mixer_getmute(&mpctx->mixer));
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2012-01-07 18:06:30 +01:00
|
|
|
return m_property_flag_ro(prop, action, arg,
|
2012-04-09 16:39:01 +02:00
|
|
|
mixer_getmute(&mpctx->mixer));
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Audio delay (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_audio_delay(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!(mpctx->sh_audio && mpctx->sh_video))
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
|
|
|
case M_PROPERTY_STEP_UP:
|
2008-01-05 02:40:36 +01:00
|
|
|
case M_PROPERTY_STEP_DOWN: {
|
2011-08-07 03:45:40 +02:00
|
|
|
int ret;
|
|
|
|
float delay = audio_delay;
|
|
|
|
ret = m_property_delay(prop, action, arg, &audio_delay);
|
|
|
|
if (ret != M_PROPERTY_OK)
|
|
|
|
return ret;
|
|
|
|
if (mpctx->sh_audio)
|
|
|
|
mpctx->delay -= audio_delay - delay;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_delay(prop, action, arg, &audio_delay);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Audio codec tag (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_audio_format(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_audio)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_int_ro(prop, action, arg, mpctx->sh_audio->format);
|
|
|
|
}
|
|
|
|
|
2007-05-30 00:14:41 +02:00
|
|
|
/// Audio codec name (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_audio_codec(m_option_t *prop, int action,
|
|
|
|
void *arg, MPContext *mpctx)
|
2007-05-30 00:14:41 +02:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_audio || !mpctx->sh_audio->codec)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2011-08-07 03:45:40 +02:00
|
|
|
return m_property_string_ro(prop, action, arg,
|
|
|
|
mpctx->sh_audio->codec->name);
|
2007-05-30 00:14:41 +02:00
|
|
|
}
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Audio bitrate (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_audio_bitrate(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_audio)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-05-30 00:14:41 +02:00
|
|
|
return m_property_bitrate(prop, action, arg, mpctx->sh_audio->i_bps);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Samplerate (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_samplerate(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_audio)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2011-08-07 03:45:40 +02:00
|
|
|
switch (action) {
|
2007-05-30 08:53:06 +02:00
|
|
|
case M_PROPERTY_PRINT:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(char **)arg = talloc_asprintf(NULL, "%d kHz",
|
|
|
|
mpctx->sh_audio->samplerate / 1000);
|
2007-05-30 08:53:06 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_int_ro(prop, action, arg, mpctx->sh_audio->samplerate);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Number of channels (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_channels(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_audio)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_PRINT:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
switch (mpctx->sh_audio->channels) {
|
|
|
|
case 1:
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_strdup(NULL, "mono");
|
2010-05-04 01:34:38 +02:00
|
|
|
break;
|
|
|
|
case 2:
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_strdup(NULL, "stereo");
|
2010-05-04 01:34:38 +02:00
|
|
|
break;
|
|
|
|
default:
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_asprintf(NULL, "%d channels",
|
|
|
|
mpctx->sh_audio->channels);
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
return m_property_int_ro(prop, action, arg, mpctx->sh_audio->channels);
|
|
|
|
}
|
|
|
|
|
2007-06-20 04:26:20 +02:00
|
|
|
/// Balance (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_balance(m_option_t *prop, int action, void *arg,
|
2011-08-07 03:45:40 +02:00
|
|
|
MPContext *mpctx)
|
2007-06-20 04:26:20 +02:00
|
|
|
{
|
|
|
|
float bal;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
mixer_getbalance(&mpctx->mixer, arg);
|
|
|
|
return M_PROPERTY_OK;
|
2007-06-20 04:26:20 +02:00
|
|
|
case M_PROPERTY_PRINT: {
|
2011-08-07 03:45:40 +02:00
|
|
|
char **str = arg;
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
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);
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
2007-06-20 04:26:20 +02:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
mixer_getbalance(&mpctx->mixer, &bal);
|
2011-08-07 03:45:40 +02:00
|
|
|
bal += (arg ? *(float *)arg : .1f) *
|
|
|
|
(action == M_PROPERTY_STEP_UP ? 1.f : -1.f);
|
2010-05-04 01:34:38 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, bal);
|
|
|
|
mixer_setbalance(&mpctx->mixer, bal);
|
|
|
|
return M_PROPERTY_OK;
|
2007-06-20 04:26:20 +02:00
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2011-08-07 03:45:40 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, *(float *)arg);
|
|
|
|
mixer_setbalance(&mpctx->mixer, *(float *)arg);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-06-20 04:26:20 +02:00
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Selected audio id (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_audio(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2009-12-27 15:13:06 +01:00
|
|
|
int current_id, tmp;
|
2010-11-08 01:38:51 +01:00
|
|
|
if (!mpctx->demuxer || !mpctx->d_audio)
|
2009-12-27 15:06:47 +01:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2011-07-03 19:41:46 +02:00
|
|
|
struct sh_audio *sh = mpctx->sh_audio;
|
|
|
|
current_id = sh ? sh->aid : -2;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(int *) arg = current_id;
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_PRINT:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2012-02-19 14:15:41 +01:00
|
|
|
if (!sh || current_id < 0)
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_strdup(NULL, mp_gtext("disabled"));
|
2012-02-19 14:15:41 +01:00
|
|
|
else {
|
2012-08-03 12:24:55 +02:00
|
|
|
char *lang = demuxer_stream_lang(mpctx->demuxer, sh->gsh);
|
2012-02-19 14:15:41 +01:00
|
|
|
if (!lang)
|
|
|
|
lang = talloc_strdup(NULL, mp_gtext("unknown"));
|
|
|
|
|
2012-08-03 12:24:55 +02:00
|
|
|
if (sh->gsh->title)
|
2011-07-03 19:41:46 +02:00
|
|
|
*(char **)arg = talloc_asprintf(NULL, "(%d) %s (\"%s\")",
|
2012-08-03 12:24:55 +02:00
|
|
|
current_id, lang, sh->gsh->title);
|
2011-07-03 19:41:46 +02:00
|
|
|
else
|
|
|
|
*(char **)arg = talloc_asprintf(NULL, "(%d) %s", current_id,
|
|
|
|
lang);
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2012-02-19 14:15:41 +01:00
|
|
|
talloc_free(lang);
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (action == M_PROPERTY_SET && arg)
|
|
|
|
tmp = *((int *) arg);
|
|
|
|
else
|
|
|
|
tmp = -1;
|
2010-11-08 01:38:51 +01:00
|
|
|
int new_id = demuxer_switch_audio(mpctx->d_audio->demuxer, tmp);
|
2010-05-22 07:19:23 +02:00
|
|
|
if (new_id != current_id)
|
2010-05-07 21:02:47 +02:00
|
|
|
uninit_player(mpctx, INITIALIZED_AO | INITIALIZED_ACODEC);
|
2010-05-22 07:19:23 +02:00
|
|
|
if (new_id != current_id && new_id >= 0) {
|
2012-08-03 10:33:11 +02:00
|
|
|
mpctx->opts.audio_id = new_id;
|
2010-05-04 01:34:38 +02:00
|
|
|
sh_audio_t *sh2;
|
2011-03-30 22:22:45 +02:00
|
|
|
sh2 = mpctx->d_audio->demuxer->a_streams[mpctx->d_audio->id];
|
|
|
|
sh2->ds = mpctx->d_audio;
|
2010-05-22 07:19:23 +02:00
|
|
|
mpctx->sh_audio = sh2;
|
|
|
|
reinit_audio_chain(mpctx);
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2010-05-22 07:19:23 +02:00
|
|
|
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_TRACK=%d\n", new_id);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Selected video id (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_video(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2008-04-23 06:01:31 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2009-12-27 15:13:06 +01:00
|
|
|
int current_id, tmp;
|
2010-11-08 01:38:51 +01:00
|
|
|
if (!mpctx->demuxer || !mpctx->d_video)
|
2009-12-27 15:06:47 +01:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2011-03-30 22:22:45 +02:00
|
|
|
current_id = mpctx->sh_video ? mpctx->sh_video->vid : -2;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(int *) arg = current_id;
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_PRINT:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2010-05-04 01:34:38 +02:00
|
|
|
if (current_id < 0)
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_strdup(NULL, mp_gtext("disabled"));
|
2010-05-04 01:34:38 +02:00
|
|
|
else {
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_asprintf(NULL, "(%d) %s", current_id,
|
|
|
|
mp_gtext("unknown"));
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (action == M_PROPERTY_SET && arg)
|
|
|
|
tmp = *((int *) arg);
|
|
|
|
else
|
|
|
|
tmp = -1;
|
2011-03-30 22:22:45 +02:00
|
|
|
int new_id = demuxer_switch_video(mpctx->d_video->demuxer, tmp);
|
|
|
|
if (new_id != current_id)
|
2010-05-07 21:02:47 +02:00
|
|
|
uninit_player(mpctx, INITIALIZED_VCODEC |
|
2011-03-30 22:22:45 +02:00
|
|
|
(opts->fixed_vo && new_id >= 0 ? 0 : INITIALIZED_VO));
|
|
|
|
if (new_id != current_id && new_id >= 0) {
|
2010-05-04 01:34:38 +02:00
|
|
|
sh_video_t *sh2;
|
2010-11-08 01:38:51 +01:00
|
|
|
sh2 = mpctx->d_video->demuxer->v_streams[mpctx->d_video->id];
|
2011-03-30 22:22:45 +02:00
|
|
|
sh2->ds = mpctx->d_video;
|
|
|
|
mpctx->sh_video = sh2;
|
|
|
|
reinit_video_chain(mpctx);
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-03-30 22:22:45 +02:00
|
|
|
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_TRACK=%d\n", new_id);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_program(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
demux_program_t prog;
|
|
|
|
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (!mpctx->demuxer)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (action == M_PROPERTY_SET && arg)
|
|
|
|
prog.progid = *((int *) arg);
|
|
|
|
else
|
|
|
|
prog.progid = -1;
|
2011-08-07 03:45:40 +02:00
|
|
|
if (demux_control(mpctx->demuxer, DEMUXER_CTRL_IDENTIFY_PROGRAM,
|
|
|
|
&prog) == DEMUXER_CTRL_NOTIMPL)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
|
|
|
|
if (prog.aid < 0 && prog.vid < 0) {
|
2011-08-07 03:45:40 +02:00
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_ERR,
|
|
|
|
"Selected program contains no audio or video streams!\n");
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
}
|
|
|
|
mp_property_do("switch_audio", M_PROPERTY_SET, &prog.aid, mpctx);
|
|
|
|
mp_property_do("switch_video", M_PROPERTY_SET, &prog.vid, mpctx);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Fullscreen state (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_fullscreen(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
if (!mpctx->video_out)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(int *) arg);
|
|
|
|
if (vo_fs == !!*(int *) arg)
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-07 21:02:47 +02:00
|
|
|
if (mpctx->video_out->config_ok)
|
|
|
|
vo_control(mpctx->video_out, VOCTRL_FULLSCREEN, 0);
|
2009-03-20 01:56:49 +01:00
|
|
|
mpctx->opts.fullscreen = vo_fs;
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_flag(prop, action, arg, &vo_fs);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_deinterlace(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
int deinterlace;
|
|
|
|
vf_instance_t *vf;
|
|
|
|
if (!mpctx->sh_video || !mpctx->sh_video->vfilter)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
vf = mpctx->sh_video->vfilter;
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
vf->control(vf, VFCTRL_GET_DEINTERLACE, arg);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(int *) arg);
|
|
|
|
vf->control(vf, VFCTRL_SET_DEINTERLACE, arg);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
vf->control(vf, VFCTRL_GET_DEINTERLACE, &deinterlace);
|
|
|
|
deinterlace = !deinterlace;
|
|
|
|
vf->control(vf, VFCTRL_SET_DEINTERLACE, &deinterlace);
|
2010-05-07 21:02:47 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
2009-09-19 04:11:39 +02:00
|
|
|
int value = 0;
|
|
|
|
vf->control(vf, VFCTRL_GET_DEINTERLACE, &value);
|
|
|
|
return m_property_flag_ro(prop, action, arg, value);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
static int colormatrix_property_helper(m_option_t *prop, int action,
|
2011-08-07 03:45:40 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2009-11-15 14:21:40 +01:00
|
|
|
{
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
int r = mp_property_generic_option(prop, action, arg, mpctx);
|
|
|
|
// testing for an actual change is too much effort
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
|
|
|
if (mpctx->sh_video)
|
|
|
|
set_video_colorspace(mpctx->sh_video);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
2009-11-15 14:21:40 +01:00
|
|
|
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
static int mp_property_colormatrix(m_option_t *prop, int action, void *arg,
|
|
|
|
MPContext *mpctx)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2009-11-15 14:21:40 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_PRINT:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
struct mp_csp_details actual = { .format = -1 };
|
|
|
|
char *req_csp = mp_csp_names[opts->requested_colorspace];
|
|
|
|
char *real_csp = NULL;
|
|
|
|
if (mpctx->sh_video) {
|
|
|
|
struct vf_instance *vf = mpctx->sh_video->vfilter;
|
|
|
|
if (vf->control(vf, VFCTRL_GET_YUV_COLORSPACE, &actual) == true) {
|
|
|
|
real_csp = mp_csp_names[actual.format];
|
|
|
|
} else {
|
|
|
|
real_csp = "Unknown";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
char *res;
|
|
|
|
if (opts->requested_colorspace == MP_CSP_AUTO && real_csp) {
|
|
|
|
// Caveat: doesn't handle the case when the autodetected colorspace
|
|
|
|
// is different from the actual colorspace as used by the
|
|
|
|
// VO - the OSD will display the VO colorspace without
|
|
|
|
// indication that it doesn't match the requested colorspace.
|
|
|
|
res = talloc_asprintf(NULL, "Auto (%s)", real_csp);
|
|
|
|
} else if (opts->requested_colorspace == actual.format || !real_csp) {
|
|
|
|
res = talloc_strdup(NULL, req_csp);
|
|
|
|
} else
|
|
|
|
res = talloc_asprintf(NULL, mp_gtext("%s, but %s used"),
|
|
|
|
req_csp, real_csp);
|
|
|
|
*(char **)arg = res;
|
2009-11-15 14:21:40 +01:00
|
|
|
return M_PROPERTY_OK;
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
default:;
|
|
|
|
return colormatrix_property_helper(prop, action, arg, mpctx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int levels_property_helper(int offset, m_option_t *prop, int action,
|
|
|
|
void *arg, MPContext *mpctx)
|
|
|
|
{
|
|
|
|
char *optname = prop->priv;
|
|
|
|
const struct m_option *opt = m_config_get_option(mpctx->mconfig,
|
2012-07-28 23:47:42 +02:00
|
|
|
bstr0(optname));
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
int *valptr = (int *)m_option_get_ptr(opt, &mpctx->opts);
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_PRINT:
|
2010-05-07 21:02:47 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
struct mp_csp_details actual = {0};
|
|
|
|
int actual_level = -1;
|
|
|
|
char *req_level = m_option_print(opt, valptr);
|
|
|
|
char *real_level = NULL;
|
|
|
|
if (mpctx->sh_video) {
|
|
|
|
struct vf_instance *vf = mpctx->sh_video->vfilter;
|
|
|
|
if (vf->control(vf, VFCTRL_GET_YUV_COLORSPACE, &actual) == true) {
|
|
|
|
actual_level = *(enum mp_csp_levels *)(((char *)&actual) + offset);
|
|
|
|
real_level = m_option_print(opt, &actual_level);
|
|
|
|
} else {
|
|
|
|
real_level = talloc_strdup(NULL, "Unknown");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
char *res;
|
|
|
|
if (*valptr == MP_CSP_LEVELS_AUTO && real_level) {
|
|
|
|
res = talloc_asprintf(NULL, "Auto (%s)", real_level);
|
|
|
|
} else if (*valptr == actual_level || !real_level) {
|
|
|
|
res = talloc_strdup(NULL, real_level);
|
|
|
|
} else
|
|
|
|
res = talloc_asprintf(NULL, mp_gtext("%s, but %s used"),
|
|
|
|
req_level, real_level);
|
|
|
|
talloc_free(req_level);
|
|
|
|
talloc_free(real_level);
|
|
|
|
*(char **)arg = res;
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
default:;
|
|
|
|
return colormatrix_property_helper(prop, action, arg, mpctx);
|
2009-11-15 14:21:40 +01:00
|
|
|
}
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mp_property_colormatrix_input_range(m_option_t *prop, int action,
|
|
|
|
void *arg, MPContext *mpctx)
|
|
|
|
{
|
|
|
|
return levels_property_helper(offsetof(struct mp_csp_details, levels_in),
|
|
|
|
prop, action, arg, mpctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mp_property_colormatrix_output_range(m_option_t *prop, int action,
|
|
|
|
void *arg, MPContext *mpctx)
|
|
|
|
{
|
|
|
|
return levels_property_helper(offsetof(struct mp_csp_details, levels_out),
|
|
|
|
prop, action, arg, mpctx);
|
2009-11-15 14:21:40 +01:00
|
|
|
}
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Panscan (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_panscan(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
if (!mpctx->video_out
|
2010-05-07 21:02:47 +02:00
|
|
|
|| vo_control(mpctx->video_out, VOCTRL_GET_PANSCAN, NULL) != VO_TRUE)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(float *) arg);
|
|
|
|
vo_panscan = *(float *) arg;
|
2010-05-07 21:02:47 +02:00
|
|
|
vo_control(mpctx->video_out, VOCTRL_SET_PANSCAN, NULL);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
vo_panscan += (arg ? *(float *) arg : 0.1) *
|
2011-08-07 03:45:40 +02:00
|
|
|
(action == M_PROPERTY_STEP_DOWN ? -1 : 1);
|
2010-05-04 01:34:38 +02:00
|
|
|
if (vo_panscan > 1)
|
|
|
|
vo_panscan = 1;
|
|
|
|
else if (vo_panscan < 0)
|
|
|
|
vo_panscan = 0;
|
2010-05-07 21:02:47 +02:00
|
|
|
vo_control(mpctx->video_out, VOCTRL_SET_PANSCAN, NULL);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_float_range(prop, action, arg, &vo_panscan);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Helper to set vo flags.
|
|
|
|
/** \ingroup PropertyImplHelper
|
|
|
|
*/
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_vo_flag(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
int vo_ctrl, int *vo_var, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
if (!mpctx->video_out)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(int *) arg);
|
|
|
|
if (*vo_var == !!*(int *) arg)
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-07 21:02:47 +02:00
|
|
|
if (mpctx->video_out->config_ok)
|
|
|
|
vo_control(mpctx->video_out, vo_ctrl, 0);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_flag(prop, action, arg, vo_var);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Window always on top (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_ontop(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2008-04-19 06:45:16 +02:00
|
|
|
return mp_property_vo_flag(prop, action, arg, VOCTRL_ONTOP,
|
|
|
|
&mpctx->opts.vo_ontop, mpctx);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Display in the root window (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_rootwin(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
return mp_property_vo_flag(prop, action, arg, VOCTRL_ROOTWIN,
|
2010-05-04 01:34:38 +02:00
|
|
|
&vo_rootwin, mpctx);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Show window borders (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_border(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
return mp_property_vo_flag(prop, action, arg, VOCTRL_BORDER,
|
2010-05-04 01:34:38 +02:00
|
|
|
&vo_border, mpctx);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Framedropping state (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_framedropping(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_PRINT:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2011-08-07 03:45:40 +02:00
|
|
|
*(char **) arg = talloc_strdup(NULL, frame_dropping == 1 ?
|
|
|
|
mp_gtext("enabled") :
|
|
|
|
(frame_dropping == 2 ? mp_gtext("hard") :
|
|
|
|
mp_gtext("disabled")));
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_choice(prop, action, arg, &frame_dropping);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Color settings, try to use vf/vo then fall back on TV. (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_gamma(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2010-11-01 21:45:46 +01:00
|
|
|
int *gamma = (int *)((char *)&mpctx->opts + prop->offset);
|
2008-04-25 06:12:05 +02:00
|
|
|
int r, val;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
if (gamma[0] == 1000) {
|
2010-05-04 01:34:38 +02:00
|
|
|
gamma[0] = 0;
|
|
|
|
get_video_colors(mpctx->sh_video, prop->name, gamma);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(int *) arg);
|
|
|
|
*gamma = *(int *) arg;
|
|
|
|
r = set_video_colors(mpctx->sh_video, prop->name, *gamma);
|
|
|
|
if (r <= 0)
|
|
|
|
break;
|
|
|
|
return r;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (get_video_colors(mpctx->sh_video, prop->name, &val) > 0) {
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(int *)arg = val;
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
*gamma += (arg ? *(int *) arg : 1) *
|
2011-08-07 03:45:40 +02:00
|
|
|
(action == M_PROPERTY_STEP_DOWN ? -1 : 1);
|
2010-05-04 01:34:38 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, *gamma);
|
|
|
|
r = set_video_colors(mpctx->sh_video, prop->name, *gamma);
|
|
|
|
if (r <= 0)
|
|
|
|
break;
|
|
|
|
return r;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_TV
|
2007-02-21 01:49:24 +01:00
|
|
|
if (mpctx->demuxer->type == DEMUXER_TYPE_TV) {
|
2010-05-04 01:34:38 +02:00
|
|
|
int l = strlen(prop->name);
|
|
|
|
char tv_prop[3 + l + 1];
|
|
|
|
sprintf(tv_prop, "tv_%s", prop->name);
|
|
|
|
return mp_property_do(tv_prop, action, arg, mpctx);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// VSync (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_vsync(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
return m_property_flag(prop, action, arg, &vo_vsync);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Video codec tag (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_video_format(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2011-08-07 03:45:40 +02:00
|
|
|
char *meta;
|
2007-02-21 01:49:24 +01:00
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2011-08-07 03:45:40 +02:00
|
|
|
switch (action) {
|
2007-05-30 00:14:41 +02:00
|
|
|
case M_PROPERTY_PRINT:
|
|
|
|
if (!arg)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_ERROR;
|
2011-08-07 03:45:40 +02:00
|
|
|
switch (mpctx->sh_video->format) {
|
2007-05-30 00:14:41 +02:00
|
|
|
case 0x10000001:
|
2011-08-07 03:45:40 +02:00
|
|
|
meta = talloc_strdup(NULL, "mpeg1");
|
|
|
|
break;
|
2007-05-30 00:14:41 +02:00
|
|
|
case 0x10000002:
|
2011-08-07 03:45:40 +02:00
|
|
|
meta = talloc_strdup(NULL, "mpeg2");
|
|
|
|
break;
|
2007-05-30 00:14:41 +02:00
|
|
|
case 0x10000004:
|
2011-08-07 03:45:40 +02:00
|
|
|
meta = talloc_strdup(NULL, "mpeg4");
|
|
|
|
break;
|
2007-05-30 00:14:41 +02:00
|
|
|
case 0x10000005:
|
2011-08-07 03:45:40 +02:00
|
|
|
meta = talloc_strdup(NULL, "h264");
|
|
|
|
break;
|
2007-05-30 00:14:41 +02:00
|
|
|
default:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (mpctx->sh_video->format >= 0x20202020) {
|
2011-07-03 19:04:21 +02:00
|
|
|
meta = talloc_asprintf(NULL, "%.4s",
|
|
|
|
(char *) &mpctx->sh_video->format);
|
2011-08-07 03:45:40 +02:00
|
|
|
} else
|
2011-07-03 19:04:21 +02:00
|
|
|
meta = talloc_asprintf(NULL, "0x%08X", mpctx->sh_video->format);
|
2007-05-30 00:14:41 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
*(char **)arg = meta;
|
2007-05-30 00:14:41 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_int_ro(prop, action, arg, mpctx->sh_video->format);
|
|
|
|
}
|
|
|
|
|
2007-05-30 00:14:41 +02:00
|
|
|
/// Video codec name (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_video_codec(m_option_t *prop, int action,
|
|
|
|
void *arg, MPContext *mpctx)
|
2007-05-30 00:14:41 +02:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_video || !mpctx->sh_video->codec)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2011-08-07 03:45:40 +02:00
|
|
|
return m_property_string_ro(prop, action, arg,
|
|
|
|
mpctx->sh_video->codec->name);
|
2007-05-30 00:14:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Video bitrate (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_video_bitrate(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-05-30 00:14:41 +02:00
|
|
|
return m_property_bitrate(prop, action, arg, mpctx->sh_video->i_bps);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Video display width (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_width(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_int_ro(prop, action, arg, mpctx->sh_video->disp_w);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Video display height (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_height(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_int_ro(prop, action, arg, mpctx->sh_video->disp_h);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Video fps (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_fps(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_float_ro(prop, action, arg, mpctx->sh_video->fps);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Video aspect (RO)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_aspect(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_float_ro(prop, action, arg, mpctx->sh_video->aspect);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Text subtitle position (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub_pos(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
vo_osd_changed(OSDTYPE_SUBTITLE);
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_int_range(prop, action, arg, &sub_pos);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Selected subtitles (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2008-04-23 06:41:17 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2007-02-21 01:49:24 +01:00
|
|
|
demux_stream_t *const d_sub = mpctx->d_sub;
|
2012-02-27 19:15:13 +01:00
|
|
|
int source = -1, reset_spu av_unused = 0; // used under CONFIG_DVDREAD
|
2010-07-10 22:48:50 +02:00
|
|
|
int source_pos = -1;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2010-07-10 22:48:50 +02:00
|
|
|
update_global_sub_size(mpctx);
|
|
|
|
const int global_sub_size = mpctx->global_sub_size;
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
if (global_sub_size <= 0)
|
2009-06-12 23:14:47 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(int *) arg = mpctx->global_sub_pos;
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_PRINT:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2011-01-12 14:15:02 +01:00
|
|
|
char *sub_name = NULL;
|
2011-01-11 16:48:45 +01:00
|
|
|
if (mpctx->subdata)
|
|
|
|
sub_name = mpctx->subdata->filename;
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2011-01-12 14:15:02 +01:00
|
|
|
if (mpctx->osd->ass_track)
|
|
|
|
sub_name = mpctx->osd->ass_track->name;
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
2011-01-12 14:15:02 +01:00
|
|
|
if (!sub_name && mpctx->subdata)
|
|
|
|
sub_name = mpctx->subdata->filename;
|
2010-05-04 01:34:38 +02:00
|
|
|
if (sub_name) {
|
2010-12-04 11:24:42 +01:00
|
|
|
const char *tmp = mp_basename(sub_name);
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_asprintf(NULL, "(%d) %s%s",
|
2011-08-07 03:45:40 +02:00
|
|
|
mpctx->set_of_sub_pos + 1,
|
|
|
|
strlen(tmp) < 20 ? "" : "...",
|
|
|
|
strlen(tmp) < 20 ? tmp : tmp + strlen(tmp) - 19);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vo_vobsub && vobsub_id >= 0) {
|
2010-05-07 21:02:47 +02:00
|
|
|
const char *language = mp_gtext("unknown");
|
2010-05-04 01:34:38 +02:00
|
|
|
language = vobsub_get_id(vo_vobsub, (unsigned int) vobsub_id);
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_asprintf(NULL, "(%d) %s",
|
2011-08-07 03:45:40 +02:00
|
|
|
vobsub_id, language ? language : mp_gtext("unknown"));
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
2012-08-03 12:24:55 +02:00
|
|
|
if (opts->sub_id >= 0 && mpctx->d_sub && mpctx->d_sub->sh) {
|
2012-08-08 21:45:37 +02:00
|
|
|
struct sh_stream *sh = ((struct sh_sub *)mpctx->d_sub->sh)->gsh;
|
2012-08-03 12:24:55 +02:00
|
|
|
char *lang = demuxer_stream_lang(mpctx->demuxer, sh);
|
2012-02-19 14:15:41 +01:00
|
|
|
if (!lang)
|
|
|
|
lang = talloc_strdup(NULL, mp_gtext("unknown"));
|
2012-08-08 21:45:37 +02:00
|
|
|
if (sh->title)
|
|
|
|
*(char **)arg = talloc_asprintf(NULL, "(%d) %s (\"%s\")",
|
|
|
|
opts->sub_id, lang, sh->title);
|
|
|
|
else
|
|
|
|
*(char **) arg = talloc_asprintf(NULL, "(%d) %s", opts->sub_id,
|
|
|
|
lang);
|
2012-02-19 14:15:41 +01:00
|
|
|
talloc_free(lang);
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_strdup(NULL, mp_gtext("disabled"));
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
if (*(int *) arg < -1)
|
|
|
|
*(int *) arg = -1;
|
|
|
|
else if (*(int *) arg >= global_sub_size)
|
|
|
|
*(int *) arg = global_sub_size - 1;
|
|
|
|
mpctx->global_sub_pos = *(int *) arg;
|
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
2010-05-04 01:34:38 +02:00
|
|
|
mpctx->global_sub_pos += 2;
|
|
|
|
mpctx->global_sub_pos =
|
|
|
|
(mpctx->global_sub_pos % (global_sub_size + 1)) - 1;
|
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
mpctx->global_sub_pos += global_sub_size + 1;
|
|
|
|
mpctx->global_sub_pos =
|
|
|
|
(mpctx->global_sub_pos % (global_sub_size + 1)) - 1;
|
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2010-07-10 22:48:50 +02:00
|
|
|
if (mpctx->global_sub_pos >= 0) {
|
2010-05-04 01:34:38 +02:00
|
|
|
source = sub_source(mpctx);
|
2010-07-10 22:48:50 +02:00
|
|
|
source_pos = sub_source_pos(mpctx);
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_DBG3,
|
2010-05-04 01:34:38 +02:00
|
|
|
"subtitles: %d subs, (v@%d s@%d d@%d), @%d, source @%d\n",
|
|
|
|
global_sub_size,
|
2010-07-10 22:48:50 +02:00
|
|
|
mpctx->sub_counts[SUB_SOURCE_VOBSUB],
|
|
|
|
mpctx->sub_counts[SUB_SOURCE_SUBS],
|
|
|
|
mpctx->sub_counts[SUB_SOURCE_DEMUX],
|
2010-05-04 01:34:38 +02:00
|
|
|
mpctx->global_sub_pos, source);
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
mpctx->set_of_sub_pos = -1;
|
2011-01-11 16:48:45 +01:00
|
|
|
mpctx->subdata = NULL;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
vobsub_id = -1;
|
2008-04-23 06:41:17 +02:00
|
|
|
opts->sub_id = -1;
|
2007-02-21 01:49:24 +01:00
|
|
|
if (d_sub) {
|
2010-05-04 01:34:38 +02:00
|
|
|
if (d_sub->id > -2)
|
|
|
|
reset_spu = 1;
|
|
|
|
d_sub->id = -2;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
2011-01-12 14:15:02 +01:00
|
|
|
mpctx->osd->ass_track = NULL;
|
2011-01-16 19:03:08 +01:00
|
|
|
uninit_player(mpctx, INITIALIZED_SUB);
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
if (source == SUB_SOURCE_VOBSUB)
|
2010-07-10 22:48:50 +02:00
|
|
|
vobsub_id = vobsub_get_id_by_index(vo_vobsub, source_pos);
|
2011-08-07 03:45:40 +02:00
|
|
|
else if (source == SUB_SOURCE_SUBS) {
|
2010-07-10 22:48:50 +02:00
|
|
|
mpctx->set_of_sub_pos = source_pos;
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2011-01-19 19:13:48 +01:00
|
|
|
if (opts->ass_enabled
|
|
|
|
&& mpctx->set_of_ass_tracks[mpctx->set_of_sub_pos]) {
|
|
|
|
mpctx->osd->ass_track =
|
|
|
|
mpctx->set_of_ass_tracks[mpctx->set_of_sub_pos];
|
|
|
|
mpctx->osd->ass_track_changed = true;
|
|
|
|
mpctx->osd->vsfilter_aspect =
|
|
|
|
mpctx->track_was_native_ass[mpctx->set_of_sub_pos];
|
|
|
|
} else
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
2010-05-04 01:34:38 +02:00
|
|
|
{
|
2011-01-11 16:48:45 +01:00
|
|
|
mpctx->subdata = mpctx->set_of_subtitles[mpctx->set_of_sub_pos];
|
2010-05-04 01:34:38 +02:00
|
|
|
vo_osd_changed(OSDTYPE_SUBTITLE);
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
} else if (source == SUB_SOURCE_DEMUX) {
|
2010-07-10 22:48:50 +02:00
|
|
|
opts->sub_id = source_pos;
|
2008-04-23 06:41:17 +02:00
|
|
|
if (d_sub && opts->sub_id < MAX_S_STREAMS) {
|
2010-05-04 01:34:38 +02:00
|
|
|
int i = 0;
|
|
|
|
// default: assume 1:1 mapping of sid and stream id
|
2008-04-23 06:41:17 +02:00
|
|
|
d_sub->id = opts->sub_id;
|
2010-11-08 01:38:51 +01:00
|
|
|
d_sub->sh = mpctx->d_sub->demuxer->s_streams[d_sub->id];
|
2010-05-04 01:34:38 +02:00
|
|
|
ds_free_packs(d_sub);
|
|
|
|
for (i = 0; i < MAX_S_STREAMS; i++) {
|
2010-11-08 01:38:51 +01:00
|
|
|
sh_sub_t *sh = mpctx->d_sub->demuxer->s_streams[i];
|
2008-04-23 06:41:17 +02:00
|
|
|
if (sh && sh->sid == opts->sub_id) {
|
2010-05-04 01:34:38 +02:00
|
|
|
d_sub->id = i;
|
|
|
|
d_sub->sh = sh;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (d_sub->sh && d_sub->id >= 0) {
|
|
|
|
sh_sub_t *sh = d_sub->sh;
|
|
|
|
if (sh->type == 'v')
|
2010-05-07 21:02:47 +02:00
|
|
|
init_vo_spudec(mpctx);
|
2011-01-16 19:03:08 +01:00
|
|
|
else {
|
|
|
|
sub_init(sh, mpctx->osd);
|
|
|
|
mpctx->initialized_flags |= INITIALIZED_SUB;
|
|
|
|
}
|
2007-07-15 19:56:06 +02:00
|
|
|
} else {
|
2011-08-07 03:45:40 +02:00
|
|
|
d_sub->id = -2;
|
|
|
|
d_sub->sh = NULL;
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_DVDREAD
|
2007-02-21 01:49:24 +01:00
|
|
|
if (vo_spudec
|
2010-05-04 01:34:38 +02:00
|
|
|
&& (mpctx->stream->type == STREAMTYPE_DVD
|
|
|
|
|| mpctx->stream->type == STREAMTYPE_DVDNAV)
|
2008-04-23 06:41:17 +02:00
|
|
|
&& opts->sub_id < 0 && reset_spu) {
|
2010-05-04 01:34:38 +02:00
|
|
|
d_sub->id = -2;
|
|
|
|
d_sub->sh = NULL;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
#endif
|
2009-10-06 03:28:59 +02:00
|
|
|
|
timeline: subs: keep subtitle tracks in source time
Timeline handling converted the pts values from demuxed subtitles to
timeline scale. Change the code to do most subtitle handling in
original subtitle source pts, and instead convert current playback
timeline pts to those units when deciding which subtitle to show.
The main functionality changes are that now demuxed subtitles which
overlap chapter boundaries are handled correctly (at least for libass
subtitles), and external subtitles are assumed to use same pts scale
as current source (this needs improvements later).
Before, a video subtitle that had a duration continuing past the end
of the chapter would continue to be shown for the original duration,
even if the chapter ended and playback switched to a position in the
source where the subtitle shouldn't exist. Now, the subtitle will
correctly end.
Before, external subtitle files were interpreted as specifying pts
values in timeline scale. Now, they're interpreted as specifying pts
values in source file time scale, for _every_ source file. This is
probably more likely to be what the user wants for the "main" source
file in case there is one, but almost certainly not quite right for
multiple source files where the same subs could be shown over
different scenes. If the user wants them to match some main source
file, it's probably still better to have incorrect extra subs for
video from some files than to have every subtitle appearing at the
wrong time. The new code makes it easier to change the interpretation
of the subtitle times, and some configurability should be added in
the future.
2012-03-20 01:54:19 +01:00
|
|
|
update_subtitles(mpctx, 0, true);
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
}
|
|
|
|
|
2007-11-25 05:09:04 +01:00
|
|
|
/// Selected sub source (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub_source(m_option_t *prop, int action, void *arg,
|
|
|
|
MPContext *mpctx)
|
2007-11-25 05:09:04 +01:00
|
|
|
{
|
|
|
|
int source;
|
2010-07-10 22:48:50 +02:00
|
|
|
update_global_sub_size(mpctx);
|
2007-11-25 05:09:04 +01:00
|
|
|
if (!mpctx->sh_video || mpctx->global_sub_size <= 0)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
*(int *) arg = sub_source(mpctx);
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_PRINT:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2011-07-03 19:04:21 +02:00
|
|
|
char *sourcename;
|
|
|
|
switch (sub_source(mpctx)) {
|
2007-11-25 05:09:04 +01:00
|
|
|
case SUB_SOURCE_SUBS:
|
2011-07-03 19:04:21 +02:00
|
|
|
sourcename = mp_gtext("file");
|
2007-11-25 05:09:04 +01:00
|
|
|
break;
|
|
|
|
case SUB_SOURCE_VOBSUB:
|
2011-07-03 19:04:21 +02:00
|
|
|
sourcename = mp_gtext("vobsub");
|
2007-11-25 05:09:04 +01:00
|
|
|
break;
|
|
|
|
case SUB_SOURCE_DEMUX:
|
2011-07-03 19:04:21 +02:00
|
|
|
sourcename = mp_gtext("embedded");
|
2007-11-25 05:09:04 +01:00
|
|
|
break;
|
|
|
|
default:
|
2011-07-03 19:04:21 +02:00
|
|
|
sourcename = mp_gtext("disabled");
|
2007-11-25 05:09:04 +01:00
|
|
|
}
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **)arg = talloc_strdup(NULL, sourcename);
|
2007-11-25 05:09:04 +01:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_SET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2011-08-07 03:45:40 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, *(int *)arg);
|
2007-11-25 05:09:04 +01:00
|
|
|
if (*(int *) arg < 0)
|
|
|
|
mpctx->global_sub_pos = -1;
|
|
|
|
else if (*(int *) arg != sub_source(mpctx)) {
|
2010-07-10 22:48:50 +02:00
|
|
|
int new_pos = sub_pos_by_source(mpctx, *(int *)arg);
|
|
|
|
if (new_pos == -1)
|
2007-11-25 05:09:04 +01:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2010-07-10 22:48:50 +02:00
|
|
|
mpctx->global_sub_pos = new_pos;
|
2007-11-25 05:09:04 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN: {
|
2011-08-07 03:45:40 +02:00
|
|
|
int step_all = (arg && *(int *)arg != 0 ? *(int *)arg : 1)
|
2007-11-25 05:09:04 +01:00
|
|
|
* (action == M_PROPERTY_STEP_UP ? 1 : -1);
|
|
|
|
int step = (step_all > 0) ? 1 : -1;
|
|
|
|
int cur_source = sub_source(mpctx);
|
|
|
|
source = cur_source;
|
|
|
|
while (step_all) {
|
|
|
|
source += step;
|
|
|
|
if (source >= SUB_SOURCES)
|
|
|
|
source = -1;
|
|
|
|
else if (source < -1)
|
|
|
|
source = SUB_SOURCES - 1;
|
|
|
|
if (source == cur_source || source == -1 ||
|
2011-08-07 03:45:40 +02:00
|
|
|
mpctx->sub_counts[source])
|
2007-11-25 05:09:04 +01:00
|
|
|
step_all -= step;
|
|
|
|
}
|
|
|
|
if (source == cur_source)
|
|
|
|
return M_PROPERTY_OK;
|
|
|
|
if (source == -1)
|
|
|
|
mpctx->global_sub_pos = -1;
|
|
|
|
else
|
2010-07-10 22:48:50 +02:00
|
|
|
mpctx->global_sub_pos = sub_pos_by_source(mpctx, source);
|
2007-11-25 05:09:04 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
--mpctx->global_sub_pos;
|
|
|
|
return mp_property_sub(prop, M_PROPERTY_STEP_UP, NULL, mpctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Selected subtitles from specific source (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub_by_type(m_option_t *prop, int action, void *arg,
|
|
|
|
MPContext *mpctx)
|
2007-11-25 05:09:04 +01:00
|
|
|
{
|
2010-07-10 22:48:50 +02:00
|
|
|
int source, is_cur_source, offset, new_pos;
|
|
|
|
update_global_sub_size(mpctx);
|
2007-11-25 05:09:04 +01:00
|
|
|
if (!mpctx->sh_video || mpctx->global_sub_size <= 0)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
|
|
|
if (!strcmp(prop->name, "sub_file"))
|
|
|
|
source = SUB_SOURCE_SUBS;
|
|
|
|
else if (!strcmp(prop->name, "sub_vob"))
|
|
|
|
source = SUB_SOURCE_VOBSUB;
|
|
|
|
else if (!strcmp(prop->name, "sub_demux"))
|
|
|
|
source = SUB_SOURCE_DEMUX;
|
|
|
|
else
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
|
2010-07-10 22:48:50 +02:00
|
|
|
offset = sub_pos_by_source(mpctx, source);
|
|
|
|
if (offset < 0)
|
2007-11-25 05:09:04 +01:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
|
|
|
is_cur_source = sub_source(mpctx) == source;
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos = mpctx->global_sub_pos;
|
2007-11-25 05:09:04 +01:00
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_GET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-12-03 05:08:36 +01:00
|
|
|
if (is_cur_source) {
|
2010-07-10 22:48:50 +02:00
|
|
|
*(int *) arg = sub_source_pos(mpctx);
|
2007-12-03 05:08:36 +01:00
|
|
|
if (source == SUB_SOURCE_VOBSUB)
|
|
|
|
*(int *) arg = vobsub_get_id_by_index(vo_vobsub, *(int *) arg);
|
2011-08-07 03:45:40 +02:00
|
|
|
} else
|
2007-12-03 05:08:36 +01:00
|
|
|
*(int *) arg = -1;
|
2007-11-25 05:09:04 +01:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_PRINT:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
if (is_cur_source)
|
|
|
|
return mp_property_sub(prop, M_PROPERTY_PRINT, arg, mpctx);
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_strdup(NULL, mp_gtext("disabled"));
|
2007-11-25 05:09:04 +01:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_SET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
if (*(int *) arg >= 0) {
|
2007-12-03 05:08:36 +01:00
|
|
|
int index = *(int *)arg;
|
|
|
|
if (source == SUB_SOURCE_VOBSUB)
|
|
|
|
index = vobsub_get_index_by_id(vo_vobsub, index);
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos = offset + index;
|
|
|
|
if (index < 0 || index > mpctx->sub_counts[source]) {
|
|
|
|
new_pos = -1;
|
2007-11-25 05:09:04 +01:00
|
|
|
*(int *) arg = -1;
|
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
} else
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos = -1;
|
2007-11-25 05:09:04 +01:00
|
|
|
break;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN: {
|
2011-08-07 03:45:40 +02:00
|
|
|
int step_all = (arg && *(int *)arg != 0 ? *(int *)arg : 1)
|
2007-11-25 05:09:04 +01:00
|
|
|
* (action == M_PROPERTY_STEP_UP ? 1 : -1);
|
|
|
|
int step = (step_all > 0) ? 1 : -1;
|
|
|
|
int max_sub_pos_for_source = -1;
|
|
|
|
if (!is_cur_source)
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos = -1;
|
2007-11-25 05:09:04 +01:00
|
|
|
while (step_all) {
|
2010-07-10 22:48:50 +02:00
|
|
|
if (new_pos == -1) {
|
2007-11-25 05:09:04 +01:00
|
|
|
if (step > 0)
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos = offset;
|
2007-11-25 05:09:04 +01:00
|
|
|
else if (max_sub_pos_for_source == -1) {
|
|
|
|
// Find max pos for specific source
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos = mpctx->global_sub_size - 1;
|
2011-08-07 03:45:40 +02:00
|
|
|
while (new_pos >= 0 && sub_source(mpctx) != source)
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos--;
|
2011-08-07 03:45:40 +02:00
|
|
|
} else
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos = max_sub_pos_for_source;
|
2011-08-07 03:45:40 +02:00
|
|
|
} else {
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos += step;
|
|
|
|
if (new_pos < offset ||
|
2011-08-07 03:45:40 +02:00
|
|
|
new_pos >= mpctx->global_sub_size ||
|
|
|
|
sub_source(mpctx) != source)
|
2010-07-10 22:48:50 +02:00
|
|
|
new_pos = -1;
|
2007-11-25 05:09:04 +01:00
|
|
|
}
|
|
|
|
step_all -= step;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
2010-07-10 22:48:50 +02:00
|
|
|
return mp_property_sub(prop, M_PROPERTY_SET, &new_pos, mpctx);
|
2007-11-25 05:09:04 +01:00
|
|
|
}
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Subtitle delay (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub_delay(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
return m_property_delay(prop, action, arg, &sub_delay);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Alignment of text subtitles (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub_alignment(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2011-08-07 03:45:40 +02:00
|
|
|
char *name[] = {
|
|
|
|
_("top"), _("center"), _("bottom")
|
|
|
|
};
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
if (!mpctx->sh_video || mpctx->global_sub_pos < 0
|
2010-05-04 01:34:38 +02:00
|
|
|
|| sub_source(mpctx) != SUB_SOURCE_SUBS)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_PRINT:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, sub_alignment);
|
2011-07-03 19:04:21 +02:00
|
|
|
*(char **) arg = talloc_strdup(NULL, mp_gtext(name[sub_alignment]));
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
vo_osd_changed(OSDTYPE_SUBTITLE);
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_choice(prop, action, arg, &sub_alignment);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Subtitle visibility (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub_visibility(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
vo_osd_changed(OSDTYPE_SUBTITLE);
|
|
|
|
if (vo_spudec)
|
|
|
|
vo_osd_changed(OSDTYPE_SPU);
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_flag(prop, action, arg, &sub_visibility);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2008-01-23 22:18:32 +01:00
|
|
|
/// Use margins for libass subtitles (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_ass_use_margins(m_option_t *prop, int action,
|
2011-08-07 03:45:40 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2008-01-23 22:18:32 +01:00
|
|
|
{
|
2011-09-03 12:47:56 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2008-01-23 22:18:32 +01:00
|
|
|
if (!mpctx->sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2008-01-23 22:18:32 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2008-01-23 22:18:32 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2011-08-08 04:59:23 +02:00
|
|
|
mpctx->osd->ass_force_reload = true;
|
2008-01-23 22:18:32 +01:00
|
|
|
default:
|
2011-09-03 12:47:56 +02:00
|
|
|
return m_property_flag(prop, action, arg, &opts->ass_use_margins);
|
2008-01-23 22:18:32 +01:00
|
|
|
}
|
|
|
|
}
|
2011-08-04 21:47:36 +02:00
|
|
|
|
|
|
|
static int mp_property_ass_vsfilter_aspect_compat(m_option_t *prop, int action,
|
|
|
|
void *arg, MPContext *mpctx)
|
|
|
|
{
|
|
|
|
if (!mpctx->sh_video)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
|
|
|
//has to re-render subs with new aspect ratio
|
|
|
|
mpctx->osd->ass_force_reload = 1;
|
|
|
|
default:
|
|
|
|
return m_property_flag(prop, action, arg,
|
|
|
|
&mpctx->opts.ass_vsfilter_aspect_compat);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-23 22:18:32 +01:00
|
|
|
#endif
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
/// Show only forced subtitles (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub_forced_only(m_option_t *prop, int action,
|
2010-05-07 21:02:47 +02:00
|
|
|
void *arg, MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
if (!vo_spudec)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-05-04 01:34:38 +02:00
|
|
|
m_property_flag(prop, action, arg, &forced_subs_only);
|
|
|
|
spudec_set_forced_subs_only(vo_spudec, forced_subs_only);
|
|
|
|
return M_PROPERTY_OK;
|
2007-02-21 01:49:24 +01:00
|
|
|
default:
|
2010-05-04 01:34:38 +02:00
|
|
|
return m_property_flag(prop, action, arg, &forced_subs_only);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2007-07-09 13:19:21 +02:00
|
|
|
/// Subtitle scale (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_sub_scale(m_option_t *prop, int action, void *arg,
|
2011-08-07 03:45:40 +02:00
|
|
|
MPContext *mpctx)
|
2007-07-09 13:19:21 +02:00
|
|
|
{
|
2009-12-02 16:36:59 +01:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2007-07-09 13:19:21 +02:00
|
|
|
|
|
|
|
switch (action) {
|
2011-08-07 03:45:40 +02:00
|
|
|
case M_PROPERTY_SET:
|
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(float *) arg);
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2011-08-07 03:45:40 +02:00
|
|
|
if (opts->ass_enabled) {
|
2011-09-03 12:47:56 +02:00
|
|
|
opts->ass_font_scale = *(float *) arg;
|
2011-08-08 04:59:23 +02:00
|
|
|
mpctx->osd->ass_force_reload = true;
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
2008-01-23 23:33:46 +01:00
|
|
|
#endif
|
2011-08-07 03:45:40 +02:00
|
|
|
text_font_scale_factor = *(float *) arg;
|
osd: use libass for OSD rendering
The OSD will now be rendered with libass. The old rendering code, which
used freetype/fontconfig and did text layout manually, is disabled. To
re-enable the old code, use the --disable-libass-osd configure switch.
Some switches do nothing with the new code enabled, such as -subalign,
-sub-bg-alpha, -sub-bg-color, and many more. (The reason is mostly that
the code for rendering unstyled subtitles with libass doesn't make any
attempts to support them. Some of them could be supported in theory.)
Teletext rendering is not implemented in the new OSD rendering code. I
don't have any teletext sources for testing, and since teletext is
being phased out world-wide, the need for this is questionable.
Note that rendering is extremely inefficient, mostly because the libass
output is blended with the extremely strange mplayer OSD format. This
could be improved at a later point.
Remove most OSD rendering from vo_aa.c, because that was extremely
hacky, can't be made work with osd_libass, and didn't work anyway in
my tests.
Internally, some cleanup is done. Subtitle and OSD related variable
declarations were literally all over the place. Move them to sub.h and
sub.c, which were hoarding most of these declarations already. Make the
player core in mplayer.c free of concerns like bitmap font loading.
The old OSD rendering code has been moved to osd_ft.c. The font_load.c
and font_load_ft.c are only needed and compiled if the old OSD
rendering code is configured.
2012-03-22 06:26:37 +01:00
|
|
|
vo_osd_resized();
|
2011-08-07 03:45:40 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2011-08-07 03:45:40 +02:00
|
|
|
if (opts->ass_enabled) {
|
2011-09-03 12:47:56 +02:00
|
|
|
opts->ass_font_scale += (arg ? *(float *) arg : 0.1) *
|
2011-08-07 03:45:40 +02:00
|
|
|
(action == M_PROPERTY_STEP_UP ? 1.0 : -1.0);
|
2011-09-03 12:47:56 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, opts->ass_font_scale);
|
2011-08-08 04:59:23 +02:00
|
|
|
mpctx->osd->ass_force_reload = true;
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
2008-01-23 23:33:46 +01:00
|
|
|
#endif
|
2011-08-07 03:45:40 +02:00
|
|
|
text_font_scale_factor += (arg ? *(float *) arg : 0.1) *
|
|
|
|
(action == M_PROPERTY_STEP_UP ? 1.0 : -1.0);
|
|
|
|
M_PROPERTY_CLAMP(prop, text_font_scale_factor);
|
osd: use libass for OSD rendering
The OSD will now be rendered with libass. The old rendering code, which
used freetype/fontconfig and did text layout manually, is disabled. To
re-enable the old code, use the --disable-libass-osd configure switch.
Some switches do nothing with the new code enabled, such as -subalign,
-sub-bg-alpha, -sub-bg-color, and many more. (The reason is mostly that
the code for rendering unstyled subtitles with libass doesn't make any
attempts to support them. Some of them could be supported in theory.)
Teletext rendering is not implemented in the new OSD rendering code. I
don't have any teletext sources for testing, and since teletext is
being phased out world-wide, the need for this is questionable.
Note that rendering is extremely inefficient, mostly because the libass
output is blended with the extremely strange mplayer OSD format. This
could be improved at a later point.
Remove most OSD rendering from vo_aa.c, because that was extremely
hacky, can't be made work with osd_libass, and didn't work anyway in
my tests.
Internally, some cleanup is done. Subtitle and OSD related variable
declarations were literally all over the place. Move them to sub.h and
sub.c, which were hoarding most of these declarations already. Make the
player core in mplayer.c free of concerns like bitmap font loading.
The old OSD rendering code has been moved to osd_ft.c. The font_load.c
and font_load_ft.c are only needed and compiled if the old OSD
rendering code is configured.
2012-03-22 06:26:37 +01:00
|
|
|
vo_osd_resized();
|
2011-08-07 03:45:40 +02:00
|
|
|
return M_PROPERTY_OK;
|
|
|
|
default:
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2011-08-07 03:45:40 +02:00
|
|
|
if (opts->ass_enabled)
|
2011-09-03 12:47:56 +02:00
|
|
|
return m_property_float_ro(prop, action, arg, opts->ass_font_scale);
|
2011-08-07 03:45:40 +02:00
|
|
|
else
|
2008-01-23 23:33:46 +01:00
|
|
|
#endif
|
2011-08-07 03:45:40 +02:00
|
|
|
return m_property_float_ro(prop, action, arg, text_font_scale_factor);
|
2007-07-09 13:19:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_TV
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
/// TV color settings (RW)
|
2008-04-25 04:04:41 +02:00
|
|
|
static int mp_property_tv_color(m_option_t *prop, int action, void *arg,
|
2010-05-07 21:02:47 +02:00
|
|
|
MPContext *mpctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
int r, val;
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (!mpctx->demuxer)
|
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
tvi_handle_t *tvh = mpctx->demuxer->priv;
|
|
|
|
if (mpctx->demuxer->type != DEMUXER_TYPE_TV || !tvh)
|
2010-05-04 01:34:38 +02:00
|
|
|
return M_PROPERTY_UNAVAILABLE;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case M_PROPERTY_SET:
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!arg)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
M_PROPERTY_CLAMP(prop, *(int *) arg);
|
2010-11-01 21:45:46 +01:00
|
|
|
return tv_set_color_options(tvh, prop->offset, *(int *) arg);
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_GET:
|
2010-11-01 21:45:46 +01:00
|
|
|
return tv_get_color_options(tvh, prop->offset, arg);
|
2007-02-21 01:49:24 +01:00
|
|
|
case M_PROPERTY_STEP_UP:
|
|
|
|
case M_PROPERTY_STEP_DOWN:
|
2010-11-01 21:45:46 +01:00
|
|
|
if ((r = tv_get_color_options(tvh, prop->offset, &val)) >= 0) {
|
2010-05-04 01:34:38 +02:00
|
|
|
if (!r)
|
|
|
|
return M_PROPERTY_ERROR;
|
|
|
|
val += (arg ? *(int *) arg : 1) *
|
2011-08-07 03:45:40 +02:00
|
|
|
(action == M_PROPERTY_STEP_DOWN ? -1 : 1);
|
2010-05-04 01:34:38 +02:00
|
|
|
M_PROPERTY_CLAMP(prop, val);
|
2010-11-01 21:45:46 +01:00
|
|
|
return tv_set_color_options(tvh, prop->offset, val);
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
|
|
|
return M_PROPERTY_ERROR;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
return M_PROPERTY_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/// All properties available in MPlayer.
|
|
|
|
/** \ingroup Properties
|
|
|
|
*/
|
2008-01-13 18:00:46 +01:00
|
|
|
static const m_option_t mp_properties[] = {
|
2007-02-21 01:49:24 +01:00
|
|
|
// General
|
|
|
|
{ "osdlevel", mp_property_osdlevel, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 3, NULL },
|
2007-07-09 16:52:46 +02:00
|
|
|
{ "loop", mp_property_loop, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, -1, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "speed", mp_property_playback_speed, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0.01, 100.0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "filename", mp_property_filename, CONF_TYPE_STRING,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "path", mp_property_path, CONF_TYPE_STRING,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "demuxer", mp_property_demuxer, CONF_TYPE_STRING,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "stream_pos", mp_property_stream_pos, CONF_TYPE_POSITION,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "stream_start", mp_property_stream_start, CONF_TYPE_POSITION,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "stream_end", mp_property_stream_end, CONF_TYPE_POSITION,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "stream_length", mp_property_stream_length, CONF_TYPE_POSITION,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, 0, 0, NULL },
|
2010-07-25 11:06:37 +02:00
|
|
|
{ "stream_time_pos", mp_property_stream_time_pos, CONF_TYPE_TIME,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, 0, 0, NULL },
|
2007-05-31 15:02:51 +02:00
|
|
|
{ "length", mp_property_length, CONF_TYPE_TIME,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, 0, 0, NULL },
|
2007-05-31 15:07:52 +02:00
|
|
|
{ "percent_pos", mp_property_percent_pos, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 100, NULL },
|
2007-05-31 15:07:52 +02:00
|
|
|
{ "time_pos", mp_property_time_pos, CONF_TYPE_TIME,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, 0, 0, NULL },
|
2007-12-14 09:33:11 +01:00
|
|
|
{ "chapter", mp_property_chapter, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, 0, 0, NULL },
|
2011-12-31 13:20:08 +01:00
|
|
|
{ "titles", mp_property_titles, CONF_TYPE_INT,
|
|
|
|
0, 0, 0, NULL },
|
2008-09-26 23:17:01 +02:00
|
|
|
{ "chapters", mp_property_chapters, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2008-01-05 15:32:39 +01:00
|
|
|
{ "angle", mp_property_angle, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
CONF_RANGE, -2, 10, NULL },
|
2007-05-30 00:14:41 +02:00
|
|
|
{ "metadata", mp_property_metadata, CONF_TYPE_STRING_LIST,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2008-10-01 19:05:30 +02:00
|
|
|
{ "pause", mp_property_pause, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2010-12-18 07:02:48 +01:00
|
|
|
{ "pts_association_mode", mp_property_generic_option, &m_option_type_choice,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, "pts-association-mode" },
|
2010-12-15 00:09:47 +01:00
|
|
|
{ "hr_seek", mp_property_generic_option, &m_option_type_choice,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, "hr-seek" },
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
// Audio
|
|
|
|
{ "volume", mp_property_volume, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 100, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "mute", mp_property_mute, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "audio_delay", mp_property_audio_delay, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "audio_format", mp_property_audio_format, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-05-30 00:14:41 +02:00
|
|
|
{ "audio_codec", mp_property_audio_codec, CONF_TYPE_STRING,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "audio_bitrate", mp_property_audio_bitrate, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "samplerate", mp_property_samplerate, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "channels", mp_property_channels, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "switch_audio", mp_property_audio, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
CONF_RANGE, -2, 65535, NULL },
|
2007-06-20 04:26:20 +02:00
|
|
|
{ "balance", mp_property_balance, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -1, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
// Video
|
|
|
|
{ "fullscreen", mp_property_fullscreen, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "deinterlace", mp_property_deinterlace, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
{ "colormatrix", mp_property_colormatrix, &m_option_type_choice,
|
|
|
|
0, 0, 0, "colormatrix" },
|
|
|
|
{ "colormatrix_input_range", mp_property_colormatrix_input_range, &m_option_type_choice,
|
|
|
|
0, 0, 0, "colormatrix-input-range" },
|
|
|
|
{ "colormatrix_output_range", mp_property_colormatrix_output_range, &m_option_type_choice,
|
|
|
|
0, 0, 0, "colormatrix-output-range" },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "ontop", mp_property_ontop, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "rootwin", mp_property_rootwin, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "border", mp_property_border, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "framedropping", mp_property_framedropping, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 2, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "gamma", mp_property_gamma, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = offsetof(struct MPOpts, vo_gamma_gamma)},
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "brightness", mp_property_gamma, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = offsetof(struct MPOpts, vo_gamma_brightness) },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "contrast", mp_property_gamma, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = offsetof(struct MPOpts, vo_gamma_contrast) },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "saturation", mp_property_gamma, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = offsetof(struct MPOpts, vo_gamma_saturation) },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "hue", mp_property_gamma, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = offsetof(struct MPOpts, vo_gamma_hue) },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "panscan", mp_property_panscan, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "vsync", mp_property_vsync, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "video_format", mp_property_video_format, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-05-30 00:14:41 +02:00
|
|
|
{ "video_codec", mp_property_video_codec, CONF_TYPE_STRING,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "video_bitrate", mp_property_video_bitrate, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "width", mp_property_width, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "height", mp_property_height, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "fps", mp_property_fps, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "aspect", mp_property_aspect, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "switch_video", mp_property_video, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
CONF_RANGE, -2, 65535, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "switch_program", mp_property_program, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
CONF_RANGE, -1, 65535, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
// Subs
|
|
|
|
{ "sub", mp_property_sub, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, -1, 0, NULL },
|
2007-11-25 05:09:04 +01:00
|
|
|
{ "sub_source", mp_property_sub_source, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -1, SUB_SOURCES - 1, NULL },
|
2007-11-25 05:09:04 +01:00
|
|
|
{ "sub_vob", mp_property_sub_by_type, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, -1, 0, NULL },
|
2007-11-25 05:09:04 +01:00
|
|
|
{ "sub_demux", mp_property_sub_by_type, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, -1, 0, NULL },
|
2007-11-25 05:09:04 +01:00
|
|
|
{ "sub_file", mp_property_sub_by_type, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_MIN, -1, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "sub_delay", mp_property_sub_delay, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
0, 0, 0, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "sub_pos", mp_property_sub_pos, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 100, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "sub_alignment", mp_property_sub_alignment, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 2, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "sub_visibility", mp_property_sub_visibility, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "sub_forced_only", mp_property_sub_forced_only, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2007-07-09 13:19:21 +02:00
|
|
|
{ "sub_scale", mp_property_sub_scale, CONF_TYPE_FLOAT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 100, NULL },
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2008-01-23 22:18:32 +01:00
|
|
|
{ "ass_use_margins", mp_property_ass_use_margins, CONF_TYPE_FLAG,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, 0, 1, NULL },
|
2011-08-04 21:47:36 +02:00
|
|
|
{ "ass_vsfilter_aspect_compat", mp_property_ass_vsfilter_aspect_compat,
|
|
|
|
CONF_TYPE_FLAG, M_OPT_RANGE, 0, 1, NULL },
|
2008-01-23 22:18:32 +01:00
|
|
|
#endif
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_TV
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "tv_brightness", mp_property_tv_color, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = TV_COLOR_BRIGHTNESS },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "tv_contrast", mp_property_tv_color, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = TV_COLOR_CONTRAST },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "tv_saturation", mp_property_tv_color, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = TV_COLOR_SATURATION },
|
2007-02-21 01:49:24 +01:00
|
|
|
{ "tv_hue", mp_property_tv_color, CONF_TYPE_INT,
|
2011-08-07 03:45:40 +02:00
|
|
|
M_OPT_RANGE, -100, 100, .offset = TV_COLOR_HUE },
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
2012-08-10 01:30:53 +02:00
|
|
|
|
|
|
|
{0},
|
2007-02-21 01:49:24 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2007-05-29 23:49:39 +02:00
|
|
|
int mp_property_do(const char *name, int action, void *val, void *ctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2007-05-29 23:49:39 +02:00
|
|
|
return m_property_do(mp_properties, name, action, val, ctx);
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
char *mp_property_print(const char *name, void *ctx)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2011-08-07 03:45:40 +02:00
|
|
|
char *ret = NULL;
|
|
|
|
if (mp_property_do(name, M_PROPERTY_PRINT, &ret, ctx) <= 0)
|
2007-05-29 23:49:39 +02:00
|
|
|
return NULL;
|
|
|
|
return ret;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
|
2008-04-25 04:04:41 +02:00
|
|
|
char *property_expand_string(MPContext *mpctx, char *str)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
return m_properties_expand_string(mp_properties, str, mpctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
void property_print_help(void)
|
|
|
|
{
|
|
|
|
m_properties_print_help_list(mp_properties);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-19 03:17:30 +02:00
|
|
|
/* List of default ways to show a property on OSD.
|
|
|
|
*
|
|
|
|
* Setting osd_progbar to -1 displays seek bar, other nonzero displays
|
|
|
|
* a bar showing the current position between min/max values of the
|
|
|
|
* property. 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.
|
|
|
|
*
|
|
|
|
* Otherwise setting osd_msg will show the string on OSD, formatted with
|
|
|
|
* the text value of the property as argument.
|
|
|
|
*/
|
|
|
|
static struct property_osd_display {
|
|
|
|
/// property name
|
|
|
|
const char *name;
|
|
|
|
/// progressbar type
|
|
|
|
int osd_progbar; // -1 is special value for seek indicators
|
|
|
|
/// osd msg id if it must be shared
|
|
|
|
int osd_id;
|
|
|
|
/// osd msg template
|
|
|
|
const char *osd_msg;
|
|
|
|
} property_osd_display[] = {
|
|
|
|
// general
|
|
|
|
{ "loop", 0, -1, _("Loop: %s") },
|
|
|
|
{ "chapter", -1, -1, NULL },
|
2010-12-18 07:02:48 +01:00
|
|
|
{ "pts_association_mode", 0, -1, "PTS association mode: %s" },
|
2010-12-15 00:09:47 +01:00
|
|
|
{ "hr_seek", 0, -1, "hr-seek: %s" },
|
2011-01-28 19:13:58 +01:00
|
|
|
{ "speed", 0, -1, _("Speed: x %6s") },
|
2009-09-19 03:17:30 +02:00
|
|
|
// audio
|
|
|
|
{ "volume", OSD_VOLUME, -1, _("Volume") },
|
|
|
|
{ "mute", 0, -1, _("Mute: %s") },
|
|
|
|
{ "audio_delay", 0, -1, _("A-V delay: %s") },
|
|
|
|
{ "switch_audio", 0, -1, _("Audio: %s") },
|
|
|
|
{ "balance", OSD_BALANCE, -1, _("Balance") },
|
|
|
|
// video
|
|
|
|
{ "panscan", OSD_PANSCAN, -1, _("Panscan") },
|
|
|
|
{ "ontop", 0, -1, _("Stay on top: %s") },
|
|
|
|
{ "rootwin", 0, -1, _("Rootwin: %s") },
|
|
|
|
{ "border", 0, -1, _("Border: %s") },
|
|
|
|
{ "framedropping", 0, -1, _("Framedropping: %s") },
|
2009-09-19 04:11:39 +02:00
|
|
|
{ "deinterlace", 0, -1, _("Deinterlace: %s") },
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
{ "colormatrix", 0, -1, _("YUV colormatrix: %s") },
|
|
|
|
{ "colormatrix_input_range", 0, -1, _("YUV input range: %s") },
|
|
|
|
{ "colormatrix_output_range", 0, -1, _("RGB output range: %s") },
|
2009-09-19 03:17:30 +02:00
|
|
|
{ "gamma", OSD_BRIGHTNESS, -1, _("Gamma") },
|
|
|
|
{ "brightness", OSD_BRIGHTNESS, -1, _("Brightness") },
|
|
|
|
{ "contrast", OSD_CONTRAST, -1, _("Contrast") },
|
|
|
|
{ "saturation", OSD_SATURATION, -1, _("Saturation") },
|
|
|
|
{ "hue", OSD_HUE, -1, _("Hue") },
|
|
|
|
{ "vsync", 0, -1, _("VSync: %s") },
|
|
|
|
// subs
|
|
|
|
{ "sub", 0, -1, _("Subtitles: %s") },
|
|
|
|
{ "sub_source", 0, -1, _("Sub source: %s") },
|
|
|
|
{ "sub_vob", 0, -1, _("Subtitles: %s") },
|
|
|
|
{ "sub_demux", 0, -1, _("Subtitles: %s") },
|
|
|
|
{ "sub_file", 0, -1, _("Subtitles: %s") },
|
|
|
|
{ "sub_pos", 0, -1, _("Sub position: %s/100") },
|
|
|
|
{ "sub_alignment", 0, -1, _("Sub alignment: %s") },
|
|
|
|
{ "sub_delay", 0, OSD_MSG_SUB_DELAY, _("Sub delay: %s") },
|
|
|
|
{ "sub_visibility", 0, -1, _("Subtitles: %s") },
|
|
|
|
{ "sub_forced_only", 0, -1, _("Forced sub only: %s") },
|
|
|
|
{ "sub_scale", 0, -1, _("Sub Scale: %s")},
|
2011-08-04 21:47:36 +02:00
|
|
|
{ "ass_vsfilter_aspect_compat", 0, -1,
|
|
|
|
_("Subtitle VSFilter aspect compat: %s")},
|
2009-09-19 03:17:30 +02:00
|
|
|
#ifdef CONFIG_TV
|
|
|
|
{ "tv_brightness", OSD_BRIGHTNESS, -1, _("Brightness") },
|
|
|
|
{ "tv_hue", OSD_HUE, -1, _("Hue") },
|
|
|
|
{ "tv_saturation", OSD_SATURATION, -1, _("Saturation") },
|
|
|
|
{ "tv_contrast", OSD_CONTRAST, -1, _("Contrast") },
|
|
|
|
#endif
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static int show_property_osd(MPContext *mpctx, const char *pname)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
|
|
|
int r;
|
2011-08-07 03:45:40 +02:00
|
|
|
m_option_t *prop;
|
2009-09-19 03:17:30 +02:00
|
|
|
struct property_osd_display *p;
|
|
|
|
|
|
|
|
// look for the command
|
|
|
|
for (p = property_osd_display; p->name; p++)
|
|
|
|
if (!strcmp(p->name, pname))
|
|
|
|
break;
|
video, options: implement better YUV->RGB conversion control
Rewrite control of the colorspace and input/output level parameters
used in YUV-RGB conversions, replacing VO-specific suboptions with new
common options and adding configuration support to more cases.
Add new option --colormatrix which selects the colorspace the original
video is assumed to have in YUV->RGB conversions. The default
behavior changes from assuming BT.601 to colorspace autoselection
between BT.601 and BT.709 using a simple heuristic based on video
size. Add new options --colormatrix-input-range and
--colormatrix-output-range which select input YUV and output RGB range.
Disable the previously existing VO-specific colorspace and level
conversion suboptions in vo_gl and vo_vdpau. Remove the
"yuv_colorspace" property and replace it with one named "colormatrix"
and semantics matching the new option. Add new properties matching the
options for level conversion.
Colorspace selection is currently supported by vo_gl, vo_vdpau, vo_xv
and vf_scale, and all can change it at runtime (previously only
vo_vdpau and vo_xv could). vo_vdpau now uses the same conversion
matrix generation as vo_gl instead of libvdpau functionality; the main
functional difference is that the "contrast" equalizer control behaves
somewhat differently (it scales the Y component around 1/2 instead of
around 0, so that contrast 0 makes the image gray rather than black).
vo_xv does not support level conversion. vf_scale supports range
setting for input, but always outputs full-range RGB.
The value of the slave properties is the policy setting used for
conversions. This means they can be set to any value regardless of
whether the current VO supports that value or whether there currently
even is any video. Possibly separate properties could be added to
query the conversion actually used at the moment, if any.
Because the colorspace and level settings are now set with a single
VF/VO control call, the return value of that is no longer used to
signal whether all the settings are actually supported. Instead code
should set all the details it can support, and ignore the rest. The
core will use GET_YUV_COLORSPACE to check which colorspace details
have been set and which not. In other words, the return value for
SET_YUV_COLORSPACE only signals whether any kind of YUV colorspace
conversion handling exists at all, and VOs have to take care to return
the actual state with GET_YUV_COLORSPACE instead.
To be changed in later commits: add missing option documentation.
2011-10-15 23:50:21 +02:00
|
|
|
|
2009-09-19 03:17:30 +02:00
|
|
|
if (!p->name)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (mp_property_do(pname, M_PROPERTY_GET_TYPE, &prop, mpctx) <= 0 || !prop)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (p->osd_progbar == -1)
|
|
|
|
mpctx->add_osd_seek_info = true;
|
|
|
|
else if (p->osd_progbar) {
|
|
|
|
if (prop->type == CONF_TYPE_INT) {
|
|
|
|
if (mp_property_do(pname, M_PROPERTY_GET, &r, mpctx) > 0)
|
2010-01-12 11:16:00 +01:00
|
|
|
set_osd_bar(mpctx, p->osd_progbar, mp_gtext(p->osd_msg),
|
2009-09-19 03:17:30 +02:00
|
|
|
prop->min, prop->max, r);
|
|
|
|
} else if (prop->type == CONF_TYPE_FLOAT) {
|
|
|
|
float f;
|
|
|
|
if (mp_property_do(pname, M_PROPERTY_GET, &f, mpctx) > 0)
|
2010-01-12 11:16:00 +01:00
|
|
|
set_osd_bar(mpctx, p->osd_progbar, mp_gtext(p->osd_msg),
|
2009-09-19 03:17:30 +02:00
|
|
|
prop->min, prop->max, f);
|
|
|
|
} else {
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_ERR,
|
|
|
|
"Property use an unsupported type.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p->osd_msg) {
|
|
|
|
char *val = mp_property_print(pname, mpctx);
|
|
|
|
if (val) {
|
|
|
|
int index = p - property_osd_display;
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, p->osd_id >= 0 ? p->osd_id : OSD_MSG_PROPERTY + index,
|
2010-01-12 11:16:00 +01:00
|
|
|
1, opts->osd_duration, p->osd_msg, val);
|
2011-07-03 19:04:21 +02:00
|
|
|
talloc_free(val);
|
2009-09-19 03:17:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2011-08-07 03:45:40 +02:00
|
|
|
* Command to property bridge
|
2007-02-21 01:49:24 +01:00
|
|
|
*
|
|
|
|
* It is used to handle most commands that just set a property
|
|
|
|
* and optionally display something on the OSD.
|
|
|
|
* Two kinds of commands are handled: adjust or toggle.
|
|
|
|
*
|
|
|
|
* Adjust commands take 1 or 2 parameters: <value> <abs>
|
|
|
|
* If <abs> is non-zero the property is set to the given value
|
|
|
|
* otherwise it is adjusted.
|
|
|
|
*
|
|
|
|
* Toggle commands take 0 or 1 parameters. With no parameter
|
|
|
|
* or a value less than the property minimum it just steps the
|
2010-12-11 13:44:39 +01:00
|
|
|
* property to its next or previous value respectively.
|
|
|
|
* Otherwise it sets it to the given value.
|
2007-02-21 01:49:24 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
/// List of the commands that can be handled by setting a property.
|
|
|
|
static struct {
|
|
|
|
/// property name
|
|
|
|
const char *name;
|
|
|
|
/// cmd id
|
|
|
|
int cmd;
|
|
|
|
/// set/adjust or toggle command
|
|
|
|
int toggle;
|
|
|
|
} set_prop_cmd[] = {
|
2007-07-09 16:52:46 +02:00
|
|
|
// general
|
2009-09-19 03:17:30 +02:00
|
|
|
{ "loop", MP_CMD_LOOP, 0},
|
|
|
|
{ "chapter", MP_CMD_SEEK_CHAPTER, 0},
|
|
|
|
{ "angle", MP_CMD_SWITCH_ANGLE, 0},
|
|
|
|
{ "pause", MP_CMD_PAUSE, 0},
|
2007-02-21 01:49:24 +01:00
|
|
|
// audio
|
2009-09-19 03:17:30 +02:00
|
|
|
{ "volume", MP_CMD_VOLUME, 0},
|
|
|
|
{ "mute", MP_CMD_MUTE, 1},
|
|
|
|
{ "audio_delay", MP_CMD_AUDIO_DELAY, 0},
|
|
|
|
{ "switch_audio", MP_CMD_SWITCH_AUDIO, 1},
|
|
|
|
{ "balance", MP_CMD_BALANCE, 0},
|
2007-02-21 01:49:24 +01:00
|
|
|
// video
|
2009-09-19 03:17:30 +02:00
|
|
|
{ "fullscreen", MP_CMD_VO_FULLSCREEN, 1},
|
|
|
|
{ "panscan", MP_CMD_PANSCAN, 0},
|
|
|
|
{ "ontop", MP_CMD_VO_ONTOP, 1},
|
|
|
|
{ "rootwin", MP_CMD_VO_ROOTWIN, 1},
|
|
|
|
{ "border", MP_CMD_VO_BORDER, 1},
|
|
|
|
{ "framedropping", MP_CMD_FRAMEDROPPING, 1},
|
|
|
|
{ "gamma", MP_CMD_GAMMA, 0},
|
|
|
|
{ "brightness", MP_CMD_BRIGHTNESS, 0},
|
|
|
|
{ "contrast", MP_CMD_CONTRAST, 0},
|
|
|
|
{ "saturation", MP_CMD_SATURATION, 0},
|
|
|
|
{ "hue", MP_CMD_HUE, 0},
|
|
|
|
{ "vsync", MP_CMD_SWITCH_VSYNC, 1},
|
|
|
|
// subs
|
|
|
|
{ "sub", MP_CMD_SUB_SELECT, 1},
|
|
|
|
{ "sub_source", MP_CMD_SUB_SOURCE, 1},
|
|
|
|
{ "sub_vob", MP_CMD_SUB_VOB, 1},
|
|
|
|
{ "sub_demux", MP_CMD_SUB_DEMUX, 1},
|
|
|
|
{ "sub_file", MP_CMD_SUB_FILE, 1},
|
|
|
|
{ "sub_pos", MP_CMD_SUB_POS, 0},
|
|
|
|
{ "sub_alignment", MP_CMD_SUB_ALIGNMENT, 1},
|
|
|
|
{ "sub_delay", MP_CMD_SUB_DELAY, 0},
|
|
|
|
{ "sub_visibility", MP_CMD_SUB_VISIBILITY, 1},
|
|
|
|
{ "sub_forced_only", MP_CMD_SUB_FORCED_ONLY, 1},
|
|
|
|
{ "sub_scale", MP_CMD_SUB_SCALE, 0},
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2009-09-19 03:17:30 +02:00
|
|
|
{ "ass_use_margins", MP_CMD_ASS_USE_MARGINS, 1},
|
2008-01-23 22:18:32 +01:00
|
|
|
#endif
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_TV
|
2009-09-19 03:17:30 +02:00
|
|
|
{ "tv_brightness", MP_CMD_TV_SET_BRIGHTNESS, 0},
|
|
|
|
{ "tv_hue", MP_CMD_TV_SET_HUE, 0},
|
|
|
|
{ "tv_saturation", MP_CMD_TV_SET_SATURATION, 0},
|
|
|
|
{ "tv_contrast", MP_CMD_TV_SET_CONTRAST, 0},
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
2009-09-19 03:17:30 +02:00
|
|
|
{}
|
2007-02-21 01:49:24 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/// Handle commands that set a property.
|
2011-08-07 03:45:40 +02:00
|
|
|
static bool set_property_command(MPContext *mpctx, mp_cmd_t *cmd)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
|
|
|
int i, r;
|
2010-05-29 16:15:55 +02:00
|
|
|
m_option_t *prop;
|
2007-05-29 23:49:39 +02:00
|
|
|
const char *pname;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
// look for the command
|
|
|
|
for (i = 0; set_prop_cmd[i].name; i++)
|
2010-05-04 01:34:38 +02:00
|
|
|
if (set_prop_cmd[i].cmd == cmd->id)
|
|
|
|
break;
|
2007-05-29 23:49:39 +02:00
|
|
|
if (!(pname = set_prop_cmd[i].name))
|
2010-05-04 01:34:38 +02:00
|
|
|
return 0;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
if (mp_property_do(pname, M_PROPERTY_GET_TYPE, &prop, mpctx) <= 0 || !prop)
|
2007-05-29 23:49:39 +02:00
|
|
|
return 0;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
// toggle command
|
|
|
|
if (set_prop_cmd[i].toggle) {
|
2010-05-04 01:34:38 +02:00
|
|
|
// set to value
|
|
|
|
if (cmd->nargs > 0 && cmd->args[0].v.i >= prop->min)
|
|
|
|
r = mp_property_do(pname, M_PROPERTY_SET, &cmd->args[0].v.i, mpctx);
|
2010-12-11 13:44:39 +01:00
|
|
|
else if (cmd->nargs > 0)
|
|
|
|
r = mp_property_do(pname, M_PROPERTY_STEP_DOWN, NULL, mpctx);
|
2010-05-04 01:34:38 +02:00
|
|
|
else
|
|
|
|
r = mp_property_do(pname, M_PROPERTY_STEP_UP, NULL, mpctx);
|
|
|
|
} else if (cmd->args[1].v.i) //set
|
|
|
|
r = mp_property_do(pname, M_PROPERTY_SET, &cmd->args[0].v, mpctx);
|
|
|
|
else // adjust
|
|
|
|
r = mp_property_do(pname, M_PROPERTY_STEP_UP, &cmd->args[0].v, mpctx);
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
if (r <= 0)
|
2010-05-04 01:34:38 +02:00
|
|
|
return 1;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2009-09-19 03:17:30 +02:00
|
|
|
show_property_osd(mpctx, pname);
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_DVDNAV
|
2008-06-19 20:51:42 +02:00
|
|
|
static const struct {
|
2011-08-07 03:45:40 +02:00
|
|
|
const char *name;
|
|
|
|
const enum mp_command_type cmd;
|
2008-06-19 20:51:42 +02:00
|
|
|
} mp_dvdnav_bindings[] = {
|
2011-08-07 03:45:40 +02:00
|
|
|
{ "up", MP_CMD_DVDNAV_UP },
|
|
|
|
{ "down", MP_CMD_DVDNAV_DOWN },
|
|
|
|
{ "left", MP_CMD_DVDNAV_LEFT },
|
|
|
|
{ "right", MP_CMD_DVDNAV_RIGHT },
|
|
|
|
{ "menu", MP_CMD_DVDNAV_MENU },
|
|
|
|
{ "select", MP_CMD_DVDNAV_SELECT },
|
|
|
|
{ "prev", MP_CMD_DVDNAV_PREVMENU },
|
|
|
|
{ "mouse", MP_CMD_DVDNAV_MOUSECLICK },
|
|
|
|
|
|
|
|
/*
|
|
|
|
* keep old dvdnav sub-command options for a while in order not to
|
|
|
|
* break slave-mode API too suddenly.
|
|
|
|
*/
|
|
|
|
{ "1", MP_CMD_DVDNAV_UP },
|
|
|
|
{ "2", MP_CMD_DVDNAV_DOWN },
|
|
|
|
{ "3", MP_CMD_DVDNAV_LEFT },
|
|
|
|
{ "4", MP_CMD_DVDNAV_RIGHT },
|
|
|
|
{ "5", MP_CMD_DVDNAV_MENU },
|
|
|
|
{ "6", MP_CMD_DVDNAV_SELECT },
|
|
|
|
{ "7", MP_CMD_DVDNAV_PREVMENU },
|
|
|
|
{ "8", MP_CMD_DVDNAV_MOUSECLICK },
|
|
|
|
{ NULL, 0 }
|
2008-06-19 20:51:42 +02:00
|
|
|
};
|
|
|
|
#endif
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2009-12-27 14:56:51 +01:00
|
|
|
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";
|
|
|
|
case M_PROPERTY_DISABLED:
|
|
|
|
return "DISABLED";
|
|
|
|
}
|
|
|
|
return "UNKNOWN";
|
|
|
|
}
|
|
|
|
|
2010-01-22 21:59:15 +01:00
|
|
|
static void remove_subtitle_range(MPContext *mpctx, int start, int count)
|
|
|
|
{
|
|
|
|
int idx;
|
|
|
|
int end = start + count;
|
|
|
|
int after = mpctx->set_of_sub_size - end;
|
|
|
|
sub_data **subs = mpctx->set_of_subtitles;
|
2010-01-22 22:10:40 +01:00
|
|
|
#ifdef CONFIG_ASS
|
2010-01-25 14:59:53 +01:00
|
|
|
struct ass_track **ass_tracks = mpctx->set_of_ass_tracks;
|
2010-01-22 22:10:40 +01:00
|
|
|
#endif
|
2010-01-22 21:59:15 +01:00
|
|
|
if (count < 0 || count > mpctx->set_of_sub_size ||
|
|
|
|
start < 0 || start > mpctx->set_of_sub_size - count) {
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_ERR,
|
|
|
|
"Cannot remove invalid subtitle range %i +%i\n", start, count);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (idx = start; idx < end; idx++) {
|
|
|
|
sub_data *subd = subs[idx];
|
2011-04-25 11:57:28 +02:00
|
|
|
char *filename = "";
|
|
|
|
if (subd)
|
|
|
|
filename = subd->filename;
|
|
|
|
#ifdef CONFIG_ASS
|
|
|
|
if (!subd)
|
|
|
|
filename = ass_tracks[idx]->name;
|
|
|
|
#endif
|
2010-01-22 21:59:15 +01:00
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_STATUS,
|
2012-07-31 01:35:53 +02:00
|
|
|
"SUB: Removed subtitle file (%d): %s\n", idx + 1, filename);
|
2010-01-22 21:59:15 +01:00
|
|
|
sub_free(subd);
|
|
|
|
subs[idx] = NULL;
|
2010-01-22 22:10:40 +01:00
|
|
|
#ifdef CONFIG_ASS
|
|
|
|
if (ass_tracks[idx])
|
|
|
|
ass_free_track(ass_tracks[idx]);
|
|
|
|
ass_tracks[idx] = NULL;
|
|
|
|
#endif
|
2010-01-22 21:59:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
mpctx->global_sub_size -= count;
|
|
|
|
mpctx->set_of_sub_size -= count;
|
|
|
|
if (mpctx->set_of_sub_size <= 0)
|
2010-07-10 22:48:50 +02:00
|
|
|
mpctx->sub_counts[SUB_SOURCE_SUBS] = 0;
|
2010-01-22 21:59:15 +01:00
|
|
|
|
|
|
|
memmove(subs + start, subs + end, after * sizeof(*subs));
|
|
|
|
memset(subs + start + after, 0, count * sizeof(*subs));
|
2010-01-22 22:10:40 +01:00
|
|
|
#ifdef CONFIG_ASS
|
|
|
|
memmove(ass_tracks + start, ass_tracks + end, after * sizeof(*ass_tracks));
|
|
|
|
memset(ass_tracks + start + after, 0, count * sizeof(*ass_tracks));
|
|
|
|
#endif
|
2010-01-22 21:59:15 +01:00
|
|
|
|
|
|
|
if (mpctx->set_of_sub_pos >= start && mpctx->set_of_sub_pos < end) {
|
|
|
|
mpctx->global_sub_pos = -2;
|
2011-01-11 16:48:45 +01:00
|
|
|
mpctx->subdata = NULL;
|
2011-01-12 14:15:02 +01:00
|
|
|
mpctx->osd->ass_track = NULL;
|
2010-01-25 14:59:53 +01:00
|
|
|
mp_input_queue_cmd(mpctx->input, mp_input_parse_cmd("sub_select"));
|
2010-01-22 21:59:15 +01:00
|
|
|
} else if (mpctx->set_of_sub_pos >= end) {
|
|
|
|
mpctx->set_of_sub_pos -= count;
|
|
|
|
mpctx->global_sub_pos -= count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-23 05:26:30 +02:00
|
|
|
static char *format_time(double time)
|
|
|
|
{
|
|
|
|
int h, m, s = time;
|
|
|
|
h = s / 3600;
|
|
|
|
s -= h * 3600;
|
|
|
|
m = s / 60;
|
|
|
|
s -= m * 60;
|
|
|
|
return talloc_asprintf(NULL, "%02d:%02d:%02d", h, m, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void show_chapters_on_osd(MPContext *mpctx)
|
|
|
|
{
|
|
|
|
int count = get_chapter_count(mpctx);
|
|
|
|
int cur = mpctx->demuxer ? 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 = format_time(t);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TEXT, 1, mpctx->opts.osd_duration, "%s", res);
|
2011-10-23 05:26:30 +02:00
|
|
|
talloc_free(res);
|
|
|
|
}
|
|
|
|
|
2011-10-24 02:41:17 +02:00
|
|
|
static void show_tracks_on_osd(MPContext *mpctx)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
|
|
|
demuxer_t *demuxer = mpctx->demuxer;
|
2012-08-03 12:24:55 +02:00
|
|
|
char *res = NULL;
|
2011-10-24 02:41:17 +02:00
|
|
|
|
|
|
|
if (!demuxer)
|
|
|
|
return;
|
|
|
|
|
2012-08-03 12:24:55 +02:00
|
|
|
struct sh_stream *cur_a = mpctx->sh_audio ? mpctx->sh_audio->gsh : NULL;
|
|
|
|
struct sh_stream *cur_s = NULL;
|
|
|
|
if (opts->sub_id >= 0 && mpctx->d_sub && mpctx->d_sub->sh)
|
|
|
|
cur_s = ((struct sh_sub *)mpctx->d_sub->sh)->gsh;
|
2011-10-24 02:41:17 +02:00
|
|
|
|
2012-08-03 12:24:55 +02:00
|
|
|
int v_count = 0;
|
|
|
|
enum stream_type t = STREAM_AUDIO;
|
2011-10-24 02:41:17 +02:00
|
|
|
|
2012-08-03 12:24:55 +02:00
|
|
|
for (int n = 0; n < demuxer->num_streams; n++) {
|
|
|
|
struct sh_stream *sh = demuxer->streams[n];
|
|
|
|
if (sh->type == STREAM_VIDEO) {
|
|
|
|
v_count++;
|
|
|
|
continue;
|
2011-10-24 02:41:17 +02:00
|
|
|
}
|
2012-08-03 12:24:55 +02:00
|
|
|
if (t != sh->type)
|
2011-10-24 02:41:17 +02:00
|
|
|
res = talloc_asprintf_append(res, "\n");
|
2012-08-03 12:24:55 +02:00
|
|
|
bool selected = sh == cur_a || sh == cur_s;
|
|
|
|
res = talloc_asprintf_append(res, "%s: ",
|
|
|
|
sh->type == STREAM_AUDIO ? "Audio" : "Sub");
|
|
|
|
if (selected)
|
|
|
|
res = talloc_asprintf_append(res, "> ");
|
|
|
|
res = talloc_asprintf_append(res, "(%d) ", sh->tid);
|
|
|
|
if (sh->title)
|
|
|
|
res = talloc_asprintf_append(res, "'%s' ", sh->title);
|
|
|
|
char *lang = demuxer_stream_lang(mpctx->demuxer, sh);
|
|
|
|
if (lang)
|
|
|
|
res = talloc_asprintf_append(res, "(%s) ", lang);
|
2012-08-04 03:32:12 +02:00
|
|
|
talloc_free(lang);
|
2012-08-03 12:24:55 +02:00
|
|
|
if (selected)
|
|
|
|
res = talloc_asprintf_append(res, "<");
|
|
|
|
res = talloc_asprintf_append(res, "\n");
|
|
|
|
t = sh->type;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (v_count > 1)
|
|
|
|
res = talloc_asprintf_append(res, "\n(Warning: more than one video stream.)\n");
|
2011-10-24 02:41:17 +02:00
|
|
|
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TEXT, 1, opts->osd_duration, "%s", res);
|
2011-10-24 02:41:17 +02:00
|
|
|
talloc_free(res);
|
|
|
|
}
|
|
|
|
|
2008-11-30 02:19:46 +01:00
|
|
|
void run_command(MPContext *mpctx, mp_cmd_t *cmd)
|
2007-02-21 01:49:24 +01:00
|
|
|
{
|
2008-04-21 05:55:23 +02:00
|
|
|
struct MPOpts *opts = &mpctx->opts;
|
2011-08-07 03:45:40 +02:00
|
|
|
sh_audio_t *const sh_audio = mpctx->sh_audio;
|
|
|
|
sh_video_t *const sh_video = mpctx->sh_video;
|
2009-03-30 01:06:58 +02:00
|
|
|
int osd_duration = opts->osd_duration;
|
2009-09-19 04:10:46 +02:00
|
|
|
int case_fallthrough_hack = 0;
|
2011-08-07 03:45:40 +02:00
|
|
|
if (set_property_command(mpctx, cmd))
|
|
|
|
goto old_pause_hack; // was handled already
|
|
|
|
switch (cmd->id) {
|
|
|
|
case MP_CMD_SEEK: {
|
|
|
|
mpctx->add_osd_seek_info = true;
|
|
|
|
float v = cmd->args[0].v.f;
|
|
|
|
int abs = (cmd->nargs > 1) ? cmd->args[1].v.i : 0;
|
|
|
|
int exact = (cmd->nargs > 2) ? cmd->args[2].v.i : 0;
|
|
|
|
if (abs == 2) { // Absolute seek to a timestamp in seconds
|
|
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, v, exact);
|
|
|
|
mpctx->osd_function = 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);
|
|
|
|
mpctx->osd_function = OSD_FFW; // Direction isn't set correctly
|
|
|
|
} else {
|
|
|
|
queue_seek(mpctx, MPSEEK_RELATIVE, v, exact);
|
|
|
|
mpctx->osd_function = (v > 0) ? OSD_FFW : OSD_REW;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SET_PROPERTY_OSD:
|
|
|
|
case_fallthrough_hack = 1;
|
|
|
|
|
|
|
|
case MP_CMD_SET_PROPERTY: {
|
|
|
|
int r = mp_property_do(cmd->args[0].v.s, M_PROPERTY_PARSE,
|
|
|
|
cmd->args[1].v.s, mpctx);
|
|
|
|
if (r == M_PROPERTY_UNKNOWN)
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_WARN,
|
|
|
|
"Unknown property: '%s'\n", cmd->args[0].v.s);
|
|
|
|
else if (r <= 0)
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_WARN,
|
|
|
|
"Failed to set property '%s' to '%s'.\n",
|
|
|
|
cmd->args[0].v.s, cmd->args[1].v.s);
|
|
|
|
else if (case_fallthrough_hack)
|
|
|
|
show_property_osd(mpctx, cmd->args[0].v.s);
|
|
|
|
if (r <= 0)
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO,
|
|
|
|
"ANS_ERROR=%s\n", property_error_string(r));
|
|
|
|
break;
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_STEP_PROPERTY_OSD:
|
|
|
|
case_fallthrough_hack = 1;
|
|
|
|
|
|
|
|
case MP_CMD_STEP_PROPERTY: {
|
|
|
|
void *arg = NULL;
|
|
|
|
int r, i;
|
|
|
|
double d;
|
|
|
|
off_t o;
|
|
|
|
if (cmd->args[1].v.f) {
|
|
|
|
m_option_t *prop;
|
|
|
|
if ((r = mp_property_do(cmd->args[0].v.s,
|
|
|
|
M_PROPERTY_GET_TYPE,
|
|
|
|
&prop, mpctx)) <= 0)
|
|
|
|
goto step_prop_err;
|
|
|
|
if (prop->type == CONF_TYPE_INT ||
|
|
|
|
prop->type == CONF_TYPE_FLAG)
|
|
|
|
i = cmd->args[1].v.f, arg = &i;
|
|
|
|
else if (prop->type == CONF_TYPE_FLOAT)
|
|
|
|
arg = &cmd->args[1].v.f;
|
|
|
|
else if (prop->type == CONF_TYPE_DOUBLE ||
|
|
|
|
prop->type == CONF_TYPE_TIME)
|
|
|
|
d = cmd->args[1].v.f, arg = &d;
|
|
|
|
else if (prop->type == CONF_TYPE_POSITION)
|
|
|
|
o = cmd->args[1].v.f, arg = &o;
|
|
|
|
else
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_WARN,
|
|
|
|
"Ignoring step size stepping property '%s'.\n",
|
|
|
|
cmd->args[0].v.s);
|
|
|
|
}
|
|
|
|
r = mp_property_do(cmd->args[0].v.s,
|
|
|
|
cmd->args[2].v.i < 0 ?
|
|
|
|
M_PROPERTY_STEP_DOWN : M_PROPERTY_STEP_UP,
|
|
|
|
arg, mpctx);
|
|
|
|
step_prop_err:
|
|
|
|
if (r == M_PROPERTY_UNKNOWN)
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_WARN,
|
|
|
|
"Unknown property: '%s'\n", cmd->args[0].v.s);
|
|
|
|
else if (r <= 0)
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_WARN,
|
|
|
|
"Failed to increment property '%s' by %f.\n",
|
|
|
|
cmd->args[0].v.s, cmd->args[1].v.f);
|
|
|
|
else if (case_fallthrough_hack)
|
|
|
|
show_property_osd(mpctx, cmd->args[0].v.s);
|
|
|
|
if (r <= 0)
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_ERROR=%s\n",
|
|
|
|
property_error_string(r));
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_PROPERTY: {
|
|
|
|
char *tmp;
|
|
|
|
int r = mp_property_do(cmd->args[0].v.s, M_PROPERTY_TO_STRING,
|
|
|
|
&tmp, mpctx);
|
|
|
|
if (r <= 0) {
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_WARN,
|
|
|
|
"Failed to get value of property '%s'.\n",
|
|
|
|
cmd->args[0].v.s);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_ERROR=%s\n",
|
|
|
|
property_error_string(r));
|
2010-05-04 01:34:38 +02:00
|
|
|
break;
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_%s=%s\n",
|
|
|
|
cmd->args[0].v.s, tmp);
|
|
|
|
talloc_free(tmp);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_EDL_MARK:
|
|
|
|
if (edl_fd) {
|
|
|
|
float v = get_current_time(mpctx);
|
|
|
|
if (mpctx->begin_skip == MP_NOPTS_VALUE) {
|
|
|
|
mpctx->begin_skip = v;
|
|
|
|
mp_tmsg(MSGT_CPLAYER, MSGL_INFO,
|
|
|
|
"EDL skip start, press 'i' again to end block.\n");
|
|
|
|
} else {
|
|
|
|
if (mpctx->begin_skip > v)
|
|
|
|
mp_tmsg(MSGT_CPLAYER, MSGL_WARN,
|
|
|
|
"EDL skip canceled, last start > stop\n");
|
|
|
|
else {
|
|
|
|
fprintf(edl_fd, "%f %f %d\n", mpctx->begin_skip, v, 0);
|
|
|
|
mp_tmsg(MSGT_CPLAYER, MSGL_INFO,
|
|
|
|
"EDL skip end, line written.\n");
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
mpctx->begin_skip = MP_NOPTS_VALUE;
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SWITCH_RATIO:
|
|
|
|
if (!sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
break;
|
2011-08-07 03:45:40 +02:00
|
|
|
if (cmd->nargs == 0 || cmd->args[0].v.f == -1)
|
|
|
|
opts->movie_aspect = (float) sh_video->disp_w / sh_video->disp_h;
|
|
|
|
else
|
|
|
|
opts->movie_aspect = cmd->args[0].v.f;
|
2011-11-14 19:12:20 +01:00
|
|
|
video_reset_aspect(sh_video);
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SPEED_INCR: {
|
|
|
|
float v = cmd->args[0].v.f;
|
|
|
|
mp_property_do("speed", M_PROPERTY_STEP_UP, &v, mpctx);
|
|
|
|
show_property_osd(mpctx, "speed");
|
|
|
|
break;
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SPEED_MULT:
|
|
|
|
case_fallthrough_hack = true;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SPEED_SET: {
|
|
|
|
float v = cmd->args[0].v.f;
|
|
|
|
if (case_fallthrough_hack)
|
|
|
|
v *= mpctx->opts.playback_speed;
|
|
|
|
mp_property_do("speed", M_PROPERTY_SET, &v, mpctx);
|
|
|
|
show_property_osd(mpctx, "speed");
|
|
|
|
break;
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_FRAME_STEP:
|
|
|
|
add_step_frame(mpctx);
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_QUIT:
|
2012-08-04 03:46:11 +02:00
|
|
|
mpctx->stop_play = PT_QUIT;
|
|
|
|
mpctx->quit_player_rc = (cmd->nargs > 0) ? cmd->args[0].v.i : 0;
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
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;
|
2011-08-07 03:45:40 +02:00
|
|
|
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
struct playlist_entry *e = playlist_get_next(mpctx->playlist, dir);
|
|
|
|
if (!e && !force)
|
|
|
|
break;
|
|
|
|
mpctx->playlist->current = e;
|
|
|
|
mpctx->playlist->current_was_replaced = false;
|
|
|
|
mpctx->stop_play = PT_CURRENT_ENTRY;
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SUB_STEP:
|
|
|
|
if (sh_video) {
|
|
|
|
int movement = cmd->args[0].v.i;
|
|
|
|
step_sub(mpctx->subdata, mpctx->video_pts, movement);
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_ASS
|
2011-08-07 03:45:40 +02:00
|
|
|
if (mpctx->osd->ass_track)
|
|
|
|
sub_delay +=
|
|
|
|
ass_step_sub(mpctx->osd->ass_track,
|
|
|
|
(mpctx->video_pts +
|
|
|
|
sub_delay) * 1000 + .5, movement) / 1000.;
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, OSD_MSG_SUB_DELAY, 1, osd_duration,
|
2011-08-07 03:45:40 +02:00
|
|
|
"Sub delay: %d ms", ROUND(sub_delay * 1000));
|
|
|
|
}
|
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SUB_LOG:
|
|
|
|
log_sub(mpctx);
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_OSD: {
|
|
|
|
int v = cmd->args[0].v.i;
|
|
|
|
int max = (opts->term_osd
|
|
|
|
&& !sh_video) ? MAX_TERM_OSD_LEVEL : MAX_OSD_LEVEL;
|
|
|
|
if (opts->osd_level > max)
|
|
|
|
opts->osd_level = max;
|
|
|
|
if (v < 0)
|
|
|
|
opts->osd_level = (opts->osd_level + 1) % (max + 1);
|
|
|
|
else
|
|
|
|
opts->osd_level = v > max ? max : v;
|
|
|
|
/* Show OSD state when disabled, but not when an explicit
|
|
|
|
argument is given to the OSD command, i.e. in slave mode. */
|
|
|
|
if (v == -1 && opts->osd_level <= 1)
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, OSD_MSG_OSD_STATUS, 0, osd_duration,
|
2011-08-07 03:45:40 +02:00
|
|
|
"OSD: %s",
|
|
|
|
opts->osd_level ? mp_gtext("enabled") :
|
|
|
|
mp_gtext("disabled"));
|
|
|
|
else
|
2012-08-04 03:50:23 +02:00
|
|
|
rm_osd_msg(mpctx, OSD_MSG_OSD_STATUS);
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case MP_CMD_OSD_SHOW_TEXT:
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TEXT, cmd->args[2].v.i,
|
2011-08-07 03:45:40 +02:00
|
|
|
(cmd->args[1].v.i <
|
|
|
|
0 ? osd_duration : cmd->args[1].v.i),
|
2011-08-08 10:07:17 +02:00
|
|
|
"%s", cmd->args[0].v.s);
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_OSD_SHOW_PROPERTY_TEXT: {
|
|
|
|
char *txt = m_properties_expand_string(mp_properties,
|
|
|
|
cmd->args[0].v.s,
|
|
|
|
mpctx);
|
|
|
|
// if no argument supplied use default osd_duration, else <arg> ms.
|
|
|
|
if (txt) {
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TEXT, cmd->args[2].v.i,
|
2010-05-04 01:34:38 +02:00
|
|
|
(cmd->args[1].v.i <
|
|
|
|
0 ? osd_duration : cmd->args[1].v.i),
|
2011-08-08 10:07:17 +02:00
|
|
|
"%s", txt);
|
2011-08-07 03:45:40 +02:00
|
|
|
free(txt);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_LOADFILE: {
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
char *filename = cmd->args[0].v.s;
|
|
|
|
bool append = cmd->args[1].v.i;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
if (!append)
|
|
|
|
playlist_clear(mpctx->playlist);
|
|
|
|
|
|
|
|
playlist_add(mpctx->playlist, playlist_entry_new(filename));
|
|
|
|
|
|
|
|
if (!append) {
|
|
|
|
mpctx->playlist->current = mpctx->playlist->first;
|
|
|
|
mpctx->playlist->current_was_replaced = false;
|
|
|
|
mpctx->stop_play = PT_CURRENT_ENTRY;
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_LOADLIST: {
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
char *filename = cmd->args[0].v.s;
|
|
|
|
bool append = cmd->args[1].v.i;
|
|
|
|
struct playlist *pl = playlist_parse_file(filename);
|
|
|
|
if (!pl) {
|
|
|
|
if (!append)
|
|
|
|
playlist_clear(mpctx->playlist);
|
|
|
|
playlist_transfer_entries(mpctx->playlist, pl);
|
|
|
|
talloc_free(pl);
|
|
|
|
|
|
|
|
if (!append)
|
|
|
|
mpctx->stop_play = PT_NEXT_ENTRY;
|
|
|
|
} else {
|
2011-08-07 03:45:40 +02:00
|
|
|
mp_tmsg(MSGT_CPLAYER, MSGL_ERR,
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
"\nUnable to load playlist %s.\n", filename);
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
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);
|
|
|
|
}
|
2012-02-10 19:03:24 +01:00
|
|
|
break;
|
mplayer: turn playtree into a list, and change per-file option handling
Summary:
- There is no playtree anymore. It's reduced to a simple list.
- Options are now always global. You can still have per-file options,
but these are optional and require special syntax.
- The slave command pt_step has been removed, and playlist_next
and playlist_prev added. (See etc/input.conf changes.)
This is a user visible incompatible change, and will break slave-mode
applications.
- The pt_clear slave command is renamed to playlist_clear.
- Playtree entries could have multiple files. This is not the case
anymore, and playlist entries have always exactly one entry. Whenever
something adds more than one file (like ASX playlists or dvd:// or
dvdnav:// on the command line), all files are added as separate
playlist entries.
Note that some of the changes are quite deep and violent. Expect
regressions.
The playlist parsing code in particular is of low quality. I didn't try
to improve it, and merely spent to least effort necessary to keep it
somehow working. (Especially ASX playlist handling.)
The playtree code was complicated and bloated. It was also barely used.
Most users don't even know that mplayer manages the playlist as tree,
or how to use it. The most obscure features was probably specifying a
tree on command line (with '{' and '}' to create/close tree nodes). It
filled the player code with complexity and confused users with weird
slave commands like pt_up.
Replace the playtree with a simple flat playlist. Playlist parsers that
actually return trees are changed to append all files to the playlist
pre-order.
It used to be the responsibility of the playtree code to change per-file
config options. Now this is done by the player core, and the playlist
code is free of such details.
Options are not per-file by default anymore. This was a very obscure and
complicated feature that confused even experienced users. Consider the
following command line:
mplayer file1.mkv file2.mkv --no-audio file3.mkv
This will disable the audio for file2.mkv only, because options are
per-file by default. To make the option affect all files, you're
supposed to put it before the first file.
This is bad, because normally you don't need per-file options. They are
very rarely needed, and the only reasonable use cases I can imagine are
use of the encode backend (mplayer encode branch), or for debugging. The
normal use case is made harder, and the feature is perceived as bug.
Even worse, correct usage is hard to explain for users.
Make all options global by default. The position of an option isn't
significant anymore (except for options that compensate each other,
consider --shuffle --no-shuffle).
One other important change is that no options are reset anymore if a
new file is started. If you change settings with slave mode commands,
they will not be changed by playing a new file. (Exceptions include
settings that are too file specific, like audio/subtitle stream
selection.)
There is still some need for per-file options. Debugging and encoding
are use cases that profit from per-file options. Per-file profiles (as
well as per-protocol and per-VO/AO options) need the implementation
related mechanisms to backup and restore options when the playback file
changes.
Simplify the save-slot stuff, which is possible because there is no
hierarchical play tree anymore. Now there's a simple backup field.
Add a way to specify per-file options on command line. Example:
mplayer f1.mkv -o0 --{ -o1 f2.mkv -o2 f3.mkv --} f4.mkv -o3
will have the following options per file set:
f1.mkv, f4.mkv: -o0 -o3
f2.mkv, f3.mkv: -o0 -o3 -o1 -o2
The options --{ and --} start and end per-file options. All files inside
the { } will be affected by the options equally (similar to how global
options and multiple files are handled). When playback of a file starts,
the per-file options are set according to the command line. When
playback ends, the per-file options are restored to the values when
playback started.
2012-07-31 21:33:26 +02:00
|
|
|
}
|
2012-02-10 19:03:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_STOP:
|
|
|
|
// Go back to the starting point.
|
|
|
|
mpctx->stop_play = PT_STOP;
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2012-08-01 00:39:49 +02:00
|
|
|
case MP_CMD_OSD_SHOW_PROGRESSION:
|
|
|
|
mp_show_osd_progression(mpctx);
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2010-04-09 21:20:52 +02:00
|
|
|
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_RADIO
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_RADIO_STEP_CHANNEL:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->demuxer->stream->type == STREAMTYPE_RADIO) {
|
2011-08-07 03:45:40 +02:00
|
|
|
int v = cmd->args[0].v.i;
|
|
|
|
if (v > 0)
|
|
|
|
radio_step_channel(mpctx->demuxer->stream,
|
|
|
|
RADIO_CHANNEL_HIGHER);
|
|
|
|
else
|
|
|
|
radio_step_channel(mpctx->demuxer->stream,
|
|
|
|
RADIO_CHANNEL_LOWER);
|
|
|
|
if (radio_get_channel_name(mpctx->demuxer->stream)) {
|
|
|
|
set_osd_tmsg(OSD_MSG_RADIO_CHANNEL, 1, osd_duration,
|
|
|
|
"Channel: %s",
|
|
|
|
radio_get_channel_name(mpctx->demuxer->stream));
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_RADIO_SET_CHANNEL:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->demuxer->stream->type == STREAMTYPE_RADIO) {
|
2011-08-07 03:45:40 +02:00
|
|
|
radio_set_channel(mpctx->demuxer->stream, cmd->args[0].v.s);
|
|
|
|
if (radio_get_channel_name(mpctx->demuxer->stream)) {
|
|
|
|
set_osd_tmsg(OSD_MSG_RADIO_CHANNEL, 1, osd_duration,
|
|
|
|
"Channel: %s",
|
|
|
|
radio_get_channel_name(mpctx->demuxer->stream));
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_RADIO_SET_FREQ:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->demuxer->stream->type == STREAMTYPE_RADIO)
|
2011-08-07 03:45:40 +02:00
|
|
|
radio_set_freq(mpctx->demuxer->stream, cmd->args[0].v.f);
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_RADIO_STEP_FREQ:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->demuxer->stream->type == STREAMTYPE_RADIO)
|
2011-08-07 03:45:40 +02:00
|
|
|
radio_step_freq(mpctx->demuxer->stream, cmd->args[0].v.f);
|
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
|
|
|
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_TV
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_TV_START_SCAN:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV)
|
2011-08-07 03:45:40 +02:00
|
|
|
tv_start_scan((tvi_handle_t *) (mpctx->demuxer->priv), 1);
|
|
|
|
break;
|
|
|
|
case MP_CMD_TV_SET_FREQ:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV)
|
2011-08-07 03:45:40 +02:00
|
|
|
tv_set_freq((tvi_handle_t *) (mpctx->demuxer->priv),
|
|
|
|
cmd->args[0].v.f * 16.0);
|
2008-08-03 17:21:40 +02:00
|
|
|
#ifdef CONFIG_PVR
|
2011-08-07 03:45:40 +02:00
|
|
|
else if (mpctx->stream && mpctx->stream->type == STREAMTYPE_PVR) {
|
|
|
|
pvr_set_freq(mpctx->stream, ROUND(cmd->args[0].v.f));
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: %s",
|
2011-08-07 03:45:40 +02:00
|
|
|
pvr_get_current_channelname(mpctx->stream),
|
|
|
|
pvr_get_current_stationname(mpctx->stream));
|
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#endif /* CONFIG_PVR */
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_TV_STEP_FREQ:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV)
|
2011-08-07 03:45:40 +02:00
|
|
|
tv_step_freq((tvi_handle_t *) (mpctx->demuxer->priv),
|
|
|
|
cmd->args[0].v.f * 16.0);
|
2008-08-03 17:21:40 +02:00
|
|
|
#ifdef CONFIG_PVR
|
2011-08-07 03:45:40 +02:00
|
|
|
else if (mpctx->stream && mpctx->stream->type == STREAMTYPE_PVR) {
|
|
|
|
pvr_force_freq_step(mpctx->stream, ROUND(cmd->args[0].v.f));
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: f %d",
|
2011-08-07 03:45:40 +02:00
|
|
|
pvr_get_current_channelname(mpctx->stream),
|
|
|
|
pvr_get_current_frequency(mpctx->stream));
|
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#endif /* CONFIG_PVR */
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_TV_SET_NORM:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV)
|
2011-08-07 03:45:40 +02:00
|
|
|
tv_set_norm((tvi_handle_t *) (mpctx->demuxer->priv),
|
|
|
|
cmd->args[0].v.s);
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_TV_STEP_CHANNEL:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV) {
|
2011-08-07 03:45:40 +02:00
|
|
|
int v = cmd->args[0].v.i;
|
|
|
|
if (v > 0) {
|
|
|
|
tv_step_channel((tvi_handle_t *) (mpctx->
|
|
|
|
demuxer->priv),
|
|
|
|
TV_CHANNEL_HIGHER);
|
|
|
|
} else {
|
|
|
|
tv_step_channel((tvi_handle_t *) (mpctx->
|
|
|
|
demuxer->priv),
|
|
|
|
TV_CHANNEL_LOWER);
|
|
|
|
}
|
|
|
|
if (tv_channel_list) {
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, OSD_MSG_TV_CHANNEL, 1, osd_duration,
|
2011-08-07 03:45:40 +02:00
|
|
|
"Channel: %s", tv_channel_current->name);
|
|
|
|
//vo_osd_changed(OSDTYPE_SUBTITLE);
|
|
|
|
}
|
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#ifdef CONFIG_PVR
|
2011-08-07 03:45:40 +02:00
|
|
|
else if (mpctx->stream &&
|
|
|
|
mpctx->stream->type == STREAMTYPE_PVR) {
|
|
|
|
pvr_set_channel_step(mpctx->stream, cmd->args[0].v.i);
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: %s",
|
2011-08-07 03:45:40 +02:00
|
|
|
pvr_get_current_channelname(mpctx->stream),
|
|
|
|
pvr_get_current_stationname(mpctx->stream));
|
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#endif /* CONFIG_PVR */
|
|
|
|
#ifdef CONFIG_DVBIN
|
2011-08-07 03:45:40 +02:00
|
|
|
if (mpctx->stream->type == STREAMTYPE_DVB) {
|
|
|
|
int dir;
|
|
|
|
int v = cmd->args[0].v.i;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
mpctx->last_dvb_step = v;
|
|
|
|
if (v > 0)
|
|
|
|
dir = DVB_CHANNEL_HIGHER;
|
|
|
|
else
|
|
|
|
dir = DVB_CHANNEL_LOWER;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
if (dvb_step_channel(mpctx->stream, dir)) {
|
|
|
|
mpctx->stop_play = PT_NEXT_ENTRY;
|
|
|
|
mpctx->dvbin_reopen = 1;
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#endif /* CONFIG_DVBIN */
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_TV_SET_CHANNEL:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV) {
|
2011-08-07 03:45:40 +02:00
|
|
|
tv_set_channel((tvi_handle_t *) (mpctx->demuxer->priv),
|
|
|
|
cmd->args[0].v.s);
|
|
|
|
if (tv_channel_list) {
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, OSD_MSG_TV_CHANNEL, 1, osd_duration,
|
2011-08-07 03:45:40 +02:00
|
|
|
"Channel: %s", tv_channel_current->name);
|
|
|
|
//vo_osd_changed(OSDTYPE_SUBTITLE);
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#ifdef CONFIG_PVR
|
2011-08-07 03:45:40 +02:00
|
|
|
else if (mpctx->stream && mpctx->stream->type == STREAMTYPE_PVR) {
|
|
|
|
pvr_set_channel(mpctx->stream, cmd->args[0].v.s);
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: %s",
|
2011-08-07 03:45:40 +02:00
|
|
|
pvr_get_current_channelname(mpctx->stream),
|
|
|
|
pvr_get_current_stationname(mpctx->stream));
|
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#endif /* CONFIG_PVR */
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2008-08-03 17:21:40 +02:00
|
|
|
#ifdef CONFIG_DVBIN
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_DVB_SET_CHANNEL:
|
|
|
|
if (mpctx->stream->type == STREAMTYPE_DVB) {
|
|
|
|
mpctx->last_dvb_step = 1;
|
|
|
|
|
|
|
|
if (dvb_set_channel(mpctx->stream, cmd->args[1].v.i,
|
|
|
|
cmd->args[0].v.i)) {
|
|
|
|
mpctx->stop_play = PT_NEXT_ENTRY;
|
|
|
|
mpctx->dvbin_reopen = 1;
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
|
|
|
break;
|
2008-08-03 17:21:40 +02:00
|
|
|
#endif /* CONFIG_DVBIN */
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_TV_LAST_CHANNEL:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV) {
|
2011-08-07 03:45:40 +02:00
|
|
|
tv_last_channel((tvi_handle_t *) (mpctx->demuxer->priv));
|
|
|
|
if (tv_channel_list) {
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_tmsg(mpctx, OSD_MSG_TV_CHANNEL, 1, osd_duration,
|
2011-08-07 03:45:40 +02:00
|
|
|
"Channel: %s", tv_channel_current->name);
|
|
|
|
//vo_osd_changed(OSDTYPE_SUBTITLE);
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#ifdef CONFIG_PVR
|
2011-08-07 03:45:40 +02:00
|
|
|
else if (mpctx->stream && mpctx->stream->type == STREAMTYPE_PVR) {
|
|
|
|
pvr_set_lastchannel(mpctx->stream);
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: %s",
|
2011-08-07 03:45:40 +02:00
|
|
|
pvr_get_current_channelname(mpctx->stream),
|
|
|
|
pvr_get_current_stationname(mpctx->stream));
|
|
|
|
}
|
2008-08-03 17:21:40 +02:00
|
|
|
#endif /* CONFIG_PVR */
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_TV_STEP_NORM:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV)
|
2011-08-07 03:45:40 +02:00
|
|
|
tv_step_norm((tvi_handle_t *) (mpctx->demuxer->priv));
|
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_TV_STEP_CHANNEL_LIST:
|
mplayer: fix idle mode regressions
Commit 89a17bcda6c16 simplified the idle loop to run any commands
mplayer receives, not just playlist related commands. Unfortunately, it
turns out many slave commands always assume the presence of a demuxer.
MPContext->demuxer is assumed not to be NULL. This made the player
crash when receiving slave commands like pause/unpause, chapter
control, subtitle selection.
We want mplayer being able to handle this. Any slave command or
property, as long as it's backed by a persistent setting, should be run
successfully, even if no file is being played. If the slave command
doesn't make sense in this state, it shouldn't crash the player.
Insert some NULL checks when accessing demuxers. If sh_video or
sh_audio are not NULL, assume demuxer can't be NULL.
(There actually aren't that many properties which need to be changed. If
it gets too complicated, we could employ alternative mechanisms instead,
such as explicitly marking safe properties with a flag.)
2012-08-04 02:00:28 +02:00
|
|
|
if (mpctx->demuxer && mpctx->file_format == DEMUXER_TYPE_TV)
|
2011-08-07 03:45:40 +02:00
|
|
|
tv_step_chanlist((tvi_handle_t *) (mpctx->demuxer->priv));
|
|
|
|
break;
|
2009-11-07 13:31:05 +01:00
|
|
|
#endif /* CONFIG_TV */
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SUB_LOAD:
|
|
|
|
if (sh_video) {
|
|
|
|
int n = mpctx->set_of_sub_size;
|
|
|
|
add_subtitles(mpctx, cmd->args[0].v.s, sh_video->fps, 0);
|
|
|
|
if (n != mpctx->set_of_sub_size) {
|
|
|
|
mpctx->sub_counts[SUB_SOURCE_SUBS]++;
|
|
|
|
++mpctx->global_sub_size;
|
2010-05-04 01:34:38 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SUB_REMOVE:
|
|
|
|
if (sh_video) {
|
|
|
|
int v = cmd->args[0].v.i;
|
|
|
|
if (v < 0)
|
|
|
|
remove_subtitle_range(mpctx, 0, mpctx->set_of_sub_size);
|
|
|
|
else if (v < mpctx->set_of_sub_size)
|
|
|
|
remove_subtitle_range(mpctx, v, 1);
|
|
|
|
}
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_SUB_VISIBILITY:
|
|
|
|
if (sh_video) {
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO,
|
|
|
|
"ANS_SUB_VISIBILITY=%d\n", sub_visibility);
|
|
|
|
}
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SCREENSHOT:
|
2011-10-06 20:46:01 +02:00
|
|
|
screenshot_request(mpctx, cmd->args[0].v.i, cmd->args[1].v.i);
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_VF_CHANGE_RECTANGLE:
|
|
|
|
if (!sh_video)
|
2010-05-04 01:34:38 +02:00
|
|
|
break;
|
2011-08-07 03:45:40 +02:00
|
|
|
set_rectangle(sh_video, cmd->args[0].v.i, cmd->args[1].v.i);
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_TIME_LENGTH:
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_LENGTH=%.2f\n",
|
|
|
|
get_time_length(mpctx));
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_FILENAME: {
|
|
|
|
char *inf = get_metadata(mpctx, META_NAME);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_FILENAME='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_VIDEO_CODEC: {
|
|
|
|
char *inf = get_metadata(mpctx, META_VIDEO_CODEC);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_VIDEO_CODEC='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_VIDEO_BITRATE: {
|
|
|
|
char *inf = get_metadata(mpctx, META_VIDEO_BITRATE);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_VIDEO_BITRATE='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_VIDEO_RESOLUTION: {
|
|
|
|
char *inf = get_metadata(mpctx, META_VIDEO_RESOLUTION);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_VIDEO_RESOLUTION='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_AUDIO_CODEC: {
|
|
|
|
char *inf = get_metadata(mpctx, META_AUDIO_CODEC);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_AUDIO_CODEC='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_AUDIO_BITRATE: {
|
|
|
|
char *inf = get_metadata(mpctx, META_AUDIO_BITRATE);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_AUDIO_BITRATE='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_AUDIO_SAMPLES: {
|
|
|
|
char *inf = get_metadata(mpctx, META_AUDIO_SAMPLES);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_AUDIO_SAMPLES='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_META_TITLE: {
|
|
|
|
char *inf = get_metadata(mpctx, META_INFO_TITLE);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_META_TITLE='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_META_ARTIST: {
|
|
|
|
char *inf = get_metadata(mpctx, META_INFO_ARTIST);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_META_ARTIST='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_META_ALBUM: {
|
|
|
|
char *inf = get_metadata(mpctx, META_INFO_ALBUM);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_META_ALBUM='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_META_YEAR: {
|
|
|
|
char *inf = get_metadata(mpctx, META_INFO_YEAR);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_META_YEAR='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_META_COMMENT: {
|
|
|
|
char *inf = get_metadata(mpctx, META_INFO_COMMENT);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_META_COMMENT='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_META_TRACK: {
|
|
|
|
char *inf = get_metadata(mpctx, META_INFO_TRACK);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_META_TRACK='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_META_GENRE: {
|
|
|
|
char *inf = get_metadata(mpctx, META_INFO_GENRE);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_META_GENRE='%s'\n", inf);
|
|
|
|
talloc_free(inf);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_VO_FULLSCREEN:
|
|
|
|
if (mpctx->video_out && mpctx->video_out->config_ok)
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_VO_FULLSCREEN=%d\n", vo_fs);
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_PERCENT_POS:
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_PERCENT_POSITION=%d\n",
|
|
|
|
get_percent_pos(mpctx));
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_GET_TIME_POS: {
|
|
|
|
float pos = get_current_time(mpctx);
|
|
|
|
mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_TIME_POSITION=%.1f\n", pos);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_RUN:
|
2007-02-21 01:49:24 +01:00
|
|
|
#ifndef __MINGW32__
|
2011-08-07 03:45:40 +02:00
|
|
|
if (!fork()) {
|
2012-08-12 19:57:35 +02:00
|
|
|
char *exp_cmd = property_expand_string(mpctx, cmd->args[0].v.s);
|
|
|
|
if (exp_cmd) {
|
|
|
|
execl("/bin/sh", "sh", "-c", exp_cmd, NULL);
|
|
|
|
free(exp_cmd);
|
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
exit(0);
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_KEYDOWN_EVENTS:
|
|
|
|
mplayer_put_key(mpctx->key_fifo, cmd->args[0].v.i);
|
|
|
|
break;
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SET_MOUSE_POS: {
|
|
|
|
int pointer_x, pointer_y;
|
|
|
|
double dx, dy;
|
|
|
|
pointer_x = cmd->args[0].v.i;
|
|
|
|
pointer_y = cmd->args[1].v.i;
|
|
|
|
rescale_input_coordinates(mpctx, pointer_x, pointer_y, &dx, &dy);
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_DVDNAV
|
2011-08-07 03:45:40 +02:00
|
|
|
if (mpctx->stream->type == STREAMTYPE_DVDNAV
|
|
|
|
&& dx > 0.0 && dy > 0.0) {
|
|
|
|
int button = -1;
|
|
|
|
pointer_x = (int) (dx * (double) sh_video->disp_w);
|
|
|
|
pointer_y = (int) (dy * (double) sh_video->disp_h);
|
|
|
|
mp_dvdnav_update_mouse_pos(mpctx->stream,
|
|
|
|
pointer_x, pointer_y, &button);
|
|
|
|
if (opts->osd_level > 1 && button > 0)
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TEXT, 1, osd_duration,
|
2011-08-07 03:45:40 +02:00
|
|
|
"Selected button number %d", button);
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
2011-08-07 03:45:40 +02:00
|
|
|
break;
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2008-07-30 14:01:30 +02:00
|
|
|
#ifdef CONFIG_DVDNAV
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_DVDNAV: {
|
|
|
|
int button = -1;
|
|
|
|
int i;
|
|
|
|
enum mp_command_type command = 0;
|
|
|
|
if (mpctx->stream->type != STREAMTYPE_DVDNAV)
|
|
|
|
break;
|
|
|
|
|
|
|
|
for (i = 0; mp_dvdnav_bindings[i].name; i++)
|
|
|
|
if (cmd->args[0].v.s &&
|
|
|
|
!strcasecmp(cmd->args[0].v.s,
|
|
|
|
mp_dvdnav_bindings[i].name))
|
|
|
|
command = mp_dvdnav_bindings[i].cmd;
|
|
|
|
|
|
|
|
mp_dvdnav_handle_input(mpctx->stream, command, &button);
|
|
|
|
if (opts->osd_level > 1 && button > 0)
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TEXT, 1, osd_duration,
|
2011-08-07 03:45:40 +02:00
|
|
|
"Selected button number %d", button);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-04 01:34:38 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_SWITCH_TITLE:
|
|
|
|
if (mpctx->stream->type == STREAMTYPE_DVDNAV)
|
|
|
|
mp_dvdnav_switch_title(mpctx->stream, cmd->args[0].v.i);
|
|
|
|
break;
|
2008-01-24 20:14:05 +01:00
|
|
|
|
2007-02-21 01:49:24 +01:00
|
|
|
#endif
|
|
|
|
|
2012-08-01 01:06:59 +02:00
|
|
|
case MP_CMD_VO_CMDLINE:
|
|
|
|
if (mpctx->video_out) {
|
|
|
|
char *s = cmd->args[0].v.s;
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_INFO, "Setting vo cmd line to '%s'.\n",
|
|
|
|
s);
|
|
|
|
if (vo_control(mpctx->video_out, VOCTRL_SET_COMMAND_LINE, s) > 0) {
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TEXT, 1, osd_duration, "vo='%s'", s);
|
2012-08-01 01:06:59 +02:00
|
|
|
} else {
|
2012-08-04 03:50:23 +02:00
|
|
|
set_osd_msg(mpctx, OSD_MSG_TEXT, 1, osd_duration, "Failed!");
|
2012-08-01 01:06:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2010-04-11 20:59:19 +02:00
|
|
|
case MP_CMD_AF_SWITCH:
|
2011-08-07 03:45:40 +02:00
|
|
|
if (sh_audio) {
|
2010-04-11 20:59:19 +02:00
|
|
|
af_uninit(mpctx->mixer.afilter);
|
|
|
|
af_init(mpctx->mixer.afilter);
|
|
|
|
}
|
|
|
|
case MP_CMD_AF_ADD:
|
2011-08-07 03:45:40 +02:00
|
|
|
case MP_CMD_AF_DEL: {
|
2010-04-11 20:59:19 +02:00
|
|
|
if (!sh_audio)
|
|
|
|
break;
|
2011-08-07 03:45:40 +02:00
|
|
|
char *af_args = strdup(cmd->args[0].v.s);
|
|
|
|
char *af_commands = af_args;
|
|
|
|
char *af_command;
|
|
|
|
af_instance_t *af;
|
|
|
|
while ((af_command = strsep(&af_commands, ",")) != NULL) {
|
|
|
|
if (cmd->id == MP_CMD_AF_DEL) {
|
|
|
|
af = af_get(mpctx->mixer.afilter, af_command);
|
|
|
|
if (af != NULL)
|
|
|
|
af_remove(mpctx->mixer.afilter, af);
|
|
|
|
} else
|
|
|
|
af_add(mpctx->mixer.afilter, af_command);
|
2010-04-11 20:59:19 +02:00
|
|
|
}
|
2011-08-07 03:45:40 +02:00
|
|
|
reinit_audio_chain(mpctx);
|
|
|
|
free(af_args);
|
2010-04-11 20:59:19 +02:00
|
|
|
break;
|
2011-08-07 03:45:40 +02:00
|
|
|
}
|
2010-04-11 20:59:19 +02:00
|
|
|
case MP_CMD_AF_CLR:
|
|
|
|
if (!sh_audio)
|
|
|
|
break;
|
|
|
|
af_uninit(mpctx->mixer.afilter);
|
|
|
|
af_init(mpctx->mixer.afilter);
|
2010-11-26 21:52:35 +01:00
|
|
|
reinit_audio_chain(mpctx);
|
2010-04-11 20:59:19 +02:00
|
|
|
break;
|
2010-10-17 17:54:55 +02:00
|
|
|
case MP_CMD_AF_CMDLINE:
|
|
|
|
if (sh_audio) {
|
|
|
|
af_instance_t *af = af_get(sh_audio->afilter, cmd->args[0].v.s);
|
|
|
|
if (!af) {
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_WARN,
|
|
|
|
"Filter '%s' not found in chain.\n", cmd->args[0].v.s);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
af->control(af, AF_CONTROL_COMMAND_LINE, cmd->args[1].v.s);
|
|
|
|
af_reinit(sh_audio->afilter, af);
|
|
|
|
}
|
|
|
|
break;
|
2011-10-23 05:26:30 +02:00
|
|
|
case MP_CMD_SHOW_CHAPTERS:
|
|
|
|
show_chapters_on_osd(mpctx);
|
|
|
|
break;
|
2011-10-24 02:41:17 +02:00
|
|
|
case MP_CMD_SHOW_TRACKS:
|
|
|
|
show_tracks_on_osd(mpctx);
|
|
|
|
break;
|
2010-10-17 17:54:55 +02:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
default:
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_V,
|
|
|
|
"Received unknown cmd %s\n", cmd->name);
|
|
|
|
}
|
2007-02-21 01:49:24 +01:00
|
|
|
|
2011-08-07 03:45:40 +02:00
|
|
|
old_pause_hack:
|
2007-02-21 01:49:24 +01:00
|
|
|
switch (cmd->pausing) {
|
2010-05-04 01:34:38 +02:00
|
|
|
case 1: // "pausing"
|
2008-11-29 07:09:57 +01:00
|
|
|
pause_player(mpctx);
|
2010-05-04 01:34:38 +02:00
|
|
|
break;
|
|
|
|
case 3: // "pausing_toggle"
|
2008-11-29 07:09:57 +01:00
|
|
|
if (mpctx->paused)
|
|
|
|
unpause_player(mpctx);
|
|
|
|
else
|
|
|
|
pause_player(mpctx);
|
2010-05-04 01:34:38 +02:00
|
|
|
break;
|
2007-02-21 01:49:24 +01:00
|
|
|
}
|
|
|
|
}
|