FFmpeg: libavformat/mux.c Source File

FFmpeg

[フレーム]

libavformat

mux.c

Go to the documentation of this file.

1 /*

2 * muxing 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 "avformat.h"

23 #include "internal.h"

24 #include "mux.h"

25 #include "version.h"

26 #include "libavcodec/bsf.h"

27 #include "libavcodec/internal.h"

28 #include "libavcodec/packet_internal.h"

29 #include "libavutil/opt.h"

30 #include "libavutil/dict.h"

31 #include "libavutil/timestamp.h"

32 #include "libavutil/avassert.h"

33 #include "libavutil/internal.h"

34 #include "libavutil/mathematics.h"

36 /**

37 * @file

38 * muxing functions for use within libavformat

39 */

41 /* fraction handling */

43 /**

44 * f = val + (num / den) + 0.5.

45 *

46 * 'num' is normalized so that it is such as 0 <= num < den.

47 *

48 * @param f fractional number

49 * @param val integer value

50 * @param num must be >= 0

51 * @param den must be >= 1

52 */

53 static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)

54 {

55 num += (den >> 1);

56 if (num >= den) {

57 val += num / den;

58 num = num % den;

59 }

60 f->val = val;

61 f->num = num;

62 f->den = den;

63 }

65 /**

66 * Fractional addition to f: f = f + (incr / f->den).

67 *

68 * @param f fractional number

69 * @param incr increment, can be positive or negative

70 */

71 static void frac_add(FFFrac *f, int64_t incr)

72 {

73 int64_t num, den;

75 num = f->num + incr;

76 den = f->den;

77 if (num < 0) {

78 f->val += num / den;

79 num = num % den;

80 if (num < 0) {

81 num += den;

82 f->val--;

83 }

84 } else if (num >= den) {

85 f->val += num / den;

86 num = num % den;

87 }

88 f->num = num;

89 }

91 int avformat_alloc_output_context2(AVFormatContext **avctx, const AVOutputFormat *oformat,

92 const char *format, const char *filename)

93 {

94 AVFormatContext *s = avformat_alloc_context();

95 int ret = 0;

97 *avctx = NULL;

98 if (!s)

99 goto nomem;

100

101 if (!oformat) {

102 if (format) {

103 oformat = av_guess_format(format, NULL, NULL);

104 if (!oformat) {

105 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);

106 ret = AVERROR(EINVAL);

107 goto error;

108 }

109 } else {

110 oformat = av_guess_format(NULL, filename, NULL);

111 if (!oformat) {

112 ret = AVERROR(EINVAL);

113 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",

114 filename);

115 goto error;

116 }

117 }

118 }

119

120 s->oformat = oformat;

121 if (ffofmt(s->oformat)->priv_data_size > 0) {

122 s->priv_data = av_mallocz(ffofmt(s->oformat)->priv_data_size);

123 if (!s->priv_data)

124 goto nomem;

125 if (s->oformat->priv_class) {

126 *(const AVClass**)s->priv_data= s->oformat->priv_class;

127 av_opt_set_defaults(s->priv_data);

128 }

129 } else

130 s->priv_data = NULL;

131

132 if (filename) {

133 if (!(s->url = av_strdup(filename)))

134 goto nomem;

135

136 }

137 *avctx = s;

138 return 0;

139 nomem:

140 av_log(s, AV_LOG_ERROR, "Out of memory\n");

141 ret = AVERROR(ENOMEM);

142 error:

143 avformat_free_context(s);

144 return ret;

145 }

146

147 static int validate_codec_tag(const AVFormatContext *s, const AVStream *st)

148 {

149 const AVCodecTag *avctag;

150 enum AVCodecID id = AV_CODEC_ID_NONE;

151 unsigned uppercase_tag = ff_toupper4(st->codecpar->codec_tag);

152 int64_t tag = -1;

153

154 /**

155 * Check that tag + id is in the table

156 * If neither is in the table -> OK

157 * If tag is in the table with another id -> FAIL

158 * If id is in the table with another tag -> FAIL unless strict < normal

159 */

160 for (int n = 0; s->oformat->codec_tag[n]; n++) {

161 avctag = s->oformat->codec_tag[n];

162 while (avctag->id != AV_CODEC_ID_NONE) {

163 if (ff_toupper4(avctag->tag) == uppercase_tag) {

164 id = avctag->id;

165 if (id == st->codecpar->codec_id)

166 return 1;

167 }

168 if (avctag->id == st->codecpar->codec_id)

169 tag = avctag->tag;

170 avctag++;

171 }

172 }

173 if (id != AV_CODEC_ID_NONE)

174 return 0;

175 if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))

176 return 0;

177 return 1;

178 }

179

180

181 static int init_muxer(AVFormatContext *s, AVDictionary **options)

182 {

183 FFFormatContext *const si = ffformatcontext(s);

184 AVDictionary *tmp = NULL;

185 const FFOutputFormat *of = ffofmt(s->oformat);

186 AVDictionaryEntry *e;

187 int ret = 0;

188

189 if (options)

190 av_dict_copy(&tmp, *options, 0);

191

192 if ((ret = av_opt_set_dict(s, &tmp)) < 0)

193 goto fail;

194 if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&

195 (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)

196 goto fail;

197

198 if (!s->url && !(s->url = av_strdup(""))) {

199 ret = AVERROR(ENOMEM);

200 goto fail;

201 }

202

203 // some sanity checks

204 if (s->nb_streams == 0 && !(of->p.flags & AVFMT_NOSTREAMS)) {

205 av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");

206 ret = AVERROR(EINVAL);

207 goto fail;

208 }

209

210 for (unsigned i = 0; i < s->nb_streams; i++) {

211 AVStream *const st = s->streams[i];

212 FFStream *const sti = ffstream(st);

213 AVCodecParameters *const par = st->codecpar;

214 const AVCodecDescriptor *desc;

215

216 if (!st->time_base.num) {

217 /* fall back on the default timebase values */

218 if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)

219 avpriv_set_pts_info(st, 64, 1, par->sample_rate);

220 else

221 avpriv_set_pts_info(st, 33, 1, 90000);

222 }

223

224 switch (par->codec_type) {

225 case AVMEDIA_TYPE_AUDIO:

226 if (par->sample_rate <= 0) {

227 av_log(s, AV_LOG_ERROR, "sample rate not set\n");

228 ret = AVERROR(EINVAL);

229 goto fail;

230 }

231

232 #if FF_API_OLD_CHANNEL_LAYOUT

233 FF_DISABLE_DEPRECATION_WARNINGS

234 /* if the caller is using the deprecated channel layout API,

235 * convert it to the new style */

236 if (!par->ch_layout.nb_channels &&

237 par->channels) {

238 if (par->channel_layout) {

239 av_channel_layout_from_mask(&par->ch_layout, par->channel_layout);

240 } else {

241 par->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;

242 par->ch_layout.nb_channels = par->channels;

243 }

244 }

245 FF_ENABLE_DEPRECATION_WARNINGS

246 #endif

247

248 if (!par->block_align)

249 par->block_align = par->ch_layout.nb_channels *

250 av_get_bits_per_sample(par->codec_id) >> 3;

251 break;

252 case AVMEDIA_TYPE_VIDEO:

253 if ((par->width <= 0 || par->height <= 0) &&

254 !(of->p.flags & AVFMT_NODIMENSIONS)) {

255 av_log(s, AV_LOG_ERROR, "dimensions not set\n");

256 ret = AVERROR(EINVAL);

257 goto fail;

258 }

259 if (av_cmp_q(st->sample_aspect_ratio, par->sample_aspect_ratio)

260 && fabs(av_q2d(st->sample_aspect_ratio) - av_q2d(par->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)

261 ) {

262 if (st->sample_aspect_ratio.num != 0 &&

263 st->sample_aspect_ratio.den != 0 &&

264 par->sample_aspect_ratio.num != 0 &&

265 par->sample_aspect_ratio.den != 0) {

266 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "

267 "(%d/%d) and encoder layer (%d/%d)\n",

268 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,

269 par->sample_aspect_ratio.num,

270 par->sample_aspect_ratio.den);

271 ret = AVERROR(EINVAL);

272 goto fail;

273 }

274 }

275 break;

276 }

277

278 desc = avcodec_descriptor_get(par->codec_id);

279 if (desc && desc->props & AV_CODEC_PROP_REORDER)

280 sti->reorder = 1;

281

282 sti->is_intra_only = ff_is_intra_only(par->codec_id);

283

284 if (of->p.codec_tag) {

285 if ( par->codec_tag

286 && par->codec_id == AV_CODEC_ID_RAWVIDEO

287 && ( av_codec_get_tag(of->p.codec_tag, par->codec_id) == 0

288 || av_codec_get_tag(of->p.codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))

289 && !validate_codec_tag(s, st)) {

290 // the current rawvideo encoding system ends up setting

291 // the wrong codec_tag for avi/mov, we override it here

292 par->codec_tag = 0;

293 }

294 if (par->codec_tag) {

295 if (!validate_codec_tag(s, st)) {

296 const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);

297 av_log(s, AV_LOG_ERROR,

298 "Tag %s incompatible with output codec id '%d' (%s)\n",

299 av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));

300 ret = AVERROR_INVALIDDATA;

301 goto fail;

302 }

303 } else

304 par->codec_tag = av_codec_get_tag(of->p.codec_tag, par->codec_id);

305 }

306

307 if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT)

308 si->nb_interleaved_streams++;

309 }

310 si->interleave_packet = of->interleave_packet;

311 if (!si->interleave_packet)

312 si->interleave_packet = si->nb_interleaved_streams > 1 ?

313 ff_interleave_packet_per_dts :

314 ff_interleave_packet_passthrough;

315

316 if (!s->priv_data && of->priv_data_size > 0) {

317 s->priv_data = av_mallocz(of->priv_data_size);

318 if (!s->priv_data) {

319 ret = AVERROR(ENOMEM);

320 goto fail;

321 }

322 if (of->p.priv_class) {

323 *(const AVClass **)s->priv_data = of->p.priv_class;

324 av_opt_set_defaults(s->priv_data);

325 if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)

326 goto fail;

327 }

328 }

329

330 /* set muxer identification string */

331 if (!(s->flags & AVFMT_FLAG_BITEXACT)) {

332 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);

333 } else {

334 av_dict_set(&s->metadata, "encoder", NULL, 0);

335 }

336

337 for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {

338 av_dict_set(&s->metadata, e->key, NULL, 0);

339 }

340

341 if (options) {

342 av_dict_free(options);

343 *options = tmp;

344 }

345

346 if (of->init) {

347 if ((ret = of->init(s)) < 0) {

348 if (of->deinit)

349 of->deinit(s);

350 return ret;

351 }

352 return ret == 0;

353 }

354

355 return 0;

356

357 fail:

358 av_dict_free(&tmp);

359 return ret;

360 }

361

362 static int init_pts(AVFormatContext *s)

363 {

364 FFFormatContext *const si = ffformatcontext(s);

365

366 /* init PTS generation */

367 for (unsigned i = 0; i < s->nb_streams; i++) {

368 AVStream *const st = s->streams[i];

369 FFStream *const sti = ffstream(st);

370 int64_t den = AV_NOPTS_VALUE;

371

372 switch (st->codecpar->codec_type) {

373 case AVMEDIA_TYPE_AUDIO:

374 den = (int64_t)st->time_base.num * st->codecpar->sample_rate;

375 break;

376 case AVMEDIA_TYPE_VIDEO:

377 den = (int64_t)st->time_base.num * st->time_base.den;

378 break;

379 default:

380 break;

381 }

382

383 if (!sti->priv_pts)

384 sti->priv_pts = av_mallocz(sizeof(*sti->priv_pts));

385 if (!sti->priv_pts)

386 return AVERROR(ENOMEM);

387

388 if (den != AV_NOPTS_VALUE) {

389 if (den <= 0)

390 return AVERROR_INVALIDDATA;

391

392 frac_init(sti->priv_pts, 0, 0, den);

393 }

394 }

395

396 si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_UNKNOWN;

397 if (s->avoid_negative_ts < 0) {

398 av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);

399 if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {

400 s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_DISABLED;

401 si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;

402 } else

403 s->avoid_negative_ts = AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE;

404 } else if (s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_DISABLED)

405 si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_DISABLED;

406

407 return 0;

408 }

409

410 static void flush_if_needed(AVFormatContext *s)

411 {

412 if (s->pb && s->pb->error >= 0) {

413 if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)

414 avio_flush(s->pb);

415 else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))

416 avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);

417 }

418 }

419

420 static void deinit_muxer(AVFormatContext *s)

421 {

422 FFFormatContext *const si = ffformatcontext(s);

423 const FFOutputFormat *const of = ffofmt(s->oformat);

424 if (of && of->deinit && si->initialized)

425 of->deinit(s);

426 si->initialized =

427 si->streams_initialized = 0;

428 }

429

430 int avformat_init_output(AVFormatContext *s, AVDictionary **options)

431 {

432 FFFormatContext *const si = ffformatcontext(s);

433 int ret = 0;

434

435 if ((ret = init_muxer(s, options)) < 0)

436 return ret;

437

438 si->initialized = 1;

439 si->streams_initialized = ret;

440

441 if (ffofmt(s->oformat)->init && ret) {

442 if ((ret = init_pts(s)) < 0)

443 return ret;

444

445 return AVSTREAM_INIT_IN_INIT_OUTPUT;

446 }

447

448 return AVSTREAM_INIT_IN_WRITE_HEADER;

449 }

450

451 int avformat_write_header(AVFormatContext *s, AVDictionary **options)

452 {

453 FFFormatContext *const si = ffformatcontext(s);

454 int already_initialized = si->initialized;

455 int streams_already_initialized = si->streams_initialized;

456 int ret = 0;

457

458 if (!already_initialized)

459 if ((ret = avformat_init_output(s, options)) < 0)

460 return ret;

461

462 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)

463 avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_HEADER);

464 if (ffofmt(s->oformat)->write_header) {

465 ret = ffofmt(s->oformat)->write_header(s);

466 if (ret >= 0 && s->pb && s->pb->error < 0)

467 ret = s->pb->error;

468 if (ret < 0)

469 goto fail;

470 flush_if_needed(s);

471 }

472 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)

473 avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_UNKNOWN);

474

475 if (!si->streams_initialized) {

476 if ((ret = init_pts(s)) < 0)

477 goto fail;

478 }

479

480 return streams_already_initialized;

481

482 fail:

483 deinit_muxer(s);

484 return ret;

485 }

486

487 #define AV_PKT_FLAG_UNCODED_FRAME 0x2000

488

489

490 #if FF_API_COMPUTE_PKT_FIELDS2

491 FF_DISABLE_DEPRECATION_WARNINGS

492 //FIXME merge with compute_pkt_fields

493 static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)

494 {

495 FFFormatContext *const si = ffformatcontext(s);

496 FFStream *const sti = ffstream(st);

497 int delay = st->codecpar->video_delay;

498 int frame_size;

499

500 if (!si->missing_ts_warning &&

501 !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&

502 (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC) || (st->disposition & AV_DISPOSITION_TIMED_THUMBNAILS)) &&

503 (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {

504 av_log(s, AV_LOG_WARNING,

505 "Timestamps are unset in a packet for stream %d. "

506 "This is deprecated and will stop working in the future. "

507 "Fix your code to set the timestamps properly\n", st->index);

508 si->missing_ts_warning = 1;

509 }

510

511 if (s->debug & FF_FDEBUG_TS)

512 av_log(s, AV_LOG_DEBUG, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",

513 av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(sti->cur_dts), delay, pkt->size, pkt->stream_index);

514

515 if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)

516 pkt->pts = pkt->dts;

517

518 //XXX/FIXME this is a temporary hack until all encoders output pts

519 if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {

520 static int warned;

521 if (!warned) {

522 av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");

523 warned = 1;

524 }

525 pkt->dts =

526 // pkt->pts= st->cur_dts;

527 pkt->pts = sti->priv_pts->val;

528 }

529

530 //calculate dts from pts

531 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {

532 sti->pts_buffer[0] = pkt->pts;

533 for (int i = 1; i < delay + 1 && sti->pts_buffer[i] == AV_NOPTS_VALUE; i++)

534 sti->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;

535 for (int i = 0; i<delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)

536 FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);

537

538 pkt->dts = sti->pts_buffer[0];

539 }

540

541 if (sti->cur_dts && sti->cur_dts != AV_NOPTS_VALUE &&

542 ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&

543 st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE &&

544 st->codecpar->codec_type != AVMEDIA_TYPE_DATA &&

545 sti->cur_dts >= pkt->dts) || sti->cur_dts > pkt->dts)) {

546 av_log(s, AV_LOG_ERROR,

547 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",

548 st->index, av_ts2str(sti->cur_dts), av_ts2str(pkt->dts));

549 return AVERROR(EINVAL);

550 }

551 if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {

552 av_log(s, AV_LOG_ERROR,

553 "pts (%s) < dts (%s) in stream %d\n",

554 av_ts2str(pkt->pts), av_ts2str(pkt->dts),

555 st->index);

556 return AVERROR(EINVAL);

557 }

558

559 if (s->debug & FF_FDEBUG_TS)

560 av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n",

561 av_ts2str(pkt->pts), av_ts2str(pkt->dts));

562

563 sti->cur_dts = pkt->dts;

564 sti->priv_pts->val = pkt->dts;

565

566 /* update pts */

567 switch (st->codecpar->codec_type) {

568 case AVMEDIA_TYPE_AUDIO:

569 frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?

570 (*(AVFrame **)pkt->data)->nb_samples :

571 av_get_audio_frame_duration2(st->codecpar, pkt->size);

572

573 /* HACK/FIXME, we skip the initial 0 size packets as they are most

574 * likely equal to the encoder delay, but it would be better if we

575 * had the real timestamps from the encoder */

576 if (frame_size >= 0 && (pkt->size || sti->priv_pts->num != sti->priv_pts->den >> 1 || sti->priv_pts->val)) {

577 frac_add(sti->priv_pts, (int64_t)st->time_base.den * frame_size);

578 }

579 break;

580 case AVMEDIA_TYPE_VIDEO:

581 frac_add(sti->priv_pts, (int64_t)st->time_base.den * st->time_base.num);

582 break;

583 }

584 return 0;

585 }

586 FF_ENABLE_DEPRECATION_WARNINGS

587 #endif

588

589 static void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)

590 {

591 if (pkt->duration < 0 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {

592 av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",

593 pkt->duration, pkt->stream_index);

594 pkt->duration = 0;

595 }

596

597 if (pkt->duration)

598 return;

599

600 switch (st->codecpar->codec_type) {

601 case AVMEDIA_TYPE_VIDEO:

602 if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0) {

603 pkt->duration = av_rescale_q(1, av_inv_q(st->avg_frame_rate),

604 st->time_base);

605 } else if (st->time_base.num * 1000LL > st->time_base.den)

606 pkt->duration = 1;

607 break;

608 case AVMEDIA_TYPE_AUDIO: {

609 int frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);

610 if (frame_size && st->codecpar->sample_rate) {

611 pkt->duration = av_rescale_q(frame_size,

612 (AVRational){1, st->codecpar->sample_rate},

613 st->time_base);

614 }

615 break;

616 }

617 }

618 }

619

620 static void handle_avoid_negative_ts(FFFormatContext *si, FFStream *sti,

621 AVPacket *pkt)

622 {

623 AVFormatContext *const s = &si->pub;

624 int64_t offset;

625

626 if (!AVOID_NEGATIVE_TS_ENABLED(si->avoid_negative_ts_status))

627 return;

628

629 if (si->avoid_negative_ts_status == AVOID_NEGATIVE_TS_UNKNOWN) {

630 int use_pts = si->avoid_negative_ts_use_pts;

631 int64_t ts = use_pts ? pkt->pts : pkt->dts;

632 AVRational tb = sti->pub.time_base;

633

634 if (ts == AV_NOPTS_VALUE)

635 return;

636

637 ts -= sti->lowest_ts_allowed;

638

639 /* Peek into the muxing queue to improve our estimate

640 * of the lowest timestamp if av_interleaved_write_frame() is used. */

641 for (const PacketListEntry *pktl = si->packet_buffer.head;

642 pktl; pktl = pktl->next) {

643 AVRational cmp_tb = s->streams[pktl->pkt.stream_index]->time_base;

644 int64_t cmp_ts = use_pts ? pktl->pkt.pts : pktl->pkt.dts;

645 if (cmp_ts == AV_NOPTS_VALUE)

646 continue;

647 cmp_ts -= ffstream(s->streams[pktl->pkt.stream_index])->lowest_ts_allowed;

648 if (s->output_ts_offset)

649 cmp_ts += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, cmp_tb);

650 if (av_compare_ts(cmp_ts, cmp_tb, ts, tb) < 0) {

651 ts = cmp_ts;

652 tb = cmp_tb;

653 }

654 }

655

656 if (ts < 0 ||

657 ts > 0 && s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {

658 for (unsigned i = 0; i < s->nb_streams; i++) {

659 AVStream *const st2 = s->streams[i];

660 FFStream *const sti2 = ffstream(st2);

661 sti2->mux_ts_offset = av_rescale_q_rnd(-ts, tb,

662 st2->time_base,

663 AV_ROUND_UP);

664 }

665 }

666 si->avoid_negative_ts_status = AVOID_NEGATIVE_TS_KNOWN;

667 }

668

669 offset = sti->mux_ts_offset;

670

671 if (pkt->dts != AV_NOPTS_VALUE)

672 pkt->dts += offset;

673 if (pkt->pts != AV_NOPTS_VALUE)

674 pkt->pts += offset;

675

676 if (si->avoid_negative_ts_use_pts) {

677 if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < sti->lowest_ts_allowed) {

678 av_log(s, AV_LOG_WARNING, "failed to avoid negative "

679 "pts %s in stream %d.\n"

680 "Try -avoid_negative_ts 1 as a possible workaround.\n",

681 av_ts2str(pkt->pts),

682 pkt->stream_index

683 );

684 }

685 } else {

686 if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < sti->lowest_ts_allowed) {

687 av_log(s, AV_LOG_WARNING,

688 "Packets poorly interleaved, failed to avoid negative "

689 "timestamp %s in stream %d.\n"

690 "Try -max_interleave_delta 0 as a possible workaround.\n",

691 av_ts2str(pkt->dts),

692 pkt->stream_index

693 );

694 }

695 }

696 }

697

698 /**

699 * Shift timestamps and call muxer; the original pts/dts are not kept.

700 *

701 * FIXME: this function should NEVER get undefined pts/dts beside when the

702 * AVFMT_NOTIMESTAMPS is set.

703 * Those additional safety checks should be dropped once the correct checks

704 * are set in the callers.

705 */

706 static int write_packet(AVFormatContext *s, AVPacket *pkt)

707 {

708 FFFormatContext *const si = ffformatcontext(s);

709 AVStream *const st = s->streams[pkt->stream_index];

710 FFStream *const sti = ffstream(st);

711 int ret;

712

713 // If the timestamp offsetting below is adjusted, adjust

714 // ff_interleaved_peek similarly.

715 if (s->output_ts_offset) {

716 int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);

717

718 if (pkt->dts != AV_NOPTS_VALUE)

719 pkt->dts += offset;

720 if (pkt->pts != AV_NOPTS_VALUE)

721 pkt->pts += offset;

722 }

723 handle_avoid_negative_ts(si, sti, pkt);

724

725 if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {

726 AVFrame **frame = (AVFrame **)pkt->data;

727 av_assert0(pkt->size == sizeof(*frame));

728 ret = ffofmt(s->oformat)->write_uncoded_frame(s, pkt->stream_index, frame, 0);

729 } else {

730 ret = ffofmt(s->oformat)->write_packet(s, pkt);

731 }

732

733 if (s->pb && ret >= 0) {

734 flush_if_needed(s);

735 if (s->pb->error < 0)

736 ret = s->pb->error;

737 }

738

739 if (ret >= 0)

740 st->nb_frames++;

741

742 return ret;

743 }

744

745 static int check_packet(AVFormatContext *s, AVPacket *pkt)

746 {

747 if (pkt->stream_index < 0 || pkt->stream_index >= s->nb_streams) {

748 av_log(s, AV_LOG_ERROR, "Invalid packet stream index: %d\n",

749 pkt->stream_index);

750 return AVERROR(EINVAL);

751 }

752

753 if (s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_ATTACHMENT) {

754 av_log(s, AV_LOG_ERROR, "Received a packet for an attachment stream.\n");

755 return AVERROR(EINVAL);

756 }

757

758 return 0;

759 }

760

761 static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)

762 {

763 FFStream *const sti = ffstream(st);

764 #if !FF_API_COMPUTE_PKT_FIELDS2

765 /* sanitize the timestamps */

766 if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {

767

768 /* when there is no reordering (so dts is equal to pts), but

769 * only one of them is set, set the other as well */

770 if (!sti->reorder) {

771 if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)

772 pkt->pts = pkt->dts;

773 if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)

774 pkt->dts = pkt->pts;

775 }

776

777 /* check that the timestamps are set */

778 if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {

779 av_log(s, AV_LOG_ERROR,

780 "Timestamps are unset in a packet for stream %d\n", st->index);

781 return AVERROR(EINVAL);

782 }

783

784 /* check that the dts are increasing (or at least non-decreasing,

785 * if the format allows it */

786 if (sti->cur_dts != AV_NOPTS_VALUE &&

787 ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && sti->cur_dts >= pkt->dts) ||

788 sti->cur_dts > pkt->dts)) {

789 av_log(s, AV_LOG_ERROR,

790 "Application provided invalid, non monotonically increasing "

791 "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",

792 st->index, sti->cur_dts, pkt->dts);

793 return AVERROR(EINVAL);

794 }

795

796 if (pkt->pts < pkt->dts) {

797 av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",

798 pkt->pts, pkt->dts, st->index);

799 return AVERROR(EINVAL);

800 }

801 }

802 #endif

803 /* update flags */

804 if (sti->is_intra_only)

805 pkt->flags |= AV_PKT_FLAG_KEY;

806

807 if (!pkt->data && !pkt->side_data_elems) {

808 /* Such empty packets signal EOS for the BSF API; so sanitize

809 * the packet by allocating data of size 0 (+ padding). */

810 av_buffer_unref(&pkt->buf);

811 return av_packet_make_refcounted(pkt);

812 }

813

814 return 0;

815 }

816

817 #define CHUNK_START 0x1000

818

819 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,

820 int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))

821 {

822 int ret;

823 FFFormatContext *const si = ffformatcontext(s);

824 PacketListEntry **next_point, *this_pktl;

825 AVStream *st = s->streams[pkt->stream_index];

826 FFStream *const sti = ffstream(st);

827 int chunked = s->max_chunk_size || s->max_chunk_duration;

828

829 this_pktl = av_malloc(sizeof(*this_pktl));

830 if (!this_pktl) {

831 av_packet_unref(pkt);

832 return AVERROR(ENOMEM);

833 }

834 if ((ret = av_packet_make_refcounted(pkt)) < 0) {

835 av_free(this_pktl);

836 av_packet_unref(pkt);

837 return ret;

838 }

839

840 av_packet_move_ref(&this_pktl->pkt, pkt);

841 pkt = &this_pktl->pkt;

842

843 if (sti->last_in_packet_buffer) {

844 next_point = &(sti->last_in_packet_buffer->next);

845 } else {

846 next_point = &si->packet_buffer.head;

847 }

848

849 if (chunked) {

850 uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);

851 sti->interleaver_chunk_size += pkt->size;

852 sti->interleaver_chunk_duration += pkt->duration;

853 if ( (s->max_chunk_size && sti->interleaver_chunk_size > s->max_chunk_size)

854 || (max && sti->interleaver_chunk_duration > max)) {

855 sti->interleaver_chunk_size = 0;

856 pkt->flags |= CHUNK_START;

857 if (max && sti->interleaver_chunk_duration > max) {

858 int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;

859 int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;

860

861 sti->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;

862 } else

863 sti->interleaver_chunk_duration = 0;

864 }

865 }

866 if (*next_point) {

867 if (chunked && !(pkt->flags & CHUNK_START))

868 goto next_non_null;

869

870 if (compare(s, &si->packet_buffer.tail->pkt, pkt)) {

871 while ( *next_point

872 && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))

873 || !compare(s, &(*next_point)->pkt, pkt)))

874 next_point = &(*next_point)->next;

875 if (*next_point)

876 goto next_non_null;

877 } else {

878 next_point = &(si->packet_buffer.tail->next);

879 }

880 }

881 av_assert1(!*next_point);

882

883 si->packet_buffer.tail = this_pktl;

884 next_non_null:

885

886 this_pktl->next = *next_point;

887

888 sti->last_in_packet_buffer = *next_point = this_pktl;

889

890 return 0;

891 }

892

893 static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next,

894 const AVPacket *pkt)

895 {

896 AVStream *st = s->streams[pkt->stream_index];

897 AVStream *st2 = s->streams[next->stream_index];

898 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,

899 st->time_base);

900 if (s->audio_preload) {

901 int preload = st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;

902 int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;

903 if (preload != preload2) {

904 int64_t ts, ts2;

905 preload *= s->audio_preload;

906 preload2 *= s->audio_preload;

907 ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - preload;

908 ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - preload2;

909 if (ts == ts2) {

910 ts = ((uint64_t)pkt ->dts*st ->time_base.num*AV_TIME_BASE - (uint64_t)preload *st ->time_base.den)*st2->time_base.den

911 - ((uint64_t)next->dts*st2->time_base.num*AV_TIME_BASE - (uint64_t)preload2*st2->time_base.den)*st ->time_base.den;

912 ts2 = 0;

913 }

914 comp = (ts2 > ts) - (ts2 < ts);

915 }

916 }

917

918 if (comp == 0)

919 return pkt->stream_index < next->stream_index;

920 return comp > 0;

921 }

922

923 int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *pkt,

924 int flush, int has_packet)

925 {

926 FFFormatContext *const si = ffformatcontext(s);

927 int stream_count = 0;

928 int noninterleaved_count = 0;

929 int ret;

930 int eof = flush;

931

932 if (has_packet) {

933 if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0)

934 return ret;

935 }

936

937 for (unsigned i = 0; i < s->nb_streams; i++) {

938 const AVStream *const st = s->streams[i];

939 const FFStream *const sti = cffstream(st);

940 const AVCodecParameters *const par = st->codecpar;

941 if (sti->last_in_packet_buffer) {

942 ++stream_count;

943 } else if (par->codec_type != AVMEDIA_TYPE_ATTACHMENT &&

944 par->codec_id != AV_CODEC_ID_VP8 &&

945 par->codec_id != AV_CODEC_ID_VP9) {

946 ++noninterleaved_count;

947 }

948 }

949

950 if (si->nb_interleaved_streams == stream_count)

951 flush = 1;

952

953 if (s->max_interleave_delta > 0 &&

954 si->packet_buffer.head &&

955 si->packet_buffer.head->pkt.dts != AV_NOPTS_VALUE &&

956 !flush &&

957 si->nb_interleaved_streams == stream_count+noninterleaved_count

958 ) {

959 AVPacket *const top_pkt = &si->packet_buffer.head->pkt;

960 int64_t delta_dts = INT64_MIN;

961 int64_t top_dts = av_rescale_q(top_pkt->dts,

962 s->streams[top_pkt->stream_index]->time_base,

963 AV_TIME_BASE_Q);

964

965 for (unsigned i = 0; i < s->nb_streams; i++) {

966 const AVStream *const st = s->streams[i];

967 const FFStream *const sti = cffstream(st);

968 const PacketListEntry *const last = sti->last_in_packet_buffer;

969 int64_t last_dts;

970

971 if (!last)

972 continue;

973

974 last_dts = av_rescale_q(last->pkt.dts,

975 st->time_base,

976 AV_TIME_BASE_Q);

977 delta_dts = FFMAX(delta_dts, last_dts - top_dts);

978 }

979

980 if (delta_dts > s->max_interleave_delta) {

981 av_log(s, AV_LOG_DEBUG,

982 "Delay between the first packet and last packet in the "

983 "muxing queue is %"PRId64" > %"PRId64": forcing output\n",

984 delta_dts, s->max_interleave_delta);

985 flush = 1;

986 }

987 }

988

989 if (si->packet_buffer.head &&

990 eof &&

991 (s->flags & AVFMT_FLAG_SHORTEST) &&

992 si->shortest_end == AV_NOPTS_VALUE) {

993 AVPacket *const top_pkt = &si->packet_buffer.head->pkt;

994

995 si->shortest_end = av_rescale_q(top_pkt->dts,

996 s->streams[top_pkt->stream_index]->time_base,

997 AV_TIME_BASE_Q);

998 }

999

1000 if (si->shortest_end != AV_NOPTS_VALUE) {

1001 while (si->packet_buffer.head) {

1002 PacketListEntry *pktl = si->packet_buffer.head;

1003 AVPacket *const top_pkt = &pktl->pkt;

1004 AVStream *const st = s->streams[top_pkt->stream_index];

1005 FFStream *const sti = ffstream(st);

1006 int64_t top_dts = av_rescale_q(top_pkt->dts, st->time_base,

1007 AV_TIME_BASE_Q);

1008

1009 if (si->shortest_end + 1 >= top_dts)

1010 break;

1011

1012 si->packet_buffer.head = pktl->next;

1013 if (!si->packet_buffer.head)

1014 si->packet_buffer.tail = NULL;

1015

1016 if (sti->last_in_packet_buffer == pktl)

1017 sti->last_in_packet_buffer = NULL;

1018

1019 av_packet_unref(&pktl->pkt);

1020 av_freep(&pktl);

1021 flush = 0;

1022 }

1023 }

1024

1025 if (stream_count && flush) {

1026 PacketListEntry *pktl = si->packet_buffer.head;

1027 AVStream *const st = s->streams[pktl->pkt.stream_index];

1028 FFStream *const sti = ffstream(st);

1029

1030 if (sti->last_in_packet_buffer == pktl)

1031 sti->last_in_packet_buffer = NULL;

1032 avpriv_packet_list_get(&si->packet_buffer, pkt);

1033

1034 return 1;

1035 } else {

1036 return 0;

1037 }

1038 }

1039

1040 int ff_interleave_packet_passthrough(AVFormatContext *s, AVPacket *pkt,

1041 int flush, int has_packet)

1042 {

1043 return has_packet;

1044 }

1045

1046 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)

1047 {

1048 AVStream *st;

1049

1050 if (stream_index < 0 || stream_index >= s->nb_streams)

1051 return AVERROR(EINVAL);

1052

1053 st = s->streams[stream_index];

1054 *offset = ffstream(st)->mux_ts_offset;

1055

1056 if (s->output_ts_offset)

1057 *offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);

1058

1059 return 0;

1060 }

1061

1062 const AVPacket *ff_interleaved_peek(AVFormatContext *s, int stream)

1063 {

1064 FFFormatContext *const si = ffformatcontext(s);

1065 PacketListEntry *pktl = si->packet_buffer.head;

1066 while (pktl) {

1067 if (pktl->pkt.stream_index == stream) {

1068 return &pktl->pkt;

1069 }

1070 pktl = pktl->next;

1071 }

1072 return NULL;

1073 }

1074

1075 static int check_bitstream(AVFormatContext *s, FFStream *sti, AVPacket *pkt)

1076 {

1077 int ret;

1078

1079 if (!(s->flags & AVFMT_FLAG_AUTO_BSF))

1080 return 1;

1081

1082 if (ffofmt(s->oformat)->check_bitstream) {

1083 if (!sti->bitstream_checked) {

1084 if ((ret = ffofmt(s->oformat)->check_bitstream(s, &sti->pub, pkt)) < 0)

1085 return ret;

1086 else if (ret == 1)

1087 sti->bitstream_checked = 1;

1088 }

1089 }

1090

1091 return 1;

1092 }

1093

1094 static int interleaved_write_packet(AVFormatContext *s, AVPacket *pkt,

1095 int flush, int has_packet)

1096 {

1097 FFFormatContext *const si = ffformatcontext(s);

1098 for (;; ) {

1099 int ret = si->interleave_packet(s, pkt, flush, has_packet);

1100 if (ret <= 0)

1101 return ret;

1102

1103 has_packet = 0;

1104

1105 ret = write_packet(s, pkt);

1106 av_packet_unref(pkt);

1107 if (ret < 0)

1108 return ret;

1109 }

1110 }

1111

1112 static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)

1113 {

1114 int ret;

1115

1116 if (s->debug & FF_FDEBUG_TS)

1117 av_log(s, AV_LOG_DEBUG, "%s size:%d dts:%s pts:%s\n", __FUNCTION__,

1118 pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));

1119

1120 guess_pkt_duration(s, st, pkt);

1121

1122 #if FF_API_COMPUTE_PKT_FIELDS2

1123 if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))

1124 return ret;

1125 #endif

1126

1127 if (interleaved) {

1128 if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))

1129 return AVERROR(EINVAL);

1130 return interleaved_write_packet(s, pkt, 0, 1);

1131 } else {

1132 return write_packet(s, pkt);

1133 }

1134 }

1135

1136 static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)

1137 {

1138 FFStream *const sti = ffstream(st);

1139 AVBSFContext *const bsfc = sti->bsfc;

1140 int ret;

1141

1142 if ((ret = av_bsf_send_packet(bsfc, pkt)) < 0) {

1143 av_log(s, AV_LOG_ERROR,

1144 "Failed to send packet to filter %s for stream %d\n",

1145 bsfc->filter->name, st->index);

1146 return ret;

1147 }

1148

1149 do {

1150 ret = av_bsf_receive_packet(bsfc, pkt);

1151 if (ret < 0) {

1152 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

1153 return 0;

1154 av_log(s, AV_LOG_ERROR, "Error applying bitstream filters to an output "

1155 "packet for stream #%d: %s\n", st->index, av_err2str(ret));

1156 if (!(s->error_recognition & AV_EF_EXPLODE) && ret != AVERROR(ENOMEM))

1157 continue;

1158 return ret;

1159 }

1160 av_packet_rescale_ts(pkt, bsfc->time_base_out, st->time_base);

1161 ret = write_packet_common(s, st, pkt, interleaved);

1162 if (ret >= 0 && !interleaved) // a successful write_packet_common already unrefed pkt for interleaved

1163 av_packet_unref(pkt);

1164 } while (ret >= 0);

1165

1166 return ret;

1167 }

1168

1169 static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)

1170 {

1171 AVStream *st;

1172 FFStream *sti;

1173 int ret = check_packet(s, pkt);

1174 if (ret < 0)

1175 return ret;

1176 st = s->streams[pkt->stream_index];

1177 sti = ffstream(st);

1178

1179 ret = prepare_input_packet(s, st, pkt);

1180 if (ret < 0)

1181 return ret;

1182

1183 ret = check_bitstream(s, sti, pkt);

1184 if (ret < 0)

1185 return ret;

1186

1187 if (sti->bsfc) {

1188 return write_packets_from_bsfs(s, st, pkt, interleaved);

1189 } else {

1190 return write_packet_common(s, st, pkt, interleaved);

1191 }

1192 }

1193

1194 int av_write_frame(AVFormatContext *s, AVPacket *in)

1195 {

1196 FFFormatContext *const si = ffformatcontext(s);

1197 AVPacket *pkt = si->parse_pkt;

1198 int ret;

1199

1200 if (!in) {

1201 if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {

1202 ret = ffofmt(s->oformat)->write_packet(s, NULL);

1203 flush_if_needed(s);

1204 if (ret >= 0 && s->pb && s->pb->error < 0)

1205 ret = s->pb->error;

1206 return ret;

1207 }

1208 return 1;

1209 }

1210

1211 if (in->flags & AV_PKT_FLAG_UNCODED_FRAME) {

1212 pkt = in;

1213 } else {

1214 /* We don't own in, so we have to make sure not to modify it.

1215 * (ff_write_chained() relies on this fact.)

1216 * The following avoids copying in's data unnecessarily.

1217 * Copying side data is unavoidable as a bitstream filter

1218 * may change it, e.g. free it on errors. */

1219 pkt->data = in->data;

1220 pkt->size = in->size;

1221 ret = av_packet_copy_props(pkt, in);

1222 if (ret < 0)

1223 return ret;

1224 if (in->buf) {

1225 pkt->buf = av_buffer_ref(in->buf);

1226 if (!pkt->buf) {

1227 ret = AVERROR(ENOMEM);

1228 goto fail;

1229 }

1230 }

1231 }

1232

1233 ret = write_packets_common(s, pkt, 0/*non-interleaved*/);

1234

1235 fail:

1236 // Uncoded frames using the noninterleaved codepath are also freed here

1237 av_packet_unref(pkt);

1238 return ret;

1239 }

1240

1241 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)

1242 {

1243 int ret;

1244

1245 if (pkt) {

1246 ret = write_packets_common(s, pkt, 1/*interleaved*/);

1247 if (ret < 0)

1248 av_packet_unref(pkt);

1249 return ret;

1250 } else {

1251 av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");

1252 return interleaved_write_packet(s, ffformatcontext(s)->parse_pkt, 1/*flush*/, 0);

1253 }

1254 }

1255

1256 int av_write_trailer(AVFormatContext *s)

1257 {

1258 FFFormatContext *const si = ffformatcontext(s);

1259 AVPacket *const pkt = si->parse_pkt;

1260 int ret1, ret = 0;

1261

1262 for (unsigned i = 0; i < s->nb_streams; i++) {

1263 AVStream *const st = s->streams[i];

1264 FFStream *const sti = ffstream(st);

1265 if (sti->bsfc) {

1266 ret1 = write_packets_from_bsfs(s, st, pkt, 1/*interleaved*/);

1267 if (ret1 < 0)

1268 av_packet_unref(pkt);

1269 if (ret >= 0)

1270 ret = ret1;

1271 }

1272 }

1273 ret1 = interleaved_write_packet(s, pkt, 1, 0);

1274 if (ret >= 0)

1275 ret = ret1;

1276

1277 if (ffofmt(s->oformat)->write_trailer) {

1278 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)

1279 avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);

1280 ret1 = ffofmt(s->oformat)->write_trailer(s);

1281 if (ret >= 0)

1282 ret = ret1;

1283 }

1284

1285 deinit_muxer(s);

1286

1287 if (s->pb)

1288 avio_flush(s->pb);

1289 if (ret == 0)

1290 ret = s->pb ? s->pb->error : 0;

1291 for (unsigned i = 0; i < s->nb_streams; i++) {

1292 av_freep(&s->streams[i]->priv_data);

1293 av_freep(&ffstream(s->streams[i])->index_entries);

1294 }

1295 if (s->oformat->priv_class)

1296 av_opt_free(s->priv_data);

1297 av_freep(&s->priv_data);

1298 av_packet_unref(si->pkt);

1299 return ret;

1300 }

1301

1302 int av_get_output_timestamp(struct AVFormatContext *s, int stream,

1303 int64_t *dts, int64_t *wall)

1304 {

1305 const FFOutputFormat *const of = ffofmt(s->oformat);

1306 if (!of || !of->get_output_timestamp)

1307 return AVERROR(ENOSYS);

1308 of->get_output_timestamp(s, stream, dts, wall);

1309 return 0;

1310 }

1311

1312 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)

1313 {

1314 int ret;

1315 const AVBitStreamFilter *bsf;

1316 FFStream *const sti = ffstream(st);

1317 AVBSFContext *bsfc;

1318

1319 av_assert0(!sti->bsfc);

1320

1321 if (!(bsf = av_bsf_get_by_name(name))) {

1322 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);

1323 return AVERROR_BSF_NOT_FOUND;

1324 }

1325

1326 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)

1327 return ret;

1328

1329 bsfc->time_base_in = st->time_base;

1330 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {

1331 av_bsf_free(&bsfc);

1332 return ret;

1333 }

1334

1335 if (args && bsfc->filter->priv_class) {

1336 if ((ret = av_set_options_string(bsfc->priv_data, args, "=", ":")) < 0) {

1337 av_bsf_free(&bsfc);

1338 return ret;

1339 }

1340 }

1341

1342 if ((ret = av_bsf_init(bsfc)) < 0) {

1343 av_bsf_free(&bsfc);

1344 return ret;

1345 }

1346

1347 sti->bsfc = bsfc;

1348

1349 av_log(NULL, AV_LOG_VERBOSE,

1350 "Automatically inserted bitstream filter '%s'; args='%s'\n",

1351 name, args ? args : "");

1352 return 1;

1353 }

1354

1355 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,

1356 AVFormatContext *src, int interleave)

1357 {

1358 int64_t pts = pkt->pts, dts = pkt->dts, duration = pkt->duration;

1359 int stream_index = pkt->stream_index;

1360 AVRational time_base = pkt->time_base;

1361 int ret;

1362

1363 pkt->stream_index = dst_stream;

1364

1365 av_packet_rescale_ts(pkt,

1366 src->streams[stream_index]->time_base,

1367 dst->streams[dst_stream]->time_base);

1368

1369 if (!interleave) {

1370 ret = av_write_frame(dst, pkt);

1371 /* We only have to backup and restore the fields that

1372 * we changed ourselves, because av_write_frame() does not

1373 * modify the packet given to it. */

1374 pkt->pts = pts;

1375 pkt->dts = dts;

1376 pkt->duration = duration;

1377 pkt->stream_index = stream_index;

1378 pkt->time_base = time_base;

1379 } else

1380 ret = av_interleaved_write_frame(dst, pkt);

1381

1382 return ret;

1383 }

1384

1385 static void uncoded_frame_free(void *unused, uint8_t *data)

1386 {

1387 av_frame_free((AVFrame **)data);

1388 av_free(data);

1389 }

1390

1391 static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,

1392 AVFrame *frame, int interleaved)

1393 {

1394 FFFormatContext *const si = ffformatcontext(s);

1395 AVPacket *pkt = si->parse_pkt;

1396

1397 av_assert0(s->oformat);

1398 if (!ffofmt(s->oformat)->write_uncoded_frame) {

1399 av_frame_free(&frame);

1400 return AVERROR(ENOSYS);

1401 }

1402

1403 if (!frame) {

1404 pkt = NULL;

1405 } else {

1406 size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;

1407 AVFrame **framep = av_mallocz(bufsize);

1408

1409 if (!framep)

1410 goto fail;

1411 pkt->buf = av_buffer_create((void *)framep, bufsize,

1412 uncoded_frame_free, NULL, 0);

1413 if (!pkt->buf) {

1414 av_free(framep);

1415 fail:

1416 av_frame_free(&frame);

1417 return AVERROR(ENOMEM);

1418 }

1419 *framep = frame;

1420

1421 pkt->data = (void *)framep;

1422 pkt->size = sizeof(frame);

1423 pkt->pts =

1424 pkt->dts = frame->pts;

1425 #if FF_API_PKT_DURATION

1426 FF_DISABLE_DEPRECATION_WARNINGS

1427 if (frame->pkt_duration)

1428 pkt->duration = frame->pkt_duration;

1429 else

1430 FF_ENABLE_DEPRECATION_WARNINGS

1431 #endif

1432 pkt->duration = frame->duration;

1433 pkt->stream_index = stream_index;

1434 pkt->flags |= AV_PKT_FLAG_UNCODED_FRAME;

1435 }

1436

1437 return interleaved ? av_interleaved_write_frame(s, pkt) :

1438 av_write_frame(s, pkt);

1439 }

1440

1441 int av_write_uncoded_frame(AVFormatContext *s, int stream_index,

1442 AVFrame *frame)

1443 {

1444 return write_uncoded_frame_internal(s, stream_index, frame, 0);

1445 }

1446

1447 int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index,

1448 AVFrame *frame)

1449 {

1450 return write_uncoded_frame_internal(s, stream_index, frame, 1);

1451 }

1452

1453 int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)

1454 {

1455 const FFOutputFormat *const of = ffofmt(s->oformat);

1456 av_assert0(of);

1457 if (!of->write_uncoded_frame)

1458 return AVERROR(ENOSYS);

1459 return of->write_uncoded_frame(s, stream_index, NULL,

1460 AV_WRITE_UNCODED_FRAME_QUERY);

1461 }

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:422

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:82

AVMEDIA_TYPE_SUBTITLE

@ AVMEDIA_TYPE_SUBTITLE

Definition: avutil.h:204

AVBSFContext::par_in

AVCodecParameters * par_in

Parameters of the input stream.

Definition: bsf.h:90

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

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

LIBAVFORMAT_IDENT

#define LIBAVFORMAT_IDENT

Definition: version.h:45

PacketList::head

PacketListEntry * head

Definition: packet_internal.h:32

avpriv_packet_list_get

int avpriv_packet_list_get(PacketList *pkt_buffer, AVPacket *pkt)

Remove the oldest AVPacket in the list and return it.

Definition: avpacket.c:575

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: defs.h:51

AVSTREAM_INIT_IN_WRITE_HEADER

#define AVSTREAM_INIT_IN_WRITE_HEADER

stream parameters initialized in avformat_write_header

Definition: avformat.h:2204

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

opt.h

FFFormatContext::interleave_packet

int(* interleave_packet)(struct AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)

The interleavement function in use.

Definition: internal.h:97

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:58

av_compare_ts

int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)

Compare two timestamps each in its own time base.

Definition: mathematics.c:147

av_opt_set_defaults

void av_opt_set_defaults(void *s)

Set the values of all AVOption fields to their default values.

Definition: opt.c:1459

AVFMT_NODIMENSIONS

#define AVFMT_NODIMENSIONS

Format does not need width/height.

Definition: avformat.h:483

FF_FDEBUG_TS

#define FF_FDEBUG_TS

Definition: avformat.h:1374

FFStream::bsfc

struct AVBSFContext * bsfc

bitstream filter to run on stream

Definition: internal.h:213

ff_interleave_packet_per_dts

int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)

Interleave an AVPacket per dts so it can be muxed.

Definition: mux.c:923

avformat_alloc_output_context2

int avformat_alloc_output_context2(AVFormatContext **avctx, const AVOutputFormat *oformat, const char *format, const char *filename)

Allocate an AVFormatContext for an output format.

Definition: mux.c:91

comp

static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)

Definition: eamad.c:80

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: codec_par.h:54

ffformatcontext

static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)

Definition: internal.h:191

interleaved_write_packet

static int interleaved_write_packet(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)

Definition: mux.c:1094

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

AV_DISPOSITION_ATTACHED_PIC

#define AV_DISPOSITION_ATTACHED_PIC

The stream is stored in the file as an attached picture/"cover art" (e.g.

Definition: avformat.h:769

AVFMT_NOTIMESTAMPS

#define AVFMT_NOTIMESTAMPS

Format does not need / have any timestamps.

Definition: avformat.h:479

AV_TIME_BASE_Q

#define AV_TIME_BASE_Q

Internal time base represented as fractional value.

Definition: avutil.h:260

AVCodecTag::id

enum AVCodecID id

Definition: internal.h:50

AVBitStreamFilter::name

const char * name

Definition: bsf.h:112

init_muxer

static int init_muxer(AVFormatContext *s, AVDictionary **options)

Definition: mux.c:181

AV_CODEC_ID_RAWVIDEO

@ AV_CODEC_ID_RAWVIDEO

Definition: codec_id.h:65

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:99

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:330

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1172

FFStream::interleaver_chunk_size

int64_t interleaver_chunk_size

Definition: internal.h:256

internal.h

av_write_uncoded_frame

int av_write_uncoded_frame(AVFormatContext *s, int stream_index, AVFrame *frame)

Write an uncoded frame to an output media file.

Definition: mux.c:1441

AVPacket::data

uint8_t * data

Definition: packet.h:374

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:927

data

const char data[16]

Definition: mxf.c:146

FFFormatContext::initialized

int initialized

Whether or not avformat_init_output has already been called.

Definition: internal.h:163

AV_DICT_IGNORE_SUFFIX

#define AV_DICT_IGNORE_SUFFIX

Return first entry in a dictionary whose first part corresponds to the search key,...

Definition: dict.h:75

AVFMT_FLAG_SHORTEST

#define AVFMT_FLAG_SHORTEST

Stop muxing when the shortest stream stops.

Definition: avformat.h:1242

ff_toupper4

unsigned int ff_toupper4(unsigned int x)

Definition: to_upper4.h:29

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

AVPacket::duration

int64_t duration

Duration of this packet in AVStream->time_base units, 0 if unknown.

Definition: packet.h:392

AVCodecParameters::codec_tag

uint32_t codec_tag

Additional information about the codec (corresponds to the AVI FOURCC).

Definition: codec_par.h:66

max

#define max(a, b)

Definition: cuda_runtime.h:33

mathematics.h

AVDictionary

Definition: dict.c:32

AVChannelLayout::order

enum AVChannelOrder order

Channel order used in this layout.

Definition: channel_layout.h:306

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

av_buffer_ref

AVBufferRef * av_buffer_ref(const AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:103

av_write_uncoded_frame_query

int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)

Test whether a muxer supports uncoded frame.

Definition: mux.c:1453

avformat_init_output

int avformat_init_output(AVFormatContext *s, AVDictionary **options)

Allocate the stream private data and initialize the codec, but do not write the header.

Definition: mux.c:430

cffstream

static const av_always_inline FFStream * cffstream(const AVStream *st)

Definition: internal.h:418

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:311

av_bsf_free

void av_bsf_free(AVBSFContext **pctx)

Free a bitstream filter context and everything associated with it; write NULL into the supplied point...

Definition: bsf.c:53

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:429

ff_get_muxer_ts_offset

int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset)

Definition: mux.c:1046

AVBSFContext

The bitstream filter state.

Definition: bsf.h:68

FFOutputFormat::p

AVOutputFormat p

The public AVOutputFormat.

Definition: mux.h:34

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

FFFormatContext::shortest_end

int64_t shortest_end

Timestamp of the end of the shortest stream.

Definition: internal.h:158

avio_write_marker

void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)

Mark the written bytestream as a specific type.

Definition: aviobuf.c:482

av_set_options_string

int av_set_options_string(void *ctx, const char *opts, const char *key_val_sep, const char *pairs_sep)

Parse the key/value pairs list in opts.

Definition: opt.c:1587

FFStream::is_intra_only

int is_intra_only

Definition: internal.h:242

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:771

bsf.h

deinit_muxer

static void deinit_muxer(AVFormatContext *s)

Definition: mux.c:420

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:413

fail

#define fail()

Definition: checkasm.h:134

AVFMT_FLAG_AUTO_BSF

#define AVFMT_FLAG_AUTO_BSF

Add bitstream filters as requested by the muxer.

Definition: avformat.h:1243

val

static double val(void *priv, double ch)

Definition: aeval.c:77

AVFMT_AVOID_NEG_TS_MAKE_ZERO

#define AVFMT_AVOID_NEG_TS_MAKE_ZERO

Shift timestamps so that they start at 0.

Definition: avformat.h:1437

AV_DISPOSITION_TIMED_THUMBNAILS

#define AV_DISPOSITION_TIMED_THUMBNAILS

The stream is sparse, and contains thumbnail images, often corresponding to chapter markers.

Definition: avformat.h:774

pts

static int64_t pts

Definition: transcode_aac.c:653

AV_ROUND_UP

@ AV_ROUND_UP

Round toward +infinity.

Definition: mathematics.h:83

AVRational::num

int num

Numerator.

Definition: rational.h:59

FFStream::priv_pts

FFFrac * priv_pts

Definition: internal.h:244

av_get_bits_per_sample

int av_get_bits_per_sample(enum AVCodecID codec_id)

Return codec bits per sample.

Definition: utils.c:583

avassert.h

AV_LOG_TRACE

#define AV_LOG_TRACE

Extremely verbose debugging, useful for libav* development.

Definition: log.h:206

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

AVCodecTag

Definition: internal.h:49

duration

int64_t duration

Definition: movenc.c:64

av_dict_get

AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)

Get a dictionary entry with matching key.

Definition: dict.c:60

av_opt_set_dict

int av_opt_set_dict(void *obj, AVDictionary **options)

Set all the options from a given dictionary on an object.

Definition: opt.c:1767

AVCodecDescriptor

This struct describes the properties of a single codec described by an AVCodecID.

Definition: codec_desc.h:38

#define s(width, name)

Definition: cbs_vp9.c:256

FFFormatContext::packet_buffer

PacketList packet_buffer

This buffer is only needed when packets were already buffered but not decoded, for example to get the...

Definition: internal.h:105

format

AVCodecParameters::sample_aspect_ratio

AVRational sample_aspect_ratio

Video only.

Definition: codec_par.h:138

AVDictionaryEntry::key

char * key

Definition: dict.h:90

frame_size

int frame_size

Definition: mxfenc.c:2205

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AV_CODEC_ID_VP9

@ AV_CODEC_ID_VP9

Definition: codec_id.h:220

AVCodecParameters::width

int width

Video only.

Definition: codec_par.h:128

AV_CHANNEL_ORDER_UNSPEC

@ AV_CHANNEL_ORDER_UNSPEC

Only the channel count is specified, without any further information about the channel order.

Definition: channel_layout.h:112

av_q2d

static double av_q2d(AVRational a)

Convert an AVRational to a double.

Definition: rational.h:104

av_channel_layout_from_mask

FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)

Initialize a native channel layout from a bitmask indicating which channels are present.

Definition: channel_layout.c:391

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

write_packets_from_bsfs

static int write_packets_from_bsfs(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)

Definition: mux.c:1136

ffofmt

static const FFOutputFormat * ffofmt(const AVOutputFormat *fmt)

Definition: mux.h:136

AVBSFContext::time_base_in

AVRational time_base_in

The timebase used for the timestamps of the input packets.

Definition: bsf.h:102

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

av_bsf_alloc

int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)

Allocate a context for a given bitstream filter.

Definition: bsf.c:105

AVOutputFormat::codec_tag

const struct AVCodecTag *const * codec_tag

List of supported codec_id-codec_tag pairs, ordered by "better choice first".

Definition: avformat.h:533

av_interleaved_write_uncoded_frame

int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index, AVFrame *frame)

Write an uncoded frame to an output media file.

Definition: mux.c:1447

AVMEDIA_TYPE_DATA

@ AVMEDIA_TYPE_DATA

Opaque data information usually continuous.

Definition: avutil.h:203

AudioData::data

uint8_t * data

samples buffer

Definition: swresample_internal.h:47

avformat_write_header

int avformat_write_header(AVFormatContext *s, AVDictionary **options)

Allocate the stream private data and write the stream header to an output media file.

Definition: mux.c:451

PacketList::tail

PacketListEntry * tail

Definition: packet_internal.h:32

init_pts

static int init_pts(AVFormatContext *s)

Definition: mux.c:362

if(ret)

Definition: filter_design.txt:179

FFFormatContext

Definition: internal.h:71

avio_flush

void avio_flush(AVIOContext *s)

Force flushing of buffered data.

Definition: aviobuf.c:244

compute_muxer_pkt_fields

static FF_DISABLE_DEPRECATION_WARNINGS int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)

Definition: mux.c:493

AVFormatContext

Format I/O context.

Definition: avformat.h:1104

FFStream::pub

AVStream pub

The public context.

Definition: internal.h:200

AVPacket::buf

AVBufferRef * buf

A reference to the reference-counted buffer where the packet data is stored.

Definition: packet.h:357

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:861

av_bsf_init

int av_bsf_init(AVBSFContext *ctx)

Prepare the filter for use, after all the parameters and options have been set.

Definition: bsf.c:150

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

AVFMT_AVOID_NEG_TS_DISABLED

#define AVFMT_AVOID_NEG_TS_DISABLED

Do not shift timestamps even when they are negative.

Definition: avformat.h:1435

fabs

static __device__ float fabs(float a)

Definition: cuda_runtime.h:182

FFStream::bitstream_checked

int bitstream_checked

Whether or not check_bitstream should still be run on each packet.

Definition: internal.h:218

AVStream::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avformat.h:877

NULL

#define NULL

Definition: coverity.c:32

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

av_bsf_receive_packet

int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)

Retrieve a filtered packet.

Definition: bsf.c:231

AVIO_DATA_MARKER_TRAILER

@ AVIO_DATA_MARKER_TRAILER

Trailer data, which doesn't contain actual content, but only for finalizing the output file.

Definition: avio.h:145

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

FFOutputFormat::write_packet

int(* write_packet)(AVFormatContext *, AVPacket *pkt)

Write a packet.

Definition: mux.h:53

guess_pkt_duration

static FF_ENABLE_DEPRECATION_WARNINGS void guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)

Definition: mux.c:589

FFOutputFormat::deinit

void(* deinit)(AVFormatContext *)

Deinitialize format.

Definition: mux.h:123

AVERROR_BSF_NOT_FOUND

#define AVERROR_BSF_NOT_FOUND

Bitstream filter not found.

Definition: error.h:51

AVBitStreamFilter::priv_class

const AVClass * priv_class

A class for the private data, used to declare bitstream filter private AVOptions.

Definition: bsf.h:130

write_packets_common

static int write_packets_common(AVFormatContext *s, AVPacket *pkt, int interleaved)

Definition: mux.c:1169

FFOutputFormat

Definition: mux.h:30

av_opt_free

void av_opt_free(void *obj)

Free all allocated objects in obj.

Definition: opt.c:1719

AVOutputFormat::priv_class

const AVClass * priv_class

AVClass for the private context.

Definition: avformat.h:536

av_write_frame

int av_write_frame(AVFormatContext *s, AVPacket *in)

Write a packet to an output media file.

Definition: mux.c:1194

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:213

FFStream::interleaver_chunk_duration

int64_t interleaver_chunk_duration

Definition: internal.h:257

av_packet_move_ref

void av_packet_move_ref(AVPacket *dst, AVPacket *src)

Move every field in src to dst and reset src.

Definition: avpacket.c:479

PacketListEntry::next

struct PacketListEntry * next

Definition: packet_internal.h:27

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:178

av_buffer_create

AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)

Create an AVBuffer from an existing array.

Definition: buffer.c:55

AVStream::nb_frames

int64_t nb_frames

number of frames in this stream if known or 0

Definition: avformat.h:899

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

validate_codec_tag

static int validate_codec_tag(const AVFormatContext *s, const AVStream *st)

Definition: mux.c:147

AVOutputFormat::flags

int flags

can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...

Definition: avformat.h:527

AVOID_NEGATIVE_TS_ENABLED

#define AVOID_NEGATIVE_TS_ENABLED(status)

Definition: internal.h:92

interleave

static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)

Definition: vf_il.c:108

options

const OptionDef options[]

Definition: af_crystalizer.c:122

AVPacket::size

int size

Definition: packet.h:375

FFFormatContext::parse_pkt

AVPacket * parse_pkt

The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.

Definition: internal.h:134

avformat_alloc_context

AVFormatContext * avformat_alloc_context(void)

Allocate an AVFormatContext.

Definition: options.c:166

av_codec_get_tag

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

Get the codec tag for the given codec id id.

FFFrac::val

int64_t val

Definition: internal.h:67

FFStream

Definition: internal.h:196

AV_CODEC_PROP_REORDER

#define AV_CODEC_PROP_REORDER

Codec supports frame reordering.

Definition: codec_desc.h:92

av_bsf_send_packet

int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)

Submit a packet for filtering.

Definition: bsf.c:203

uncoded_frame_free

static void uncoded_frame_free(void *unused, uint8_t *data)

Definition: mux.c:1385

FFOutputFormat::write_uncoded_frame

int(* write_uncoded_frame)(AVFormatContext *, int stream_index, AVFrame **frame, unsigned flags)

Write an uncoded AVFrame.

Definition: mux.h:98

av_err2str

#define av_err2str(errnum)

Convenience macro, the return value should be used only directly in function arguments but never stan...

Definition: error.h:121

FFOutputFormat::check_bitstream

int(* check_bitstream)(AVFormatContext *s, AVStream *st, const AVPacket *pkt)

Set up any necessary bitstream filtering and extract any extra data needed for the global header.

Definition: mux.h:132

AV_PKT_FLAG_UNCODED_FRAME

#define AV_PKT_FLAG_UNCODED_FRAME

Definition: mux.c:487

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

AVFMT_ALLOW_FLUSH

#define AVFMT_ALLOW_FLUSH

Format allows flushing.

Definition: avformat.h:488

av_get_audio_frame_duration2

int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)

This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...

Definition: utils.c:837

PacketListEntry::pkt

AVPacket pkt

Definition: packet_internal.h:28

AVFMT_NOFILE

#define AVFMT_NOFILE

Demuxer will use avio_open, no opened file should be provided by the caller.

Definition: avformat.h:468

write_uncoded_frame_internal

static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index, AVFrame *frame, int interleaved)

Definition: mux.c:1391

AVStream::sample_aspect_ratio

AVRational sample_aspect_ratio

sample aspect ratio (0 if unknown)

Definition: avformat.h:916

AVFMT_NOSTREAMS

#define AVFMT_NOSTREAMS

Format does not require any streams.

Definition: avformat.h:484

AV_OPT_SEARCH_CHILDREN

#define AV_OPT_SEARCH_CHILDREN

Search in possible children of the given object first.

Definition: opt.h:563

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:373

FF_COMPLIANCE_NORMAL

#define FF_COMPLIANCE_NORMAL

Definition: defs.h:60

FFOutputFormat::interleave_packet

int(* interleave_packet)(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)

A format-specific function for interleavement.

Definition: mux.h:71

offset

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 offset

Definition: writing_filters.txt:86

prepare_input_packet

static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)

Definition: mux.c:761

av_opt_set_dict2

int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)

Set all the options from a given dictionary on an object.

Definition: opt.c:1743

av_packet_make_refcounted

int av_packet_make_refcounted(AVPacket *pkt)

Ensure the data described by a given packet is reference counted.

Definition: avpacket.c:485

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:380

av_dict_free

void av_dict_free(AVDictionary **pm)

Free all the memory allocated for an AVDictionary struct and all keys and values.

Definition: dict.c:223

av_packet_rescale_ts

void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)

Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.

Definition: avpacket.c:526

FFOutputFormat::priv_data_size

int priv_data_size

size of private data so that it can be allocated in the wrapper

Definition: mux.h:38

FFOutputFormat::write_header

int(* write_header)(AVFormatContext *)

Definition: mux.h:45

av_write_trailer

int av_write_trailer(AVFormatContext *s)

Write the stream trailer to an output media file and free the file private data.

Definition: mux.c:1256

av_assert2

#define av_assert2(cond)

assert() equivalent, that does lie in speed critical code.

Definition: avassert.h:64

av_packet_copy_props

int av_packet_copy_props(AVPacket *dst, const AVPacket *src)

Copy only "properties" fields from src to dst.

Definition: avpacket.c:385

ff_is_intra_only

int ff_is_intra_only(enum AVCodecID id)

Definition: avformat.c:835

ff_interleaved_peek

const AVPacket * ff_interleaved_peek(AVFormatContext *s, int stream)

Find the next packet in the interleaving queue for the given stream.

Definition: mux.c:1062

PacketListEntry

Definition: packet_internal.h:26

FFStream::mux_ts_offset

int64_t mux_ts_offset

Timestamp offset added to timestamps before muxing.

Definition: internal.h:310

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:50

AVOutputFormat

Definition: avformat.h:507

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

Definition: cbs_h2645.c:269

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:367

internal.h

AVCodecParameters::height

int height

Definition: codec_par.h:129

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:254

AVCodecParameters::block_align

int block_align

Audio only.

Definition: codec_par.h:185

CHUNK_START

#define CHUNK_START

Definition: mux.c:817

check_bitstream

static int check_bitstream(AVFormatContext *s, FFStream *sti, AVPacket *pkt)

Definition: mux.c:1075

ff_interleave_add_packet

int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))

Add packet to an AVFormatContext's packet_buffer list, determining its interleaved position using com...

Definition: mux.c:819

av_get_output_timestamp

int av_get_output_timestamp(struct AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)

Get timing information for the data currently output.

Definition: mux.c:1302

FFStream::reorder

int reorder

Set to 1 if the codec allows reordering, so pts can be different from dts.

Definition: internal.h:206

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:53

AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE

#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE

Shift timestamps so they are non negative.

Definition: avformat.h:1436

write_packet

static int write_packet(AVFormatContext *s, AVPacket *pkt)

Shift timestamps and call muxer; the original pts/dts are not kept.

Definition: mux.c:706

AVMEDIA_TYPE_ATTACHMENT

@ AVMEDIA_TYPE_ATTACHMENT

Opaque data information usually sparse.

Definition: avutil.h:205

FFStream::pts_buffer

int64_t pts_buffer[MAX_REORDER_DELAY+1]

Definition: internal.h:349

#define tb

Definition: regdef.h:68

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:254

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

av_rescale

int64_t av_rescale(int64_t a, int64_t b, int64_t c)

Rescale a 64-bit integer with rounding to nearest.

Definition: mathematics.c:129

AVBSFContext::time_base_out

AVRational time_base_out

The timebase used for the timestamps of the output packets.

Definition: bsf.h:108

FFStream::last_in_packet_buffer

PacketListEntry * last_in_packet_buffer

last packet in packet_buffer for this stream when muxing.

Definition: internal.h:375

AVIO_DATA_MARKER_UNKNOWN

@ AVIO_DATA_MARKER_UNKNOWN

This is any, unlabelled data.

Definition: avio.h:140

AVFMT_TS_NEGATIVE

#define AVFMT_TS_NEGATIVE

Format allows muxing negative timestamps.

Definition: avformat.h:492

MAX_REORDER_DELAY

@ MAX_REORDER_DELAY

Definition: vaapi_encode.h:45

AVFMT_TS_NONSTRICT

#define AVFMT_TS_NONSTRICT

Format does not require strictly increasing timestamps, but they must still be monotonic.

Definition: avformat.h:489

av_cmp_q

static int av_cmp_q(AVRational a, AVRational b)

Compare two rationals.

Definition: rational.h:89

version.h

AVBSFContext::priv_data

void * priv_data

Opaque filter-specific private data.

Definition: bsf.h:83

AVStream::disposition

int disposition

Stream disposition - a combination of AV_DISPOSITION_* flags.

Definition: avformat.h:907

FFOutputFormat::get_output_timestamp

void(* get_output_timestamp)(AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)

Definition: mux.h:82

tag

uint32_t tag

Definition: movenc.c:1641

AVFMT_FLAG_BITEXACT

#define AVFMT_FLAG_BITEXACT

When muxing, try to avoid writing any random/volatile data to the output.

Definition: avformat.h:1239

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:838

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

interleave_compare_dts

static int interleave_compare_dts(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)

Definition: mux.c:893

avformat.h

dict.h

frac_init

static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)

f = val + (num / den) + 0.5.

Definition: mux.c:53

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:844

compare

static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)

Definition: vf_find_rect.c:95

AVBitStreamFilter

Definition: bsf.h:111

AVRational::den

int den

Denominator.

Definition: rational.h:60

write_packet_common

static int write_packet_common(AVFormatContext *s, AVStream *st, AVPacket *pkt, int interleaved)

Definition: mux.c:1112

AVIO_DATA_MARKER_HEADER

@ AVIO_DATA_MARKER_HEADER

Header data; this needs to be present for the stream to be decodeable.

Definition: avio.h:120

avformat_free_context

void avformat_free_context(AVFormatContext *s)

Free an AVFormatContext and all its streams.

Definition: avformat.c:96

AV_WRITE_UNCODED_FRAME_QUERY

@ AV_WRITE_UNCODED_FRAME_QUERY

Query whether the feature is possible on this stream.

Definition: mux.h:208

AVSTREAM_INIT_IN_INIT_OUTPUT

#define AVSTREAM_INIT_IN_INIT_OUTPUT

stream parameters initialized in avformat_init_output

Definition: avformat.h:2205

AVPacket::stream_index

int stream_index

Definition: packet.h:376

FFStream::index_entries

AVIndexEntry * index_entries

Only used if the format does not support seeking natively.

Definition: internal.h:251

FF_DISABLE_DEPRECATION_WARNINGS

#define FF_DISABLE_DEPRECATION_WARNINGS

Definition: internal.h:81

AVBSFContext::filter

const struct AVBitStreamFilter * filter

The bitstream filter this context is an instance of.

Definition: bsf.h:77

flush_if_needed

static void flush_if_needed(AVFormatContext *s)

Definition: mux.c:410

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:270

desc

const char * desc

Definition: libsvtav1.c:83

FFFormatContext::streams_initialized

int streams_initialized

Whether or not avformat_init_output fully initialized streams.

Definition: internal.h:168

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

av_guess_format

const AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)

Return the output format in the list of registered output formats which best matches the provided par...

Definition: format.c:53

flush

void(* flush)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:367

FFFrac::num

int64_t num

Definition: internal.h:67

packet_internal.h

handle_avoid_negative_ts

static void handle_avoid_negative_ts(FFFormatContext *si, FFStream *sti, AVPacket *pkt)

Definition: mux.c:620

AVCodecParameters::video_delay

int video_delay

Video only.

Definition: codec_par.h:157

FFFormatContext::pkt

AVPacket * pkt

Used to hold temporary packets for the generic demuxing code.

Definition: internal.h:141

check_packet

static int check_packet(AVFormatContext *s, AVPacket *pkt)

Definition: mux.c:745

ff_interleave_packet_passthrough

int ff_interleave_packet_passthrough(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)

Interleave packets directly in the order in which they arrive without any sort of buffering.

Definition: mux.c:1040

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

AVDictionaryEntry

Definition: dict.h:89

SwrContext::in

AudioData in

input audio data

Definition: swresample_internal.h:153

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: codec_par.h:62

AVPacket

This structure stores compressed data.

Definition: packet.h:351

av_interleaved_write_frame

int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)

Write a packet to an output media file ensuring correct interleaving.

Definition: mux.c:1241

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:86

src

INIT_CLIP pixel * src

Definition: h264pred_template.c:418

av_dict_copy

int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)

Copy entries from one AVDictionary struct into another.

Definition: dict.c:237

FFStream::cur_dts

int64_t cur_dts

Definition: internal.h:410

FFOutputFormat::write_trailer

int(* write_trailer)(AVFormatContext *)

Definition: mux.h:54

frac_add

static void frac_add(FFFrac *f, int64_t incr)

Fractional addition to f: f = f + (incr / f->den).

Definition: mux.c:71

timestamp.h

AV_CODEC_ID_VP8

@ AV_CODEC_ID_VP8

Definition: codec_id.h:192

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

av_ts2str

#define av_ts2str(ts)

Convenience macro, the return value should be used only directly in function arguments but never stan...

Definition: timestamp.h:54

AVFMT_FLAG_FLUSH_PACKETS

#define AVFMT_FLAG_FLUSH_PACKETS

Flush the AVIOContext every packet.

Definition: avformat.h:1232

MKTAG

#define MKTAG(a, b, c, d)

Definition: macros.h:55

FFOutputFormat::init

int(* init)(AVFormatContext *)

Initialize format.

Definition: mux.h:114

avcodec_descriptor_get

const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)

Definition: codec_desc.c:3664

AVFMT_AVOID_NEG_TS_AUTO

#define AVFMT_AVOID_NEG_TS_AUTO

Enabled when required by target format.

Definition: avformat.h:1434

FFFrac

The exact value of the fractional number is: 'val + num / den'.

Definition: internal.h:66

FFFrac::den

int64_t den

Definition: internal.h:67

AVCodecTag::tag

unsigned int tag

Definition: internal.h:51

FFFormatContext::pub

AVFormatContext pub

The public context.

Definition: internal.h:75

ff_stream_add_bitstream_filter

int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)

Add a bitstream filter to a stream.

Definition: mux.c:1312

FFStream::lowest_ts_allowed

int64_t lowest_ts_allowed

This is the lowest ts allowed in this track; it may be set by the muxer during init or write_header a...

Definition: internal.h:317

FFFormatContext::avoid_negative_ts_status

enum FFFormatContext::@282 avoid_negative_ts_status

Whether the timestamp shift offset has already been determined.

av_rescale_q_rnd

int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)

Rescale a 64-bit integer by 2 rational numbers with specified rounding.

Definition: mathematics.c:134

avcodec_parameters_copy

int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)

Copy the contents of src to dst.

Definition: codec_par.c:74

AVPacket::time_base

AVRational time_base

Time base of the packet's timestamps.

Definition: packet.h:418

AVPacket::side_data_elems

int side_data_elems

Definition: packet.h:386

FFFormatContext::nb_interleaved_streams

int nb_interleaved_streams

Number of streams relevant for interleaving.

Definition: internal.h:81

av_fourcc2str

#define av_fourcc2str(fourcc)

Definition: avutil.h:354

AVIO_DATA_MARKER_FLUSH_POINT

@ AVIO_DATA_MARKER_FLUSH_POINT

A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...

Definition: avio.h:151

av_bsf_get_by_name

const AVBitStreamFilter * av_bsf_get_by_name(const char *name)

Definition: bitstream_filters.c:83

mux.h

ff_write_chained

int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt, AVFormatContext *src, int interleave)

Write a packet to another muxer than the one the user originally intended.

Definition: mux.c:1355

FFFormatContext::avoid_negative_ts_use_pts

int avoid_negative_ts_use_pts

Definition: internal.h:153

Generated on Tue Feb 28 2023 21:33:03 for FFmpeg by doxygen 1.8.17