Line data Source code
1 : /*
2 : * copyright (c) 2009 Michael Niedermayer
3 : *
4 : * This file is part of Libav.
5 : *
6 : * Libav 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 : * Libav 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 Libav; 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;
30 : AVDictionaryEntry *elems;
31 : };
32 :
33 0 : int av_dict_count(const AVDictionary *m)
34 : {
35 0 : return m ? m->count : 0;
36 : }
37 :
38 0 : AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key,
39 : const AVDictionaryEntry *prev, int flags)
40 : {
41 : unsigned int i, j;
42 :
43 0 : if (!m)
44 0 : return NULL;
45 :
46 0 : if (prev)
47 0 : i = prev - m->elems + 1;
48 : else
49 0 : i = 0;
50 :
51 0 : for (; i < m->count; i++) {
52 0 : const char *s = m->elems[i].key;
53 0 : if (flags & AV_DICT_MATCH_CASE)
54 0 : for (j = 0; s[j] == key[j] && key[j]; j++)
55 : ;
56 : else
57 0 : for (j = 0; av_toupper(s[j]) == av_toupper(key[j]) && key[j]; j++)
58 : ;
59 0 : if (key[j])
60 0 : continue;
61 0 : if (s[j] && !(flags & AV_DICT_IGNORE_SUFFIX))
62 0 : continue;
63 0 : return &m->elems[i];
64 : }
65 0 : return NULL;
66 : }
67 :
68 0 : int av_dict_set(AVDictionary **pm, const char *key, const char *value,
69 : int flags)
70 : {
71 0 : AVDictionary *m = *pm;
72 0 : AVDictionaryEntry *tag = av_dict_get(m, key, NULL, flags);
73 0 : char *oldval = NULL;
74 :
75 0 : if (!m)
76 0 : m = *pm = av_mallocz(sizeof(*m));
77 :
78 0 : if (tag) {
79 0 : if (flags & AV_DICT_DONT_OVERWRITE) {
80 0 : if (flags & AV_DICT_DONT_STRDUP_KEY) av_free(key);
81 0 : if (flags & AV_DICT_DONT_STRDUP_VAL) av_free(value);
82 0 : return 0;
83 : }
84 0 : if (flags & AV_DICT_APPEND)
85 0 : oldval = tag->value;
86 : else
87 0 : av_free(tag->value);
88 0 : av_free(tag->key);
89 0 : *tag = m->elems[--m->count];
90 : } else {
91 0 : AVDictionaryEntry *tmp = av_realloc(m->elems,
92 0 : (m->count + 1) * sizeof(*m->elems));
93 0 : if (tmp)
94 0 : m->elems = tmp;
95 : else
96 0 : return AVERROR(ENOMEM);
97 : }
98 0 : if (value) {
99 0 : if (flags & AV_DICT_DONT_STRDUP_KEY)
100 0 : m->elems[m->count].key = key;
101 : else
102 0 : m->elems[m->count].key = av_strdup(key);
103 0 : if (flags & AV_DICT_DONT_STRDUP_VAL) {
104 0 : m->elems[m->count].value = value;
105 0 : } else if (oldval && flags & AV_DICT_APPEND) {
106 0 : int len = strlen(oldval) + strlen(value) + 1;
107 0 : if (!(oldval = av_realloc(oldval, len)))
108 0 : return AVERROR(ENOMEM);
109 0 : av_strlcat(oldval, value, len);
110 0 : m->elems[m->count].value = oldval;
111 : } else
112 0 : m->elems[m->count].value = av_strdup(value);
113 0 : m->count++;
114 : }
115 0 : if (!m->count) {
116 0 : av_free(m->elems);
117 0 : av_freep(pm);
118 : }
119 :
120 0 : return 0;
121 : }
122 :
123 0 : static int parse_key_value_pair(AVDictionary **pm, const char **buf,
124 : const char *key_val_sep, const char *pairs_sep,
125 : int flags)
126 : {
127 0 : char *key = av_get_token(buf, key_val_sep);
128 0 : char *val = NULL;
129 : int ret;
130 :
131 0 : if (key && *key && strspn(*buf, key_val_sep)) {
132 0 : (*buf)++;
133 0 : val = av_get_token(buf, pairs_sep);
134 : }
135 :
136 0 : if (key && *key && val && *val)
137 0 : ret = av_dict_set(pm, key, val, flags);
138 : else
139 0 : ret = AVERROR(EINVAL);
140 :
141 0 : av_freep(&key);
142 0 : av_freep(&val);
143 :
144 0 : return ret;
145 : }
146 :
147 0 : int av_dict_parse_string(AVDictionary **pm, const char *str,
148 : const char *key_val_sep, const char *pairs_sep,
149 : int flags)
150 : {
151 : int ret;
152 :
153 0 : if (!str)
154 0 : return 0;
155 :
156 : /* ignore STRDUP flags */
157 0 : flags &= ~(AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
158 :
159 0 : while (*str) {
160 0 : if ((ret = parse_key_value_pair(pm, &str, key_val_sep, pairs_sep, flags)) < 0)
161 0 : return ret;
162 :
163 0 : if (*str)
164 0 : str++;
165 : }
166 :
167 0 : return 0;
168 : }
169 :
170 0 : void av_dict_free(AVDictionary **pm)
171 : {
172 0 : AVDictionary *m = *pm;
173 :
174 0 : if (m) {
175 0 : while (m->count--) {
176 0 : av_free(m->elems[m->count].key);
177 0 : av_free(m->elems[m->count].value);
178 : }
179 0 : av_free(m->elems);
180 : }
181 0 : av_freep(pm);
182 0 : }
183 :
184 0 : void av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
185 : {
186 0 : AVDictionaryEntry *t = NULL;
187 :
188 0 : while ((t = av_dict_get(src, "", t, AV_DICT_IGNORE_SUFFIX)))
189 0 : av_dict_set(dst, t->key, t->value, flags);
190 0 : }
|
