Something went wrong. Try again.
🎥 Command line media player
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347/* * This file is part of mpv. * * mpv is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * mpv is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with mpv. If not, see <http://www.gnu.org/licenses/>. */
#include <assert.h>#include <string.h>#include <strings.h>#include <sys/types.h>#include <sys/stat.h>#include <unistd.h>#include <dirent.h>#include <math.h>#include <stdint.h>
#include <mujs.h>
#include "osdep/io.h"#include "mpv_talloc.h"#include "common/common.h"#include "options/m_property.h"#include "common/msg.h"#include "common/msg_control.h"#include "options/m_option.h"#include "input/input.h"#include "options/path.h"#include "misc/bstr.h"#include "osdep/subprocess.h"#include "osdep/timer.h"#include "osdep/threads.h"#include "stream/stream.h"#include "sub/osd.h"#include "core.h"#include "command.h"#include "client.h"#include "libmpv/client.h"
// List of builtin modules and their contents as strings.// All these are generated from player/javascript/*.jsstatic const char *const builtin_files[][3] = { {"@/defaults.js",# include "player/javascript/defaults.js.inc" }, {0}};
// Represents a loaded script. Each has its own js state.struct script_ctx { const char *filename; struct mpv_handle *client; struct MPContext *mpctx; struct mp_log *log; char *last_error_str;};
static struct script_ctx *jctx(js_State *J){ return (struct script_ctx *)js_getcontext(J);}
static mpv_handle *jclient(js_State *J){ return jctx(J)->client;}
/********************************************************************** * conventions, MuJS notes and vm errors *********************************************************************/// - push_foo functions are called from C and push a value to the vm stack.//// - JavaScript C functions are code which the vm can call as a js function.// By convention, script_bar and script__baz are js C functions. The former// is exposed to end users as bar, and _baz is for internal use.//// - js C functions get a fresh vm stack with their arguments, and may// manipulate their stack as they see fit. On exit, the vm considers the// top value of their stack as their return value, and GC the rest.//// - js C function's stack[0] is "this", and the rest (1, 2, ...) are the args.// On entry the stack has at least the number of args defined for the func,// padded with undefined if called with less, or bigger if called with more.//// - Almost all vm APIs (js_*) may throw an error - a longjmp to the last// recovery/catch point, which could skip releasing resources. Use protected// code (e.g. js_pcall) between aquisition and release. Alternatively, use// the autofree mechanism to manage it more easily. See more details below.//// - Unless named s_foo, all the functions at this file (inc. init) which// touch the vm may throw, but either cleanup resources regardless (mostly// autofree) or leave allocated resources on caller-provided talloc context// which the caller should release, typically with autofree (e.g. makenode).//// - Functions named s_foo (safe foo) never throw, return 0 on success, else 1.
/********************************************************************** * mpv scripting API error handling *********************************************************************/// - Errors may be thrown on some cases - the reason is at the exception.//// - Some APIs also set last error which can be fetched with mp.last_error(),// where empty string (false-y) is success, or an error string otherwise.//// - The rest of the APIs are guaranteed to return undefined on error or a// true-thy value on success and may or may not set last error.//// - push_success, push_failure, push_status and pushed_error set last error.
// iserr as true indicates an error, and if so, str may indicate a reason.// Internally ctx->last_error_str is never NULL, and empty indicates success.static void set_last_error(struct script_ctx *ctx, bool iserr, const char *str){ ctx->last_error_str[0] = 0; if (!iserr) return; if (!str || !str[0]) str = "Error"; ctx->last_error_str = talloc_strdup_append(ctx->last_error_str, str);}
// For use only by wrappers at defaults.js.// arg: error string. Use empty string to indicate success.static void script__set_last_error(js_State *J){ const char *e = js_tostring(J, 1); set_last_error(jctx(J), e[0], e);}
// mp.last_error() . args: none. return the last error without modifying it.static void script_last_error(js_State *J){ js_pushstring(J, jctx(J)->last_error_str);}
// Generic success for APIs which don't return an actual value.static void push_success(js_State *J){ set_last_error(jctx(J), 0, NULL); js_pushboolean(J, true);}
// Doesn't (intentionally) throw. Just sets last_error and pushes undefinedstatic void push_failure(js_State *J, const char *str){ set_last_error(jctx(J), 1, str); js_pushundefined(J);}
// Most of the scripting APIs are either sending some values and getting status// code in return, or requesting some value while providing a default in case an// error happened. These simplify the C code for that and always set last_error.
static void push_status(js_State *J, int err){ if (err >= 0) { push_success(J); } else { push_failure(J, mpv_error_string(err)); }}
// If err is success then return 0, else push the item at def and return 1static bool pushed_error(js_State *J, int err, int def){ bool iserr = err < 0; set_last_error(jctx(J), iserr, iserr ? mpv_error_string(err) : NULL); if (!iserr) return false;
js_copy(J, def); return true;}
/********************************************************************** * Autofree - care-free resource deallocation on vm errors, and otherwise *********************************************************************/// - Autofree (af) functions are called with a talloc context argument which is// freed after the function exits - either normally or because it threw an// error, on the latter case it then re-throws the error after the cleanup.//// Autofree js C functions should have an additional void* talloc arg and// inserted into the vm using af_newcfunction, but otherwise used normally.//// To wrap an autofree function af_TARGET in C:// 1. Create a wrapper s_TARGET which runs af_TARGET safely inside js_try.// 2. Use s_TARGET like so (always autofree, and throws if af_TARGET threw):// void *af = talloc_new(NULL);// int r = s_TARGET(J, ..., af); // use J, af where the callee expects.// talloc_free(af);// if (r)// js_throw(J);
// add_af_file, add_af_dir, add_af_mpv_alloc take a valid FILE*/DIR*/char* value// respectively, and fclose/closedir/mpv_free it when the parent is freed.
static void destruct_af_file(void *p){ fclose(*(FILE**)p);}
static void add_af_file(void *parent, FILE *f){ FILE **pf = talloc(parent, FILE*); *pf = f; talloc_set_destructor(pf, destruct_af_file);}
static void destruct_af_dir(void *p){ closedir(*(DIR**)p);}
static void add_af_dir(void *parent, DIR *d){ DIR **pd = talloc(parent, DIR*); *pd = d; talloc_set_destructor(pd, destruct_af_dir);}
static void destruct_af_mpv_alloc(void *p){ mpv_free(*(char**)p);}
static void add_af_mpv_alloc(void *parent, char *ma){ char **p = talloc(parent, char*); *p = ma; talloc_set_destructor(p, destruct_af_mpv_alloc);}
static void destruct_af_mpv_node(void *p){ mpv_free_node_contents((mpv_node*)p); // does nothing for MPV_FORMAT_NONE}
// returns a new zeroed allocated struct mpv_node, and free it and its content// when the parent is freed.static mpv_node *new_af_mpv_node(void *parent){ mpv_node *p = talloc_zero(parent, mpv_node); // .format == MPV_FORMAT_NONE talloc_set_destructor(p, destruct_af_mpv_node); return p;}
// Prototype for autofree functions which can be called from inside the vm.typedef void (*af_CFunction)(js_State*, void*);
// safely run autofree js c function directlystatic int s_run_af_jsc(js_State *J, af_CFunction fn, void *af){ if (js_try(J)) return 1; fn(J, af); js_endtry(J); return 0;}
// The trampoline function through which all autofree functions are called from// inside the vm. Obtains the target function address and autofree-call it.static void script__autofree(js_State *J){ // The target function is at the "af_" property of this function instance. js_currentfunction(J); js_getproperty(J, -1, "af_"); af_CFunction fn = (af_CFunction)js_touserdata(J, -1, "af_fn"); js_pop(J, 2);
void *af = talloc_new(NULL); int r = s_run_af_jsc(J, fn, af); talloc_free(af); if (r) js_throw(J);}
// Identical to js_newcfunction, but the function is inserted with an autofree// wrapper, and its prototype should have the additional af argument.static void af_newcfunction(js_State *J, af_CFunction fn, const char *name, int length){ js_newcfunction(J, script__autofree, name, length); js_pushnull(J); // a prototype for the userdata object js_newuserdata(J, "af_fn", fn, NULL); // uses a "af_fn" verification tag js_defproperty(J, -2, "af_", JS_READONLY | JS_DONTENUM | JS_DONTCONF);}
/********************************************************************** * Initialization and file loading *********************************************************************/
static const char *get_builtin_file(const char *name){ for (int n = 0; builtin_files[n][0]; n++) { if (strcmp(builtin_files[n][0], name) == 0) return builtin_files[n][1]; } return NULL;}
// Push up to limit bytes of file fname: from builtin_files, else from the OS.static void af_push_file(js_State *J, const char *fname, int limit, void *af){ char *filename = mp_get_user_path(af, jctx(J)->mpctx->global, fname); MP_VERBOSE(jctx(J), "Reading file '%s'\n", filename); if (limit < 0) limit = INT_MAX - 1;
const char *builtin = get_builtin_file(filename); if (builtin) { js_pushlstring(J, builtin, MPMIN(limit, strlen(builtin))); return; }
FILE *f = fopen(filename, "rb"); if (!f) js_error(J, "cannot open file: '%s'", filename); add_af_file(af, f);
int len = MPMIN(limit, 32 * 1024); // initial allocation, size*2 strategy int got = 0; char *s = NULL; while ((s = talloc_realloc(af, s, char, len))) { int want = len - got; int r = fread(s + got, 1, want, f);
if (feof(f) || (len == limit && r == want)) { js_pushlstring(J, s, got + r); return; } if (r != want) js_error(J, "cannot read data from file: '%s'", filename);
got = got + r; len = MPMIN(limit, len * 2); }
js_error(J, "cannot allocate %d bytes for file: '%s'", len, filename);}
// Safely run af_push_file.static int s_push_file(js_State *J, const char *fname, int limit, void *af){ if (js_try(J)) return 1; af_push_file(J, fname, limit, af); js_endtry(J); return 0;}
// Called directly, push up to limit bytes of file fname (from builtin/os).static void push_file_content(js_State *J, const char *fname, int limit){ void *af = talloc_new(NULL); int r = s_push_file(J, fname, limit, af); talloc_free(af); if (r) js_throw(J);}
// utils.read_file(..). args: fname [,max]. returns [up to max] bytes as string.static void script_read_file(js_State *J){ int limit = js_isundefined(J, 2) ? -1 : js_tonumber(J, 2); push_file_content(J, js_tostring(J, 1), limit);}
// Runs a file with the caller's this, leaves the stack as is.static void run_file(js_State *J, const char *fname){ MP_VERBOSE(jctx(J), "Loading file %s\n", fname); push_file_content(J, fname, -1); js_loadstring(J, fname, js_tostring(J, -1)); js_copy(J, 0); // use the caller's this js_call(J, 0); js_pop(J, 2); // result, file content}
// The spec defines .name and .message for Error objects. Most engines also set// a very convenient .stack = name + message + trace, but MuJS instead sets// .stackTrace = trace only. Normalize by adding such .stack if required.// Run this before anything such that we can get traces on any following errors.static const char *norm_err_proto_js = "\ if (Error().stackTrace && !Error().stack) {\ Object.defineProperty(Error.prototype, 'stack', {\ get: function() {\ return this.name + ': ' + this.message + this.stackTrace;\ }\ });\ }\";
static void add_functions(js_State*, struct script_ctx*);
// args: none. called as script, setup and run the main scriptstatic void script__run_script(js_State *J){ js_loadstring(J, "@/norm_err.js", norm_err_proto_js); js_copy(J, 0); js_pcall(J, 0);
struct script_ctx *ctx = jctx(J); add_functions(J, ctx); run_file(J, "@/defaults.js"); run_file(J, ctx->filename); // the main file to run
if (!js_hasproperty(J, 0, "mp_event_loop") || !js_iscallable(J, -1)) js_error(J, "no event loop function"); js_copy(J, 0); js_call(J, 0); // mp_event_loop}
// Safely set last error from stack top: stack trace or toString or generic.// May leave items on stack - the caller should detect and pop if it cares.static void s_top_to_last_error(struct script_ctx *ctx, js_State *J){ set_last_error(ctx, 1, "unknown error"); if (js_try(J)) return; if (js_isobject(J, -1)) js_hasproperty(J, -1, "stack"); // fetches it if exists set_last_error(ctx, 1, js_tostring(J, -1)); js_endtry(J);}
// MuJS can report warnings through this.static void report_handler(js_State *J, const char *msg){ MP_WARN(jctx(J), "[JS] %s\n", msg);}
// Safely setup the js vm for calling run_script.static int s_init_js(js_State *J, struct script_ctx *ctx){ if (js_try(J)) return 1; js_setcontext(J, ctx); js_setreport(J, report_handler); js_newcfunction(J, script__run_script, "run_script", 0); js_pushglobal(J); // 'this' for script__run_script js_endtry(J); return 0;}
/********************************************************************** * Initialization - booting the script *********************************************************************/// s_load_javascript: (entry point) creates the js vm, runs the script, returns// on script exit or uncaught js errors. Never throws.// script__run_script: - loads the built in functions and vars into the vm// - runs the default file[s] and the main script file// - calls mp_event_loop, returns on script-exit or throws.//// Note: init functions don't need autofree. They can use ctx as a talloc// context and free normally. If they throw - ctx is freed right afterwards.static int s_load_javascript(struct mpv_handle *client, const char *fname){ struct script_ctx *ctx = talloc_ptrtype(NULL, ctx); *ctx = (struct script_ctx) { .client = client, .mpctx = mp_client_get_core(client), .log = mp_client_get_log(client), .last_error_str = talloc_strdup(ctx, "Cannot initialize JavaScript"), .filename = fname, };
int r = -1; js_State *J = js_newstate(NULL, NULL, 0); if (!J || s_init_js(J, ctx)) goto error_out;
set_last_error(ctx, 0, NULL); if (js_pcall(J, 0)) { // script__run_script s_top_to_last_error(ctx, J); goto error_out; }
r = 0;
error_out: if (r) MP_FATAL(ctx, "%s\n", ctx->last_error_str); if (J) js_freestate(J);
talloc_free(ctx); return r;}
/********************************************************************** * Main mp.* scripting APIs and helpers *********************************************************************/static void pushnode(js_State *J, mpv_node *node);static void makenode(void *ta_ctx, mpv_node *dst, js_State *J, int idx);
// Return the index in opts of stack[idx] (or of def if undefined), else throws.static int checkopt(js_State *J, int idx, const char *def, const char *opts[], const char *desc){ const char *opt = js_isundefined(J, idx) ? def : js_tostring(J, idx); for (int i = 0; opts[i]; i++) { if (strcmp(opt, opts[i]) == 0) return i; } js_error(J, "Invalid %s '%s'", desc, opt);}
// args: level as string and a variable numbers of args to print. adds final \nstatic void script_log(js_State *J){ const char *level = js_tostring(J, 1); int msgl = mp_msg_find_level(level); if (msgl < 0) js_error(J, "Invalid log level '%s'", level);
struct mp_log *log = jctx(J)->log; for (int top = js_gettop(J), i = 2; i < top; i++) mp_msg(log, msgl, (i == 2 ? "%s" : " %s"), js_tostring(J, i)); mp_msg(log, msgl, "\n"); push_success(J);}
static void script_find_config_file(js_State *J, void *af){ const char *fname = js_tostring(J, 1); char *path = mp_find_config_file(af, jctx(J)->mpctx->global, fname); if (path) { js_pushstring(J, path); } else { push_failure(J, "not found"); }}
static void script__request_event(js_State *J){ const char *event = js_tostring(J, 1); bool enable = js_toboolean(J, 2);
const char *name; for (int n = 0; n < 256 && (name = mpv_event_name(n)); n++) { if (strcmp(name, event) == 0) { push_status(J, mpv_request_event(jclient(J), n, enable)); return; } } push_failure(J, "Unknown event name");}
static void script_enable_messages(js_State *J){ const char *level = js_tostring(J, 1); if (mp_msg_find_level(level) < 0) js_error(J, "Invalid log level '%s'", level); push_status(J, mpv_request_log_messages(jclient(J), level));}
// args - command [with arguments] as stringstatic void script_command(js_State *J){ push_status(J, mpv_command_string(jclient(J), js_tostring(J, 1)));}
// args: strings of command and then variable number of argumentsstatic void script_commandv(js_State *J){ const char *argv[MP_CMD_MAX_ARGS + 1]; int length = js_gettop(J) - 1; if (length >= MP_ARRAY_SIZE(argv)) js_error(J, "Too many arguments");
for (int i = 0; i < length; i++) argv[i] = js_tostring(J, 1 + i); argv[length] = NULL; push_status(J, mpv_command(jclient(J), argv));}
// args: name, string valuestatic void script_set_property(js_State *J){ int e = mpv_set_property_string(jclient(J), js_tostring(J, 1), js_tostring(J, 2)); push_status(J, e);}
// args: name, booleanstatic void script_set_property_bool(js_State *J){ int v = js_toboolean(J, 2); int e = mpv_set_property(jclient(J), js_tostring(J, 1), MPV_FORMAT_FLAG, &v); push_status(J, e);}
// args: name [,def]static void script_get_property_number(js_State *J){ double result; const char *name = js_tostring(J, 1); int e = mpv_get_property(jclient(J), name, MPV_FORMAT_DOUBLE, &result); if (!pushed_error(J, e, 2)) js_pushnumber(J, result);}
// args: name, native valuestatic void script_set_property_native(js_State *J, void *af){ mpv_node node; makenode(af, &node, J, 2); mpv_handle *h = jclient(J); int e = mpv_set_property(h, js_tostring(J, 1), MPV_FORMAT_NODE, &node); push_status(J, e);}
// args: name [,def]static void script_get_property(js_State *J, void *af){ mpv_handle *h = jclient(J); char *res = NULL; int e = mpv_get_property(h, js_tostring(J, 1), MPV_FORMAT_STRING, &res); if (e >= 0) add_af_mpv_alloc(af, res); if (!pushed_error(J, e, 2)) js_pushstring(J, res);}
// args: name [,def]static void script_get_property_bool(js_State *J){ int result; mpv_handle *h = jclient(J); int e = mpv_get_property(h, js_tostring(J, 1), MPV_FORMAT_FLAG, &result); if (!pushed_error(J, e, 2)) js_pushboolean(J, result);}
// args: name, numberstatic void script_set_property_number(js_State *J){ double v = js_tonumber(J, 2); mpv_handle *h = jclient(J); int e = mpv_set_property(h, js_tostring(J, 1), MPV_FORMAT_DOUBLE, &v); push_status(J, e);}
// args: name [,def]static void script_get_property_native(js_State *J, void *af){ const char *name = js_tostring(J, 1); mpv_handle *h = jclient(J); mpv_node *presult_node = new_af_mpv_node(af); int e = mpv_get_property(h, name, MPV_FORMAT_NODE, presult_node); if (!pushed_error(J, e, 2)) pushnode(J, presult_node);}
// args: name [,def]static void script_get_property_osd(js_State *J, void *af){ const char *name = js_tostring(J, 1); mpv_handle *h = jclient(J); char *res = NULL; int e = mpv_get_property(h, name, MPV_FORMAT_OSD_STRING, &res); if (e >= 0) add_af_mpv_alloc(af, res); if (!pushed_error(J, e, 2)) js_pushstring(J, res);}
// args: id, name, typestatic void script__observe_property(js_State *J){ const char *fmts[] = {"none", "native", "bool", "string", "number", NULL}; const mpv_format mf[] = {MPV_FORMAT_NONE, MPV_FORMAT_NODE, MPV_FORMAT_FLAG, MPV_FORMAT_STRING, MPV_FORMAT_DOUBLE};
mpv_format f = mf[checkopt(J, 3, "none", fmts, "observe type")]; int e = mpv_observe_property(jclient(J), js_tonumber(J, 1), js_tostring(J, 2), f); push_status(J, e);}
// args: idstatic void script__unobserve_property(js_State *J){ int e = mpv_unobserve_property(jclient(J), js_tonumber(J, 1)); push_status(J, e);}
// args: native (array of command and args, similar to commandv) [,def]static void script_command_native(js_State *J, void *af){ mpv_node cmd; makenode(af, &cmd, J, 1); mpv_node *presult_node = new_af_mpv_node(af); int e = mpv_command_node(jclient(J), &cmd, presult_node); if (!pushed_error(J, e, 2)) pushnode(J, presult_node);}
// args: none, result in millisecstatic void script_get_time_ms(js_State *J){ js_pushnumber(J, mpv_get_time_us(jclient(J)) / (double)(1000));}
static void script_set_osd_ass(js_State *J){ struct script_ctx *ctx = jctx(J); int res_x = js_tonumber(J, 1); int res_y = js_tonumber(J, 2); const char *text = js_tostring(J, 3); osd_set_external(ctx->mpctx->osd, ctx->client, res_x, res_y, (char *)text); mp_wakeup_core(ctx->mpctx); push_success(J);}
// push object with properties names (NULL terminated) with respective valsstatic void push_nums_obj(js_State *J, const char * const names[], const double vals[]){ js_newobject(J); for (int i = 0; names[i]; i++) { js_pushnumber(J, vals[i]); js_setproperty(J, -2, names[i]); }}
// args: none, return: object with properties width, height, aspectstatic void script_get_osd_size(js_State *J){ struct mp_osd_res r = osd_get_vo_res(jctx(J)->mpctx->osd); double ar = 1.0 * r.w / MPMAX(r.h, 1) / (r.display_par ? r.display_par : 1); const char * const names[] = {"width", "height", "aspect", NULL}; const double vals[] = {r.w, r.h, ar}; push_nums_obj(J, names, vals);}
// args: none, return: object with properties top, bottom, left, rightstatic void script_get_osd_margins(js_State *J){ struct mp_osd_res r = osd_get_vo_res(jctx(J)->mpctx->osd); const char * const names[] = {"left", "top", "right", "bottom", NULL}; const double vals[] = {r.ml, r.mt, r.mr, r.mb}; push_nums_obj(J, names, vals);}
// args: none, return: object with properties x, ystatic void script_get_mouse_pos(js_State *J){ int x, y; mp_input_get_mouse_pos(jctx(J)->mpctx->input, &x, &y); const char * const names[] = {"x", "y", NULL}; const double vals[] = {x, y}; push_nums_obj(J, names, vals);}
// args: input-section-name, x0, y0, x1, y1static void script_input_set_section_mouse_area(js_State *J){ char *section = (char *)js_tostring(J, 1); mp_input_set_section_mouse_area(jctx(J)->mpctx->input, section, js_tonumber(J, 2), js_tonumber(J, 3), // x0, y0 js_tonumber(J, 4), js_tonumber(J, 5)); // x1, y1 push_success(J);}
// args: time-in-ms [,format-string]static void script_format_time(js_State *J, void *af){ double t = js_tonumber(J, 1); const char *fmt = js_isundefined(J, 2) ? "%H:%M:%S" : js_tostring(J, 2); char *r = talloc_steal(af, mp_format_time_fmt(fmt, t)); if (!r) js_error(J, "Invalid time format string '%s'", fmt); js_pushstring(J, r);}
// TODO: untestedstatic void script_get_wakeup_pipe(js_State *J){ js_pushnumber(J, mpv_get_wakeup_pipe(jclient(J)));}
/********************************************************************** * mp.utils *********************************************************************/
// args: [path [,filter]]static void script_readdir(js_State *J, void *af){ // 0 1 2 3 const char *filters[] = {"all", "files", "dirs", "normal", NULL}; const char *path = js_isundefined(J, 1) ? "." : js_tostring(J, 1); int t = checkopt(J, 2, "normal", filters, "listing filter");
DIR *dir = opendir(path); if (!dir) { push_failure(J, "Cannot open dir"); return; } add_af_dir(af, dir); set_last_error(jctx(J), 0, NULL); js_newarray(J); // the return value char *fullpath = talloc_strdup(af, ""); struct dirent *e; int n = 0; while ((e = readdir(dir))) { char *name = e->d_name; if (t) { if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue; if (fullpath) fullpath[0] = '\0'; fullpath = talloc_asprintf_append(fullpath, "%s/%s", path, name); struct stat st; if (stat(fullpath, &st)) continue; if (!(((t & 1) && S_ISREG(st.st_mode)) || ((t & 2) && S_ISDIR(st.st_mode)))) { continue; } } js_pushstring(J, name); js_setindex(J, -2, n++); }}
static void script_file_info(js_State *J){ const char *path = js_tostring(J, 1);
struct stat statbuf; if (stat(path, &statbuf) != 0) { push_failure(J, "Cannot stat path"); return; } // Clear last error set_last_error(jctx(J), 0, NULL);
const char * stat_names[] = { "mode", "size", "atime", "mtime", "ctime", NULL }; const double stat_values[] = { statbuf.st_mode, statbuf.st_size, statbuf.st_atime, statbuf.st_mtime, statbuf.st_ctime }; // Create an object and add all fields push_nums_obj(J, stat_names, stat_values);
// Convenience booleans js_pushboolean(J, S_ISREG(statbuf.st_mode)); js_setproperty(J, -2, "is_file");
js_pushboolean(J, S_ISDIR(statbuf.st_mode)); js_setproperty(J, -2, "is_dir");}
static void script_split_path(js_State *J){ const char *p = js_tostring(J, 1); bstr fname = mp_dirname(p); js_newarray(J); js_pushlstring(J, fname.start, fname.len); js_setindex(J, -2, 0); js_pushstring(J, mp_basename(p)); js_setindex(J, -2, 1);}
static void script_join_path(js_State *J, void *af){ js_pushstring(J, mp_path_join(af, js_tostring(J, 1), js_tostring(J, 2)));}
static void script_get_user_path(js_State *J, void *af){ const char *path = js_tostring(J, 1); js_pushstring(J, mp_get_user_path(af, jctx(J)->mpctx->global, path));}
struct subprocess_cb_ctx { struct mp_log *log; void *talloc_ctx; int64_t max_size; bstr output; bstr err;};
static void subprocess_stdout(void *p, char *data, size_t size){ struct subprocess_cb_ctx *ctx = p; if (ctx->output.len < ctx->max_size) bstr_xappend(ctx->talloc_ctx, &ctx->output, (bstr){data, size});}
static void subprocess_stderr(void *p, char *data, size_t size){ struct subprocess_cb_ctx *ctx = p; if (ctx->err.len < ctx->max_size) bstr_xappend(ctx->talloc_ctx, &ctx->err, (bstr){data, size}); MP_INFO(ctx, "%.*s", (int)size, data);}
// args: client invocation args object. TODO: use common backend for js/luastatic void af_subprocess_common(js_State *J, int detach, void *af){ struct script_ctx *ctx = jctx(J); if (!js_isobject(J, 1)) js_error(J, "argument must be an object");
js_getproperty(J, 1, "args"); // args int num_args = js_getlength(J, -1); if (!num_args) // not using js_isarray to also accept array-like objects js_error(J, "args must be an non-empty array"); char *args[256]; if (num_args > MP_ARRAY_SIZE(args) - 1) // last needs to be NULL js_error(J, "too many arguments"); if (num_args < 1) js_error(J, "program name missing");
for (int n = 0; n < num_args; n++) { js_getindex(J, -1, n); if (js_isundefined(J, -1)) js_error(J, "program arguments must be strings"); args[n] = talloc_strdup(af, js_tostring(J, -1)); js_pop(J, 1); // args } args[num_args] = NULL;
if (detach) { mp_subprocess_detached(ctx->log, args); push_success(J); return; }
struct mp_cancel *cancel = NULL; if (js_hasproperty(J, 1, "cancellable") ? js_toboolean(J, -1) : true) cancel = ctx->mpctx->playback_abort;
int64_t max_size = js_hasproperty(J, 1, "max_size") ? js_tointeger(J, -1) : 16 * 1024 * 1024; struct subprocess_cb_ctx cb_ctx = { .log = ctx->log, .talloc_ctx = af, .max_size = max_size, };
char *error = NULL; int status = mp_subprocess(args, cancel, &cb_ctx, subprocess_stdout, subprocess_stderr, &error);
js_newobject(J); // res if (error) { js_pushstring(J, error); // res e js_setproperty(J, -2, "error"); // res } js_pushnumber(J, status); // res s js_setproperty(J, -2, "status"); // res js_pushlstring(J, cb_ctx.output.start, cb_ctx.output.len); // res d js_setproperty(J, -2, "stdout"); // res js_pushlstring(J, cb_ctx.err.start, cb_ctx.err.len); js_setproperty(J, -2, "stderr"); js_pushboolean(J, status == MP_SUBPROCESS_EKILLED_BY_US); // res b js_setproperty(J, -2, "killed_by_us"); // res}
// args: client invocation args object (same also for _detached)static void script_subprocess(js_State *J, void *af){ af_subprocess_common(J, 0, af);}
static void script_subprocess_detached(js_State *J, void *af){ af_subprocess_common(J, 1, af);}
// args: prefixed file name, data (c-str)static void script_write_file(js_State *J, void *af){ static const char *prefix = "file://"; const char *fname = js_tostring(J, 1); const char *data = js_tostring(J, 2); if (strstr(fname, prefix) != fname) // simple protection for incorrect use js_error(J, "File name must be prefixed with '%s'", prefix); fname += strlen(prefix); fname = mp_get_user_path(af, jctx(J)->mpctx->global, fname); MP_VERBOSE(jctx(J), "Writing file '%s'\n", fname);
FILE *f = fopen(fname, "wb"); if (!f) js_error(J, "Cannot open file for writing: '%s'", fname); add_af_file(af, f);
int len = strlen(data); // limited by terminating null int wrote = fwrite(data, 1, len, f); if (len != wrote) js_error(J, "Cannot write to file: '%s'", fname);}
// args: env var namestatic void script_getenv(js_State *J){ const char *v = getenv(js_tostring(J, 1)); if (v) { js_pushstring(J, v); } else { js_pushundefined(J); }}
// args: as-filename, content-string, returns the compiled result as a functionstatic void script_compile_js(js_State *J){ js_loadstring(J, js_tostring(J, 1), js_tostring(J, 2));}
// args: true = print info (with the warning report function - no info report)static void script__gc(js_State *J){ js_gc(J, js_toboolean(J, 1) ? 1 : 0); push_success(J);}
/********************************************************************** * Core functions: pushnode, makenode and the event loop backend *********************************************************************/
// pushes a js value/array/object from an mpv_nodestatic void pushnode(js_State *J, mpv_node *node){ int len; switch (node->format) { case MPV_FORMAT_NONE: js_pushnull(J); break; case MPV_FORMAT_STRING: js_pushstring(J, node->u.string); break; case MPV_FORMAT_INT64: js_pushnumber(J, node->u.int64); break; case MPV_FORMAT_DOUBLE: js_pushnumber(J, node->u.double_); break; case MPV_FORMAT_FLAG: js_pushboolean(J, node->u.flag); break; case MPV_FORMAT_NODE_ARRAY: js_newarray(J); len = node->u.list->num; for (int n = 0; n < len; n++) { pushnode(J, &node->u.list->values[n]); js_setindex(J, -2, n); } break; case MPV_FORMAT_NODE_MAP: js_newobject(J); len = node->u.list->num; for (int n = 0; n < len; n++) { pushnode(J, &node->u.list->values[n]); js_setproperty(J, -2, node->u.list->keys[n]); } break; default: js_pushstring(J, "[UNSUPPORTED_MPV_FORMAT]"); break; }}
// For the object at stack index idx, extract the (own) property names into// keys array (and allocate it to accommodate) and return the number of keys.static int get_obj_properties(void *ta_ctx, char ***keys, js_State *J, int idx){ int length = 0; js_pushiterator(J, idx, 1);
*keys = talloc_new(ta_ctx); const char *name; while ((name = js_nextiterator(J, -1))) MP_TARRAY_APPEND(ta_ctx, *keys, length, talloc_strdup(ta_ctx, name));
js_pop(J, 1); // the iterator return length;}
// true if we don't lose (too much) precision when casting to int64static bool same_as_int64(double d){ // The range checks also validly filter inf and nan, so behavior is defined return d >= INT64_MIN && d <= INT64_MAX && d == (int64_t)d;}
// From the js stack value/array/object at index idxstatic void makenode(void *ta_ctx, mpv_node *dst, js_State *J, int idx){ if (js_isundefined(J, idx) || js_isnull(J, idx)) { dst->format = MPV_FORMAT_NONE;
} else if (js_isboolean(J, idx)) { dst->format = MPV_FORMAT_FLAG; dst->u.flag = js_toboolean(J, idx);
} else if (js_isnumber(J, idx)) { double val = js_tonumber(J, idx); if (same_as_int64(val)) { // use int, because we can dst->format = MPV_FORMAT_INT64; dst->u.int64 = val; } else { dst->format = MPV_FORMAT_DOUBLE; dst->u.double_ = val; }
} else if (js_isarray(J, idx)) { dst->format = MPV_FORMAT_NODE_ARRAY; dst->u.list = talloc(ta_ctx, struct mpv_node_list); dst->u.list->keys = NULL;
int length = js_getlength(J, idx); dst->u.list->num = length; dst->u.list->values = talloc_array(ta_ctx, mpv_node, length); for (int n = 0; n < length; n++) { js_getindex(J, idx, n); makenode(ta_ctx, &dst->u.list->values[n], J, -1); js_pop(J, 1); }
} else if (js_isobject(J, idx)) { dst->format = MPV_FORMAT_NODE_MAP; dst->u.list = talloc(ta_ctx, struct mpv_node_list);
int length = get_obj_properties(ta_ctx, &dst->u.list->keys, J, idx); dst->u.list->num = length; dst->u.list->values = talloc_array(ta_ctx, mpv_node, length); for (int n = 0; n < length; n++) { js_getproperty(J, idx, dst->u.list->keys[n]); makenode(ta_ctx, &dst->u.list->values[n], J, -1); js_pop(J, 1); }
} else { // string, or anything else as string dst->format = MPV_FORMAT_STRING; dst->u.string = talloc_strdup(ta_ctx, js_tostring(J, idx)); }}
// args: wait in secs (infinite if negative) if mpv doesn't send events earlier.static void script_wait_event(js_State *J){ int top = js_gettop(J); double timeout = js_isnumber(J, 1) ? js_tonumber(J, 1) : -1; mpv_event *event = mpv_wait_event(jclient(J), timeout);
js_newobject(J); // the reply js_pushstring(J, mpv_event_name(event->event_id)); js_setproperty(J, -2, "event"); // reply.event (is an event name)
if (event->reply_userdata) { js_pushnumber(J, event->reply_userdata); js_setproperty(J, -2, "id"); // reply.id }
if (event->error < 0) { // TODO: untested js_pushstring(J, mpv_error_string(event->error)); js_setproperty(J, -2, "error"); // reply.error }
switch (event->event_id) { case MPV_EVENT_LOG_MESSAGE: { mpv_event_log_message *msg = event->data;
js_pushstring(J, msg->prefix); js_setproperty(J, -2, "prefix"); // reply.prefix (e.g. "cplayer") js_pushstring(J, msg->level); js_setproperty(J, -2, "level"); // reply.level (e.g. "v" or "info") js_pushstring(J, msg->text); js_setproperty(J, -2, "text"); // reply.text break; }
case MPV_EVENT_CLIENT_MESSAGE: { mpv_event_client_message *msg = event->data;
js_newarray(J); // reply.args for (int n = 0; n < msg->num_args; n++) { js_pushstring(J, msg->args[n]); js_setindex(J, -2, n); } js_setproperty(J, -2, "args"); // reply.args (is a strings array) break; }
case MPV_EVENT_END_FILE: { mpv_event_end_file *eef = event->data; const char *reason;
switch (eef->reason) { case MPV_END_FILE_REASON_EOF: reason = "eof"; break; case MPV_END_FILE_REASON_STOP: reason = "stop"; break; case MPV_END_FILE_REASON_QUIT: reason = "quit"; break; case MPV_END_FILE_REASON_ERROR: reason = "error"; break; case MPV_END_FILE_REASON_REDIRECT: reason = "redirect"; break; default: reason = "unknown"; } js_pushstring(J, reason); js_setproperty(J, -2, "reason"); // reply.reason
if (eef->reason == MPV_END_FILE_REASON_ERROR) { js_pushstring(J, mpv_error_string(eef->error)); js_setproperty(J, -2, "error"); // reply.error } break; }
case MPV_EVENT_PROPERTY_CHANGE: { mpv_event_property *prop = event->data; js_pushstring(J, prop->name); js_setproperty(J, -2, "name"); // reply.name (is a property name)
switch (prop->format) { case MPV_FORMAT_NODE: pushnode(J, prop->data); break; case MPV_FORMAT_DOUBLE: js_pushnumber(J, *(double *)prop->data); break; case MPV_FORMAT_INT64: js_pushnumber(J, *(int64_t *)prop->data); break; case MPV_FORMAT_FLAG: js_pushboolean(J, *(int *)prop->data); break; case MPV_FORMAT_STRING: js_pushstring(J, *(char **)prop->data); break; default: js_pushnull(J); // also for FORMAT_NONE, e.g. observe type "none" } js_setproperty(J, -2, "data"); // reply.data (value as observed type) break; } } // switch (event->event_id)
assert(top == js_gettop(J) - 1);}
/********************************************************************** * Script functions setup *********************************************************************/#define FN_ENTRY(name, length) {#name, length, script_ ## name, NULL}#define AF_ENTRY(name, length) {#name, length, NULL, script_ ## name}struct fn_entry { const char *name; int length; js_CFunction jsc_fn; af_CFunction afc_fn;};
// Names starting with underscore are wrapped at @defaults.js// FN_ENTRY is a normal js C function, AF_ENTRY is an autofree js C function.static const struct fn_entry main_fns[] = { FN_ENTRY(log, 1), FN_ENTRY(wait_event, 1), FN_ENTRY(_request_event, 2), AF_ENTRY(find_config_file, 1), FN_ENTRY(command, 1), FN_ENTRY(commandv, 0), AF_ENTRY(command_native, 2), FN_ENTRY(get_property_bool, 2), FN_ENTRY(get_property_number, 2), AF_ENTRY(get_property_native, 2), AF_ENTRY(get_property, 2), AF_ENTRY(get_property_osd, 2), FN_ENTRY(set_property, 2), FN_ENTRY(set_property_bool, 2), FN_ENTRY(set_property_number, 2), AF_ENTRY(set_property_native, 2), FN_ENTRY(_observe_property, 3), FN_ENTRY(_unobserve_property, 1), FN_ENTRY(get_time_ms, 0), AF_ENTRY(format_time, 2), FN_ENTRY(enable_messages, 1), FN_ENTRY(get_wakeup_pipe, 0), FN_ENTRY(set_osd_ass, 3), FN_ENTRY(get_osd_size, 0), FN_ENTRY(get_osd_margins, 0), FN_ENTRY(get_mouse_pos, 0), FN_ENTRY(input_set_section_mouse_area, 5), FN_ENTRY(last_error, 0), FN_ENTRY(_set_last_error, 1), {0}};
static const struct fn_entry utils_fns[] = { AF_ENTRY(readdir, 2), FN_ENTRY(file_info, 1), FN_ENTRY(split_path, 1), AF_ENTRY(join_path, 2), AF_ENTRY(get_user_path, 1), AF_ENTRY(subprocess, 1), AF_ENTRY(subprocess_detached, 1),
FN_ENTRY(read_file, 2), AF_ENTRY(write_file, 2), FN_ENTRY(getenv, 1), FN_ENTRY(compile_js, 2), FN_ENTRY(_gc, 1), {0}};
// Adds an object <module> with the functions at e to the top objectstatic void add_package_fns(js_State *J, const char *module, const struct fn_entry *e){ js_newobject(J); for (int n = 0; e[n].name; n++) { if (e[n].jsc_fn) { js_newcfunction(J, e[n].jsc_fn, e[n].name, e[n].length); } else { af_newcfunction(J, e[n].afc_fn, e[n].name, e[n].length); } js_setproperty(J, -2, e[n].name); } js_setproperty(J, -2, module);}
// Called directly, adds functions/vars to the caller's this.static void add_functions(js_State *J, struct script_ctx *ctx){ js_copy(J, 0); add_package_fns(J, "mp", main_fns); js_getproperty(J, 0, "mp"); // + this mp add_package_fns(J, "utils", utils_fns);
js_pushstring(J, mpv_client_name(ctx->client)); js_setproperty(J, -2, "script_name");
js_pushstring(J, ctx->filename); js_setproperty(J, -2, "script_file");
js_pop(J, 2); // leave the stack as we got it}
// main export of this file, used by cplayer to load js scriptsconst struct mp_scripting mp_scripting_js = { .name = "javascript", .file_ext = "js", .load = s_load_javascript,};