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 "libavutil/dict.c"
22 
24  const AVDictionaryEntry *prev)
25 {
26  const AVDictionaryEntry *dict_get = av_dict_get(m, "", prev, AV_DICT_IGNORE_SUFFIX);
28 
29  if (dict_get != dict_iterate) {
30 #define GET(entry, mem) ((entry) ? (entry)->mem : "N/A")
31  printf("Iterating with av_dict_iterate() yields a different result "
32  "than iterating with av_dict_get() and AV_DICT_IGNORE_SUFFIX "
33  "(prev: %p, key %s; av_dict_iterate() %p, key %s, value %s; "
34  "av_dict_get() %p, key %s, value %s)\n",
35  prev, GET(prev, key),
37  dict_get, GET(dict_get, key), GET(dict_get, value));
38 #undef GET
39  }
40  return dict_iterate;
41 }
42 
43 static void print_dict(const AVDictionary *m)
44 {
45  const AVDictionaryEntry *t = NULL;
46  while ((t = dict_iterate(m, t)))
47  printf("%s %s ", t->key, t->value);
48  printf("\n");
49 }
50 
51 static void test_separators(const AVDictionary *m, const char pair, const char val)
52 {
53  AVDictionary *dict = NULL;
54  char pairs[] = {pair , '\0'};
55  char vals[] = {val, '\0'};
56 
57  char *buffer = NULL;
58  int ret;
59 
60  av_dict_copy(&dict, m, 0);
61  print_dict(dict);
62  av_dict_get_string(dict, &buffer, val, pair);
63  printf("%s\n", buffer);
64  av_dict_free(&dict);
65  ret = av_dict_parse_string(&dict, buffer, vals, pairs, 0);
66  printf("ret %d\n", ret);
67  av_freep(&buffer);
68  print_dict(dict);
69  av_dict_free(&dict);
70 }
71 
72 int main(void)
73 {
74  AVDictionary *dict = NULL;
75  const AVDictionaryEntry *e;
76  char *buffer = NULL;
77 
78  printf("Testing av_dict_get_string() and av_dict_parse_string()\n");
79  av_dict_get_string(dict, &buffer, '=', ',');
80  printf("%s\n", buffer);
81  av_freep(&buffer);
82  av_dict_set(&dict, "aaa", "aaa", 0);
83  av_dict_set(&dict, "b,b", "bbb", 0);
84  av_dict_set(&dict, "c=c", "ccc", 0);
85  av_dict_set(&dict, "ddd", "d,d", 0);
86  av_dict_set(&dict, "eee", "e=e", 0);
87  av_dict_set(&dict, "f,f", "f=f", 0);
88  av_dict_set(&dict, "g=g", "g,g", 0);
89  test_separators(dict, ',', '=');
90  av_dict_free(&dict);
91  av_dict_set(&dict, "aaa", "aaa", 0);
92  av_dict_set(&dict, "bbb", "bbb", 0);
93  av_dict_set(&dict, "ccc", "ccc", 0);
94  av_dict_set(&dict, "\\,=\'\"", "\\,=\'\"", 0);
95  test_separators(dict, '"', '=');
96  test_separators(dict, '\'', '=');
97  test_separators(dict, ',', '"');
98  test_separators(dict, ',', '\'');
99  test_separators(dict, '\'', '"');
100  test_separators(dict, '"', '\'');
101  av_dict_free(&dict);
102 
103  printf("\nTesting av_dict_set()\n");
104  av_dict_set(&dict, "a", "a", 0);
105  av_dict_set(&dict, "b", av_strdup("b"), AV_DICT_DONT_STRDUP_VAL);
106  av_dict_set(&dict, av_strdup("c"), "c", AV_DICT_DONT_STRDUP_KEY);
108  av_dict_set(&dict, "e", "e", AV_DICT_DONT_OVERWRITE);
109  av_dict_set(&dict, "e", "f", AV_DICT_DONT_OVERWRITE);
110  av_dict_set(&dict, "f", "f", 0);
111  av_dict_set(&dict, "f", NULL, 0);
112  av_dict_set(&dict, "ff", "f", 0);
113  av_dict_set(&dict, "ff", "f", AV_DICT_APPEND);
114  if (av_dict_get(dict, NULL, NULL, 0))
115  printf("av_dict_get() does not correctly handle NULL key.\n");
116  e = NULL;
117  while ((e = dict_iterate(dict, e)))
118  printf("%s %s\n", e->key, e->value);
119  av_dict_free(&dict);
120 
121  if (av_dict_set(&dict, NULL, "a", 0) >= 0 ||
122  av_dict_set(&dict, NULL, "b", 0) >= 0 ||
123  av_dict_set(&dict, NULL, NULL, AV_DICT_DONT_STRDUP_KEY) >= 0 ||
124  av_dict_set(&dict, NULL, av_strdup("b"), AV_DICT_DONT_STRDUP_VAL) >= 0 ||
125  av_dict_count(dict))
126  printf("av_dict_set does not correctly handle NULL key\n");
127 
128  e = NULL;
129  while ((e = dict_iterate(dict, e)))
130  printf("'%s' '%s'\n", e->key, e->value);
131  av_dict_free(&dict);
132 
133 
134  //valgrind sensible test
135  printf("\nTesting av_dict_set_int()\n");
139  av_dict_set_int(&dict, "4", 4, 0);
140  av_dict_set_int(&dict, "5", 5, AV_DICT_DONT_OVERWRITE);
141  av_dict_set_int(&dict, "5", 6, AV_DICT_DONT_OVERWRITE);
142  av_dict_set_int(&dict, "12", 1, 0);
143  av_dict_set_int(&dict, "12", 2, AV_DICT_APPEND);
144  e = NULL;
145  while ((e = dict_iterate(dict, e)))
146  printf("%s %s\n", e->key, e->value);
147  av_dict_free(&dict);
148 
149  //valgrind sensible test
150  printf("\nTesting av_dict_set() with existing AVDictionaryEntry.key as key\n");
151  av_dict_set(&dict, "key", "old", 0);
152  e = av_dict_get(dict, "key", NULL, 0);
153  av_dict_set(&dict, e->key, "new val OK", 0);
154  e = av_dict_get(dict, "key", NULL, 0);
155  printf("%s\n", e->value);
156  av_dict_set(&dict, e->key, e->value, 0);
157  e = av_dict_get(dict, "key", NULL, 0);
158  printf("%s\n", e->value);
159  av_dict_free(&dict);
160 
161  return 0;
162 }
GET
#define GET(entry, mem)
main
int main(void)
Definition: dict.c:72
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:37
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
print_dict
static void print_dict(const AVDictionary *m)
Definition: dict.c:43
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
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
dict_iterate
static const AVDictionaryEntry * dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Definition: dict.c:23
AVDictionaryEntry::key
char * key
Definition: dict.h:90
key
const char * key
Definition: hwcontext_opencl.c:174
NULL
#define NULL
Definition: coverity.c:32
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
printf
printf("static const uint8_t my_array[100] = {\n")
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
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
test_separators
static void test_separators(const AVDictionary *m, const char pair, const char val)
Definition: dict.c:51
ret
ret
Definition: filter_design.txt:187
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
dict.c
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
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
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
AVDictionaryEntry::value
char * value
Definition: dict.h:91
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