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"
36 #include "libavutil/samplefmt.h"
38 #define INBUF_SIZE 4096
39 #define AUDIO_INBUF_SIZE 20480
40 #define AUDIO_REFILL_THRESH 4096
43 * Audio encoding example
45 static void audio_encode_example(const char *filename)
48 AVCodecContext *c= NULL;
49 int frame_size, i, j, out_size, outbuf_size;
55 printf("Audio encoding\n");
57 /* find the MP2 encoder */
58 codec = avcodec_find_encoder(CODEC_ID_MP2);
60 fprintf(stderr, "codec not found\n");
64 c = avcodec_alloc_context3(codec);
66 /* put sample parameters */
68 c->sample_rate = 44100;
70 c->sample_fmt = AV_SAMPLE_FMT_S16;
73 if (avcodec_open(c, codec) < 0) {
74 fprintf(stderr, "could not open codec\n");
78 /* the codec gives us the frame size, in samples */
79 frame_size = c->frame_size;
80 samples = malloc(frame_size * 2 * c->channels);
82 outbuf = malloc(outbuf_size);
84 f = fopen(filename, "wb");
86 fprintf(stderr, "could not open %s\n", filename);
90 /* encode a single tone sound */
92 tincr = 2 * M_PI * 440.0 / c->sample_rate;
94 for(j=0;j<frame_size;j++) {
95 samples[2*j] = (int)(sin(t) * 10000);
96 samples[2*j+1] = samples[2*j];
99 /* encode the samples */
100 out_size = avcodec_encode_audio(c, outbuf, outbuf_size, samples);
101 fwrite(outbuf, 1, out_size, f);
114 static void audio_decode_example(const char *outfilename, const char *filename)
117 AVCodecContext *c= NULL;
120 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
122 AVFrame *decoded_frame = NULL;
124 av_init_packet(&avpkt);
126 printf("Audio decoding\n");
128 /* find the mpeg audio decoder */
129 codec = avcodec_find_decoder(CODEC_ID_MP2);
131 fprintf(stderr, "codec not found\n");
135 c = avcodec_alloc_context3(codec);
138 if (avcodec_open(c, codec) < 0) {
139 fprintf(stderr, "could not open codec\n");
143 f = fopen(filename, "rb");
145 fprintf(stderr, "could not open %s\n", filename);
148 outfile = fopen(outfilename, "wb");
154 /* decode until eof */
156 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
158 while (avpkt.size > 0) {
161 if (!decoded_frame) {
162 if (!(decoded_frame = avcodec_alloc_frame())) {
163 fprintf(stderr, "out of memory\n");
167 avcodec_get_frame_defaults(decoded_frame);
169 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
171 fprintf(stderr, "Error while decoding\n");
175 /* if a frame has been decoded, output it */
176 int data_size = av_samples_get_buffer_size(NULL, c->channels,
177 decoded_frame->nb_samples,
179 fwrite(decoded_frame->data[0], 1, data_size, outfile);
184 avpkt.pts = AV_NOPTS_VALUE;
185 if (avpkt.size < AUDIO_REFILL_THRESH) {
186 /* Refill the input buffer, to avoid trying to decode
187 * incomplete frames. Instead of this, one could also use
188 * a parser, or use a proper container format through
190 memmove(inbuf, avpkt.data, avpkt.size);
192 len = fread(avpkt.data + avpkt.size, 1,
193 AUDIO_INBUF_SIZE - avpkt.size, f);
204 av_free(decoded_frame);
208 * Video encoding example
210 static void video_encode_example(const char *filename, int codec_id)
213 AVCodecContext *c= NULL;
214 int i, out_size, size, x, y, outbuf_size;
219 printf("Video encoding\n");
221 /* find the mpeg1 video encoder */
222 codec = avcodec_find_encoder(codec_id);
224 fprintf(stderr, "codec not found\n");
228 c = avcodec_alloc_context3(codec);
229 picture= avcodec_alloc_frame();
231 /* put sample parameters */
232 c->bit_rate = 400000;
233 /* resolution must be a multiple of two */
236 /* frames per second */
237 c->time_base= (AVRational){1,25};
238 c->gop_size = 10; /* emit one intra frame every ten frames */
240 c->pix_fmt = PIX_FMT_YUV420P;
242 if(codec_id == CODEC_ID_H264)
243 av_opt_set(c->priv_data, "preset", "slow", 0);
246 if (avcodec_open(c, codec) < 0) {
247 fprintf(stderr, "could not open codec\n");
251 f = fopen(filename, "wb");
253 fprintf(stderr, "could not open %s\n", filename);
257 /* alloc image and output buffer */
258 outbuf_size = 100000;
259 outbuf = malloc(outbuf_size);
261 /* the image can be allocated by any means and av_image_alloc() is
262 * just the most convenient way if av_malloc() is to be used */
263 av_image_alloc(picture->data, picture->linesize,
264 c->width, c->height, c->pix_fmt, 1);
266 /* encode 1 second of video */
269 /* prepare a dummy image */
271 for(y=0;y<c->height;y++) {
272 for(x=0;x<c->width;x++) {
273 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
278 for(y=0;y<c->height/2;y++) {
279 for(x=0;x<c->width/2;x++) {
280 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
281 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
285 /* encode the image */
286 out_size = avcodec_encode_video(c, outbuf, outbuf_size, picture);
287 printf("encoding frame %3d (size=%5d)\n", i, out_size);
288 fwrite(outbuf, 1, out_size, f);
291 /* get the delayed frames */
292 for(; out_size; i++) {
295 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
296 printf("write frame %3d (size=%5d)\n", i, out_size);
297 fwrite(outbuf, 1, out_size, f);
300 /* add sequence end code to have a real mpeg file */
305 fwrite(outbuf, 1, 4, f);
311 av_free(picture->data[0]);
317 * Video decoding example
320 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
326 f=fopen(filename,"w");
327 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
329 fwrite(buf + i * wrap,1,xsize,f);
333 static void video_decode_example(const char *outfilename, const char *filename)
336 AVCodecContext *c= NULL;
337 int frame, got_picture, len;
340 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
344 av_init_packet(&avpkt);
346 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
347 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
349 printf("Video decoding\n");
351 /* find the mpeg1 video decoder */
352 codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO);
354 fprintf(stderr, "codec not found\n");
358 c = avcodec_alloc_context3(codec);
359 picture= avcodec_alloc_frame();
361 if(codec->capabilities&CODEC_CAP_TRUNCATED)
362 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
364 /* For some codecs, such as msmpeg4 and mpeg4, width and height
365 MUST be initialized there because this information is not
366 available in the bitstream. */
369 if (avcodec_open(c, codec) < 0) {
370 fprintf(stderr, "could not open codec\n");
374 /* the codec gives us the frame size, in samples */
376 f = fopen(filename, "rb");
378 fprintf(stderr, "could not open %s\n", filename);
384 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
388 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
389 and this is the only method to use them because you cannot
390 know the compressed data size before analysing it.
392 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
393 based, so you must call them with all the data for one
394 frame exactly. You must also initialize 'width' and
395 'height' before initializing them. */
397 /* NOTE2: some codecs allow the raw parameters (frame size,
398 sample rate) to be changed at any frame. We handle this, so
399 you should also take care of it */
401 /* here, we use a stream based decoder (mpeg1video), so we
402 feed decoder and see if it could decode a frame */
404 while (avpkt.size > 0) {
405 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
407 fprintf(stderr, "Error while decoding frame %d\n", frame);
411 printf("saving frame %3d\n", frame);
414 /* the picture is allocated by the decoder. no need to
416 snprintf(buf, sizeof(buf), outfilename, frame);
417 pgm_save(picture->data[0], picture->linesize[0],
418 c->width, c->height, buf);
426 /* some codecs, such as MPEG, transmit the I and P frame with a
427 latency of one frame. You must do the following to have a
428 chance to get the last frame of the video */
431 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
433 printf("saving last frame %3d\n", frame);
436 /* the picture is allocated by the decoder. no need to
438 snprintf(buf, sizeof(buf), outfilename, frame);
439 pgm_save(picture->data[0], picture->linesize[0],
440 c->width, c->height, buf);
452 int main(int argc, char **argv)
454 const char *filename;
456 /* must be called before using avcodec lib */
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.h264", CODEC_ID_H264);
467 video_encode_example("/tmp/test.mpg", CODEC_ID_MPEG1VIDEO);
468 filename = "/tmp/test.mpg";
473 // audio_decode_example("/tmp/test.sw", filename);
474 video_decode_example("/tmp/test%d.pgm", filename);