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 * Note that libavcodec only handles codecs (mpeg, mpeg4, etc...),
28 * not file formats (avi, vob, mp4, mov, mkv, mxf, flv, mpegts, mpegps, etc...). See library 'libavformat' for the
32 #include "libavutil/imgutils.h"
33 #include "libavutil/opt.h"
34 #include "libavcodec/avcodec.h"
35 #include "libavutil/mathematics.h"
37 #define INBUF_SIZE 4096
38 #define AUDIO_INBUF_SIZE 20480
39 #define AUDIO_REFILL_THRESH 4096
42 * Audio encoding example
44 static void audio_encode_example(const char *filename)
47 AVCodecContext *c= NULL;
48 int frame_size, i, j, out_size, outbuf_size;
54 printf("Audio encoding\n");
56 /* find the MP2 encoder */
57 codec = avcodec_find_encoder(CODEC_ID_MP2);
59 fprintf(stderr, "codec not found\n");
63 c = avcodec_alloc_context3(codec);
65 /* put sample parameters */
67 c->sample_rate = 44100;
69 c->sample_fmt = AV_SAMPLE_FMT_S16;
72 if (avcodec_open(c, codec) < 0) {
73 fprintf(stderr, "could not open codec\n");
77 /* the codec gives us the frame size, in samples */
78 frame_size = c->frame_size;
79 samples = malloc(frame_size * 2 * c->channels);
81 outbuf = malloc(outbuf_size);
83 f = fopen(filename, "wb");
85 fprintf(stderr, "could not open %s\n", filename);
89 /* encode a single tone sound */
91 tincr = 2 * M_PI * 440.0 / c->sample_rate;
93 for(j=0;j<frame_size;j++) {
94 samples[2*j] = (int)(sin(t) * 10000);
95 samples[2*j+1] = samples[2*j];
98 /* encode the samples */
99 out_size = avcodec_encode_audio(c, outbuf, outbuf_size, samples);
100 fwrite(outbuf, 1, out_size, f);
113 static void audio_decode_example(const char *outfilename, const char *filename)
116 AVCodecContext *c= NULL;
120 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
123 av_init_packet(&avpkt);
125 printf("Audio decoding\n");
127 /* find the mpeg audio decoder */
128 codec = avcodec_find_decoder(CODEC_ID_MP2);
130 fprintf(stderr, "codec not found\n");
134 c = avcodec_alloc_context3(codec);
137 if (avcodec_open(c, codec) < 0) {
138 fprintf(stderr, "could not open codec\n");
142 outbuf = malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
144 f = fopen(filename, "rb");
146 fprintf(stderr, "could not open %s\n", filename);
149 outfile = fopen(outfilename, "wb");
155 /* decode until eof */
157 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
159 while (avpkt.size > 0) {
160 out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
161 len = avcodec_decode_audio3(c, (short *)outbuf, &out_size, &avpkt);
163 fprintf(stderr, "Error while decoding\n");
167 /* if a frame has been decoded, output it */
168 fwrite(outbuf, 1, out_size, outfile);
172 if (avpkt.size < AUDIO_REFILL_THRESH) {
173 /* Refill the input buffer, to avoid trying to decode
174 * incomplete frames. Instead of this, one could also use
175 * a parser, or use a proper container format through
177 memmove(inbuf, avpkt.data, avpkt.size);
179 len = fread(avpkt.data + avpkt.size, 1,
180 AUDIO_INBUF_SIZE - avpkt.size, f);
195 * Video encoding example
197 static void video_encode_example(const char *filename, int codec_id)
200 AVCodecContext *c= NULL;
201 int i, out_size, size, x, y, outbuf_size;
206 printf("Video encoding\n");
208 /* find the mpeg1 video encoder */
209 codec = avcodec_find_encoder(codec_id);
211 fprintf(stderr, "codec not found\n");
215 c = avcodec_alloc_context3(codec);
216 picture= avcodec_alloc_frame();
218 /* put sample parameters */
219 c->bit_rate = 400000;
220 /* resolution must be a multiple of two */
223 /* frames per second */
224 c->time_base= (AVRational){1,25};
225 c->gop_size = 10; /* emit one intra frame every ten frames */
227 c->pix_fmt = PIX_FMT_YUV420P;
229 if(codec_id == CODEC_ID_H264)
230 av_opt_set(c->priv_data, "preset", "slow", 0);
233 if (avcodec_open(c, codec) < 0) {
234 fprintf(stderr, "could not open codec\n");
238 f = fopen(filename, "wb");
240 fprintf(stderr, "could not open %s\n", filename);
244 /* alloc image and output buffer */
245 outbuf_size = 100000;
246 outbuf = malloc(outbuf_size);
248 /* the image can be allocated by any means and av_image_alloc() is
249 * just the most convenient way if av_malloc() is to be used */
250 av_image_alloc(picture->data, picture->linesize,
251 c->width, c->height, c->pix_fmt, 1);
253 /* encode 1 second of video */
256 /* prepare a dummy image */
258 for(y=0;y<c->height;y++) {
259 for(x=0;x<c->width;x++) {
260 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
265 for(y=0;y<c->height/2;y++) {
266 for(x=0;x<c->width/2;x++) {
267 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
268 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
272 /* encode the image */
273 out_size = avcodec_encode_video(c, outbuf, outbuf_size, picture);
274 printf("encoding frame %3d (size=%5d)\n", i, out_size);
275 fwrite(outbuf, 1, out_size, f);
278 /* get the delayed frames */
279 for(; out_size; i++) {
282 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
283 printf("write frame %3d (size=%5d)\n", i, out_size);
284 fwrite(outbuf, 1, out_size, f);
287 /* add sequence end code to have a real mpeg file */
292 fwrite(outbuf, 1, 4, f);
298 av_free(picture->data[0]);
304 * Video decoding example
307 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
313 f=fopen(filename,"w");
314 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
316 fwrite(buf + i * wrap,1,xsize,f);
320 static void video_decode_example(const char *outfilename, const char *filename)
323 AVCodecContext *c= NULL;
324 int frame, got_picture, len;
327 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
331 av_init_packet(&avpkt);
333 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
334 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
336 printf("Video decoding\n");
338 /* find the mpeg1 video decoder */
339 codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO);
341 fprintf(stderr, "codec not found\n");
345 c = avcodec_alloc_context3(codec);
346 picture= avcodec_alloc_frame();
348 if(codec->capabilities&CODEC_CAP_TRUNCATED)
349 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
351 /* For some codecs, such as msmpeg4 and mpeg4, width and height
352 MUST be initialized there because this information is not
353 available in the bitstream. */
356 if (avcodec_open(c, codec) < 0) {
357 fprintf(stderr, "could not open codec\n");
361 /* the codec gives us the frame size, in samples */
363 f = fopen(filename, "rb");
365 fprintf(stderr, "could not open %s\n", filename);
371 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
375 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
376 and this is the only method to use them because you cannot
377 know the compressed data size before analysing it.
379 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
380 based, so you must call them with all the data for one
381 frame exactly. You must also initialize 'width' and
382 'height' before initializing them. */
384 /* NOTE2: some codecs allow the raw parameters (frame size,
385 sample rate) to be changed at any frame. We handle this, so
386 you should also take care of it */
388 /* here, we use a stream based decoder (mpeg1video), so we
389 feed decoder and see if it could decode a frame */
391 while (avpkt.size > 0) {
392 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
394 fprintf(stderr, "Error while decoding frame %d\n", frame);
398 printf("saving frame %3d\n", frame);
401 /* the picture is allocated by the decoder. no need to
403 snprintf(buf, sizeof(buf), outfilename, frame);
404 pgm_save(picture->data[0], picture->linesize[0],
405 c->width, c->height, buf);
413 /* some codecs, such as MPEG, transmit the I and P frame with a
414 latency of one frame. You must do the following to have a
415 chance to get the last frame of the video */
418 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
420 printf("saving last frame %3d\n", frame);
423 /* the picture is allocated by the decoder. no need to
425 snprintf(buf, sizeof(buf), outfilename, frame);
426 pgm_save(picture->data[0], picture->linesize[0],
427 c->width, c->height, buf);
439 int main(int argc, char **argv)
441 const char *filename;
443 /* must be called before using avcodec lib */
446 /* register all the codecs */
447 avcodec_register_all();
450 audio_encode_example("/tmp/test.mp2");
451 audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
453 video_encode_example("/tmp/test.h264", CODEC_ID_H264);
454 video_encode_example("/tmp/test.mpg", CODEC_ID_MPEG1VIDEO);
455 filename = "/tmp/test.mpg";
460 // audio_decode_example("/tmp/test.sw", filename);
461 video_decode_example("/tmp/test%d.pgm", filename);