2 * copyright (c) 2001 Fabrice Bellard
4 * This file is part of Libav.
6 * Libav is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * Libav is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * libavcodec API use example.
25 * @example libavcodec/api-example.c
26 * Note that this library only handles codecs (mpeg, mpeg4, etc...),
27 * not file formats (avi, vob, etc...). See library 'libavformat' for the
35 #ifdef HAVE_AV_CONFIG_H
36 #undef HAVE_AV_CONFIG_H
39 #include "libavcodec/avcodec.h"
40 #include "libavutil/audioconvert.h"
41 #include "libavutil/mathematics.h"
42 #include "libavutil/samplefmt.h"
44 #define INBUF_SIZE 4096
45 #define AUDIO_INBUF_SIZE 20480
46 #define AUDIO_REFILL_THRESH 4096
48 /* check that a given sample format is supported by the encoder */
49 static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
51 const enum AVSampleFormat *p = codec->sample_fmts;
53 while (*p != AV_SAMPLE_FMT_NONE) {
61 /* just pick the highest supported samplerate */
62 static int select_sample_rate(AVCodec *codec)
65 int best_samplerate = 0;
67 if (!codec->supported_samplerates)
70 p = codec->supported_samplerates;
72 best_samplerate = FFMAX(*p, best_samplerate);
75 return best_samplerate;
78 /* select layout with the highest channel count */
79 static int select_channel_layout(AVCodec *codec)
82 uint64_t best_ch_layout = 0;
83 int best_nb_channells = 0;
85 if (!codec->channel_layouts)
86 return AV_CH_LAYOUT_STEREO;
88 p = codec->channel_layouts;
90 int nb_channels = av_get_channel_layout_nb_channels(*p);
92 if (nb_channels > best_nb_channells) {
94 best_nb_channells = nb_channels;
98 return best_ch_layout;
102 * Audio encoding example
104 static void audio_encode_example(const char *filename)
107 AVCodecContext *c= NULL;
110 int i, j, k, ret, got_output;
116 printf("Audio encoding\n");
118 /* find the MP2 encoder */
119 codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
121 fprintf(stderr, "codec not found\n");
125 c = avcodec_alloc_context3(codec);
127 /* put sample parameters */
130 /* check that the encoder supports s16 pcm input */
131 c->sample_fmt = AV_SAMPLE_FMT_S16;
132 if (!check_sample_fmt(codec, c->sample_fmt)) {
133 fprintf(stderr, "encoder does not support %s",
134 av_get_sample_fmt_name(c->sample_fmt));
138 /* select other audio parameters supported by the encoder */
139 c->sample_rate = select_sample_rate(codec);
140 c->channel_layout = select_channel_layout(codec);
141 c->channels = av_get_channel_layout_nb_channels(c->channel_layout);
144 if (avcodec_open2(c, codec, NULL) < 0) {
145 fprintf(stderr, "could not open codec\n");
149 f = fopen(filename, "wb");
151 fprintf(stderr, "could not open %s\n", filename);
155 /* frame containing input raw audio */
156 frame = avcodec_alloc_frame();
158 fprintf(stderr, "could not allocate audio frame\n");
162 frame->nb_samples = c->frame_size;
163 frame->format = c->sample_fmt;
164 frame->channel_layout = c->channel_layout;
166 /* the codec gives us the frame size, in samples,
167 * we calculate the size of the samples buffer in bytes */
168 buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
170 samples = av_malloc(buffer_size);
172 fprintf(stderr, "could not allocate %d bytes for samples buffer\n",
176 /* setup the data pointers in the AVFrame */
177 ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
178 (const uint8_t*)samples, buffer_size, 0);
180 fprintf(stderr, "could not setup audio frame\n");
184 /* encode a single tone sound */
186 tincr = 2 * M_PI * 440.0 / c->sample_rate;
188 av_init_packet(&pkt);
189 pkt.data = NULL; // packet data will be allocated by the encoder
192 for (j = 0; j < c->frame_size; j++) {
193 samples[2*j] = (int)(sin(t) * 10000);
195 for (k = 1; k < c->channels; k++)
196 samples[2*j + k] = samples[2*j];
199 /* encode the samples */
200 ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
202 fprintf(stderr, "error encoding audio frame\n");
206 fwrite(pkt.data, 1, pkt.size, f);
207 av_free_packet(&pkt);
221 static void audio_decode_example(const char *outfilename, const char *filename)
224 AVCodecContext *c= NULL;
227 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
229 AVFrame *decoded_frame = NULL;
231 av_init_packet(&avpkt);
233 printf("Audio decoding\n");
235 /* find the mpeg audio decoder */
236 codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
238 fprintf(stderr, "codec not found\n");
242 c = avcodec_alloc_context3(codec);
245 if (avcodec_open2(c, codec, NULL) < 0) {
246 fprintf(stderr, "could not open codec\n");
250 f = fopen(filename, "rb");
252 fprintf(stderr, "could not open %s\n", filename);
255 outfile = fopen(outfilename, "wb");
261 /* decode until eof */
263 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
265 while (avpkt.size > 0) {
268 if (!decoded_frame) {
269 if (!(decoded_frame = avcodec_alloc_frame())) {
270 fprintf(stderr, "out of memory\n");
274 avcodec_get_frame_defaults(decoded_frame);
276 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
278 fprintf(stderr, "Error while decoding\n");
282 /* if a frame has been decoded, output it */
283 int data_size = av_samples_get_buffer_size(NULL, c->channels,
284 decoded_frame->nb_samples,
286 fwrite(decoded_frame->data[0], 1, data_size, outfile);
290 if (avpkt.size < AUDIO_REFILL_THRESH) {
291 /* Refill the input buffer, to avoid trying to decode
292 * incomplete frames. Instead of this, one could also use
293 * a parser, or use a proper container format through
295 memmove(inbuf, avpkt.data, avpkt.size);
297 len = fread(avpkt.data + avpkt.size, 1,
298 AUDIO_INBUF_SIZE - avpkt.size, f);
309 av_free(decoded_frame);
313 * Video encoding example
315 static void video_encode_example(const char *filename)
318 AVCodecContext *c= NULL;
319 int i, out_size, size, x, y, outbuf_size;
322 uint8_t *outbuf, *picture_buf;
324 printf("Video encoding\n");
326 /* find the mpeg1 video encoder */
327 codec = avcodec_find_encoder(AV_CODEC_ID_MPEG1VIDEO);
329 fprintf(stderr, "codec not found\n");
333 c = avcodec_alloc_context3(codec);
334 picture= avcodec_alloc_frame();
336 /* put sample parameters */
337 c->bit_rate = 400000;
338 /* resolution must be a multiple of two */
341 /* frames per second */
342 c->time_base= (AVRational){1,25};
343 c->gop_size = 10; /* emit one intra frame every ten frames */
345 c->pix_fmt = PIX_FMT_YUV420P;
348 if (avcodec_open2(c, codec, NULL) < 0) {
349 fprintf(stderr, "could not open codec\n");
353 f = fopen(filename, "wb");
355 fprintf(stderr, "could not open %s\n", filename);
359 /* alloc image and output buffer */
360 outbuf_size = 100000;
361 outbuf = malloc(outbuf_size);
362 size = c->width * c->height;
363 picture_buf = malloc((size * 3) / 2); /* size for YUV 420 */
365 picture->data[0] = picture_buf;
366 picture->data[1] = picture->data[0] + size;
367 picture->data[2] = picture->data[1] + size / 4;
368 picture->linesize[0] = c->width;
369 picture->linesize[1] = c->width / 2;
370 picture->linesize[2] = c->width / 2;
372 /* encode 1 second of video */
375 /* prepare a dummy image */
377 for(y=0;y<c->height;y++) {
378 for(x=0;x<c->width;x++) {
379 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
384 for(y=0;y<c->height/2;y++) {
385 for(x=0;x<c->width/2;x++) {
386 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
387 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
391 /* encode the image */
392 out_size = avcodec_encode_video(c, outbuf, outbuf_size, picture);
393 printf("encoding frame %3d (size=%5d)\n", i, out_size);
394 fwrite(outbuf, 1, out_size, f);
397 /* get the delayed frames */
398 for(; out_size; i++) {
401 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
402 printf("write frame %3d (size=%5d)\n", i, out_size);
403 fwrite(outbuf, 1, out_size, f);
406 /* add sequence end code to have a real mpeg file */
411 fwrite(outbuf, 1, 4, f);
423 * Video decoding example
426 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
432 f=fopen(filename,"w");
433 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
435 fwrite(buf + i * wrap,1,xsize,f);
439 static void video_decode_example(const char *outfilename, const char *filename)
442 AVCodecContext *c= NULL;
443 int frame, got_picture, len;
446 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
450 av_init_packet(&avpkt);
452 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
453 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
455 printf("Video decoding\n");
457 /* find the mpeg1 video decoder */
458 codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
460 fprintf(stderr, "codec not found\n");
464 c = avcodec_alloc_context3(codec);
465 picture= avcodec_alloc_frame();
467 if(codec->capabilities&CODEC_CAP_TRUNCATED)
468 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
470 /* For some codecs, such as msmpeg4 and mpeg4, width and height
471 MUST be initialized there because this information is not
472 available in the bitstream. */
475 if (avcodec_open2(c, codec, NULL) < 0) {
476 fprintf(stderr, "could not open codec\n");
480 /* the codec gives us the frame size, in samples */
482 f = fopen(filename, "rb");
484 fprintf(stderr, "could not open %s\n", filename);
490 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
494 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
495 and this is the only method to use them because you cannot
496 know the compressed data size before analysing it.
498 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
499 based, so you must call them with all the data for one
500 frame exactly. You must also initialize 'width' and
501 'height' before initializing them. */
503 /* NOTE2: some codecs allow the raw parameters (frame size,
504 sample rate) to be changed at any frame. We handle this, so
505 you should also take care of it */
507 /* here, we use a stream based decoder (mpeg1video), so we
508 feed decoder and see if it could decode a frame */
510 while (avpkt.size > 0) {
511 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
513 fprintf(stderr, "Error while decoding frame %d\n", frame);
517 printf("saving frame %3d\n", frame);
520 /* the picture is allocated by the decoder. no need to
522 snprintf(buf, sizeof(buf), outfilename, frame);
523 pgm_save(picture->data[0], picture->linesize[0],
524 c->width, c->height, buf);
532 /* some codecs, such as MPEG, transmit the I and P frame with a
533 latency of one frame. You must do the following to have a
534 chance to get the last frame of the video */
537 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
539 printf("saving last frame %3d\n", frame);
542 /* the picture is allocated by the decoder. no need to
544 snprintf(buf, sizeof(buf), outfilename, frame);
545 pgm_save(picture->data[0], picture->linesize[0],
546 c->width, c->height, buf);
558 int main(int argc, char **argv)
560 const char *filename;
562 /* register all the codecs */
563 avcodec_register_all();
566 audio_encode_example("/tmp/test.mp2");
567 audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
569 video_encode_example("/tmp/test.mpg");
570 filename = "/tmp/test.mpg";
575 // audio_decode_example("/tmp/test.sw", filename);
576 video_decode_example("/tmp/test%d.pgm", filename);