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
34 #include <libavutil/imgutils.h>
35 #include <libavutil/opt.h>
36 #include <libavcodec/avcodec.h>
37 #include <libavutil/mathematics.h>
38 #include <libavutil/samplefmt.h>
40 #define INBUF_SIZE 4096
41 #define AUDIO_INBUF_SIZE 20480
42 #define AUDIO_REFILL_THRESH 4096
45 * Audio encoding example
47 static void audio_encode_example(const char *filename)
50 AVCodecContext *c= NULL;
51 int frame_size, i, j, out_size, outbuf_size;
57 printf("Encode audio file %s\n", filename);
59 /* find the MP2 encoder */
60 codec = avcodec_find_encoder(CODEC_ID_MP2);
62 fprintf(stderr, "codec not found\n");
66 c = avcodec_alloc_context3(codec);
68 /* put sample parameters */
70 c->sample_rate = 44100;
72 c->sample_fmt = AV_SAMPLE_FMT_S16;
75 if (avcodec_open2(c, codec, NULL) < 0) {
76 fprintf(stderr, "could not open codec\n");
80 /* the codec gives us the frame size, in samples */
81 frame_size = c->frame_size;
82 samples = malloc(frame_size * 2 * c->channels);
84 outbuf = malloc(outbuf_size);
86 f = fopen(filename, "wb");
88 fprintf(stderr, "could not open %s\n", filename);
92 /* encode a single tone sound */
94 tincr = 2 * M_PI * 440.0 / c->sample_rate;
96 for(j=0;j<frame_size;j++) {
97 samples[2*j] = (int)(sin(t) * 10000);
98 samples[2*j+1] = samples[2*j];
101 /* encode the samples */
102 out_size = avcodec_encode_audio(c, outbuf, outbuf_size, samples);
103 fwrite(outbuf, 1, out_size, f);
116 static void audio_decode_example(const char *outfilename, const char *filename)
119 AVCodecContext *c= NULL;
122 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
124 AVFrame *decoded_frame = NULL;
126 av_init_packet(&avpkt);
128 printf("Decode audio file %s\n", filename);
130 /* find the mpeg audio decoder */
131 codec = avcodec_find_decoder(CODEC_ID_MP2);
133 fprintf(stderr, "codec not found\n");
137 c = avcodec_alloc_context3(codec);
140 if (avcodec_open2(c, codec, NULL) < 0) {
141 fprintf(stderr, "could not open codec\n");
145 f = fopen(filename, "rb");
147 fprintf(stderr, "could not open %s\n", filename);
150 outfile = fopen(outfilename, "wb");
156 /* decode until eof */
158 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
160 while (avpkt.size > 0) {
163 if (!decoded_frame) {
164 if (!(decoded_frame = avcodec_alloc_frame())) {
165 fprintf(stderr, "out of memory\n");
169 avcodec_get_frame_defaults(decoded_frame);
171 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
173 fprintf(stderr, "Error while decoding\n");
177 /* if a frame has been decoded, output it */
178 int data_size = av_samples_get_buffer_size(NULL, c->channels,
179 decoded_frame->nb_samples,
181 fwrite(decoded_frame->data[0], 1, data_size, outfile);
186 avpkt.pts = AV_NOPTS_VALUE;
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, int codec_id)
215 AVCodecContext *c= NULL;
216 int i, out_size, x, y, outbuf_size;
222 printf("Encode video file %s\n", filename);
224 /* find the mpeg1 video encoder */
225 codec = avcodec_find_encoder(codec_id);
227 fprintf(stderr, "codec not found\n");
231 c = avcodec_alloc_context3(codec);
232 picture= avcodec_alloc_frame();
234 /* put sample parameters */
235 c->bit_rate = 400000;
236 /* resolution must be a multiple of two */
239 /* frames per second */
240 c->time_base= (AVRational){1,25};
241 c->gop_size = 10; /* emit one intra frame every ten frames */
243 c->pix_fmt = PIX_FMT_YUV420P;
245 if(codec_id == CODEC_ID_H264)
246 av_opt_set(c->priv_data, "preset", "slow", 0);
249 if (avcodec_open2(c, codec, NULL) < 0) {
250 fprintf(stderr, "could not open codec\n");
254 f = fopen(filename, "wb");
256 fprintf(stderr, "could not open %s\n", filename);
260 /* alloc image and output buffer */
261 outbuf_size = 100000 + 12*c->width*c->height;
262 outbuf = malloc(outbuf_size);
264 /* the image can be allocated by any means and av_image_alloc() is
265 * just the most convenient way if av_malloc() is to be used */
266 av_image_alloc(picture->data, picture->linesize,
267 c->width, c->height, c->pix_fmt, 1);
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 had_output |= out_size;
291 printf("encoding frame %3d (size=%5d)\n", i, out_size);
292 fwrite(outbuf, 1, out_size, f);
295 /* get the delayed frames */
296 for(; out_size || !had_output; i++) {
299 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
300 had_output |= out_size;
301 printf("write frame %3d (size=%5d)\n", i, out_size);
302 fwrite(outbuf, 1, out_size, f);
305 /* add sequence end code to have a real mpeg file */
310 fwrite(outbuf, 1, 4, f);
316 av_free(picture->data[0]);
322 * Video decoding example
325 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
331 f=fopen(filename,"w");
332 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
334 fwrite(buf + i * wrap,1,xsize,f);
338 static void video_decode_example(const char *outfilename, const char *filename)
341 AVCodecContext *c= NULL;
342 int frame, got_picture, len;
345 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
349 av_init_packet(&avpkt);
351 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
352 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
354 printf("Decode video file %s\n", filename);
356 /* find the mpeg1 video decoder */
357 codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO);
359 fprintf(stderr, "codec not found\n");
363 c = avcodec_alloc_context3(codec);
364 picture= avcodec_alloc_frame();
366 if(codec->capabilities&CODEC_CAP_TRUNCATED)
367 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
369 /* For some codecs, such as msmpeg4 and mpeg4, width and height
370 MUST be initialized there because this information is not
371 available in the bitstream. */
374 if (avcodec_open2(c, codec, NULL) < 0) {
375 fprintf(stderr, "could not open codec\n");
379 /* the codec gives us the frame size, in samples */
381 f = fopen(filename, "rb");
383 fprintf(stderr, "could not open %s\n", filename);
389 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
393 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
394 and this is the only method to use them because you cannot
395 know the compressed data size before analysing it.
397 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
398 based, so you must call them with all the data for one
399 frame exactly. You must also initialize 'width' and
400 'height' before initializing them. */
402 /* NOTE2: some codecs allow the raw parameters (frame size,
403 sample rate) to be changed at any frame. We handle this, so
404 you should also take care of it */
406 /* here, we use a stream based decoder (mpeg1video), so we
407 feed decoder and see if it could decode a frame */
409 while (avpkt.size > 0) {
410 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
412 fprintf(stderr, "Error while decoding frame %d\n", frame);
416 printf("saving frame %3d\n", frame);
419 /* the picture is allocated by the decoder. no need to
421 snprintf(buf, sizeof(buf), outfilename, frame);
422 pgm_save(picture->data[0], picture->linesize[0],
423 c->width, c->height, buf);
431 /* some codecs, such as MPEG, transmit the I and P frame with a
432 latency of one frame. You must do the following to have a
433 chance to get the last frame of the video */
436 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
438 printf("saving last frame %3d\n", frame);
441 /* the picture is allocated by the decoder. no need to
443 snprintf(buf, sizeof(buf), outfilename, frame);
444 pgm_save(picture->data[0], picture->linesize[0],
445 c->width, c->height, buf);
457 int main(int argc, char **argv)
459 const char *filename;
461 /* register all the codecs */
462 avcodec_register_all();
465 audio_encode_example("/tmp/test.mp2");
466 audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
468 video_encode_example("/tmp/test.h264", CODEC_ID_H264);
469 video_encode_example("/tmp/test.mpg", CODEC_ID_MPEG1VIDEO);
470 filename = "/tmp/test.mpg";
475 // audio_decode_example("/tmp/test.sw", filename);
476 video_decode_example("/tmp/test%d.pgm", filename);