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 "internal.h"
26 #include "mem.h"
27 
28 struct AVDictionary {
29  int count;
31 };
32 
34 {
35  return m ? m->count : 0;
36 }
37 
39 av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
40 {
41  unsigned int i, j;
42 
43  if(!m)
44  return NULL;
45 
46  if(prev) i= prev - m->elems + 1;
47  else i= 0;
48 
49  for(; i<m->count; i++){
50  const char *s= m->elems[i].key;
51  if(flags & AV_DICT_MATCH_CASE) for(j=0; s[j] == key[j] && key[j]; j++);
52  else for(j=0; av_toupper(s[j]) == av_toupper(key[j]) && key[j]; j++);
53  if(key[j])
54  continue;
55  if(s[j] && !(flags & AV_DICT_IGNORE_SUFFIX))
56  continue;
57  return &m->elems[i];
58  }
59  return NULL;
60 }
61 
62 int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
63 {
64  AVDictionary *m = *pm;
65  AVDictionaryEntry *tag = av_dict_get(m, key, NULL, flags);
66  char *oldval = NULL;
67 
68  if(!m)
69  m = *pm = av_mallocz(sizeof(*m));
70 
71  if(tag) {
72  if (flags & AV_DICT_DONT_OVERWRITE)
73  return 0;
74  if (flags & AV_DICT_APPEND)
75  oldval = tag->value;
76  else
77  av_free(tag->value);
78  av_free(tag->key);
79  *tag = m->elems[--m->count];
80  } else {
81  AVDictionaryEntry *tmp = av_realloc(m->elems, (m->count+1) * sizeof(*m->elems));
82  if(tmp) {
83  m->elems = tmp;
84  } else
85  return AVERROR(ENOMEM);
86  }
87  if (value) {
88  if (flags & AV_DICT_DONT_STRDUP_KEY) {
89  m->elems[m->count].key = (char*)(intptr_t)key;
90  } else
91  m->elems[m->count].key = av_strdup(key);
92  if (flags & AV_DICT_DONT_STRDUP_VAL) {
93  m->elems[m->count].value = (char*)(intptr_t)value;
94  } else if (oldval && flags & AV_DICT_APPEND) {
95  int len = strlen(oldval) + strlen(value) + 1;
96  char *newval = av_mallocz(len);
97  if (!newval)
98  return AVERROR(ENOMEM);
99  av_strlcat(newval, oldval, len);
100  av_freep(&oldval);
101  av_strlcat(newval, value, len);
102  m->elems[m->count].value = newval;
103  } else
104  m->elems[m->count].value = av_strdup(value);
105  m->count++;
106  }
107  if (!m->count) {
108  av_free(m->elems);
109  av_freep(pm);
110  }
111 
112  return 0;
113 }
114 
115 static int parse_key_value_pair(AVDictionary **pm, const char **buf,
116  const char *key_val_sep, const char *pairs_sep,
117  int flags)
118 {
119  char *key = av_get_token(buf, key_val_sep);
120  char *val = NULL;
121  int ret;
122 
123  if (key && *key && strspn(*buf, key_val_sep)) {
124  (*buf)++;
125  val = av_get_token(buf, pairs_sep);
126  }
127 
128  if (key && *key && val && *val)
129  ret = av_dict_set(pm, key, val, flags);
130  else
131  ret = AVERROR(EINVAL);
132 
133  av_freep(&key);
134  av_freep(&val);
135 
136  return ret;
137 }
138 
139 int av_dict_parse_string(AVDictionary **pm, const char *str,
140  const char *key_val_sep, const char *pairs_sep,
141  int flags)
142 {
143  int ret;
144 
145  if (!str)
146  return 0;
147 
148  /* ignore STRDUP flags */
150 
151  while (*str) {
152  if ((ret = parse_key_value_pair(pm, &str, key_val_sep, pairs_sep, flags)) < 0)
153  return ret;
154 
155  if (*str)
156  str++;
157  }
158 
159  return 0;
160 }
161 
163 {
164  AVDictionary *m = *pm;
165 
166  if (m) {
167  while(m->count--) {
168  av_free(m->elems[m->count].key);
169  av_free(m->elems[m->count].value);
170  }
171  av_free(m->elems);
172  }
173  av_freep(pm);
174 }
175 
177 {
179 
180  while ((t = av_dict_get(src, "", t, AV_DICT_IGNORE_SUFFIX)))
181  av_dict_set(dst, t->key, t->value, flags);
182 }
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
int count
Definition: dict.c:29
const char * s
Definition: avisynth_c.h:668
memory handling functions
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:75
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:33
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:141
AVDictionaryEntry * av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:39
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that&#39;s been allocated with av_malloc() and children.
Definition: dict.h:69
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
Public dictionary API.
window constants for m
uint32_t tag
Definition: movenc.c:894
void av_dict_copy(AVDictionary **dst, AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:176
#define AV_DICT_MATCH_CASE
Definition: dict.h:67
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:183
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:162
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:148
common internal API header
AVDictionaryEntry * elems
Definition: dict.c:30
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() and chilren.
Definition: dict.h:72
ret
Definition: avfilter.c:821
t
Definition: genspecsines3.m:6
#define AV_DICT_APPEND
If the entry already exists, append to it.
Definition: dict.h:76
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 to a dictionary.
Definition: dict.c:139
NULL
Definition: eval.c:55
AVS_Value src
Definition: avisynth_c.h:523
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:220
void * buf
Definition: avisynth_c.h:594
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:62
double value
Definition: eval.c:82
synthesis window for stochastic i
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer 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.Buffer references ownership and permissions
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:92
static int flags
Definition: cpu.c:23
static int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:206
char * key
Definition: dict.h:81
char * value
Definition: dict.h:82
int len
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:68
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:115