mirror of
https://github.com/mpv-player/mpv
synced 2024-12-21 06:14:32 +00:00
e8a77e5279
A bit of a long standing pain with scripting is that when opening a file that gets interpreted as a playlist (like an m3u), the original path of the file gets thrown away later. Workarounds basically consist of getting the filename before mpv expands the path, but that's not really reliable. Instead of throwing it away, save the original playlist path by copying to the playlist entries when applicable (demuxer playlist and the playlist option). Then expose these as properties: playlist-path for the currently playing entry and playlist/N/playlist-path for each specific entry. Closes #8508, #7605.
262 lines
8.1 KiB
C
262 lines
8.1 KiB
C
/*
|
|
* This file is part of mpv.
|
|
*
|
|
* mpv is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* mpv is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
#include <stdbool.h>
|
|
|
|
#include "osdep/io.h"
|
|
#include "common/global.h"
|
|
#include "common/msg.h"
|
|
#include "common/msg_control.h"
|
|
#include "m_option.h"
|
|
#include "m_config_frontend.h"
|
|
#include "options.h"
|
|
#include "common/playlist.h"
|
|
#include "parse_commandline.h"
|
|
|
|
#define GLOBAL 0
|
|
#define LOCAL 1
|
|
|
|
struct parse_state {
|
|
struct m_config *config;
|
|
char **argv;
|
|
struct mp_log *log; // silent if NULL
|
|
|
|
bool no_more_opts;
|
|
bool error;
|
|
|
|
bool is_opt;
|
|
struct bstr arg;
|
|
struct bstr param;
|
|
};
|
|
|
|
// Returns true if more args, false if all parsed or an error occurred.
|
|
static bool split_opt(struct parse_state *p)
|
|
{
|
|
assert(!p->error);
|
|
|
|
if (!p->argv || !p->argv[0])
|
|
return false;
|
|
|
|
p->is_opt = false;
|
|
p->arg = bstr0(p->argv[0]);
|
|
p->param = bstr0(NULL);
|
|
|
|
p->argv++;
|
|
|
|
if (p->no_more_opts || !bstr_startswith0(p->arg, "-") || p->arg.len == 1)
|
|
return true;
|
|
|
|
if (bstrcmp0(p->arg, "--") == 0) {
|
|
p->no_more_opts = true;
|
|
return split_opt(p);
|
|
}
|
|
|
|
p->is_opt = true;
|
|
|
|
bool new_opt = bstr_eatstart0(&p->arg, "--");
|
|
if (!new_opt)
|
|
bstr_eatstart0(&p->arg, "-");
|
|
|
|
bool ambiguous = !bstr_split_tok(p->arg, "=", &p->arg, &p->param);
|
|
|
|
bool need_param = m_config_option_requires_param(p->config, p->arg) > 0;
|
|
|
|
if (ambiguous && need_param) {
|
|
if (!p->argv[0] || new_opt) {
|
|
p->error = true;
|
|
MP_FATAL(p, "Error parsing commandline option %.*s: %s\n",
|
|
BSTR_P(p->arg), m_option_strerror(M_OPT_MISSING_PARAM));
|
|
MP_WARN(p, "Make sure you're using e.g. '--%.*s=value' instead "
|
|
"of '--%.*s value'.\n", BSTR_P(p->arg), BSTR_P(p->arg));
|
|
return false;
|
|
}
|
|
p->param = bstr0(p->argv[0]);
|
|
p->argv++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#ifdef __MINGW32__
|
|
static void process_non_option(struct playlist *files, const char *arg)
|
|
{
|
|
glob_t gg;
|
|
|
|
// Glob filenames on Windows (cmd.exe doesn't do this automatically)
|
|
if (glob(arg, 0, NULL, &gg)) {
|
|
playlist_add_file(files, arg);
|
|
} else {
|
|
for (int i = 0; i < gg.gl_pathc; i++)
|
|
playlist_add_file(files, gg.gl_pathv[i]);
|
|
|
|
globfree(&gg);
|
|
}
|
|
}
|
|
#else
|
|
static void process_non_option(struct playlist *files, const char *arg)
|
|
{
|
|
playlist_add_file(files, arg);
|
|
}
|
|
#endif
|
|
|
|
// returns M_OPT_... error code
|
|
int m_config_parse_mp_command_line(m_config_t *config, struct playlist *files,
|
|
struct mpv_global *global, char **argv)
|
|
{
|
|
int ret = M_OPT_UNKNOWN;
|
|
int mode = 0;
|
|
struct playlist_entry *local_start = NULL;
|
|
|
|
int local_params_count = 0;
|
|
struct playlist_param *local_params = 0;
|
|
|
|
assert(config != NULL);
|
|
|
|
mode = GLOBAL;
|
|
|
|
struct parse_state p = {config, argv, config->log};
|
|
while (split_opt(&p)) {
|
|
if (p.is_opt) {
|
|
int flags = M_SETOPT_FROM_CMDLINE;
|
|
if (mode == LOCAL)
|
|
flags |= M_SETOPT_BACKUP | M_SETOPT_CHECK_ONLY;
|
|
int r = m_config_set_option_cli(config, p.arg, p.param, flags);
|
|
if (r == M_OPT_EXIT) {
|
|
ret = r;
|
|
goto err_out;
|
|
} else if (r < 0) {
|
|
MP_FATAL(config, "Setting commandline option --%.*s=%.*s failed.\n",
|
|
BSTR_P(p.arg), BSTR_P(p.param));
|
|
goto err_out;
|
|
}
|
|
|
|
// Handle some special arguments outside option parser.
|
|
|
|
if (!bstrcmp0(p.arg, "{")) {
|
|
if (mode != GLOBAL) {
|
|
MP_ERR(config, "'--{' can not be nested.\n");
|
|
goto err_out;
|
|
}
|
|
mode = LOCAL;
|
|
assert(!local_start);
|
|
local_start = playlist_get_last(files);
|
|
continue;
|
|
}
|
|
|
|
if (!bstrcmp0(p.arg, "}")) {
|
|
if (mode != LOCAL) {
|
|
MP_ERR(config, "Too many closing '--}'.\n");
|
|
goto err_out;
|
|
}
|
|
if (local_params_count) {
|
|
// The files added between '{' and '}' are the entries from
|
|
// the entry _after_ local_start, until the end of the list.
|
|
// If local_start is NULL, the list was empty on '{', and we
|
|
// want all files in the list.
|
|
struct playlist_entry *cur = local_start
|
|
? playlist_entry_get_rel(local_start, 1)
|
|
: playlist_get_first(files);
|
|
if (!cur)
|
|
MP_WARN(config, "Ignored options!\n");
|
|
while (cur) {
|
|
playlist_entry_add_params(cur, local_params,
|
|
local_params_count);
|
|
cur = playlist_entry_get_rel(cur, 1);
|
|
}
|
|
}
|
|
local_params_count = 0;
|
|
mode = GLOBAL;
|
|
m_config_restore_backups(config);
|
|
local_start = NULL;
|
|
continue;
|
|
}
|
|
|
|
if (bstrcmp0(p.arg, "playlist") == 0) {
|
|
// append the playlist to the local args
|
|
char *param0 = bstrdup0(NULL, p.param);
|
|
struct playlist *pl = playlist_parse_file(param0, NULL, global);
|
|
if (!pl) {
|
|
MP_FATAL(config, "Error reading playlist '%.*s'\n",
|
|
BSTR_P(p.param));
|
|
talloc_free(param0);
|
|
goto err_out;
|
|
}
|
|
playlist_transfer_entries(files, pl);
|
|
playlist_populate_playlist_path(files, param0);
|
|
talloc_free(param0);
|
|
talloc_free(pl);
|
|
continue;
|
|
}
|
|
|
|
if (mode == LOCAL) {
|
|
MP_TARRAY_APPEND(NULL, local_params, local_params_count,
|
|
(struct playlist_param) {p.arg, p.param});
|
|
}
|
|
} else {
|
|
// filename
|
|
void *tmp = talloc_new(NULL);
|
|
char *file0 = bstrdup0(tmp, p.arg);
|
|
process_non_option(files, file0);
|
|
talloc_free(tmp);
|
|
}
|
|
}
|
|
|
|
if (p.error)
|
|
goto err_out;
|
|
|
|
if (mode != GLOBAL) {
|
|
MP_ERR(config, "Missing closing --} on command line.\n");
|
|
goto err_out;
|
|
}
|
|
|
|
ret = 0; // success
|
|
|
|
err_out:
|
|
talloc_free(local_params);
|
|
m_config_restore_backups(config);
|
|
return ret;
|
|
}
|
|
|
|
/* Parse some command line options early before main parsing.
|
|
* --no-config prevents reading configuration files (otherwise done before
|
|
* command line parsing), and --really-quiet suppresses messages printed
|
|
* during normal options parsing.
|
|
*/
|
|
void m_config_preparse_command_line(m_config_t *config, struct mpv_global *global,
|
|
int *verbose, char **argv)
|
|
{
|
|
struct parse_state p = {config, argv, mp_null_log};
|
|
while (split_opt(&p)) {
|
|
if (p.is_opt) {
|
|
// Ignore non-pre-parse options. They will be set later.
|
|
// Option parsing errors will be handled later as well.
|
|
int flags = M_SETOPT_FROM_CMDLINE | M_SETOPT_PRE_PARSE_ONLY;
|
|
m_config_set_option_cli(config, p.arg, p.param, flags);
|
|
if (bstrcmp0(p.arg, "v") == 0)
|
|
(*verbose)++;
|
|
}
|
|
}
|
|
|
|
for (int n = 0; n < config->num_opts; n++)
|
|
config->opts[n].warning_was_printed = false;
|
|
}
|