doc fixes (forgot to commit)
[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);
2c19981a 134 assert(pic->type==0 || pic->type==FF_BUFFER_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++){
2c19981a
MN
184 const int h_shift= i==0 ? 0 : h_chroma_shift;
185 const int v_shift= i==0 ? 0 : v_chroma_shift;
1e491e29
MN
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)
b536d0aa 195 pic->data[i] = pic->base[i];
1e491e29 196 else
b536d0aa 197 pic->data[i] = pic->base[i] + (pic->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift);
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;
14bea432
MN
239 s->frame_rate_base= 1;
240 s->frame_rate = 25;
8d0e42ca
MN
241 s->gop_size= 50;
242 s->me_method= ME_EPZS;
1e491e29
MN
243 s->get_buffer= avcodec_default_get_buffer;
244 s->release_buffer= avcodec_default_release_buffer;
a33c7159 245 s->get_format= avcodec_default_get_format;
826f429a 246 s->me_subpel_quality=8;
1984f635
MN
247
248 s->intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
249 s->inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
a949d72e
MN
250}
251
252/**
253 * allocates a AVCodecContext and set it to defaults.
254 * this can be deallocated by simply calling free()
255 */
7ffbb60e 256AVCodecContext *avcodec_alloc_context(void){
a949d72e
MN
257 AVCodecContext *avctx= av_mallocz(sizeof(AVCodecContext));
258
259 if(avctx==NULL) return NULL;
260
261 avcodec_get_context_defaults(avctx);
262
263 return avctx;
264}
265
1e491e29 266/**
492cd3a9 267 * allocates a AVPFrame and set it to defaults.
1e491e29
MN
268 * this can be deallocated by simply calling free()
269 */
492cd3a9
MN
270AVFrame *avcodec_alloc_frame(void){
271 AVFrame *pic= av_mallocz(sizeof(AVFrame));
1e491e29
MN
272
273 return pic;
274}
275
de6d9b64
FB
276int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
277{
278 int ret;
279
280 avctx->codec = codec;
4cb3ca72 281 avctx->codec_id = codec->id;
de6d9b64 282 avctx->frame_number = 0;
0edf8a7a
PG
283 if (codec->priv_data_size > 0) {
284 avctx->priv_data = av_mallocz(codec->priv_data_size);
285 if (!avctx->priv_data)
286 return -ENOMEM;
287 } else {
288 avctx->priv_data = NULL;
289 }
de6d9b64
FB
290 ret = avctx->codec->init(avctx);
291 if (ret < 0) {
3123dd79 292 av_freep(&avctx->priv_data);
de6d9b64
FB
293 return ret;
294 }
295 return 0;
296}
297
0c1a9eda 298int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
de6d9b64
FB
299 const short *samples)
300{
301 int ret;
302
303 ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
304 avctx->frame_number++;
305 return ret;
306}
307
0c1a9eda 308int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
492cd3a9 309 const AVFrame *pict)
de6d9b64
FB
310{
311 int ret;
312
313 ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
6bb925f4
MN
314
315 emms_c(); //needed to avoid a emms_c() call before every return;
316
de6d9b64
FB
317 avctx->frame_number++;
318 return ret;
319}
320
321/* decode a frame. return -1 if error, otherwise return the number of
322 bytes used. If no frame could be decompressed, *got_picture_ptr is
323 zero. Otherwise, it is non zero */
492cd3a9 324int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
de6d9b64 325 int *got_picture_ptr,
0c1a9eda 326 uint8_t *buf, int buf_size)
de6d9b64
FB
327{
328 int ret;
1e491e29 329
de6d9b64
FB
330 ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
331 buf, buf_size);
6bb925f4
MN
332
333 emms_c(); //needed to avoid a emms_c() call before every return;
1e491e29 334
1cb0edb4
J
335 if (*got_picture_ptr)
336 avctx->frame_number++;
de6d9b64
FB
337 return ret;
338}
339
340/* decode an audio frame. return -1 if error, otherwise return the
341 *number of bytes used. If no frame could be decompressed,
342 *frame_size_ptr is zero. Otherwise, it is the decompressed frame
343 *size in BYTES. */
0c1a9eda 344int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples,
de6d9b64 345 int *frame_size_ptr,
0c1a9eda 346 uint8_t *buf, int buf_size)
de6d9b64
FB
347{
348 int ret;
349
350 ret = avctx->codec->decode(avctx, samples, frame_size_ptr,
351 buf, buf_size);
352 avctx->frame_number++;
353 return ret;
354}
355
356int avcodec_close(AVCodecContext *avctx)
357{
358 if (avctx->codec->close)
359 avctx->codec->close(avctx);
3123dd79 360 av_freep(&avctx->priv_data);
de6d9b64
FB
361 avctx->codec = NULL;
362 return 0;
363}
364
365AVCodec *avcodec_find_encoder(enum CodecID id)
366{
367 AVCodec *p;
368 p = first_avcodec;
369 while (p) {
370 if (p->encode != NULL && p->id == id)
371 return p;
372 p = p->next;
373 }
374 return NULL;
375}
376
98f3b098
A
377AVCodec *avcodec_find_encoder_by_name(const char *name)
378{
379 AVCodec *p;
380 p = first_avcodec;
381 while (p) {
382 if (p->encode != NULL && strcmp(name,p->name) == 0)
383 return p;
384 p = p->next;
385 }
386 return NULL;
387}
388
de6d9b64
FB
389AVCodec *avcodec_find_decoder(enum CodecID id)
390{
391 AVCodec *p;
392 p = first_avcodec;
393 while (p) {
394 if (p->decode != NULL && p->id == id)
395 return p;
396 p = p->next;
397 }
398 return NULL;
399}
400
401AVCodec *avcodec_find_decoder_by_name(const char *name)
402{
403 AVCodec *p;
404 p = first_avcodec;
405 while (p) {
406 if (p->decode != NULL && strcmp(name,p->name) == 0)
407 return p;
408 p = p->next;
409 }
410 return NULL;
411}
412
413AVCodec *avcodec_find(enum CodecID id)
414{
415 AVCodec *p;
416 p = first_avcodec;
417 while (p) {
418 if (p->id == id)
419 return p;
420 p = p->next;
421 }
422 return NULL;
423}
424
425void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
426{
427 const char *codec_name;
428 AVCodec *p;
429 char buf1[32];
623563c0 430 char channels_str[100];
a96b68b7 431 int bitrate;
de6d9b64
FB
432
433 if (encode)
434 p = avcodec_find_encoder(enc->codec_id);
435 else
436 p = avcodec_find_decoder(enc->codec_id);
437
438 if (p) {
439 codec_name = p->name;
440 } else if (enc->codec_name[0] != '\0') {
441 codec_name = enc->codec_name;
442 } else {
443 /* output avi tags */
444 if (enc->codec_type == CODEC_TYPE_VIDEO) {
445 snprintf(buf1, sizeof(buf1), "%c%c%c%c",
446 enc->codec_tag & 0xff,
447 (enc->codec_tag >> 8) & 0xff,
448 (enc->codec_tag >> 16) & 0xff,
449 (enc->codec_tag >> 24) & 0xff);
450 } else {
451 snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
452 }
453 codec_name = buf1;
454 }
455
456 switch(enc->codec_type) {
457 case CODEC_TYPE_VIDEO:
458 snprintf(buf, buf_size,
459 "Video: %s%s",
460 codec_name, enc->flags & CODEC_FLAG_HQ ? " (hq)" : "");
cf087595
FB
461 if (enc->codec_id == CODEC_ID_RAWVIDEO) {
462 snprintf(buf + strlen(buf), buf_size - strlen(buf),
463 ", %s",
9bbffbb1 464 avcodec_get_pix_fmt_name(enc->pix_fmt));
cf087595 465 }
de6d9b64
FB
466 if (enc->width) {
467 snprintf(buf + strlen(buf), buf_size - strlen(buf),
468 ", %dx%d, %0.2f fps",
469 enc->width, enc->height,
14bea432 470 (float)enc->frame_rate / enc->frame_rate_base);
de6d9b64 471 }
4bfad535
FB
472 if (encode) {
473 snprintf(buf + strlen(buf), buf_size - strlen(buf),
474 ", q=%d-%d", enc->qmin, enc->qmax);
475 }
a96b68b7 476 bitrate = enc->bit_rate;
de6d9b64
FB
477 break;
478 case CODEC_TYPE_AUDIO:
479 snprintf(buf, buf_size,
480 "Audio: %s",
481 codec_name);
e0d2714a
J
482 switch (enc->channels) {
483 case 1:
623563c0 484 strcpy(channels_str, "mono");
e0d2714a
J
485 break;
486 case 2:
623563c0 487 strcpy(channels_str, "stereo");
e0d2714a
J
488 break;
489 case 6:
623563c0 490 strcpy(channels_str, "5:1");
e0d2714a
J
491 break;
492 default:
493 sprintf(channels_str, "%d channels", enc->channels);
494 break;
495 }
de6d9b64
FB
496 if (enc->sample_rate) {
497 snprintf(buf + strlen(buf), buf_size - strlen(buf),
498 ", %d Hz, %s",
499 enc->sample_rate,
e0d2714a 500 channels_str);
de6d9b64 501 }
e0d2714a 502
a96b68b7
FB
503 /* for PCM codecs, compute bitrate directly */
504 switch(enc->codec_id) {
505 case CODEC_ID_PCM_S16LE:
506 case CODEC_ID_PCM_S16BE:
507 case CODEC_ID_PCM_U16LE:
508 case CODEC_ID_PCM_U16BE:
a190b7e9 509 bitrate = enc->sample_rate * enc->channels * 16;
a96b68b7
FB
510 break;
511 case CODEC_ID_PCM_S8:
512 case CODEC_ID_PCM_U8:
513 case CODEC_ID_PCM_ALAW:
514 case CODEC_ID_PCM_MULAW:
a190b7e9 515 bitrate = enc->sample_rate * enc->channels * 8;
a96b68b7
FB
516 break;
517 default:
518 bitrate = enc->bit_rate;
519 break;
520 }
de6d9b64
FB
521 break;
522 default:
b71472eb 523 av_abort();
de6d9b64 524 }
4bfad535
FB
525 if (encode) {
526 if (enc->flags & CODEC_FLAG_PASS1)
527 snprintf(buf + strlen(buf), buf_size - strlen(buf),
528 ", pass 1");
529 if (enc->flags & CODEC_FLAG_PASS2)
530 snprintf(buf + strlen(buf), buf_size - strlen(buf),
531 ", pass 2");
532 }
a96b68b7 533 if (bitrate != 0) {
de6d9b64 534 snprintf(buf + strlen(buf), buf_size - strlen(buf),
a96b68b7 535 ", %d kb/s", bitrate / 1000);
de6d9b64
FB
536 }
537}
538
156e5023
NK
539unsigned avcodec_version( void )
540{
541 return LIBAVCODEC_VERSION_INT;
542}
cf087595 543
8bceb6af
NK
544unsigned avcodec_build( void )
545{
546 return LIBAVCODEC_BUILD;
547}
548
de6d9b64
FB
549/* must be called before any other functions */
550void avcodec_init(void)
551{
0344cd0a
AB
552 static int inited = 0;
553
554 if (inited != 0)
555 return;
556 inited = 1;
557
59cf08ce 558 dsputil_static_init();
de6d9b64
FB
559}
560
4e00e76b 561/* this can be called after seeking and before trying to decode the next keyframe */
1c2a8c7f
MN
562void avcodec_flush_buffers(AVCodecContext *avctx)
563{
4e00e76b 564 int i;
1c2a8c7f 565 MpegEncContext *s = avctx->priv_data;
4e00e76b
MN
566
567 switch(avctx->codec_id){
568 case CODEC_ID_MPEG1VIDEO:
569 case CODEC_ID_H263:
570 case CODEC_ID_RV10:
571 case CODEC_ID_MJPEG:
572 case CODEC_ID_MJPEGB:
573 case CODEC_ID_MPEG4:
574 case CODEC_ID_MSMPEG4V1:
575 case CODEC_ID_MSMPEG4V2:
576 case CODEC_ID_MSMPEG4V3:
577 case CODEC_ID_WMV1:
578 case CODEC_ID_WMV2:
579 case CODEC_ID_H263P:
580 case CODEC_ID_H263I:
581 case CODEC_ID_SVQ1:
582 for(i=0; i<MAX_PICTURE_COUNT; i++){
583 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
584 || s->picture[i].type == FF_BUFFER_TYPE_USER))
492cd3a9 585 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
87fb268f 586 }
b536d0aa 587 s->last_picture_ptr = s->next_picture_ptr = NULL;
4e00e76b
MN
588 break;
589 default:
590 //FIXME
591 break;
592 }
1c2a8c7f
MN
593}
594
14bea432
MN
595int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max){
596 int exact=1, sign=0;
597 int64_t gcd, larger;
598
599 assert(den != 0);
600
601 if(den < 0){
602 den= -den;
603 nom= -nom;
604 }
605
606 if(nom < 0){
607 nom= -nom;
608 sign= 1;
609 }
610
611 for(;;){ //note is executed 1 or 2 times
612 gcd = ff_gcd(nom, den);
613 nom /= gcd;
614 den /= gcd;
615
616 larger= FFMAX(nom, den);
617
618 if(larger > max){
619 int64_t div= (larger + max - 1) / max;
620 nom = (nom + div/2)/div;
621 den = (den + div/2)/div;
622 exact=0;
623 }else
624 break;
625 }
626
627 if(sign) nom= -nom;
628
629 *dst_nom = nom;
630 *dst_den = den;
631
632 return exact;
633}
634
635int64_t av_rescale(int64_t a, int b, int c){
636 uint64_t h, l;
637 assert(c > 0);
638 assert(b >=0);
639
640 if(a<0) return -av_rescale(-a, b, c);
641
642 h= a>>32;
643 if(h==0) return a*b/c;
644
645 l= a&0xFFFFFFFF;
646 l *= b;
647 h *= b;
648
649 l += (h%c)<<32;
650
651 return ((h/c)<<32) + l/c;
652}