FFmpeg: libavutil/avstring.c Source File

FFmpeg

[フレーム]

libavutil

avstring.c

Go to the documentation of this file.

1 /*

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 */

22 #include <limits.h>

23 #include <stdarg.h>

24 #include <stdint.h>

25 #include <stdio.h>

26 #include <string.h>

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"

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 }

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 }

58 char *av_stristr(const char *s1, const char *s2)

59 {

60 if (!*s2)

61 return (char*)(intptr_t)s1;

63 do

64 if (av_stristart(s1, s2, NULL))

65 return (char*)(intptr_t)s1;

66 while (*s1++);

68 return NULL;

69 }

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 }

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 }

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

236 av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);

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 size_t 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 &&

427 !(flags & AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES))

428 ret = AVERROR(EILSEQ);

429 if (code < 0x20 && code != 0x9 && code != 0xA && code != 0xD &&

430 flags & AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES)

431 ret = AVERROR(EILSEQ);

432 if (code >= 0xD800 && code <= 0xDFFF &&

433 !(flags & AV_UTF8_FLAG_ACCEPT_SURROGATES))

434 ret = AVERROR(EILSEQ);

435 if ((code == 0xFFFE || code == 0xFFFF) &&

436 !(flags & AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS))

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

#define b

Definition: input.c:41

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

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

#define s(width, name)

Definition: cbs_vp9.c:198

#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

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

Definition: filter_design.txt:25

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

#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

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