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/mathematics.h"
41 #include "libavutil/samplefmt.h"
43 #define INBUF_SIZE 4096
44 #define AUDIO_INBUF_SIZE 20480
45 #define AUDIO_REFILL_THRESH 4096
48 * Audio encoding example
50 static void audio_encode_example(const char *filename)
53 AVCodecContext *c= NULL;
54 int frame_size, i, j, out_size, outbuf_size;
60 printf("Audio encoding\n");
62 /* find the MP2 encoder */
63 codec = avcodec_find_encoder(CODEC_ID_MP2);
65 fprintf(stderr, "codec not found\n");
69 c = avcodec_alloc_context3(codec);
71 /* put sample parameters */
73 c->sample_rate = 44100;
77 if (avcodec_open2(c, codec, NULL) < 0) {
78 fprintf(stderr, "could not open codec\n");
82 /* the codec gives us the frame size, in samples */
83 frame_size = c->frame_size;
84 samples = malloc(frame_size * 2 * c->channels);
86 outbuf = malloc(outbuf_size);
88 f = fopen(filename, "wb");
90 fprintf(stderr, "could not open %s\n", filename);
94 /* encode a single tone sound */
96 tincr = 2 * M_PI * 440.0 / c->sample_rate;
98 for(j=0;j<frame_size;j++) {
99 samples[2*j] = (int)(sin(t) * 10000);
100 samples[2*j+1] = samples[2*j];
103 /* encode the samples */
104 out_size = avcodec_encode_audio(c, outbuf, outbuf_size, samples);
105 fwrite(outbuf, 1, out_size, f);
118 static void audio_decode_example(const char *outfilename, const char *filename)
121 AVCodecContext *c= NULL;
124 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
126 AVFrame *decoded_frame = NULL;
128 av_init_packet(&avpkt);
130 printf("Audio decoding\n");
132 /* find the mpeg audio decoder */
133 codec = avcodec_find_decoder(CODEC_ID_MP2);
135 fprintf(stderr, "codec not found\n");
139 c = avcodec_alloc_context3(codec);
142 if (avcodec_open2(c, codec, NULL) < 0) {
143 fprintf(stderr, "could not open codec\n");
147 f = fopen(filename, "rb");
149 fprintf(stderr, "could not open %s\n", filename);
152 outfile = fopen(outfilename, "wb");
158 /* decode until eof */
160 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
162 while (avpkt.size > 0) {
165 if (!decoded_frame) {
166 if (!(decoded_frame = avcodec_alloc_frame())) {
167 fprintf(stderr, "out of memory\n");
171 avcodec_get_frame_defaults(decoded_frame);
173 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
175 fprintf(stderr, "Error while decoding\n");
179 /* if a frame has been decoded, output it */
180 int data_size = av_samples_get_buffer_size(NULL, c->channels,
181 decoded_frame->nb_samples,
183 fwrite(decoded_frame->data[0], 1, data_size, outfile);
187 if (avpkt.size < AUDIO_REFILL_THRESH) {
188 /* Refill the input buffer, to avoid trying to decode
189 * incomplete frames. Instead of this, one could also use
190 * a parser, or use a proper container format through
192 memmove(inbuf, avpkt.data, avpkt.size);
194 len = fread(avpkt.data + avpkt.size, 1,
195 AUDIO_INBUF_SIZE - avpkt.size, f);
206 av_free(decoded_frame);
210 * Video encoding example
212 static void video_encode_example(const char *filename)
215 AVCodecContext *c= NULL;
216 int i, out_size, size, x, y, outbuf_size;
219 uint8_t *outbuf, *picture_buf;
221 printf("Video encoding\n");
223 /* find the mpeg1 video encoder */
224 codec = avcodec_find_encoder(CODEC_ID_MPEG1VIDEO);
226 fprintf(stderr, "codec not found\n");
230 c = avcodec_alloc_context3(codec);
231 picture= avcodec_alloc_frame();
233 /* put sample parameters */
234 c->bit_rate = 400000;
235 /* resolution must be a multiple of two */
238 /* frames per second */
239 c->time_base= (AVRational){1,25};
240 c->gop_size = 10; /* emit one intra frame every ten frames */
242 c->pix_fmt = PIX_FMT_YUV420P;
245 if (avcodec_open2(c, codec, NULL) < 0) {
246 fprintf(stderr, "could not open codec\n");
250 f = fopen(filename, "wb");
252 fprintf(stderr, "could not open %s\n", filename);
256 /* alloc image and output buffer */
257 outbuf_size = 100000;
258 outbuf = malloc(outbuf_size);
259 size = c->width * c->height;
260 picture_buf = malloc((size * 3) / 2); /* size for YUV 420 */
262 picture->data[0] = picture_buf;
263 picture->data[1] = picture->data[0] + size;
264 picture->data[2] = picture->data[1] + size / 4;
265 picture->linesize[0] = c->width;
266 picture->linesize[1] = c->width / 2;
267 picture->linesize[2] = c->width / 2;
269 /* encode 1 second of video */
272 /* prepare a dummy image */
274 for(y=0;y<c->height;y++) {
275 for(x=0;x<c->width;x++) {
276 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
281 for(y=0;y<c->height/2;y++) {
282 for(x=0;x<c->width/2;x++) {
283 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
284 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
288 /* encode the image */
289 out_size = avcodec_encode_video(c, outbuf, outbuf_size, picture);
290 printf("encoding frame %3d (size=%5d)\n", i, out_size);
291 fwrite(outbuf, 1, out_size, f);
294 /* get the delayed frames */
295 for(; out_size; i++) {
298 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
299 printf("write frame %3d (size=%5d)\n", i, out_size);
300 fwrite(outbuf, 1, out_size, f);
303 /* add sequence end code to have a real mpeg file */
308 fwrite(outbuf, 1, 4, f);
320 * Video decoding example
323 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
329 f=fopen(filename,"w");
330 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
332 fwrite(buf + i * wrap,1,xsize,f);
336 static void video_decode_example(const char *outfilename, const char *filename)
339 AVCodecContext *c= NULL;
340 int frame, got_picture, len;
343 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
347 av_init_packet(&avpkt);
349 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
350 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
352 printf("Video decoding\n");
354 /* find the mpeg1 video decoder */
355 codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO);
357 fprintf(stderr, "codec not found\n");
361 c = avcodec_alloc_context3(codec);
362 picture= avcodec_alloc_frame();
364 if(codec->capabilities&CODEC_CAP_TRUNCATED)
365 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
367 /* For some codecs, such as msmpeg4 and mpeg4, width and height
368 MUST be initialized there because this information is not
369 available in the bitstream. */
372 if (avcodec_open2(c, codec, NULL) < 0) {
373 fprintf(stderr, "could not open codec\n");
377 /* the codec gives us the frame size, in samples */
379 f = fopen(filename, "rb");
381 fprintf(stderr, "could not open %s\n", filename);
387 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
391 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
392 and this is the only method to use them because you cannot
393 know the compressed data size before analysing it.
395 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
396 based, so you must call them with all the data for one
397 frame exactly. You must also initialize 'width' and
398 'height' before initializing them. */
400 /* NOTE2: some codecs allow the raw parameters (frame size,
401 sample rate) to be changed at any frame. We handle this, so
402 you should also take care of it */
404 /* here, we use a stream based decoder (mpeg1video), so we
405 feed decoder and see if it could decode a frame */
407 while (avpkt.size > 0) {
408 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
410 fprintf(stderr, "Error while decoding frame %d\n", frame);
414 printf("saving frame %3d\n", frame);
417 /* the picture is allocated by the decoder. no need to
419 snprintf(buf, sizeof(buf), outfilename, frame);
420 pgm_save(picture->data[0], picture->linesize[0],
421 c->width, c->height, buf);
429 /* some codecs, such as MPEG, transmit the I and P frame with a
430 latency of one frame. You must do the following to have a
431 chance to get the last frame of the video */
434 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
436 printf("saving last frame %3d\n", frame);
439 /* the picture is allocated by the decoder. no need to
441 snprintf(buf, sizeof(buf), outfilename, frame);
442 pgm_save(picture->data[0], picture->linesize[0],
443 c->width, c->height, buf);
455 int main(int argc, char **argv)
457 const char *filename;
459 /* register all the codecs */
460 avcodec_register_all();
463 audio_encode_example("/tmp/test.mp2");
464 audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
466 video_encode_example("/tmp/test.mpg");
467 filename = "/tmp/test.mpg";
472 // audio_decode_example("/tmp/test.sw", filename);
473 video_decode_example("/tmp/test%d.pgm", filename);