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 "avstring.h"
24 #include "dict.h"
25 #include "dict_internal.h"
26 #include "internal.h"
27 #include "mem.h"
28 #include "time_internal.h"
29 #include "bprint.h"
30 
31 struct AVDictionary {
32  int count;
34 };
35 
37 {
38  return m ? m->count : 0;
39 }
40 
42  const AVDictionaryEntry *prev, int flags)
43 {
44  unsigned int i, j;
45 
46  if (!m || !key)
47  return NULL;
48 
49  if (prev)
50  i = prev - m->elems + 1;
51  else
52  i = 0;
53 
54  for (; i < m->count; i++) {
55  const char *s = m->elems[i].key;
57  for (j = 0; s[j] == key[j] && key[j]; j++)
58  ;
59  else
60  for (j = 0; av_toupper(s[j]) == av_toupper(key[j]) && key[j]; j++)
61  ;
62  if (key[j])
63  continue;
64  if (s[j] && !(flags & AV_DICT_IGNORE_SUFFIX))
65  continue;
66  return &m->elems[i];
67  }
68  return NULL;
69 }
70 
71 int av_dict_set(AVDictionary **pm, const char *key, const char *value,
72  int flags)
73 {
74  AVDictionary *m = *pm;
76  char *copy_key = NULL, *copy_value = NULL;
77  int err;
78 
80  copy_value = (void *)value;
81  else if (value)
82  copy_value = av_strdup(value);
83  if (!key) {
84  err = AVERROR(EINVAL);
85  goto err_out;
86  }
87  if (!(flags & AV_DICT_MULTIKEY)) {
88  tag = av_dict_get(m, key, NULL, flags);
89  }
91  copy_key = (void *)key;
92  else
93  copy_key = av_strdup(key);
94  if (!m)
95  m = *pm = av_mallocz(sizeof(*m));
96  if (!m || !copy_key || (value && !copy_value))
97  goto enomem;
98 
99  if (tag) {
101  av_free(copy_key);
102  av_free(copy_value);
103  return 0;
104  }
105  if (copy_value && flags & AV_DICT_APPEND) {
106  size_t oldlen = strlen(tag->value);
107  size_t new_part_len = strlen(copy_value);
108  size_t len = oldlen + new_part_len + 1;
109  char *newval = av_realloc(tag->value, len);
110  if (!newval)
111  goto enomem;
112  memcpy(newval + oldlen, copy_value, new_part_len + 1);
113  av_freep(&copy_value);
114  copy_value = newval;
115  } else
116  av_free(tag->value);
117  av_free(tag->key);
118  *tag = m->elems[--m->count];
119  } else if (copy_value) {
121  m->count + 1, sizeof(*m->elems));
122  if (!tmp)
123  goto enomem;
124  m->elems = tmp;
125  }
126  if (copy_value) {
127  m->elems[m->count].key = copy_key;
128  m->elems[m->count].value = copy_value;
129  m->count++;
130  } else {
131  if (!m->count) {
132  av_freep(&m->elems);
133  av_freep(pm);
134  }
135  av_freep(&copy_key);
136  }
137 
138  return 0;
139 
140 enomem:
141  err = AVERROR(ENOMEM);
142 err_out:
143  if (m && !m->count) {
144  av_freep(&m->elems);
145  av_freep(pm);
146  }
147  av_free(copy_key);
148  av_free(copy_value);
149  return err;
150 }
151 
152 int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value,
153  int flags)
154 {
155  char valuestr[22];
156  snprintf(valuestr, sizeof(valuestr), "%"PRId64, value);
158  return av_dict_set(pm, key, valuestr, flags);
159 }
160 
161 static int parse_key_value_pair(AVDictionary **pm, const char **buf,
162  const char *key_val_sep, const char *pairs_sep,
163  int flags)
164 {
165  char *key = av_get_token(buf, key_val_sep);
166  char *val = NULL;
167  int ret;
168 
169  if (key && *key && strspn(*buf, key_val_sep)) {
170  (*buf)++;
171  val = av_get_token(buf, pairs_sep);
172  }
173 
174  if (key && *key && val && *val)
175  ret = av_dict_set(pm, key, val, flags);
176  else
177  ret = AVERROR(EINVAL);
178 
179  av_freep(&key);
180  av_freep(&val);
181 
182  return ret;
183 }
184 
185 int av_dict_parse_string(AVDictionary **pm, const char *str,
186  const char *key_val_sep, const char *pairs_sep,
187  int flags)
188 {
189  int ret;
190 
191  if (!str)
192  return 0;
193 
194  /* ignore STRDUP flags */
196 
197  while (*str) {
198  if ((ret = parse_key_value_pair(pm, &str, key_val_sep, pairs_sep, flags)) < 0)
199  return ret;
200 
201  if (*str)
202  str++;
203  }
204 
205  return 0;
206 }
207 
209 {
210  AVDictionary *m = *pm;
211 
212  if (m) {
213  while (m->count--) {
214  av_freep(&m->elems[m->count].key);
215  av_freep(&m->elems[m->count].value);
216  }
217  av_freep(&m->elems);
218  }
219  av_freep(pm);
220 }
221 
223 {
224  AVDictionaryEntry *t = NULL;
225 
226  while ((t = av_dict_get(src, "", t, AV_DICT_IGNORE_SUFFIX))) {
227  int ret = av_dict_set(dst, t->key, t->value, flags);
228  if (ret < 0)
229  return ret;
230  }
231 
232  return 0;
233 }
234 
236  const char key_val_sep, const char pairs_sep)
237 {
238  AVDictionaryEntry *t = NULL;
239  AVBPrint bprint;
240  int cnt = 0;
241  char special_chars[] = {pairs_sep, key_val_sep, '\0'};
242 
243  if (!buffer || pairs_sep == '\0' || key_val_sep == '\0' || pairs_sep == key_val_sep ||
244  pairs_sep == '\\' || key_val_sep == '\\')
245  return AVERROR(EINVAL);
246 
247  if (!av_dict_count(m)) {
248  *buffer = av_strdup("");
249  return *buffer ? 0 : AVERROR(ENOMEM);
250  }
251 
253  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
254  if (cnt++)
255  av_bprint_append_data(&bprint, &pairs_sep, 1);
256  av_bprint_escape(&bprint, t->key, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
257  av_bprint_append_data(&bprint, &key_val_sep, 1);
258  av_bprint_escape(&bprint, t->value, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
259  }
260  return av_bprint_finalize(&bprint, buffer);
261 }
262 
263 int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
264 {
265  time_t seconds = timestamp / 1000000;
266  struct tm *ptm, tmbuf;
267  ptm = gmtime_r(&seconds, &tmbuf);
268  if (ptm) {
269  char buf[32];
270  if (!strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", ptm))
271  return AVERROR_EXTERNAL;
272  av_strlcatf(buf, sizeof(buf), ".%06dZ", (int)(timestamp % 1000000));
273  return av_dict_set(dict, key, buf, 0);
274  } else {
275  return AVERROR_EXTERNAL;
276  }
277 }
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_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
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:36
AVDictionary::elems
AVDictionaryEntry * elems
Definition: dict.c:33
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:75
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:68
AVDictionary
Definition: dict.c:31
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
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:72
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:41
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:80
key
const char * key
Definition: hwcontext_opencl.c:174
time_internal.h
AVDictionary::count
int count
Definition: dict.c:32
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:77
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:74
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:208
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:161
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:236
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:1646
ret
ret
Definition: filter_design.txt:187
dict.h
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_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:67
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:185
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:152
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:79
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:71
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:235
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:222
AV_ESCAPE_MODE_BACKSLASH
@ AV_ESCAPE_MODE_BACKSLASH
Use backslash escaping.
Definition: avstring.h:325
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:81
avstring.h
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:263
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:70