34f788947a9bff5c81adf3e340bc64b730918655
[libav.git] / libavcodec / utils.c
1 /*
2 * utils for libavcodec
3 * Copyright (c) 2001 Fabrice Bellard.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library 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 GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19 #include "avcodec.h"
20 #include "dsputil.h"
21 #include "mpegvideo.h"
22 #ifdef HAVE_MALLOC_H
23 #include <malloc.h>
24 #endif
25
26 /* memory alloc */
27 void *av_malloc(int size)
28 {
29 void *ptr;
30 #if defined ( ARCH_X86 ) && defined ( HAVE_MEMALIGN )
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
42 ptr = malloc(size);
43 #endif
44 if (!ptr)
45 return NULL;
46 memset(ptr, 0, size);
47 return ptr;
48 }
49
50 void *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 */
61 void av_free(void *ptr)
62 {
63 /* XXX: this test should not be needed on most libcs */
64 if (ptr)
65 free(ptr);
66 }
67
68 /* cannot call it directly because of 'void **' casting is not automatic */
69 void __av_freep(void **ptr)
70 {
71 av_free(*ptr);
72 *ptr = NULL;
73 }
74
75 /* encoder management */
76 AVCodec *first_avcodec;
77
78 void 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
87 int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
88 {
89 int ret;
90
91 avctx->codec = codec;
92 avctx->frame_number = 0;
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 }
100 ret = avctx->codec->init(avctx);
101 if (ret < 0) {
102 av_freep(&avctx->priv_data);
103 return ret;
104 }
105 return 0;
106 }
107
108 int 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
118 int 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 */
131 int 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);
139 if (*got_picture_ptr)
140 avctx->frame_number++;
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. */
148 int 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
160 int avcodec_close(AVCodecContext *avctx)
161 {
162 if (avctx->codec->close)
163 avctx->codec->close(avctx);
164 av_freep(&avctx->priv_data);
165 avctx->codec = NULL;
166 return 0;
167 }
168
169 AVCodec *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
181 AVCodec *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
193 AVCodec *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
205 AVCodec *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
217 AVCodec *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
229 const char *pix_fmt_str[] = {
230 "??",
231 "yuv420p",
232 "yuv422",
233 "rgb24",
234 "bgr24",
235 "yuv422p",
236 "yuv444p",
237 };
238
239 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
240 {
241 const char *codec_name;
242 AVCodec *p;
243 char buf1[32];
244 char channels_str[100];
245 int bitrate;
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)" : "");
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 }
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 }
286 snprintf(buf + strlen(buf), buf_size - strlen(buf),
287 ", q=%d-%d", enc->qmin, enc->qmax);
288
289 bitrate = enc->bit_rate;
290 break;
291 case CODEC_TYPE_AUDIO:
292 snprintf(buf, buf_size,
293 "Audio: %s",
294 codec_name);
295 switch (enc->channels) {
296 case 1:
297 strcpy(channels_str, "mono");
298 break;
299 case 2:
300 strcpy(channels_str, "stereo");
301 break;
302 case 6:
303 strcpy(channels_str, "5:1");
304 break;
305 default:
306 sprintf(channels_str, "%d channels", enc->channels);
307 break;
308 }
309 if (enc->sample_rate) {
310 snprintf(buf + strlen(buf), buf_size - strlen(buf),
311 ", %d Hz, %s",
312 enc->sample_rate,
313 channels_str);
314 }
315
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:
322 bitrate = enc->sample_rate * enc->channels * 16;
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:
328 bitrate = enc->sample_rate * enc->channels * 8;
329 break;
330 default:
331 bitrate = enc->bit_rate;
332 break;
333 }
334 break;
335 default:
336 abort();
337 }
338 if (bitrate != 0) {
339 snprintf(buf + strlen(buf), buf_size - strlen(buf),
340 ", %d kb/s", bitrate / 1000);
341 }
342 }
343
344 /* Picture field are filled with 'ptr' addresses */
345 void 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
397 int 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
426 unsigned avcodec_version( void )
427 {
428 return LIBAVCODEC_VERSION_INT;
429 }
430
431 unsigned avcodec_build( void )
432 {
433 return LIBAVCODEC_BUILD;
434 }
435
436 /* must be called before any other functions */
437 void avcodec_init(void)
438 {
439 static int inited = 0;
440
441 if (inited != 0)
442 return;
443 inited = 1;
444
445 dsputil_init();
446 }
447
448 /* simple call to use all the codecs */
449 void avcodec_register_all(void)
450 {
451 static int inited = 0;
452
453 if (inited != 0)
454 return;
455 inited = 1;
456
457 /* encoders */
458 #ifdef CONFIG_ENCODERS
459 register_avcodec(&ac3_encoder);
460 register_avcodec(&mp2_encoder);
461 #ifdef CONFIG_MP3LAME
462 register_avcodec(&mp3lame_encoder);
463 #endif
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);
469 register_avcodec(&mpeg4_encoder);
470 register_avcodec(&msmpeg4v1_encoder);
471 register_avcodec(&msmpeg4v2_encoder);
472 register_avcodec(&msmpeg4v3_encoder);
473 #endif /* CONFIG_ENCODERS */
474 register_avcodec(&rawvideo_codec);
475
476 /* decoders */
477 #ifdef CONFIG_DECODERS
478 register_avcodec(&h263_decoder);
479 register_avcodec(&mpeg4_decoder);
480 register_avcodec(&msmpeg4v1_decoder);
481 register_avcodec(&msmpeg4v2_decoder);
482 register_avcodec(&msmpeg4v3_decoder);
483 register_avcodec(&wmv1_decoder);
484 register_avcodec(&mpeg_decoder);
485 register_avcodec(&h263i_decoder);
486 register_avcodec(&rv10_decoder);
487 register_avcodec(&mjpeg_decoder);
488 register_avcodec(&mp2_decoder);
489 register_avcodec(&mp3_decoder);
490 #ifdef CONFIG_AC3
491 register_avcodec(&ac3_decoder);
492 #endif
493 #endif /* CONFIG_DECODERS */
494
495 /* pcm codecs */
496
497 #define PCM_CODEC(id, name) \
498 register_avcodec(& name ## _encoder); \
499 register_avcodec(& name ## _decoder); \
500
501 PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
502 PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
503 PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
504 PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
505 PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
506 PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
507 PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
508 PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
509
510 #undef PCM_CODEC
511 }
512
513 /* this should be called after seeking and before trying to decode the next frame */
514 void avcodec_flush_buffers(AVCodecContext *avctx)
515 {
516 MpegEncContext *s = avctx->priv_data;
517 s->num_available_buffers=0;
518 }
519
520
521 static int raw_encode_init(AVCodecContext *s)
522 {
523 return 0;
524 }
525
526 static int raw_decode_frame(AVCodecContext *avctx,
527 void *data, int *data_size,
528 UINT8 *buf, int buf_size)
529 {
530 return -1;
531 }
532
533 static int raw_encode_frame(AVCodecContext *avctx,
534 unsigned char *frame, int buf_size, void *data)
535 {
536 return -1;
537 }
538
539 AVCodec rawvideo_codec = {
540 "rawvideo",
541 CODEC_TYPE_VIDEO,
542 CODEC_ID_RAWVIDEO,
543 0,
544 raw_encode_init,
545 raw_encode_frame,
546 NULL,
547 raw_decode_frame,
548 };