FFmpeg
avstring.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
3  * Copyright (c) 2007 Mans Rullgard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <limits.h>
23 #include <stdarg.h>
24 #include <stdint.h>
25 #include <stdio.h>
26 #include <string.h>
27 
28 #include "config.h"
29 #include "mem.h"
30 #include "avassert.h"
31 #include "avstring.h"
32 #include "bprint.h"
33 #include "error.h"
34 #include "macros.h"
35 #include "version.h"
36 
37 int av_strstart(const char *str, const char *pfx, const char **ptr)
38 {
39  while (*pfx && *pfx == *str) {
40  pfx++;
41  str++;
42  }
43  if (!*pfx && ptr)
44  *ptr = str;
45  return !*pfx;
46 }
47 
48 int av_stristart(const char *str, const char *pfx, const char **ptr)
49 {
50  while (*pfx && av_toupper((unsigned)*pfx) == av_toupper((unsigned)*str)) {
51  pfx++;
52  str++;
53  }
54  if (!*pfx && ptr)
55  *ptr = str;
56  return !*pfx;
57 }
58 
59 char *av_stristr(const char *s1, const char *s2)
60 {
61  if (!*s2)
62  return (char*)(intptr_t)s1;
63 
64  do
65  if (av_stristart(s1, s2, NULL))
66  return (char*)(intptr_t)s1;
67  while (*s1++);
68 
69  return NULL;
70 }
71 
72 char *av_strnstr(const char *haystack, const char *needle, size_t hay_length)
73 {
74  size_t needle_len = strlen(needle);
75  if (!needle_len)
76  return (char*)haystack;
77  while (hay_length >= needle_len) {
78  hay_length--;
79  if (!memcmp(haystack, needle, needle_len))
80  return (char*)haystack;
81  haystack++;
82  }
83  return NULL;
84 }
85 
86 size_t av_strlcpy(char *dst, const char *src, size_t size)
87 {
88  size_t len = 0;
89  while (++len < size && *src)
90  *dst++ = *src++;
91  if (len <= size)
92  *dst = 0;
93  return len + strlen(src) - 1;
94 }
95 
96 size_t av_strlcat(char *dst, const char *src, size_t size)
97 {
98  size_t len = strlen(dst);
99  if (size <= len + 1)
100  return len + strlen(src);
101  return len + av_strlcpy(dst + len, src, size - len);
102 }
103 
104 size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...)
105 {
106  size_t len = strlen(dst);
107  va_list vl;
108 
109  va_start(vl, fmt);
110  len += vsnprintf(dst + len, size > len ? size - len : 0, fmt, vl);
111  va_end(vl);
112 
113  return len;
114 }
115 
116 char *av_asprintf(const char *fmt, ...)
117 {
118  char *p = NULL;
119  va_list va;
120  int len;
121 
122  va_start(va, fmt);
123  len = vsnprintf(NULL, 0, fmt, va);
124  va_end(va);
125  if (len < 0)
126  goto end;
127 
128  p = av_malloc(len + 1);
129  if (!p)
130  goto end;
131 
132  va_start(va, fmt);
133  len = vsnprintf(p, len + 1, fmt, va);
134  va_end(va);
135  if (len < 0)
136  av_freep(&p);
137 
138 end:
139  return p;
140 }
141 
142 #if FF_API_D2STR
143 char *av_d2str(double d)
144 {
145  char *str = av_malloc(16);
146  if (str)
147  snprintf(str, 16, "%f", d);
148  return str;
149 }
150 #endif
151 
152 #define WHITESPACES " \n\t\r"
153 
154 char *av_get_token(const char **buf, const char *term)
155 {
156  char *out = av_malloc(strlen(*buf) + 1);
157  char *ret = out, *end = out;
158  const char *p = *buf;
159  if (!out)
160  return NULL;
161  p += strspn(p, WHITESPACES);
162 
163  while (*p && !strspn(p, term)) {
164  char c = *p++;
165  if (c == '\\' && *p) {
166  *out++ = *p++;
167  end = out;
168  } else if (c == '\'') {
169  while (*p && *p != '\'')
170  *out++ = *p++;
171  if (*p) {
172  p++;
173  end = out;
174  }
175  } else {
176  *out++ = c;
177  }
178  }
179 
180  do
181  *out-- = 0;
182  while (out >= end && strspn(out, WHITESPACES));
183 
184  *buf = p;
185 
186  return ret;
187 }
188 
189 char *av_strtok(char *s, const char *delim, char **saveptr)
190 {
191  char *tok;
192 
193  if (!s && !(s = *saveptr))
194  return NULL;
195 
196  /* skip leading delimiters */
197  s += strspn(s, delim);
198 
199  /* s now points to the first non delimiter char, or to the end of the string */
200  if (!*s) {
201  *saveptr = NULL;
202  return NULL;
203  }
204  tok = s++;
205 
206  /* skip non delimiters */
207  s += strcspn(s, delim);
208  if (*s) {
209  *s = 0;
210  *saveptr = s+1;
211  } else {
212  *saveptr = NULL;
213  }
214 
215  return tok;
216 }
217 
218 int av_strcasecmp(const char *a, const char *b)
219 {
220  uint8_t c1, c2;
221  do {
222  c1 = av_tolower(*a++);
223  c2 = av_tolower(*b++);
224  } while (c1 && c1 == c2);
225  return c1 - c2;
226 }
227 
228 int av_strncasecmp(const char *a, const char *b, size_t n)
229 {
230  uint8_t c1, c2;
231  if (n <= 0)
232  return 0;
233  do {
234  c1 = av_tolower(*a++);
235  c2 = av_tolower(*b++);
236  } while (--n && c1 && c1 == c2);
237  return c1 - c2;
238 }
239 
240 char *av_strireplace(const char *str, const char *from, const char *to)
241 {
242  char *ret = NULL;
243  const char *pstr2, *pstr = str;
244  size_t tolen = strlen(to), fromlen = strlen(from);
245  AVBPrint pbuf;
246 
248  while ((pstr2 = av_stristr(pstr, from))) {
249  av_bprint_append_data(&pbuf, pstr, pstr2 - pstr);
250  pstr = pstr2 + fromlen;
251  av_bprint_append_data(&pbuf, to, tolen);
252  }
253  av_bprint_append_data(&pbuf, pstr, strlen(pstr));
254  if (!av_bprint_is_complete(&pbuf)) {
255  av_bprint_finalize(&pbuf, NULL);
256  } else {
257  av_bprint_finalize(&pbuf, &ret);
258  }
259 
260  return ret;
261 }
262 
263 const char *av_basename(const char *path)
264 {
265  char *p;
266 #if HAVE_DOS_PATHS
267  char *q, *d;
268 #endif
269 
270  if (!path || *path == '\0')
271  return ".";
272 
273  p = strrchr(path, '/');
274 #if HAVE_DOS_PATHS
275  q = strrchr(path, '\\');
276  d = strchr(path, ':');
277  p = FFMAX3(p, q, d);
278 #endif
279 
280  if (!p)
281  return path;
282 
283  return p + 1;
284 }
285 
286 const char *av_dirname(char *path)
287 {
288  char *p = path ? strrchr(path, '/') : NULL;
289 
290 #if HAVE_DOS_PATHS
291  char *q = path ? strrchr(path, '\\') : NULL;
292  char *d = path ? strchr(path, ':') : NULL;
293 
294  d = d ? d + 1 : d;
295 
296  p = FFMAX3(p, q, d);
297 #endif
298 
299  if (!p)
300  return ".";
301 
302  *p = '\0';
303 
304  return path;
305 }
306 
307 char *av_append_path_component(const char *path, const char *component)
308 {
309  size_t p_len, c_len;
310  char *fullpath;
311 
312  if (!path)
313  return av_strdup(component);
314  if (!component)
315  return av_strdup(path);
316 
317  p_len = strlen(path);
318  c_len = strlen(component);
319  if (p_len > SIZE_MAX - c_len || p_len + c_len > SIZE_MAX - 2)
320  return NULL;
321  fullpath = av_malloc(p_len + c_len + 2);
322  if (fullpath) {
323  if (p_len) {
324  av_strlcpy(fullpath, path, p_len + 1);
325  if (c_len) {
326  if (fullpath[p_len - 1] != '/' && component[0] != '/')
327  fullpath[p_len++] = '/';
328  else if (fullpath[p_len - 1] == '/' && component[0] == '/')
329  p_len--;
330  }
331  }
332  av_strlcpy(&fullpath[p_len], component, c_len + 1);
333  fullpath[p_len + c_len] = 0;
334  }
335  return fullpath;
336 }
337 
338 int av_escape(char **dst, const char *src, const char *special_chars,
339  enum AVEscapeMode mode, int flags)
340 {
341  AVBPrint dstbuf;
342  int ret;
343 
344  av_bprint_init(&dstbuf, 1, INT_MAX); /* (int)dstbuf.len must be >= 0 */
345  av_bprint_escape(&dstbuf, src, special_chars, mode, flags);
346 
347  if (!av_bprint_is_complete(&dstbuf)) {
348  av_bprint_finalize(&dstbuf, NULL);
349  return AVERROR(ENOMEM);
350  }
351  if ((ret = av_bprint_finalize(&dstbuf, dst)) < 0)
352  return ret;
353  return dstbuf.len;
354 }
355 
356 int av_match_name(const char *name, const char *names)
357 {
358  const char *p;
359  int len, namelen;
360 
361  if (!name || !names)
362  return 0;
363 
364  namelen = strlen(name);
365  while (*names) {
366  int negate = '-' == *names;
367  p = strchr(names, ',');
368  if (!p)
369  p = names + strlen(names);
370  names += negate;
371  len = FFMAX(p - names, namelen);
372  if (!av_strncasecmp(name, names, len) || !strncmp("ALL", names, FFMAX(3, p - names)))
373  return !negate;
374  names = p + (*p == ',');
375  }
376  return 0;
377 }
378 
379 int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,
380  unsigned int flags)
381 {
382  const uint8_t *p = *bufp;
383  uint32_t top;
384  uint64_t code;
385  int ret = 0, tail_len;
386  uint32_t overlong_encoding_mins[6] = {
387  0x00000000, 0x00000080, 0x00000800, 0x00010000, 0x00200000, 0x04000000,
388  };
389 
390  if (p >= buf_end)
391  return 0;
392 
393  code = *p++;
394 
395  /* first sequence byte starts with 10, or is 1111-1110 or 1111-1111,
396  which is not admitted */
397  if ((code & 0xc0) == 0x80 || code >= 0xFE) {
398  ret = AVERROR(EILSEQ);
399  goto end;
400  }
401  top = (code & 128) >> 1;
402 
403  tail_len = 0;
404  while (code & top) {
405  int tmp;
406  tail_len++;
407  if (p >= buf_end) {
408  (*bufp) ++;
409  return AVERROR(EILSEQ); /* incomplete sequence */
410  }
411 
412  /* we assume the byte to be in the form 10xx-xxxx */
413  tmp = *p++ - 128; /* strip leading 1 */
414  if (tmp>>6) {
415  (*bufp) ++;
416  return AVERROR(EILSEQ);
417  }
418  code = (code<<6) + tmp;
419  top <<= 5;
420  }
421  code &= (top << 1) - 1;
422 
423  /* check for overlong encodings */
424  av_assert0(tail_len <= 5);
425  if (code < overlong_encoding_mins[tail_len]) {
426  ret = AVERROR(EILSEQ);
427  goto end;
428  }
429 
430  if (code >= 1U<<31) {
431  ret = AVERROR(EILSEQ); /* out-of-range value */
432  goto end;
433  }
434 
435  *codep = code;
436 
437  if (code > 0x10FFFF &&
439  ret = AVERROR(EILSEQ);
440  if (code < 0x20 && code != 0x9 && code != 0xA && code != 0xD &&
442  ret = AVERROR(EILSEQ);
443  if (code >= 0xD800 && code <= 0xDFFF &&
445  ret = AVERROR(EILSEQ);
446  if ((code == 0xFFFE || code == 0xFFFF) &&
448  ret = AVERROR(EILSEQ);
449 
450 end:
451  *bufp = p;
452  return ret;
453 }
454 
455 int av_match_list(const char *name, const char *list, char separator)
456 {
457  const char *p, *q;
458 
459  for (p = name; p && *p; ) {
460  for (q = list; q && *q; ) {
461  int k;
462  for (k = 0; p[k] == q[k] || (p[k]*q[k] == 0 && p[k]+q[k] == separator); k++)
463  if (k && (!p[k] || p[k] == separator))
464  return 1;
465  q = strchr(q, separator);
466  q += !!q;
467  }
468  p = strchr(p, separator);
469  p += !!p;
470  }
471 
472  return 0;
473 }
av_utf8_decode
int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end, unsigned int flags)
Read and decode a single UTF-8 code point (character) from the buffer in *buf, and update *buf to poi...
Definition: avstring.c:379
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
name
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 minimum maximum flags name is the option name
Definition: writing_filters.txt:88
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
out
FILE * out
Definition: movenc.c:54
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_stristr
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle.
Definition: avstring.c:59
AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS
#define AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS
accept non-characters - 0xFFFE and 0xFFFF
Definition: avstring.h:381
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:116
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:218
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
b
#define b
Definition: input.c:41
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
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_d2str
char * av_d2str(double d)
Convert a number to an av_malloced string.
Definition: avstring.c:143
c1
static const uint64_t c1
Definition: murmur3.c:51
AV_UTF8_FLAG_ACCEPT_SURROGATES
#define AV_UTF8_FLAG_ACCEPT_SURROGATES
accept UTF-16 surrogates codes
Definition: avstring.h:382
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:104
av_basename
const char * av_basename(const char *path)
Thread safe basename.
Definition: avstring.c:263
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
av_append_path_component
char * av_append_path_component(const char *path, const char *component)
Append path component to the existing path.
Definition: avstring.c:307
AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES
#define AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES
exclude control codes not accepted by XML
Definition: avstring.h:383
av_escape
int av_escape(char **dst, const char *src, const char *special_chars, enum AVEscapeMode mode, int flags)
Escape string in src, and put the escaped string in an allocated string in *dst, which must be freed ...
Definition: avstring.c:338
macros.h
av_dirname
const char * av_dirname(char *path)
Thread safe dirname.
Definition: avstring.c:286
avassert.h
AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES
#define AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES
accept codepoints over 0x10FFFF
Definition: avstring.h:380
s
#define s(width, name)
Definition: cbs_vp9.c:256
s1
#define s1
Definition: regdef.h:38
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:189
from
const char * from
Definition: jacosubdec.c:66
to
const char * to
Definition: webvttdec.c:35
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
limits.h
av_stristart
int av_stristart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str independent of case.
Definition: avstring.c:48
NULL
#define NULL
Definition: coverity.c:32
av_match_list
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:455
av_strireplace
char * av_strireplace(const char *str, const char *from, const char *to)
Locale-independent strings replace.
Definition: avstring.c:240
list
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 list
Definition: filter_design.txt:25
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
error.h
FFFILE::buf
unsigned char * buf
Definition: avsscanf.c:39
av_strncasecmp
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:228
s2
#define s2
Definition: regdef.h:39
size
int size
Definition: twinvq_data.h:10344
WHITESPACES
#define WHITESPACES
Definition: avstring.c:152
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:37
bprint.h
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
vsnprintf
#define vsnprintf
Definition: snprintf.h:36
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:236
len
int len
Definition: vorbis_enc_data.h:426
version.h
ret
ret
Definition: filter_design.txt:187
av_strlcat
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:96
av_strnstr
char * av_strnstr(const char *haystack, const char *needle, size_t hay_length)
Locate the first occurrence of the string needle in the string haystack where not more than hay_lengt...
Definition: avstring.c:72
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
U
#define U(x)
Definition: vpx_arith.h:37
c2
static const uint64_t c2
Definition: murmur3.c:52
mode
mode
Definition: ebur128.h:83
av_match_name
int av_match_name(const char *name, const char *names)
Match instances of a name in a comma-separated list of names.
Definition: avstring.c:356
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
mem.h
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
d
d
Definition: ffmpeg_filter.c:156
int32_t
int32_t
Definition: audioconvert.c:56
convert_header.str
string str
Definition: convert_header.py:20
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:86
AVEscapeMode
AVEscapeMode
Definition: avstring.h:323
avstring.h
snprintf
#define snprintf
Definition: snprintf.h:34
av_tolower
static av_const int av_tolower(int c)
Locale-independent conversion of ASCII characters to lowercase.
Definition: avstring.h:246