examples/decoding_encoding: fix misc typos in the usage text
[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     if (!c) {
125         fprintf(stderr, "Could not allocate audio codec context\n");
126         exit(1);
127     }
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 sample format %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 = avcodec_alloc_frame();
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
213     /* get the delayed frames */
214     for (got_output = 1; got_output; i++) {
215         ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
216         if (ret < 0) {
217             fprintf(stderr, "Error encoding frame\n");
218             exit(1);
219         }
220
221         if (got_output) {
222             fwrite(pkt.data, 1, pkt.size, f);
223             av_free_packet(&pkt);
224         }
225     }
226     fclose(f);
227
228     av_freep(&samples);
229     avcodec_free_frame(&frame);
230     avcodec_close(c);
231     av_free(c);
232 }
233
234 /*
235  * Audio decoding.
236  */
237 static void audio_decode_example(const char *outfilename, const char *filename)
238 {
239     AVCodec *codec;
240     AVCodecContext *c= NULL;
241     int len;
242     FILE *f, *outfile;
243     uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
244     AVPacket avpkt;
245     AVFrame *decoded_frame = NULL;
246
247     av_init_packet(&avpkt);
248
249     printf("Decode audio file %s to %s\n", filename, outfilename);
250
251     /* find the mpeg audio decoder */
252     codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
253     if (!codec) {
254         fprintf(stderr, "Codec not found\n");
255         exit(1);
256     }
257
258     c = avcodec_alloc_context3(codec);
259     if (!c) {
260         fprintf(stderr, "Could not allocate audio codec context\n");
261         exit(1);
262     }
263
264     /* open it */
265     if (avcodec_open2(c, codec, NULL) < 0) {
266         fprintf(stderr, "Could not open codec\n");
267         exit(1);
268     }
269
270     f = fopen(filename, "rb");
271     if (!f) {
272         fprintf(stderr, "Could not open %s\n", filename);
273         exit(1);
274     }
275     outfile = fopen(outfilename, "wb");
276     if (!outfile) {
277         av_free(c);
278         exit(1);
279     }
280
281     /* decode until eof */
282     avpkt.data = inbuf;
283     avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
284
285     while (avpkt.size > 0) {
286         int got_frame = 0;
287
288         if (!decoded_frame) {
289             if (!(decoded_frame = avcodec_alloc_frame())) {
290                 fprintf(stderr, "Could not allocate audio frame\n");
291                 exit(1);
292             }
293         } else
294             avcodec_get_frame_defaults(decoded_frame);
295
296         len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
297         if (len < 0) {
298             fprintf(stderr, "Error while decoding\n");
299             exit(1);
300         }
301         if (got_frame) {
302             /* if a frame has been decoded, output it */
303             int data_size = av_samples_get_buffer_size(NULL, c->channels,
304                                                        decoded_frame->nb_samples,
305                                                        c->sample_fmt, 1);
306             fwrite(decoded_frame->data[0], 1, data_size, outfile);
307         }
308         avpkt.size -= len;
309         avpkt.data += len;
310         avpkt.dts =
311         avpkt.pts = AV_NOPTS_VALUE;
312         if (avpkt.size < AUDIO_REFILL_THRESH) {
313             /* Refill the input buffer, to avoid trying to decode
314              * incomplete frames. Instead of this, one could also use
315              * a parser, or use a proper container format through
316              * libavformat. */
317             memmove(inbuf, avpkt.data, avpkt.size);
318             avpkt.data = inbuf;
319             len = fread(avpkt.data + avpkt.size, 1,
320                         AUDIO_INBUF_SIZE - avpkt.size, f);
321             if (len > 0)
322                 avpkt.size += len;
323         }
324     }
325
326     fclose(outfile);
327     fclose(f);
328
329     avcodec_close(c);
330     av_free(c);
331     avcodec_free_frame(&decoded_frame);
332 }
333
334 /*
335  * Video encoding example
336  */
337 static void video_encode_example(const char *filename, int codec_id)
338 {
339     AVCodec *codec;
340     AVCodecContext *c= NULL;
341     int i, ret, x, y, got_output;
342     FILE *f;
343     AVFrame *frame;
344     AVPacket pkt;
345     uint8_t endcode[] = { 0, 0, 1, 0xb7 };
346
347     printf("Encode video file %s\n", filename);
348
349     /* find the mpeg1 video encoder */
350     codec = avcodec_find_encoder(codec_id);
351     if (!codec) {
352         fprintf(stderr, "Codec not found\n");
353         exit(1);
354     }
355
356     c = avcodec_alloc_context3(codec);
357     if (!c) {
358         fprintf(stderr, "Could not allocate video codec context\n");
359         exit(1);
360     }
361
362     /* put sample parameters */
363     c->bit_rate = 400000;
364     /* resolution must be a multiple of two */
365     c->width = 352;
366     c->height = 288;
367     /* frames per second */
368     c->time_base= (AVRational){1,25};
369     c->gop_size = 10; /* emit one intra frame every ten frames */
370     c->max_b_frames=1;
371     c->pix_fmt = AV_PIX_FMT_YUV420P;
372
373     if(codec_id == AV_CODEC_ID_H264)
374         av_opt_set(c->priv_data, "preset", "slow", 0);
375
376     /* open it */
377     if (avcodec_open2(c, codec, NULL) < 0) {
378         fprintf(stderr, "Could not open codec\n");
379         exit(1);
380     }
381
382     f = fopen(filename, "wb");
383     if (!f) {
384         fprintf(stderr, "Could not open %s\n", filename);
385         exit(1);
386     }
387
388     frame = avcodec_alloc_frame();
389     if (!frame) {
390         fprintf(stderr, "Could not allocate video frame\n");
391         exit(1);
392     }
393     frame->format = c->pix_fmt;
394     frame->width  = c->width;
395     frame->height = c->height;
396
397     /* the image can be allocated by any means and av_image_alloc() is
398      * just the most convenient way if av_malloc() is to be used */
399     ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
400                          c->pix_fmt, 32);
401     if (ret < 0) {
402         fprintf(stderr, "Could not allocate raw picture buffer\n");
403         exit(1);
404     }
405
406     /* encode 1 second of video */
407     for(i=0;i<25;i++) {
408         av_init_packet(&pkt);
409         pkt.data = NULL;    // packet data will be allocated by the encoder
410         pkt.size = 0;
411
412         fflush(stdout);
413         /* prepare a dummy image */
414         /* Y */
415         for(y=0;y<c->height;y++) {
416             for(x=0;x<c->width;x++) {
417                 frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
418             }
419         }
420
421         /* Cb and Cr */
422         for(y=0;y<c->height/2;y++) {
423             for(x=0;x<c->width/2;x++) {
424                 frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
425                 frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
426             }
427         }
428
429         frame->pts = i;
430
431         /* encode the image */
432         ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
433         if (ret < 0) {
434             fprintf(stderr, "Error encoding frame\n");
435             exit(1);
436         }
437
438         if (got_output) {
439             printf("Write frame %3d (size=%5d)\n", i, pkt.size);
440             fwrite(pkt.data, 1, pkt.size, f);
441             av_free_packet(&pkt);
442         }
443     }
444
445     /* get the delayed frames */
446     for (got_output = 1; got_output; i++) {
447         fflush(stdout);
448
449         ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
450         if (ret < 0) {
451             fprintf(stderr, "Error encoding frame\n");
452             exit(1);
453         }
454
455         if (got_output) {
456             printf("Write frame %3d (size=%5d)\n", i, pkt.size);
457             fwrite(pkt.data, 1, pkt.size, f);
458             av_free_packet(&pkt);
459         }
460     }
461
462     /* add sequence end code to have a real mpeg file */
463     fwrite(endcode, 1, sizeof(endcode), f);
464     fclose(f);
465
466     avcodec_close(c);
467     av_free(c);
468     av_freep(&frame->data[0]);
469     avcodec_free_frame(&frame);
470     printf("\n");
471 }
472
473 /*
474  * Video decoding example
475  */
476
477 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
478                      char *filename)
479 {
480     FILE *f;
481     int i;
482
483     f=fopen(filename,"w");
484     fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
485     for(i=0;i<ysize;i++)
486         fwrite(buf + i * wrap,1,xsize,f);
487     fclose(f);
488 }
489
490 static void video_decode_example(const char *outfilename, const char *filename)
491 {
492     AVCodec *codec;
493     AVCodecContext *c= NULL;
494     int frame, got_picture, len;
495     FILE *f;
496     AVFrame *picture;
497     uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
498     char buf[1024];
499     AVPacket avpkt;
500
501     av_init_packet(&avpkt);
502
503     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
504     memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
505
506     printf("Decode video file %s to %s\n", filename, outfilename);
507
508     /* find the mpeg1 video decoder */
509     codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
510     if (!codec) {
511         fprintf(stderr, "Codec not found\n");
512         exit(1);
513     }
514
515     c = avcodec_alloc_context3(codec);
516     if (!c) {
517         fprintf(stderr, "Could not allocate video codec context\n");
518         exit(1);
519     }
520
521     if(codec->capabilities&CODEC_CAP_TRUNCATED)
522         c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
523
524     /* For some codecs, such as msmpeg4 and mpeg4, width and height
525        MUST be initialized there because this information is not
526        available in the bitstream. */
527
528     /* open it */
529     if (avcodec_open2(c, codec, NULL) < 0) {
530         fprintf(stderr, "Could not open codec\n");
531         exit(1);
532     }
533
534     f = fopen(filename, "rb");
535     if (!f) {
536         fprintf(stderr, "Could not open %s\n", filename);
537         exit(1);
538     }
539
540     picture = avcodec_alloc_frame();
541     if (!picture) {
542         fprintf(stderr, "Could not allocate video frame\n");
543         exit(1);
544     }
545
546     frame = 0;
547     for(;;) {
548         avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
549         if (avpkt.size == 0)
550             break;
551
552         /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
553            and this is the only method to use them because you cannot
554            know the compressed data size before analysing it.
555
556            BUT some other codecs (msmpeg4, mpeg4) are inherently frame
557            based, so you must call them with all the data for one
558            frame exactly. You must also initialize 'width' and
559            'height' before initializing them. */
560
561         /* NOTE2: some codecs allow the raw parameters (frame size,
562            sample rate) to be changed at any frame. We handle this, so
563            you should also take care of it */
564
565         /* here, we use a stream based decoder (mpeg1video), so we
566            feed decoder and see if it could decode a frame */
567         avpkt.data = inbuf;
568         while (avpkt.size > 0) {
569             len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
570             if (len < 0) {
571                 fprintf(stderr, "Error while decoding frame %d\n", frame);
572                 exit(1);
573             }
574             if (got_picture) {
575                 printf("Saving frame %3d\n", frame);
576                 fflush(stdout);
577
578                 /* the picture is allocated by the decoder. no need to
579                    free it */
580                 snprintf(buf, sizeof(buf), outfilename, frame);
581                 pgm_save(picture->data[0], picture->linesize[0],
582                          c->width, c->height, buf);
583                 frame++;
584             }
585             avpkt.size -= len;
586             avpkt.data += len;
587         }
588     }
589
590     /* some codecs, such as MPEG, transmit the I and P frame with a
591        latency of one frame. You must do the following to have a
592        chance to get the last frame of the video */
593     avpkt.data = NULL;
594     avpkt.size = 0;
595     len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
596     if (got_picture) {
597         printf("Saving last frame %3d\n", frame);
598         fflush(stdout);
599
600         /* the picture is allocated by the decoder. no need to
601            free it */
602         snprintf(buf, sizeof(buf), outfilename, frame);
603         pgm_save(picture->data[0], picture->linesize[0],
604                  c->width, c->height, buf);
605         frame++;
606     }
607
608     fclose(f);
609
610     avcodec_close(c);
611     av_free(c);
612     avcodec_free_frame(&picture);
613     printf("\n");
614 }
615
616 int main(int argc, char **argv)
617 {
618     const char *output_type;
619
620     /* register all the codecs */
621     avcodec_register_all();
622
623     if (argc < 2) {
624         printf("usage: %s output_type\n"
625                "API example program to decode/encode a media stream with libavcodec.\n"
626                "This program generates a synthetic stream and encodes it to a file\n"
627                "named test.h264, test.mp2 or test.mpg depending on output_type.\n"
628                "The encoded stream is then decoded and written to a raw data output.\n"
629                "output_type must be choosen between 'h264', 'mp2', 'mpg'.\n",
630                argv[0]);
631         return 1;
632     }
633     output_type = argv[1];
634
635     if (!strcmp(output_type, "h264")) {
636         video_encode_example("test.h264", AV_CODEC_ID_H264);
637     } else if (!strcmp(output_type, "mp2")) {
638         audio_encode_example("test.mp2");
639         audio_decode_example("test.sw", "test.mp2");
640     } else if (!strcmp(output_type, "mpg")) {
641         video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);
642         video_decode_example("test%02d.pgm", "test.mpg");
643     } else {
644         fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",
645                 output_type);
646         return 1;
647     }
648
649     return 0;
650 }