lavc: make avcodec_alloc_context3 officially public.
[ffmpeg.git] / libavcodec / api-example.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 libavcodec/api-example.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/mathematics.h"
41
42 #define INBUF_SIZE 4096
43 #define AUDIO_INBUF_SIZE 20480
44 #define AUDIO_REFILL_THRESH 4096
45
46 /*
47  * Audio encoding example
48  */
49 static void audio_encode_example(const char *filename)
50 {
51     AVCodec *codec;
52     AVCodecContext *c= NULL;
53     int frame_size, i, j, out_size, outbuf_size;
54     FILE *f;
55     short *samples;
56     float t, tincr;
57     uint8_t *outbuf;
58
59     printf("Audio encoding\n");
60
61     /* find the MP2 encoder */
62     codec = avcodec_find_encoder(CODEC_ID_MP2);
63     if (!codec) {
64         fprintf(stderr, "codec not found\n");
65         exit(1);
66     }
67
68     c = avcodec_alloc_context3(codec);
69
70     /* put sample parameters */
71     c->bit_rate = 64000;
72     c->sample_rate = 44100;
73     c->channels = 2;
74
75     /* open it */
76     if (avcodec_open(c, codec) < 0) {
77         fprintf(stderr, "could not open codec\n");
78         exit(1);
79     }
80
81     /* the codec gives us the frame size, in samples */
82     frame_size = c->frame_size;
83     samples = malloc(frame_size * 2 * c->channels);
84     outbuf_size = 10000;
85     outbuf = malloc(outbuf_size);
86
87     f = fopen(filename, "wb");
88     if (!f) {
89         fprintf(stderr, "could not open %s\n", filename);
90         exit(1);
91     }
92
93     /* encode a single tone sound */
94     t = 0;
95     tincr = 2 * M_PI * 440.0 / c->sample_rate;
96     for(i=0;i<200;i++) {
97         for(j=0;j<frame_size;j++) {
98             samples[2*j] = (int)(sin(t) * 10000);
99             samples[2*j+1] = samples[2*j];
100             t += tincr;
101         }
102         /* encode the samples */
103         out_size = avcodec_encode_audio(c, outbuf, outbuf_size, samples);
104         fwrite(outbuf, 1, out_size, f);
105     }
106     fclose(f);
107     free(outbuf);
108     free(samples);
109
110     avcodec_close(c);
111     av_free(c);
112 }
113
114 /*
115  * Audio decoding.
116  */
117 static void audio_decode_example(const char *outfilename, const char *filename)
118 {
119     AVCodec *codec;
120     AVCodecContext *c= NULL;
121     int out_size, len;
122     FILE *f, *outfile;
123     uint8_t *outbuf;
124     uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
125     AVPacket avpkt;
126
127     av_init_packet(&avpkt);
128
129     printf("Audio decoding\n");
130
131     /* find the mpeg audio decoder */
132     codec = avcodec_find_decoder(CODEC_ID_MP2);
133     if (!codec) {
134         fprintf(stderr, "codec not found\n");
135         exit(1);
136     }
137
138     c = avcodec_alloc_context3(codec);
139
140     /* open it */
141     if (avcodec_open(c, codec) < 0) {
142         fprintf(stderr, "could not open codec\n");
143         exit(1);
144     }
145
146     outbuf = malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
147
148     f = fopen(filename, "rb");
149     if (!f) {
150         fprintf(stderr, "could not open %s\n", filename);
151         exit(1);
152     }
153     outfile = fopen(outfilename, "wb");
154     if (!outfile) {
155         av_free(c);
156         exit(1);
157     }
158
159     /* decode until eof */
160     avpkt.data = inbuf;
161     avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
162
163     while (avpkt.size > 0) {
164         out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
165         len = avcodec_decode_audio3(c, (short *)outbuf, &out_size, &avpkt);
166         if (len < 0) {
167             fprintf(stderr, "Error while decoding\n");
168             exit(1);
169         }
170         if (out_size > 0) {
171             /* if a frame has been decoded, output it */
172             fwrite(outbuf, 1, out_size, outfile);
173         }
174         avpkt.size -= len;
175         avpkt.data += len;
176         if (avpkt.size < AUDIO_REFILL_THRESH) {
177             /* Refill the input buffer, to avoid trying to decode
178              * incomplete frames. Instead of this, one could also use
179              * a parser, or use a proper container format through
180              * libavformat. */
181             memmove(inbuf, avpkt.data, avpkt.size);
182             avpkt.data = inbuf;
183             len = fread(avpkt.data + avpkt.size, 1,
184                         AUDIO_INBUF_SIZE - avpkt.size, f);
185             if (len > 0)
186                 avpkt.size += len;
187         }
188     }
189
190     fclose(outfile);
191     fclose(f);
192     free(outbuf);
193
194     avcodec_close(c);
195     av_free(c);
196 }
197
198 /*
199  * Video encoding example
200  */
201 static void video_encode_example(const char *filename)
202 {
203     AVCodec *codec;
204     AVCodecContext *c= NULL;
205     int i, out_size, size, x, y, outbuf_size;
206     FILE *f;
207     AVFrame *picture;
208     uint8_t *outbuf, *picture_buf;
209
210     printf("Video encoding\n");
211
212     /* find the mpeg1 video encoder */
213     codec = avcodec_find_encoder(CODEC_ID_MPEG1VIDEO);
214     if (!codec) {
215         fprintf(stderr, "codec not found\n");
216         exit(1);
217     }
218
219     c = avcodec_alloc_context3(codec);
220     picture= avcodec_alloc_frame();
221
222     /* put sample parameters */
223     c->bit_rate = 400000;
224     /* resolution must be a multiple of two */
225     c->width = 352;
226     c->height = 288;
227     /* frames per second */
228     c->time_base= (AVRational){1,25};
229     c->gop_size = 10; /* emit one intra frame every ten frames */
230     c->max_b_frames=1;
231     c->pix_fmt = PIX_FMT_YUV420P;
232
233     /* open it */
234     if (avcodec_open(c, codec) < 0) {
235         fprintf(stderr, "could not open codec\n");
236         exit(1);
237     }
238
239     f = fopen(filename, "wb");
240     if (!f) {
241         fprintf(stderr, "could not open %s\n", filename);
242         exit(1);
243     }
244
245     /* alloc image and output buffer */
246     outbuf_size = 100000;
247     outbuf = malloc(outbuf_size);
248     size = c->width * c->height;
249     picture_buf = malloc((size * 3) / 2); /* size for YUV 420 */
250
251     picture->data[0] = picture_buf;
252     picture->data[1] = picture->data[0] + size;
253     picture->data[2] = picture->data[1] + size / 4;
254     picture->linesize[0] = c->width;
255     picture->linesize[1] = c->width / 2;
256     picture->linesize[2] = c->width / 2;
257
258     /* encode 1 second of video */
259     for(i=0;i<25;i++) {
260         fflush(stdout);
261         /* prepare a dummy image */
262         /* Y */
263         for(y=0;y<c->height;y++) {
264             for(x=0;x<c->width;x++) {
265                 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
266             }
267         }
268
269         /* Cb and Cr */
270         for(y=0;y<c->height/2;y++) {
271             for(x=0;x<c->width/2;x++) {
272                 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
273                 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
274             }
275         }
276
277         /* encode the image */
278         out_size = avcodec_encode_video(c, outbuf, outbuf_size, picture);
279         printf("encoding frame %3d (size=%5d)\n", i, out_size);
280         fwrite(outbuf, 1, out_size, f);
281     }
282
283     /* get the delayed frames */
284     for(; out_size; i++) {
285         fflush(stdout);
286
287         out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
288         printf("write frame %3d (size=%5d)\n", i, out_size);
289         fwrite(outbuf, 1, out_size, f);
290     }
291
292     /* add sequence end code to have a real mpeg file */
293     outbuf[0] = 0x00;
294     outbuf[1] = 0x00;
295     outbuf[2] = 0x01;
296     outbuf[3] = 0xb7;
297     fwrite(outbuf, 1, 4, f);
298     fclose(f);
299     free(picture_buf);
300     free(outbuf);
301
302     avcodec_close(c);
303     av_free(c);
304     av_free(picture);
305     printf("\n");
306 }
307
308 /*
309  * Video decoding example
310  */
311
312 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
313                      char *filename)
314 {
315     FILE *f;
316     int i;
317
318     f=fopen(filename,"w");
319     fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
320     for(i=0;i<ysize;i++)
321         fwrite(buf + i * wrap,1,xsize,f);
322     fclose(f);
323 }
324
325 static void video_decode_example(const char *outfilename, const char *filename)
326 {
327     AVCodec *codec;
328     AVCodecContext *c= NULL;
329     int frame, got_picture, len;
330     FILE *f;
331     AVFrame *picture;
332     uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
333     char buf[1024];
334     AVPacket avpkt;
335
336     av_init_packet(&avpkt);
337
338     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
339     memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
340
341     printf("Video decoding\n");
342
343     /* find the mpeg1 video decoder */
344     codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO);
345     if (!codec) {
346         fprintf(stderr, "codec not found\n");
347         exit(1);
348     }
349
350     c = avcodec_alloc_context3(codec);
351     picture= avcodec_alloc_frame();
352
353     if(codec->capabilities&CODEC_CAP_TRUNCATED)
354         c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
355
356     /* For some codecs, such as msmpeg4 and mpeg4, width and height
357        MUST be initialized there because this information is not
358        available in the bitstream. */
359
360     /* open it */
361     if (avcodec_open(c, codec) < 0) {
362         fprintf(stderr, "could not open codec\n");
363         exit(1);
364     }
365
366     /* the codec gives us the frame size, in samples */
367
368     f = fopen(filename, "rb");
369     if (!f) {
370         fprintf(stderr, "could not open %s\n", filename);
371         exit(1);
372     }
373
374     frame = 0;
375     for(;;) {
376         avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
377         if (avpkt.size == 0)
378             break;
379
380         /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
381            and this is the only method to use them because you cannot
382            know the compressed data size before analysing it.
383
384            BUT some other codecs (msmpeg4, mpeg4) are inherently frame
385            based, so you must call them with all the data for one
386            frame exactly. You must also initialize 'width' and
387            'height' before initializing them. */
388
389         /* NOTE2: some codecs allow the raw parameters (frame size,
390            sample rate) to be changed at any frame. We handle this, so
391            you should also take care of it */
392
393         /* here, we use a stream based decoder (mpeg1video), so we
394            feed decoder and see if it could decode a frame */
395         avpkt.data = inbuf;
396         while (avpkt.size > 0) {
397             len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
398             if (len < 0) {
399                 fprintf(stderr, "Error while decoding frame %d\n", frame);
400                 exit(1);
401             }
402             if (got_picture) {
403                 printf("saving frame %3d\n", frame);
404                 fflush(stdout);
405
406                 /* the picture is allocated by the decoder. no need to
407                    free it */
408                 snprintf(buf, sizeof(buf), outfilename, frame);
409                 pgm_save(picture->data[0], picture->linesize[0],
410                          c->width, c->height, buf);
411                 frame++;
412             }
413             avpkt.size -= len;
414             avpkt.data += len;
415         }
416     }
417
418     /* some codecs, such as MPEG, transmit the I and P frame with a
419        latency of one frame. You must do the following to have a
420        chance to get the last frame of the video */
421     avpkt.data = NULL;
422     avpkt.size = 0;
423     len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
424     if (got_picture) {
425         printf("saving last frame %3d\n", frame);
426         fflush(stdout);
427
428         /* the picture is allocated by the decoder. no need to
429            free it */
430         snprintf(buf, sizeof(buf), outfilename, frame);
431         pgm_save(picture->data[0], picture->linesize[0],
432                  c->width, c->height, buf);
433         frame++;
434     }
435
436     fclose(f);
437
438     avcodec_close(c);
439     av_free(c);
440     av_free(picture);
441     printf("\n");
442 }
443
444 int main(int argc, char **argv)
445 {
446     const char *filename;
447
448     /* must be called before using avcodec lib */
449     avcodec_init();
450
451     /* register all the codecs */
452     avcodec_register_all();
453
454     if (argc <= 1) {
455         audio_encode_example("/tmp/test.mp2");
456         audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
457
458         video_encode_example("/tmp/test.mpg");
459         filename = "/tmp/test.mpg";
460     } else {
461         filename = argv[1];
462     }
463
464     //    audio_decode_example("/tmp/test.sw", filename);
465     video_decode_example("/tmp/test%d.pgm", filename);
466
467     return 0;
468 }