git.sesse.net Git - ffmpeg/blob - libavcodec/utils.c

   1 /*
   2  * utils for libavcodec
   3  * Copyright (c) 2001 Fabrice Bellard.
   4  * Copyright (c) 2003 Michel Bardiaux for the av_log API
   5  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /**
  23  * @file utils.c
  24  * utils.
  25  */
  26
  27 #include "avcodec.h"
  28 #include "dsputil.h"
  29 #include "mpegvideo.h"
  30 #include "integer.h"
  31 #include <stdarg.h>
  32 #include <limits.h>
  33
  34 const uint8_t ff_sqrt_tab[128]={
  35         0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
  36         5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  37         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
  38         9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11
  39 };
  40
  41 const uint8_t ff_log2_tab[256]={
  42         0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
  43         5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
  44         6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
  45         6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
  46         7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  47         7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  48         7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  49         7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
  50 };
  51
  52 const uint8_t ff_reverse[256]={
  53 0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
  54 0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
  55 0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
  56 0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
  57 0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
  58 0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
  59 0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
  60 0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
  61 0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
  62 0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
  63 0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
  64 0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
  65 0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
  66 0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
  67 0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
  68 0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
  69 };
  70
  71 void avcodec_default_free_buffers(AVCodecContext *s);
  72
  73 void *av_mallocz(unsigned int size)
  74 {
  75     void *ptr;
  76
  77     ptr = av_malloc(size);
  78     if (!ptr)
  79         return NULL;
  80     memset(ptr, 0, size);
  81     return ptr;
  82 }
  83
  84 char *av_strdup(const char *s)
  85 {
  86     char *ptr;
  87     int len;
  88     len = strlen(s) + 1;
  89     ptr = av_malloc(len);
  90     if (!ptr)
  91         return NULL;
  92     memcpy(ptr, s, len);
  93     return ptr;
  94 }
  95
  96 /**
  97  * realloc which does nothing if the block is large enough
  98  */
  99 void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
 100 {
 101     if(min_size < *size)
 102         return ptr;
 103
 104     *size= FFMAX(17*min_size/16 + 32, min_size);
 105
 106     return av_realloc(ptr, *size);
 107 }
 108
 109
 110 static unsigned int last_static = 0;
 111 static unsigned int allocated_static = 0;
 112 static void** array_static = NULL;
 113
 114 /**
 115  * allocation of static arrays - do not use for normal allocation.
 116  */
 117 void *av_mallocz_static(unsigned int size)
 118 {
 119     void *ptr = av_mallocz(size);
 120
 121     if(ptr){
 122         array_static =av_fast_realloc(array_static, &allocated_static, sizeof(void*)*(last_static+1));
 123         if(!array_static)
 124             return NULL;
 125         array_static[last_static++] = ptr;
 126     }
 127
 128     return ptr;
 129 }
 130
 131 /**
 132  * same as above, but does realloc
 133  */
 134
 135 void *av_realloc_static(void *ptr, unsigned int size)
 136 {
 137     int i;
 138     if(!ptr)
 139       return av_mallocz_static(size);
 140     /* Look for the old ptr */
 141     for(i = 0; i < last_static; i++) {
 142         if(array_static[i] == ptr) {
 143             array_static[i] = av_realloc(array_static[i], size);
 144             return array_static[i];
 145         }
 146     }
 147     return NULL;
 148
 149 }
 150
 151 /**
 152  * free all static arrays and reset pointers to 0.
 153  */
 154 void av_free_static(void)
 155 {
 156     while(last_static){
 157         av_freep(&array_static[--last_static]);
 158     }
 159     av_freep(&array_static);
 160 }
 161
 162 /**
 163  * Frees memory and sets the pointer to NULL.
 164  * @param arg pointer to the pointer which should be freed
 165  */
 166 void av_freep(void *arg)
 167 {
 168     void **ptr= (void**)arg;
 169     av_free(*ptr);
 170     *ptr = NULL;
 171 }
 172
 173 /* encoder management */
 174 AVCodec *first_avcodec = NULL;
 175
 176 void register_avcodec(AVCodec *format)
 177 {
 178     AVCodec **p;
 179     p = &first_avcodec;
 180     while (*p != NULL) p = &(*p)->next;
 181     *p = format;
 182     format->next = NULL;
 183 }
 184
 185 void avcodec_set_dimensions(AVCodecContext *s, int width, int height){
 186     s->coded_width = width;
 187     s->coded_height= height;
 188     s->width = -((-width )>>s->lowres);
 189     s->height= -((-height)>>s->lowres);
 190 }
 191
 192 typedef struct InternalBuffer{
 193     int last_pic_num;
 194     uint8_t *base[4];
 195     uint8_t *data[4];
 196     int linesize[4];
 197 }InternalBuffer;
 198
 199 #define INTERNAL_BUFFER_SIZE 32
 200
 201 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
 202
 203 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
 204     int w_align= 1;
 205     int h_align= 1;
 206
 207     switch(s->pix_fmt){
 208     case PIX_FMT_YUV420P:
 209     case PIX_FMT_YUV422:
 210     case PIX_FMT_UYVY422:
 211     case PIX_FMT_YUV422P:
 212     case PIX_FMT_YUV444P:
 213     case PIX_FMT_GRAY8:
 214     case PIX_FMT_YUVJ420P:
 215     case PIX_FMT_YUVJ422P:
 216     case PIX_FMT_YUVJ444P:
 217         w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
 218         h_align= 16;
 219         break;
 220     case PIX_FMT_YUV411P:
 221     case PIX_FMT_UYVY411:
 222         w_align=32;
 223         h_align=8;
 224         break;
 225     case PIX_FMT_YUV410P:
 226         if(s->codec_id == CODEC_ID_SVQ1){
 227             w_align=64;
 228             h_align=64;
 229         }
 230     case PIX_FMT_RGB555:
 231         if(s->codec_id == CODEC_ID_RPZA){
 232             w_align=4;
 233             h_align=4;
 234         }
 235     case PIX_FMT_PAL8:
 236         if(s->codec_id == CODEC_ID_SMC){
 237             w_align=4;
 238             h_align=4;
 239         }
 240         break;
 241     case PIX_FMT_BGR24:
 242         if((s->codec_id == CODEC_ID_MSZH) || (s->codec_id == CODEC_ID_ZLIB)){
 243             w_align=4;
 244             h_align=4;
 245         }
 246         break;
 247     default:
 248         w_align= 1;
 249         h_align= 1;
 250         break;
 251     }
 252
 253     *width = ALIGN(*width , w_align);
 254     *height= ALIGN(*height, h_align);
 255 }
 256
 257 int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h){
 258     if((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/4)
 259         return 0;
 260
 261     av_log(av_log_ctx, AV_LOG_ERROR, "picture size invalid (%ux%u)\n", w, h);
 262     return -1;
 263 }
 264
 265 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
 266     int i;
 267     int w= s->width;
 268     int h= s->height;
 269     InternalBuffer *buf;
 270     int *picture_number;
 271
 272     assert(pic->data[0]==NULL);
 273     assert(INTERNAL_BUFFER_SIZE > s->internal_buffer_count);
 274
 275     if(avcodec_check_dimensions(s,w,h))
 276         return -1;
 277
 278     if(s->internal_buffer==NULL){
 279         s->internal_buffer= av_mallocz(INTERNAL_BUFFER_SIZE*sizeof(InternalBuffer));
 280     }
 281 #if 0
 282     s->internal_buffer= av_fast_realloc(
 283         s->internal_buffer,
 284         &s->internal_buffer_size,
 285         sizeof(InternalBuffer)*FFMAX(99,  s->internal_buffer_count+1)/*FIXME*/
 286         );
 287 #endif
 288
 289     buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
 290     picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE-1]).last_pic_num; //FIXME ugly hack
 291     (*picture_number)++;
 292
 293     if(buf->base[0]){
 294         pic->age= *picture_number - buf->last_pic_num;
 295         buf->last_pic_num= *picture_number;
 296     }else{
 297         int h_chroma_shift, v_chroma_shift;
 298         int pixel_size;
 299
 300         avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
 301
 302         switch(s->pix_fmt){
 303         case PIX_FMT_RGB555:
 304         case PIX_FMT_RGB565:
 305         case PIX_FMT_YUV422:
 306         case PIX_FMT_UYVY422:
 307             pixel_size=2;
 308             break;
 309         case PIX_FMT_RGB24:
 310         case PIX_FMT_BGR24:
 311             pixel_size=3;
 312             break;
 313         case PIX_FMT_RGBA32:
 314             pixel_size=4;
 315             break;
 316         default:
 317             pixel_size=1;
 318         }
 319
 320         avcodec_align_dimensions(s, &w, &h);
 321
 322         if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
 323             w+= EDGE_WIDTH*2;
 324             h+= EDGE_WIDTH*2;
 325         }
 326
 327         buf->last_pic_num= -256*256*256*64;
 328
 329         for(i=0; i<3; i++){
 330             const int h_shift= i==0 ? 0 : h_chroma_shift;
 331             const int v_shift= i==0 ? 0 : v_chroma_shift;
 332
 333             //FIXME next ensures that linesize= 2^x uvlinesize, thats needed because some MC code assumes it
 334             buf->linesize[i]= ALIGN(pixel_size*w>>h_shift, STRIDE_ALIGN<<(h_chroma_shift-h_shift));
 335
 336             buf->base[i]= av_malloc((buf->linesize[i]*h>>v_shift)+16); //FIXME 16
 337             if(buf->base[i]==NULL) return -1;
 338             memset(buf->base[i], 128, buf->linesize[i]*h>>v_shift);
 339
 340             if(s->flags&CODEC_FLAG_EMU_EDGE)
 341                 buf->data[i] = buf->base[i];
 342             else
 343                 buf->data[i] = buf->base[i] + ALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), STRIDE_ALIGN);
 344         }
 345         pic->age= 256*256*256*64;
 346     }
 347     pic->type= FF_BUFFER_TYPE_INTERNAL;
 348
 349     for(i=0; i<4; i++){
 350         pic->base[i]= buf->base[i];
 351         pic->data[i]= buf->data[i];
 352         pic->linesize[i]= buf->linesize[i];
 353     }
 354     s->internal_buffer_count++;
 355
 356     return 0;
 357 }
 358
 359 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
 360     int i;
 361     InternalBuffer *buf, *last, temp;
 362
 363     assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
 364     assert(s->internal_buffer_count);
 365
 366     buf = NULL; /* avoids warning */
 367     for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
 368         buf= &((InternalBuffer*)s->internal_buffer)[i];
 369         if(buf->data[0] == pic->data[0])
 370             break;
 371     }
 372     assert(i < s->internal_buffer_count);
 373     s->internal_buffer_count--;
 374     last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
 375
 376     temp= *buf;
 377     *buf= *last;
 378     *last= temp;
 379
 380     for(i=0; i<3; i++){
 381         pic->data[i]=NULL;
 382 //        pic->base[i]=NULL;
 383     }
 384 //printf("R%X\n", pic->opaque);
 385 }
 386
 387 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
 388     AVFrame temp_pic;
 389     int i;
 390
 391     /* If no picture return a new buffer */
 392     if(pic->data[0] == NULL) {
 393         /* We will copy from buffer, so must be readable */
 394         pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
 395         return s->get_buffer(s, pic);
 396     }
 397
 398     /* If internal buffer type return the same buffer */
 399     if(pic->type == FF_BUFFER_TYPE_INTERNAL)
 400         return 0;
 401
 402     /*
 403      * Not internal type and reget_buffer not overridden, emulate cr buffer
 404      */
 405     temp_pic = *pic;
 406     for(i = 0; i < 4; i++)
 407         pic->data[i] = pic->base[i] = NULL;
 408     pic->opaque = NULL;
 409     /* Allocate new frame */
 410     if (s->get_buffer(s, pic))
 411         return -1;
 412     /* Copy image data from old buffer to new buffer */
 413     img_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width,
 414              s->height);
 415     s->release_buffer(s, &temp_pic); // Release old frame
 416     return 0;
 417 }
 418
 419 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count){
 420     int i;
 421
 422     for(i=0; i<count; i++){
 423         int r= func(c, arg[i]);
 424         if(ret) ret[i]= r;
 425     }
 426     return 0;
 427 }
 428
 429 enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt){
 430     return fmt[0];
 431 }
 432
 433 static const char* context_to_name(void* ptr) {
 434     AVCodecContext *avc= ptr;
 435
 436     if(avc && avc->codec && avc->codec->name)
 437         return avc->codec->name;
 438     else
 439         return "NULL";
 440 }
 441
 442 static AVClass av_codec_context_class = { "AVCodecContext", context_to_name };
 443
 444 void avcodec_get_context_defaults(AVCodecContext *s){
 445     memset(s, 0, sizeof(AVCodecContext));
 446
 447     s->av_class= &av_codec_context_class;
 448     s->bit_rate= 800*1000;
 449     s->bit_rate_tolerance= s->bit_rate*10;
 450     s->qmin= 2;
 451     s->qmax= 31;
 452     s->mb_lmin= FF_QP2LAMBDA * 2;
 453     s->mb_lmax= FF_QP2LAMBDA * 31;
 454     s->rc_eq= "tex^qComp";
 455     s->qcompress= 0.5;
 456     s->max_qdiff= 3;
 457     s->b_quant_factor=1.25;
 458     s->b_quant_offset=1.25;
 459     s->i_quant_factor=-0.8;
 460     s->i_quant_offset=0.0;
 461     s->error_concealment= 3;
 462     s->error_resilience= 1;
 463     s->workaround_bugs= FF_BUG_AUTODETECT;
 464     s->time_base= (AVRational){0,1};
 465     s->gop_size= 50;
 466     s->me_method= ME_EPZS;
 467     s->get_buffer= avcodec_default_get_buffer;
 468     s->release_buffer= avcodec_default_release_buffer;
 469     s->get_format= avcodec_default_get_format;
 470     s->execute= avcodec_default_execute;
 471     s->thread_count=1;
 472     s->me_subpel_quality=8;
 473     s->lmin= FF_QP2LAMBDA * s->qmin;
 474     s->lmax= FF_QP2LAMBDA * s->qmax;
 475     s->sample_aspect_ratio= (AVRational){0,1};
 476     s->ildct_cmp= FF_CMP_VSAD;
 477     s->profile= FF_PROFILE_UNKNOWN;
 478     s->level= FF_LEVEL_UNKNOWN;
 479     s->me_penalty_compensation= 256;
 480     s->pix_fmt= PIX_FMT_NONE;
 481
 482     s->intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
 483     s->inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
 484     s->palctrl = NULL;
 485     s->reget_buffer= avcodec_default_reget_buffer;
 486 }
 487
 488 /**
 489  * allocates a AVCodecContext and set it to defaults.
 490  * this can be deallocated by simply calling free()
 491  */
 492 AVCodecContext *avcodec_alloc_context(void){
 493     AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
 494
 495     if(avctx==NULL) return NULL;
 496
 497     avcodec_get_context_defaults(avctx);
 498
 499     return avctx;
 500 }
 501
 502 void avcodec_get_frame_defaults(AVFrame *pic){
 503     memset(pic, 0, sizeof(AVFrame));
 504
 505     pic->pts= AV_NOPTS_VALUE;
 506     pic->key_frame= 1;
 507 }
 508
 509 /**
 510  * allocates a AVPFrame and set it to defaults.
 511  * this can be deallocated by simply calling free()
 512  */
 513 AVFrame *avcodec_alloc_frame(void){
 514     AVFrame *pic= av_malloc(sizeof(AVFrame));
 515
 516     if(pic==NULL) return NULL;
 517
 518     avcodec_get_frame_defaults(pic);
 519
 520     return pic;
 521 }
 522
 523 int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
 524 {
 525     int ret;
 526
 527     if(avctx->codec)
 528         return -1;
 529
 530     avctx->codec = codec;
 531     avctx->codec_id = codec->id;
 532     avctx->frame_number = 0;
 533     if (codec->priv_data_size > 0) {
 534         avctx->priv_data = av_mallocz(codec->priv_data_size);
 535         if (!avctx->priv_data)
 536             return -ENOMEM;
 537     } else {
 538         avctx->priv_data = NULL;
 539     }
 540
 541     if(avctx->coded_width && avctx->coded_height)
 542         avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
 543     else if(avctx->width && avctx->height)
 544         avcodec_set_dimensions(avctx, avctx->width, avctx->height);
 545
 546     if((avctx->coded_width||avctx->coded_height) && avcodec_check_dimensions(avctx,avctx->coded_width,avctx->coded_height)){
 547         av_freep(&avctx->priv_data);
 548         return -1;
 549     }
 550
 551     ret = avctx->codec->init(avctx);
 552     if (ret < 0) {
 553         av_freep(&avctx->priv_data);
 554         return ret;
 555     }
 556     return 0;
 557 }
 558
 559 int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 560                          const short *samples)
 561 {
 562     if(buf_size < FF_MIN_BUFFER_SIZE && 0){
 563         av_log(avctx, AV_LOG_ERROR, "buffer smaller then minimum size\n");
 564         return -1;
 565     }
 566     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){
 567         int ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
 568         avctx->frame_number++;
 569         return ret;
 570     }else
 571         return 0;
 572 }
 573
 574 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 575                          const AVFrame *pict)
 576 {
 577     if(buf_size < FF_MIN_BUFFER_SIZE){
 578         av_log(avctx, AV_LOG_ERROR, "buffer smaller then minimum size\n");
 579         return -1;
 580     }
 581     if(avcodec_check_dimensions(avctx,avctx->width,avctx->height))
 582         return -1;
 583     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || pict){
 584         int ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
 585         avctx->frame_number++;
 586         emms_c(); //needed to avoid a emms_c() call before every return;
 587
 588         return ret;
 589     }else
 590         return 0;
 591 }
 592
 593 /**
 594  * decode a frame.
 595  * @param buf bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE larger then the actual read bytes
 596  * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
 597  * @param buf_size the size of the buffer in bytes
 598  * @param got_picture_ptr zero if no frame could be decompressed, Otherwise, it is non zero
 599  * @return -1 if error, otherwise return the number of
 600  * bytes used.
 601  */
 602 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
 603                          int *got_picture_ptr,
 604                          uint8_t *buf, int buf_size)
 605 {
 606     int ret;
 607
 608     *got_picture_ptr= 0;
 609     if((avctx->coded_width||avctx->coded_height) && avcodec_check_dimensions(avctx,avctx->coded_width,avctx->coded_height))
 610         return -1;
 611     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || buf_size){
 612         ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
 613                                 buf, buf_size);
 614
 615         emms_c(); //needed to avoid a emms_c() call before every return;
 616
 617         if (*got_picture_ptr)
 618             avctx->frame_number++;
 619     }else
 620         ret= 0;
 621
 622     return ret;
 623 }
 624
 625 /* decode an audio frame. return -1 if error, otherwise return the
 626    *number of bytes used. If no frame could be decompressed,
 627    *frame_size_ptr is zero. Otherwise, it is the decompressed frame
 628    *size in BYTES. */
 629 int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples,
 630                          int *frame_size_ptr,
 631                          uint8_t *buf, int buf_size)
 632 {
 633     int ret;
 634
 635     *frame_size_ptr= 0;
 636     ret = avctx->codec->decode(avctx, samples, frame_size_ptr,
 637                                buf, buf_size);
 638     avctx->frame_number++;
 639     return ret;
 640 }
 641
 642 int avcodec_close(AVCodecContext *avctx)
 643 {
 644     if (avctx->codec->close)
 645         avctx->codec->close(avctx);
 646     avcodec_default_free_buffers(avctx);
 647     av_freep(&avctx->priv_data);
 648     avctx->codec = NULL;
 649     return 0;
 650 }
 651
 652 AVCodec *avcodec_find_encoder(enum CodecID id)
 653 {
 654     AVCodec *p;
 655     p = first_avcodec;
 656     while (p) {
 657         if (p->encode != NULL && p->id == id)
 658             return p;
 659         p = p->next;
 660     }
 661     return NULL;
 662 }
 663
 664 AVCodec *avcodec_find_encoder_by_name(const char *name)
 665 {
 666     AVCodec *p;
 667     p = first_avcodec;
 668     while (p) {
 669         if (p->encode != NULL && strcmp(name,p->name) == 0)
 670             return p;
 671         p = p->next;
 672     }
 673     return NULL;
 674 }
 675
 676 AVCodec *avcodec_find_decoder(enum CodecID id)
 677 {
 678     AVCodec *p;
 679     p = first_avcodec;
 680     while (p) {
 681         if (p->decode != NULL && p->id == id)
 682             return p;
 683         p = p->next;
 684     }
 685     return NULL;
 686 }
 687
 688 AVCodec *avcodec_find_decoder_by_name(const char *name)
 689 {
 690     AVCodec *p;
 691     p = first_avcodec;
 692     while (p) {
 693         if (p->decode != NULL && strcmp(name,p->name) == 0)
 694             return p;
 695         p = p->next;
 696     }
 697     return NULL;
 698 }
 699
 700 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
 701 {
 702     const char *codec_name;
 703     AVCodec *p;
 704     char buf1[32];
 705     char channels_str[100];
 706     int bitrate;
 707
 708     if (encode)
 709         p = avcodec_find_encoder(enc->codec_id);
 710     else
 711         p = avcodec_find_decoder(enc->codec_id);
 712
 713     if (p) {
 714         codec_name = p->name;
 715         if (!encode && enc->codec_id == CODEC_ID_MP3) {
 716             if (enc->sub_id == 2)
 717                 codec_name = "mp2";
 718             else if (enc->sub_id == 1)
 719                 codec_name = "mp1";
 720         }
 721     } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
 722         /* fake mpeg2 transport stream codec (currently not
 723            registered) */
 724         codec_name = "mpeg2ts";
 725     } else if (enc->codec_name[0] != '\0') {
 726         codec_name = enc->codec_name;
 727     } else {
 728         /* output avi tags */
 729         if (enc->codec_type == CODEC_TYPE_VIDEO) {
 730             snprintf(buf1, sizeof(buf1), "%c%c%c%c",
 731                      enc->codec_tag & 0xff,
 732                      (enc->codec_tag >> 8) & 0xff,
 733                      (enc->codec_tag >> 16) & 0xff,
 734                      (enc->codec_tag >> 24) & 0xff);
 735         } else {
 736             snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
 737         }
 738         codec_name = buf1;
 739     }
 740
 741     switch(enc->codec_type) {
 742     case CODEC_TYPE_VIDEO:
 743         snprintf(buf, buf_size,
 744                  "Video: %s%s",
 745                  codec_name, enc->mb_decision ? " (hq)" : "");
 746         if (enc->pix_fmt != PIX_FMT_NONE) {
 747             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 748                      ", %s",
 749                      avcodec_get_pix_fmt_name(enc->pix_fmt));
 750         }
 751         if (enc->width) {
 752             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 753                      ", %dx%d, %0.2f fps",
 754                      enc->width, enc->height,
 755                      1/av_q2d(enc->time_base));
 756         }
 757         if (encode) {
 758             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 759                      ", q=%d-%d", enc->qmin, enc->qmax);
 760         }
 761         bitrate = enc->bit_rate;
 762         break;
 763     case CODEC_TYPE_AUDIO:
 764         snprintf(buf, buf_size,
 765                  "Audio: %s",
 766                  codec_name);
 767         switch (enc->channels) {
 768             case 1:
 769                 strcpy(channels_str, "mono");
 770                 break;
 771             case 2:
 772                 strcpy(channels_str, "stereo");
 773                 break;
 774             case 6:
 775                 strcpy(channels_str, "5:1");
 776                 break;
 777             default:
 778                 snprintf(channels_str, sizeof(channels_str), "%d channels", enc->channels);
 779                 break;
 780         }
 781         if (enc->sample_rate) {
 782             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 783                      ", %d Hz, %s",
 784                      enc->sample_rate,
 785                      channels_str);
 786         }
 787
 788         /* for PCM codecs, compute bitrate directly */
 789         switch(enc->codec_id) {
 790         case CODEC_ID_PCM_S16LE:
 791         case CODEC_ID_PCM_S16BE:
 792         case CODEC_ID_PCM_U16LE:
 793         case CODEC_ID_PCM_U16BE:
 794             bitrate = enc->sample_rate * enc->channels * 16;
 795             break;
 796         case CODEC_ID_PCM_S8:
 797         case CODEC_ID_PCM_U8:
 798         case CODEC_ID_PCM_ALAW:
 799         case CODEC_ID_PCM_MULAW:
 800             bitrate = enc->sample_rate * enc->channels * 8;
 801             break;
 802         default:
 803             bitrate = enc->bit_rate;
 804             break;
 805         }
 806         break;
 807     case CODEC_TYPE_DATA:
 808         snprintf(buf, buf_size, "Data: %s", codec_name);
 809         bitrate = enc->bit_rate;
 810         break;
 811     default:
 812         snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
 813         return;
 814     }
 815     if (encode) {
 816         if (enc->flags & CODEC_FLAG_PASS1)
 817             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 818                      ", pass 1");
 819         if (enc->flags & CODEC_FLAG_PASS2)
 820             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 821                      ", pass 2");
 822     }
 823     if (bitrate != 0) {
 824         snprintf(buf + strlen(buf), buf_size - strlen(buf),
 825                  ", %d kb/s", bitrate / 1000);
 826     }
 827 }
 828
 829 unsigned avcodec_version( void )
 830 {
 831   return LIBAVCODEC_VERSION_INT;
 832 }
 833
 834 unsigned avcodec_build( void )
 835 {
 836   return LIBAVCODEC_BUILD;
 837 }
 838
 839 /* must be called before any other functions */
 840 void avcodec_init(void)
 841 {
 842     static int inited = 0;
 843
 844     if (inited != 0)
 845         return;
 846     inited = 1;
 847
 848     dsputil_static_init();
 849 }
 850
 851 /**
 852  * Flush buffers, should be called when seeking or when swicthing to a different stream.
 853  */
 854 void avcodec_flush_buffers(AVCodecContext *avctx)
 855 {
 856     if(avctx->codec->flush)
 857         avctx->codec->flush(avctx);
 858 }
 859
 860 void avcodec_default_free_buffers(AVCodecContext *s){
 861     int i, j;
 862
 863     if(s->internal_buffer==NULL) return;
 864
 865     for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
 866         InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
 867         for(j=0; j<4; j++){
 868             av_freep(&buf->base[j]);
 869             buf->data[j]= NULL;
 870         }
 871     }
 872     av_freep(&s->internal_buffer);
 873
 874     s->internal_buffer_count=0;
 875 }
 876
 877 char av_get_pict_type_char(int pict_type){
 878     switch(pict_type){
 879     case I_TYPE: return 'I';
 880     case P_TYPE: return 'P';
 881     case B_TYPE: return 'B';
 882     case S_TYPE: return 'S';
 883     case SI_TYPE:return 'i';
 884     case SP_TYPE:return 'p';
 885     default:     return '?';
 886     }
 887 }
 888
 889 int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max){
 890     AVRational a0={0,1}, a1={1,0};
 891     int sign= (nom<0) ^ (den<0);
 892     int64_t gcd= ff_gcd(ABS(nom), ABS(den));
 893
 894     nom = ABS(nom)/gcd;
 895     den = ABS(den)/gcd;
 896     if(nom<=max && den<=max){
 897         a1= (AVRational){nom, den};
 898         den=0;
 899     }
 900
 901     while(den){
 902         int64_t x       = nom / den;
 903         int64_t next_den= nom - den*x;
 904         int64_t a2n= x*a1.num + a0.num;
 905         int64_t a2d= x*a1.den + a0.den;
 906
 907         if(a2n > max || a2d > max) break;
 908
 909         a0= a1;
 910         a1= (AVRational){a2n, a2d};
 911         nom= den;
 912         den= next_den;
 913     }
 914     assert(ff_gcd(a1.num, a1.den) == 1);
 915
 916     *dst_nom = sign ? -a1.num : a1.num;
 917     *dst_den = a1.den;
 918
 919     return den==0;
 920 }
 921
 922 int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd){
 923     AVInteger ai;
 924     int64_t r=0;
 925     assert(c > 0);
 926     assert(b >=0);
 927     assert(rnd >=0 && rnd<=5 && rnd!=4);
 928
 929     if(a<0 && a != INT64_MIN) return -av_rescale_rnd(-a, b, c, rnd ^ ((rnd>>1)&1));
 930
 931     if(rnd==AV_ROUND_NEAR_INF) r= c/2;
 932     else if(rnd&1)             r= c-1;
 933
 934     if(b<=INT_MAX && c<=INT_MAX){
 935         if(a<=INT_MAX)
 936             return (a * b + r)/c;
 937         else
 938             return a/c*b + (a%c*b + r)/c;
 939     }
 940
 941     ai= av_mul_i(av_int2i(a), av_int2i(b));
 942     ai= av_add_i(ai, av_int2i(r));
 943
 944     return av_i2int(av_div_i(ai, av_int2i(c)));
 945 }
 946
 947 int64_t av_rescale(int64_t a, int64_t b, int64_t c){
 948     return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
 949 }
 950
 951 int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq){
 952     int64_t b= bq.num * (int64_t)cq.den;
 953     int64_t c= cq.num * (int64_t)bq.den;
 954     return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
 955 }
 956
 957 int64_t ff_gcd(int64_t a, int64_t b){
 958     if(b) return ff_gcd(b, a%b);
 959     else  return a;
 960 }
 961
 962 /* av_log API */
 963
 964 static int av_log_level = AV_LOG_DEBUG;
 965
 966 static void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl)
 967 {
 968     static int print_prefix=1;
 969     AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
 970     if(level>av_log_level)
 971         return;
 972 #undef fprintf
 973     if(print_prefix && avc) {
 974             fprintf(stderr, "[%s @ %p]", avc->item_name(ptr), avc);
 975     }
 976 #define fprintf please_use_av_log
 977
 978     print_prefix= strstr(fmt, "\n") != NULL;
 979
 980     vfprintf(stderr, fmt, vl);
 981 }
 982
 983 static void (*av_log_callback)(void*, int, const char*, va_list) = av_log_default_callback;
 984
 985 void av_log(void* avcl, int level, const char *fmt, ...)
 986 {
 987     va_list vl;
 988     va_start(vl, fmt);
 989     av_vlog(avcl, level, fmt, vl);
 990     va_end(vl);
 991 }
 992
 993 void av_vlog(void* avcl, int level, const char *fmt, va_list vl)
 994 {
 995     av_log_callback(avcl, level, fmt, vl);
 996 }
 997
 998 int av_log_get_level(void)
 999 {
1000     return av_log_level;
1001 }
1002
1003 void av_log_set_level(int level)
1004 {
1005     av_log_level = level;
1006 }
1007
1008 void av_log_set_callback(void (*callback)(void*, int, const char*, va_list))
1009 {
1010     av_log_callback = callback;
1011 }
1012
1013 #if !defined(HAVE_THREADS)
1014 int avcodec_thread_init(AVCodecContext *s, int thread_count){
1015     return -1;
1016 }
1017 #endif