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