Mercurial > libavcodec.hg
annotate apiexample.c @ 4096:99616a74260a libavcodec
use lambda/lmax instead of qscale/qmax as end check for vbv retry
author | michael |
---|---|
date | Sat, 28 Oct 2006 11:15:06 +0000 |
parents | c8c591fe26f8 |
children | 219255141aa1 |
rev | line source |
---|---|
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
1 /* |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
2 * copyright (c) 2001 Fabrice Bellard |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
3 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3699
diff
changeset
|
4 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3699
diff
changeset
|
5 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3699
diff
changeset
|
6 * FFmpeg is free software; you can redistribute it and/or |
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
7 * modify it under the terms of the GNU Lesser General Public |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
8 * License as published by the Free Software Foundation; either |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3699
diff
changeset
|
9 * version 2.1 of the License, or (at your option) any later version. |
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
10 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3699
diff
changeset
|
11 * FFmpeg is distributed in the hope that it will be useful, |
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
14 * Lesser General Public License for more details. |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
15 * |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
16 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3699
diff
changeset
|
17 * License along with FFmpeg; if not, write to the Free Software |
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
19 */ |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
2967
diff
changeset
|
20 |
1106 | 21 /** |
22 * @file apiexample.c | |
23 * avcodec API use example. | |
0 | 24 * |
25 * Note that this library only handles codecs (mpeg, mpeg4, etc...), | |
1427 | 26 * not file formats (avi, vob, etc...). See library 'libavformat' for the |
2967 | 27 * format handling |
0 | 28 */ |
1106 | 29 |
0 | 30 #include <stdlib.h> |
31 #include <stdio.h> | |
32 #include <string.h> | |
33 #include <math.h> | |
34 | |
1059 | 35 #ifdef HAVE_AV_CONFIG_H |
36 #undef HAVE_AV_CONFIG_H | |
37 #endif | |
38 | |
0 | 39 #include "avcodec.h" |
40 | |
41 #define INBUF_SIZE 4096 | |
42 | |
43 /* | |
2967 | 44 * Audio encoding example |
0 | 45 */ |
46 void audio_encode_example(const char *filename) | |
47 { | |
48 AVCodec *codec; | |
685 | 49 AVCodecContext *c= NULL; |
0 | 50 int frame_size, i, j, out_size, outbuf_size; |
51 FILE *f; | |
52 short *samples; | |
53 float t, tincr; | |
1064 | 54 uint8_t *outbuf; |
0 | 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 | |
685 | 65 c= avcodec_alloc_context(); |
2967 | 66 |
0 | 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 } | |
2967 | 77 |
0 | 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 | |
1931
902556e6d21d
writing corrupt files on MinGW patch by (Matthias Fritschi <choi at netlabs dot org>)
michael
parents:
1427
diff
changeset
|
84 f = fopen(filename, "wb"); |
0 | 85 if (!f) { |
86 fprintf(stderr, "could not open %s\n", filename); | |
87 exit(1); | |
88 } | |
2967 | 89 |
0 | 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); | |
2517
3d8bbb8e7156
use av_free() instead of free() where it's meant to.
mmu_man
parents:
2423
diff
changeset
|
108 av_free(c); |
0 | 109 } |
110 | |
111 /* | |
2967 | 112 * Audio decoding. |
0 | 113 */ |
114 void audio_decode_example(const char *outfilename, const char *filename) | |
115 { | |
116 AVCodec *codec; | |
685 | 117 AVCodecContext *c= NULL; |
0 | 118 int out_size, size, len; |
119 FILE *f, *outfile; | |
1064 | 120 uint8_t *outbuf; |
1394 | 121 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE], *inbuf_ptr; |
0 | 122 |
123 printf("Audio decoding\n"); | |
2967 | 124 |
1394 | 125 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */ |
126 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE); | |
0 | 127 |
128 /* find the mpeg audio decoder */ | |
129 codec = avcodec_find_decoder(CODEC_ID_MP2); | |
130 if (!codec) { | |
131 fprintf(stderr, "codec not found\n"); | |
132 exit(1); | |
133 } | |
134 | |
685 | 135 c= avcodec_alloc_context(); |
0 | 136 |
137 /* open it */ | |
138 if (avcodec_open(c, codec) < 0) { | |
139 fprintf(stderr, "could not open codec\n"); | |
140 exit(1); | |
141 } | |
2967 | 142 |
0 | 143 outbuf = malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE); |
144 | |
1931
902556e6d21d
writing corrupt files on MinGW patch by (Matthias Fritschi <choi at netlabs dot org>)
michael
parents:
1427
diff
changeset
|
145 f = fopen(filename, "rb"); |
0 | 146 if (!f) { |
147 fprintf(stderr, "could not open %s\n", filename); | |
148 exit(1); | |
149 } | |
1931
902556e6d21d
writing corrupt files on MinGW patch by (Matthias Fritschi <choi at netlabs dot org>)
michael
parents:
1427
diff
changeset
|
150 outfile = fopen(outfilename, "wb"); |
0 | 151 if (!outfile) { |
2517
3d8bbb8e7156
use av_free() instead of free() where it's meant to.
mmu_man
parents:
2423
diff
changeset
|
152 av_free(c); |
0 | 153 exit(1); |
154 } | |
2967 | 155 |
0 | 156 /* decode until eof */ |
157 inbuf_ptr = inbuf; | |
158 for(;;) { | |
159 size = fread(inbuf, 1, INBUF_SIZE, f); | |
160 if (size == 0) | |
161 break; | |
162 | |
163 inbuf_ptr = inbuf; | |
164 while (size > 0) { | |
2967 | 165 len = avcodec_decode_audio(c, (short *)outbuf, &out_size, |
0 | 166 inbuf_ptr, size); |
167 if (len < 0) { | |
168 fprintf(stderr, "Error while decoding\n"); | |
169 exit(1); | |
170 } | |
171 if (out_size > 0) { | |
172 /* if a frame has been decoded, output it */ | |
173 fwrite(outbuf, 1, out_size, outfile); | |
174 } | |
175 size -= len; | |
176 inbuf_ptr += len; | |
177 } | |
178 } | |
179 | |
180 fclose(outfile); | |
181 fclose(f); | |
182 free(outbuf); | |
183 | |
184 avcodec_close(c); | |
2517
3d8bbb8e7156
use av_free() instead of free() where it's meant to.
mmu_man
parents:
2423
diff
changeset
|
185 av_free(c); |
0 | 186 } |
187 | |
188 /* | |
2967 | 189 * Video encoding example |
0 | 190 */ |
191 void video_encode_example(const char *filename) | |
192 { | |
193 AVCodec *codec; | |
685 | 194 AVCodecContext *c= NULL; |
0 | 195 int i, out_size, size, x, y, outbuf_size; |
196 FILE *f; | |
925 | 197 AVFrame *picture; |
1064 | 198 uint8_t *outbuf, *picture_buf; |
0 | 199 |
200 printf("Video encoding\n"); | |
201 | |
202 /* find the mpeg1 video encoder */ | |
203 codec = avcodec_find_encoder(CODEC_ID_MPEG1VIDEO); | |
204 if (!codec) { | |
205 fprintf(stderr, "codec not found\n"); | |
206 exit(1); | |
207 } | |
208 | |
685 | 209 c= avcodec_alloc_context(); |
925 | 210 picture= avcodec_alloc_frame(); |
2967 | 211 |
0 | 212 /* put sample parameters */ |
213 c->bit_rate = 400000; | |
214 /* resolution must be a multiple of two */ | |
2967 | 215 c->width = 352; |
0 | 216 c->height = 288; |
217 /* frames per second */ | |
2637 | 218 c->time_base= (AVRational){1,25}; |
0 | 219 c->gop_size = 10; /* emit one intra frame every ten frames */ |
1373 | 220 c->max_b_frames=1; |
2760 | 221 c->pix_fmt = PIX_FMT_YUV420P; |
0 | 222 |
223 /* open it */ | |
224 if (avcodec_open(c, codec) < 0) { | |
225 fprintf(stderr, "could not open codec\n"); | |
226 exit(1); | |
227 } | |
2967 | 228 |
0 | 229 /* the codec gives us the frame size, in samples */ |
230 | |
1931
902556e6d21d
writing corrupt files on MinGW patch by (Matthias Fritschi <choi at netlabs dot org>)
michael
parents:
1427
diff
changeset
|
231 f = fopen(filename, "wb"); |
0 | 232 if (!f) { |
233 fprintf(stderr, "could not open %s\n", filename); | |
234 exit(1); | |
235 } | |
2967 | 236 |
0 | 237 /* alloc image and output buffer */ |
238 outbuf_size = 100000; | |
239 outbuf = malloc(outbuf_size); | |
240 size = c->width * c->height; | |
241 picture_buf = malloc((size * 3) / 2); /* size for YUV 420 */ | |
2967 | 242 |
919 | 243 picture->data[0] = picture_buf; |
244 picture->data[1] = picture->data[0] + size; | |
245 picture->data[2] = picture->data[1] + size / 4; | |
246 picture->linesize[0] = c->width; | |
247 picture->linesize[1] = c->width / 2; | |
248 picture->linesize[2] = c->width / 2; | |
0 | 249 |
250 /* encode 1 second of video */ | |
251 for(i=0;i<25;i++) { | |
252 fflush(stdout); | |
253 /* prepare a dummy image */ | |
254 /* Y */ | |
255 for(y=0;y<c->height;y++) { | |
256 for(x=0;x<c->width;x++) { | |
919 | 257 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3; |
0 | 258 } |
259 } | |
260 | |
261 /* Cb and Cr */ | |
262 for(y=0;y<c->height/2;y++) { | |
263 for(x=0;x<c->width/2;x++) { | |
919 | 264 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2; |
265 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5; | |
0 | 266 } |
267 } | |
268 | |
269 /* encode the image */ | |
919 | 270 out_size = avcodec_encode_video(c, outbuf, outbuf_size, picture); |
1373 | 271 printf("encoding frame %3d (size=%5d)\n", i, out_size); |
272 fwrite(outbuf, 1, out_size, f); | |
273 } | |
274 | |
275 /* get the delayed frames */ | |
276 for(; out_size; i++) { | |
277 fflush(stdout); | |
2967 | 278 |
1373 | 279 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); |
280 printf("write frame %3d (size=%5d)\n", i, out_size); | |
0 | 281 fwrite(outbuf, 1, out_size, f); |
282 } | |
283 | |
284 /* add sequence end code to have a real mpeg file */ | |
285 outbuf[0] = 0x00; | |
286 outbuf[1] = 0x00; | |
287 outbuf[2] = 0x01; | |
288 outbuf[3] = 0xb7; | |
289 fwrite(outbuf, 1, 4, f); | |
290 fclose(f); | |
291 free(picture_buf); | |
292 free(outbuf); | |
293 | |
294 avcodec_close(c); | |
2517
3d8bbb8e7156
use av_free() instead of free() where it's meant to.
mmu_man
parents:
2423
diff
changeset
|
295 av_free(c); |
3d8bbb8e7156
use av_free() instead of free() where it's meant to.
mmu_man
parents:
2423
diff
changeset
|
296 av_free(picture); |
0 | 297 printf("\n"); |
298 } | |
299 | |
300 /* | |
2967 | 301 * Video decoding example |
0 | 302 */ |
303 | |
2967 | 304 void pgm_save(unsigned char *buf,int wrap, int xsize,int ysize,char *filename) |
0 | 305 { |
306 FILE *f; | |
307 int i; | |
308 | |
309 f=fopen(filename,"w"); | |
310 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255); | |
311 for(i=0;i<ysize;i++) | |
312 fwrite(buf + i * wrap,1,xsize,f); | |
313 fclose(f); | |
314 } | |
315 | |
316 void video_decode_example(const char *outfilename, const char *filename) | |
317 { | |
318 AVCodec *codec; | |
685 | 319 AVCodecContext *c= NULL; |
0 | 320 int frame, size, got_picture, len; |
321 FILE *f; | |
925 | 322 AVFrame *picture; |
1394 | 323 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE], *inbuf_ptr; |
0 | 324 char buf[1024]; |
325 | |
1394 | 326 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */ |
327 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE); | |
328 | |
0 | 329 printf("Video decoding\n"); |
330 | |
331 /* find the mpeg1 video decoder */ | |
332 codec = avcodec_find_decoder(CODEC_ID_MPEG1VIDEO); | |
333 if (!codec) { | |
334 fprintf(stderr, "codec not found\n"); | |
335 exit(1); | |
336 } | |
337 | |
685 | 338 c= avcodec_alloc_context(); |
925 | 339 picture= avcodec_alloc_frame(); |
0 | 340 |
895
1a5926aeed5f
apiexample doesnt send complete frames to the codec
michaelni
parents:
685
diff
changeset
|
341 if(codec->capabilities&CODEC_CAP_TRUNCATED) |
1a5926aeed5f
apiexample doesnt send complete frames to the codec
michaelni
parents:
685
diff
changeset
|
342 c->flags|= CODEC_FLAG_TRUNCATED; /* we dont send complete frames */ |
1a5926aeed5f
apiexample doesnt send complete frames to the codec
michaelni
parents:
685
diff
changeset
|
343 |
71 | 344 /* for some codecs, such as msmpeg4 and mpeg4, width and height |
0 | 345 MUST be initialized there because these info are not available |
346 in the bitstream */ | |
347 | |
348 /* open it */ | |
349 if (avcodec_open(c, codec) < 0) { | |
350 fprintf(stderr, "could not open codec\n"); | |
351 exit(1); | |
352 } | |
2967 | 353 |
0 | 354 /* the codec gives us the frame size, in samples */ |
355 | |
1931
902556e6d21d
writing corrupt files on MinGW patch by (Matthias Fritschi <choi at netlabs dot org>)
michael
parents:
1427
diff
changeset
|
356 f = fopen(filename, "rb"); |
0 | 357 if (!f) { |
358 fprintf(stderr, "could not open %s\n", filename); | |
359 exit(1); | |
360 } | |
2967 | 361 |
0 | 362 frame = 0; |
363 for(;;) { | |
364 size = fread(inbuf, 1, INBUF_SIZE, f); | |
365 if (size == 0) | |
366 break; | |
367 | |
368 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio) | |
369 and this is the only method to use them because you cannot | |
2967 | 370 know the compressed data size before analysing it. |
0 | 371 |
71 | 372 BUT some other codecs (msmpeg4, mpeg4) are inherently frame |
373 based, so you must call them with all the data for one | |
374 frame exactly. You must also initialize 'width' and | |
0 | 375 'height' before initializing them. */ |
376 | |
377 /* NOTE2: some codecs allow the raw parameters (frame size, | |
378 sample rate) to be changed at any frame. We handle this, so | |
379 you should also take care of it */ | |
380 | |
381 /* here, we use a stream based decoder (mpeg1video), so we | |
382 feed decoder and see if it could decode a frame */ | |
383 inbuf_ptr = inbuf; | |
384 while (size > 0) { | |
2967 | 385 len = avcodec_decode_video(c, picture, &got_picture, |
0 | 386 inbuf_ptr, size); |
387 if (len < 0) { | |
388 fprintf(stderr, "Error while decoding frame %d\n", frame); | |
389 exit(1); | |
390 } | |
391 if (got_picture) { | |
1373 | 392 printf("saving frame %3d\n", frame); |
0 | 393 fflush(stdout); |
394 | |
395 /* the picture is allocated by the decoder. no need to | |
396 free it */ | |
397 snprintf(buf, sizeof(buf), outfilename, frame); | |
2967 | 398 pgm_save(picture->data[0], picture->linesize[0], |
0 | 399 c->width, c->height, buf); |
400 frame++; | |
401 } | |
402 size -= len; | |
403 inbuf_ptr += len; | |
404 } | |
405 } | |
406 | |
407 /* some codecs, such as MPEG, transmit the I and P frame with a | |
408 latency of one frame. You must do the following to have a | |
409 chance to get the last frame of the video */ | |
2967 | 410 len = avcodec_decode_video(c, picture, &got_picture, |
0 | 411 NULL, 0); |
412 if (got_picture) { | |
1373 | 413 printf("saving last frame %3d\n", frame); |
0 | 414 fflush(stdout); |
2967 | 415 |
0 | 416 /* the picture is allocated by the decoder. no need to |
417 free it */ | |
418 snprintf(buf, sizeof(buf), outfilename, frame); | |
2967 | 419 pgm_save(picture->data[0], picture->linesize[0], |
0 | 420 c->width, c->height, buf); |
421 frame++; | |
422 } | |
2967 | 423 |
0 | 424 fclose(f); |
425 | |
426 avcodec_close(c); | |
2517
3d8bbb8e7156
use av_free() instead of free() where it's meant to.
mmu_man
parents:
2423
diff
changeset
|
427 av_free(c); |
3d8bbb8e7156
use av_free() instead of free() where it's meant to.
mmu_man
parents:
2423
diff
changeset
|
428 av_free(picture); |
0 | 429 printf("\n"); |
430 } | |
431 | |
432 int main(int argc, char **argv) | |
433 { | |
434 const char *filename; | |
435 | |
436 /* must be called before using avcodec lib */ | |
437 avcodec_init(); | |
438 | |
439 /* register all the codecs (you can also register only the codec | |
440 you wish to have smaller code */ | |
441 avcodec_register_all(); | |
1059 | 442 |
0 | 443 if (argc <= 1) { |
444 audio_encode_example("/tmp/test.mp2"); | |
445 audio_decode_example("/tmp/test.sw", "/tmp/test.mp2"); | |
446 | |
447 video_encode_example("/tmp/test.mpg"); | |
448 filename = "/tmp/test.mpg"; | |
449 } else { | |
450 filename = argv[1]; | |
451 } | |
452 | |
453 // audio_decode_example("/tmp/test.sw", filename); | |
454 video_decode_example("/tmp/test%d.pgm", filename); | |
455 | |
456 return 0; | |
457 } |