diff --git a/m_config.c b/m_config.c
index e8996670f4..7545cdb4eb 100644
--- a/m_config.c
+++ b/m_config.c
@@ -67,7 +67,8 @@ static int parse_profile(struct m_config *config, const struct m_option *opt,
     }
 
     char **list = NULL;
-    int r = m_option_type_string_list.parse(opt, name, param, false, &list);
+    int r = m_option_type_string_list.parse(opt, name, param, false, &list,
+                                            NULL);
     if (r < 0)
         return r;
     if (!list || !list[0])
@@ -144,7 +145,7 @@ static void m_option_save(const struct m_config *config,
 {
     if (opt->type->copy) {
         const void *src = m_option_get_ptr(opt, config->optstruct);
-        opt->type->copy(opt, dst, src);
+        opt->type->copy(opt, dst, src, NULL);
     }
 }
 
@@ -153,7 +154,7 @@ static void m_option_set(void *optstruct,
 {
     if (opt->type->copy) {
         void *dst = m_option_get_ptr(opt, optstruct);
-        opt->type->copy(opt, dst, src);
+        opt->type->copy(opt, dst, src, optstruct);
     }
 }
 
@@ -483,7 +484,8 @@ static int m_config_parse_option(struct m_config *config, void *optstruct,
     }
 
     void *dst = set ? m_option_get_ptr(co->opt, optstruct) : NULL;
-    int r = m_option_parse(co->opt, name, param, ambiguous_param, dst);
+    int r = co->opt->type->parse(co->opt, name, param, ambiguous_param, dst,
+                                 optstruct);
     // Parsing failed ?
     if (r < 0)
         return r;
@@ -498,7 +500,8 @@ static int parse_subopts(struct m_config *config, void *optstruct, char *name,
 {
     char **lst = NULL;
     // Split the argument into child options
-    int r = m_option_type_subconfig.parse(NULL, bstr(""), param, false, &lst);
+    int r = m_option_type_subconfig.parse(NULL, bstr(""), param, false, &lst,
+                                          optstruct);
     if (r < 0)
         return r;
     // Parse the child options
diff --git a/m_option.c b/m_option.c
index 7e701765b7..23343c73a6 100644
--- a/m_option.c
+++ b/m_option.c
@@ -77,7 +77,8 @@ const m_option_t *m_option_list_find(const m_option_t *list, const char *name)
 
 // Default function that just does a memcpy
 
-static void copy_opt(const m_option_t *opt, void *dst, const void *src)
+static void copy_opt(const m_option_t *opt, void *dst, const void *src,
+                     void *talloc_ctx)
 {
     if (dst && src)
         memcpy(dst, src, opt->type->size);
@@ -88,7 +89,8 @@ static void copy_opt(const m_option_t *opt, void *dst, const void *src)
 #define VAL(x) (*(int *)(x))
 
 static int parse_flag(const m_option_t *opt, struct bstr name,
-                      struct bstr param, bool ambiguous_param, void *dst)
+                      struct bstr param, bool ambiguous_param, void *dst,
+                      void *talloc_ctx)
 {
     if (param.len && !ambiguous_param) {
         char * const enable[] = { "yes", "on", "ja", "si", "igen", "y", "j",
@@ -177,7 +179,8 @@ static int parse_longlong(const m_option_t *opt, struct bstr name,
 }
 
 static int parse_int(const m_option_t *opt, struct bstr name,
-                     struct bstr param, bool ambiguous_param, void *dst)
+                     struct bstr param, bool ambiguous_param, void *dst,
+                     void *talloc_ctx)
 {
     long long tmp;
     int r = parse_longlong(opt, name, param, false, &tmp);
@@ -187,7 +190,8 @@ static int parse_int(const m_option_t *opt, struct bstr name,
 }
 
 static int parse_int64(const m_option_t *opt, struct bstr name,
-                       struct bstr param, bool ambiguous_param, void *dst)
+                       struct bstr param, bool ambiguous_param, void *dst,
+                       void *talloc_ctx)
 {
     long long tmp;
     int r = parse_longlong(opt, name, param, false, &tmp);
@@ -221,7 +225,8 @@ const m_option_type_t m_option_type_int64 = {
 };
 
 static int parse_intpair(const struct m_option *opt, struct bstr name,
-                         struct bstr param, bool ambiguous_param, void *dst)
+                         struct bstr param, bool ambiguous_param, void *dst,
+                         void *talloc_ctx)
 {
     if (param.len == 0)
         return M_OPT_MISSING_PARAM;
@@ -264,7 +269,8 @@ const struct m_option_type m_option_type_intpair = {
 };
 
 static int parse_choice(const struct m_option *opt, struct bstr name,
-                        struct bstr param, bool ambiguous_param, void *dst)
+                        struct bstr param, bool ambiguous_param, void *dst,
+                        void *talloc_ctx)
 {
     if (param.len == 0)
         return M_OPT_MISSING_PARAM;
@@ -313,7 +319,8 @@ const struct m_option_type m_option_type_choice = {
 #define VAL(x) (*(double *)(x))
 
 static int parse_double(const m_option_t *opt, struct bstr name,
-                        struct bstr param, bool ambiguous_param, void *dst)
+                        struct bstr param, bool ambiguous_param, void *dst,
+                        void *talloc_ctx)
 {
     if (param.len == 0)
         return M_OPT_MISSING_PARAM;
@@ -387,10 +394,11 @@ const m_option_type_t m_option_type_double = {
 #define VAL(x) (*(float *)(x))
 
 static int parse_float(const m_option_t *opt, struct bstr name,
-                       struct bstr param, bool ambiguous_param, void *dst)
+                       struct bstr param, bool ambiguous_param, void *dst,
+                       void *talloc_ctx)
 {
     double tmp;
-    int r = parse_double(opt, name, param, false, &tmp);
+    int r = parse_double(opt, name, param, false, &tmp, NULL);
     if (r == 1 && dst)
         VAL(dst) = tmp;
     return r;
@@ -416,7 +424,8 @@ const m_option_type_t m_option_type_float = {
 #define VAL(x) (*(off_t *)(x))
 
 static int parse_position(const m_option_t *opt, struct bstr name,
-                          struct bstr param, bool ambiguous_param, void *dst)
+                          struct bstr param, bool ambiguous_param, void *dst,
+                          void *talloc_ctx)
 {
     long long tmp;
     int r = parse_longlong(opt, name, param, false, &tmp);
@@ -446,7 +455,8 @@ const m_option_type_t m_option_type_position = {
 #define VAL(x) (*(char **)(x))
 
 static int parse_str(const m_option_t *opt, struct bstr name,
-                     struct bstr param, bool ambiguous_param, void *dst)
+                     struct bstr param, bool ambiguous_param, void *dst,
+                     void *talloc_ctx)
 {
     if ((opt->flags & M_OPT_MIN) && (param.len < opt->min)) {
         mp_msg(MSGT_CFGPARSER, MSGL_ERR,
@@ -464,7 +474,7 @@ static int parse_str(const m_option_t *opt, struct bstr name,
 
     if (dst) {
         talloc_free(VAL(dst));
-        VAL(dst) = bstrdup0(NULL, param);
+        VAL(dst) = bstrdup0(talloc_ctx, param);
     }
 
     return 1;
@@ -476,11 +486,12 @@ static char *print_str(const m_option_t *opt, const void *val)
     return (val && VAL(val)) ? talloc_strdup(NULL, VAL(val)) : NULL;
 }
 
-static void copy_str(const m_option_t *opt, void *dst, const void *src)
+static void copy_str(const m_option_t *opt, void *dst, const void *src,
+                     void *talloc_ctx)
 {
     if (dst && src) {
         talloc_free(VAL(dst));
-        VAL(dst) = talloc_strdup(NULL, VAL(src));
+        VAL(dst) = talloc_strdup(talloc_ctx, VAL(src));
     }
 }
 
@@ -528,7 +539,7 @@ static void free_str_list(void *dst)
     VAL(dst) = NULL;
 }
 
-static int str_list_add(char **add, int n, void *dst, int pre)
+static int str_list_add(char **add, int n, void *dst, int pre, void *talloc_ctx)
 {
     char **lst = VAL(dst);
     int ln;
@@ -632,7 +643,8 @@ static struct bstr get_nextsep(struct bstr *ptr, char sep, bool modify)
 }
 
 static int parse_str_list(const m_option_t *opt, struct bstr name,
-                          struct bstr param, bool ambiguous_param, void *dst)
+                          struct bstr param, bool ambiguous_param, void *dst,
+                          void *talloc_ctx)
 {
     char **res;
     int op = OP_NONE;
@@ -681,14 +693,14 @@ static int parse_str_list(const m_option_t *opt, struct bstr name,
     if (!dst)
         return 1;
 
-    res = talloc_array(NULL, char *, n + 2);
+    res = talloc_array(talloc_ctx, char *, n + 2);
     str = bstrdup(NULL, param);
     char *ptr = str.start;
     n = 0;
 
     while (1) {
         struct bstr el = get_nextsep(&str, separator, 1);
-        res[n] = bstrdup0(NULL, el);
+        res[n] = bstrdup0(talloc_ctx, el);
         n++;
         if (!str.len)
             break;
@@ -699,9 +711,9 @@ static int parse_str_list(const m_option_t *opt, struct bstr name,
 
     switch (op) {
     case OP_ADD:
-        return str_list_add(res, n, dst, 0);
+        return str_list_add(res, n, dst, 0, talloc_ctx);
     case OP_PRE:
-        return str_list_add(res, n, dst, 1);
+        return str_list_add(res, n, dst, 1, talloc_ctx);
     case OP_DEL:
         return str_list_del(res, n, dst);
     }
@@ -713,7 +725,8 @@ static int parse_str_list(const m_option_t *opt, struct bstr name,
     return 1;
 }
 
-static void copy_str_list(const m_option_t *opt, void *dst, const void *src)
+static void copy_str_list(const m_option_t *opt, void *dst, const void *src,
+                          void *talloc_ctx)
 {
     int n;
     char **d, **s;
@@ -732,9 +745,9 @@ static void copy_str_list(const m_option_t *opt, void *dst, const void *src)
 
     for (n = 0; s[n] != NULL; n++)
         /* NOTHING */;
-    d = talloc_array(NULL, char *, n + 1);
+    d = talloc_array(talloc_ctx, char *, n + 1);
     for (; n >= 0; n--)
-        d[n] = talloc_strdup(NULL, s[n]);
+        d[n] = talloc_strdup(talloc_ctx, s[n]);
 
     VAL(dst) = d;
 }
@@ -778,7 +791,8 @@ const m_option_type_t m_option_type_string_list = {
 /////////////////// Print
 
 static int parse_print(const m_option_t *opt, struct bstr name,
-                       struct bstr param, bool ambiguous_param, void *dst)
+                       struct bstr param, bool ambiguous_param, void *dst,
+                       void *talloc_ctx)
 {
     if (opt->type == CONF_TYPE_PRINT_INDIRECT)
         mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", *(char **) opt->p);
@@ -819,7 +833,8 @@ const m_option_type_t m_option_type_print_func = {
 #define VAL(x) (*(char ***)(x))
 
 static int parse_subconf(const m_option_t *opt, struct bstr name,
-                         struct bstr param, bool ambiguous_param, void *dst)
+                         struct bstr param, bool ambiguous_param, void *dst,
+                         void *talloc_ctx)
 {
     int nr = 0;
     char **lst = NULL;
@@ -977,7 +992,8 @@ static struct {
 };
 
 static int parse_imgfmt(const m_option_t *opt, struct bstr name,
-                        struct bstr param, bool ambiguous_param, void *dst)
+                        struct bstr param, bool ambiguous_param, void *dst,
+                        void *talloc_ctx)
 {
     uint32_t fmt = 0;
     int i;
@@ -1067,7 +1083,8 @@ static struct {
 };
 
 static int parse_afmt(const m_option_t *opt, struct bstr name,
-                      struct bstr param, bool ambiguous_param, void *dst)
+                      struct bstr param, bool ambiguous_param, void *dst,
+                      void *talloc_ctx)
 {
     uint32_t fmt = 0;
     int i;
@@ -1135,7 +1152,8 @@ static int parse_timestring(struct bstr str, double *time, char endchar)
 
 
 static int parse_time(const m_option_t *opt, struct bstr name,
-                      struct bstr param, bool ambiguous_param, void *dst)
+                      struct bstr param, bool ambiguous_param, void *dst,
+                      void *talloc_ctx)
 {
     double time;
 
@@ -1165,7 +1183,8 @@ const m_option_type_t m_option_type_time = {
 // Time or size (-endpos)
 
 static int parse_time_size(const m_option_t *opt, struct bstr name,
-                           struct bstr param, bool ambiguous_param, void *dst)
+                           struct bstr param, bool ambiguous_param, void *dst,
+                           void *talloc_ctx)
 {
     m_time_size_t ts;
     char unit[4];
@@ -1397,7 +1416,8 @@ static int get_obj_params(struct bstr opt_name, struct bstr name,
 }
 
 static int parse_obj_params(const m_option_t *opt, struct bstr name,
-                            struct bstr param, bool ambiguous_param, void *dst)
+                            struct bstr param, bool ambiguous_param, void *dst,
+                            void *talloc_ctx)
 {
     char **opts;
     int r;
@@ -1595,7 +1615,7 @@ static void free_obj_settings_list(void *dst)
 
 static int parse_obj_settings_list(const m_option_t *opt, struct bstr name,
                                    struct bstr param, bool ambiguous_param,
-                                   void *dst)
+                                   void *dst, void *talloc_ctx)
 {
     int len = strlen(opt->name);
     m_obj_settings_t *res = NULL, *queue = NULL, *head = NULL;
@@ -1726,7 +1746,7 @@ static int parse_obj_settings_list(const m_option_t *opt, struct bstr name,
 }
 
 static void copy_obj_settings_list(const m_option_t *opt, void *dst,
-                                   const void *src)
+                                   const void *src, void *talloc_ctx)
 {
     m_obj_settings_t *d, *s;
     int n;
@@ -1749,7 +1769,7 @@ static void copy_obj_settings_list(const m_option_t *opt, void *dst,
     for (n = 0; s[n].name; n++) {
         d[n].name = talloc_strdup(NULL, s[n].name);
         d[n].attribs = NULL;
-        copy_str_list(NULL, &(d[n].attribs), &(s[n].attribs));
+        copy_str_list(NULL, &(d[n].attribs), &(s[n].attribs), NULL);
     }
     d[n].name = NULL;
     d[n].attribs = NULL;
@@ -1769,7 +1789,7 @@ const m_option_type_t m_option_type_obj_settings_list = {
 
 static int parse_obj_presets(const m_option_t *opt, struct bstr name,
                              struct bstr param, bool ambiguous_param,
-                             void *dst)
+                             void *dst, void *talloc_ctx)
 {
     m_obj_presets_t *obj_p = (m_obj_presets_t *)opt->priv;
     const m_struct_t *in_desc;
@@ -1844,7 +1864,8 @@ const m_option_type_t m_option_type_obj_presets = {
 };
 
 static int parse_custom_url(const m_option_t *opt, struct bstr name,
-                            struct bstr url, bool ambiguous_param, void *dst)
+                            struct bstr url, bool ambiguous_param, void *dst,
+                            void *talloc_ctx)
 {
     int r;
     m_struct_t *desc = opt->priv;
diff --git a/m_option.h b/m_option.h
index 9b355ff3e0..648c560305 100644
--- a/m_option.h
+++ b/m_option.h
@@ -192,11 +192,12 @@ struct m_option_type {
      *         may not be an argument meant for this option
      *  \param dst Pointer to the memory where the data should be written.
      *             If NULL the parameter validity should still be checked.
+     *         talloc_ctx: talloc context if value type requires allocations
      *  \return On error a negative value is returned, on success the number
      *          of arguments consumed. For details see \ref OptionParserReturn.
      */
     int (*parse)(const m_option_t *opt, struct bstr name, struct bstr param,
-                 bool ambiguous_param, void *dst);
+                 bool ambiguous_param, void *dst, void *talloc_ctx);
 
     // Print back a value in string form.
     /** \param opt The option to print.
@@ -210,8 +211,10 @@ struct m_option_type {
     /** \param opt The option to copy.
      *  \param dst Pointer to the destination memory.
      *  \param src Pointer to the source memory.
+     *         talloc_ctx: talloc context to use in deep copy
      */
-    void (*copy)(const m_option_t *opt, void *dst, const void *src);
+    void (*copy)(const m_option_t *opt, void *dst, const void *src,
+                 void *talloc_ctx);
 
     // Free the data allocated for a save slot.
     /** This is only needed for dynamic types like strings.
@@ -385,7 +388,7 @@ static inline int m_option_parse(const m_option_t *opt, struct bstr name,
                                  struct bstr param, bool ambiguous_param,
                                  void *dst)
 {
-    return opt->type->parse(opt, name, param, ambiguous_param, dst);
+    return opt->type->parse(opt, name, param, ambiguous_param, dst, NULL);
 }
 
 // Helper to print options, see \ref m_option_type::print.
@@ -402,7 +405,7 @@ static inline void m_option_copy(const m_option_t *opt, void *dst,
                                  const void *src)
 {
     if (opt->type->copy)
-        opt->type->copy(opt, dst, src);
+        opt->type->copy(opt, dst, src, NULL);
 }
 
 // Helper around \ref m_option_type::free.
diff --git a/m_struct.c b/m_struct.c
index 8b34cea359..6e32bf32c8 100644
--- a/m_struct.c
+++ b/m_struct.c
@@ -71,7 +71,7 @@ int m_struct_set(const m_struct_t *st, void *obj, const char *field,
     return 0;
   }
 
-  if(f->type->parse(f, bstr(field), param, false, M_ST_MB_P(obj,f->p)) < 0) {
+  if(f->type->parse(f, bstr(field), param, false, M_ST_MB_P(obj,f->p), NULL) < 0) {
     mp_msg(MSGT_CFGPARSER, MSGL_ERR,"Struct %s, field %s parsing error: %.*s\n",
 	   st->name, field, BSTR_P(param));
     return 0;