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 
36 int av_strstart(const char *str, const char *pfx, const char **ptr)
37 {
38  while (*pfx && *pfx == *str) {
39  pfx++;
40  str++;
41  }
42  if (!*pfx && ptr)
43  *ptr = str;
44  return !*pfx;
45 }
46 
47 int av_stristart(const char *str, const char *pfx, const char **ptr)
48 {
49  while (*pfx && av_toupper((unsigned)*pfx) == av_toupper((unsigned)*str)) {
50  pfx++;
51  str++;
52  }
53  if (!*pfx && ptr)
54  *ptr = str;
55  return !*pfx;
56 }
57 
58 char *av_stristr(const char *s1, const char *s2)
59 {
60  if (!*s2)
61  return (char*)(intptr_t)s1;
62 
63  do
64  if (av_stristart(s1, s2, NULL))
65  return (char*)(intptr_t)s1;
66  while (*s1++);
67 
68  return NULL;
69 }
70 
71 char *av_strnstr(const char *haystack, const char *needle, size_t hay_length)
72 {
73  size_t needle_len = strlen(needle);
74  if (!needle_len)
75  return (char*)haystack;
76  while (hay_length >= needle_len) {
77  hay_length--;
78  if (!memcmp(haystack, needle, needle_len))
79  return (char*)haystack;
80  haystack++;
81  }
82  return NULL;
83 }
84 
85 size_t av_strlcpy(char *dst, const char *src, size_t size)
86 {
87  size_t len = 0;
88  while (++len < size && *src)
89  *dst++ = *src++;
90  if (len <= size)
91  *dst = 0;
92  return len + strlen(src) - 1;
93 }
94 
95 size_t av_strlcat(char *dst, const char *src, size_t size)
96 {
97  size_t len = strlen(dst);
98  if (size <= len + 1)
99  return len + strlen(src);
100  return len + av_strlcpy(dst + len, src, size - len);
101 }
102 
103 size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...)
104 {
105  size_t len = strlen(dst);
106  va_list vl;
107 
108  va_start(vl, fmt);
109  len += vsnprintf(dst + len, size > len ? size - len : 0, fmt, vl);
110  va_end(vl);
111 
112  return len;
113 }
114 
115 char *av_asprintf(const char *fmt, ...)
116 {
117  char *p = NULL;
118  va_list va;
119  int len;
120 
121  va_start(va, fmt);
122  len = vsnprintf(NULL, 0, fmt, va);
123  va_end(va);
124  if (len < 0)
125  goto end;
126 
127  p = av_malloc(len + 1);
128  if (!p)
129  goto end;
130 
131  va_start(va, fmt);
132  len = vsnprintf(p, len + 1, fmt, va);
133  va_end(va);
134  if (len < 0)
135  av_freep(&p);
136 
137 end:
138  return p;
139 }
140 
141 #define WHITESPACES " \n\t\r"
142 
143 char *av_get_token(const char **buf, const char *term)
144 {
145  char *out = av_malloc(strlen(*buf) + 1);
146  char *ret = out, *end = out;
147  const char *p = *buf;
148  if (!out)
149  return NULL;
150  p += strspn(p, WHITESPACES);
151 
152  while (*p && !strspn(p, term)) {
153  char c = *p++;
154  if (c == '\\' && *p) {
155  *out++ = *p++;
156  end = out;
157  } else if (c == '\'') {
158  while (*p && *p != '\'')
159  *out++ = *p++;
160  if (*p) {
161  p++;
162  end = out;
163  }
164  } else {
165  *out++ = c;
166  }
167  }
168 
169  do
170  *out-- = 0;
171  while (out >= end && strspn(out, WHITESPACES));
172 
173  *buf = p;
174 
175  return ret;
176 }
177 
178 char *av_strtok(char *s, const char *delim, char **saveptr)
179 {
180  char *tok;
181 
182  if (!s && !(s = *saveptr))
183  return NULL;
184 
185  /* skip leading delimiters */
186  s += strspn(s, delim);
187 
188  /* s now points to the first non delimiter char, or to the end of the string */
189  if (!*s) {
190  *saveptr = NULL;
191  return NULL;
192  }
193  tok = s++;
194 
195  /* skip non delimiters */
196  s += strcspn(s, delim);
197  if (*s) {
198  *s = 0;
199  *saveptr = s+1;
200  } else {
201  *saveptr = NULL;
202  }
203 
204  return tok;
205 }
206 
207 int av_strcasecmp(const char *a, const char *b)
208 {
209  uint8_t c1, c2;
210  do {
211  c1 = av_tolower(*a++);
212  c2 = av_tolower(*b++);
213  } while (c1 && c1 == c2);
214  return c1 - c2;
215 }
216 
217 int av_strncasecmp(const char *a, const char *b, size_t n)
218 {
219  uint8_t c1, c2;
220  if (n <= 0)
221  return 0;
222  do {
223  c1 = av_tolower(*a++);
224  c2 = av_tolower(*b++);
225  } while (--n && c1 && c1 == c2);
226  return c1 - c2;
227 }
228 
229 char *av_strireplace(const char *str, const char *from, const char *to)
230 {
231  char *ret = NULL;
232  const char *pstr2, *pstr = str;
233  size_t tolen = strlen(to), fromlen = strlen(from);
234  AVBPrint pbuf;
235 
237  while ((pstr2 = av_stristr(pstr, from))) {
238  av_bprint_append_data(&pbuf, pstr, pstr2 - pstr);
239  pstr = pstr2 + fromlen;
240  av_bprint_append_data(&pbuf, to, tolen);
241  }
242  av_bprint_append_data(&pbuf, pstr, strlen(pstr));
243  if (!av_bprint_is_complete(&pbuf)) {
244  av_bprint_finalize(&pbuf, NULL);
245  } else {
246  av_bprint_finalize(&pbuf, &ret);
247  }
248 
249  return ret;
250 }
251 
252 const char *av_basename(const char *path)
253 {
254  char *p;
255 #if HAVE_DOS_PATHS
256  char *q, *d;
257 #endif
258 
259  if (!path || *path == '\0')
260  return ".";
261 
262  p = strrchr(path, '/');
263 #if HAVE_DOS_PATHS
264  q = strrchr(path, '\\');
265  d = strchr(path, ':');
266  p = FFMAX3(p, q, d);
267 #endif
268 
269  if (!p)
270  return path;
271 
272  return p + 1;
273 }
274 
275 const char *av_dirname(char *path)
276 {
277  char *p = path ? strrchr(path, '/') : NULL;
278 
279 #if HAVE_DOS_PATHS
280  char *q = path ? strrchr(path, '\\') : NULL;
281  char *d = path ? strchr(path, ':') : NULL;
282 
283  d = d ? d + 1 : d;
284 
285  p = FFMAX3(p, q, d);
286 #endif
287 
288  if (!p)
289  return ".";
290 
291  *p = '\0';
292 
293  return path;
294 }
295 
296 char *av_append_path_component(const char *path, const char *component)
297 {
298  size_t p_len, c_len;
299  char *fullpath;
300 
301  if (!path)
302  return av_strdup(component);
303  if (!component)
304  return av_strdup(path);
305 
306  p_len = strlen(path);
307  c_len = strlen(component);
308  if (p_len > SIZE_MAX - c_len || p_len + c_len > SIZE_MAX - 2)
309  return NULL;
310  fullpath = av_malloc(p_len + c_len + 2);
311  if (fullpath) {
312  if (p_len) {
313  av_strlcpy(fullpath, path, p_len + 1);
314  if (c_len) {
315  if (fullpath[p_len - 1] != '/' && component[0] != '/')
316  fullpath[p_len++] = '/';
317  else if (fullpath[p_len - 1] == '/' && component[0] == '/')
318  p_len--;
319  }
320  }
321  av_strlcpy(&fullpath[p_len], component, c_len + 1);
322  fullpath[p_len + c_len] = 0;
323  }
324  return fullpath;
325 }
326 
327 int av_escape(char **dst, const char *src, const char *special_chars,
328  enum AVEscapeMode mode, int flags)
329 {
330  AVBPrint dstbuf;
331  int ret;
332 
333  av_bprint_init(&dstbuf, 1, INT_MAX); /* (int)dstbuf.len must be >= 0 */
334  av_bprint_escape(&dstbuf, src, special_chars, mode, flags);
335 
336  if (!av_bprint_is_complete(&dstbuf)) {
337  av_bprint_finalize(&dstbuf, NULL);
338  return AVERROR(ENOMEM);
339  }
340  if ((ret = av_bprint_finalize(&dstbuf, dst)) < 0)
341  return ret;
342  return dstbuf.len;
343 }
344 
345 int av_match_name(const char *name, const char *names)
346 {
347  const char *p;
348  int len, namelen;
349 
350  if (!name || !names)
351  return 0;
352 
353  namelen = strlen(name);
354  while (*names) {
355  int negate = '-' == *names;
356  p = strchr(names, ',');
357  if (!p)
358  p = names + strlen(names);
359  names += negate;
360  len = FFMAX(p - names, namelen);
361  if (!av_strncasecmp(name, names, len) || !strncmp("ALL", names, FFMAX(3, p - names)))
362  return !negate;
363  names = p + (*p == ',');
364  }
365  return 0;
366 }
367 
368 int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,
369  unsigned int flags)
370 {
371  const uint8_t *p = *bufp;
372  uint32_t top;
373  uint64_t code;
374  int ret = 0, tail_len;
375  uint32_t overlong_encoding_mins[6] = {
376  0x00000000, 0x00000080, 0x00000800, 0x00010000, 0x00200000, 0x04000000,
377  };
378 
379  if (p >= buf_end)
380  return 0;
381 
382  code = *p++;
383 
384  /* first sequence byte starts with 10, or is 1111-1110 or 1111-1111,
385  which is not admitted */
386  if ((code & 0xc0) == 0x80 || code >= 0xFE) {
387  ret = AVERROR(EILSEQ);
388  goto end;
389  }
390  top = (code & 128) >> 1;
391 
392  tail_len = 0;
393  while (code & top) {
394  int tmp;
395  tail_len++;
396  if (p >= buf_end) {
397  (*bufp) ++;
398  return AVERROR(EILSEQ); /* incomplete sequence */
399  }
400 
401  /* we assume the byte to be in the form 10xx-xxxx */
402  tmp = *p++ - 128; /* strip leading 1 */
403  if (tmp>>6) {
404  (*bufp) ++;
405  return AVERROR(EILSEQ);
406  }
407  code = (code<<6) + tmp;
408  top <<= 5;
409  }
410  code &= (top << 1) - 1;
411 
412  /* check for overlong encodings */
413  av_assert0(tail_len <= 5);
414  if (code < overlong_encoding_mins[tail_len]) {
415  ret = AVERROR(EILSEQ);
416  goto end;
417  }
418 
419  if (code >= 1U<<31) {
420  ret = AVERROR(EILSEQ); /* out-of-range value */
421  goto end;
422  }
423 
424  *codep = code;
425 
426  if (code > 0x10FFFF &&
428  ret = AVERROR(EILSEQ);
429  if (code < 0x20 && code != 0x9 && code != 0xA && code != 0xD &&
431  ret = AVERROR(EILSEQ);
432  if (code >= 0xD800 && code <= 0xDFFF &&
434  ret = AVERROR(EILSEQ);
435  if ((code == 0xFFFE || code == 0xFFFF) &&
437  ret = AVERROR(EILSEQ);
438 
439 end:
440  *bufp = p;
441  return ret;
442 }
443 
444 int av_match_list(const char *name, const char *list, char separator)
445 {
446  const char *p, *q;
447 
448  for (p = name; p && *p; ) {
449  for (q = list; q && *q; ) {
450  int k;
451  for (k = 0; p[k] == q[k] || (p[k]*q[k] == 0 && p[k]+q[k] == separator); k++)
452  if (k && (!p[k] || p[k] == separator))
453  return 1;
454  q = strchr(q, separator);
455  q += !!q;
456  }
457  p = strchr(p, separator);
458  p += !!p;
459  }
460 
461  return 0;
462 }
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:368
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
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:218
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
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_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:58
AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS
#define AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS
accept non-characters - 0xFFFE and 0xFFFF
Definition: avstring.h:372
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
b
#define b
Definition: input.c:41
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
c1
static const uint64_t c1
Definition: murmur3.c:52
AV_UTF8_FLAG_ACCEPT_SURROGATES
#define AV_UTF8_FLAG_ACCEPT_SURROGATES
accept UTF-16 surrogates codes
Definition: avstring.h:373
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
av_basename
const char * av_basename(const char *path)
Thread safe basename.
Definition: avstring.c:252
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:296
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:374
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:327
macros.h
av_dirname
const char * av_dirname(char *path)
Thread safe dirname.
Definition: avstring.c:275
avassert.h
AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES
#define AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES
accept codepoints over 0x10FFFF
Definition: avstring.h:371
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:178
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:40
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:47
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:444
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:268
av_strireplace
char * av_strireplace(const char *str, const char *from, const char *to)
Locale-independent strings replace.
Definition: avstring.c:229
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
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:217
s2
#define s2
Definition: regdef.h:39
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
size
int size
Definition: twinvq_data.h:10344
WHITESPACES
#define WHITESPACES
Definition: avstring.c:141
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:36
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:227
len
int len
Definition: vorbis_enc_data.h:426
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:95
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:71
U
#define U(x)
Definition: vpx_arith.h:37
c2
static const uint64_t c2
Definition: murmur3.c:53
mode
mode
Definition: ebur128.h:83
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:143
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:345
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
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:424
int32_t
int32_t
Definition: audioconvert.c:56
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
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:85
AVEscapeMode
AVEscapeMode
Definition: avstring.h:314
avstring.h
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:163
av_tolower
static av_const int av_tolower(int c)
Locale-independent conversion of ASCII characters to lowercase.
Definition: avstring.h:237