7a4a862c71ea6af5ffdac382190990daf706bc3d
[ffmpeg.git] / libavcodec / apiexample.c
1 /**
2  * @file apiexample.c
3  * avcodec API use example.
4  *
5  * Note that this library only handles codecs (mpeg, mpeg4, etc...),
6  * not file formats (avi, vob, etc...). See library 'libavformat' for the
7  * format handling 
8  */
9
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <string.h>
13 #include <math.h>
14
15 #ifdef HAVE_AV_CONFIG_H
16 #undef HAVE_AV_CONFIG_H
17 #endif
18
19 #include "avcodec.h"
20
21 #define INBUF_SIZE 4096
22
23 /*
24  * Audio encoding example 
25  */
26 void audio_encode_example(const char *filename)
27 {
28     AVCodec *codec;
29     AVCodecContext *c= NULL;
30     int frame_size, i, j, out_size, outbuf_size;
31     FILE *f;
32     short *samples;
33     float t, tincr;
34     uint8_t *outbuf;
35
36     printf("Audio encoding\n");
37
38     /* find the MP2 encoder */
39     codec = avcodec_find_encoder(CODEC_ID_MP2);
40     if (!codec) {
41         fprintf(stderr, "codec not found\n");
42         exit(1);
43     }
44
45     c= avcodec_alloc_context();
46     
47     /* put sample parameters */
48     c->bit_rate = 64000;
49     c->sample_rate = 44100;
50     c->channels = 2;
51
52     /* open it */
53     if (avcodec_open(c, codec) < 0) {
54         fprintf(stderr, "could not open codec\n");
55         exit(1);
56     }
57     
58     /* the codec gives us the frame size, in samples */
59     frame_size = c->frame_size;
60     samples = malloc(frame_size * 2 * c->channels);
61     outbuf_size = 10000;
62     outbuf = malloc(outbuf_size);
63
64     f = fopen(filename, "wb");
65     if (!f) {
66         fprintf(stderr, "could not open %s\n", filename);
67         exit(1);
68     }
69         
70     /* encode a single tone sound */
71     t = 0;
72     tincr = 2 * M_PI * 440.0 / c->sample_rate;
73     for(i=0;i<200;i++) {
74         for(j=0;j<frame_size;j++) {
75             samples[2*j] = (int)(sin(t) * 10000);
76             samples[2*j+1] = samples[2*j];
77             t += tincr;
78         }
79         /* encode the samples */
80         out_size = avcodec_encode_audio(c, outbuf, outbuf_size, samples);
81         fwrite(outbuf, 1, out_size, f);
82     }
83     fclose(f);
84     free(outbuf);
85     free(samples);
86
87     avcodec_close(c);
88     av_free(c);
89 }
90
91 /*
92  * Audio decoding. 
93  */
94 void audio_decode_example(const char *outfilename, const char *filename)
95 {
96     AVCodec *codec;
97     AVCodecContext *c= NULL;
98     int out_size, size, len;
99     FILE *f, *outfile;
100     uint8_t *outbuf;
101     uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE], *inbuf_ptr;
102
103     printf("Audio decoding\n");
104     
105     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
106     memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
107
108     /* find the mpeg audio decoder */
109     codec = avcodec_find_decoder(CODEC_ID_MP2);
110     if (!codec) {
111         fprintf(stderr, "codec not found\n");
112         exit(1);
113     }
114
115     c= avcodec_alloc_context();
116
117     /* open it */
118     if (avcodec_open(c, codec) < 0) {
119         fprintf(stderr, "could not open codec\n");
120         exit(1);
121     }
122     
123     outbuf = malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
124
125     f = fopen(filename, "rb");
126     if (!f) {
127         fprintf(stderr, "could not open %s\n", filename);
128         exit(1);
129     }
130     outfile = fopen(outfilename, "wb");
131     if (!outfile) {
132         av_free(c);
133         exit(1);
134     }
135         
136     /* decode until eof */
137     inbuf_ptr = inbuf;
138     for(;;) {
139         size = fread(inbuf, 1, INBUF_SIZE, f);
140         if (size == 0)
141             break;
142
143         inbuf_ptr = inbuf;
144         while (size > 0) {
145             len = avcodec_decode_audio(c, (short *)outbuf, &out_size, 
146                                        inbuf_ptr, size);
147             if (len < 0) {
148                 fprintf(stderr, "Error while decoding\n");
149                 exit(1);
150             }
151             if (out_size > 0) {
152                 /* if a frame has been decoded, output it */
153                 fwrite(outbuf, 1, out_size, outfile);
154             }
155             size -= len;
156             inbuf_ptr += len;
157         }
158     }
159
160     fclose(outfile);
161     fclose(f);
162     free(outbuf);
163
164     avcodec_close(c);
165     av_free(c);
166 }
167
168 /*
169  * Video encoding example 
170  */
171 void video_encode_example(const char *filename)
172 {
173     AVCodec *codec;
174     AVCodecContext *c= NULL;
175     int i, out_size, size, x, y, outbuf_size;
176     FILE *f;
177     AVFrame *picture;
178     uint8_t *outbuf, *picture_buf;
179
180     printf("Video encoding\n");
181
182     /* find the mpeg1 video encoder */
183     codec = avcodec_find_encoder(CODEC_ID_MPEG1VIDEO);
184     if (!codec) {
185         fprintf(stderr, "codec not found\n");
186         exit(1);
187     }
188
189     c= avcodec_alloc_context();
190     picture= avcodec_alloc_frame();
191     
192     /* put sample parameters */
193     c->bit_rate = 400000;
194     /* resolution must be a multiple of two */
195     c->width = 352;  
196     c->height = 288;
197     /* frames per second */
198     c->frame_rate = 25;  
199     c->frame_rate_base= 1;
200     c->gop_size = 10; /* emit one intra frame every ten frames */
201     c->max_b_frames=1;
202
203     /* open it */
204     if (avcodec_open(c, codec) < 0) {
205         fprintf(stderr, "could not open codec\n");
206         exit(1);
207     }
208     
209     /* the codec gives us the frame size, in samples */
210
211     f = fopen(filename, "wb");
212     if (!f) {
213         fprintf(stderr, "could not open %s\n", filename);
214         exit(1);
215     }
216     
217     /* alloc image and output buffer */
218     outbuf_size = 100000;
219     outbuf = malloc(outbuf_size);
220     size = c->width * c->height;
221     picture_buf = malloc((size * 3) / 2); /* size for YUV 420 */
222     
223     picture->data[0] = picture_buf;
224     picture->data[1] = picture->data[0] + size;
225     picture->data[2] = picture->data[1] + size / 4;
226     picture->linesize[0] = c->width;
227     picture->linesize[1] = c->width / 2;
228     picture->linesize[2] = c->width / 2;
229
230     /* encode 1 second of video */
231     for(i=0;i<25;i++) {
232         fflush(stdout);
233         /* prepare a dummy image */
234         /* Y */
235         for(y=0;y<c->height;y++) {
236             for(x=0;x<c->width;x++) {
237                 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
238             }
239         }
240
241         /* Cb and Cr */
242         for(y=0;y<c->height/2;y++) {
243             for(x=0;x<c->width/2;x++) {
244                 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
245                 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
246             }
247         }
248
249         /* encode the image */
250         out_size = avcodec_encode_video(c, outbuf, outbuf_size, picture);
251         printf("encoding frame %3d (size=%5d)\n", i, out_size);
252         fwrite(outbuf, 1, out_size, f);
253     }
254
255     /* get the delayed frames */
256     for(; out_size; i++) {
257         fflush(stdout);
258         
259         out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
260         printf("write frame %3d (size=%5d)\n", i, out_size);
261         fwrite(outbuf, 1, out_size, f);
262     }
263
264     /* add sequence end code to have a real mpeg file */
265     outbuf[0] = 0x00;
266     outbuf[1] = 0x00;
267     outbuf[2] = 0x01;
268     outbuf[3] = 0xb7;
269     fwrite(outbuf, 1, 4, f);
270     fclose(f);
271     free(picture_buf);
272     free(outbuf);
273
274     avcodec_close(c);
275     av_free(c);
276     av_free(picture);
277     printf("\n");
278 }
279
280 /*
281  * Video decoding example 
282  */
283
284 void pgm_save(unsigned char *buf,int wrap, int xsize,int ysize,char *filename) 
285 {
286     FILE *f;
287     int i;
288
289     f=fopen(filename,"w");
290     fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
291     for(i=0;i<ysize;i++)
292         fwrite(buf + i * wrap,1,xsize,f);
293     fclose(f);
294 }
295
296 void video_decode_example(const char *outfilename, const char *filename)
297 {
298     AVCodec *codec;
299     AVCodecContext *c= NULL;
300     int frame, size, got_picture, len;
301     FILE *f;
302     AVFrame *picture;
303     uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE], *inbuf_ptr;
304     char buf[1024];
305
306     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
307     memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
308
309     printf("Video decoding\n");
310
311     /* find the mpeg1 video decoder */
312     codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO);
313     if (!codec) {
314         fprintf(stderr, "codec not found\n");
315         exit(1);
316     }
317
318     c= avcodec_alloc_context();
319     picture= avcodec_alloc_frame();
320
321     if(codec->capabilities&CODEC_CAP_TRUNCATED)
322         c->flags|= CODEC_FLAG_TRUNCATED; /* we dont send complete frames */
323
324     /* for some codecs, such as msmpeg4 and mpeg4, width and height
325        MUST be initialized there because these info are not available
326        in the bitstream */
327
328     /* open it */
329     if (avcodec_open(c, codec) < 0) {
330         fprintf(stderr, "could not open codec\n");
331         exit(1);
332     }
333     
334     /* the codec gives us the frame size, in samples */
335
336     f = fopen(filename, "rb");
337     if (!f) {
338         fprintf(stderr, "could not open %s\n", filename);
339         exit(1);
340     }
341     
342     frame = 0;
343     for(;;) {
344         size = fread(inbuf, 1, INBUF_SIZE, f);
345         if (size == 0)
346             break;
347
348         /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
349            and this is the only method to use them because you cannot
350            know the compressed data size before analysing it. 
351
352            BUT some other codecs (msmpeg4, mpeg4) are inherently frame
353            based, so you must call them with all the data for one
354            frame exactly. You must also initialize 'width' and
355            'height' before initializing them. */
356
357         /* NOTE2: some codecs allow the raw parameters (frame size,
358            sample rate) to be changed at any frame. We handle this, so
359            you should also take care of it */
360
361         /* here, we use a stream based decoder (mpeg1video), so we
362            feed decoder and see if it could decode a frame */
363         inbuf_ptr = inbuf;
364         while (size > 0) {
365             len = avcodec_decode_video(c, picture, &got_picture, 
366                                        inbuf_ptr, size);
367             if (len < 0) {
368                 fprintf(stderr, "Error while decoding frame %d\n", frame);
369                 exit(1);
370             }
371             if (got_picture) {
372                 printf("saving frame %3d\n", frame);
373                 fflush(stdout);
374
375                 /* the picture is allocated by the decoder. no need to
376                    free it */
377                 snprintf(buf, sizeof(buf), outfilename, frame);
378                 pgm_save(picture->data[0], picture->linesize[0], 
379                          c->width, c->height, buf);
380                 frame++;
381             }
382             size -= len;
383             inbuf_ptr += len;
384         }
385     }
386
387     /* some codecs, such as MPEG, transmit the I and P frame with a
388        latency of one frame. You must do the following to have a
389        chance to get the last frame of the video */
390     len = avcodec_decode_video(c, picture, &got_picture, 
391                                NULL, 0);
392     if (got_picture) {
393         printf("saving last frame %3d\n", frame);
394         fflush(stdout);
395         
396         /* the picture is allocated by the decoder. no need to
397            free it */
398         snprintf(buf, sizeof(buf), outfilename, frame);
399         pgm_save(picture->data[0], picture->linesize[0], 
400                  c->width, c->height, buf);
401         frame++;
402     }
403         
404     fclose(f);
405
406     avcodec_close(c);
407     av_free(c);
408     av_free(picture);
409     printf("\n");
410 }
411
412 // simple example how the options could be used
413 int options_example(int argc, char* argv[])
414 {
415     AVCodec* codec = avcodec_find_encoder_by_name((argc > 1) ? argv[2] : "mpeg4");
416     const AVOption* c;
417     AVCodecContext* avctx;
418 #define DEF_SIZE 5000
419     char* def = av_malloc(DEF_SIZE);
420     const char* col = "";
421     int i = 0;
422
423     if (!codec)
424         return -1;
425     c = codec->options;
426     avctx = avcodec_alloc_context();
427     *def = 0;
428
429     if (c) {
430         const AVOption *stack[FF_OPT_MAX_DEPTH];
431         int depth = 0;
432         for (;;) {
433             if (!c->name) {
434                 if (c->help) {
435                     stack[depth++] = c;
436                     c = (const AVOption*)c->help;
437                 } else {
438                     if (depth == 0)
439                         break; // finished
440                     c = stack[--depth];
441                     c++;
442                 }
443             } else {
444                 int t = c->type & FF_OPT_TYPE_MASK;
445                 printf("Config   %s  %s\n",
446                        t == FF_OPT_TYPE_BOOL ? "bool   " :
447                        t == FF_OPT_TYPE_DOUBLE ? "double  " :
448                        t == FF_OPT_TYPE_INT ? "integer" :
449                        t == FF_OPT_TYPE_STRING ? "string " :
450                        "unknown??", c->name);
451                 switch (t) {
452                 case FF_OPT_TYPE_BOOL:
453                     i += snprintf(def + i, DEF_SIZE-i, "%s%s=%s",
454                                  col, c->name,
455                                  c->defval != 0. ? "on" : "off");
456                     break;
457                 case FF_OPT_TYPE_DOUBLE:
458                     i += snprintf(def + i, DEF_SIZE-i, "%s%s=%f",
459                                  col, c->name, c->defval);
460                     break;
461                 case FF_OPT_TYPE_INT:
462                     i += snprintf(def + i, DEF_SIZE-i, "%s%s=%d",
463                                  col, c->name, (int) c->defval);
464                     break;
465                 case FF_OPT_TYPE_STRING:
466                     if (c->defstr) {
467                         char* d = av_strdup(c->defstr);
468                         char* f = strchr(d, ',');
469                         if (f)
470                             *f = 0;
471                         i += snprintf(def + i, DEF_SIZE-i, "%s%s=%s",
472                                      col, c->name, d);
473                         av_free(d);
474                     }
475                     break;
476                 }
477                 col = ":";
478                 c++;
479             }
480         }
481     }
482     printf("Default Options: %s\n", def);
483     av_free(def);
484     return 0;
485 }
486
487
488 int main(int argc, char **argv)
489 {
490     const char *filename;
491
492     /* must be called before using avcodec lib */
493     avcodec_init();
494
495     /* register all the codecs (you can also register only the codec
496        you wish to have smaller code */
497     avcodec_register_all();
498
499 #ifdef OPT_TEST
500     options_example(argc, argv);
501 #else
502     if (argc <= 1) {
503         audio_encode_example("/tmp/test.mp2");
504         audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
505
506         video_encode_example("/tmp/test.mpg");
507         filename = "/tmp/test.mpg";
508     } else {
509         filename = argv[1];
510     }
511
512     //    audio_decode_example("/tmp/test.sw", filename);
513     video_decode_example("/tmp/test%d.pgm", filename);
514 #endif
515
516     return 0;
517 }