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