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