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 <stdarg.h>

23 #include <stdint.h>

24 #include <stdio.h>

25 #include <string.h>

27 #include "config.h"

28 #include "common.h"

29 #include "mem.h"

30 #include "avassert.h"

31 #include "avstring.h"

32 #include "bprint.h"

34 int av_strstart(const char *str, const char *pfx, const char **ptr)

35 {

36 while (*pfx && *pfx == *str) {

37 pfx++;

38 str++;

39 }

40 if (!*pfx && ptr)

41 *ptr = str;

42 return !*pfx;

43 }

45 int av_stristart(const char *str, const char *pfx, const char **ptr)

46 {

47 while (*pfx && av_toupper((unsigned)*pfx) == av_toupper((unsigned)*str)) {

48 pfx++;

49 str++;

50 }

51 if (!*pfx && ptr)

52 *ptr = str;

53 return !*pfx;

54 }

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

57 {

58 if (!*s2)

59 return (char*)(intptr_t)s1;

61 do

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

63 return (char*)(intptr_t)s1;

64 while (*s1++);

66 return NULL;

67 }

69 char *av_strnstr(const char *haystack, const char *needle, size_t hay_length)

70 {

71 size_t needle_len = strlen(needle);

72 if (!needle_len)

73 return (char*)haystack;

74 while (hay_length >= needle_len) {

75 hay_length--;

76 if (!memcmp(haystack, needle, needle_len))

77 return (char*)haystack;

78 haystack++;

79 }

80 return NULL;

81 }

83 size_t av_strlcpy(char *dst, const char *src, size_t size)

84 {

85 size_t len = 0;

86 while (++len < size && *src)

87 *dst++ = *src++;

88 if (len <= size)

89 *dst = 0;

90 return len + strlen(src) - 1;

91 }

93 size_t av_strlcat(char *dst, const char *src, size_t size)

94 {

95 size_t len = strlen(dst);

96 if (size <= len + 1)

97 return len + strlen(src);

98 return len + av_strlcpy(dst + len, src, size - len);

99 }

100

101 size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...)

102 {

103 size_t len = strlen(dst);

104 va_list vl;

105

106 va_start(vl, fmt);

107 len += vsnprintf(dst + len, size > len ? size - len : 0, fmt, vl);

108 va_end(vl);

109

110 return len;

111 }

112

113 char *av_asprintf(const char *fmt, ...)

114 {

115 char *p = NULL;

116 va_list va;

117 int len;

118

119 va_start(va, fmt);

120 len = vsnprintf(NULL, 0, fmt, va);

121 va_end(va);

122 if (len < 0)

123 goto end;

124

125 p = av_malloc(len + 1);

126 if (!p)

127 goto end;

128

129 va_start(va, fmt);

130 len = vsnprintf(p, len + 1, fmt, va);

131 va_end(va);

132 if (len < 0)

133 av_freep(&p);

134

135 end:

136 return p;

137 }

138

139 #if FF_API_D2STR

140 char *av_d2str(double d)

141 {

142 char *str = av_malloc(16);

143 if (str)

144 snprintf(str, 16, "%f", d);

145 return str;

146 }

147 #endif

148

149 #define WHITESPACES " \n\t\r"

150

151 char *av_get_token(const char **buf, const char *term)

152 {

153 char *out = av_malloc(strlen(*buf) + 1);

154 char *ret = out, *end = out;

155 const char *p = *buf;

156 if (!out)

157 return NULL;

158 p += strspn(p, WHITESPACES);

159

160 while (*p && !strspn(p, term)) {

161 char c = *p++;

162 if (c == '\\' && *p) {

163 *out++ = *p++;

164 end = out;

165 } else if (c == '\'') {

166 while (*p && *p != '\'')

167 *out++ = *p++;

168 if (*p) {

169 p++;

170 end = out;

171 }

172 } else {

173 *out++ = c;

174 }

175 }

176

177 do

178 *out-- = 0;

179 while (out >= end && strspn(out, WHITESPACES));

180

181 *buf = p;

182

183 return ret;

184 }

185

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

187 {

188 char *tok;

189

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

191 return NULL;

192

193 /* skip leading delimiters */

194 s += strspn(s, delim);

195

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

197 if (!*s) {

198 *saveptr = NULL;

199 return NULL;

200 }

201 tok = s++;

202

203 /* skip non delimiters */

204 s += strcspn(s, delim);

205 if (*s) {

206 *s = 0;

207 *saveptr = s+1;

208 } else {

209 *saveptr = NULL;

210 }

211

212 return tok;

213 }

214

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

216 {

217 uint8_t c1, c2;

218 do {

219 c1 = av_tolower(*a++);

220 c2 = av_tolower(*b++);

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

222 return c1 - c2;

223 }

224

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

226 {

227 uint8_t c1, c2;

228 if (n <= 0)

229 return 0;

230 do {

231 c1 = av_tolower(*a++);

232 c2 = av_tolower(*b++);

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

234 return c1 - c2;

235 }

236

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

238 {

239 char *ret = NULL;

240 const char *pstr2, *pstr = str;

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

242 AVBPrint pbuf;

243

244 av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);

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

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

247 pstr = pstr2 + fromlen;

248 av_bprint_append_data(&pbuf, to, tolen);

249 }

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

251 if (!av_bprint_is_complete(&pbuf)) {

252 av_bprint_finalize(&pbuf, NULL);

253 } else {

254 av_bprint_finalize(&pbuf, &ret);

255 }

256

257 return ret;

258 }

259

260 const char *av_basename(const char *path)

261 {

262 char *p;

263 #if HAVE_DOS_PATHS

264 char *q, *d;

265 #endif

266

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

268 return ".";

269

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

271 #if HAVE_DOS_PATHS

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

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

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

275 #endif

276

277 if (!p)

278 return path;

279

280 return p + 1;

281 }

282

283 const char *av_dirname(char *path)

284 {

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

286

287 #if HAVE_DOS_PATHS

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

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

290

291 d = d ? d + 1 : d;

292

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

294 #endif

295

296 if (!p)

297 return ".";

298

299 *p = '0円';

300

301 return path;

302 }

303

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

305 {

306 size_t p_len, c_len;

307 char *fullpath;

308

309 if (!path)

310 return av_strdup(component);

311 if (!component)

312 return av_strdup(path);

313

314 p_len = strlen(path);

315 c_len = strlen(component);

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

317 return NULL;

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

319 if (fullpath) {

320 if (p_len) {

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

322 if (c_len) {

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

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

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

326 p_len--;

327 }

328 }

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

330 fullpath[p_len + c_len] = 0;

331 }

332 return fullpath;

333 }

334

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

336 enum AVEscapeMode mode, int flags)

337 {

338 AVBPrint dstbuf;

339 int ret;

340

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

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

343

344 if (!av_bprint_is_complete(&dstbuf)) {

345 av_bprint_finalize(&dstbuf, NULL);

346 return AVERROR(ENOMEM);

347 }

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

349 return ret;

350 return dstbuf.len;

351 }

352

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

354 {

355 const char *p;

356 int len, namelen;

357

358 if (!name || !names)

359 return 0;

360

361 namelen = strlen(name);

362 while (*names) {

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

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

365 if (!p)

366 p = names + strlen(names);

367 names += negate;

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

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

370 return !negate;

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

372 }

373 return 0;

374 }

375

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

377 unsigned int flags)

378 {

379 const uint8_t *p = *bufp;

380 uint32_t top;

381 uint64_t code;

382 int ret = 0, tail_len;

383 uint32_t overlong_encoding_mins[6] = {

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

385 };

386

387 if (p >= buf_end)

388 return 0;

389

390 code = *p++;

391

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

393 which is not admitted */

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

395 ret = AVERROR(EILSEQ);

396 goto end;

397 }

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

399

400 tail_len = 0;

401 while (code & top) {

402 int tmp;

403 tail_len++;

404 if (p >= buf_end) {

405 (*bufp) ++;

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

407 }

408

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

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

411 if (tmp>>6) {

412 (*bufp) ++;

413 return AVERROR(EILSEQ);

414 }

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

416 top <<= 5;

417 }

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

419

420 /* check for overlong encodings */

421 av_assert0(tail_len <= 5);

422 if (code < overlong_encoding_mins[tail_len]) {

423 ret = AVERROR(EILSEQ);

424 goto end;

425 }

426

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

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

429 goto end;

430 }

431

432 *codep = code;

433

434 if (code > 0x10FFFF &&

435 !(flags & AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES))

436 ret = AVERROR(EILSEQ);

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

438 flags & AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES)

439 ret = AVERROR(EILSEQ);

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

441 !(flags & AV_UTF8_FLAG_ACCEPT_SURROGATES))

442 ret = AVERROR(EILSEQ);

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

444 !(flags & AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS))

445 ret = AVERROR(EILSEQ);

446

447 end:

448 *bufp = p;

449 return ret;

450 }

451

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

453 {

454 const char *p, *q;

455

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

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

458 int k;

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

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

461 return 1;

462 q = strchr(q, separator);

463 q += !!q;

464 }

465 p = strchr(p, separator);

466 p += !!p;

467 }

468

469 return 0;

470 }

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

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

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

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

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

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

av_strcasecmp

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

Locale-independent case-insensitive compare.

Definition: avstring.c:215

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

#define b

Definition: input.c:40

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

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

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

av_basename

const char * av_basename(const char *path)

Thread safe basename.

Definition: avstring.c:260

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

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

#define U(x)

Definition: vp56_arith.h:37

av_dirname

const char * av_dirname(char *path)

Thread safe dirname.

Definition: avstring.c:283

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

#define s(width, name)

Definition: cbs_vp9.c:257

#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:186

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

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

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

av_strireplace

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

Locale-independent strings replace.

Definition: avstring.c:237

src

#define src

Definition: vp8dsp.c:255

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

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

FFFILE::buf

unsigned char * buf

Definition: avsscanf.c:37

av_strncasecmp

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

Locale-independent case-insensitive compare.

Definition: avstring.c:225

#define s2

Definition: regdef.h:39

size

int size

Definition: twinvq_data.h:10344

WHITESPACES

#define WHITESPACES

Definition: avstring.c:149

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

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

common.h

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