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/common.h"
42 #include "libavutil/imgutils.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/samplefmt.h"
46 #define INBUF_SIZE 4096
47 #define AUDIO_INBUF_SIZE 20480
48 #define AUDIO_REFILL_THRESH 4096
50 /* check that a given sample format is supported by the encoder */
51 static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
53 const enum AVSampleFormat *p = codec->sample_fmts;
55 while (*p != AV_SAMPLE_FMT_NONE) {
63 /* just pick the highest supported samplerate */
64 static int select_sample_rate(AVCodec *codec)
67 int best_samplerate = 0;
69 if (!codec->supported_samplerates)
72 p = codec->supported_samplerates;
74 best_samplerate = FFMAX(*p, best_samplerate);
77 return best_samplerate;
80 /* select layout with the highest channel count */
81 static int select_channel_layout(AVCodec *codec)
84 uint64_t best_ch_layout = 0;
85 int best_nb_channells = 0;
87 if (!codec->channel_layouts)
88 return AV_CH_LAYOUT_STEREO;
90 p = codec->channel_layouts;
92 int nb_channels = av_get_channel_layout_nb_channels(*p);
94 if (nb_channels > best_nb_channells) {
96 best_nb_channells = nb_channels;
100 return best_ch_layout;
104 * Audio encoding example
106 static void audio_encode_example(const char *filename)
109 AVCodecContext *c= NULL;
112 int i, j, k, ret, got_output;
118 printf("Audio encoding\n");
120 /* find the MP2 encoder */
121 codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
123 fprintf(stderr, "codec not found\n");
127 c = avcodec_alloc_context3(codec);
129 /* put sample parameters */
132 /* check that the encoder supports s16 pcm input */
133 c->sample_fmt = AV_SAMPLE_FMT_S16;
134 if (!check_sample_fmt(codec, c->sample_fmt)) {
135 fprintf(stderr, "encoder does not support %s",
136 av_get_sample_fmt_name(c->sample_fmt));
140 /* select other audio parameters supported by the encoder */
141 c->sample_rate = select_sample_rate(codec);
142 c->channel_layout = select_channel_layout(codec);
143 c->channels = av_get_channel_layout_nb_channels(c->channel_layout);
146 if (avcodec_open2(c, codec, NULL) < 0) {
147 fprintf(stderr, "could not open codec\n");
151 f = fopen(filename, "wb");
153 fprintf(stderr, "could not open %s\n", filename);
157 /* frame containing input raw audio */
158 frame = avcodec_alloc_frame();
160 fprintf(stderr, "could not allocate audio frame\n");
164 frame->nb_samples = c->frame_size;
165 frame->format = c->sample_fmt;
166 frame->channel_layout = c->channel_layout;
168 /* the codec gives us the frame size, in samples,
169 * we calculate the size of the samples buffer in bytes */
170 buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
172 samples = av_malloc(buffer_size);
174 fprintf(stderr, "could not allocate %d bytes for samples buffer\n",
178 /* setup the data pointers in the AVFrame */
179 ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
180 (const uint8_t*)samples, buffer_size, 0);
182 fprintf(stderr, "could not setup audio frame\n");
186 /* encode a single tone sound */
188 tincr = 2 * M_PI * 440.0 / c->sample_rate;
190 av_init_packet(&pkt);
191 pkt.data = NULL; // packet data will be allocated by the encoder
194 for (j = 0; j < c->frame_size; j++) {
195 samples[2*j] = (int)(sin(t) * 10000);
197 for (k = 1; k < c->channels; k++)
198 samples[2*j + k] = samples[2*j];
201 /* encode the samples */
202 ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
204 fprintf(stderr, "error encoding audio frame\n");
208 fwrite(pkt.data, 1, pkt.size, f);
209 av_free_packet(&pkt);
215 avcodec_free_frame(&frame);
223 static void audio_decode_example(const char *outfilename, const char *filename)
226 AVCodecContext *c= NULL;
229 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
231 AVFrame *decoded_frame = NULL;
233 av_init_packet(&avpkt);
235 printf("Audio decoding\n");
237 /* find the mpeg audio decoder */
238 codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
240 fprintf(stderr, "codec not found\n");
244 c = avcodec_alloc_context3(codec);
247 if (avcodec_open2(c, codec, NULL) < 0) {
248 fprintf(stderr, "could not open codec\n");
252 f = fopen(filename, "rb");
254 fprintf(stderr, "could not open %s\n", filename);
257 outfile = fopen(outfilename, "wb");
263 /* decode until eof */
265 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
267 while (avpkt.size > 0) {
270 if (!decoded_frame) {
271 if (!(decoded_frame = avcodec_alloc_frame())) {
272 fprintf(stderr, "out of memory\n");
276 avcodec_get_frame_defaults(decoded_frame);
278 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
280 fprintf(stderr, "Error while decoding\n");
284 /* if a frame has been decoded, output it */
285 int data_size = av_samples_get_buffer_size(NULL, c->channels,
286 decoded_frame->nb_samples,
288 fwrite(decoded_frame->data[0], 1, data_size, outfile);
292 if (avpkt.size < AUDIO_REFILL_THRESH) {
293 /* Refill the input buffer, to avoid trying to decode
294 * incomplete frames. Instead of this, one could also use
295 * a parser, or use a proper container format through
297 memmove(inbuf, avpkt.data, avpkt.size);
299 len = fread(avpkt.data + avpkt.size, 1,
300 AUDIO_INBUF_SIZE - avpkt.size, f);
311 avcodec_free_frame(&decoded_frame);
315 * Video encoding example
317 static void video_encode_example(const char *filename)
320 AVCodecContext *c= NULL;
321 int i, ret, x, y, got_output;
325 uint8_t endcode[] = { 0, 0, 1, 0xb7 };
327 printf("Video encoding\n");
329 /* find the mpeg1 video encoder */
330 codec = avcodec_find_encoder(AV_CODEC_ID_MPEG1VIDEO);
332 fprintf(stderr, "codec not found\n");
336 c = avcodec_alloc_context3(codec);
337 picture= avcodec_alloc_frame();
339 /* put sample parameters */
340 c->bit_rate = 400000;
341 /* resolution must be a multiple of two */
344 /* frames per second */
345 c->time_base= (AVRational){1,25};
346 c->gop_size = 10; /* emit one intra frame every ten frames */
348 c->pix_fmt = AV_PIX_FMT_YUV420P;
351 if (avcodec_open2(c, codec, NULL) < 0) {
352 fprintf(stderr, "could not open codec\n");
356 f = fopen(filename, "wb");
358 fprintf(stderr, "could not open %s\n", filename);
362 ret = av_image_alloc(picture->data, picture->linesize, c->width, c->height,
365 fprintf(stderr, "could not alloc raw picture buffer\n");
368 picture->format = c->pix_fmt;
369 picture->width = c->width;
370 picture->height = c->height;
372 /* encode 1 second of video */
374 av_init_packet(&pkt);
375 pkt.data = NULL; // packet data will be allocated by the encoder
379 /* prepare a dummy image */
381 for(y=0;y<c->height;y++) {
382 for(x=0;x<c->width;x++) {
383 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
388 for(y=0;y<c->height/2;y++) {
389 for(x=0;x<c->width/2;x++) {
390 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
391 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
397 /* encode the image */
398 ret = avcodec_encode_video2(c, &pkt, picture, &got_output);
400 fprintf(stderr, "error encoding frame\n");
405 printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
406 fwrite(pkt.data, 1, pkt.size, f);
407 av_free_packet(&pkt);
411 /* get the delayed frames */
412 for (got_output = 1; got_output; i++) {
415 ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
417 fprintf(stderr, "error encoding frame\n");
422 printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
423 fwrite(pkt.data, 1, pkt.size, f);
424 av_free_packet(&pkt);
428 /* add sequence end code to have a real mpeg file */
429 fwrite(endcode, 1, sizeof(endcode), f);
434 av_freep(&picture->data[0]);
435 avcodec_free_frame(&picture);
440 * Video decoding example
443 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
449 f=fopen(filename,"w");
450 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
452 fwrite(buf + i * wrap,1,xsize,f);
456 static void video_decode_example(const char *outfilename, const char *filename)
459 AVCodecContext *c= NULL;
460 int frame, got_picture, len;
463 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
467 av_init_packet(&avpkt);
469 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
470 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
472 printf("Video decoding\n");
474 /* find the mpeg1 video decoder */
475 codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
477 fprintf(stderr, "codec not found\n");
481 c = avcodec_alloc_context3(codec);
482 picture= avcodec_alloc_frame();
484 if(codec->capabilities&CODEC_CAP_TRUNCATED)
485 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
487 /* For some codecs, such as msmpeg4 and mpeg4, width and height
488 MUST be initialized there because this information is not
489 available in the bitstream. */
492 if (avcodec_open2(c, codec, NULL) < 0) {
493 fprintf(stderr, "could not open codec\n");
497 /* the codec gives us the frame size, in samples */
499 f = fopen(filename, "rb");
501 fprintf(stderr, "could not open %s\n", filename);
507 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
511 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
512 and this is the only method to use them because you cannot
513 know the compressed data size before analysing it.
515 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
516 based, so you must call them with all the data for one
517 frame exactly. You must also initialize 'width' and
518 'height' before initializing them. */
520 /* NOTE2: some codecs allow the raw parameters (frame size,
521 sample rate) to be changed at any frame. We handle this, so
522 you should also take care of it */
524 /* here, we use a stream based decoder (mpeg1video), so we
525 feed decoder and see if it could decode a frame */
527 while (avpkt.size > 0) {
528 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
530 fprintf(stderr, "Error while decoding frame %d\n", frame);
534 printf("saving frame %3d\n", frame);
537 /* the picture is allocated by the decoder. no need to
539 snprintf(buf, sizeof(buf), outfilename, frame);
540 pgm_save(picture->data[0], picture->linesize[0],
541 c->width, c->height, buf);
549 /* some codecs, such as MPEG, transmit the I and P frame with a
550 latency of one frame. You must do the following to have a
551 chance to get the last frame of the video */
554 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
556 printf("saving last frame %3d\n", frame);
559 /* the picture is allocated by the decoder. no need to
561 snprintf(buf, sizeof(buf), outfilename, frame);
562 pgm_save(picture->data[0], picture->linesize[0],
563 c->width, c->height, buf);
571 avcodec_free_frame(&picture);
575 int main(int argc, char **argv)
577 const char *filename;
579 /* register all the codecs */
580 avcodec_register_all();
583 audio_encode_example("/tmp/test.mp2");
584 audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
586 video_encode_example("/tmp/test.mpg");
587 filename = "/tmp/test.mpg";
592 // audio_decode_example("/tmp/test.sw", filename);
593 video_decode_example("/tmp/test%d.pgm", filename);