FFmpeg: doc/examples/mux.c Source File

FFmpeg

[フレーム]

mux.c

Go to the documentation of this file.

1 /*

3 *

4 * Permission is hereby granted, free of charge, to any person obtaining a copy

5 * of this software and associated documentation files (the "Software"), to deal

6 * in the Software without restriction, including without limitation the rights

7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8 * copies of the Software, and to permit persons to whom the Software is

9 * furnished to do so, subject to the following conditions:

10 *

11 * The above copyright notice and this permission notice shall be included in

12 * all copies or substantial portions of the Software.

13 *

14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20 * THE SOFTWARE.

21 */

23 /**

24 * @file libavformat muxing API usage example

25 * @example mux.c

26 *

27 * Generate a synthetic audio and video signal and mux them to a media file in

28 * any supported libavformat format. The default codecs are used.

29 */

31 #include <stdlib.h>

32 #include <stdio.h>

33 #include <string.h>

34 #include <math.h>

36 #include <libavutil/avassert.h>

37 #include <libavutil/channel_layout.h>

38 #include <libavutil/opt.h>

39 #include <libavutil/mathematics.h>

40 #include <libavutil/timestamp.h>

41 #include <libavcodec/avcodec.h>

42 #include <libavformat/avformat.h>

43 #include <libswscale/swscale.h>

44 #include <libswresample/swresample.h>

46 #define STREAM_DURATION 10.0

47 #define STREAM_FRAME_RATE 25 /* 25 images/s */

48 #define STREAM_PIX_FMT AV_PIX_FMT_YUV420P /* default pix_fmt */

50 #define SCALE_FLAGS SWS_BICUBIC

52 // a wrapper around a single output AVStream

53 typedef struct OutputStream {

54 AVStream *st;

55 AVCodecContext *enc;

57 /* pts of the next frame that will be generated */

58 int64_t next_pts;

59 int samples_count;

61 AVFrame *frame;

62 AVFrame *tmp_frame;

64 AVPacket *tmp_pkt;

66 float t, tincr, tincr2;

68 struct SwsContext *sws_ctx;

69 struct SwrContext *swr_ctx;

70 } OutputStream;

72 static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt)

73 {

74 AVRational *time_base = &fmt_ctx->streams[pkt->stream_index]->time_base;

76 printf("pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",

77 av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, time_base),

78 av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, time_base),

79 av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, time_base),

80 pkt->stream_index);

81 }

83 static int write_frame(AVFormatContext *fmt_ctx, AVCodecContext *c,

84 AVStream *st, AVFrame *frame, AVPacket *pkt)

85 {

86 int ret;

88 // send the frame to the encoder

89 ret = avcodec_send_frame(c, frame);

90 if (ret < 0) {

91 fprintf(stderr, "Error sending a frame to the encoder: %s\n",

92 av_err2str(ret));

93 exit(1);

94 }

96 while (ret >= 0) {

97 ret = avcodec_receive_packet(c, pkt);

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

99 break;

100 else if (ret < 0) {

101 fprintf(stderr, "Error encoding a frame: %s\n", av_err2str(ret));

102 exit(1);

103 }

104

105 /* rescale output packet timestamp values from codec to stream timebase */

106 av_packet_rescale_ts(pkt, c->time_base, st->time_base);

107 pkt->stream_index = st->index;

108

109 /* Write the compressed frame to the media file. */

110 log_packet(fmt_ctx, pkt);

111 ret = av_interleaved_write_frame(fmt_ctx, pkt);

112 /* pkt is now blank (av_interleaved_write_frame() takes ownership of

113 * its contents and resets pkt), so that no unreferencing is necessary.

114 * This would be different if one used av_write_frame(). */

115 if (ret < 0) {

116 fprintf(stderr, "Error while writing output packet: %s\n", av_err2str(ret));

117 exit(1);

118 }

119 }

120

121 return ret == AVERROR_EOF ? 1 : 0;

122 }

123

124 /* Add an output stream. */

125 static void add_stream(OutputStream *ost, AVFormatContext *oc,

126 const AVCodec **codec,

127 enum AVCodecID codec_id)

128 {

129 AVCodecContext *c;

130 int i;

131

132 /* find the encoder */

133 *codec = avcodec_find_encoder(codec_id);

134 if (!(*codec)) {

135 fprintf(stderr, "Could not find encoder for '%s'\n",

136 avcodec_get_name(codec_id));

137 exit(1);

138 }

139

140 ost->tmp_pkt = av_packet_alloc();

141 if (!ost->tmp_pkt) {

142 fprintf(stderr, "Could not allocate AVPacket\n");

143 exit(1);

144 }

145

146 ost->st = avformat_new_stream(oc, NULL);

147 if (!ost->st) {

148 fprintf(stderr, "Could not allocate stream\n");

149 exit(1);

150 }

151 ost->st->id = oc->nb_streams-1;

152 c = avcodec_alloc_context3(*codec);

153 if (!c) {

154 fprintf(stderr, "Could not alloc an encoding context\n");

155 exit(1);

156 }

157 ost->enc = c;

158

159 switch ((*codec)->type) {

160 case AVMEDIA_TYPE_AUDIO:

161 c->sample_fmt = (*codec)->sample_fmts ?

162 (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;

163 c->bit_rate = 64000;

164 c->sample_rate = 44100;

165 if ((*codec)->supported_samplerates) {

166 c->sample_rate = (*codec)->supported_samplerates[0];

167 for (i = 0; (*codec)->supported_samplerates[i]; i++) {

168 if ((*codec)->supported_samplerates[i] == 44100)

169 c->sample_rate = 44100;

170 }

171 }

172 av_channel_layout_copy(&c->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO);

173 ost->st->time_base = (AVRational){ 1, c->sample_rate };

174 break;

175

176 case AVMEDIA_TYPE_VIDEO:

177 c->codec_id = codec_id;

178

179 c->bit_rate = 400000;

180 /* Resolution must be a multiple of two. */

181 c->width = 352;

182 c->height = 288;

183 /* timebase: This is the fundamental unit of time (in seconds) in terms

184 * of which frame timestamps are represented. For fixed-fps content,

185 * timebase should be 1/framerate and timestamp increments should be

186 * identical to 1. */

187 ost->st->time_base = (AVRational){ 1, STREAM_FRAME_RATE };

188 c->time_base = ost->st->time_base;

189

190 c->gop_size = 12; /* emit one intra frame every twelve frames at most */

191 c->pix_fmt = STREAM_PIX_FMT;

192 if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {

193 /* just for testing, we also add B-frames */

194 c->max_b_frames = 2;

195 }

196 if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {

197 /* Needed to avoid using macroblocks in which some coeffs overflow.

198 * This does not happen with normal video, it just happens here as

199 * the motion of the chroma plane does not match the luma plane. */

200 c->mb_decision = 2;

201 }

202 break;

203

204 default:

205 break;

206 }

207

208 /* Some formats want stream headers to be separate. */

209 if (oc->oformat->flags & AVFMT_GLOBALHEADER)

210 c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

211 }

212

213 /**************************************************************/

214 /* audio output */

215

216 static AVFrame *alloc_audio_frame(enum AVSampleFormat sample_fmt,

217 const AVChannelLayout *channel_layout,

218 int sample_rate, int nb_samples)

219 {

220 AVFrame *frame = av_frame_alloc();

221 if (!frame) {

222 fprintf(stderr, "Error allocating an audio frame\n");

223 exit(1);

224 }

225

226 frame->format = sample_fmt;

227 av_channel_layout_copy(&frame->ch_layout, channel_layout);

228 frame->sample_rate = sample_rate;

229 frame->nb_samples = nb_samples;

230

231 if (nb_samples) {

232 if (av_frame_get_buffer(frame, 0) < 0) {

233 fprintf(stderr, "Error allocating an audio buffer\n");

234 exit(1);

235 }

236 }

237

238 return frame;

239 }

240

241 static void open_audio(AVFormatContext *oc, const AVCodec *codec,

242 OutputStream *ost, AVDictionary *opt_arg)

243 {

244 AVCodecContext *c;

245 int nb_samples;

246 int ret;

247 AVDictionary *opt = NULL;

248

249 c = ost->enc;

250

251 /* open it */

252 av_dict_copy(&opt, opt_arg, 0);

253 ret = avcodec_open2(c, codec, &opt);

254 av_dict_free(&opt);

255 if (ret < 0) {

256 fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));

257 exit(1);

258 }

259

260 /* init signal generator */

261 ost->t = 0;

262 ost->tincr = 2 * M_PI * 110.0 / c->sample_rate;

263 /* increment frequency by 110 Hz per second */

264 ost->tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;

265

266 if (c->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)

267 nb_samples = 10000;

268 else

269 nb_samples = c->frame_size;

270

271 ost->frame = alloc_audio_frame(c->sample_fmt, &c->ch_layout,

272 c->sample_rate, nb_samples);

273 ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, &c->ch_layout,

274 c->sample_rate, nb_samples);

275

276 /* copy the stream parameters to the muxer */

277 ret = avcodec_parameters_from_context(ost->st->codecpar, c);

278 if (ret < 0) {

279 fprintf(stderr, "Could not copy the stream parameters\n");

280 exit(1);

281 }

282

283 /* create resampler context */

284 ost->swr_ctx = swr_alloc();

285 if (!ost->swr_ctx) {

286 fprintf(stderr, "Could not allocate resampler context\n");

287 exit(1);

288 }

289

290 /* set options */

291 av_opt_set_chlayout (ost->swr_ctx, "in_chlayout", &c->ch_layout, 0);

292 av_opt_set_int (ost->swr_ctx, "in_sample_rate", c->sample_rate, 0);

293 av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);

294 av_opt_set_chlayout (ost->swr_ctx, "out_chlayout", &c->ch_layout, 0);

295 av_opt_set_int (ost->swr_ctx, "out_sample_rate", c->sample_rate, 0);

296 av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt", c->sample_fmt, 0);

297

298 /* initialize the resampling context */

299 if ((ret = swr_init(ost->swr_ctx)) < 0) {

300 fprintf(stderr, "Failed to initialize the resampling context\n");

301 exit(1);

302 }

303 }

304

305 /* Prepare a 16 bit dummy audio frame of 'frame_size' samples and

306 * 'nb_channels' channels. */

307 static AVFrame *get_audio_frame(OutputStream *ost)

308 {

309 AVFrame *frame = ost->tmp_frame;

310 int j, i, v;

311 int16_t *q = (int16_t*)frame->data[0];

312

313 /* check if we want to generate more frames */

314 if (av_compare_ts(ost->next_pts, ost->enc->time_base,

315 STREAM_DURATION, (AVRational){ 1, 1 }) > 0)

316 return NULL;

317

318 for (j = 0; j <frame->nb_samples; j++) {

319 v = (int)(sin(ost->t) * 10000);

320 for (i = 0; i < ost->enc->ch_layout.nb_channels; i++)

321 *q++ = v;

322 ost->t += ost->tincr;

323 ost->tincr += ost->tincr2;

324 }

325

326 frame->pts = ost->next_pts;

327 ost->next_pts += frame->nb_samples;

328

329 return frame;

330 }

331

332 /*

333 * encode one audio frame and send it to the muxer

334 * return 1 when encoding is finished, 0 otherwise

335 */

336 static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)

337 {

338 AVCodecContext *c;

339 AVFrame *frame;

340 int ret;

341 int dst_nb_samples;

342

343 c = ost->enc;

344

345 frame = get_audio_frame(ost);

346

347 if (frame) {

348 /* convert samples from native format to destination codec format, using the resampler */

349 /* compute destination number of samples */

350 dst_nb_samples = swr_get_delay(ost->swr_ctx, c->sample_rate) + frame->nb_samples;

351 av_assert0(dst_nb_samples == frame->nb_samples);

352

353 /* when we pass a frame to the encoder, it may keep a reference to it

354 * internally;

355 * make sure we do not overwrite it here

356 */

357 ret = av_frame_make_writable(ost->frame);

358 if (ret < 0)

359 exit(1);

360

361 /* convert to destination format */

362 ret = swr_convert(ost->swr_ctx,

363 ost->frame->data, dst_nb_samples,

364 (const uint8_t **)frame->data, frame->nb_samples);

365 if (ret < 0) {

366 fprintf(stderr, "Error while converting\n");

367 exit(1);

368 }

369 frame = ost->frame;

370

371 frame->pts = av_rescale_q(ost->samples_count, (AVRational){1, c->sample_rate}, c->time_base);

372 ost->samples_count += dst_nb_samples;

373 }

374

375 return write_frame(oc, c, ost->st, frame, ost->tmp_pkt);

376 }

377

378 /**************************************************************/

379 /* video output */

380

381 static AVFrame *alloc_frame(enum AVPixelFormat pix_fmt, int width, int height)

382 {

383 AVFrame *frame;

384 int ret;

385

386 frame = av_frame_alloc();

387 if (!frame)

388 return NULL;

389

390 frame->format = pix_fmt;

391 frame->width = width;

392 frame->height = height;

393

394 /* allocate the buffers for the frame data */

395 ret = av_frame_get_buffer(frame, 0);

396 if (ret < 0) {

397 fprintf(stderr, "Could not allocate frame data.\n");

398 exit(1);

399 }

400

401 return frame;

402 }

403

404 static void open_video(AVFormatContext *oc, const AVCodec *codec,

405 OutputStream *ost, AVDictionary *opt_arg)

406 {

407 int ret;

408 AVCodecContext *c = ost->enc;

409 AVDictionary *opt = NULL;

410

411 av_dict_copy(&opt, opt_arg, 0);

412

413 /* open the codec */

414 ret = avcodec_open2(c, codec, &opt);

415 av_dict_free(&opt);

416 if (ret < 0) {

417 fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));

418 exit(1);

419 }

420

421 /* allocate and init a reusable frame */

422 ost->frame = alloc_frame(c->pix_fmt, c->width, c->height);

423 if (!ost->frame) {

424 fprintf(stderr, "Could not allocate video frame\n");

425 exit(1);

426 }

427

428 /* If the output format is not YUV420P, then a temporary YUV420P

429 * picture is needed too. It is then converted to the required

430 * output format. */

431 ost->tmp_frame = NULL;

432 if (c->pix_fmt != AV_PIX_FMT_YUV420P) {

433 ost->tmp_frame = alloc_frame(AV_PIX_FMT_YUV420P, c->width, c->height);

434 if (!ost->tmp_frame) {

435 fprintf(stderr, "Could not allocate temporary video frame\n");

436 exit(1);

437 }

438 }

439

440 /* copy the stream parameters to the muxer */

441 ret = avcodec_parameters_from_context(ost->st->codecpar, c);

442 if (ret < 0) {

443 fprintf(stderr, "Could not copy the stream parameters\n");

444 exit(1);

445 }

446 }

447

448 /* Prepare a dummy image. */

449 static void fill_yuv_image(AVFrame *pict, int frame_index,

450 int width, int height)

451 {

452 int x, y, i;

453

454 i = frame_index;

455

456 /* Y */

457 for (y = 0; y < height; y++)

458 for (x = 0; x < width; x++)

459 pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;

460

461 /* Cb and Cr */

462 for (y = 0; y < height / 2; y++) {

463 for (x = 0; x < width / 2; x++) {

464 pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;

465 pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;

466 }

467 }

468 }

469

470 static AVFrame *get_video_frame(OutputStream *ost)

471 {

472 AVCodecContext *c = ost->enc;

473

474 /* check if we want to generate more frames */

475 if (av_compare_ts(ost->next_pts, c->time_base,

476 STREAM_DURATION, (AVRational){ 1, 1 }) > 0)

477 return NULL;

478

479 /* when we pass a frame to the encoder, it may keep a reference to it

480 * internally; make sure we do not overwrite it here */

481 if (av_frame_make_writable(ost->frame) < 0)

482 exit(1);

483

484 if (c->pix_fmt != AV_PIX_FMT_YUV420P) {

485 /* as we only generate a YUV420P picture, we must convert it

486 * to the codec pixel format if needed */

487 if (!ost->sws_ctx) {

488 ost->sws_ctx = sws_getContext(c->width, c->height,

489 AV_PIX_FMT_YUV420P,

490 c->width, c->height,

491 c->pix_fmt,

492 SCALE_FLAGS, NULL, NULL, NULL);

493 if (!ost->sws_ctx) {

494 fprintf(stderr,

495 "Could not initialize the conversion context\n");

496 exit(1);

497 }

498 }

499 fill_yuv_image(ost->tmp_frame, ost->next_pts, c->width, c->height);

500 sws_scale(ost->sws_ctx, (const uint8_t * const *) ost->tmp_frame->data,

501 ost->tmp_frame->linesize, 0, c->height, ost->frame->data,

502 ost->frame->linesize);

503 } else {

504 fill_yuv_image(ost->frame, ost->next_pts, c->width, c->height);

505 }

506

507 ost->frame->pts = ost->next_pts++;

508

509 return ost->frame;

510 }

511

512 /*

513 * encode one video frame and send it to the muxer

514 * return 1 when encoding is finished, 0 otherwise

515 */

516 static int write_video_frame(AVFormatContext *oc, OutputStream *ost)

517 {

518 return write_frame(oc, ost->enc, ost->st, get_video_frame(ost), ost->tmp_pkt);

519 }

520

521 static void close_stream(AVFormatContext *oc, OutputStream *ost)

522 {

523 avcodec_free_context(&ost->enc);

524 av_frame_free(&ost->frame);

525 av_frame_free(&ost->tmp_frame);

526 av_packet_free(&ost->tmp_pkt);

527 sws_freeContext(ost->sws_ctx);

528 swr_free(&ost->swr_ctx);

529 }

530

531 /**************************************************************/

532 /* media file output */

533

534 int main(int argc, char **argv)

535 {

536 OutputStream video_st = { 0 }, audio_st = { 0 };

537 const AVOutputFormat *fmt;

538 const char *filename;

539 AVFormatContext *oc;

540 const AVCodec *audio_codec, *video_codec;

541 int ret;

542 int have_video = 0, have_audio = 0;

543 int encode_video = 0, encode_audio = 0;

544 AVDictionary *opt = NULL;

545 int i;

546

547 if (argc < 2) {

548 printf("usage: %s output_file\n"

549 "API example program to output a media file with libavformat.\n"

550 "This program generates a synthetic audio and video stream, encodes and\n"

551 "muxes them into a file named output_file.\n"

552 "The output format is automatically guessed according to the file extension.\n"

553 "Raw images can also be output by using '%%d' in the filename.\n"

554 "\n", argv[0]);

555 return 1;

556 }

557

558 filename = argv[1];

559 for (i = 2; i+1 < argc; i+=2) {

560 if (!strcmp(argv[i], "-flags") || !strcmp(argv[i], "-fflags"))

561 av_dict_set(&opt, argv[i]+1, argv[i+1], 0);

562 }

563

564 /* allocate the output media context */

565 avformat_alloc_output_context2(&oc, NULL, NULL, filename);

566 if (!oc) {

567 printf("Could not deduce output format from file extension: using MPEG.\n");

568 avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);

569 }

570 if (!oc)

571 return 1;

572

573 fmt = oc->oformat;

574

575 /* Add the audio and video streams using the default format codecs

576 * and initialize the codecs. */

577 if (fmt->video_codec != AV_CODEC_ID_NONE) {

578 add_stream(&video_st, oc, &video_codec, fmt->video_codec);

579 have_video = 1;

580 encode_video = 1;

581 }

582 if (fmt->audio_codec != AV_CODEC_ID_NONE) {

583 add_stream(&audio_st, oc, &audio_codec, fmt->audio_codec);

584 have_audio = 1;

585 encode_audio = 1;

586 }

587

588 /* Now that all the parameters are set, we can open the audio and

589 * video codecs and allocate the necessary encode buffers. */

590 if (have_video)

591 open_video(oc, video_codec, &video_st, opt);

592

593 if (have_audio)

594 open_audio(oc, audio_codec, &audio_st, opt);

595

596 av_dump_format(oc, 0, filename, 1);

597

598 /* open the output file, if needed */

599 if (!(fmt->flags & AVFMT_NOFILE)) {

600 ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);

601 if (ret < 0) {

602 fprintf(stderr, "Could not open '%s': %s\n", filename,

603 av_err2str(ret));

604 return 1;

605 }

606 }

607

608 /* Write the stream header, if any. */

609 ret = avformat_write_header(oc, &opt);

610 if (ret < 0) {

611 fprintf(stderr, "Error occurred when opening output file: %s\n",

612 av_err2str(ret));

613 return 1;

614 }

615

616 while (encode_video || encode_audio) {

617 /* select the stream to encode */

618 if (encode_video &&

619 (!encode_audio || av_compare_ts(video_st.next_pts, video_st.enc->time_base,

620 audio_st.next_pts, audio_st.enc->time_base) <= 0)) {

621 encode_video = !write_video_frame(oc, &video_st);

622 } else {

623 encode_audio = !write_audio_frame(oc, &audio_st);

624 }

625 }

626

627 av_write_trailer(oc);

628

629 /* Close each codec. */

630 if (have_video)

631 close_stream(oc, &video_st);

632 if (have_audio)

633 close_stream(oc, &audio_st);

634

635 if (!(fmt->flags & AVFMT_NOFILE))

636 /* Close the output file. */

637 avio_closep(&oc->pb);

638

639 /* free the stream */

640 avformat_free_context(oc);

641

642 return 0;

643 }

AVCodec

AVCodec.

Definition: codec.h:172

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

avcodec_receive_packet

int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)

Read encoded data from the encoder.

Definition: encode.c:523

OutputStream::tincr

float tincr

Definition: mux.c:66

OutputStream::samples_count

int samples_count

Definition: mux.c:59

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

printf

__device__ int printf(const char *,...)

opt.h

OutputStream::enc

AVCodecContext * enc

Definition: mux.c:55

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_frame_get_buffer

int av_frame_get_buffer(AVFrame *frame, int align)

Allocate new buffer(s) for audio or video data.

Definition: frame.c:206

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:395

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

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

alloc_audio_frame

static AVFrame * alloc_audio_frame(enum AVSampleFormat sample_fmt, const AVChannelLayout *channel_layout, int sample_rate, int nb_samples)

Definition: mux.c:216

int64_t

long long int64_t

Definition: coverity.c:34

write_frame

static int write_frame(AVFormatContext *fmt_ctx, AVCodecContext *c, AVStream *st, AVFrame *frame, AVPacket *pkt)

Definition: mux.c:83

sws_freeContext

void sws_freeContext(SwsContext *swsContext)

Free the swscaler context swsContext.

Definition: utils.c:2244

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:64

avcodec_find_encoder

const AVCodec * avcodec_find_encoder(enum AVCodecID id)

Find a registered encoder with a matching codec ID.

Definition: allcodecs.c:1033

AVFrame

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

Definition: frame.h:427

av_frame_make_writable

int av_frame_make_writable(AVFrame *frame)

Ensure that the frame data is writable, avoiding data copy if possible.

Definition: frame.c:552

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1332

avio_open

int avio_open(AVIOContext **s, const char *filename, int flags)

Create and initialize a AVIOContext for accessing the resource indicated by url.

Definition: avio.c:498

AVPacket::duration

int64_t duration

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

Definition: packet.h:606

mathematics.h

AVDictionary

Definition: dict.c:32

ost

static AVStream * ost

Definition: vaapi_transcode.c:42

av_packet_free

void av_packet_free(AVPacket **pkt)

Free the packet, if the packet is reference counted, it will be unreferenced first.

Definition: packet.c:74

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:448

AV_CODEC_FLAG_GLOBAL_HEADER

#define AV_CODEC_FLAG_GLOBAL_HEADER

Place global headers in extradata instead of every keyframe.

Definition: avcodec.h:318

OutputStream::next_pts

int64_t next_pts

Definition: mux.c:58

OutputStream::tmp_frame

AVFrame * tmp_frame

Definition: mux.c:62

swr_convert

int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t *const *out_arg, int out_count, const uint8_t *const *in_arg, int in_count)

Convert audio.

Definition: swresample.c:717

swr_get_delay

int64_t swr_get_delay(struct SwrContext *s, int64_t base)

Gets the delay the next input sample will experience relative to the next output sample.

Definition: swresample.c:871

open_audio

static void open_audio(AVFormatContext *oc, const AVCodec *codec, OutputStream *ost, AVDictionary *opt_arg)

Definition: mux.c:241

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

avassert.h

pkt

AVPacket * pkt

Definition: movenc.c:60

OutputStream::swr_ctx

struct SwrContext * swr_ctx

Definition: mux.c:69

av_dump_format

void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)

Print detailed information about the input or output format, such as duration, bitrate,...

Definition: dump.c:848

swr_init

av_cold int swr_init(struct SwrContext *s)

Initialize context after user parameters have been set.

Definition: swresample.c:138

avcodec_alloc_context3

AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)

Allocate an AVCodecContext and set its fields to default values.

Definition: options.c:149

get_audio_frame

static AVFrame * get_audio_frame(OutputStream *ost)

Definition: mux.c:307

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demux_decode.c:41

OutputStream::frame

AVFrame * frame

Definition: mux.c:61

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

swr_alloc

av_cold struct SwrContext * swr_alloc(void)

Allocate SwrContext.

Definition: options.c:148

AVOutputFormat::audio_codec

enum AVCodecID audio_codec

default audio codec

Definition: avformat.h:516

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

AVIO_FLAG_WRITE

#define AVIO_FLAG_WRITE

write-only

Definition: avio.h:618

open_video

static void open_video(AVFormatContext *oc, const AVCodec *codec, OutputStream *ost, AVDictionary *opt_arg)

Definition: mux.c:404

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

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:410

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

SwrContext

The libswresample context.

Definition: swresample_internal.h:95

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

if(ret)

Definition: filter_design.txt:179

AVFormatContext

Format I/O context.

Definition: avformat.h:1264

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:767

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

NULL

#define NULL

Definition: coverity.c:32

avcodec_free_context

void avcodec_free_context(AVCodecContext **avctx)

Free the codec context and everything associated with it and write NULL to the provided pointer.

Definition: options.c:164

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

get_video_frame

static AVFrame * get_video_frame(OutputStream *ost)

Definition: mux.c:470

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1306

AV_CODEC_CAP_VARIABLE_FRAME_SIZE

#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE

Audio encoder supports receiving a different number of samples in each call.

Definition: codec.h:113

avcodec_open2

int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)

Initialize the AVCodecContext to use the given AVCodec.

Definition: avcodec.c:144

log_packet

static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt)

Definition: mux.c:72

OutputStream::sws_ctx

struct SwsContext * sws_ctx

Definition: mux.c:68

audio_st

AVStream * audio_st

Definition: movenc.c:61

swresample.h

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_opt_set_int

int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)

Definition: opt.c:880

AV_CODEC_ID_MPEG1VIDEO

@ AV_CODEC_ID_MPEG1VIDEO

Definition: codec_id.h:53

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

AVFormatContext::nb_streams

unsigned int nb_streams

Number of elements in AVFormatContext.streams.

Definition: avformat.h:1320

AVOutputFormat::flags

int flags

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

Definition: avformat.h:525

fmt_ctx

static AVFormatContext * fmt_ctx

Definition: decode_filter_audio.c:44

av_ts2timestr

#define av_ts2timestr(ts, tb)

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

Definition: timestamp.h:83

STREAM_FRAME_RATE

#define STREAM_FRAME_RATE

Definition: mux.c:47

height

#define height

Definition: dsp.h:89

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:319

av_opt_set_chlayout

int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *channel_layout, int search_flags)

Definition: opt.c:1000

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

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

SCALE_FLAGS

#define SCALE_FLAGS

Definition: mux.c:50

alloc_frame

static AVFrame * alloc_frame(enum AVPixelFormat pix_fmt, int width, int height)

Definition: mux.c:381

video_st

AVStream * video_st

Definition: movenc.c:61

main

int main(int argc, char **argv)

Definition: mux.c:534

swr_free

av_cold void swr_free(SwrContext **ss)

Free the given SwrContext and set the pointer to NULL.

Definition: swresample.c:119

AVFMT_NOFILE

#define AVFMT_NOFILE

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

Definition: avformat.h:468

AVPacket::dts

int64_t dts

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

Definition: packet.h:587

OutputStream::t

float t

Definition: mux.c:66

av_packet_alloc

AVPacket * av_packet_alloc(void)

Allocate an AVPacket and set its fields to default values.

Definition: packet.c:63

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

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: packet.c:536

STREAM_DURATION

#define STREAM_DURATION

Definition: mux.c:46

M_PI

#define M_PI

Definition: mathematics.h:67

avcodec_get_name

const char * avcodec_get_name(enum AVCodecID id)

Get the name of a codec.

Definition: utils.c:406

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

AVFMT_GLOBALHEADER

#define AVFMT_GLOBALHEADER

Format wants global header.

Definition: avformat.h:477

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:50

AVOutputFormat

Definition: avformat.h:505

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

Definition: cbs_h2645.c:256

AVPacket::pts

int64_t pts

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

Definition: packet.h:581

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

avcodec_send_frame

int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)

Supply a raw video or audio frame to the encoder.

Definition: encode.c:490

avcodec.h

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:756

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:744

OutputStream::tincr2

float tincr2

Definition: mux.c:66

OutputStream::tmp_pkt

AVPacket * tmp_pkt

Definition: mux.c:64

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

AVFormatContext::oformat

const struct AVOutputFormat * oformat

The output container format.

Definition: avformat.h:1283

sws_getContext

SwsContext * sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)

Allocate and return an SwsContext.

Definition: utils.c:1913

avformat.h

STREAM_PIX_FMT

#define STREAM_PIX_FMT

Definition: mux.c:48

write_audio_frame

static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)

Definition: mux.c:336

AVCodecContext

main external API structure.

Definition: avcodec.h:431

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:750

write_video_frame

static int write_video_frame(AVFormatContext *oc, OutputStream *ost)

Definition: mux.c:516

channel_layout.h

sws_scale

int attribute_align_arg sws_scale(SwsContext *sws, const uint8_t *const srcSlice[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])

swscale wrapper, so we don't need to export the SwsContext.

Definition: swscale.c:1503

close_stream

static void close_stream(AVFormatContext *oc, OutputStream *ost)

Definition: mux.c:521

avformat_free_context

void avformat_free_context(AVFormatContext *s)

Free an AVFormatContext and all its streams.

Definition: avformat.c:141

AVOutputFormat::video_codec

enum AVCodecID video_codec

default video codec