FFmpeg
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 "avassert.h"
24 #include "avstring.h"
25 #include "dict.h"
26 #include "dict_internal.h"
27 #include "internal.h"
28 #include "mem.h"
29 #include "time_internal.h"
30 #include "bprint.h"
31 
32 struct AVDictionary {
33  int count;
35 };
36 
38 {
39  return m ? m->count : 0;
40 }
41 
43  const AVDictionaryEntry *prev)
44 {
45  int i = 0;
46 
47  if (!m)
48  return NULL;
49 
50  if (prev)
51  i = prev - m->elems + 1;
52 
53  av_assert2(i >= 0);
54  if (i >= m->count)
55  return NULL;
56 
57  return &m->elems[i];
58 }
59 
61  const AVDictionaryEntry *prev, int flags)
62 {
63  const AVDictionaryEntry *entry = prev;
64  unsigned int j;
65 
66  if (!key)
67  return NULL;
68 
69  while ((entry = av_dict_iterate(m, entry))) {
70  const char *s = entry->key;
72  for (j = 0; s[j] == key[j] && key[j]; j++)
73  ;
74  else
75  for (j = 0; av_toupper(s[j]) == av_toupper(key[j]) && key[j]; j++)
76  ;
77  if (key[j])
78  continue;
79  if (s[j] && !(flags & AV_DICT_IGNORE_SUFFIX))
80  continue;
81  return (AVDictionaryEntry *)entry;
82  }
83  return NULL;
84 }
85 
86 int av_dict_set(AVDictionary **pm, const char *key, const char *value,
87  int flags)
88 {
89  AVDictionary *m = *pm;
91  char *copy_key = NULL, *copy_value = NULL;
92  int err;
93 
95  copy_value = (void *)value;
96  else if (value)
97  copy_value = av_strdup(value);
98  if (!key) {
99  err = AVERROR(EINVAL);
100  goto err_out;
101  }
102  if (!(flags & AV_DICT_MULTIKEY)) {
103  tag = av_dict_get(m, key, NULL, flags);
104  }
106  copy_key = (void *)key;
107  else
108  copy_key = av_strdup(key);
109  if (!m)
110  m = *pm = av_mallocz(sizeof(*m));
111  if (!m || !copy_key || (value && !copy_value))
112  goto enomem;
113 
114  if (tag) {
116  av_free(copy_key);
117  av_free(copy_value);
118  return 0;
119  }
120  if (copy_value && flags & AV_DICT_APPEND) {
121  size_t oldlen = strlen(tag->value);
122  size_t new_part_len = strlen(copy_value);
123  size_t len = oldlen + new_part_len + 1;
124  char *newval = av_realloc(tag->value, len);
125  if (!newval)
126  goto enomem;
127  memcpy(newval + oldlen, copy_value, new_part_len + 1);
128  av_freep(&copy_value);
129  copy_value = newval;
130  } else
131  av_free(tag->value);
132  av_free(tag->key);
133  *tag = m->elems[--m->count];
134  } else if (copy_value) {
136  m->count + 1, sizeof(*m->elems));
137  if (!tmp)
138  goto enomem;
139  m->elems = tmp;
140  }
141  if (copy_value) {
142  m->elems[m->count].key = copy_key;
143  m->elems[m->count].value = copy_value;
144  m->count++;
145  } else {
146  if (!m->count) {
147  av_freep(&m->elems);
148  av_freep(pm);
149  }
150  av_freep(&copy_key);
151  }
152 
153  return 0;
154 
155 enomem:
156  err = AVERROR(ENOMEM);
157 err_out:
158  if (m && !m->count) {
159  av_freep(&m->elems);
160  av_freep(pm);
161  }
162  av_free(copy_key);
163  av_free(copy_value);
164  return err;
165 }
166 
167 int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value,
168  int flags)
169 {
170  char valuestr[22];
171  snprintf(valuestr, sizeof(valuestr), "%"PRId64, value);
173  return av_dict_set(pm, key, valuestr, flags);
174 }
175 
176 static int parse_key_value_pair(AVDictionary **pm, const char **buf,
177  const char *key_val_sep, const char *pairs_sep,
178  int flags)
179 {
180  char *key = av_get_token(buf, key_val_sep);
181  char *val = NULL;
182  int ret;
183 
184  if (key && *key && strspn(*buf, key_val_sep)) {
185  (*buf)++;
186  val = av_get_token(buf, pairs_sep);
187  }
188 
189  if (key && *key && val && *val)
190  ret = av_dict_set(pm, key, val, flags);
191  else
192  ret = AVERROR(EINVAL);
193 
194  av_freep(&key);
195  av_freep(&val);
196 
197  return ret;
198 }
199 
200 int av_dict_parse_string(AVDictionary **pm, const char *str,
201  const char *key_val_sep, const char *pairs_sep,
202  int flags)
203 {
204  int ret;
205 
206  if (!str)
207  return 0;
208 
209  /* ignore STRDUP flags */
211 
212  while (*str) {
213  if ((ret = parse_key_value_pair(pm, &str, key_val_sep, pairs_sep, flags)) < 0)
214  return ret;
215 
216  if (*str)
217  str++;
218  }
219 
220  return 0;
221 }
222 
224 {
225  AVDictionary *m = *pm;
226 
227  if (m) {
228  while (m->count--) {
229  av_freep(&m->elems[m->count].key);
230  av_freep(&m->elems[m->count].value);
231  }
232  av_freep(&m->elems);
233  }
234  av_freep(pm);
235 }
236 
238 {
239  const AVDictionaryEntry *t = NULL;
240 
241  while ((t = av_dict_iterate(src, t))) {
242  int ret = av_dict_set(dst, t->key, t->value, flags);
243  if (ret < 0)
244  return ret;
245  }
246 
247  return 0;
248 }
249 
251  const char key_val_sep, const char pairs_sep)
252 {
253  const AVDictionaryEntry *t = NULL;
254  AVBPrint bprint;
255  int cnt = 0;
256  char special_chars[] = {pairs_sep, key_val_sep, '\0'};
257 
258  if (!buffer || pairs_sep == '\0' || key_val_sep == '\0' || pairs_sep == key_val_sep ||
259  pairs_sep == '\\' || key_val_sep == '\\')
260  return AVERROR(EINVAL);
261 
262  if (!av_dict_count(m)) {
263  *buffer = av_strdup("");
264  return *buffer ? 0 : AVERROR(ENOMEM);
265  }
266 
268  while ((t = av_dict_iterate(m, t))) {
269  if (cnt++)
270  av_bprint_append_data(&bprint, &pairs_sep, 1);
271  av_bprint_escape(&bprint, t->key, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
272  av_bprint_append_data(&bprint, &key_val_sep, 1);
273  av_bprint_escape(&bprint, t->value, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
274  }
275  return av_bprint_finalize(&bprint, buffer);
276 }
277 
278 int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
279 {
280  time_t seconds = timestamp / 1000000;
281  struct tm *ptm, tmbuf;
282  ptm = gmtime_r(&seconds, &tmbuf);
283  if (ptm) {
284  char buf[32];
285  if (!strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", ptm))
286  return AVERROR_EXTERNAL;
287  av_strlcatf(buf, sizeof(buf), ".%06dZ", (int)(timestamp % 1000000));
288  return av_dict_set(dict, key, buf, 0);
289  } else {
290  return AVERROR_EXTERNAL;
291  }
292 }
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
av_get_token
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:154
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:37
AVDictionary::elems
AVDictionaryEntry * elems
Definition: dict.c:34
dict_internal.h
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AV_DICT_APPEND
#define AV_DICT_APPEND
If the entry already exists, append to it.
Definition: dict.h:82
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
AVDictionary
Definition: dict.c:32
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:104
gmtime_r
#define gmtime_r
Definition: time_internal.h:34
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:79
avassert.h
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:60
s
#define s(width, name)
Definition: cbs_vp9.c:256
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:225
AVDictionaryEntry::key
char * key
Definition: dict.h:90
key
const char * key
Definition: hwcontext_opencl.c:174
time_internal.h
AVDictionary::count
int count
Definition: dict.c:33
NULL
#define NULL
Definition: coverity.c:32
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
AV_DICT_MULTIKEY
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
Definition: dict.h:84
av_bprint_escape
void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars, enum AVEscapeMode mode, int flags)
Escape the content in src and append it to dstbuf.
Definition: bprint.c:263
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
bprint.h
parse_key_value_pair
static int parse_key_value_pair(AVDictionary **pm, const char **buf, const char *key_val_sep, const char *pairs_sep, int flags)
Definition: dict.c:176
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
internal.h
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:237
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
len
int len
Definition: vorbis_enc_data.h:426
tag
uint32_t tag
Definition: movenc.c:1647
ret
ret
Definition: filter_design.txt:187
dict.h
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:74
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
av_dict_parse_string
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:200
av_dict_set_int
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set() that converts the value to a string and stores it.
Definition: dict.c:167
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
av_dict_get_string
int av_dict_get_string(const AVDictionary *m, char **buffer, const char key_val_sep, const char pairs_sep)
Get dictionary entries as a string.
Definition: dict.c:250
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
AV_ESCAPE_MODE_BACKSLASH
@ AV_ESCAPE_MODE_BACKSLASH
Use backslash escaping.
Definition: avstring.h:326
convert_header.str
string str
Definition: convert_header.py:20
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
av_bprint_append_data
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:158
snprintf
#define snprintf
Definition: snprintf.h:34
avpriv_dict_set_timestamp
int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
Definition: dict.c:278
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
AV_DICT_DONT_STRDUP_KEY
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
Definition: dict.h:77