FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dict.c
Go to the documentation of this file.
1 /*
2  * copyright (c) 2009 Michael Niedermayer
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <string.h>
22 
23 #include "avstring.h"
24 #include "dict.h"
25 #include "internal.h"
26 #include "mem.h"
27 
28 struct AVDictionary {
29  int count;
31 };
32 
34 {
35  return m ? m->count : 0;
36 }
37 
39  const AVDictionaryEntry *prev, int flags)
40 {
41  unsigned int i, j;
42 
43  if (!m)
44  return NULL;
45 
46  if (prev)
47  i = prev - m->elems + 1;
48  else
49  i = 0;
50 
51  for (; i < m->count; i++) {
52  const char *s = m->elems[i].key;
53  if (flags & AV_DICT_MATCH_CASE)
54  for (j = 0; s[j] == key[j] && key[j]; j++)
55  ;
56  else
57  for (j = 0; av_toupper(s[j]) == av_toupper(key[j]) && key[j]; j++)
58  ;
59  if (key[j])
60  continue;
61  if (s[j] && !(flags & AV_DICT_IGNORE_SUFFIX))
62  continue;
63  return &m->elems[i];
64  }
65  return NULL;
66 }
67 
68 int av_dict_set(AVDictionary **pm, const char *key, const char *value,
69  int flags)
70 {
71  AVDictionary *m = *pm;
72  AVDictionaryEntry *tag = av_dict_get(m, key, NULL, flags);
73  char *oldval = NULL;
74 
75  if (!m)
76  m = *pm = av_mallocz(sizeof(*m));
77 
78  if (tag) {
79  if (flags & AV_DICT_DONT_OVERWRITE) {
80  if (flags & AV_DICT_DONT_STRDUP_KEY) av_free(key);
81  if (flags & AV_DICT_DONT_STRDUP_VAL) av_free(value);
82  return 0;
83  }
84  if (flags & AV_DICT_APPEND)
85  oldval = tag->value;
86  else
87  av_free(tag->value);
88  av_free(tag->key);
89  *tag = m->elems[--m->count];
90  } else {
92  (m->count + 1) * sizeof(*m->elems));
93  if (tmp)
94  m->elems = tmp;
95  else
96  return AVERROR(ENOMEM);
97  }
98  if (value) {
99  if (flags & AV_DICT_DONT_STRDUP_KEY)
100  m->elems[m->count].key = (char*)(intptr_t)key;
101  else
102  m->elems[m->count].key = av_strdup(key);
103  if (flags & AV_DICT_DONT_STRDUP_VAL) {
104  m->elems[m->count].value = (char*)(intptr_t)value;
105  } else if (oldval && flags & AV_DICT_APPEND) {
106  int len = strlen(oldval) + strlen(value) + 1;
107  char *newval = av_mallocz(len);
108  if (!newval)
109  return AVERROR(ENOMEM);
110  av_strlcat(newval, oldval, len);
111  av_freep(&oldval);
112  av_strlcat(newval, value, len);
113  m->elems[m->count].value = newval;
114  } else
115  m->elems[m->count].value = av_strdup(value);
116  m->count++;
117  }
118  if (!m->count) {
119  av_free(m->elems);
120  av_freep(pm);
121  }
122 
123  return 0;
124 }
125 
126 static int parse_key_value_pair(AVDictionary **pm, const char **buf,
127  const char *key_val_sep, const char *pairs_sep,
128  int flags)
129 {
130  char *key = av_get_token(buf, key_val_sep);
131  char *val = NULL;
132  int ret;
133 
134  if (key && *key && strspn(*buf, key_val_sep)) {
135  (*buf)++;
136  val = av_get_token(buf, pairs_sep);
137  }
138 
139  if (key && *key && val && *val)
140  ret = av_dict_set(pm, key, val, flags);
141  else
142  ret = AVERROR(EINVAL);
143 
144  av_freep(&key);
145  av_freep(&val);
146 
147  return ret;
148 }
149 
150 int av_dict_parse_string(AVDictionary **pm, const char *str,
151  const char *key_val_sep, const char *pairs_sep,
152  int flags)
153 {
154  int ret;
155 
156  if (!str)
157  return 0;
158 
159  /* ignore STRDUP flags */
161 
162  while (*str) {
163  if ((ret = parse_key_value_pair(pm, &str, key_val_sep, pairs_sep, flags)) < 0)
164  return ret;
165 
166  if (*str)
167  str++;
168  }
169 
170  return 0;
171 }
172 
174 {
175  AVDictionary *m = *pm;
176 
177  if (m) {
178  while (m->count--) {
179  av_free(m->elems[m->count].key);
180  av_free(m->elems[m->count].value);
181  }
182  av_free(m->elems);
183  }
184  av_freep(pm);
185 }
186 
188 {
189  AVDictionaryEntry *t = NULL;
190 
191  while ((t = av_dict_get(src, "", t, AV_DICT_IGNORE_SUFFIX)))
192  av_dict_set(dst, t->key, t->value, flags);
193 }