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_realloc(NULL, 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 char *small_ret = av_realloc(ret, out - ret + 2);

176 return small_ret ? small_ret : ret;

177 }

178

179 char *av_strtok(char *s, const char *delim, char **saveptr)

180 {

181 char *tok;

182

183 if (!s && !(s = *saveptr))

184 return NULL;

185

186 /* skip leading delimiters */

187 s += strspn(s, delim);

188

189 /* s now points to the first non delimiter char, or to the end of the string */

190 if (!*s) {

191 *saveptr = NULL;

192 return NULL;

193 }

194 tok = s++;

195

196 /* skip non delimiters */

197 s += strcspn(s, delim);

198 if (*s) {

199 *s = 0;

200 *saveptr = s+1;

201 } else {

202 *saveptr = NULL;

203 }

204

205 return tok;

206 }

207

208 int av_strcasecmp(const char *a, const char *b)

209 {

210 uint8_t c1, c2;

211 do {

212 c1 = av_tolower(*a++);

213 c2 = av_tolower(*b++);

214 } while (c1 && c1 == c2);

215 return c1 - c2;

216 }

217

218 int av_strncasecmp(const char *a, const char *b, size_t n)

219 {

220 uint8_t c1, c2;

221 if (n <= 0)

222 return 0;

223 do {

224 c1 = av_tolower(*a++);

225 c2 = av_tolower(*b++);

226 } while (--n && c1 && c1 == c2);

227 return c1 - c2;

228 }

229

230 char *av_strireplace(const char *str, const char *from, const char *to)

231 {

232 char *ret = NULL;

233 const char *pstr2, *pstr = str;

234 size_t tolen = strlen(to), fromlen = strlen(from);

235 AVBPrint pbuf;

236

237 av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);

238 while ((pstr2 = av_stristr(pstr, from))) {

239 av_bprint_append_data(&pbuf, pstr, pstr2 - pstr);

240 pstr = pstr2 + fromlen;

241 av_bprint_append_data(&pbuf, to, tolen);

242 }

243 av_bprint_append_data(&pbuf, pstr, strlen(pstr));

244 if (!av_bprint_is_complete(&pbuf)) {

245 av_bprint_finalize(&pbuf, NULL);

246 } else {

247 av_bprint_finalize(&pbuf, &ret);

248 }

249

250 return ret;

251 }

252

253 const char *av_basename(const char *path)

254 {

255 char *p;

256 #if HAVE_DOS_PATHS

257 char *q, *d;

258 #endif

259

260 if (!path || *path == '0円')

261 return ".";

262

263 p = strrchr(path, '/');

264 #if HAVE_DOS_PATHS

265 q = strrchr(path, '\\');

266 d = strchr(path, ':');

267 p = FFMAX3(p, q, d);

268 #endif

269

270 if (!p)

271 return path;

272

273 return p + 1;

274 }

275

276 const char *av_dirname(char *path)

277 {

278 char *p = path ? strrchr(path, '/') : NULL;

279

280 #if HAVE_DOS_PATHS

281 char *q = path ? strrchr(path, '\\') : NULL;

282 char *d = path ? strchr(path, ':') : NULL;

283

284 d = d ? d + 1 : d;

285

286 p = FFMAX3(p, q, d);

287 #endif

288

289 if (!p)

290 return ".";

291

292 *p = '0円';

293

294 return path;

295 }

296

297 char *av_append_path_component(const char *path, const char *component)

298 {

299 size_t p_len, c_len;

300 char *fullpath;

301

302 if (!path)

303 return av_strdup(component);

304 if (!component)

305 return av_strdup(path);

306

307 p_len = strlen(path);

308 c_len = strlen(component);

309 if (p_len > SIZE_MAX - c_len || p_len + c_len > SIZE_MAX - 2)

310 return NULL;

311 fullpath = av_malloc(p_len + c_len + 2);

312 if (fullpath) {

313 if (p_len) {

314 av_strlcpy(fullpath, path, p_len + 1);

315 if (c_len) {

316 if (fullpath[p_len - 1] != '/' && component[0] != '/')

317 fullpath[p_len++] = '/';

318 else if (fullpath[p_len - 1] == '/' && component[0] == '/')

319 p_len--;

320 }

321 }

322 av_strlcpy(&fullpath[p_len], component, c_len + 1);

323 fullpath[p_len + c_len] = 0;

324 }

325 return fullpath;

326 }

327

328 int av_escape(char **dst, const char *src, const char *special_chars,

329 enum AVEscapeMode mode, int flags)

330 {

331 AVBPrint dstbuf;

332 int ret;

333

334 av_bprint_init(&dstbuf, 1, INT_MAX); /* (int)dstbuf.len must be >= 0 */

335 av_bprint_escape(&dstbuf, src, special_chars, mode, flags);

336

337 if (!av_bprint_is_complete(&dstbuf)) {

338 av_bprint_finalize(&dstbuf, NULL);

339 return AVERROR(ENOMEM);

340 }

341 if ((ret = av_bprint_finalize(&dstbuf, dst)) < 0)

342 return ret;

343 return dstbuf.len;

344 }

345

346 int av_match_name(const char *name, const char *names)

347 {

348 const char *p;

349 size_t len, namelen;

350

351 if (!name || !names)

352 return 0;

353

354 namelen = strlen(name);

355 while (*names) {

356 int negate = '-' == *names;

357 p = strchr(names, ',');

358 if (!p)

359 p = names + strlen(names);

360 names += negate;

361 len = FFMAX(p - names, namelen);

362 if (!av_strncasecmp(name, names, len) || !strncmp("ALL", names, FFMAX(3, p - names)))

363 return !negate;

364 names = p + (*p == ',');

365 }

366 return 0;

367 }

368

369 int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,

370 unsigned int flags)

371 {

372 const uint8_t *p = *bufp;

373 uint32_t top;

374 uint64_t code;

375 int ret = 0, tail_len;

376 uint32_t overlong_encoding_mins[6] = {

377 0x00000000, 0x00000080, 0x00000800, 0x00010000, 0x00200000, 0x04000000,

378 };

379

380 if (p >= buf_end)

381 return 0;

382

383 code = *p++;

384

385 /* first sequence byte starts with 10, or is 1111-1110 or 1111-1111,

386 which is not admitted */

387 if ((code & 0xc0) == 0x80 || code >= 0xFE) {

388 ret = AVERROR(EILSEQ);

389 goto end;

390 }

391 top = (code & 128) >> 1;

392

393 tail_len = 0;

394 while (code & top) {

395 int tmp;

396 tail_len++;

397 if (p >= buf_end) {

398 (*bufp) ++;

399 return AVERROR(EILSEQ); /* incomplete sequence */

400 }

401

402 /* we assume the byte to be in the form 10xx-xxxx */

403 tmp = *p++ - 128; /* strip leading 1 */

404 if (tmp>>6) {

405 (*bufp) ++;

406 return AVERROR(EILSEQ);

407 }

408 code = (code<<6) + tmp;

409 top <<= 5;

410 }

411 code &= (top << 1) - 1;

412

413 /* check for overlong encodings */

414 av_assert0(tail_len <= 5);

415 if (code < overlong_encoding_mins[tail_len]) {

416 ret = AVERROR(EILSEQ);

417 goto end;

418 }

419

420 if (code >= 1U<<31) {

421 ret = AVERROR(EILSEQ); /* out-of-range value */

422 goto end;

423 }

424

425 *codep = code;

426

427 if (code > 0x10FFFF &&

428 !(flags & AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES))

429 ret = AVERROR(EILSEQ);

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

431 flags & AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES)

432 ret = AVERROR(EILSEQ);

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

434 !(flags & AV_UTF8_FLAG_ACCEPT_SURROGATES))

435 ret = AVERROR(EILSEQ);

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

437 !(flags & AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS))

438 ret = AVERROR(EILSEQ);

439

440 end:

441 *bufp = p;

442 return ret;

443 }

444

445 int av_match_list(const char *name, const char *list, char separator)

446 {

447 const char *p, *q;

448

449 for (p = name; p && *p; ) {

450 for (q = list; q && *q; ) {

451 int k;

452 for (k = 0; p[k] == q[k] || (p[k]*q[k] == 0 && p[k]+q[k] == separator); k++)

453 if (k && (!p[k] || p[k] == separator))

454 return 1;

455 q = strchr(q, separator);

456 if(q)

457 q++;

458 }

459 p = strchr(p, separator);

460 if (p)

461 p++;

462 }

463

464 return 0;

465 }

flags

const SwsFlags flags[]

Definition: swscale.c:61

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:369

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:55

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:208

mode

Definition: swscale.c:56

#define b

Definition: input.c:42

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:253

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

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:297

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:328

macros.h

av_dirname

const char * av_dirname(char *path)

Thread safe dirname.

Definition: avstring.c:276

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

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:179

from

const char * from

Definition: jacosubdec.c:66

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

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

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

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:445

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

av_strireplace

char * av_strireplace(const char *str, const char *from, const char *to)

Locale-independent strings replace.

Definition: avstring.c:230

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:218

const char * to

Definition: webvttdec.c:35

av_bprint_finalize

int av_bprint_finalize(AVBPrint *buf, char **ret_str)

Finalize a print buffer.

Definition: bprint.c:235

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

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