FFmpeg: libavformat/utils.c Source File

FFmpeg

[フレーム]

libavformat

utils.c

Go to the documentation of this file.

1 /*

2 * various utility functions for use within FFmpeg

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

24 #include "config.h"

26 #include "libavutil/avstring.h"

27 #include "libavutil/bprint.h"

28 #include "libavutil/internal.h"

29 #include "libavutil/thread.h"

30 #include "libavutil/time.h"

32 #include "libavcodec/internal.h"

34 #include "avformat.h"

35 #include "avio_internal.h"

36 #include "internal.h"

37 #if CONFIG_NETWORK

38 #include "network.h"

39 #endif

41 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;

43 /**

44 * @file

45 * various utility functions for use within FFmpeg

46 */

48 int ff_lock_avformat(void)

49 {

50 return ff_mutex_lock(&avformat_mutex) ? -1 : 0;

51 }

53 int ff_unlock_avformat(void)

54 {

55 return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;

56 }

58 /* an arbitrarily chosen "sane" max packet size -- 50M */

59 #define SANE_CHUNK_SIZE (50000000)

61 /* Read the data in sane-sized chunks and append to pkt.

62 * Return the number of bytes read or an error. */

63 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)

64 {

65 int orig_size = pkt->size;

66 int ret;

68 do {

69 int prev_size = pkt->size;

70 int read_size;

72 /* When the caller requests a lot of data, limit it to the amount

73 * left in file or SANE_CHUNK_SIZE when it is not known. */

74 read_size = size;

75 if (read_size > SANE_CHUNK_SIZE/10) {

76 read_size = ffio_limit(s, read_size);

77 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE

78 if (ffiocontext(s)->maxsize < 0)

79 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);

80 }

82 ret = av_grow_packet(pkt, read_size);

83 if (ret < 0)

84 break;

86 ret = avio_read(s, pkt->data + prev_size, read_size);

87 if (ret != read_size) {

88 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));

89 break;

90 }

92 size -= read_size;

93 } while (size > 0);

94 if (size > 0)

95 pkt->flags |= AV_PKT_FLAG_CORRUPT;

97 if (!pkt->size)

98 av_packet_unref(pkt);

99 return pkt->size > orig_size ? pkt->size - orig_size : ret;

100 }

101

102 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

103 {

104 #if FF_API_INIT_PACKET

105 FF_DISABLE_DEPRECATION_WARNINGS

106 av_init_packet(pkt);

107 pkt->data = NULL;

108 pkt->size = 0;

109 FF_ENABLE_DEPRECATION_WARNINGS

110 #else

111 av_packet_unref(pkt);

112 #endif

113 pkt->pos = avio_tell(s);

114

115 return append_packet_chunked(s, pkt, size);

116 }

117

118 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)

119 {

120 if (!pkt->size)

121 return av_get_packet(s, pkt, size);

122 return append_packet_chunked(s, pkt, size);

123 }

124

125 int av_filename_number_test(const char *filename)

126 {

127 char buf[1024];

128 return filename &&

129 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);

130 }

131

132 /**********************************************************/

133

134 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)

135 {

136 while (tags->id != AV_CODEC_ID_NONE) {

137 if (tags->id == id)

138 return tags->tag;

139 tags++;

140 }

141 return 0;

142 }

143

144 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)

145 {

146 for (int i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)

147 if (tag == tags[i].tag)

148 return tags[i].id;

149 for (int i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)

150 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))

151 return tags[i].id;

152 return AV_CODEC_ID_NONE;

153 }

154

155 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)

156 {

157 if (bps <= 0 || bps > 64)

158 return AV_CODEC_ID_NONE;

159

160 if (flt) {

161 switch (bps) {

162 case 32:

163 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;

164 case 64:

165 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;

166 default:

167 return AV_CODEC_ID_NONE;

168 }

169 } else {

170 bps += 7;

171 bps >>= 3;

172 if (sflags & (1 << (bps - 1))) {

173 switch (bps) {

174 case 1:

175 return AV_CODEC_ID_PCM_S8;

176 case 2:

177 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;

178 case 3:

179 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;

180 case 4:

181 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;

182 case 8:

183 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;

184 default:

185 return AV_CODEC_ID_NONE;

186 }

187 } else {

188 switch (bps) {

189 case 1:

190 return AV_CODEC_ID_PCM_U8;

191 case 2:

192 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;

193 case 3:

194 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;

195 case 4:

196 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;

197 default:

198 return AV_CODEC_ID_NONE;

199 }

200 }

201 }

202 }

203

204 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)

205 {

206 unsigned int tag;

207 if (!av_codec_get_tag2(tags, id, &tag))

208 return 0;

209 return tag;

210 }

211

212 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,

213 unsigned int *tag)

214 {

215 for (int i = 0; tags && tags[i]; i++) {

216 const AVCodecTag *codec_tags = tags[i];

217 while (codec_tags->id != AV_CODEC_ID_NONE) {

218 if (codec_tags->id == id) {

219 *tag = codec_tags->tag;

220 return 1;

221 }

222 codec_tags++;

223 }

224 }

225 return 0;

226 }

227

228 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)

229 {

230 for (int i = 0; tags && tags[i]; i++) {

231 enum AVCodecID id = ff_codec_get_id(tags[i], tag);

232 if (id != AV_CODEC_ID_NONE)

233 return id;

234 }

235 return AV_CODEC_ID_NONE;

236 }

237

238 int ff_alloc_extradata(AVCodecParameters *par, int size)

239 {

240 av_freep(&par->extradata);

241 par->extradata_size = 0;

242

243 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)

244 return AVERROR(EINVAL);

245

246 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);

247 if (!par->extradata)

248 return AVERROR(ENOMEM);

249

250 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

251 par->extradata_size = size;

252

253 return 0;

254 }

255

256 /*******************************************************/

257

258 uint64_t ff_ntp_time(void)

259 {

260 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;

261 }

262

263 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)

264 {

265 uint64_t ntp_ts, frac_part, sec;

266 uint32_t usec;

267

268 //current ntp time in seconds and micro seconds

269 sec = ntp_time_us / 1000000;

270 usec = ntp_time_us % 1000000;

271

272 //encoding in ntp timestamp format

273 frac_part = usec * 0xFFFFFFFFULL;

274 frac_part /= 1000000;

275

276 if (sec > 0xFFFFFFFFULL)

277 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");

278

279 ntp_ts = sec << 32;

280 ntp_ts |= frac_part;

281

282 return ntp_ts;

283 }

284

285 uint64_t ff_parse_ntp_time(uint64_t ntp_ts)

286 {

287 uint64_t sec = ntp_ts >> 32;

288 uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;

289 uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;

290

291 return (sec * 1000000) + usec;

292 }

293

294 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)

295 {

296 const char *p;

297 char *q, buf1[20], c;

298 int nd, len, percentd_found;

299

300 q = buf;

301 p = path;

302 percentd_found = 0;

303 for (;;) {

304 c = *p++;

305 if (c == '0円')

306 break;

307 if (c == '%') {

308 do {

309 nd = 0;

310 while (av_isdigit(*p)) {

311 if (nd >= INT_MAX / 10 - 255)

312 goto fail;

313 nd = nd * 10 + *p++ - '0';

314 }

315 c = *p++;

316 } while (av_isdigit(c));

317

318 switch (c) {

319 case '%':

320 goto addchar;

321 case 'd':

322 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)

323 goto fail;

324 percentd_found = 1;

325 if (number < 0)

326 nd += 1;

327 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);

328 len = strlen(buf1);

329 if ((q - buf + len) > buf_size - 1)

330 goto fail;

331 memcpy(q, buf1, len);

332 q += len;

333 break;

334 default:

335 goto fail;

336 }

337 } else {

338 addchar:

339 if ((q - buf) < buf_size - 1)

340 *q++ = c;

341 }

342 }

343 if (!percentd_found)

344 goto fail;

345 *q = '0円';

346 return 0;

347 fail:

348 *q = '0円';

349 return -1;

350 }

351

352 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)

353 {

354 return av_get_frame_filename2(buf, buf_size, path, number, 0);

355 }

356

357 void av_url_split(char *proto, int proto_size,

358 char *authorization, int authorization_size,

359 char *hostname, int hostname_size,

360 int *port_ptr, char *path, int path_size, const char *url)

361 {

362 const char *p, *ls, *at, *at2, *col, *brk;

363

364 if (port_ptr)

365 *port_ptr = -1;

366 if (proto_size > 0)

367 proto[0] = 0;

368 if (authorization_size > 0)

369 authorization[0] = 0;

370 if (hostname_size > 0)

371 hostname[0] = 0;

372 if (path_size > 0)

373 path[0] = 0;

374

375 /* parse protocol */

376 if ((p = strchr(url, ':'))) {

377 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));

378 p++; /* skip ':' */

379 if (*p == '/')

380 p++;

381 if (*p == '/')

382 p++;

383 } else {

384 /* no protocol means plain filename */

385 av_strlcpy(path, url, path_size);

386 return;

387 }

388

389 /* separate path from hostname */

390 ls = p + strcspn(p, "/?#");

391 av_strlcpy(path, ls, path_size);

392

393 /* the rest is hostname, use that to parse auth/port */

394 if (ls != p) {

395 /* authorization (user[:pass]@hostname) */

396 at2 = p;

397 while ((at = strchr(p, '@')) && at < ls) {

398 av_strlcpy(authorization, at2,

399 FFMIN(authorization_size, at + 1 - at2));

400 p = at + 1; /* skip '@' */

401 }

402

403 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {

404 /* [host]:port */

405 av_strlcpy(hostname, p + 1,

406 FFMIN(hostname_size, brk - p));

407 if (brk[1] == ':' && port_ptr)

408 *port_ptr = atoi(brk + 2);

409 } else if ((col = strchr(p, ':')) && col < ls) {

410 av_strlcpy(hostname, p,

411 FFMIN(col + 1 - p, hostname_size));

412 if (port_ptr)

413 *port_ptr = atoi(col + 1);

414 } else

415 av_strlcpy(hostname, p,

416 FFMIN(ls + 1 - p, hostname_size));

417 }

418 }

419

420 int ff_mkdir_p(const char *path)

421 {

422 int ret = 0;

423 char *temp = av_strdup(path);

424 char *pos = temp;

425 char tmp_ch = '0円';

426

427 if (!path || !temp) {

428 return -1;

429 }

430

431 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {

432 pos++;

433 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {

434 pos += 2;

435 }

436

437 for ( ; *pos != '0円'; ++pos) {

438 if (*pos == '/' || *pos == '\\') {

439 tmp_ch = *pos;

440 *pos = '0円';

441 ret = mkdir(temp, 0755);

442 *pos = tmp_ch;

443 }

444 }

445

446 if ((*(pos - 1) != '/') && (*(pos - 1) != '\\')) {

447 ret = mkdir(temp, 0755);

448 }

449

450 av_free(temp);

451 return ret;

452 }

453

454 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)

455 {

456 static const char hex_table_uc[16] = { '0', '1', '2', '3',

457 '4', '5', '6', '7',

458 '8', '9', 'A', 'B',

459 'C', 'D', 'E', 'F' };

460 static const char hex_table_lc[16] = { '0', '1', '2', '3',

461 '4', '5', '6', '7',

462 '8', '9', 'a', 'b',

463 'c', 'd', 'e', 'f' };

464 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;

465

466 for (int i = 0; i < s; i++) {

467 buff[i * 2] = hex_table[src[i] >> 4];

468 buff[i * 2 + 1] = hex_table[src[i] & 0xF];

469 }

470 buff[2 * s] = '0円';

471

472 return buff;

473 }

474

475 int ff_hex_to_data(uint8_t *data, const char *p)

476 {

477 int c, len, v;

478

479 len = 0;

480 v = 1;

481 for (;;) {

482 p += strspn(p, SPACE_CHARS);

483 if (*p == '0円')

484 break;

485 c = av_toupper((unsigned char) *p++);

486 if (c >= '0' && c <= '9')

487 c = c - '0';

488 else if (c >= 'A' && c <= 'F')

489 c = c - 'A' + 10;

490 else

491 break;

492 v = (v << 4) | c;

493 if (v & 0x100) {

494 if (data)

495 data[len] = v;

496 len++;

497 v = 1;

498 }

499 }

500 return len;

501 }

502

503 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,

504 void *context)

505 {

506 const char *ptr = str;

507

508 /* Parse key=value pairs. */

509 for (;;) {

510 const char *key;

511 char *dest = NULL, *dest_end;

512 int key_len, dest_len = 0;

513

514 /* Skip whitespace and potential commas. */

515 while (*ptr && (av_isspace(*ptr) || *ptr == ','))

516 ptr++;

517 if (!*ptr)

518 break;

519

520 key = ptr;

521

522 if (!(ptr = strchr(key, '=')))

523 break;

524 ptr++;

525 key_len = ptr - key;

526

527 callback_get_buf(context, key, key_len, &dest, &dest_len);

528 dest_end = dest ? dest + dest_len - 1 : NULL;

529

530 if (*ptr == '\"') {

531 ptr++;

532 while (*ptr && *ptr != '\"') {

533 if (*ptr == '\\') {

534 if (!ptr[1])

535 break;

536 if (dest && dest < dest_end)

537 *dest++ = ptr[1];

538 ptr += 2;

539 } else {

540 if (dest && dest < dest_end)

541 *dest++ = *ptr;

542 ptr++;

543 }

544 }

545 if (*ptr == '\"')

546 ptr++;

547 } else {

548 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)

549 if (dest && dest < dest_end)

550 *dest++ = *ptr;

551 }

552 if (dest)

553 *dest = 0;

554 }

555 }

556

557 int avformat_network_init(void)

558 {

559 #if CONFIG_NETWORK

560 int ret;

561 if ((ret = ff_network_init()) < 0)

562 return ret;

563 if ((ret = ff_tls_init()) < 0)

564 return ret;

565 #endif

566 return 0;

567 }

568

569 int avformat_network_deinit(void)

570 {

571 #if CONFIG_NETWORK

572 ff_network_close();

573 ff_tls_deinit();

574 #endif

575 return 0;

576 }

577

578 int ff_is_http_proto(const char *filename) {

579 const char *proto = avio_find_protocol_name(filename);

580 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;

581 }

582

583 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)

584 {

585 int ret;

586 char *str;

587

588 ret = av_bprint_finalize(buf, &str);

589 if (ret < 0)

590 return ret;

591 if (!av_bprint_is_complete(buf)) {

592 av_free(str);

593 return AVERROR(ENOMEM);

594 }

595

596 par->extradata = str;

597 /* Note: the string is NUL terminated (so extradata can be read as a

598 * string), but the ending character is not accounted in the size (in

599 * binary formats you are likely not supposed to mux that character). When

600 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE

601 * zeros. */

602 par->extradata_size = buf->len;

603 return 0;

604 }

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:318

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:422

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 be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:83

ff_codec_get_id

enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)

Definition: utils.c:144

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AV_CODEC_ID_PCM_F32BE

@ AV_CODEC_ID_PCM_F32BE

Definition: codec_id.h:338

ff_data_to_hex

char * ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)

Write hexadecimal string corresponding to given binary data.

Definition: utils.c:454

AVCodecParameters::extradata

uint8_t * extradata

Extra binary data needed for initializing the decoder, codec-dependent.

Definition: codec_par.h:75

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

ff_lock_avformat

int ff_lock_avformat(void)

Definition: utils.c:48

av_codec_get_tag2

int av_codec_get_tag2(const AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)

Definition: utils.c:212

av_bprint_finalize

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

Finalize a print buffer.

Definition: bprint.c:235

ff_mkdir_p

int ff_mkdir_p(const char *path)

Automatically create sub-directories.

Definition: utils.c:420

ff_ntp_time

uint64_t ff_ntp_time(void)

Get the current time since NTP epoch in microseconds.

Definition: utils.c:258

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: codec_par.h:53

ffiocontext

static av_always_inline FFIOContext * ffiocontext(AVIOContext *ctx)

Definition: avio_internal.h:82

thread.h

AVCodecTag::id

enum AVCodecID id

Definition: internal.h:51

av_grow_packet

int av_grow_packet(AVPacket *pkt, int grow_by)

Increase packet size, correctly zeroing padding.

Definition: avpacket.c:120

av_strcasecmp

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

Locale-independent case-insensitive compare.

Definition: avstring.c:218

av_isspace

static av_const int av_isspace(int c)

Locale-independent conversion of ASCII isspace.

Definition: avstring.h:227

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

av_get_frame_filename2

int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)

Return in 'buf' the path with 'd' replaced by a number.

Definition: utils.c:294

data

const char data[16]

Definition: mxf.c:143

AV_CODEC_ID_PCM_U24LE

@ AV_CODEC_ID_PCM_U24LE

Definition: codec_id.h:332

ff_toupper4

unsigned int ff_toupper4(unsigned int x)

Definition: to_upper4.h:29

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

ff_network_close

void ff_network_close(void)

Definition: network.c:116

av_get_frame_filename

int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)

Definition: utils.c:352

ff_network_init

int ff_network_init(void)

Definition: network.c:58

ff_tls_init

int ff_tls_init(void)

Definition: network.c:31

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

av_filename_number_test

int av_filename_number_test(const char *filename)

Check whether filename actually is a numbered sequence generator.

Definition: utils.c:125

AV_CODEC_ID_PCM_S64LE

@ AV_CODEC_ID_PCM_S64LE

Definition: codec_id.h:349

ff_mutex_unlock

static int ff_mutex_unlock(AVMutex *mutex)

Definition: thread.h:173

AV_CODEC_ID_PCM_S16BE

@ AV_CODEC_ID_PCM_S16BE

Definition: codec_id.h:319

fail

#define fail()

Definition: checkasm.h:131

av_shrink_packet

void av_shrink_packet(AVPacket *pkt, int size)

Reduce packet size, correctly zeroing padding.

Definition: avpacket.c:112

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:505

avformat_network_init

int avformat_network_init(void)

Do global initialization of network libraries.

Definition: utils.c:557

SPACE_CHARS

#define SPACE_CHARS

Definition: dnn_backend_tf.c:361

AV_CODEC_ID_PCM_S8

@ AV_CODEC_ID_PCM_S8

Definition: codec_id.h:322

av_codec_get_tag

unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)

Definition: utils.c:204

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_PKT_FLAG_CORRUPT

#define AV_PKT_FLAG_CORRUPT

The packet content is corrupted.

Definition: packet.h:430

AVCodecTag

Definition: internal.h:50

AVMutex

#define AVMutex

Definition: thread.h:168

#define s(width, name)

Definition: cbs_vp9.c:256

av_append_packet

int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)

Read data and append it to the current content of the AVPacket.

Definition: utils.c:118

AV_CODEC_ID_PCM_U16BE

@ AV_CODEC_ID_PCM_U16BE

Definition: codec_id.h:321

key

const char * key

Definition: hwcontext_opencl.c:174

ff_hex_to_data

int ff_hex_to_data(uint8_t *data, const char *p)

Parse a string of hexadecimal strings.

Definition: utils.c:475

context

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 keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context

Definition: writing_filters.txt:91

NULL

#define NULL

Definition: coverity.c:32

AV_CODEC_ID_PCM_U24BE

@ AV_CODEC_ID_PCM_U24BE

Definition: codec_id.h:333

AV_CODEC_ID_PCM_U32BE

@ AV_CODEC_ID_PCM_U32BE

Definition: codec_id.h:329

AV_CODEC_ID_PCM_S64BE

@ AV_CODEC_ID_PCM_S64BE

Definition: codec_id.h:350

ff_parse_key_value

void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf, void *context)

Parse a string with comma-separated key=value pairs.

Definition: utils.c:503

time.h

ff_get_formatted_ntp_time

uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)

Get the NTP time stamp formatted as per the RFC-5905.

Definition: utils.c:263

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

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:47

AVCodecParameters::extradata_size

int extradata_size

Size of the extradata content in bytes.

Definition: codec_par.h:79

av_strncasecmp

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

Locale-independent case-insensitive compare.

Definition: avstring.c:228

AVIOContext

Bytestream IO Context.

Definition: avio.h:162

AV_CODEC_ID_PCM_S24LE

@ AV_CODEC_ID_PCM_S24LE

Definition: codec_id.h:330

AVPacket::size

int size

Definition: packet.h:375

enum AVCodecID id

Definition: extract_extradata_bsf.c:324

bps

unsigned bps

Definition: movenc.c:1647

AV_MUTEX_INITIALIZER

#define AV_MUTEX_INITIALIZER

Definition: thread.h:169

ff_get_pcm_codec_id

enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)

Select a PCM codec based on the given parameters.

Definition: utils.c:155

size

int size

Definition: twinvq_data.h:10344

NTP_OFFSET_US

#define NTP_OFFSET_US

Definition: internal.h:467

ff_unlock_avformat

int ff_unlock_avformat(void)

Definition: utils.c:53

av_isdigit

static av_const int av_isdigit(int c)

Locale-independent conversion of ASCII isdigit.

Definition: avstring.h:211

ff_mutex_lock

static int ff_mutex_lock(AVMutex *mutex)

Definition: thread.h:172

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:380

AV_FRAME_FILENAME_FLAGS_MULTIPLE

#define AV_FRAME_FILENAME_FLAGS_MULTIPLE

Allow multiple d.

Definition: avformat.h:2721

SANE_CHUNK_SIZE

#define SANE_CHUNK_SIZE

Definition: utils.c:59

ffio_limit

int ffio_limit(AVIOContext *s, int size)

Definition: aviobuf.c:1093

bprint.h

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:48

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

avio_internal.h

internal.h

avformat_mutex

static AVMutex avformat_mutex

Definition: utils.c:41

AV_CODEC_ID_PCM_F64BE

@ AV_CODEC_ID_PCM_F64BE

Definition: codec_id.h:340

av_toupper

static av_const int av_toupper(int c)

Locale-independent conversion of ASCII characters to uppercase.

Definition: avstring.h:236

av_url_split

void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)

Split a URL string into components.

Definition: utils.c:357

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AV_CODEC_ID_PCM_S32BE

@ AV_CODEC_ID_PCM_S32BE

Definition: codec_id.h:327

len

int len

Definition: vorbis_enc_data.h:426

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

Allocate and read the payload of a packet and initialize its fields with default values.

Definition: utils.c:102

ff_tls_deinit

void ff_tls_deinit(void)

Definition: network.c:46

tag

uint32_t tag

Definition: movenc.c:1646

ret

Definition: filter_design.txt:187

ff_is_http_proto

int ff_is_http_proto(const char *filename)

Utility function to check if the file uses http or https protocol.

Definition: utils.c:578

ff_bprint_to_codecpar_extradata

int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)

Finalize buf into extradata and set its size appropriately.

Definition: utils.c:583

lowercase

Definition: writing_filters.txt:89

pos

unsigned int pos

Definition: spdifenc.c:412

avformat.h

network.h

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

avformat_network_deinit

int avformat_network_deinit(void)

Undo the initialization done by avformat_network_init.

Definition: utils.c:569

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:641

ff_parse_key_val_cb

void(* ff_parse_key_val_cb)(void *context, const char *key, int key_len, char **dest, int *dest_len)

Callback function type for ff_parse_key_value.

Definition: internal.h:546

AV_CODEC_ID_PCM_U32LE

@ AV_CODEC_ID_PCM_U32LE

Definition: codec_id.h:328

temp

else temp

Definition: vf_mcdeint.c:248

av_gettime

int64_t av_gettime(void)

Get the current time in microseconds.

Definition: time.c:39

FF_DISABLE_DEPRECATION_WARNINGS

#define FF_DISABLE_DEPRECATION_WARNINGS

Definition: internal.h:82

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:280

AV_CODEC_ID_PCM_S32LE

@ AV_CODEC_ID_PCM_S32LE

Definition: codec_id.h:326

ff_codec_get_tag

unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)

Definition: utils.c:134

AV_CODEC_ID_PCM_U8

@ AV_CODEC_ID_PCM_U8

Definition: codec_id.h:323

AV_CODEC_ID_PCM_F64LE

@ AV_CODEC_ID_PCM_F64LE

Definition: codec_id.h:341

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

AVPacket

This structure stores compressed data.

Definition: packet.h:351

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

src

INIT_CLIP pixel * src

Definition: h264pred_template.c:418

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: packet.h:394

avio_find_protocol_name

const char * avio_find_protocol_name(const char *url)

Return the name of the protocol that will handle the passed URL.

Definition: avio.c:467

ff_parse_ntp_time

uint64_t ff_parse_ntp_time(uint64_t ntp_ts)

Parse the NTP time in micro seconds (since NTP epoch).

Definition: utils.c:285

convert_header.str

string str

Definition: convert_header.py:20

AV_CODEC_ID_PCM_U16LE

@ AV_CODEC_ID_PCM_U16LE

Definition: codec_id.h:320

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:561

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

AV_CODEC_ID_PCM_F32LE

@ AV_CODEC_ID_PCM_F32LE

Definition: codec_id.h:339

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

avstring.h

av_codec_get_id

enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)

Definition: utils.c:228

AVCodecTag::tag

unsigned int tag

Definition: internal.h:52

snprintf

#define snprintf

Definition: snprintf.h:34

ff_alloc_extradata

int ff_alloc_extradata(AVCodecParameters *par, int size)

Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.

Definition: utils.c:238

AV_CODEC_ID_PCM_S24BE

@ AV_CODEC_ID_PCM_S24BE

Definition: codec_id.h:331

append_packet_chunked

static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)

Definition: utils.c:63

Generated on Wed Aug 24 2022 21:41:50 for FFmpeg by doxygen 1.8.17