Skip to content

Instantly share code, notes, and snippets.

@daniel-j
Last active Sep 20, 2019
Embed
What would you like to do?
super simple nim video player with libmpv. requires nimterop for now
from mpvclient as mpv import nil
proc mpv_check_error(status: cint) =
if status < 0:
echo "mpv API error: ", mpv.mpv_error_string(status)
quit(1)
proc main: int =
result = 1
let ctx = mpv.mpv_create()
defer: mpv.mpv_terminate_destroy(ctx)
mpv_check_error(mpv.mpv_initialize(ctx))
block:
let cmd = allocCStringArray(["loadfile", "https://www.youtube.com/watch?v=ywjyeaMUibM"])
defer: deallocCStringArray(cmd)
mpv_check_error(mpv.mpv_command(ctx, cmd))
while true:
let event = mpv.mpv_wait_event(ctx, 10000)
echo "event: ", mpv.mpv_event_name(event.event_id)
if cint(event.event_id) == cint(mpv.MPV_EVENT_SHUTDOWN):
break
return 0
quit main()
{.hint[ConvFromXtoItselfNotNeeded]: off.}
import nimterop/types
const libname = "mpv"
{.passL: "-L" & "mpv/build".}
{.passL: "-l" & libname.}
# *
# * List of error codes than can be returned by API functions. 0 and positive
# * return values always mean success, negative values are always errors.
#
defineEnum(mpv_error)
# *
# * Data format for options and properties. The API functions to get/set
# * properties and options support multiple formats, and this enum describes
# * them.
#
defineEnum(mpv_format)
defineEnum(mpv_event_id)
# *
# * Numeric log levels. The lower the number, the more important the message is.
# * MPV_LOG_LEVEL_NONE is never used when receiving messages. The string in
# * the comment after the value is the name of the log level as used for the
# * mpv_request_log_messages() function.
# * Unused numeric values are unused, but reserved for future use.
#
defineEnum(mpv_log_level)
# / Since API version 1.9.
defineEnum(mpv_end_file_reason)
# *
# * @deprecated use render.h
#
defineEnum(mpv_sub_api)
const
# Copyright (C) 2017 the mpv developers
# *
# * Permission to use, copy, modify, and/or distribute this software for any
# * purpose with or without fee is hereby granted, provided that the above
# * copyright notice and this permission notice appear in all copies.
# *
# * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#
#
# * Note: the client API is licensed under ISC (see above) to enable
# * other wrappers outside of mpv. But keep in mind that the
# * mpv core is by default still GPLv2+ - unless built with
# * --enable-lgpl, which makes it LGPLv2+.
#
# *
# * Mechanisms provided by this API
# * -------------------------------
# *
# * This API provides general control over mpv playback. It does not give you
# * direct access to individual components of the player, only the whole thing.
# * It's somewhat equivalent to MPlayer's slave mode. You can send commands,
# * retrieve or set playback status or settings with properties, and receive
# * events.
# *
# * The API can be used in two ways:
# * 1) Internally in mpv, to provide additional features to the command line
# * player. Lua scripting uses this. (Currently there is no plugin API to
# * get a client API handle in external user code. It has to be a fixed
# * part of the player at compilation time.)
# * 2) Using mpv as a library with mpv_create(). This basically allows embedding
# * mpv in other applications.
# *
# * Documentation
# * -------------
# *
# * The libmpv C API is documented directly in this header. Note that most
# * actual interaction with this player is done through
# * options/commands/properties, which can be accessed through this API.
# * Essentially everything is done with them, including loading a file,
# * retrieving playback progress, and so on.
# *
# * These are documented elsewhere:
# * * http:mpv.io/manual/master/#options
# * * http:mpv.io/manual/master/#list-of-input-commands
# * * http:mpv.io/manual/master/#properties
# *
# * You can also look at the examples here:
# * * https:github.com/mpv-player/mpv-examples/tree/master/libmpv
# *
# * Event loop
# * ----------
# *
# * In general, the API user should run an event loop in order to receive events.
# * This event loop should call mpv_wait_event(), which will return once a new
# * mpv client API is available. It is also possible to integrate client API
# * usage in other event loops (e.g. GUI toolkits) with the
# * mpv_set_wakeup_callback() function, and then polling for events by calling
# * mpv_wait_event() with a 0 timeout.
# *
# * Note that the event loop is detached from the actual player. Not calling
# * mpv_wait_event() will not stop playback. It will eventually congest the
# * event queue of your API handle, though.
# *
# * Synchronous vs. asynchronous calls
# * ----------------------------------
# *
# * The API allows both synchronous and asynchronous calls. Synchronous calls
# * have to wait until the playback core is ready, which currently can take
# * an unbounded time (e.g. if network is slow or unresponsive). Asynchronous
# * calls just queue operations as requests, and return the result of the
# * operation as events.
# *
# * Asynchronous calls
# * ------------------
# *
# * The client API includes asynchronous functions. These allow you to send
# * requests instantly, and get replies as events at a later point. The
# * requests are made with functions carrying the _async suffix, and replies
# * are returned by mpv_wait_event() (interleaved with the normal event stream).
# *
# * A 64 bit userdata value is used to allow the user to associate requests
# * with replies. The value is passed as reply_userdata parameter to the request
# * function. The reply to the request will have the reply
# * mpv_event->reply_userdata field set to the same value as the
# * reply_userdata parameter of the corresponding request.
# *
# * This userdata value is arbitrary and is never interpreted by the API. Note
# * that the userdata value 0 is also allowed, but then the client must be
# * careful not accidentally interpret the mpv_event->reply_userdata if an
# * event is not a reply. (For non-replies, this field is set to 0.)
# *
# * Asynchronous calls may be reordered in arbitrarily with other synchronous
# * and asynchronous calls. If you want a guaranteed order, you need to wait
# * until asynchronous calls report completion before doing the next call.
# *
# * Multithreading
# * --------------
# *
# * The client API is generally fully thread-safe, unless otherwise noted.
# * Currently, there is no real advantage in using more than 1 thread to access
# * the client API, since everything is serialized through a single lock in the
# * playback core.
# *
# * Basic environment requirements
# * ------------------------------
# *
# * This documents basic requirements on the C environment. This is especially
# * important if mpv is used as library with mpv_create().
# *
# * - The LC_NUMERIC locale category must be set to "C". If your program calls
# * setlocale(), be sure not to use LC_ALL, or if you do, reset LC_NUMERIC
# * to its sane default: setlocale(LC_NUMERIC, "C").
# * - If a X11 based VO is used, mpv will set the xlib error handler. This error
# * handler is process-wide, and there's no proper way to share it with other
# * xlib users within the same process. This might confuse GUI toolkits.
# * - mpv uses some other libraries that are not library-safe, such as Fribidi
# * (used through libass), ALSA, FFmpeg, and possibly more.
# * - The FPU precision must be set at least to double precision.
# * - On Windows, mpv will call timeBeginPeriod(1).
# * - On memory exhaustion, mpv will kill the process.
# * - In certain cases, mpv may start sub processes (such as with the ytdl
# * wrapper script).
# * - Using UNIX IPC (off by default) will override the SIGPIPE signal handler,
# * and set it to SIG_IGN.
# *
# * Encoding of filenames
# * ---------------------
# *
# * mpv uses UTF-8 everywhere.
# *
# * On some platforms (like Linux), filenames actually do not have to be UTF-8;
# * for this reason libmpv supports non-UTF-8 strings. libmpv uses what the
# * kernel uses and does not recode filenames. At least on Linux, passing a
# * string to libmpv is like passing a string to the fopen() function.
# *
# * On Windows, filenames are always UTF-8, libmpv converts between UTF-8 and
# * UTF-16 when using win32 API functions. libmpv never uses or accepts
# * filenames in the local 8 bit encoding. It does not use fopen() either;
# * it uses _wfopen().
# *
# * On OS X, filenames and other strings taken/returned by libmpv can have
# * inconsistent unicode normalization. This can sometimes lead to problems.
# * You have to hope for the best.
# *
# * Also see the remarks for MPV_FORMAT_STRING.
# *
# * Embedding the video window
# * --------------------------
# *
# * Using the opengl-cb API (in opengl_cb.h) is recommended. This API requires
# * you to create and maintain an OpenGL context, to which you can render
# * video using a specific API call. This API does not include keyboard or mouse
# * input directly.
# *
# * There is an older way to embed the native mpv window into your own. You have
# * to get the raw window handle, and set it as "wid" option. This works on X11,
# * win32, and OSX only. It's much easier to use than the opengl-cb API, but
# * also has various problems.
# *
# * Also see client API examples and the mpv manpage. There is an extensive
# * discussion here:
# * https:github.com/mpv-player/mpv-examples/tree/master/libmpv#methods-of-embedding-the-video-window
# *
# * Compatibility
# * -------------
# *
# * mpv development doesn't stand still, and changes to mpv internals as well as
# * to its interface can cause compatibility issues to client API users.
# *
# * The API is versioned (see MPV_CLIENT_API_VERSION), and changes to it are
# * documented in DOCS/client-api-changes.rst. The C API itself will probably
# * remain compatible for a long time, but the functionality exposed by it
# * could change more rapidly. For example, it's possible that options are
# * renamed, or change the set of allowed values.
# *
# * Defensive programming should be used to potentially deal with the fact that
# * options, commands, and properties could disappear, change their value range,
# * or change the underlying datatypes. It might be a good idea to prefer
# * MPV_FORMAT_STRING over other types to decouple your code from potential
# * mpv changes.
# *
# * Future changes
# * --------------
# *
# * This are the planned changes that will most likely be done on the next major
# * bump of the library:
# *
# * - remove all symbols and include files that are marked as deprecated
# * - reassign enum numerical values to remove gaps
# * - remove the mpv_opengl_init_params.extra_exts field
# * - change the type of mpv_event_end_file.reason
# * - disabling all events by default
#
# *
# * The version is incremented on each API change. The 16 lower bits form the
# * minor version number, and the 16 higher bits the major version number. If
# * the API becomes incompatible to previous versions, the major version
# * number is incremented. This affects only C part, and not properties and
# * options.
# *
# * Every API bump is described in DOCS/client-api-changes.rst
# *
# * You can use MPV_MAKE_VERSION() and compare the result with integer
# * relational operators (<, >, <=, >=).
#
# *
# * The API user is allowed to "#define MPV_ENABLE_DEPRECATED 0" before
# * including any libmpv headers. Then deprecated symbols will be excluded
# * from the headers. (Of course, deprecated properties and commands and
# * other functionality will still work.)
#
MPV_ENABLE_DEPRECATED* = 1
MPV_ERROR_SUCCESS* = (0).mpv_error
MPV_ERROR_EVENT_QUEUE_FULL* = (-1).mpv_error
MPV_ERROR_NOMEM* = (-2).mpv_error
MPV_ERROR_UNINITIALIZED* = (-3).mpv_error
MPV_ERROR_INVALID_PARAMETER* = (-4).mpv_error
MPV_ERROR_OPTION_NOT_FOUND* = (-5).mpv_error
MPV_ERROR_OPTION_FORMAT* = (-6).mpv_error
MPV_ERROR_OPTION_ERROR* = (-7).mpv_error
MPV_ERROR_PROPERTY_NOT_FOUND* = (-8).mpv_error
MPV_ERROR_PROPERTY_FORMAT* = (-9).mpv_error
MPV_ERROR_PROPERTY_UNAVAILABLE* = (-10).mpv_error
MPV_ERROR_PROPERTY_ERROR* = (-11).mpv_error
MPV_ERROR_COMMAND* = (-12).mpv_error
MPV_ERROR_LOADING_FAILED* = (-13).mpv_error
MPV_ERROR_AO_INIT_FAILED* = (-14).mpv_error
MPV_ERROR_VO_INIT_FAILED* = (-15).mpv_error
MPV_ERROR_NOTHING_TO_PLAY* = (-16).mpv_error
MPV_ERROR_UNKNOWN_FORMAT* = (-17).mpv_error
MPV_ERROR_UNSUPPORTED* = (-18).mpv_error
MPV_ERROR_NOT_IMPLEMENTED* = (-19).mpv_error
MPV_ERROR_GENERIC* = (-20).mpv_error
MPV_FORMAT_NONE* = (0).mpv_format
MPV_FORMAT_STRING* = (1).mpv_format
MPV_FORMAT_OSD_STRING* = (2).mpv_format
MPV_FORMAT_FLAG* = (3).mpv_format
MPV_FORMAT_INT64* = (4).mpv_format
MPV_FORMAT_DOUBLE* = (5).mpv_format
MPV_FORMAT_NODE* = (6).mpv_format
MPV_FORMAT_NODE_ARRAY* = (7).mpv_format
MPV_FORMAT_NODE_MAP* = (8).mpv_format
MPV_FORMAT_BYTE_ARRAY* = (9).mpv_format
MPV_EVENT_NONE* = (0).mpv_event_id
MPV_EVENT_SHUTDOWN* = (1).mpv_event_id
MPV_EVENT_LOG_MESSAGE* = (2).mpv_event_id
MPV_EVENT_GET_PROPERTY_REPLY* = (3).mpv_event_id
MPV_EVENT_SET_PROPERTY_REPLY* = (4).mpv_event_id
MPV_EVENT_COMMAND_REPLY* = (5).mpv_event_id
MPV_EVENT_START_FILE* = (6).mpv_event_id
MPV_EVENT_END_FILE* = (7).mpv_event_id
MPV_EVENT_FILE_LOADED* = (8).mpv_event_id
MPV_EVENT_TRACKS_CHANGED* = (9).mpv_event_id
MPV_EVENT_TRACK_SWITCHED* = (10).mpv_event_id
MPV_EVENT_IDLE* = (11).mpv_event_id
MPV_EVENT_PAUSE* = (12).mpv_event_id
MPV_EVENT_UNPAUSE* = (13).mpv_event_id
MPV_EVENT_TICK* = (14).mpv_event_id
MPV_EVENT_SCRIPT_INPUT_DISPATCH* = (15).mpv_event_id
MPV_EVENT_CLIENT_MESSAGE* = (16).mpv_event_id
MPV_EVENT_VIDEO_RECONFIG* = (17).mpv_event_id
MPV_EVENT_AUDIO_RECONFIG* = (18).mpv_event_id
MPV_EVENT_METADATA_UPDATE* = (19).mpv_event_id
MPV_EVENT_SEEK* = (20).mpv_event_id
MPV_EVENT_PLAYBACK_RESTART* = (21).mpv_event_id
MPV_EVENT_PROPERTY_CHANGE* = (22).mpv_event_id
MPV_EVENT_CHAPTER_CHANGE* = (23).mpv_event_id
MPV_EVENT_QUEUE_OVERFLOW* = (24).mpv_event_id
MPV_EVENT_HOOK* = (25).mpv_event_id
MPV_LOG_LEVEL_NONE* = (0).mpv_log_level
MPV_LOG_LEVEL_FATAL* = (10).mpv_log_level
MPV_LOG_LEVEL_ERROR* = (20).mpv_log_level
MPV_LOG_LEVEL_WARN* = (30).mpv_log_level
MPV_LOG_LEVEL_INFO* = (40).mpv_log_level
MPV_LOG_LEVEL_V* = (50).mpv_log_level
MPV_LOG_LEVEL_DEBUG* = (60).mpv_log_level
MPV_LOG_LEVEL_TRACE* = (70).mpv_log_level
MPV_END_FILE_REASON_EOF* = (0).mpv_end_file_reason
MPV_END_FILE_REASON_STOP* = (2).mpv_end_file_reason
MPV_END_FILE_REASON_QUIT* = (3).mpv_end_file_reason
MPV_END_FILE_REASON_ERROR* = (4).mpv_end_file_reason
MPV_END_FILE_REASON_REDIRECT* = (5).mpv_end_file_reason
MPV_SUB_API_OPENGL_CB* = (1).mpv_sub_api
{.pragma: impclientC, importc, cdecl.}
type
# *
# * Client context used by the client API. Every client has its own private
# * handle.
#
mpv_handle* {.pure, final.} = object
# *
# * Generic data storage.
# *
# * If mpv writes this struct (e.g. via mpv_get_property()), you must not change
# * the data. In some cases (mpv_get_property()), you have to free it with
# * mpv_free_node_contents(). If you fill this struct yourself, you're also
# * responsible for freeing it, and you must not call mpv_free_node_contents().
mpv_node_u* {.pure, final, union.} = object
string*: cstring
flag*: cint
int64*: int64
double*: cdouble
list*: ptr mpv_node_list
ba*: ptr mpv_byte_array
mpv_node* {.pure, final.} = object
u*: mpv_node_u
format*: mpv_format
# *
# * (see mpv_node)
#
mpv_node_list* {.pure, final.} = object
num*: cint
values*: ptr mpv_node
keys*: ptr cstring
# *
# * (see mpv_node)
#
mpv_byte_array* {.pure, final.} = object
data*: pointer
size*: cuint
mpv_event_property* {.pure, final.} = object
name*: cstring
format*: mpv_format
data*: pointer
mpv_event_log_message* {.pure, final.} = object
prefix*: cstring
level*: cstring
text*: cstring
log_level*: mpv_log_level
mpv_event_end_file* {.pure, final.} = object
reason*: cint
error*: cint
# * @deprecated see MPV_EVENT_SCRIPT_INPUT_DISPATCH for remarks
#
mpv_event_script_input_dispatch* {.pure, final.} = object
arg0*: cint
`type`*: cstring
mpv_event_client_message* {.pure, final.} = object
num_args*: cint
args*: ptr cstring
mpv_event_hook* {.pure, final.} = object
name*: cstring
id*: uint64
# Since API version 1.102.
mpv_event_command* {.pure, final.} = object
result*: mpv_node
mpv_event* {.pure, final.} = object
event_id*: mpv_event_id
error*: cint
reply_userdata*: uint64
data*: pointer
# *
# * Return the MPV_CLIENT_API_VERSION the mpv source has been compiled with.
#
proc mpv_client_api_version*(): culong {.impclientC.}
# *
# * Return a string describing the error. For unknown errors, the string
# * "unknown error" is returned.
# *
# * @param error error number, see enum mpv_error
# * @return A static string describing the error. The string is completely
# * static, i.e. doesn't need to be deallocated, and is valid forever.
#
proc mpv_error_string*(error: cint): cstring {.impclientC.}
# *
# * General function to deallocate memory returned by some of the API functions.
# * Call this only if it's explicitly documented as allowed. Calling this on
# * mpv memory not owned by the caller will lead to undefined behavior.
# *
# * @param data A valid pointer returned by the API, or NULL.
#
proc mpv_free*(data: pointer) {.impclientC.}
# *
# * Return the name of this client handle. Every client has its own unique
# * name, which is mostly used for user interface purposes.
# *
# * @return The client name. The string is read-only and is valid until the
# * mpv_handle is destroyed.
#
proc mpv_client_name*(ctx: ptr mpv_handle): cstring {.impclientC.}
# *
# * Create a new mpv instance and an associated client API handle to control
# * the mpv instance. This instance is in a pre-initialized state,
# * and needs to be initialized to be actually used with most other API
# * functions.
# *
# * Some API functions will return MPV_ERROR_UNINITIALIZED in the uninitialized
# * state. You can call mpv_set_property() (or mpv_set_property_string() and
# * other variants, and before mpv 0.21.0 mpv_set_option() etc.) to set initial
# * options. After this, call mpv_initialize() to start the player, and then use
# * e.g. mpv_command() to start playback of a file.
# *
# * The point of separating handle creation and actual initialization is that
# * you can configure things which can't be changed during runtime.
# *
# * Unlike the command line player, this will have initial settings suitable
# * for embedding in applications. The following settings are different:
# * - stdin/stdout/stderr and the terminal will never be accessed. This is
# * equivalent to setting the --no-terminal option.
# * (Technically, this also suppresses C signal handling.)
# * - No config files will be loaded. This is roughly equivalent to using
# * --config=no. Since libmpv 1.15, you can actually re-enable this option,
# * which will make libmpv load config files during mpv_initialize(). If you
# * do this, you are strongly encouraged to set the "config-dir" option too.
# * (Otherwise it will load the mpv command line player's config.)
# * For example:
# * mpv_set_option_string(mpv, "config-dir", "/my/path"); set config root
# * mpv_set_option_string(mpv, "config", "yes"); enable config loading
# * (call mpv_initialize() _after_ this)
# * - Idle mode is enabled, which means the playback core will enter idle mode
# * if there are no more files to play on the internal playlist, instead of
# * exiting. This is equivalent to the --idle option.
# * - Disable parts of input handling.
# * - Most of the different settings can be viewed with the command line player
# * by running "mpv --show-profile=libmpv".
# *
# * All this assumes that API users want a mpv instance that is strictly
# * isolated from the command line player's configuration, user settings, and
# * so on. You can re-enable disabled features by setting the appropriate
# * options.
# *
# * The mpv command line parser is not available through this API, but you can
# * set individual options with mpv_set_property(). Files for playback must be
# * loaded with mpv_command() or others.
# *
# * Note that you should avoid doing concurrent accesses on the uninitialized
# * client handle. (Whether concurrent access is definitely allowed or not has
# * yet to be decided.)
# *
# * @return a new mpv client API handle. Returns NULL on error. Currently, this
# * can happen in the following situations:
# * - out of memory
# * - LC_NUMERIC is not set to "C" (see general remarks)
#
proc mpv_create*(): ptr mpv_handle {.impclientC.}
# *
# * Initialize an uninitialized mpv instance. If the mpv instance is already
# * running, an error is retuned.
# *
# * This function needs to be called to make full use of the client API if the
# * client API handle was created with mpv_create().
# *
# * Only the following options require to be set _before_ mpv_initialize():
# * - options which are only read at initialization time:
# * - config
# * - config-dir
# * - input-conf
# * - load-scripts
# * - script
# * - player-operation-mode
# * - input-app-events (OSX)
# * - all encoding mode options
# *
# * @return error code
#
proc mpv_initialize*(ctx: ptr mpv_handle): cint {.impclientC.}
# *
# * Disconnect and destroy the mpv_handle. ctx will be deallocated with this
# * API call.
# *
# * If the last mpv_handle is detached, the core player is destroyed. In
# * addition, if there are only weak mpv_handles (such as created by
# * mpv_create_weak_client() or internal scripts), these mpv_handles will
# * be sent MPV_EVENT_SHUTDOWN. This function may block until these clients
# * have responded to the shutdown event, and the core is finally destroyed.
#
proc mpv_destroy*(ctx: ptr mpv_handle) {.impclientC.}
# *
# * @deprecated use mpv_destroy(), which has exactly the same semantics (the
# * deprecation is a mere rename)
# *
# * Since mpv client API version 1.29:
# * If the last mpv_handle is detached, the core player is destroyed. In
# * addition, if there are only weak mpv_handles (such as created by
# * mpv_create_weak_client() or internal scripts), these mpv_handles will
# * be sent MPV_EVENT_SHUTDOWN. This function may block until these clients
# * have responded to the shutdown event, and the core is finally destroyed.
# *
# * Before mpv client API version 1.29:
# * This left the player running. If you want to be sure that the
# * player is terminated, send a "quit" command, and wait until the
# * MPV_EVENT_SHUTDOWN event is received, or use mpv_terminate_destroy().
#
proc mpv_detach_destroy*(ctx: ptr mpv_handle) {.impclientC.}
# *
# * Similar to mpv_destroy(), but brings the player and all clients down
# * as well, and waits until all of them are destroyed. This function blocks. The
# * advantage over mpv_destroy() is that while mpv_destroy() merely
# * detaches the client handle from the player, this function quits the player,
# * waits until all other clients are destroyed (i.e. all mpv_handles are
# * detached), and also waits for the final termination of the player.
# *
# * Since mpv_destroy() is called somewhere on the way, it's not safe to
# * call other functions concurrently on the same context.
# *
# * Since mpv client API version 1.29:
# * The first call on any mpv_handle will block until the core is destroyed.
# * This means it will wait until other mpv_handle have been destroyed. If you
# * want asynchronous destruction, just run the "quit" command, and then react
# * to the MPV_EVENT_SHUTDOWN event.
# * If another mpv_handle already called mpv_terminate_destroy(), this call will
# * not actually block. It will destroy the mpv_handle, and exit immediately,
# * while other mpv_handles might still be uninitializing.
# *
# * Before mpv client API version 1.29:
# * If this is called on a mpv_handle that was not created with mpv_create(),
# * this function will merely send a quit command and then call
# * mpv_destroy(), without waiting for the actual shutdown.
#
proc mpv_terminate_destroy*(ctx: ptr mpv_handle) {.impclientC.}
# *
# * Create a new client handle connected to the same player core as ctx. This
# * context has its own event queue, its own mpv_request_event() state, its own
# * mpv_request_log_messages() state, its own set of observed properties, and
# * its own state for asynchronous operations. Otherwise, everything is shared.
# *
# * This handle should be destroyed with mpv_destroy() if no longer
# * needed. The core will live as long as there is at least 1 handle referencing
# * it. Any handle can make the core quit, which will result in every handle
# * receiving MPV_EVENT_SHUTDOWN.
# *
# * This function can not be called before the main handle was initialized with
# * mpv_initialize(). The new handle is always initialized, unless ctx=NULL was
# * passed.
# *
# * @param ctx Used to get the reference to the mpv core; handle-specific
# * settings and parameters are not used.
# * If NULL, this function behaves like mpv_create() (ignores name).
# * @param name The client name. This will be returned by mpv_client_name(). If
# * the name is already in use, or contains non-alphanumeric
# * characters (other than '_'), the name is modified to fit.
# * If NULL, an arbitrary name is automatically chosen.
# * @return a new handle, or NULL on error
#
proc mpv_create_client*(ctx: ptr mpv_handle, name: cstring): ptr mpv_handle {.impclientC.}
# *
# * This is the same as mpv_create_client(), but the created mpv_handle is
# * treated as a weak reference. If all mpv_handles referencing a core are
# * weak references, the core is automatically destroyed. (This still goes
# * through normal uninit of course. Effectively, if the last non-weak mpv_handle
# * is destroyed, then the weak mpv_handles receive MPV_EVENT_SHUTDOWN and are
# * asked to terminate as well.)
# *
# * Note if you want to use this like refcounting: you have to be aware that
# * mpv_terminate_destroy() _and_ mpv_destroy() for the last non-weak
# * mpv_handle will block until all weak mpv_handles are destroyed.
#
proc mpv_create_weak_client*(ctx: ptr mpv_handle, name: cstring): ptr mpv_handle {.impclientC.}
# *
# * Load a config file. This loads and parses the file, and sets every entry in
# * the config file's default section as if mpv_set_option_string() is called.
# *
# * The filename should be an absolute path. If it isn't, the actual path used
# * is unspecified. (Note: an absolute path starts with '/' on UNIX.) If the
# * file wasn't found, MPV_ERROR_INVALID_PARAMETER is returned.
# *
# * If a fatal error happens when parsing a config file, MPV_ERROR_OPTION_ERROR
# * is returned. Errors when setting options as well as other types or errors
# * are ignored (even if options do not exist). You can still try to capture
# * the resulting error messages with mpv_request_log_messages(). Note that it's
# * possible that some options were successfully set even if any of these errors
# * happen.
# *
# * @param filename absolute path to the config file on the local filesystem
# * @return error code
#
proc mpv_load_config_file*(ctx: ptr mpv_handle, filename: cstring): cint {.impclientC.}
# *
# * This does nothing since mpv 0.23.0 (API version 1.24). Below is the
# * description of the old behavior.
# *
# * Stop the playback thread. This means the core will stop doing anything, and
# * only run and answer to client API requests. This is sometimes useful; for
# * example, no new frame will be queued to the video output, so doing requests
# * which have to wait on the video output can run instantly.
# *
# * Suspension is reentrant and recursive for convenience. Any thread can call
# * the suspend function multiple times, and the playback thread will remain
# * suspended until the last thread resumes it. Note that during suspension, all
# * clients still have concurrent access to the core, which is serialized through
# * a single mutex.
# *
# * Call mpv_resume() to resume the playback thread. You must call mpv_resume()
# * for each mpv_suspend() call. Calling mpv_resume() more often than
# * mpv_suspend() is not allowed.
# *
# * Calling this on an uninitialized player (see mpv_create()) will deadlock.
# *
# * @deprecated This function, as well as mpv_resume(), are deprecated, and
# * will stop doing anything soon. Their semantics were never
# * well-defined, and their usefulness is extremely limited. The
# * calls will remain stubs in order to keep ABI compatibility.
#
proc mpv_suspend*(ctx: ptr mpv_handle) {.impclientC.}
# *
# * See mpv_suspend().
#
proc mpv_resume*(ctx: ptr mpv_handle) {.impclientC.}
# *
# * Return the internal time in microseconds. This has an arbitrary start offset,
# * but will never wrap or go backwards.
# *
# * Note that this is always the real time, and doesn't necessarily have to do
# * with playback time. For example, playback could go faster or slower due to
# * playback speed, or due to playback being paused. Use the "time-pos" property
# * instead to get the playback status.
# *
# * Unlike other libmpv APIs, this can be called at absolutely any time (even
# * within wakeup callbacks), as long as the context is valid.
# *
# * Safe to be called from mpv render API threads.
#
proc mpv_get_time_us*(ctx: ptr mpv_handle): int64 {.impclientC.}
# *
# * Frees any data referenced by the node. It doesn't free the node itself.
# * Call this only if the mpv client API set the node. If you constructed the
# * node yourself (manually), you have to free it yourself.
# *
# * If node->format is MPV_FORMAT_NONE, this call does nothing. Likewise, if
# * the client API sets a node with this format, this function doesn't need to
# * be called. (This is just a clarification that there's no danger of anything
# * strange happening in these cases.)
#
proc mpv_free_node_contents*(node: ptr mpv_node) {.impclientC.}
# *
# * Set an option. Note that you can't normally set options during runtime. It
# * works in uninitialized state (see mpv_create()), and in some cases in at
# * runtime.
# *
# * Using a format other than MPV_FORMAT_NODE is equivalent to constructing a
# * mpv_node with the given format and data, and passing the mpv_node to this
# * function.
# *
# * Note: this is semi-deprecated. For most purposes, this is not needed anymore.
# * Starting with mpv version 0.21.0 (version 1.23) most options can be set
# * with mpv_set_property() (and related functions), and even before
# * mpv_initialize(). In some obscure corner cases, using this function
# * to set options might still be required (see below, and also section
# * "Inconsistencies between options and properties" on the manpage). Once
# * these are resolved, the option setting functions might be fully
# * deprecated.
# *
# * The following options still need to be set either _before_
# * mpv_initialize() with mpv_set_property() (or related functions), or
# * with mpv_set_option() (or related functions) at any time:
# * - options shadowed by deprecated properties:
# * - demuxer (property deprecated in 0.21.0)
# * - idle (property deprecated in 0.21.0)
# * - fps (property deprecated in 0.21.0)
# * - cache (property deprecated in 0.21.0)
# * - length (property deprecated in 0.10.0)
# * - audio-samplerate (property deprecated in 0.10.0)
# * - audio-channels (property deprecated in 0.10.0)
# * - audio-format (property deprecated in 0.10.0)
# * - deprecated options shadowed by properties:
# * - chapter (option deprecated in 0.21.0)
# * - playlist-pos (option deprecated in 0.21.0)
# * The deprecated properties were removed in mpv 0.23.0.
# *
# * @param name Option name. This is the same as on the mpv command line, but
# * without the leading "--".
# * @param format see enum mpv_format.
# * @param[in] data Option value (according to the format).
# * @return error code
#
proc mpv_set_option*(ctx: ptr mpv_handle, name: cstring, format: mpv_format, data: pointer): cint {.impclientC.}
# *
# * Convenience function to set an option to a string value. This is like
# * calling mpv_set_option() with MPV_FORMAT_STRING.
# *
# * @return error code
#
proc mpv_set_option_string*(ctx: ptr mpv_handle, name: cstring, data: cstring): cint {.impclientC.}
# *
# * Send a command to the player. Commands are the same as those used in
# * input.conf, except that this function takes parameters in a pre-split
# * form.
# *
# * The commands and their parameters are documented in input.rst.
# *
# * Does not use OSD and string expansion by default (unlike mpv_command_string()
# * and input.conf).
# *
# * @param[in] args NULL-terminated list of strings. Usually, the first item
# * is the command, and the following items are arguments.
# * @return error code
#
proc mpv_command*(ctx: ptr mpv_handle, args: cstringArray): cint {.impclientC.}
# *
# * Same as mpv_command(), but allows passing structured data in any format.
# * In particular, calling mpv_command() is exactly like calling
# * mpv_command_node() with the format set to MPV_FORMAT_NODE_ARRAY, and
# * every arg passed in order as MPV_FORMAT_STRING.
# *
# * Does not use OSD and string expansion by default.
# *
# * The args argument can have one of the following formats:
# *
# * MPV_FORMAT_NODE_ARRAY:
# * Positional arguments. Each entry is an argument using an arbitrary
# * format (the format must be compatible to the used command). Usually,
# * the first item is the command name (as MPV_FORMAT_STRING). The order
# * of arguments is as documented in each command description.
# *
# * MPV_FORMAT_NODE_MAP:
# * Named arguments. This requires at least an entry with the key "name"
# * to be present, which must be a string, and contains the command name.
# * The special entry "_flags" is optional, and if present, must be an
# * array of strings, each being a command prefix to apply. All other
# * entries are interpreted as arguments. They must use the argument names
# * as documented in each command description. Some commands do not
# * support named arguments at all, and must use MPV_FORMAT_NODE_ARRAY.
# *
# * @param[in] args mpv_node with format set to one of the values documented
# * above (see there for details)
# * @param[out] result Optional, pass NULL if unused. If not NULL, and if the
# * function succeeds, this is set to command-specific return
# * data. You must call mpv_free_node_contents() to free it
# * (again, only if the command actually succeeds).
# * Not many commands actually use this at all.
# * @return error code (the result parameter is not set on error)
#
proc mpv_command_node*(ctx: ptr mpv_handle, args: ptr mpv_node, result: ptr mpv_node): cint {.impclientC.}
# *
# * Same as mpv_command, but use input.conf parsing for splitting arguments.
# * This is slightly simpler, but also more error prone, since arguments may
# * need quoting/escaping.
# *
# * This also has OSD and string expansion enabled by default.
#
proc mpv_command_string*(ctx: ptr mpv_handle, args: cstring): cint {.impclientC.}
# *
# * Same as mpv_command, but run the command asynchronously.
# *
# * Commands are executed asynchronously. You will receive a
# * MPV_EVENT_COMMAND_REPLY event. This event will also have an
# * error code set if running the command failed. For commands that
# * return data, the data is put into mpv_event_command.result.
# *
# * Safe to be called from mpv render API threads.
# *
# * @param reply_userdata the value mpv_event.reply_userdata of the reply will
# * be set to (see section about asynchronous calls)
# * @param args NULL-terminated list of strings (see mpv_command())
# * @return error code (if parsing or queuing the command fails)
#
proc mpv_command_async*(ctx: ptr mpv_handle, reply_userdata: uint64, args: ptr cstring): cint {.impclientC.}
# *
# * Same as mpv_command_node(), but run it asynchronously. Basically, this
# * function is to mpv_command_node() what mpv_command_async() is to
# * mpv_command().
# *
# * See mpv_command_async() for details.
# *
# * Safe to be called from mpv render API threads.
# *
# * @param reply_userdata the value mpv_event.reply_userdata of the reply will
# * be set to (see section about asynchronous calls)
# * @param args as in mpv_command_node()
# * @return error code (if parsing or queuing the command fails)
#
proc mpv_command_node_async*(ctx: ptr mpv_handle, reply_userdata: uint64, args: ptr mpv_node): cint {.impclientC.}
# *
# * Signal to all async requests with the matching ID to abort. This affects
# * the following API calls:
# *
# * mpv_command_async
# * mpv_command_node_async
# *
# * All of these functions take a reply_userdata parameter. This API function
# * tells all requests with the matching reply_userdata value to try to return
# * as soon as possible. If there are multiple requests with matching ID, it
# * aborts all of them.
# *
# * This API function is mostly asynchronous itself. It will not wait until the
# * command is aborted. Instead, the command will terminate as usual, but with
# * some work not done. How this is signaled depends on the specific command (for
# * example, the "subprocess" command will indicate it by "killed_by_us" set to
# * true in the result). How long it takes also depends on the situation. The
# * aborting process is completely asynchronous.
# *
# * Not all commands may support this functionality. In this case, this function
# * will have no effect. The same is true if the request using the passed
# * reply_userdata has already terminated, has not been started yet, or was
# * never in use at all.
# *
# * You have to be careful of race conditions: the time during which the abort
# * request will be effective is _after_ e.g. mpv_command_async() has returned,
# * and before the command has signaled completion with MPV_EVENT_COMMAND_REPLY.
# *
# * @param reply_userdata ID of the request to be aborted (see above)
#
proc mpv_abort_async_command*(ctx: ptr mpv_handle, reply_userdata: uint64) {.impclientC.}
# *
# * Set a property to a given value. Properties are essentially variables which
# * can be queried or set at runtime. For example, writing to the pause property
# * will actually pause or unpause playback.
# *
# * If the format doesn't match with the internal format of the property, access
# * usually will fail with MPV_ERROR_PROPERTY_FORMAT. In some cases, the data
# * is automatically converted and access succeeds. For example, MPV_FORMAT_INT64
# * is always converted to MPV_FORMAT_DOUBLE, and access using MPV_FORMAT_STRING
# * usually invokes a string parser. The same happens when calling this function
# * with MPV_FORMAT_NODE: the underlying format may be converted to another
# * type if possible.
# *
# * Using a format other than MPV_FORMAT_NODE is equivalent to constructing a
# * mpv_node with the given format and data, and passing the mpv_node to this
# * function. (Before API version 1.21, this was different.)
# *
# * Note: starting with mpv 0.21.0 (client API version 1.23), this can be used to
# * set options in general. It even can be used before mpv_initialize()
# * has been called. If called before mpv_initialize(), setting properties
# * not backed by options will result in MPV_ERROR_PROPERTY_UNAVAILABLE.
# * In some cases, properties and options still conflict. In these cases,
# * mpv_set_property() accesses the options before mpv_initialize(), and
# * the properties after mpv_initialize(). These conflicts will be removed
# * in mpv 0.23.0. See mpv_set_option() for further remarks.
# *
# * @param name The property name. See input.rst for a list of properties.
# * @param format see enum mpv_format.
# * @param[in] data Option value.
# * @return error code
#
proc mpv_set_property*(ctx: ptr mpv_handle, name: cstring, format: mpv_format, data: pointer): cint {.impclientC.}
# *
# * Convenience function to set a property to a string value.
# *
# * This is like calling mpv_set_property() with MPV_FORMAT_STRING.
#
proc mpv_set_property_string*(ctx: ptr mpv_handle, name: cstring, data: cstring): cint {.impclientC.}
# *
# * Set a property asynchronously. You will receive the result of the operation
# * as MPV_EVENT_SET_PROPERTY_REPLY event. The mpv_event.error field will contain
# * the result status of the operation. Otherwise, this function is similar to
# * mpv_set_property().
# *
# * Safe to be called from mpv render API threads.
# *
# * @param reply_userdata see section about asynchronous calls
# * @param name The property name.
# * @param format see enum mpv_format.
# * @param[in] data Option value. The value will be copied by the function. It
# * will never be modified by the client API.
# * @return error code if sending the request failed
#
proc mpv_set_property_async*(ctx: ptr mpv_handle, reply_userdata: uint64, name: cstring, format: mpv_format, data: pointer): cint {.impclientC.}
# *
# * Read the value of the given property.
# *
# * If the format doesn't match with the internal format of the property, access
# * usually will fail with MPV_ERROR_PROPERTY_FORMAT. In some cases, the data
# * is automatically converted and access succeeds. For example, MPV_FORMAT_INT64
# * is always converted to MPV_FORMAT_DOUBLE, and access using MPV_FORMAT_STRING
# * usually invokes a string formatter.
# *
# * @param name The property name.
# * @param format see enum mpv_format.
# * @param[out] data Pointer to the variable holding the option value. On
# * success, the variable will be set to a copy of the option
# * value. For formats that require dynamic memory allocation,
# * you can free the value with mpv_free() (strings) or
# * mpv_free_node_contents() (MPV_FORMAT_NODE).
# * @return error code
#
proc mpv_get_property*(ctx: ptr mpv_handle, name: cstring, format: mpv_format, data: pointer): cint {.impclientC.}
# *
# * Return the value of the property with the given name as string. This is
# * equivalent to mpv_get_property() with MPV_FORMAT_STRING.
# *
# * See MPV_FORMAT_STRING for character encoding issues.
# *
# * On error, NULL is returned. Use mpv_get_property() if you want fine-grained
# * error reporting.
# *
# * @param name The property name.
# * @return Property value, or NULL if the property can't be retrieved. Free
# * the string with mpv_free().
#
proc mpv_get_property_string*(ctx: ptr mpv_handle, name: cstring): cstring {.impclientC.}
# *
# * Return the property as "OSD" formatted string. This is the same as
# * mpv_get_property_string, but using MPV_FORMAT_OSD_STRING.
# *
# * @return Property value, or NULL if the property can't be retrieved. Free
# * the string with mpv_free().
#
proc mpv_get_property_osd_string*(ctx: ptr mpv_handle, name: cstring): cstring {.impclientC.}
# *
# * Get a property asynchronously. You will receive the result of the operation
# * as well as the property data with the MPV_EVENT_GET_PROPERTY_REPLY event.
# * You should check the mpv_event.error field on the reply event.
# *
# * Safe to be called from mpv render API threads.
# *
# * @param reply_userdata see section about asynchronous calls
# * @param name The property name.
# * @param format see enum mpv_format.
# * @return error code if sending the request failed
#
proc mpv_get_property_async*(ctx: ptr mpv_handle, reply_userdata: uint64, name: cstring, format: mpv_format): cint {.impclientC.}
# *
# * Get a notification whenever the given property changes. You will receive
# * updates as MPV_EVENT_PROPERTY_CHANGE. Note that this is not very precise:
# * for some properties, it may not send updates even if the property changed.
# * This depends on the property, and it's a valid feature request to ask for
# * better update handling of a specific property. (For some properties, like
# * ``clock``, which shows the wall clock, this mechanism doesn't make too
# * much sense anyway.)
# *
# * Property changes are coalesced: the change events are returned only once the
# * event queue becomes empty (e.g. mpv_wait_event() would block or return
# * MPV_EVENT_NONE), and then only one event per changed property is returned.
# *
# * Normally, change events are sent only if the property value changes according
# * to the requested format. mpv_event_property will contain the property value
# * as data member.
# *
# * Warning: if a property is unavailable or retrieving it caused an error,
# * MPV_FORMAT_NONE will be set in mpv_event_property, even if the
# * format parameter was set to a different value. In this case, the
# * mpv_event_property.data field is invalid.
# *
# * If the property is observed with the format parameter set to MPV_FORMAT_NONE,
# * you get low-level notifications whether the property _may_ have changed, and
# * the data member in mpv_event_property will be unset. With this mode, you
# * will have to determine yourself whether the property really changd. On the
# * other hand, this mechanism can be faster and uses less resources.
# *
# * Observing a property that doesn't exist is allowed. (Although it may still
# * cause some sporadic change events.)
# *
# * Keep in mind that you will get change notifications even if you change a
# * property yourself. Try to avoid endless feedback loops, which could happen
# * if you react to the change notifications triggered by your own change.
# *
# * Only the mpv_handle on which this was called will receive the property
# * change events, or can unobserve them.
# *
# * Safe to be called from mpv render API threads.
# *
# * @param reply_userdata This will be used for the mpv_event.reply_userdata
# * field for the received MPV_EVENT_PROPERTY_CHANGE
# * events. (Also see section about asynchronous calls,
# * although this function is somewhat different from
# * actual asynchronous calls.)
# * If you have no use for this, pass 0.
# * Also see mpv_unobserve_property().
# * @param name The property name.
# * @param format see enum mpv_format. Can be MPV_FORMAT_NONE to omit values
# * from the change events.
# * @return error code (usually fails only on OOM or unsupported format)
#
proc mpv_observe_property*(mpv: ptr mpv_handle, reply_userdata: uint64, name: cstring, format: mpv_format): cint {.impclientC.}
# *
# * Undo mpv_observe_property(). This will remove all observed properties for
# * which the given number was passed as reply_userdata to mpv_observe_property.
# *
# * Safe to be called from mpv render API threads.
# *
# * @param registered_reply_userdata ID that was passed to mpv_observe_property
# * @return negative value is an error code, >=0 is number of removed properties
# * on success (includes the case when 0 were removed)
#
proc mpv_unobserve_property*(mpv: ptr mpv_handle, registered_reply_userdata: uint64): cint {.impclientC.}
# *
# * Return a string describing the event. For unknown events, NULL is returned.
# *
# * Note that all events actually returned by the API will also yield a non-NULL
# * string with this function.
# *
# * @param event event ID, see see enum mpv_event_id
# * @return A static string giving a short symbolic name of the event. It
# * consists of lower-case alphanumeric characters and can include "-"
# * characters. This string is suitable for use in e.g. scripting
# * interfaces.
# * The string is completely static, i.e. doesn't need to be deallocated,
# * and is valid forever.
#
proc mpv_event_name*(event: mpv_event_id): cstring {.impclientC.}
# *
# * Enable or disable the given event.
# *
# * Some events are enabled by default. Some events can't be disabled.
# *
# * (Informational note: currently, all events are enabled by default, except
# * MPV_EVENT_TICK.)
# *
# * Safe to be called from mpv render API threads.
# *
# * @param event See enum mpv_event_id.
# * @param enable 1 to enable receiving this event, 0 to disable it.
# * @return error code
#
proc mpv_request_event*(ctx: ptr mpv_handle, event: mpv_event_id, enable: cint): cint {.impclientC.}
# *
# * Enable or disable receiving of log messages. These are the messages the
# * command line player prints to the terminal. This call sets the minimum
# * required log level for a message to be received with MPV_EVENT_LOG_MESSAGE.
# *
# * @param min_level Minimal log level as string. Valid log levels:
# * no fatal error warn info v debug trace
# * The value "no" disables all messages. This is the default.
# * An exception is the value "terminal-default", which uses the
# * log level as set by the "--msg-level" option. This works
# * even if the terminal is disabled. (Since API version 1.19.)
# * Also see mpv_log_level.
# * @return error code
#
proc mpv_request_log_messages*(ctx: ptr mpv_handle, min_level: cstring): cint {.impclientC.}
# *
# * Wait for the next event, or until the timeout expires, or if another thread
# * makes a call to mpv_wakeup(). Passing 0 as timeout will never wait, and
# * is suitable for polling.
# *
# * The internal event queue has a limited size (per client handle). If you
# * don't empty the event queue quickly enough with mpv_wait_event(), it will
# * overflow and silently discard further events. If this happens, making
# * asynchronous requests will fail as well (with MPV_ERROR_EVENT_QUEUE_FULL).
# *
# * Only one thread is allowed to call this on the same mpv_handle at a time.
# * The API won't complain if more than one thread calls this, but it will cause
# * race conditions in the client when accessing the shared mpv_event struct.
# * Note that most other API functions are not restricted by this, and no API
# * function internally calls mpv_wait_event(). Additionally, concurrent calls
# * to different mpv_handles are always safe.
# *
# * As long as the timeout is 0, this is safe to be called from mpv render API
# * threads.
# *
# * @param timeout Timeout in seconds, after which the function returns even if
# * no event was received. A MPV_EVENT_NONE is returned on
# * timeout. A value of 0 will disable waiting. Negative values
# * will wait with an infinite timeout.
# * @return A struct containing the event ID and other data. The pointer (and
# * fields in the struct) stay valid until the next mpv_wait_event()
# * call, or until the mpv_handle is destroyed. You must not write to
# * the struct, and all memory referenced by it will be automatically
# * released by the API on the next mpv_wait_event() call, or when the
# * context is destroyed. The return value is never NULL.
#
proc mpv_wait_event*(ctx: ptr mpv_handle, timeout: cdouble): ptr mpv_event {.impclientC.}
# *
# * Interrupt the current mpv_wait_event() call. This will wake up the thread
# * currently waiting in mpv_wait_event(). If no thread is waiting, the next
# * mpv_wait_event() call will return immediately (this is to avoid lost
# * wakeups).
# *
# * mpv_wait_event() will receive a MPV_EVENT_NONE if it's woken up due to
# * this call. But note that this dummy event might be skipped if there are
# * already other events queued. All what counts is that the waiting thread
# * is woken up at all.
# *
# * Safe to be called from mpv render API threads.
#
proc mpv_wakeup*(ctx: ptr mpv_handle) {.impclientC.}
# *
# * Set a custom function that should be called when there are new events. Use
# * this if blocking in mpv_wait_event() to wait for new events is not feasible.
# *
# * Keep in mind that the callback will be called from foreign threads. You
# * must not make any assumptions of the environment, and you must return as
# * soon as possible (i.e. no long blocking waits). Exiting the callback through
# * any other means than a normal return is forbidden (no throwing exceptions,
# * no longjmp() calls). You must not change any local thread state (such as
# * the C floating point environment).
# *
# * You are not allowed to call any client API functions inside of the callback.
# * In particular, you should not do any processing in the callback, but wake up
# * another thread that does all the work. The callback is meant strictly for
# * notification only, and is called from arbitrary core parts of the player,
# * that make no considerations for reentrant API use or allowing the callee to
# * spend a lot of time doing other things. Keep in mind that it's also possible
# * that the callback is called from a thread while a mpv API function is called
# * (i.e. it can be reentrant).
# *
# * In general, the client API expects you to call mpv_wait_event() to receive
# * notifications, and the wakeup callback is merely a helper utility to make
# * this easier in certain situations. Note that it's possible that there's
# * only one wakeup callback invocation for multiple events. You should call
# * mpv_wait_event() with no timeout until MPV_EVENT_NONE is reached, at which
# * point the event queue is empty.
# *
# * If you actually want to do processing in a callback, spawn a thread that
# * does nothing but call mpv_wait_event() in a loop and dispatches the result
# * to a callback.
# *
# * Only one wakeup callback can be set.
# *
# * @param cb function that should be called if a wakeup is required
# * @param d arbitrary userdata passed to cb
#
# *
# * Block until all asynchronous requests are done. This affects functions like
# * mpv_command_async(), which return immediately and return their result as
# * events.
# *
# * This is a helper, and somewhat equivalent to calling mpv_wait_event() in a
# * loop until all known asynchronous requests have sent their reply as event,
# * except that the event queue is not emptied.
# *
# * In case you called mpv_suspend() before, this will also forcibly reset the
# * suspend counter of the given handle.
#
proc mpv_wait_async_requests*(ctx: ptr mpv_handle) {.impclientC.}
# *
# * A hook is like a synchronous event that blocks the player. You register
# * a hook handler with this function. You will get an event, which you need
# * to handle, and once things are ready, you can let the player continue with
# * mpv_hook_continue().
# *
# * Currently, hooks can't be removed explicitly. But they will be implicitly
# * removed if the mpv_handle it was registered with is destroyed. This also
# * continues the hook if it was being handled by the destroyed mpv_handle (but
# * this should be avoided, as it might mess up order of hook execution).
# *
# * Hook handlers are ordered globally by priority and order of registration.
# * Handlers for the same hook with same priority are invoked in order of
# * registration (the handler registered first is run first). Handlers with
# * lower priority are run first (which seems backward).
# *
# * See the "Hooks" section in the manpage to see which hooks are currently
# * defined.
# *
# * Some hooks might be reentrant (so you get multiple MPV_EVENT_HOOK for the
# * same hook). If this can happen for a specific hook type, it will be
# * explicitly documented in the manpage.
# *
# * Only the mpv_handle on which this was called will receive the hook events,
# * or can "continue" them.
# *
# * @param reply_userdata This will be used for the mpv_event.reply_userdata
# * field for the received MPV_EVENT_HOOK events.
# * If you have no use for this, pass 0.
# * @param name The hook name. This should be one of the documented names. But
# * if the name is unknown, the hook event will simply be never
# * raised.
# * @param priority See remarks above. Use 0 as a neutral default.
# * @return error code (usually fails only on OOM)
#
proc mpv_hook_add*(ctx: ptr mpv_handle, reply_userdata: uint64, name: cstring, priority: cint): cint {.impclientC.}
# *
# * Respond to a MPV_EVENT_HOOK event. You must call this after you have handled
# * the event. There is no way to "cancel" or "stop" the hook.
# *
# * Calling this will will typically unblock the player for whatever the hook
# * is responsible for (e.g. for the "on_load" hook it lets it continue
# * playback).
# *
# * It is explicitly undefined behavior to call this more than once for each
# * MPV_EVENT_HOOK, to pass an incorrect ID, or to call this on a mpv_handle
# * different from the one that registered the handler and received the event.
# *
# * @param id This must be the value of the mpv_event_hook.id field for the
# * corresponding MPV_EVENT_HOOK.
# * @return error code
#
proc mpv_hook_continue*(ctx: ptr mpv_handle, id: uint64): cint {.impclientC.}
# *
# * Return a UNIX file descriptor referring to the read end of a pipe. This
# * pipe can be used to wake up a poll() based processing loop. The purpose of
# * this function is very similar to mpv_set_wakeup_callback(), and provides
# * a primitive mechanism to handle coordinating a foreign event loop and the
# * libmpv event loop. The pipe is non-blocking. It's closed when the mpv_handle
# * is destroyed. This function always returns the same value (on success).
# *
# * This is in fact implemented using the same underlying code as for
# * mpv_set_wakeup_callback() (though they don't conflict), and it is as if each
# * callback invocation writes a single 0 byte to the pipe. When the pipe
# * becomes readable, the code calling poll() (or select()) on the pipe should
# * read all contents of the pipe and then call mpv_wait_event(c, 0) until
# * no new events are returned. The pipe contents do not matter and can just
# * be discarded. There is not necessarily one byte per readable event in the
# * pipe. For example, the pipes are non-blocking, and mpv won't block if the
# * pipe is full. Pipes are normally limited to 4096 bytes, so if there are
# * more than 4096 events, the number of readable bytes can not equal the number
# * of events queued. Also, it's possible that mpv does not write to the pipe
# * once it's guaranteed that the client was already signaled. See the example
# * below how to do it correctly.
# *
# * Example:
# *
# * int pipefd = mpv_get_wakeup_pipe(mpv);
# * if (pipefd < 0)
# * error();
# * while (1) {
# * struct pollfd pfds[1] = {
# * { .fd = pipefd, .events = POLLIN },
# * };
# * Wait until there are possibly new mpv events.
# * poll(pfds, 1, -1);
# * if (pfds[0].revents & POLLIN) {
# * Empty the pipe. Doing this before calling mpv_wait_event()
# * ensures that no wakeups are missed. It's not so important to
# * make sure the pipe is really empty (it will just cause some
# * additional wakeups in unlikely corner cases).
# * char unused[256];
# * read(pipefd, unused, sizeof(unused));
# * while (1) {
# * mpv_event *ev = mpv_wait_event(mpv, 0);
# * If MPV_EVENT_NONE is received, the event queue is empty.
# * if (ev->event_id == MPV_EVENT_NONE)
# * break;
# * Process the event.
# * ...
# * }
# * }
# * }
# *
# * @deprecated this function will be removed in the future. If you need this
# * functionality, use mpv_set_wakeup_callback(), create a pipe
# * manually, and call write() on your pipe in the callback.
# *
# * @return A UNIX FD of the read end of the wakeup pipe, or -1 on error.
# * On MS Windows/MinGW, this will always return -1.
#
proc mpv_get_wakeup_pipe*(ctx: ptr mpv_handle): cint {.impclientC.}
# *
# * This is used for additional APIs that are not strictly part of the core API.
# * See the individual mpv_sub_api member values.
# *
# * @deprecated use render.h
#
proc mpv_get_sub_api*(ctx: ptr mpv_handle, sub_api: mpv_sub_api): pointer {.impclientC.}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment