cosmetics: Fix spelling mistakes
[ffmpeg.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, MPEG-4, 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_packet_unref(&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 mpeg1video 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_packet_unref(&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_packet_unref(&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 MPEG-1 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 }