lavc: Consistently prefix input buffer defines
[libav.git] / doc / examples / avcodec.c
1 /*
2 * copyright (c) 2001 Fabrice Bellard
3 *
4 * This file is part of Libav.
5 *
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.
10 *
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.
15 *
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
19 */
20
21 /**
22 * @file
23 * libavcodec API use example.
24 *
25 * @example avcodec.c
26 * Note that this library only handles codecs (mpeg, mpeg4, etc...),
27 * not file formats (avi, vob, etc...). See library 'libavformat' for the
28 * format handling
29 */
30
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <string.h>
34
35 #ifdef HAVE_AV_CONFIG_H
36 #undef HAVE_AV_CONFIG_H
37 #endif
38
39 #include "libavcodec/avcodec.h"
40 #include "libavutil/channel_layout.h"
41 #include "libavutil/common.h"
42 #include "libavutil/imgutils.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/samplefmt.h"
45
46 #define INBUF_SIZE 4096
47 #define AUDIO_INBUF_SIZE 20480
48 #define AUDIO_REFILL_THRESH 4096
49
50 /* check that a given sample format is supported by the encoder */
51 static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
52 {
53 const enum AVSampleFormat *p = codec->sample_fmts;
54
55 while (*p != AV_SAMPLE_FMT_NONE) {
56 if (*p == sample_fmt)
57 return 1;
58 p++;
59 }
60 return 0;
61 }
62
63 /* just pick the highest supported samplerate */
64 static int select_sample_rate(AVCodec *codec)
65 {
66 const int *p;
67 int best_samplerate = 0;
68
69 if (!codec->supported_samplerates)
70 return 44100;
71
72 p = codec->supported_samplerates;
73 while (*p) {
74 best_samplerate = FFMAX(*p, best_samplerate);
75 p++;
76 }
77 return best_samplerate;
78 }
79
80 /* select layout with the highest channel count */
81 static int select_channel_layout(AVCodec *codec)
82 {
83 const uint64_t *p;
84 uint64_t best_ch_layout = 0;
85 int best_nb_channels = 0;
86
87 if (!codec->channel_layouts)
88 return AV_CH_LAYOUT_STEREO;
89
90 p = codec->channel_layouts;
91 while (*p) {
92 int nb_channels = av_get_channel_layout_nb_channels(*p);
93
94 if (nb_channels > best_nb_channels) {
95 best_ch_layout = *p;
96 best_nb_channels = nb_channels;
97 }
98 p++;
99 }
100 return best_ch_layout;
101 }
102
103 /*
104 * Audio encoding example
105 */
106 static void audio_encode_example(const char *filename)
107 {
108 AVCodec *codec;
109 AVCodecContext *c= NULL;
110 AVFrame *frame;
111 AVPacket pkt;
112 int i, j, k, ret, got_output;
113 int buffer_size;
114 FILE *f;
115 uint16_t *samples;
116 float t, tincr;
117
118 printf("Audio encoding\n");
119
120 /* find the MP2 encoder */
121 codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
122 if (!codec) {
123 fprintf(stderr, "codec not found\n");
124 exit(1);
125 }
126
127 c = avcodec_alloc_context3(codec);
128
129 /* put sample parameters */
130 c->bit_rate = 64000;
131
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));
137 exit(1);
138 }
139
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);
144
145 /* open it */
146 if (avcodec_open2(c, codec, NULL) < 0) {
147 fprintf(stderr, "could not open codec\n");
148 exit(1);
149 }
150
151 f = fopen(filename, "wb");
152 if (!f) {
153 fprintf(stderr, "could not open %s\n", filename);
154 exit(1);
155 }
156
157 /* frame containing input raw audio */
158 frame = av_frame_alloc();
159 if (!frame) {
160 fprintf(stderr, "could not allocate audio frame\n");
161 exit(1);
162 }
163
164 frame->nb_samples = c->frame_size;
165 frame->format = c->sample_fmt;
166 frame->channel_layout = c->channel_layout;
167
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,
171 c->sample_fmt, 0);
172 samples = av_malloc(buffer_size);
173 if (!samples) {
174 fprintf(stderr, "could not allocate %d bytes for samples buffer\n",
175 buffer_size);
176 exit(1);
177 }
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);
181 if (ret < 0) {
182 fprintf(stderr, "could not setup audio frame\n");
183 exit(1);
184 }
185
186 /* encode a single tone sound */
187 t = 0;
188 tincr = 2 * M_PI * 440.0 / c->sample_rate;
189 for(i=0;i<200;i++) {
190 av_init_packet(&pkt);
191 pkt.data = NULL; // packet data will be allocated by the encoder
192 pkt.size = 0;
193
194 for (j = 0; j < c->frame_size; j++) {
195 samples[2*j] = (int)(sin(t) * 10000);
196
197 for (k = 1; k < c->channels; k++)
198 samples[2*j + k] = samples[2*j];
199 t += tincr;
200 }
201 /* encode the samples */
202 ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
203 if (ret < 0) {
204 fprintf(stderr, "error encoding audio frame\n");
205 exit(1);
206 }
207 if (got_output) {
208 fwrite(pkt.data, 1, pkt.size, f);
209 av_free_packet(&pkt);
210 }
211 }
212 fclose(f);
213
214 av_freep(&samples);
215 av_frame_free(&frame);
216 avcodec_close(c);
217 av_free(c);
218 }
219
220 /*
221 * Audio decoding.
222 */
223 static void audio_decode_example(const char *outfilename, const char *filename)
224 {
225 AVCodec *codec;
226 AVCodecContext *c= NULL;
227 int len;
228 FILE *f, *outfile;
229 uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
230 AVPacket avpkt;
231 AVFrame *decoded_frame = NULL;
232
233 av_init_packet(&avpkt);
234
235 printf("Audio decoding\n");
236
237 /* find the mpeg audio decoder */
238 codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
239 if (!codec) {
240 fprintf(stderr, "codec not found\n");
241 exit(1);
242 }
243
244 c = avcodec_alloc_context3(codec);
245
246 /* open it */
247 if (avcodec_open2(c, codec, NULL) < 0) {
248 fprintf(stderr, "could not open codec\n");
249 exit(1);
250 }
251
252 f = fopen(filename, "rb");
253 if (!f) {
254 fprintf(stderr, "could not open %s\n", filename);
255 exit(1);
256 }
257 outfile = fopen(outfilename, "wb");
258 if (!outfile) {
259 av_free(c);
260 exit(1);
261 }
262
263 /* decode until eof */
264 avpkt.data = inbuf;
265 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
266
267 while (avpkt.size > 0) {
268 int got_frame = 0;
269
270 if (!decoded_frame) {
271 if (!(decoded_frame = av_frame_alloc())) {
272 fprintf(stderr, "out of memory\n");
273 exit(1);
274 }
275 }
276
277 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
278 if (len < 0) {
279 fprintf(stderr, "Error while decoding\n");
280 exit(1);
281 }
282 if (got_frame) {
283 /* if a frame has been decoded, output it */
284 int data_size = av_samples_get_buffer_size(NULL, c->channels,
285 decoded_frame->nb_samples,
286 c->sample_fmt, 1);
287 fwrite(decoded_frame->data[0], 1, data_size, outfile);
288 }
289 avpkt.size -= len;
290 avpkt.data += len;
291 if (avpkt.size < AUDIO_REFILL_THRESH) {
292 /* Refill the input buffer, to avoid trying to decode
293 * incomplete frames. Instead of this, one could also use
294 * a parser, or use a proper container format through
295 * libavformat. */
296 memmove(inbuf, avpkt.data, avpkt.size);
297 avpkt.data = inbuf;
298 len = fread(avpkt.data + avpkt.size, 1,
299 AUDIO_INBUF_SIZE - avpkt.size, f);
300 if (len > 0)
301 avpkt.size += len;
302 }
303 }
304
305 fclose(outfile);
306 fclose(f);
307
308 avcodec_close(c);
309 av_free(c);
310 av_frame_free(&decoded_frame);
311 }
312
313 /*
314 * Video encoding example
315 */
316 static void video_encode_example(const char *filename)
317 {
318 AVCodec *codec;
319 AVCodecContext *c= NULL;
320 int i, ret, x, y, got_output;
321 FILE *f;
322 AVFrame *picture;
323 AVPacket pkt;
324 uint8_t endcode[] = { 0, 0, 1, 0xb7 };
325
326 printf("Video encoding\n");
327
328 /* find the mpeg1 video encoder */
329 codec = avcodec_find_encoder(AV_CODEC_ID_MPEG1VIDEO);
330 if (!codec) {
331 fprintf(stderr, "codec not found\n");
332 exit(1);
333 }
334
335 c = avcodec_alloc_context3(codec);
336 picture = av_frame_alloc();
337
338 /* put sample parameters */
339 c->bit_rate = 400000;
340 /* resolution must be a multiple of two */
341 c->width = 352;
342 c->height = 288;
343 /* frames per second */
344 c->time_base= (AVRational){1,25};
345 c->gop_size = 10; /* emit one intra frame every ten frames */
346 c->max_b_frames=1;
347 c->pix_fmt = AV_PIX_FMT_YUV420P;
348
349 /* open it */
350 if (avcodec_open2(c, codec, NULL) < 0) {
351 fprintf(stderr, "could not open codec\n");
352 exit(1);
353 }
354
355 f = fopen(filename, "wb");
356 if (!f) {
357 fprintf(stderr, "could not open %s\n", filename);
358 exit(1);
359 }
360
361 ret = av_image_alloc(picture->data, picture->linesize, c->width, c->height,
362 c->pix_fmt, 32);
363 if (ret < 0) {
364 fprintf(stderr, "could not alloc raw picture buffer\n");
365 exit(1);
366 }
367 picture->format = c->pix_fmt;
368 picture->width = c->width;
369 picture->height = c->height;
370
371 /* encode 1 second of video */
372 for(i=0;i<25;i++) {
373 av_init_packet(&pkt);
374 pkt.data = NULL; // packet data will be allocated by the encoder
375 pkt.size = 0;
376
377 fflush(stdout);
378 /* prepare a dummy image */
379 /* Y */
380 for(y=0;y<c->height;y++) {
381 for(x=0;x<c->width;x++) {
382 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
383 }
384 }
385
386 /* Cb and Cr */
387 for(y=0;y<c->height/2;y++) {
388 for(x=0;x<c->width/2;x++) {
389 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
390 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
391 }
392 }
393
394 picture->pts = i;
395
396 /* encode the image */
397 ret = avcodec_encode_video2(c, &pkt, picture, &got_output);
398 if (ret < 0) {
399 fprintf(stderr, "error encoding frame\n");
400 exit(1);
401 }
402
403 if (got_output) {
404 printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
405 fwrite(pkt.data, 1, pkt.size, f);
406 av_free_packet(&pkt);
407 }
408 }
409
410 /* get the delayed frames */
411 for (got_output = 1; got_output; i++) {
412 fflush(stdout);
413
414 ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
415 if (ret < 0) {
416 fprintf(stderr, "error encoding frame\n");
417 exit(1);
418 }
419
420 if (got_output) {
421 printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
422 fwrite(pkt.data, 1, pkt.size, f);
423 av_free_packet(&pkt);
424 }
425 }
426
427 /* add sequence end code to have a real mpeg file */
428 fwrite(endcode, 1, sizeof(endcode), f);
429 fclose(f);
430
431 avcodec_close(c);
432 av_free(c);
433 av_freep(&picture->data[0]);
434 av_frame_free(&picture);
435 printf("\n");
436 }
437
438 /*
439 * Video decoding example
440 */
441
442 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
443 char *filename)
444 {
445 FILE *f;
446 int i;
447
448 f=fopen(filename,"w");
449 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
450 for(i=0;i<ysize;i++)
451 fwrite(buf + i * wrap,1,xsize,f);
452 fclose(f);
453 }
454
455 static void video_decode_example(const char *outfilename, const char *filename)
456 {
457 AVCodec *codec;
458 AVCodecContext *c= NULL;
459 int frame, got_picture, len;
460 FILE *f;
461 AVFrame *picture;
462 uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
463 char buf[1024];
464 AVPacket avpkt;
465
466 av_init_packet(&avpkt);
467
468 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
469 memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
470
471 printf("Video decoding\n");
472
473 /* find the mpeg1 video decoder */
474 codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
475 if (!codec) {
476 fprintf(stderr, "codec not found\n");
477 exit(1);
478 }
479
480 c = avcodec_alloc_context3(codec);
481 picture = av_frame_alloc();
482
483 if (codec->capabilities & AV_CODEC_CAP_TRUNCATED)
484 c->flags |= AV_CODEC_FLAG_TRUNCATED; // we do not send complete frames
485
486 /* For some codecs, such as msmpeg4 and mpeg4, width and height
487 MUST be initialized there because this information is not
488 available in the bitstream. */
489
490 /* open it */
491 if (avcodec_open2(c, codec, NULL) < 0) {
492 fprintf(stderr, "could not open codec\n");
493 exit(1);
494 }
495
496 /* the codec gives us the frame size, in samples */
497
498 f = fopen(filename, "rb");
499 if (!f) {
500 fprintf(stderr, "could not open %s\n", filename);
501 exit(1);
502 }
503
504 frame = 0;
505 for(;;) {
506 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
507 if (avpkt.size == 0)
508 break;
509
510 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
511 and this is the only method to use them because you cannot
512 know the compressed data size before analysing it.
513
514 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
515 based, so you must call them with all the data for one
516 frame exactly. You must also initialize 'width' and
517 'height' before initializing them. */
518
519 /* NOTE2: some codecs allow the raw parameters (frame size,
520 sample rate) to be changed at any frame. We handle this, so
521 you should also take care of it */
522
523 /* here, we use a stream based decoder (mpeg1video), so we
524 feed decoder and see if it could decode a frame */
525 avpkt.data = inbuf;
526 while (avpkt.size > 0) {
527 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
528 if (len < 0) {
529 fprintf(stderr, "Error while decoding frame %d\n", frame);
530 exit(1);
531 }
532 if (got_picture) {
533 printf("saving frame %3d\n", frame);
534 fflush(stdout);
535
536 /* the picture is allocated by the decoder. no need to
537 free it */
538 snprintf(buf, sizeof(buf), outfilename, frame);
539 pgm_save(picture->data[0], picture->linesize[0],
540 c->width, c->height, buf);
541 frame++;
542 }
543 avpkt.size -= len;
544 avpkt.data += len;
545 }
546 }
547
548 /* some codecs, such as MPEG, transmit the I and P frame with a
549 latency of one frame. You must do the following to have a
550 chance to get the last frame of the video */
551 avpkt.data = NULL;
552 avpkt.size = 0;
553 len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
554 if (got_picture) {
555 printf("saving last frame %3d\n", frame);
556 fflush(stdout);
557
558 /* the picture is allocated by the decoder. no need to
559 free it */
560 snprintf(buf, sizeof(buf), outfilename, frame);
561 pgm_save(picture->data[0], picture->linesize[0],
562 c->width, c->height, buf);
563 frame++;
564 }
565
566 fclose(f);
567
568 avcodec_close(c);
569 av_free(c);
570 av_frame_free(&picture);
571 printf("\n");
572 }
573
574 int main(int argc, char **argv)
575 {
576 const char *filename;
577
578 /* register all the codecs */
579 avcodec_register_all();
580
581 if (argc <= 1) {
582 audio_encode_example("/tmp/test.mp2");
583 audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
584
585 video_encode_example("/tmp/test.mpg");
586 filename = "/tmp/test.mpg";
587 } else {
588 filename = argv[1];
589 }
590
591 // audio_decode_example("/tmp/test.sw", filename);
592 video_decode_example("/tmp/test%d.pgm", filename);
593
594 return 0;
595 }