2 * Copyright (c) 2001 Fabrice Bellard
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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
25 * libavcodec API use example.
27 * @example decoding_encoding.c
28 * Note that libavcodec only handles codecs (mpeg, mpeg4, etc...),
29 * not file formats (avi, vob, mp4, mov, mkv, mxf, flv, mpegts, mpegps, etc...). See library 'libavformat' for the
35 #include <libavutil/opt.h>
36 #include <libavcodec/avcodec.h>
37 #include <libavutil/channel_layout.h>
38 #include <libavutil/common.h>
39 #include <libavutil/imgutils.h>
40 #include <libavutil/mathematics.h>
41 #include <libavutil/samplefmt.h>
43 #define INBUF_SIZE 4096
44 #define AUDIO_INBUF_SIZE 20480
45 #define AUDIO_REFILL_THRESH 4096
47 /* check that a given sample format is supported by the encoder */
48 static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
50 const enum AVSampleFormat *p = codec->sample_fmts;
52 while (*p != AV_SAMPLE_FMT_NONE) {
60 /* just pick the highest supported samplerate */
61 static int select_sample_rate(AVCodec *codec)
64 int best_samplerate = 0;
66 if (!codec->supported_samplerates)
69 p = codec->supported_samplerates;
71 best_samplerate = FFMAX(*p, best_samplerate);
74 return best_samplerate;
77 /* select layout with the highest channel count */
78 static int select_channel_layout(AVCodec *codec)
81 uint64_t best_ch_layout = 0;
82 int best_nb_channels = 0;
84 if (!codec->channel_layouts)
85 return AV_CH_LAYOUT_STEREO;
87 p = codec->channel_layouts;
89 int nb_channels = av_get_channel_layout_nb_channels(*p);
91 if (nb_channels > best_nb_channels) {
93 best_nb_channels = nb_channels;
97 return best_ch_layout;
101 * Audio encoding example
103 static void audio_encode_example(const char *filename)
106 AVCodecContext *c= NULL;
109 int i, j, k, ret, got_output;
115 printf("Encode audio file %s\n", filename);
117 /* find the MP2 encoder */
118 codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
120 fprintf(stderr, "Codec not found\n");
124 c = avcodec_alloc_context3(codec);
126 fprintf(stderr, "Could not allocate audio codec context\n");
130 /* put sample parameters */
133 /* check that the encoder supports s16 pcm input */
134 c->sample_fmt = AV_SAMPLE_FMT_S16;
135 if (!check_sample_fmt(codec, c->sample_fmt)) {
136 fprintf(stderr, "Encoder does not support sample format %s",
137 av_get_sample_fmt_name(c->sample_fmt));
141 /* select other audio parameters supported by the encoder */
142 c->sample_rate = select_sample_rate(codec);
143 c->channel_layout = select_channel_layout(codec);
144 c->channels = av_get_channel_layout_nb_channels(c->channel_layout);
147 if (avcodec_open2(c, codec, NULL) < 0) {
148 fprintf(stderr, "Could not open codec\n");
152 f = fopen(filename, "wb");
154 fprintf(stderr, "Could not open %s\n", filename);
158 /* frame containing input raw audio */
159 frame = av_frame_alloc();
161 fprintf(stderr, "Could not allocate audio frame\n");
165 frame->nb_samples = c->frame_size;
166 frame->format = c->sample_fmt;
167 frame->channel_layout = c->channel_layout;
169 /* the codec gives us the frame size, in samples,
170 * we calculate the size of the samples buffer in bytes */
171 buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
173 if (buffer_size < 0) {
174 fprintf(stderr, "Could not get sample buffer size\n");
177 samples = av_malloc(buffer_size);
179 fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",
183 /* setup the data pointers in the AVFrame */
184 ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
185 (const uint8_t*)samples, buffer_size, 0);
187 fprintf(stderr, "Could not setup audio frame\n");
191 /* encode a single tone sound */
193 tincr = 2 * M_PI * 440.0 / c->sample_rate;
194 for (i = 0; i < 200; i++) {
195 av_init_packet(&pkt);
196 pkt.data = NULL; // packet data will be allocated by the encoder
199 for (j = 0; j < c->frame_size; j++) {
200 samples[2*j] = (int)(sin(t) * 10000);
202 for (k = 1; k < c->channels; k++)
203 samples[2*j + k] = samples[2*j];
206 /* encode the samples */
207 ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
209 fprintf(stderr, "Error encoding audio frame\n");
213 fwrite(pkt.data, 1, pkt.size, f);
214 av_free_packet(&pkt);
218 /* get the delayed frames */
219 for (got_output = 1; got_output; i++) {
220 ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
222 fprintf(stderr, "Error encoding frame\n");
227 fwrite(pkt.data, 1, pkt.size, f);
228 av_free_packet(&pkt);
234 av_frame_free(&frame);
242 static void audio_decode_example(const char *outfilename, const char *filename)
245 AVCodecContext *c= NULL;
248 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
250 AVFrame *decoded_frame = NULL;
252 av_init_packet(&avpkt);
254 printf("Decode audio file %s to %s\n", filename, outfilename);
256 /* find the mpeg audio decoder */
257 codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
259 fprintf(stderr, "Codec not found\n");
263 c = avcodec_alloc_context3(codec);
265 fprintf(stderr, "Could not allocate audio codec context\n");
270 if (avcodec_open2(c, codec, NULL) < 0) {
271 fprintf(stderr, "Could not open codec\n");
275 f = fopen(filename, "rb");
277 fprintf(stderr, "Could not open %s\n", filename);
280 outfile = fopen(outfilename, "wb");
286 /* decode until eof */
288 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
290 while (avpkt.size > 0) {
293 if (!decoded_frame) {
294 if (!(decoded_frame = av_frame_alloc())) {
295 fprintf(stderr, "Could not allocate audio frame\n");
300 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
302 fprintf(stderr, "Error while decoding\n");
306 /* if a frame has been decoded, output it */
307 int data_size = av_samples_get_buffer_size(NULL, c->channels,
308 decoded_frame->nb_samples,
311 /* This should not occur, checking just for paranoia */
312 fprintf(stderr, "Failed to calculate data size\n");
315 fwrite(decoded_frame->data[0], 1, data_size, outfile);
320 avpkt.pts = AV_NOPTS_VALUE;
321 if (avpkt.size < AUDIO_REFILL_THRESH) {
322 /* Refill the input buffer, to avoid trying to decode
323 * incomplete frames. Instead of this, one could also use
324 * a parser, or use a proper container format through
326 memmove(inbuf, avpkt.data, avpkt.size);
328 len = fread(avpkt.data + avpkt.size, 1,
329 AUDIO_INBUF_SIZE - avpkt.size, f);
340 av_frame_free(&decoded_frame);
344 * Video encoding example
346 static void video_encode_example(const char *filename, int codec_id)
349 AVCodecContext *c= NULL;
350 int i, ret, x, y, got_output;
354 uint8_t endcode[] = { 0, 0, 1, 0xb7 };
356 printf("Encode video file %s\n", filename);
358 /* find the mpeg1 video encoder */
359 codec = avcodec_find_encoder(codec_id);
361 fprintf(stderr, "Codec not found\n");
365 c = avcodec_alloc_context3(codec);
367 fprintf(stderr, "Could not allocate video codec context\n");
371 /* put sample parameters */
372 c->bit_rate = 400000;
373 /* resolution must be a multiple of two */
376 /* frames per second */
377 c->time_base = (AVRational){1,25};
378 /* emit one intra frame every ten frames
379 * check frame pict_type before passing frame
380 * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
381 * then gop_size is ignored and the output of encoder
382 * will always be I frame irrespective to gop_size
386 c->pix_fmt = AV_PIX_FMT_YUV420P;
388 if (codec_id == AV_CODEC_ID_H264)
389 av_opt_set(c->priv_data, "preset", "slow", 0);
392 if (avcodec_open2(c, codec, NULL) < 0) {
393 fprintf(stderr, "Could not open codec\n");
397 f = fopen(filename, "wb");
399 fprintf(stderr, "Could not open %s\n", filename);
403 frame = av_frame_alloc();
405 fprintf(stderr, "Could not allocate video frame\n");
408 frame->format = c->pix_fmt;
409 frame->width = c->width;
410 frame->height = c->height;
412 /* the image can be allocated by any means and av_image_alloc() is
413 * just the most convenient way if av_malloc() is to be used */
414 ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
417 fprintf(stderr, "Could not allocate raw picture buffer\n");
421 /* encode 1 second of video */
422 for (i = 0; i < 25; i++) {
423 av_init_packet(&pkt);
424 pkt.data = NULL; // packet data will be allocated by the encoder
428 /* prepare a dummy image */
430 for (y = 0; y < c->height; y++) {
431 for (x = 0; x < c->width; x++) {
432 frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
437 for (y = 0; y < c->height/2; y++) {
438 for (x = 0; x < c->width/2; x++) {
439 frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
440 frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
446 /* encode the image */
447 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
449 fprintf(stderr, "Error encoding frame\n");
454 printf("Write frame %3d (size=%5d)\n", i, pkt.size);
455 fwrite(pkt.data, 1, pkt.size, f);
456 av_free_packet(&pkt);
460 /* get the delayed frames */
461 for (got_output = 1; got_output; i++) {
464 ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
466 fprintf(stderr, "Error encoding frame\n");
471 printf("Write frame %3d (size=%5d)\n", i, pkt.size);
472 fwrite(pkt.data, 1, pkt.size, f);
473 av_free_packet(&pkt);
477 /* add sequence end code to have a real mpeg file */
478 fwrite(endcode, 1, sizeof(endcode), f);
483 av_freep(&frame->data[0]);
484 av_frame_free(&frame);
489 * Video decoding example
492 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
498 f = fopen(filename,"w");
499 fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
500 for (i = 0; i < ysize; i++)
501 fwrite(buf + i * wrap, 1, xsize, f);
505 static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,
506 AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
511 len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
513 fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
517 printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);
520 /* the picture is allocated by the decoder, no need to free it */
521 snprintf(buf, sizeof(buf), outfilename, *frame_count);
522 pgm_save(frame->data[0], frame->linesize[0],
523 avctx->width, avctx->height, buf);
533 static void video_decode_example(const char *outfilename, const char *filename)
536 AVCodecContext *c= NULL;
540 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
543 av_init_packet(&avpkt);
545 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
546 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
548 printf("Decode video file %s to %s\n", filename, outfilename);
550 /* find the mpeg1 video decoder */
551 codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
553 fprintf(stderr, "Codec not found\n");
557 c = avcodec_alloc_context3(codec);
559 fprintf(stderr, "Could not allocate video codec context\n");
563 if(codec->capabilities&CODEC_CAP_TRUNCATED)
564 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
566 /* For some codecs, such as msmpeg4 and mpeg4, width and height
567 MUST be initialized there because this information is not
568 available in the bitstream. */
571 if (avcodec_open2(c, codec, NULL) < 0) {
572 fprintf(stderr, "Could not open codec\n");
576 f = fopen(filename, "rb");
578 fprintf(stderr, "Could not open %s\n", filename);
582 frame = av_frame_alloc();
584 fprintf(stderr, "Could not allocate video frame\n");
590 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
594 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
595 and this is the only method to use them because you cannot
596 know the compressed data size before analysing it.
598 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
599 based, so you must call them with all the data for one
600 frame exactly. You must also initialize 'width' and
601 'height' before initializing them. */
603 /* NOTE2: some codecs allow the raw parameters (frame size,
604 sample rate) to be changed at any frame. We handle this, so
605 you should also take care of it */
607 /* here, we use a stream based decoder (mpeg1video), so we
608 feed decoder and see if it could decode a frame */
610 while (avpkt.size > 0)
611 if (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)
615 /* some codecs, such as MPEG, transmit the I and P frame with a
616 latency of one frame. You must do the following to have a
617 chance to get the last frame of the video */
620 decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 1);
626 av_frame_free(&frame);
630 int main(int argc, char **argv)
632 const char *output_type;
634 /* register all the codecs */
635 avcodec_register_all();
638 printf("usage: %s output_type\n"
639 "API example program to decode/encode a media stream with libavcodec.\n"
640 "This program generates a synthetic stream and encodes it to a file\n"
641 "named test.h264, test.mp2 or test.mpg depending on output_type.\n"
642 "The encoded stream is then decoded and written to a raw data output.\n"
643 "output_type must be chosen between 'h264', 'mp2', 'mpg'.\n",
647 output_type = argv[1];
649 if (!strcmp(output_type, "h264")) {
650 video_encode_example("test.h264", AV_CODEC_ID_H264);
651 } else if (!strcmp(output_type, "mp2")) {
652 audio_encode_example("test.mp2");
653 audio_decode_example("test.sw", "test.mp2");
654 } else if (!strcmp(output_type, "mpg")) {
655 video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);
656 video_decode_example("test%02d.pgm", "test.mpg");
658 fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",