Something went wrong. Try again.
🎥 Command line media player
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930/* * 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 <errno.h>#include <stdatomic.h>#include <stdbool.h>#include <stdio.h>#include <stdlib.h>#include <string.h>
#include "common/common.h"#include "common/global.h"#include "common/msg_control.h"#include "common/msg.h"#include "m_config_core.h"#include "misc/dispatch.h"#include "options/m_option.h"#include "osdep/threads.h"
// For use with m_config_cache.struct m_config_shadow { mp_mutex lock; // Incremented on every option change. _Atomic uint64_t ts; // -- immutable after init // List of m_sub_options instances. // Index 0 is the top-level and is always present. // Immutable after init. // Invariant: a parent is always at a lower index than any of its children. struct m_config_group *groups; int num_groups; // -- protected by lock struct m_config_data *data; // protected shadow copy of the option data struct config_cache **listeners; int num_listeners;};
// Represents a sub-struct (OPT_SUBSTRUCT()).struct m_config_group { const struct m_sub_options *group; int opt_count; // cached opt. count; group->opts[opt_count].name==NULL int group_count; // 1 + number of all sub groups owned by this (so // m_config_shadow.groups[idx..idx+group_count] is used // by the entire tree of sub groups included by this // group) int parent_group; // index of parent group into m_config_shadow.groups[], // or -1 for group 0 int parent_ptr; // ptr offset in the parent group's data, or -1 if // none const char *prefix; // concat_name(_, prefix, opt->name) => full name // (the parent names are already included in this)};
// A copy of option data. Used for the main option struct, the shadow data,// and copies for m_config_cache.struct m_config_data { struct m_config_shadow *shadow; // option definitions etc., main data copy int group_index; // start index into m_config.groups[] struct m_group_data *gdata; // user struct allocation (our copy of data) int num_gdata; // (group_index+num_gdata = end index)};
struct config_cache { struct m_config_cache *public;
struct m_config_data *data; // public data struct m_config_data *src; // global data (currently ==shadow->data) struct m_config_shadow *shadow; // global metadata int group_start, group_end; // derived from data->group_index etc. uint64_t ts; // timestamp of this data copy bool in_list; // part of m_config_shadow->listeners[] int upd_group; // for "incremental" change notification int upd_opt;
// --- Implicitly synchronized by setting/unsetting wakeup_cb. struct mp_dispatch_queue *wakeup_dispatch_queue; void (*wakeup_dispatch_cb)(void *ctx); void *wakeup_dispatch_cb_ctx;
// --- Protected by shadow->lock void (*wakeup_cb)(void *ctx); void *wakeup_cb_ctx;};
struct force_update { char *name; uint64_t ts;};
// Per m_config_data state for each m_config_group.struct m_group_data { char *udata; // pointer to group user option struct uint64_t ts; // timestamp of the data copy struct force_update **force_update; // tracks opts that are written with force update int force_update_len;};
static void add_sub_group(struct m_config_shadow *shadow, const char *name_prefix, int parent_group_index, int parent_ptr, const struct m_sub_options *subopts);
static struct m_group_data *m_config_gdata(struct m_config_data *data, int group_index){ if (group_index < data->group_index || group_index >= data->group_index + data->num_gdata) return NULL;
return &data->gdata[group_index - data->group_index];}
// Like concat_name(), but returns either a, b, or buf. buf/buf_size is used as// target for snprintf(). (buf_size is recommended to be MAX_OPT_NAME_LEN.)static const char *concat_name_buf(char *buf, size_t buf_size, const char *a, const char *b){ assert(a); assert(b); if (!a[0]) return b; if (!b[0]) return a; snprintf(buf, buf_size, "%s-%s", a, b); return buf;}
// Return full option name from prefix (a) and option name (b). Returns either// a, b, or a talloc'ed string under ta_parent.static const char *concat_name(void *ta_parent, const char *a, const char *b){ char buf[M_CONFIG_MAX_OPT_NAME_LEN]; const char *r = concat_name_buf(buf, sizeof(buf), a, b); return r == buf ? talloc_strdup(ta_parent, r) : r;}
static bool iter_next(struct m_config_shadow *shadow, int group_start, int group_end, int32_t *p_id){ int32_t id = *p_id; int group_index = id == -1 ? group_start : id >> 16; int opt_index = id == -1 ? -1 : id & 0xFFFF;
assert(group_index >= group_start && group_index <= group_end);
while (1) { if (group_index >= group_end) return false;
struct m_config_group *g = &shadow->groups[group_index]; const struct m_option *opts = g->group->opts;
assert(opt_index >= -1 && opt_index < g->opt_count);
opt_index += 1;
if (!opts || !opts[opt_index].name) { group_index += 1; opt_index = -1; continue; }
if (opts[opt_index].type == &m_option_type_subconfig) continue;
*p_id = (group_index << 16) | opt_index; return true; }}
bool m_config_shadow_get_next_opt(struct m_config_shadow *shadow, int32_t *p_id){ return iter_next(shadow, 0, shadow->num_groups, p_id);}
bool m_config_cache_get_next_opt(struct m_config_cache *cache, int32_t *p_id){ return iter_next(cache->shadow, cache->internal->group_start, cache->internal->group_end, p_id);}
static void get_opt_from_id(struct m_config_shadow *shadow, int32_t id, int *out_group_index, int *out_opt_index){ int group_index = id >> 16; int opt_index = id & 0xFFFF;
assert(group_index >= 0 && group_index < shadow->num_groups); assert(opt_index >= 0 && opt_index < shadow->groups[group_index].opt_count);
*out_group_index = group_index; *out_opt_index = opt_index;}
const struct m_option *m_config_shadow_get_opt(struct m_config_shadow *shadow, int32_t id){ int group_index, opt_index; get_opt_from_id(shadow, id, &group_index, &opt_index);
return &shadow->groups[group_index].group->opts[opt_index];}
const char *m_config_shadow_get_opt_name(struct m_config_shadow *shadow, int32_t id, char *buf, size_t buf_size){ int group_index, opt_index; get_opt_from_id(shadow, id, &group_index, &opt_index);
struct m_config_group *g = &shadow->groups[group_index]; return concat_name_buf(buf, buf_size, g->prefix, g->group->opts[opt_index].name);}
const char *m_config_shadow_get_alias_from_opt(struct m_config_shadow *shadow, int32_t id, char *buf, size_t buf_size){ int group_index, opt_index; get_opt_from_id(shadow, id, &group_index, &opt_index);
struct m_config_group *g = &shadow->groups[group_index]; const struct m_option *opt = &shadow->groups[group_index].group->opts[opt_index]; if (opt->alias_use_prefix) return concat_name_buf(buf, buf_size, g->prefix, (const char *)opt->priv); return (const char *)opt->priv;}
const void *m_config_shadow_get_opt_default(struct m_config_shadow *shadow, int32_t id){ int group_index, opt_index; get_opt_from_id(shadow, id, &group_index, &opt_index);
const struct m_sub_options *subopt = shadow->groups[group_index].group; const struct m_option *opt = &subopt->opts[opt_index];
if (opt->offset < 0) return NULL;
if (opt->defval) return opt->defval;
if (subopt->defaults) return (char *)subopt->defaults + opt->offset;
return &m_option_value_default;}
void *m_config_cache_get_opt_data(struct m_config_cache *cache, int32_t id){ int group_index, opt_index; get_opt_from_id(cache->shadow, id, &group_index, &opt_index);
assert(group_index >= cache->internal->group_start && group_index < cache->internal->group_end);
struct m_group_data *gd = m_config_gdata(cache->internal->data, group_index); const struct m_option *opt = &cache->shadow->groups[group_index].group->opts[opt_index];
return gd && opt->offset >= 0 ? gd->udata + opt->offset : NULL;}
static uint64_t get_opt_change_mask(struct m_config_shadow *shadow, int group_index, int group_root, const struct m_option *opt){ uint64_t changed = opt->flags & UPDATE_OPTS_MASK; while (group_index != group_root) { struct m_config_group *g = &shadow->groups[group_index]; changed |= g->group->change_flags; group_index = g->parent_group; } return changed;}
uint64_t m_config_cache_get_option_change_mask(struct m_config_cache *cache, int32_t id){ struct m_config_shadow *shadow = cache->shadow; int group_index, opt_index; get_opt_from_id(shadow, id, &group_index, &opt_index);
assert(group_index >= cache->internal->group_start && group_index < cache->internal->group_end);
return get_opt_change_mask(cache->shadow, group_index, cache->internal->data->group_index, &shadow->groups[group_index].group->opts[opt_index]);}
// The memcpys are supposed to work around the strict aliasing violation,// that would result if we just dereferenced a void** (where the void** is// actually casted from struct some_type* ). The dummy struct type is in// theory needed, because void* and struct pointers could have different// representations, while pointers to different struct types don't.static void *substruct_read_ptr(const void *ptr){ struct mp_dummy_ *res; memcpy(&res, ptr, sizeof(res)); return res;}static void substruct_write_ptr(void *ptr, void *val){ struct mp_dummy_ *src = val; memcpy(ptr, &src, sizeof(src));}
// Initialize a field with a given value. In case this is dynamic data, it has// to be allocated and copied. src can alias dst.static void init_opt_inplace(const struct m_option *opt, void *dst, const void *src){ // The option will use dynamic memory allocation iff it has a free callback. if (opt->type->free) { union m_option_value temp; memcpy(&temp, src, opt->type->size); memset(dst, 0, opt->type->size); m_option_copy(opt, dst, &temp); } else if (src != dst) { memcpy(dst, src, opt->type->size); }}
static void alloc_group(struct m_config_data *data, int group_index, struct m_config_data *copy){ assert(group_index == data->group_index + data->num_gdata); assert(group_index < data->shadow->num_groups); struct m_config_group *group = &data->shadow->groups[group_index]; const struct m_sub_options *opts = group->group;
MP_TARRAY_GROW(data, data->gdata, data->num_gdata); struct m_group_data *gdata = &data->gdata[data->num_gdata++];
struct m_group_data *copy_gdata = copy ? m_config_gdata(copy, group_index) : NULL;
*gdata = (struct m_group_data){ .udata = talloc_zero_size(data, opts->size), .ts = copy_gdata ? copy_gdata->ts : 0, };
if (opts->defaults) memcpy(gdata->udata, opts->defaults, opts->size);
char *copy_src = copy_gdata ? copy_gdata->udata : NULL;
for (int n = 0; opts->opts && opts->opts[n].name; n++) { const struct m_option *opt = &opts->opts[n];
if (opt->offset < 0 || opt->type->size == 0) continue;
void *dst = gdata->udata + opt->offset; const void *defptr = opt->defval ? opt->defval : dst; if (copy_src) defptr = copy_src + opt->offset;
init_opt_inplace(opt, dst, defptr); }
// If there's a parent, update its pointer to the new struct. if (group->parent_group >= data->group_index && group->parent_ptr >= 0) { struct m_group_data *parent_gdata = m_config_gdata(data, group->parent_group); assert(parent_gdata);
substruct_write_ptr(parent_gdata->udata + group->parent_ptr, gdata->udata); }}
static void free_option_data(void *p){ struct m_config_data *data = p;
for (int i = 0; i < data->num_gdata; i++) { struct m_group_data *gdata = &data->gdata[i]; struct m_config_group *group = &data->shadow->groups[data->group_index + i]; const struct m_option *opts = group->group->opts;
for (int n = 0; opts && opts[n].name; n++) { const struct m_option *opt = &opts[n];
if (opt->offset >= 0 && opt->type->size > 0) m_option_free(opt, gdata->udata + opt->offset); } }}
// Allocate data using the option description in shadow, starting at group_index// (index into m_config.groups[]).// If copy is not NULL, copy all data from there (for groups which are in both// m_config_data instances), in all other cases init the data with the defaults.static struct m_config_data *allocate_option_data(void *ta_parent, struct m_config_shadow *shadow, int group_index, struct m_config_data *copy){ assert(group_index >= 0 && group_index < shadow->num_groups); struct m_config_data *data = talloc_zero(ta_parent, struct m_config_data); talloc_set_destructor(data, free_option_data);
data->shadow = shadow; data->group_index = group_index;
struct m_config_group *root_group = &shadow->groups[group_index]; assert(root_group->group_count > 0);
for (int n = group_index; n < group_index + root_group->group_count; n++) alloc_group(data, n, copy);
return data;}
static void shadow_destroy(void *p){ struct m_config_shadow *shadow = p;
// must all have been unregistered assert(shadow->num_listeners == 0);
talloc_free(shadow->data); mp_mutex_destroy(&shadow->lock);}
struct m_config_shadow *m_config_shadow_new(const struct m_sub_options *root){ struct m_config_shadow *shadow = talloc_zero(NULL, struct m_config_shadow); talloc_set_destructor(shadow, shadow_destroy); mp_mutex_init(&shadow->lock);
add_sub_group(shadow, NULL, -1, -1, root);
if (!root->size) return shadow;
shadow->data = allocate_option_data(shadow, shadow, 0, NULL);
return shadow;}
static void init_obj_settings_list(struct m_config_shadow *shadow, int parent_group_index, const struct m_obj_list *list){ struct m_obj_desc desc; for (int n = 0; ; n++) { if (!list->get_desc(&desc, n)) break; if (desc.global_opts) { add_sub_group(shadow, NULL, parent_group_index, -1, desc.global_opts); } if (list->use_global_options && desc.options) { struct m_sub_options *conf = talloc_ptrtype(shadow, conf); *conf = (struct m_sub_options){ .prefix = desc.options_prefix, .opts = desc.options, .defaults = desc.priv_defaults, .size = desc.priv_size, }; add_sub_group(shadow, NULL, parent_group_index, -1, conf); } }}
static void add_sub_group(struct m_config_shadow *shadow, const char *name_prefix, int parent_group_index, int parent_ptr, const struct m_sub_options *subopts){ // Can't be used multiple times. for (int n = 0; n < shadow->num_groups; n++) assert(shadow->groups[n].group != subopts);
if (!name_prefix) name_prefix = ""; if (subopts->prefix && subopts->prefix[0]) { assert(!name_prefix[0]); name_prefix = subopts->prefix; }
// You can only use UPDATE_ flags here. assert(!(subopts->change_flags & ~(unsigned)UPDATE_OPTS_MASK));
assert(parent_group_index >= -1 && parent_group_index < shadow->num_groups);
int group_index = shadow->num_groups++; MP_TARRAY_GROW(shadow, shadow->groups, group_index); shadow->groups[group_index] = (struct m_config_group){ .group = subopts, .parent_group = parent_group_index, .parent_ptr = parent_ptr, .prefix = name_prefix, };
for (int i = 0; subopts->opts && subopts->opts[i].name; i++) { const struct m_option *opt = &subopts->opts[i];
if (opt->type == &m_option_type_subconfig) { const struct m_sub_options *new_subopts = opt->priv;
// Providing default structs in-place is not allowed. if (opt->offset >= 0 && subopts->defaults) { void *ptr = (char *)subopts->defaults + opt->offset; assert(!substruct_read_ptr(ptr)); }
const char *prefix = concat_name(shadow, name_prefix, opt->name); add_sub_group(shadow, prefix, group_index, opt->offset, new_subopts);
} else if (opt->type == &m_option_type_obj_settings_list) { const struct m_obj_list *objlist = opt->priv; init_obj_settings_list(shadow, group_index, objlist); }
shadow->groups[group_index].opt_count = i + 1; }
if (subopts->get_sub_options) { for (int i = 0; ; i++) { const struct m_sub_options *sub = NULL; if (!subopts->get_sub_options(i, &sub)) break; if (sub) add_sub_group(shadow, NULL, group_index, -1, sub); } }
shadow->groups[group_index].group_count = shadow->num_groups - group_index;}
static void cache_destroy(void *p){ struct m_config_cache *cache = p;
// (technically speaking, being able to call them both without anything // breaking is a feature provided by these functions) m_config_cache_set_wakeup_cb(cache, NULL, NULL); m_config_cache_set_dispatch_change_cb(cache, NULL, NULL, NULL);}
struct m_config_cache *m_config_cache_from_shadow(void *ta_parent, struct m_config_shadow *shadow, const struct m_sub_options *group){ int group_index = -1;
for (int n = 0; n < shadow->num_groups; n++) { if (shadow->groups[n].group == group) { group_index = n; break; } }
assert(group_index >= 0); // invalid group (or not in option tree)
struct cache_alloc { struct m_config_cache a; struct config_cache b; }; struct cache_alloc *alloc = talloc_zero(ta_parent, struct cache_alloc); assert((void *)&alloc->a == (void *)alloc); struct m_config_cache *cache = &alloc->a; talloc_set_destructor(cache, cache_destroy); cache->internal = &alloc->b; cache->shadow = shadow;
struct config_cache *in = cache->internal; in->shadow = shadow; in->src = shadow->data;
mp_mutex_lock(&shadow->lock); in->data = allocate_option_data(cache, shadow, group_index, in->src); mp_mutex_unlock(&shadow->lock);
cache->opts = in->data->gdata[0].udata;
in->group_start = in->data->group_index; in->group_end = in->group_start + in->data->num_gdata; assert(shadow->groups[in->group_start].group_count == in->data->num_gdata);
in->upd_group = -1;
return cache;}
struct m_config_cache *m_config_cache_alloc(void *ta_parent, struct mpv_global *global, const struct m_sub_options *group){ return m_config_cache_from_shadow(ta_parent, global->config, group);}
static void append_force_update(struct m_config_cache *cache, struct m_group_data *gdata, const char *opt_name){ for (int i = 0; i < gdata->force_update_len; ++i) { if (strcmp(opt_name, gdata->force_update[i]->name) == 0) { gdata->force_update[i]->ts = gdata->ts; return; } } struct force_update *new_update = talloc_zero(cache, struct force_update); new_update->name = talloc_strdup(cache, opt_name); new_update->ts = gdata->ts; MP_TARRAY_APPEND(cache, gdata->force_update, gdata->force_update_len, new_update);}
static bool check_force_update(struct m_group_data *gdata, const char *opt_name, uint64_t timestamp){ for (int i = 0; i < gdata->force_update_len; ++i) { if ((strcmp(opt_name, gdata->force_update[i]->name) == 0) && gdata->force_update[i]->ts == timestamp) { return true; } } return false;}
static void update_next_option(struct m_config_cache *cache, void **p_opt){ struct config_cache *in = cache->internal; struct m_config_data *dst = in->data; struct m_config_data *src = in->src;
assert(src->group_index == 0); // must be the option root currently
*p_opt = NULL;
while (in->upd_group < dst->group_index + dst->num_gdata) { struct m_group_data *gsrc = m_config_gdata(src, in->upd_group); struct m_group_data *gdst = m_config_gdata(dst, in->upd_group); assert(gsrc && gdst);
if (gdst->ts < gsrc->ts) { struct m_config_group *g = &dst->shadow->groups[in->upd_group]; const struct m_option *opts = g->group->opts;
while (opts && opts[in->upd_opt].name) { const struct m_option *opt = &opts[in->upd_opt]; void *dsrc = gsrc->udata + opt->offset; void *ddst = gdst->udata + opt->offset;
if (opt->offset >= 0 && opt->type->size) { bool opt_equal = m_option_equal(opt, ddst, dsrc); bool force_update = opt->force_update && check_force_update(gsrc, opt->name, in->ts); if (!opt_equal || force_update) { uint64_t ch = get_opt_change_mask(dst->shadow, in->upd_group, dst->group_index, opt);
if (cache->debug && !opt_equal) { char *vdst = m_option_print(opt, ddst); char *vsrc = m_option_print(opt, dsrc); mp_warn(cache->debug, "Option '%s' changed from " "'%s' to' %s' (flags = 0x%"PRIx64")\n", opt->name, vdst, vsrc, ch); talloc_free(vdst); talloc_free(vsrc); }
m_option_copy(opt, ddst, dsrc); cache->change_flags |= ch;
in->upd_opt++; // skip this next time *p_opt = ddst; return; } }
in->upd_opt++; }
gdst->ts = gsrc->ts; }
in->upd_group++; in->upd_opt = 0; }
in->upd_group = -1;}
static bool cache_check_update(struct m_config_cache *cache){ struct config_cache *in = cache->internal; struct m_config_shadow *shadow = in->shadow;
// Using atomics and checking outside of the lock - it's unknown whether // this makes it faster or slower. Just cargo culting it. uint64_t new_ts = atomic_load(&shadow->ts); if (in->ts >= new_ts) return false;
in->ts = new_ts; in->upd_group = in->data->group_index; in->upd_opt = 0; return true;}
bool m_config_cache_update(struct m_config_cache *cache){ struct config_cache *in = cache->internal; struct m_config_shadow *shadow = in->shadow;
if (!cache_check_update(cache)) return false;
mp_mutex_lock(&shadow->lock); bool res = false; while (1) { void *p; update_next_option(cache, &p); if (!p) break; res = true; } mp_mutex_unlock(&shadow->lock); return res;}
bool m_config_cache_get_next_changed(struct m_config_cache *cache, void **opt){ struct config_cache *in = cache->internal; struct m_config_shadow *shadow = in->shadow;
*opt = NULL; if (!cache_check_update(cache) && in->upd_group < 0) return false;
mp_mutex_lock(&shadow->lock); update_next_option(cache, opt); mp_mutex_unlock(&shadow->lock); return !!*opt;}
static void find_opt(struct m_config_shadow *shadow, struct m_config_data *data, void *ptr, int *group_idx, int *opt_idx){ *group_idx = -1; *opt_idx = -1;
for (int n = data->group_index; n < data->group_index + data->num_gdata; n++) { struct m_group_data *gd = m_config_gdata(data, n); struct m_config_group *g = &shadow->groups[n]; const struct m_option *opts = g->group->opts;
for (int i = 0; opts && opts[i].name; i++) { const struct m_option *opt = &opts[i];
if (opt->offset >= 0 && opt->type->size && ptr == gd->udata + opt->offset) { *group_idx = n; *opt_idx = i; return; } } }}
bool m_config_cache_write_opt(struct m_config_cache *cache, void *ptr){ struct config_cache *in = cache->internal; struct m_config_shadow *shadow = in->shadow;
int group_idx = -1; int opt_idx = -1; find_opt(shadow, in->data, ptr, &group_idx, &opt_idx);
// ptr was not in cache->opts, or no option declaration matching it. assert(group_idx >= 0);
struct m_config_group *g = &shadow->groups[group_idx]; const struct m_option *opt = &g->group->opts[opt_idx];
mp_mutex_lock(&shadow->lock);
struct m_group_data *gdst = m_config_gdata(in->data, group_idx); struct m_group_data *gsrc = m_config_gdata(in->src, group_idx); assert(gdst && gsrc);
bool changed = !m_option_equal(opt, gsrc->udata + opt->offset, ptr) || opt->force_update; if (changed) { m_option_copy(opt, gsrc->udata + opt->offset, ptr);
gsrc->ts = atomic_fetch_add(&shadow->ts, 1) + 1;
for (int n = 0; n < shadow->num_listeners; n++) { struct config_cache *listener = shadow->listeners[n]; if (listener->wakeup_cb && m_config_gdata(listener->data, group_idx)) listener->wakeup_cb(listener->wakeup_cb_ctx); } }
if (opt->force_update) append_force_update(cache, gsrc, opt->name);
mp_mutex_unlock(&shadow->lock);
return changed;}
void m_config_cache_set_wakeup_cb(struct m_config_cache *cache, void (*cb)(void *ctx), void *cb_ctx){ struct config_cache *in = cache->internal; struct m_config_shadow *shadow = in->shadow;
mp_mutex_lock(&shadow->lock); if (in->in_list) { for (int n = 0; n < shadow->num_listeners; n++) { if (shadow->listeners[n] == in) { MP_TARRAY_REMOVE_AT(shadow->listeners, shadow->num_listeners, n); break; } } for (int n = 0; n < shadow->num_listeners; n++) assert(shadow->listeners[n] != in); // only 1 wakeup_cb per cache // (The deinitialization path relies on this to free all memory.) if (!shadow->num_listeners) { talloc_free(shadow->listeners); shadow->listeners = NULL; } } if (cb) { MP_TARRAY_APPEND(NULL, shadow->listeners, shadow->num_listeners, in); in->in_list = true; in->wakeup_cb = cb; in->wakeup_cb_ctx = cb_ctx; } mp_mutex_unlock(&shadow->lock);}
static void dispatch_notify(void *p){ struct config_cache *in = p;
assert(in->wakeup_dispatch_queue); mp_dispatch_enqueue_notify(in->wakeup_dispatch_queue, in->wakeup_dispatch_cb, in->wakeup_dispatch_cb_ctx);}
void m_config_cache_set_dispatch_change_cb(struct m_config_cache *cache, struct mp_dispatch_queue *dispatch, void (*cb)(void *ctx), void *cb_ctx){ struct config_cache *in = cache->internal;
// Removing the old one is tricky. First make sure no new notifications will // come. m_config_cache_set_wakeup_cb(cache, NULL, NULL); // Remove any pending notifications (assume we're on the same thread as // any potential mp_dispatch_queue_process() callers). if (in->wakeup_dispatch_queue) { mp_dispatch_cancel_fn(in->wakeup_dispatch_queue, in->wakeup_dispatch_cb, in->wakeup_dispatch_cb_ctx); }
in->wakeup_dispatch_queue = NULL; in->wakeup_dispatch_cb = NULL; in->wakeup_dispatch_cb_ctx = NULL;
if (cb) { in->wakeup_dispatch_queue = dispatch; in->wakeup_dispatch_cb = cb; in->wakeup_dispatch_cb_ctx = cb_ctx; m_config_cache_set_wakeup_cb(cache, dispatch_notify, in); }}
void *mp_get_config_group(void *ta_parent, struct mpv_global *global, const struct m_sub_options *group){ struct m_config_cache *cache = m_config_cache_alloc(NULL, global, group); // Make talloc_free(cache->opts) free the entire cache. ta_set_parent(cache->opts, ta_parent); ta_set_parent(cache, cache->opts); return cache->opts;}
static const struct m_config_group *find_group(struct mpv_global *global, const struct m_option *cfg){ struct m_config_shadow *shadow = global->config;
for (int n = 0; n < shadow->num_groups; n++) { if (shadow->groups[n].group->opts == cfg) return &shadow->groups[n]; }
return NULL;}
void *m_config_group_from_desc(void *ta_parent, struct mp_log *log, struct mpv_global *global, struct m_obj_desc *desc, const char *name){ const struct m_config_group *group = find_group(global, desc->options); if (group) { return mp_get_config_group(ta_parent, global, group->group); } else { void *d = talloc_zero_size(ta_parent, desc->priv_size); if (desc->priv_defaults) memcpy(d, desc->priv_defaults, desc->priv_size); return d; }}