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  goto err_out;
95  m->elems = tmp;
96  }
97  if (value) {
98  if (flags & AV_DICT_DONT_STRDUP_KEY)
99  m->elems[m->count].key = (char*)(intptr_t)key;
100  else
101  m->elems[m->count].key = av_strdup(key);
102  if (flags & AV_DICT_DONT_STRDUP_VAL) {
103  m->elems[m->count].value = (char*)(intptr_t)value;
104  } else if (oldval && flags & AV_DICT_APPEND) {
105  int len = strlen(oldval) + strlen(value) + 1;
106  char *newval = av_mallocz(len);
107  if (!newval)
108  goto err_out;
109  av_strlcat(newval, oldval, len);
110  av_freep(&oldval);
111  av_strlcat(newval, value, len);
112  m->elems[m->count].value = newval;
113  } else
114  m->elems[m->count].value = av_strdup(value);
115  m->count++;
116  }
117  if (!m->count) {
118  av_free(m->elems);
119  av_freep(pm);
120  }
121 
122  return 0;
123 
124 err_out:
125  if (!m->count) {
126  av_free(m->elems);
127  av_freep(pm);
128  }
129  if (flags & AV_DICT_DONT_STRDUP_KEY) av_free(key);
130  if (flags & AV_DICT_DONT_STRDUP_VAL) av_free(value);
131  return AVERROR(ENOMEM);
132 }
133 
134 int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value,
135  int flags)
136 {
137  char valuestr[22];
138  snprintf(valuestr, sizeof(valuestr), "%"PRId64, value);
139  return av_dict_set(pm, key, valuestr, flags);
140 }
141 
142 static int parse_key_value_pair(AVDictionary **pm, const char **buf,
143  const char *key_val_sep, const char *pairs_sep,
144  int flags)
145 {
146  char *key = av_get_token(buf, key_val_sep);
147  char *val = NULL;
148  int ret;
149 
150  if (key && *key && strspn(*buf, key_val_sep)) {
151  (*buf)++;
152  val = av_get_token(buf, pairs_sep);
153  }
154 
155  if (key && *key && val && *val)
156  ret = av_dict_set(pm, key, val, flags);
157  else
158  ret = AVERROR(EINVAL);
159 
160  av_freep(&key);
161  av_freep(&val);
162 
163  return ret;
164 }
165 
166 int av_dict_parse_string(AVDictionary **pm, const char *str,
167  const char *key_val_sep, const char *pairs_sep,
168  int flags)
169 {
170  int ret;
171 
172  if (!str)
173  return 0;
174 
175  /* ignore STRDUP flags */
177 
178  while (*str) {
179  if ((ret = parse_key_value_pair(pm, &str, key_val_sep, pairs_sep, flags)) < 0)
180  return ret;
181 
182  if (*str)
183  str++;
184  }
185 
186  return 0;
187 }
188 
190 {
191  AVDictionary *m = *pm;
192 
193  if (m) {
194  while (m->count--) {
195  av_free(m->elems[m->count].key);
196  av_free(m->elems[m->count].value);
197  }
198  av_free(m->elems);
199  }
200  av_freep(pm);
201 }
202 
204 {
205  AVDictionaryEntry *t = NULL;
206 
207  while ((t = av_dict_get(src, "", t, AV_DICT_IGNORE_SUFFIX)))
208  av_dict_set(dst, t->key, t->value, flags);
209 }