FFmpeg: libavutil/tests/dict.c Source File

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 if (av_dict_set(&dict, "key", "old", 0) < 0)

154 return 1;

155 e = av_dict_get(dict, "key", NULL, 0);

156 if (av_dict_set(&dict, e->key, "new val OK", 0) < 0)

157 return 1;

158 e = av_dict_get(dict, "key", NULL, 0);

159 printf("%s\n", e->value);

160 if (av_dict_set(&dict, e->key, e->value, 0) < 0)

161 return 1;

162 e = av_dict_get(dict, "key", NULL, 0);

163 printf("%s\n", e->value);

164 av_dict_free(&dict);

165

166 return 0;

167 }

#define GET(entry, mem)

__device__ int printf(const char *,...)

int main(void)

Definition: dict.c:74

int av_dict_count(const AVDictionary *m)

Get number of entries in dictionary.

Definition: dict.c:37

#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

Definition: dict.c:32

static void print_dict(const AVDictionary *m)

Definition: dict.c:45

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

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

static const AVDictionaryEntry * dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)

Definition: dict.c:25

AVDictionaryEntry::key

char * key

Definition: dict.h:91

const char * key

Definition: hwcontext_opencl.c:189

#define NULL

Definition: coverity.c:32

AV_DICT_DONT_OVERWRITE

#define AV_DICT_DONT_OVERWRITE

Don't overwrite existing entries.

Definition: dict.h:81

void av_dict_free(AVDictionary **pm)

Free all the memory allocated for an AVDictionary struct and all keys and values.

Definition: dict.c:233

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

Definition: filter_design.txt:187

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:210

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:177

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:272

AVDictionaryEntry

Definition: dict.h:90

#define av_freep(p)

Definition: tableprint_vlc.h:35

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:260

int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)

Copy entries from one AVDictionary struct into another.

Definition: dict.c:247

AVDictionaryEntry::value

char * value

Definition: dict.h:92

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

Generated on Sat Oct 18 2025 19:23:33 for FFmpeg by doxygen 1.8.17