making configure a shell script not a bash one patch by (Roman Shaposhnick <rvs at...
[libav.git] / libavcodec / utils.c
CommitLineData
de6d9b64
FB
1/*
2 * utils for libavcodec
ff4ec49e 3 * Copyright (c) 2001 Fabrice Bellard.
de6d9b64 4 *
ff4ec49e
FB
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.
de6d9b64 9 *
ff4ec49e 10 * This library is distributed in the hope that it will be useful,
de6d9b64 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ff4ec49e
FB
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
de6d9b64 14 *
ff4ec49e
FB
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
de6d9b64 18 */
983e3246
MN
19
20/**
21 * @file utils.c
22 * utils.
23 */
24
de6d9b64 25#include "avcodec.h"
3123dd79 26#include "dsputil.h"
1c2a8c7f 27#include "mpegvideo.h"
de6d9b64 28
18f77016 29void *av_mallocz(unsigned int size)
3123dd79
FB
30{
31 void *ptr;
5b20b732 32
3123dd79
FB
33 ptr = av_malloc(size);
34 if (!ptr)
35 return NULL;
36 memset(ptr, 0, size);
37 return ptr;
38}
39
8e1e6f31
FB
40char *av_strdup(const char *s)
41{
42 char *ptr;
43 int len;
44 len = strlen(s) + 1;
45 ptr = av_malloc(len);
46 if (!ptr)
47 return NULL;
48 memcpy(ptr, s, len);
49 return ptr;
50}
51
52/**
53 * realloc which does nothing if the block is large enough
54 */
5c91a675 55void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
8e1e6f31
FB
56{
57 if(min_size < *size)
58 return ptr;
59
60 *size= min_size + 10*1024;
61
62 return av_realloc(ptr, *size);
63}
64
65
855ea723
ZK
66/* allocation of static arrays - do not use for normal allocation */
67static unsigned int last_static = 0;
68static char*** array_static = NULL;
69static const unsigned int grow_static = 64; // ^2
70void *__av_mallocz_static(void** location, unsigned int size)
71{
5c91a675 72 unsigned int l = (last_static + grow_static) & ~(grow_static - 1);
855ea723
ZK
73 void *ptr = av_mallocz(size);
74 if (!ptr)
75 return NULL;
76
77 if (location)
78 {
79 if (l > last_static)
8e1e6f31 80 array_static = av_realloc(array_static, l);
855ea723
ZK
81 array_static[last_static++] = (char**) location;
82 *location = ptr;
83 }
84 return ptr;
85}
86/* free all static arrays and reset pointers to 0 */
87void av_free_static()
88{
89 if (array_static)
90 {
91 unsigned i;
92 for (i = 0; i < last_static; i++)
93 {
8e1e6f31 94 av_free(*array_static[i]);
855ea723
ZK
95 *array_static[i] = NULL;
96 }
8e1e6f31 97 av_free(array_static);
855ea723
ZK
98 array_static = 0;
99 }
100 last_static = 0;
101}
102
4d7a0a05
FB
103/* cannot call it directly because of 'void **' casting is not automatic */
104void __av_freep(void **ptr)
105{
106 av_free(*ptr);
107 *ptr = NULL;
108}
109
de6d9b64
FB
110/* encoder management */
111AVCodec *first_avcodec;
112
113void register_avcodec(AVCodec *format)
114{
115 AVCodec **p;
116 p = &first_avcodec;
117 while (*p != NULL) p = &(*p)->next;
118 *p = format;
119 format->next = NULL;
120}
121
1e491e29
MN
122typedef struct DefaultPicOpaque{
123 int last_pic_num;
124 uint8_t *data[4];
125}DefaultPicOpaque;
126
492cd3a9 127int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
1e491e29
MN
128 int i;
129 const int width = s->width;
130 const int height= s->height;
131 DefaultPicOpaque *opaque;
4e00e76b
MN
132
133 assert(pic->data[0]==NULL);
134 assert(pic->type==0 || pic->type==FF_TYPE_INTERNAL);
1e491e29
MN
135
136 if(pic->opaque){
137 opaque= (DefaultPicOpaque *)pic->opaque;
138 for(i=0; i<3; i++)
139 pic->data[i]= opaque->data[i];
140
141// printf("get_buffer %X coded_pic_num:%d last:%d\n", pic->opaque, pic->coded_picture_number, opaque->last_pic_num);
142 pic->age= pic->coded_picture_number - opaque->last_pic_num;
143 opaque->last_pic_num= pic->coded_picture_number;
144//printf("age: %d %d %d\n", pic->age, c->picture_number, pic->coded_picture_number);
145 }else{
146 int align, h_chroma_shift, v_chroma_shift;
147 int w, h, pixel_size;
148
149 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
150
151 switch(s->pix_fmt){
152 case PIX_FMT_YUV422:
153 pixel_size=2;
154 break;
155 case PIX_FMT_RGB24:
156 case PIX_FMT_BGR24:
157 pixel_size=3;
158 break;
1e491e29
MN
159 case PIX_FMT_RGBA32:
160 pixel_size=4;
161 break;
162 default:
163 pixel_size=1;
164 }
165
166 if(s->codec_id==CODEC_ID_SVQ1) align=63;
167 else align=15;
168
169 w= (width +align)&~align;
170 h= (height+align)&~align;
171
172 if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
173 w+= EDGE_WIDTH*2;
174 h+= EDGE_WIDTH*2;
175 }
176
177 opaque= av_mallocz(sizeof(DefaultPicOpaque));
178 if(opaque==NULL) return -1;
179
180 pic->opaque= opaque;
181 opaque->last_pic_num= -256*256*256*64;
182
183 for(i=0; i<3; i++){
184 int h_shift= i==0 ? 0 : h_chroma_shift;
185 int v_shift= i==0 ? 0 : v_chroma_shift;
186
187 pic->linesize[i]= pixel_size*w>>h_shift;
188
189 pic->base[i]= av_mallocz((pic->linesize[i]*h>>v_shift)+16); //FIXME 16
190 if(pic->base[i]==NULL) return -1;
191
192 memset(pic->base[i], 128, pic->linesize[i]*h>>v_shift);
193
194 if(s->flags&CODEC_FLAG_EMU_EDGE)
4e00e76b 195 pic->data[i] = pic->base[i] + 16; //FIXME 16
1e491e29 196 else
4e00e76b 197 pic->data[i] = pic->base[i] + (pic->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift) + 16; //FIXME 16
1e491e29
MN
198
199 opaque->data[i]= pic->data[i];
200 }
201 pic->age= 256*256*256*64;
4e00e76b 202 pic->type= FF_BUFFER_TYPE_INTERNAL;
1e491e29
MN
203 }
204
205 return 0;
206}
207
492cd3a9 208void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
1e491e29
MN
209 int i;
210
4e00e76b
MN
211 assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
212
1e491e29
MN
213 for(i=0; i<3; i++)
214 pic->data[i]=NULL;
215//printf("R%X\n", pic->opaque);
216}
217
a33c7159
MN
218enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, enum PixelFormat * fmt){
219 return fmt[0];
220}
221
a949d72e 222void avcodec_get_context_defaults(AVCodecContext *s){
e8b62df6
MN
223 s->bit_rate= 800*1000;
224 s->bit_rate_tolerance= s->bit_rate*10;
a949d72e
MN
225 s->qmin= 2;
226 s->qmax= 31;
17a70fde
MN
227 s->mb_qmin= 2;
228 s->mb_qmax= 31;
a949d72e
MN
229 s->rc_eq= "tex^qComp";
230 s->qcompress= 0.5;
e8b62df6
MN
231 s->max_qdiff= 3;
232 s->b_quant_factor=1.25;
233 s->b_quant_offset=1.25;
b3a391e8 234 s->i_quant_factor=-0.8;
e8b62df6 235 s->i_quant_offset=0.0;
4d2858de 236 s->error_concealment= 3;
8d0e42ca 237 s->error_resilience= 1;
4d2858de 238 s->workaround_bugs= FF_BUG_AUTODETECT;
8d0e42ca
MN
239 s->frame_rate = 25 * FRAME_RATE_BASE;
240 s->gop_size= 50;
241 s->me_method= ME_EPZS;
1e491e29
MN
242 s->get_buffer= avcodec_default_get_buffer;
243 s->release_buffer= avcodec_default_release_buffer;
a33c7159 244 s->get_format= avcodec_default_get_format;
826f429a 245 s->me_subpel_quality=8;
a949d72e
MN
246}
247
248/**
249 * allocates a AVCodecContext and set it to defaults.
250 * this can be deallocated by simply calling free()
251 */
7ffbb60e 252AVCodecContext *avcodec_alloc_context(void){
a949d72e
MN
253 AVCodecContext *avctx= av_mallocz(sizeof(AVCodecContext));
254
255 if(avctx==NULL) return NULL;
256
257 avcodec_get_context_defaults(avctx);
258
259 return avctx;
260}
261
1e491e29 262/**
492cd3a9 263 * allocates a AVPFrame and set it to defaults.
1e491e29
MN
264 * this can be deallocated by simply calling free()
265 */
492cd3a9
MN
266AVFrame *avcodec_alloc_frame(void){
267 AVFrame *pic= av_mallocz(sizeof(AVFrame));
1e491e29
MN
268
269 return pic;
270}
271
de6d9b64
FB
272int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
273{
274 int ret;
275
276 avctx->codec = codec;
4cb3ca72 277 avctx->codec_id = codec->id;
de6d9b64 278 avctx->frame_number = 0;
0edf8a7a
PG
279 if (codec->priv_data_size > 0) {
280 avctx->priv_data = av_mallocz(codec->priv_data_size);
281 if (!avctx->priv_data)
282 return -ENOMEM;
283 } else {
284 avctx->priv_data = NULL;
285 }
de6d9b64
FB
286 ret = avctx->codec->init(avctx);
287 if (ret < 0) {
3123dd79 288 av_freep(&avctx->priv_data);
de6d9b64
FB
289 return ret;
290 }
291 return 0;
292}
293
0c1a9eda 294int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
de6d9b64
FB
295 const short *samples)
296{
297 int ret;
298
299 ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
300 avctx->frame_number++;
301 return ret;
302}
303
0c1a9eda 304int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
492cd3a9 305 const AVFrame *pict)
de6d9b64
FB
306{
307 int ret;
308
309 ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
6bb925f4
MN
310
311 emms_c(); //needed to avoid a emms_c() call before every return;
312
de6d9b64
FB
313 avctx->frame_number++;
314 return ret;
315}
316
317/* decode a frame. return -1 if error, otherwise return the number of
318 bytes used. If no frame could be decompressed, *got_picture_ptr is
319 zero. Otherwise, it is non zero */
492cd3a9 320int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
de6d9b64 321 int *got_picture_ptr,
0c1a9eda 322 uint8_t *buf, int buf_size)
de6d9b64
FB
323{
324 int ret;
1e491e29 325
de6d9b64
FB
326 ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
327 buf, buf_size);
6bb925f4
MN
328
329 emms_c(); //needed to avoid a emms_c() call before every return;
1e491e29 330
1cb0edb4
J
331 if (*got_picture_ptr)
332 avctx->frame_number++;
de6d9b64
FB
333 return ret;
334}
335
336/* decode an audio frame. return -1 if error, otherwise return the
337 *number of bytes used. If no frame could be decompressed,
338 *frame_size_ptr is zero. Otherwise, it is the decompressed frame
339 *size in BYTES. */
0c1a9eda 340int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples,
de6d9b64 341 int *frame_size_ptr,
0c1a9eda 342 uint8_t *buf, int buf_size)
de6d9b64
FB
343{
344 int ret;
345
346 ret = avctx->codec->decode(avctx, samples, frame_size_ptr,
347 buf, buf_size);
348 avctx->frame_number++;
349 return ret;
350}
351
352int avcodec_close(AVCodecContext *avctx)
353{
354 if (avctx->codec->close)
355 avctx->codec->close(avctx);
3123dd79 356 av_freep(&avctx->priv_data);
de6d9b64
FB
357 avctx->codec = NULL;
358 return 0;
359}
360
361AVCodec *avcodec_find_encoder(enum CodecID id)
362{
363 AVCodec *p;
364 p = first_avcodec;
365 while (p) {
366 if (p->encode != NULL && p->id == id)
367 return p;
368 p = p->next;
369 }
370 return NULL;
371}
372
98f3b098
A
373AVCodec *avcodec_find_encoder_by_name(const char *name)
374{
375 AVCodec *p;
376 p = first_avcodec;
377 while (p) {
378 if (p->encode != NULL && strcmp(name,p->name) == 0)
379 return p;
380 p = p->next;
381 }
382 return NULL;
383}
384
de6d9b64
FB
385AVCodec *avcodec_find_decoder(enum CodecID id)
386{
387 AVCodec *p;
388 p = first_avcodec;
389 while (p) {
390 if (p->decode != NULL && p->id == id)
391 return p;
392 p = p->next;
393 }
394 return NULL;
395}
396
397AVCodec *avcodec_find_decoder_by_name(const char *name)
398{
399 AVCodec *p;
400 p = first_avcodec;
401 while (p) {
402 if (p->decode != NULL && strcmp(name,p->name) == 0)
403 return p;
404 p = p->next;
405 }
406 return NULL;
407}
408
409AVCodec *avcodec_find(enum CodecID id)
410{
411 AVCodec *p;
412 p = first_avcodec;
413 while (p) {
414 if (p->id == id)
415 return p;
416 p = p->next;
417 }
418 return NULL;
419}
420
421void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
422{
423 const char *codec_name;
424 AVCodec *p;
425 char buf1[32];
623563c0 426 char channels_str[100];
a96b68b7 427 int bitrate;
de6d9b64
FB
428
429 if (encode)
430 p = avcodec_find_encoder(enc->codec_id);
431 else
432 p = avcodec_find_decoder(enc->codec_id);
433
434 if (p) {
435 codec_name = p->name;
436 } else if (enc->codec_name[0] != '\0') {
437 codec_name = enc->codec_name;
438 } else {
439 /* output avi tags */
440 if (enc->codec_type == CODEC_TYPE_VIDEO) {
441 snprintf(buf1, sizeof(buf1), "%c%c%c%c",
442 enc->codec_tag & 0xff,
443 (enc->codec_tag >> 8) & 0xff,
444 (enc->codec_tag >> 16) & 0xff,
445 (enc->codec_tag >> 24) & 0xff);
446 } else {
447 snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
448 }
449 codec_name = buf1;
450 }
451
452 switch(enc->codec_type) {
453 case CODEC_TYPE_VIDEO:
454 snprintf(buf, buf_size,
455 "Video: %s%s",
456 codec_name, enc->flags & CODEC_FLAG_HQ ? " (hq)" : "");
cf087595
FB
457 if (enc->codec_id == CODEC_ID_RAWVIDEO) {
458 snprintf(buf + strlen(buf), buf_size - strlen(buf),
459 ", %s",
9bbffbb1 460 avcodec_get_pix_fmt_name(enc->pix_fmt));
cf087595 461 }
de6d9b64
FB
462 if (enc->width) {
463 snprintf(buf + strlen(buf), buf_size - strlen(buf),
464 ", %dx%d, %0.2f fps",
465 enc->width, enc->height,
466 (float)enc->frame_rate / FRAME_RATE_BASE);
467 }
4bfad535
FB
468 if (encode) {
469 snprintf(buf + strlen(buf), buf_size - strlen(buf),
470 ", q=%d-%d", enc->qmin, enc->qmax);
471 }
a96b68b7 472 bitrate = enc->bit_rate;
de6d9b64
FB
473 break;
474 case CODEC_TYPE_AUDIO:
475 snprintf(buf, buf_size,
476 "Audio: %s",
477 codec_name);
e0d2714a
J
478 switch (enc->channels) {
479 case 1:
623563c0 480 strcpy(channels_str, "mono");
e0d2714a
J
481 break;
482 case 2:
623563c0 483 strcpy(channels_str, "stereo");
e0d2714a
J
484 break;
485 case 6:
623563c0 486 strcpy(channels_str, "5:1");
e0d2714a
J
487 break;
488 default:
489 sprintf(channels_str, "%d channels", enc->channels);
490 break;
491 }
de6d9b64
FB
492 if (enc->sample_rate) {
493 snprintf(buf + strlen(buf), buf_size - strlen(buf),
494 ", %d Hz, %s",
495 enc->sample_rate,
e0d2714a 496 channels_str);
de6d9b64 497 }
e0d2714a 498
a96b68b7
FB
499 /* for PCM codecs, compute bitrate directly */
500 switch(enc->codec_id) {
501 case CODEC_ID_PCM_S16LE:
502 case CODEC_ID_PCM_S16BE:
503 case CODEC_ID_PCM_U16LE:
504 case CODEC_ID_PCM_U16BE:
a190b7e9 505 bitrate = enc->sample_rate * enc->channels * 16;
a96b68b7
FB
506 break;
507 case CODEC_ID_PCM_S8:
508 case CODEC_ID_PCM_U8:
509 case CODEC_ID_PCM_ALAW:
510 case CODEC_ID_PCM_MULAW:
a190b7e9 511 bitrate = enc->sample_rate * enc->channels * 8;
a96b68b7
FB
512 break;
513 default:
514 bitrate = enc->bit_rate;
515 break;
516 }
de6d9b64
FB
517 break;
518 default:
b71472eb 519 av_abort();
de6d9b64 520 }
4bfad535
FB
521 if (encode) {
522 if (enc->flags & CODEC_FLAG_PASS1)
523 snprintf(buf + strlen(buf), buf_size - strlen(buf),
524 ", pass 1");
525 if (enc->flags & CODEC_FLAG_PASS2)
526 snprintf(buf + strlen(buf), buf_size - strlen(buf),
527 ", pass 2");
528 }
a96b68b7 529 if (bitrate != 0) {
de6d9b64 530 snprintf(buf + strlen(buf), buf_size - strlen(buf),
a96b68b7 531 ", %d kb/s", bitrate / 1000);
de6d9b64
FB
532 }
533}
534
156e5023
NK
535unsigned avcodec_version( void )
536{
537 return LIBAVCODEC_VERSION_INT;
538}
cf087595 539
8bceb6af
NK
540unsigned avcodec_build( void )
541{
542 return LIBAVCODEC_BUILD;
543}
544
de6d9b64
FB
545/* must be called before any other functions */
546void avcodec_init(void)
547{
0344cd0a
AB
548 static int inited = 0;
549
550 if (inited != 0)
551 return;
552 inited = 1;
553
c6af86c2 554 //dsputil_init();
de6d9b64
FB
555}
556
4e00e76b 557/* this can be called after seeking and before trying to decode the next keyframe */
1c2a8c7f
MN
558void avcodec_flush_buffers(AVCodecContext *avctx)
559{
4e00e76b 560 int i;
1c2a8c7f 561 MpegEncContext *s = avctx->priv_data;
4e00e76b
MN
562
563 switch(avctx->codec_id){
564 case CODEC_ID_MPEG1VIDEO:
565 case CODEC_ID_H263:
566 case CODEC_ID_RV10:
567 case CODEC_ID_MJPEG:
568 case CODEC_ID_MJPEGB:
569 case CODEC_ID_MPEG4:
570 case CODEC_ID_MSMPEG4V1:
571 case CODEC_ID_MSMPEG4V2:
572 case CODEC_ID_MSMPEG4V3:
573 case CODEC_ID_WMV1:
574 case CODEC_ID_WMV2:
575 case CODEC_ID_H263P:
576 case CODEC_ID_H263I:
577 case CODEC_ID_SVQ1:
578 for(i=0; i<MAX_PICTURE_COUNT; i++){
579 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
580 || s->picture[i].type == FF_BUFFER_TYPE_USER))
492cd3a9 581 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
87fb268f
ZK
582 }
583 s->last_picture.data[0] = s->next_picture.data[0] = NULL;
4e00e76b
MN
584 break;
585 default:
586 //FIXME
587 break;
588 }
1c2a8c7f
MN
589}
590
cd4af68a 591static int raw_encode_init(AVCodecContext *s)
de6d9b64
FB
592{
593 return 0;
594}
595
cd4af68a
ZK
596static int raw_decode_frame(AVCodecContext *avctx,
597 void *data, int *data_size,
0c1a9eda 598 uint8_t *buf, int buf_size)
de6d9b64
FB
599{
600 return -1;
601}
602
cd4af68a
ZK
603static int raw_encode_frame(AVCodecContext *avctx,
604 unsigned char *frame, int buf_size, void *data)
de6d9b64
FB
605{
606 return -1;
607}
608
de6d9b64
FB
609AVCodec rawvideo_codec = {
610 "rawvideo",
611 CODEC_TYPE_VIDEO,
612 CODEC_ID_RAWVIDEO,
613 0,
cd4af68a
ZK
614 raw_encode_init,
615 raw_encode_frame,
de6d9b64 616 NULL,
cd4af68a 617 raw_decode_frame,
de6d9b64 618};