Line | Branch | Exec | Source |
---|---|---|---|
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 | 175071086 | int av_strstart(const char *str, const char *pfx, const char **ptr) | |
37 | { | ||
38 |
4/4✓ Branch 0 taken 190955562 times.
✓ Branch 1 taken 1253376 times.
✓ Branch 2 taken 17137852 times.
✓ Branch 3 taken 173817710 times.
|
192208938 | while (*pfx && *pfx == *str) { |
39 | 17137852 | pfx++; | |
40 | 17137852 | str++; | |
41 | } | ||
42 |
4/4✓ Branch 0 taken 1253376 times.
✓ Branch 1 taken 173817710 times.
✓ Branch 2 taken 1250711 times.
✓ Branch 3 taken 2665 times.
|
175071086 | if (!*pfx && ptr) |
43 | 1250711 | *ptr = str; | |
44 | 175071086 | return !*pfx; | |
45 | } | ||
46 | |||
47 | 10528 | int av_stristart(const char *str, const char *pfx, const char **ptr) | |
48 | { | ||
49 |
4/4✓ Branch 0 taken 10970 times.
✓ Branch 1 taken 181 times.
✓ Branch 2 taken 623 times.
✓ Branch 3 taken 10347 times.
|
11151 | while (*pfx && av_toupper((unsigned)*pfx) == av_toupper((unsigned)*str)) { |
50 | 623 | pfx++; | |
51 | 623 | str++; | |
52 | } | ||
53 |
3/4✓ Branch 0 taken 181 times.
✓ Branch 1 taken 10347 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 181 times.
|
10528 | if (!*pfx && ptr) |
54 | ✗ | *ptr = str; | |
55 | 10528 | return !*pfx; | |
56 | } | ||
57 | |||
58 | 657 | char *av_stristr(const char *s1, const char *s2) | |
59 | { | ||
60 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 657 times.
|
657 | if (!*s2) |
61 | ✗ | return (char*)(intptr_t)s1; | |
62 | |||
63 | do | ||
64 |
2/2✓ Branch 1 taken 181 times.
✓ Branch 2 taken 10340 times.
|
10521 | if (av_stristart(s1, s2, NULL)) |
65 | 181 | return (char*)(intptr_t)s1; | |
66 |
2/2✓ Branch 0 taken 9864 times.
✓ Branch 1 taken 476 times.
|
10340 | while (*s1++); |
67 | |||
68 | 476 | return NULL; | |
69 | } | ||
70 | |||
71 | 7 | char *av_strnstr(const char *haystack, const char *needle, size_t hay_length) | |
72 | { | ||
73 | 7 | size_t needle_len = strlen(needle); | |
74 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6 times.
|
7 | if (!needle_len) |
75 | 1 | return (char*)haystack; | |
76 |
2/2✓ Branch 0 taken 141 times.
✓ Branch 1 taken 1 times.
|
142 | while (hay_length >= needle_len) { |
77 | 141 | hay_length--; | |
78 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 136 times.
|
141 | if (!memcmp(haystack, needle, needle_len)) |
79 | 5 | return (char*)haystack; | |
80 | 136 | haystack++; | |
81 | } | ||
82 | 1 | return NULL; | |
83 | } | ||
84 | |||
85 | 373988 | size_t av_strlcpy(char *dst, const char *src, size_t size) | |
86 | { | ||
87 | 373988 | size_t len = 0; | |
88 |
4/4✓ Branch 0 taken 2578767 times.
✓ Branch 1 taken 120582 times.
✓ Branch 2 taken 2325361 times.
✓ Branch 3 taken 253406 times.
|
2699349 | while (++len < size && *src) |
89 | 2325361 | *dst++ = *src++; | |
90 |
1/2✓ Branch 0 taken 373988 times.
✗ Branch 1 not taken.
|
373988 | if (len <= size) |
91 | 373988 | *dst = 0; | |
92 | 373988 | return len + strlen(src) - 1; | |
93 | } | ||
94 | |||
95 | 60757 | size_t av_strlcat(char *dst, const char *src, size_t size) | |
96 | { | ||
97 | 60757 | size_t len = strlen(dst); | |
98 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60757 times.
|
60757 | if (size <= len + 1) |
99 | ✗ | return len + strlen(src); | |
100 | 60757 | return len + av_strlcpy(dst + len, src, size - len); | |
101 | } | ||
102 | |||
103 | 145345 | size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) | |
104 | { | ||
105 | 145345 | size_t len = strlen(dst); | |
106 | va_list vl; | ||
107 | |||
108 | 145345 | va_start(vl, fmt); | |
109 |
1/2✓ Branch 0 taken 145345 times.
✗ Branch 1 not taken.
|
145345 | len += vsnprintf(dst + len, size > len ? size - len : 0, fmt, vl); |
110 | 145345 | va_end(vl); | |
111 | |||
112 | 145345 | return len; | |
113 | } | ||
114 | |||
115 | 16303 | char *av_asprintf(const char *fmt, ...) | |
116 | { | ||
117 | 16303 | char *p = NULL; | |
118 | va_list va; | ||
119 | int len; | ||
120 | |||
121 | 16303 | va_start(va, fmt); | |
122 | 16303 | len = vsnprintf(NULL, 0, fmt, va); | |
123 | 16303 | va_end(va); | |
124 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16303 times.
|
16303 | if (len < 0) |
125 | ✗ | goto end; | |
126 | |||
127 | 16303 | p = av_malloc(len + 1); | |
128 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16303 times.
|
16303 | if (!p) |
129 | ✗ | goto end; | |
130 | |||
131 | 16303 | va_start(va, fmt); | |
132 | 16303 | len = vsnprintf(p, len + 1, fmt, va); | |
133 | 16303 | va_end(va); | |
134 |
1/2✓ Branch 0 taken 16303 times.
✗ Branch 1 not taken.
|
16303 | if (len < 0) |
135 | ✗ | av_freep(&p); | |
136 | |||
137 | 16303 | end: | |
138 | 16303 | return p; | |
139 | } | ||
140 | |||
141 | #define WHITESPACES " \n\t\r" | ||
142 | |||
143 | 109757 | char *av_get_token(const char **buf, const char *term) | |
144 | { | ||
145 | 109757 | char *out = av_malloc(strlen(*buf) + 1); | |
146 | 109757 | char *ret = out, *end = out; | |
147 | 109757 | const char *p = *buf; | |
148 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 109757 times.
|
109757 | if (!out) |
149 | ✗ | return NULL; | |
150 | 109757 | p += strspn(p, WHITESPACES); | |
151 | |||
152 |
4/4✓ Branch 0 taken 1105369 times.
✓ Branch 1 taken 41033 times.
✓ Branch 2 taken 1036645 times.
✓ Branch 3 taken 68724 times.
|
1146402 | while (*p && !strspn(p, term)) { |
153 | 1036645 | char c = *p++; | |
154 |
4/4✓ Branch 0 taken 160 times.
✓ Branch 1 taken 1036485 times.
✓ Branch 2 taken 158 times.
✓ Branch 3 taken 2 times.
|
1036645 | if (c == '\\' && *p) { |
155 | 158 | *out++ = *p++; | |
156 | 158 | end = out; | |
157 |
2/2✓ Branch 0 taken 46 times.
✓ Branch 1 taken 1036441 times.
|
1036487 | } else if (c == '\'') { |
158 |
4/4✓ Branch 0 taken 824 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 782 times.
✓ Branch 3 taken 42 times.
|
828 | while (*p && *p != '\'') |
159 | 782 | *out++ = *p++; | |
160 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 4 times.
|
46 | if (*p) { |
161 | 42 | p++; | |
162 | 42 | end = out; | |
163 | } | ||
164 | } else { | ||
165 | 1036441 | *out++ = c; | |
166 | } | ||
167 | } | ||
168 | |||
169 | do | ||
170 | 110223 | *out-- = 0; | |
171 |
4/4✓ Branch 0 taken 108409 times.
✓ Branch 1 taken 1814 times.
✓ Branch 2 taken 466 times.
✓ Branch 3 taken 107943 times.
|
110223 | while (out >= end && strspn(out, WHITESPACES)); |
172 | |||
173 | 109757 | *buf = p; | |
174 | |||
175 | 109757 | return ret; | |
176 | } | ||
177 | |||
178 | 11824 | char *av_strtok(char *s, const char *delim, char **saveptr) | |
179 | { | ||
180 | char *tok; | ||
181 | |||
182 |
4/4✓ Branch 0 taken 9379 times.
✓ Branch 1 taken 2445 times.
✓ Branch 2 taken 901 times.
✓ Branch 3 taken 8478 times.
|
11824 | if (!s && !(s = *saveptr)) |
183 | 901 | return NULL; | |
184 | |||
185 | /* skip leading delimiters */ | ||
186 | 10923 | s += strspn(s, delim); | |
187 | |||
188 | /* s now points to the first non delimiter char, or to the end of the string */ | ||
189 |
2/2✓ Branch 0 taken 133 times.
✓ Branch 1 taken 10790 times.
|
10923 | if (!*s) { |
190 | 133 | *saveptr = NULL; | |
191 | 133 | return NULL; | |
192 | } | ||
193 | 10790 | tok = s++; | |
194 | |||
195 | /* skip non delimiters */ | ||
196 | 10790 | s += strcspn(s, delim); | |
197 |
2/2✓ Branch 0 taken 9029 times.
✓ Branch 1 taken 1761 times.
|
10790 | if (*s) { |
198 | 9029 | *s = 0; | |
199 | 9029 | *saveptr = s+1; | |
200 | } else { | ||
201 | 1761 | *saveptr = NULL; | |
202 | } | ||
203 | |||
204 | 10790 | return tok; | |
205 | } | ||
206 | |||
207 | 587521 | int av_strcasecmp(const char *a, const char *b) | |
208 | { | ||
209 | uint8_t c1, c2; | ||
210 | do { | ||
211 | 647583 | c1 = av_tolower(*a++); | |
212 | 647583 | c2 = av_tolower(*b++); | |
213 |
4/4✓ Branch 0 taken 642770 times.
✓ Branch 1 taken 4813 times.
✓ Branch 2 taken 60062 times.
✓ Branch 3 taken 582708 times.
|
647583 | } while (c1 && c1 == c2); |
214 | 587521 | return c1 - c2; | |
215 | } | ||
216 | |||
217 | 3340546 | int av_strncasecmp(const char *a, const char *b, size_t n) | |
218 | { | ||
219 | uint8_t c1, c2; | ||
220 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3340546 times.
|
3340546 | if (n <= 0) |
221 | ✗ | return 0; | |
222 | do { | ||
223 | 3649329 | c1 = av_tolower(*a++); | |
224 | 3649329 | c2 = av_tolower(*b++); | |
225 |
6/6✓ Branch 0 taken 3609605 times.
✓ Branch 1 taken 39724 times.
✓ Branch 2 taken 3607698 times.
✓ Branch 3 taken 1907 times.
✓ Branch 4 taken 308783 times.
✓ Branch 5 taken 3298915 times.
|
3649329 | } while (--n && c1 && c1 == c2); |
226 | 3340546 | return c1 - c2; | |
227 | } | ||
228 | |||
229 | 4 | char *av_strireplace(const char *str, const char *from, const char *to) | |
230 | { | ||
231 | 4 | char *ret = NULL; | |
232 | 4 | const char *pstr2, *pstr = str; | |
233 | 4 | size_t tolen = strlen(to), fromlen = strlen(from); | |
234 | AVBPrint pbuf; | ||
235 | |||
236 | 4 | av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED); | |
237 |
2/2✓ Branch 1 taken 4 times.
✓ Branch 2 taken 4 times.
|
8 | while ((pstr2 = av_stristr(pstr, from))) { |
238 | 4 | av_bprint_append_data(&pbuf, pstr, pstr2 - pstr); | |
239 | 4 | pstr = pstr2 + fromlen; | |
240 | 4 | av_bprint_append_data(&pbuf, to, tolen); | |
241 | } | ||
242 | 4 | av_bprint_append_data(&pbuf, pstr, strlen(pstr)); | |
243 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
|
4 | if (!av_bprint_is_complete(&pbuf)) { |
244 | ✗ | av_bprint_finalize(&pbuf, NULL); | |
245 | } else { | ||
246 | 4 | av_bprint_finalize(&pbuf, &ret); | |
247 | } | ||
248 | |||
249 | 4 | return ret; | |
250 | } | ||
251 | |||
252 | 121 | const char *av_basename(const char *path) | |
253 | { | ||
254 | char *p; | ||
255 | #if HAVE_DOS_PATHS | ||
256 | char *q, *d; | ||
257 | #endif | ||
258 | |||
259 |
2/4✓ Branch 0 taken 121 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 121 times.
|
121 | if (!path || *path == '\0') |
260 | ✗ | return "."; | |
261 | |||
262 | 121 | 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 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 117 times.
|
121 | if (!p) |
270 | 4 | return path; | |
271 | |||
272 | 117 | return p + 1; | |
273 | } | ||
274 | |||
275 | 22 | const char *av_dirname(char *path) | |
276 | { | ||
277 |
1/2✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
|
22 | 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 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 20 times.
|
22 | if (!p) |
289 | 2 | return "."; | |
290 | |||
291 | 20 | *p = '\0'; | |
292 | |||
293 | 20 | return path; | |
294 | } | ||
295 | |||
296 | 8 | char *av_append_path_component(const char *path, const char *component) | |
297 | { | ||
298 | size_t p_len, c_len; | ||
299 | char *fullpath; | ||
300 | |||
301 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
|
8 | if (!path) |
302 | 2 | return av_strdup(component); | |
303 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
|
6 | if (!component) |
304 | 1 | return av_strdup(path); | |
305 | |||
306 | 5 | p_len = strlen(path); | |
307 | 5 | c_len = strlen(component); | |
308 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
|
5 | if (p_len > SIZE_MAX - c_len || p_len + c_len > SIZE_MAX - 2) |
309 | ✗ | return NULL; | |
310 | 5 | fullpath = av_malloc(p_len + c_len + 2); | |
311 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (fullpath) { |
312 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (p_len) { |
313 | 5 | av_strlcpy(fullpath, path, p_len + 1); | |
314 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (c_len) { |
315 |
4/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
|
5 | if (fullpath[p_len - 1] != '/' && component[0] != '/') |
316 | 1 | fullpath[p_len++] = '/'; | |
317 |
4/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
|
4 | else if (fullpath[p_len - 1] == '/' && component[0] == '/') |
318 | 2 | p_len--; | |
319 | } | ||
320 | } | ||
321 | 5 | av_strlcpy(&fullpath[p_len], component, c_len + 1); | |
322 | 5 | fullpath[p_len + c_len] = 0; | |
323 | } | ||
324 | 5 | 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 | 7404370 | int av_match_name(const char *name, const char *names) | |
346 | { | ||
347 | const char *p; | ||
348 | size_t len, namelen; | ||
349 | |||
350 |
4/4✓ Branch 0 taken 4840721 times.
✓ Branch 1 taken 2563649 times.
✓ Branch 2 taken 1928320 times.
✓ Branch 3 taken 2912401 times.
|
7404370 | if (!name || !names) |
351 | 4491969 | return 0; | |
352 | |||
353 | 2912401 | namelen = strlen(name); | |
354 |
2/2✓ Branch 0 taken 3323138 times.
✓ Branch 1 taken 2896930 times.
|
6220068 | while (*names) { |
355 | 3323138 | int negate = '-' == *names; | |
356 | 3323138 | p = strchr(names, ','); | |
357 |
2/2✓ Branch 0 taken 2911386 times.
✓ Branch 1 taken 411752 times.
|
3323138 | if (!p) |
358 | 2911386 | p = names + strlen(names); | |
359 | 3323138 | names += negate; | |
360 | 3323138 | len = FFMAX(p - names, namelen); | |
361 |
3/4✓ Branch 1 taken 3307667 times.
✓ Branch 2 taken 15471 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3307667 times.
|
3323138 | if (!av_strncasecmp(name, names, len) || !strncmp("ALL", names, FFMAX(3, p - names))) |
362 | 15471 | return !negate; | |
363 | 3307667 | names = p + (*p == ','); | |
364 | } | ||
365 | 2896930 | return 0; | |
366 | } | ||
367 | |||
368 | 92972 | int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end, | |
369 | unsigned int flags) | ||
370 | { | ||
371 | 92972 | const uint8_t *p = *bufp; | |
372 | uint32_t top; | ||
373 | uint64_t code; | ||
374 | 92972 | int ret = 0, tail_len; | |
375 | 92972 | uint32_t overlong_encoding_mins[6] = { | |
376 | 0x00000000, 0x00000080, 0x00000800, 0x00010000, 0x00200000, 0x04000000, | ||
377 | }; | ||
378 | |||
379 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 92972 times.
|
92972 | if (p >= buf_end) |
380 | ✗ | return 0; | |
381 | |||
382 | 92972 | code = *p++; | |
383 | |||
384 | /* first sequence byte starts with 10, or is 1111-1110 or 1111-1111, | ||
385 | which is not admitted */ | ||
386 |
2/4✓ Branch 0 taken 92972 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 92972 times.
|
92972 | if ((code & 0xc0) == 0x80 || code >= 0xFE) { |
387 | ✗ | ret = AVERROR(EILSEQ); | |
388 | ✗ | goto end; | |
389 | } | ||
390 | 92972 | top = (code & 128) >> 1; | |
391 | |||
392 | 92972 | tail_len = 0; | |
393 |
2/2✓ Branch 0 taken 450 times.
✓ Branch 1 taken 92972 times.
|
93422 | while (code & top) { |
394 | int tmp; | ||
395 | 450 | tail_len++; | |
396 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 450 times.
|
450 | 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 | 450 | tmp = *p++ - 128; /* strip leading 1 */ | |
403 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 450 times.
|
450 | if (tmp>>6) { |
404 | ✗ | (*bufp) ++; | |
405 | ✗ | return AVERROR(EILSEQ); | |
406 | } | ||
407 | 450 | code = (code<<6) + tmp; | |
408 | 450 | top <<= 5; | |
409 | } | ||
410 | 92972 | code &= (top << 1) - 1; | |
411 | |||
412 | /* check for overlong encodings */ | ||
413 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 92972 times.
|
92972 | av_assert0(tail_len <= 5); |
414 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 92972 times.
|
92972 | if (code < overlong_encoding_mins[tail_len]) { |
415 | ✗ | ret = AVERROR(EILSEQ); | |
416 | ✗ | goto end; | |
417 | } | ||
418 | |||
419 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 92972 times.
|
92972 | if (code >= 1U<<31) { |
420 | ✗ | ret = AVERROR(EILSEQ); /* out-of-range value */ | |
421 | ✗ | goto end; | |
422 | } | ||
423 | |||
424 | 92972 | *codep = code; | |
425 | |||
426 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 92972 times.
|
92972 | if (code > 0x10FFFF && |
427 | ✗ | !(flags & AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES)) | |
428 | ✗ | ret = AVERROR(EILSEQ); | |
429 |
6/8✓ Branch 0 taken 499 times.
✓ Branch 1 taken 92473 times.
✓ Branch 2 taken 499 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 91 times.
✓ Branch 5 taken 408 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 91 times.
|
92972 | if (code < 0x20 && code != 0x9 && code != 0xA && code != 0xD && |
430 | ✗ | flags & AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES) | |
431 | ✗ | ret = AVERROR(EILSEQ); | |
432 |
3/4✓ Branch 0 taken 153 times.
✓ Branch 1 taken 92819 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 153 times.
|
92972 | if (code >= 0xD800 && code <= 0xDFFF && |
433 | ✗ | !(flags & AV_UTF8_FLAG_ACCEPT_SURROGATES)) | |
434 | ✗ | ret = AVERROR(EILSEQ); | |
435 |
2/4✓ Branch 0 taken 92972 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 92972 times.
✗ Branch 3 not taken.
|
92972 | if ((code == 0xFFFE || code == 0xFFFF) && |
436 | ✗ | !(flags & AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS)) | |
437 | ✗ | ret = AVERROR(EILSEQ); | |
438 | |||
439 | 92972 | end: | |
440 | 92972 | *bufp = p; | |
441 | 92972 | return ret; | |
442 | } | ||
443 | |||
444 | 137 | int av_match_list(const char *name, const char *list, char separator) | |
445 | { | ||
446 | const char *p, *q; | ||
447 | |||
448 |
2/4✓ Branch 0 taken 137 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 137 times.
✗ Branch 3 not taken.
|
137 | for (p = name; p && *p; ) { |
449 |
2/4✓ Branch 0 taken 141 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 141 times.
✗ Branch 3 not taken.
|
141 | for (q = list; q && *q; ) { |
450 | int k; | ||
451 |
5/6✓ Branch 0 taken 548 times.
✓ Branch 1 taken 141 times.
✓ Branch 2 taken 137 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 137 times.
✗ Branch 5 not taken.
|
689 | for (k = 0; p[k] == q[k] || (p[k]*q[k] == 0 && p[k]+q[k] == separator); k++) |
452 |
5/6✓ Branch 0 taken 548 times.
✓ Branch 1 taken 137 times.
✓ Branch 2 taken 411 times.
✓ Branch 3 taken 137 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 411 times.
|
685 | if (k && (!p[k] || p[k] == separator)) |
453 | 137 | return 1; | |
454 | 4 | q = strchr(q, separator); | |
455 | 4 | q += !!q; | |
456 | } | ||
457 | ✗ | p = strchr(p, separator); | |
458 | ✗ | p += !!p; | |
459 | } | ||
460 | |||
461 | ✗ | return 0; | |
462 | } | ||
463 |