consistent include usage
[libav.git] / libavcodec / utils.c
CommitLineData
de6d9b64
FB
1/*
2 * utils for libavcodec
3 * Copyright (c) 2001 Gerard Lantau.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
de6d9b64 19#include "avcodec.h"
3123dd79 20#include "dsputil.h"
1c2a8c7f 21#include "mpegvideo.h"
3d204385
NK
22#ifdef HAVE_MALLOC_H
23#include <malloc.h>
3d204385 24#endif
de6d9b64
FB
25
26/* memory alloc */
3123dd79 27void *av_malloc(int size)
de6d9b64
FB
28{
29 void *ptr;
36157009 30#if defined ( ARCH_X86 ) && defined ( HAVE_MEMALIGN )
36157009
NK
31 ptr = memalign(64,size);
32 /* Why 64?
33 Indeed, we should align it:
34 on 4 for 386
35 on 16 for 486
36 on 32 for 586, PPro - k6-III
37 on 64 for K7 (maybe for P3 too).
38 Because L1 and L2 caches are aligned on those values.
39 But I don't want to code such logic here!
40 */
41#else
de6d9b64 42 ptr = malloc(size);
36157009 43#endif
de6d9b64
FB
44 if (!ptr)
45 return NULL;
46 memset(ptr, 0, size);
47 return ptr;
48}
49
3123dd79
FB
50void *av_mallocz(int size)
51{
52 void *ptr;
53 ptr = av_malloc(size);
54 if (!ptr)
55 return NULL;
56 memset(ptr, 0, size);
57 return ptr;
58}
59
60/* NOTE: ptr = NULL is explicetly allowed */
61void av_free(void *ptr)
62{
63 /* XXX: this test should not be needed on most libcs */
64 if (ptr)
65 free(ptr);
66}
67
4d7a0a05
FB
68/* cannot call it directly because of 'void **' casting is not automatic */
69void __av_freep(void **ptr)
70{
71 av_free(*ptr);
72 *ptr = NULL;
73}
74
de6d9b64
FB
75/* encoder management */
76AVCodec *first_avcodec;
77
78void register_avcodec(AVCodec *format)
79{
80 AVCodec **p;
81 p = &first_avcodec;
82 while (*p != NULL) p = &(*p)->next;
83 *p = format;
84 format->next = NULL;
85}
86
87int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
88{
89 int ret;
90
91 avctx->codec = codec;
92 avctx->frame_number = 0;
0edf8a7a
PG
93 if (codec->priv_data_size > 0) {
94 avctx->priv_data = av_mallocz(codec->priv_data_size);
95 if (!avctx->priv_data)
96 return -ENOMEM;
97 } else {
98 avctx->priv_data = NULL;
99 }
de6d9b64
FB
100 ret = avctx->codec->init(avctx);
101 if (ret < 0) {
3123dd79 102 av_freep(&avctx->priv_data);
de6d9b64
FB
103 return ret;
104 }
105 return 0;
106}
107
108int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size,
109 const short *samples)
110{
111 int ret;
112
113 ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
114 avctx->frame_number++;
115 return ret;
116}
117
118int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size,
119 const AVPicture *pict)
120{
121 int ret;
122
123 ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
124 avctx->frame_number++;
125 return ret;
126}
127
128/* decode a frame. return -1 if error, otherwise return the number of
129 bytes used. If no frame could be decompressed, *got_picture_ptr is
130 zero. Otherwise, it is non zero */
131int avcodec_decode_video(AVCodecContext *avctx, AVPicture *picture,
132 int *got_picture_ptr,
133 UINT8 *buf, int buf_size)
134{
135 int ret;
136
137 ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
138 buf, buf_size);
1cb0edb4
J
139 if (*got_picture_ptr)
140 avctx->frame_number++;
de6d9b64
FB
141 return ret;
142}
143
144/* decode an audio frame. return -1 if error, otherwise return the
145 *number of bytes used. If no frame could be decompressed,
146 *frame_size_ptr is zero. Otherwise, it is the decompressed frame
147 *size in BYTES. */
148int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples,
149 int *frame_size_ptr,
150 UINT8 *buf, int buf_size)
151{
152 int ret;
153
154 ret = avctx->codec->decode(avctx, samples, frame_size_ptr,
155 buf, buf_size);
156 avctx->frame_number++;
157 return ret;
158}
159
160int avcodec_close(AVCodecContext *avctx)
161{
162 if (avctx->codec->close)
163 avctx->codec->close(avctx);
3123dd79 164 av_freep(&avctx->priv_data);
de6d9b64
FB
165 avctx->codec = NULL;
166 return 0;
167}
168
169AVCodec *avcodec_find_encoder(enum CodecID id)
170{
171 AVCodec *p;
172 p = first_avcodec;
173 while (p) {
174 if (p->encode != NULL && p->id == id)
175 return p;
176 p = p->next;
177 }
178 return NULL;
179}
180
98f3b098
A
181AVCodec *avcodec_find_encoder_by_name(const char *name)
182{
183 AVCodec *p;
184 p = first_avcodec;
185 while (p) {
186 if (p->encode != NULL && strcmp(name,p->name) == 0)
187 return p;
188 p = p->next;
189 }
190 return NULL;
191}
192
de6d9b64
FB
193AVCodec *avcodec_find_decoder(enum CodecID id)
194{
195 AVCodec *p;
196 p = first_avcodec;
197 while (p) {
198 if (p->decode != NULL && p->id == id)
199 return p;
200 p = p->next;
201 }
202 return NULL;
203}
204
205AVCodec *avcodec_find_decoder_by_name(const char *name)
206{
207 AVCodec *p;
208 p = first_avcodec;
209 while (p) {
210 if (p->decode != NULL && strcmp(name,p->name) == 0)
211 return p;
212 p = p->next;
213 }
214 return NULL;
215}
216
217AVCodec *avcodec_find(enum CodecID id)
218{
219 AVCodec *p;
220 p = first_avcodec;
221 while (p) {
222 if (p->id == id)
223 return p;
224 p = p->next;
225 }
226 return NULL;
227}
228
cf087595 229const char *pix_fmt_str[] = {
bc657ac3 230 "??",
cf087595
FB
231 "yuv420p",
232 "yuv422",
233 "rgb24",
234 "bgr24",
235 "yuv422p",
236 "yuv444p",
237};
238
de6d9b64
FB
239void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
240{
241 const char *codec_name;
242 AVCodec *p;
243 char buf1[32];
623563c0 244 char channels_str[100];
a96b68b7 245 int bitrate;
de6d9b64
FB
246
247 if (encode)
248 p = avcodec_find_encoder(enc->codec_id);
249 else
250 p = avcodec_find_decoder(enc->codec_id);
251
252 if (p) {
253 codec_name = p->name;
254 } else if (enc->codec_name[0] != '\0') {
255 codec_name = enc->codec_name;
256 } else {
257 /* output avi tags */
258 if (enc->codec_type == CODEC_TYPE_VIDEO) {
259 snprintf(buf1, sizeof(buf1), "%c%c%c%c",
260 enc->codec_tag & 0xff,
261 (enc->codec_tag >> 8) & 0xff,
262 (enc->codec_tag >> 16) & 0xff,
263 (enc->codec_tag >> 24) & 0xff);
264 } else {
265 snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
266 }
267 codec_name = buf1;
268 }
269
270 switch(enc->codec_type) {
271 case CODEC_TYPE_VIDEO:
272 snprintf(buf, buf_size,
273 "Video: %s%s",
274 codec_name, enc->flags & CODEC_FLAG_HQ ? " (hq)" : "");
cf087595
FB
275 if (enc->codec_id == CODEC_ID_RAWVIDEO) {
276 snprintf(buf + strlen(buf), buf_size - strlen(buf),
277 ", %s",
278 pix_fmt_str[enc->pix_fmt]);
279 }
de6d9b64
FB
280 if (enc->width) {
281 snprintf(buf + strlen(buf), buf_size - strlen(buf),
282 ", %dx%d, %0.2f fps",
283 enc->width, enc->height,
284 (float)enc->frame_rate / FRAME_RATE_BASE);
285 }
bc657ac3
ZK
286 snprintf(buf + strlen(buf), buf_size - strlen(buf),
287 ", q=%d-%d", enc->qmin, enc->qmax);
288
a96b68b7 289 bitrate = enc->bit_rate;
de6d9b64
FB
290 break;
291 case CODEC_TYPE_AUDIO:
292 snprintf(buf, buf_size,
293 "Audio: %s",
294 codec_name);
e0d2714a
J
295 switch (enc->channels) {
296 case 1:
623563c0 297 strcpy(channels_str, "mono");
e0d2714a
J
298 break;
299 case 2:
623563c0 300 strcpy(channels_str, "stereo");
e0d2714a
J
301 break;
302 case 6:
623563c0 303 strcpy(channels_str, "5:1");
e0d2714a
J
304 break;
305 default:
306 sprintf(channels_str, "%d channels", enc->channels);
307 break;
308 }
de6d9b64
FB
309 if (enc->sample_rate) {
310 snprintf(buf + strlen(buf), buf_size - strlen(buf),
311 ", %d Hz, %s",
312 enc->sample_rate,
e0d2714a 313 channels_str);
de6d9b64 314 }
e0d2714a 315
a96b68b7
FB
316 /* for PCM codecs, compute bitrate directly */
317 switch(enc->codec_id) {
318 case CODEC_ID_PCM_S16LE:
319 case CODEC_ID_PCM_S16BE:
320 case CODEC_ID_PCM_U16LE:
321 case CODEC_ID_PCM_U16BE:
a190b7e9 322 bitrate = enc->sample_rate * enc->channels * 16;
a96b68b7
FB
323 break;
324 case CODEC_ID_PCM_S8:
325 case CODEC_ID_PCM_U8:
326 case CODEC_ID_PCM_ALAW:
327 case CODEC_ID_PCM_MULAW:
a190b7e9 328 bitrate = enc->sample_rate * enc->channels * 8;
a96b68b7
FB
329 break;
330 default:
331 bitrate = enc->bit_rate;
332 break;
333 }
de6d9b64
FB
334 break;
335 default:
336 abort();
337 }
a96b68b7 338 if (bitrate != 0) {
de6d9b64 339 snprintf(buf + strlen(buf), buf_size - strlen(buf),
a96b68b7 340 ", %d kb/s", bitrate / 1000);
de6d9b64
FB
341 }
342}
343
cf087595
FB
344/* Picture field are filled with 'ptr' addresses */
345void avpicture_fill(AVPicture *picture, UINT8 *ptr,
346 int pix_fmt, int width, int height)
347{
348 int size;
349
350 size = width * height;
351 switch(pix_fmt) {
352 case PIX_FMT_YUV420P:
353 picture->data[0] = ptr;
354 picture->data[1] = picture->data[0] + size;
355 picture->data[2] = picture->data[1] + size / 4;
356 picture->linesize[0] = width;
357 picture->linesize[1] = width / 2;
358 picture->linesize[2] = width / 2;
359 break;
360 case PIX_FMT_YUV422P:
361 picture->data[0] = ptr;
362 picture->data[1] = picture->data[0] + size;
363 picture->data[2] = picture->data[1] + size / 2;
364 picture->linesize[0] = width;
365 picture->linesize[1] = width / 2;
366 picture->linesize[2] = width / 2;
367 break;
368 case PIX_FMT_YUV444P:
369 picture->data[0] = ptr;
370 picture->data[1] = picture->data[0] + size;
371 picture->data[2] = picture->data[1] + size;
372 picture->linesize[0] = width;
373 picture->linesize[1] = width;
374 picture->linesize[2] = width;
375 break;
376 case PIX_FMT_RGB24:
377 case PIX_FMT_BGR24:
378 picture->data[0] = ptr;
379 picture->data[1] = NULL;
380 picture->data[2] = NULL;
381 picture->linesize[0] = width * 3;
382 break;
383 case PIX_FMT_YUV422:
384 picture->data[0] = ptr;
385 picture->data[1] = NULL;
386 picture->data[2] = NULL;
387 picture->linesize[0] = width * 2;
388 break;
389 default:
390 picture->data[0] = NULL;
391 picture->data[1] = NULL;
392 picture->data[2] = NULL;
393 break;
394 }
395}
396
397int avpicture_get_size(int pix_fmt, int width, int height)
398{
399 int size;
400
401 size = width * height;
402 switch(pix_fmt) {
403 case PIX_FMT_YUV420P:
404 size = (size * 3) / 2;
405 break;
406 case PIX_FMT_YUV422P:
407 size = (size * 2);
408 break;
409 case PIX_FMT_YUV444P:
410 size = (size * 3);
411 break;
412 case PIX_FMT_RGB24:
413 case PIX_FMT_BGR24:
414 size = (size * 3);
415 break;
416 case PIX_FMT_YUV422:
417 size = (size * 2);
418 break;
419 default:
420 size = -1;
421 break;
422 }
423 return size;
424}
425
156e5023
NK
426unsigned avcodec_version( void )
427{
428 return LIBAVCODEC_VERSION_INT;
429}
cf087595 430
8bceb6af
NK
431unsigned avcodec_build( void )
432{
433 return LIBAVCODEC_BUILD;
434}
435
de6d9b64
FB
436/* must be called before any other functions */
437void avcodec_init(void)
438{
0344cd0a
AB
439 static int inited = 0;
440
441 if (inited != 0)
442 return;
443 inited = 1;
444
de6d9b64
FB
445 dsputil_init();
446}
447
448/* simple call to use all the codecs */
449void avcodec_register_all(void)
450{
0344cd0a
AB
451 static int inited = 0;
452
453 if (inited != 0)
454 return;
455 inited = 1;
456
d771bcae
FB
457 /* encoders */
458#ifdef CONFIG_ENCODERS
de6d9b64
FB
459 register_avcodec(&ac3_encoder);
460 register_avcodec(&mp2_encoder);
9d36bdc9
J
461#ifdef CONFIG_MP3LAME
462 register_avcodec(&mp3lame_encoder);
463#endif
de6d9b64
FB
464 register_avcodec(&mpeg1video_encoder);
465 register_avcodec(&h263_encoder);
466 register_avcodec(&h263p_encoder);
467 register_avcodec(&rv10_encoder);
468 register_avcodec(&mjpeg_encoder);
58f26ba9 469 register_avcodec(&mpeg4_encoder);
84afee34
MN
470 register_avcodec(&msmpeg4v1_encoder);
471 register_avcodec(&msmpeg4v2_encoder);
472 register_avcodec(&msmpeg4v3_encoder);
d771bcae 473#endif /* CONFIG_ENCODERS */
de6d9b64 474 register_avcodec(&rawvideo_codec);
d771bcae 475
de6d9b64 476 /* decoders */
d771bcae 477#ifdef CONFIG_DECODERS
de6d9b64 478 register_avcodec(&h263_decoder);
58f26ba9 479 register_avcodec(&mpeg4_decoder);
84afee34
MN
480 register_avcodec(&msmpeg4v1_decoder);
481 register_avcodec(&msmpeg4v2_decoder);
482 register_avcodec(&msmpeg4v3_decoder);
e1a9dbff 483 register_avcodec(&wmv1_decoder);
de6d9b64
FB
484 register_avcodec(&mpeg_decoder);
485 register_avcodec(&h263i_decoder);
486 register_avcodec(&rv10_decoder);
4e66ab3b 487 register_avcodec(&mjpeg_decoder);
4b1f4f23 488 register_avcodec(&mp2_decoder);
d771bcae 489 register_avcodec(&mp3_decoder);
d771bcae
FB
490#ifdef CONFIG_AC3
491 register_avcodec(&ac3_decoder);
492#endif
493#endif /* CONFIG_DECODERS */
a96b68b7
FB
494
495 /* pcm codecs */
496
497#define PCM_CODEC(id, name) \
498 register_avcodec(& name ## _encoder); \
499 register_avcodec(& name ## _decoder); \
500
501PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
502PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
503PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
504PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
505PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
506PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
507PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
508PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
509
510#undef PCM_CODEC
de6d9b64
FB
511}
512
1c2a8c7f
MN
513/* this should be called after seeking and before trying to decode the next frame */
514void avcodec_flush_buffers(AVCodecContext *avctx)
515{
516 MpegEncContext *s = avctx->priv_data;
517 s->num_available_buffers=0;
518}
519
520
de6d9b64
FB
521static int encode_init(AVCodecContext *s)
522{
523 return 0;
524}
525
526static int decode_frame(AVCodecContext *avctx,
527 void *data, int *data_size,
528 UINT8 *buf, int buf_size)
529{
530 return -1;
531}
532
533static int encode_frame(AVCodecContext *avctx,
534 unsigned char *frame, int buf_size, void *data)
535{
536 return -1;
537}
538
de6d9b64
FB
539AVCodec rawvideo_codec = {
540 "rawvideo",
541 CODEC_TYPE_VIDEO,
542 CODEC_ID_RAWVIDEO,
543 0,
544 encode_init,
545 encode_frame,
546 NULL,
547 decode_frame,
548};