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 void avcodec_default_free_buffers(AVCodecContext *s);
  35
  36 void *av_mallocz(unsigned int size)
  37 {
  38     void *ptr;
  39
  40     ptr = av_malloc(size);
  41     if (!ptr)
  42         return NULL;
  43     memset(ptr, 0, size);
  44     return ptr;
  45 }
  46
  47 char *av_strdup(const char *s)
  48 {
  49     char *ptr;
  50     int len;
  51     len = strlen(s) + 1;
  52     ptr = av_malloc(len);
  53     if (!ptr)
  54         return NULL;
  55     memcpy(ptr, s, len);
  56     return ptr;
  57 }
  58
  59 /**
  60  * realloc which does nothing if the block is large enough
  61  */
  62 void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
  63 {
  64     if(min_size < *size)
  65         return ptr;
  66
  67     *size= 17*min_size/16 + 32;
  68
  69     return av_realloc(ptr, *size);
  70 }
  71
  72
  73 static unsigned int last_static = 0;
  74 static unsigned int allocated_static = 0;
  75 static void** array_static = NULL;
  76
  77 /**
  78  * allocation of static arrays - do not use for normal allocation.
  79  */
  80 void *av_mallocz_static(unsigned int size)
  81 {
  82     void *ptr = av_mallocz(size);
  83
  84     if(ptr){
  85         array_static =av_fast_realloc(array_static, &allocated_static, sizeof(void*)*(last_static+1));
  86         array_static[last_static++] = ptr;
  87     }
  88
  89     return ptr;
  90 }
  91
  92 /**
  93  * free all static arrays and reset pointers to 0.
  94  */
  95 void av_free_static(void)
  96 {
  97     while(last_static){
  98         av_freep(&array_static[--last_static]);
  99     }
 100     av_freep(&array_static);
 101 }
 102
 103 /**
 104  * Frees memory and sets the pointer to NULL.
 105  * @param arg pointer to the pointer which should be freed
 106  */
 107 void av_freep(void *arg)
 108 {
 109     void **ptr= (void**)arg;
 110     av_free(*ptr);
 111     *ptr = NULL;
 112 }
 113
 114 /* encoder management */
 115 AVCodec *first_avcodec = NULL;
 116
 117 void register_avcodec(AVCodec *format)
 118 {
 119     AVCodec **p;
 120     p = &first_avcodec;
 121     while (*p != NULL) p = &(*p)->next;
 122     *p = format;
 123     format->next = NULL;
 124 }
 125
 126 void avcodec_set_dimensions(AVCodecContext *s, int width, int height){
 127     s->coded_width = width;
 128     s->coded_height= height;
 129     s->width = -((-width )>>s->lowres);
 130     s->height= -((-height)>>s->lowres);
 131 }
 132
 133 typedef struct InternalBuffer{
 134     int last_pic_num;
 135     uint8_t *base[4];
 136     uint8_t *data[4];
 137     int linesize[4];
 138 }InternalBuffer;
 139
 140 #define INTERNAL_BUFFER_SIZE 32
 141
 142 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
 143
 144 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
 145     int w_align= 1;
 146     int h_align= 1;
 147
 148     switch(s->pix_fmt){
 149     case PIX_FMT_YUV420P:
 150     case PIX_FMT_YUV422:
 151     case PIX_FMT_UYVY422:
 152     case PIX_FMT_YUV422P:
 153     case PIX_FMT_YUV444P:
 154     case PIX_FMT_GRAY8:
 155     case PIX_FMT_YUVJ420P:
 156     case PIX_FMT_YUVJ422P:
 157     case PIX_FMT_YUVJ444P:
 158         w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
 159         h_align= 16;
 160         break;
 161     case PIX_FMT_YUV411P:
 162         w_align=32;
 163         h_align=8;
 164         break;
 165     case PIX_FMT_YUV410P:
 166         if(s->codec_id == CODEC_ID_SVQ1){
 167             w_align=64;
 168             h_align=64;
 169         }
 170     case PIX_FMT_RGB555:
 171         if(s->codec_id == CODEC_ID_RPZA){
 172             w_align=4;
 173             h_align=4;
 174         }
 175     case PIX_FMT_PAL8:
 176         if(s->codec_id == CODEC_ID_SMC){
 177             w_align=4;
 178             h_align=4;
 179         }
 180         break;
 181     default:
 182         w_align= 1;
 183         h_align= 1;
 184         break;
 185     }
 186
 187     *width = ALIGN(*width , w_align);
 188     *height= ALIGN(*height, h_align);
 189 }
 190
 191 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
 192     int i;
 193     int w= s->width;
 194     int h= s->height;
 195     InternalBuffer *buf;
 196     int *picture_number;
 197
 198     assert(pic->data[0]==NULL);
 199     assert(INTERNAL_BUFFER_SIZE > s->internal_buffer_count);
 200
 201     if(s->internal_buffer==NULL){
 202         s->internal_buffer= av_mallocz(INTERNAL_BUFFER_SIZE*sizeof(InternalBuffer));
 203     }
 204 #if 0
 205     s->internal_buffer= av_fast_realloc(
 206         s->internal_buffer,
 207         &s->internal_buffer_size,
 208         sizeof(InternalBuffer)*FFMAX(99,  s->internal_buffer_count+1)/*FIXME*/
 209         );
 210 #endif
 211
 212     buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
 213     picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE-1]).last_pic_num; //FIXME ugly hack
 214     (*picture_number)++;
 215
 216     if(buf->base[0]){
 217         pic->age= *picture_number - buf->last_pic_num;
 218         buf->last_pic_num= *picture_number;
 219     }else{
 220         int h_chroma_shift, v_chroma_shift;
 221         int s_align, pixel_size;
 222
 223         avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
 224
 225         switch(s->pix_fmt){
 226         case PIX_FMT_RGB555:
 227         case PIX_FMT_RGB565:
 228         case PIX_FMT_YUV422:
 229         case PIX_FMT_UYVY422:
 230             pixel_size=2;
 231             break;
 232         case PIX_FMT_RGB24:
 233         case PIX_FMT_BGR24:
 234             pixel_size=3;
 235             break;
 236         case PIX_FMT_RGBA32:
 237             pixel_size=4;
 238             break;
 239         default:
 240             pixel_size=1;
 241         }
 242
 243         avcodec_align_dimensions(s, &w, &h);
 244 #if defined(ARCH_POWERPC) || defined(HAVE_MMI) //FIXME some cleaner check
 245         s_align= 16;
 246 #else
 247         s_align= 8;
 248 #endif
 249
 250         if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
 251             w+= EDGE_WIDTH*2;
 252             h+= EDGE_WIDTH*2;
 253         }
 254
 255         buf->last_pic_num= -256*256*256*64;
 256
 257         for(i=0; i<3; i++){
 258             const int h_shift= i==0 ? 0 : h_chroma_shift;
 259             const int v_shift= i==0 ? 0 : v_chroma_shift;
 260
 261             //FIXME next ensures that linesize= 2^x uvlinesize, thats needed because some MC code assumes it
 262             buf->linesize[i]= ALIGN(pixel_size*w>>h_shift, s_align<<(h_chroma_shift-h_shift));
 263
 264             buf->base[i]= av_mallocz((buf->linesize[i]*h>>v_shift)+16); //FIXME 16
 265             if(buf->base[i]==NULL) return -1;
 266             memset(buf->base[i], 128, buf->linesize[i]*h>>v_shift);
 267
 268             if(s->flags&CODEC_FLAG_EMU_EDGE)
 269                 buf->data[i] = buf->base[i];
 270             else
 271                 buf->data[i] = buf->base[i] + ALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), s_align);
 272         }
 273         pic->age= 256*256*256*64;
 274     }
 275     pic->type= FF_BUFFER_TYPE_INTERNAL;
 276
 277     for(i=0; i<4; i++){
 278         pic->base[i]= buf->base[i];
 279         pic->data[i]= buf->data[i];
 280         pic->linesize[i]= buf->linesize[i];
 281     }
 282     s->internal_buffer_count++;
 283
 284     return 0;
 285 }
 286
 287 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
 288     int i;
 289     InternalBuffer *buf, *last, temp;
 290
 291     assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
 292     assert(s->internal_buffer_count);
 293
 294     buf = NULL; /* avoids warning */
 295     for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
 296         buf= &((InternalBuffer*)s->internal_buffer)[i];
 297         if(buf->data[0] == pic->data[0])
 298             break;
 299     }
 300     assert(i < s->internal_buffer_count);
 301     s->internal_buffer_count--;
 302     last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
 303
 304     temp= *buf;
 305     *buf= *last;
 306     *last= temp;
 307
 308     for(i=0; i<3; i++){
 309         pic->data[i]=NULL;
 310 //        pic->base[i]=NULL;
 311     }
 312 //printf("R%X\n", pic->opaque);
 313 }
 314
 315 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
 316     AVFrame temp_pic;
 317     int i;
 318
 319     /* If no picture return a new buffer */
 320     if(pic->data[0] == NULL) {
 321         /* We will copy from buffer, so must be readable */
 322         pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
 323         return s->get_buffer(s, pic);
 324     }
 325
 326     /* If internal buffer type return the same buffer */
 327     if(pic->type == FF_BUFFER_TYPE_INTERNAL)
 328         return 0;
 329
 330     /*
 331      * Not internal type and reget_buffer not overridden, emulate cr buffer
 332      */
 333     temp_pic = *pic;
 334     for(i = 0; i < 4; i++)
 335         pic->data[i] = pic->base[i] = NULL;
 336     pic->opaque = NULL;
 337     /* Allocate new frame */
 338     if (s->get_buffer(s, pic))
 339         return -1;
 340     /* Copy image data from old buffer to new buffer */
 341     img_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width,
 342              s->height);
 343     s->release_buffer(s, &temp_pic); // Release old frame
 344     return 0;
 345 }
 346
 347 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count){
 348     int i;
 349
 350     for(i=0; i<count; i++){
 351         int r= func(c, arg[i]);
 352         if(ret) ret[i]= r;
 353     }
 354     return 0;
 355 }
 356
 357 enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt){
 358     return fmt[0];
 359 }
 360
 361 static const char* context_to_name(void* ptr) {
 362     AVCodecContext *avc= ptr;
 363
 364     if(avc && avc->codec && avc->codec->name)
 365         return avc->codec->name;
 366     else
 367         return "NULL";
 368 }
 369
 370 static AVClass av_codec_context_class = { "AVCodecContext", context_to_name };
 371
 372 void avcodec_get_context_defaults(AVCodecContext *s){
 373     memset(s, 0, sizeof(AVCodecContext));
 374
 375     s->av_class= &av_codec_context_class;
 376     s->bit_rate= 800*1000;
 377     s->bit_rate_tolerance= s->bit_rate*10;
 378     s->qmin= 2;
 379     s->qmax= 31;
 380     s->mb_qmin= 2;
 381     s->mb_qmax= 31;
 382     s->rc_eq= "tex^qComp";
 383     s->qcompress= 0.5;
 384     s->max_qdiff= 3;
 385     s->b_quant_factor=1.25;
 386     s->b_quant_offset=1.25;
 387     s->i_quant_factor=-0.8;
 388     s->i_quant_offset=0.0;
 389     s->error_concealment= 3;
 390     s->error_resilience= 1;
 391     s->workaround_bugs= FF_BUG_AUTODETECT;
 392     s->frame_rate_base= 1;
 393     s->frame_rate = 25;
 394     s->gop_size= 50;
 395     s->me_method= ME_EPZS;
 396     s->get_buffer= avcodec_default_get_buffer;
 397     s->release_buffer= avcodec_default_release_buffer;
 398     s->get_format= avcodec_default_get_format;
 399     s->execute= avcodec_default_execute;
 400     s->thread_count=1;
 401     s->me_subpel_quality=8;
 402     s->lmin= FF_QP2LAMBDA * s->qmin;
 403     s->lmax= FF_QP2LAMBDA * s->qmax;
 404     s->sample_aspect_ratio= (AVRational){0,1};
 405     s->ildct_cmp= FF_CMP_VSAD;
 406     s->profile= FF_PROFILE_UNKNOWN;
 407     s->level= FF_LEVEL_UNKNOWN;
 408
 409     s->intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
 410     s->inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
 411     s->palctrl = NULL;
 412     s->reget_buffer= avcodec_default_reget_buffer;
 413 }
 414
 415 /**
 416  * allocates a AVCodecContext and set it to defaults.
 417  * this can be deallocated by simply calling free()
 418  */
 419 AVCodecContext *avcodec_alloc_context(void){
 420     AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
 421
 422     if(avctx==NULL) return NULL;
 423
 424     avcodec_get_context_defaults(avctx);
 425
 426     return avctx;
 427 }
 428
 429 void avcodec_get_frame_defaults(AVFrame *pic){
 430     memset(pic, 0, sizeof(AVFrame));
 431
 432     pic->pts= AV_NOPTS_VALUE;
 433 }
 434
 435 /**
 436  * allocates a AVPFrame and set it to defaults.
 437  * this can be deallocated by simply calling free()
 438  */
 439 AVFrame *avcodec_alloc_frame(void){
 440     AVFrame *pic= av_malloc(sizeof(AVFrame));
 441
 442     if(pic==NULL) return NULL;
 443
 444     avcodec_get_frame_defaults(pic);
 445
 446     return pic;
 447 }
 448
 449 int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
 450 {
 451     int ret;
 452
 453     if(avctx->codec)
 454         return -1;
 455
 456     avctx->codec = codec;
 457     avctx->codec_id = codec->id;
 458     avctx->frame_number = 0;
 459     if (codec->priv_data_size > 0) {
 460         avctx->priv_data = av_mallocz(codec->priv_data_size);
 461         if (!avctx->priv_data)
 462             return -ENOMEM;
 463     } else {
 464         avctx->priv_data = NULL;
 465     }
 466
 467     if(avctx->coded_width && avctx->coded_height)
 468         avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
 469     else if(avctx->width && avctx->height)
 470         avcodec_set_dimensions(avctx, avctx->width, avctx->height);
 471
 472     ret = avctx->codec->init(avctx);
 473     if (ret < 0) {
 474         av_freep(&avctx->priv_data);
 475         return ret;
 476     }
 477     return 0;
 478 }
 479
 480 int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 481                          const short *samples)
 482 {
 483     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){
 484         int ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
 485         avctx->frame_number++;
 486         return ret;
 487     }else
 488         return 0;
 489 }
 490
 491 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 492                          const AVFrame *pict)
 493 {
 494     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || pict){
 495         int ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
 496         avctx->frame_number++;
 497         emms_c(); //needed to avoid a emms_c() call before every return;
 498
 499         return ret;
 500     }else
 501         return 0;
 502 }
 503
 504 /**
 505  * decode a frame.
 506  * @param buf bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE larger then the actual read bytes
 507  * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
 508  * @param buf_size the size of the buffer in bytes
 509  * @param got_picture_ptr zero if no frame could be decompressed, Otherwise, it is non zero
 510  * @return -1 if error, otherwise return the number of
 511  * bytes used.
 512  */
 513 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
 514                          int *got_picture_ptr,
 515                          uint8_t *buf, int buf_size)
 516 {
 517     int ret;
 518
 519     *got_picture_ptr= 0;
 520     ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
 521                                buf, buf_size);
 522
 523     emms_c(); //needed to avoid a emms_c() call before every return;
 524
 525     if (*got_picture_ptr)
 526         avctx->frame_number++;
 527     return ret;
 528 }
 529
 530 /* decode an audio frame. return -1 if error, otherwise return the
 531    *number of bytes used. If no frame could be decompressed,
 532    *frame_size_ptr is zero. Otherwise, it is the decompressed frame
 533    *size in BYTES. */
 534 int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples,
 535                          int *frame_size_ptr,
 536                          uint8_t *buf, int buf_size)
 537 {
 538     int ret;
 539
 540     *frame_size_ptr= 0;
 541     ret = avctx->codec->decode(avctx, samples, frame_size_ptr,
 542                                buf, buf_size);
 543     avctx->frame_number++;
 544     return ret;
 545 }
 546
 547 int avcodec_close(AVCodecContext *avctx)
 548 {
 549     if (avctx->codec->close)
 550         avctx->codec->close(avctx);
 551     avcodec_default_free_buffers(avctx);
 552     av_freep(&avctx->priv_data);
 553     avctx->codec = NULL;
 554     return 0;
 555 }
 556
 557 AVCodec *avcodec_find_encoder(enum CodecID id)
 558 {
 559     AVCodec *p;
 560     p = first_avcodec;
 561     while (p) {
 562         if (p->encode != NULL && p->id == id)
 563             return p;
 564         p = p->next;
 565     }
 566     return NULL;
 567 }
 568
 569 AVCodec *avcodec_find_encoder_by_name(const char *name)
 570 {
 571     AVCodec *p;
 572     p = first_avcodec;
 573     while (p) {
 574         if (p->encode != NULL && strcmp(name,p->name) == 0)
 575             return p;
 576         p = p->next;
 577     }
 578     return NULL;
 579 }
 580
 581 AVCodec *avcodec_find_decoder(enum CodecID id)
 582 {
 583     AVCodec *p;
 584     p = first_avcodec;
 585     while (p) {
 586         if (p->decode != NULL && p->id == id)
 587             return p;
 588         p = p->next;
 589     }
 590     return NULL;
 591 }
 592
 593 AVCodec *avcodec_find_decoder_by_name(const char *name)
 594 {
 595     AVCodec *p;
 596     p = first_avcodec;
 597     while (p) {
 598         if (p->decode != NULL && strcmp(name,p->name) == 0)
 599             return p;
 600         p = p->next;
 601     }
 602     return NULL;
 603 }
 604
 605 static AVCodec *avcodec_find(enum CodecID id)
 606 {
 607     AVCodec *p;
 608     p = first_avcodec;
 609     while (p) {
 610         if (p->id == id)
 611             return p;
 612         p = p->next;
 613     }
 614     return NULL;
 615 }
 616
 617 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
 618 {
 619     const char *codec_name;
 620     AVCodec *p;
 621     char buf1[32];
 622     char channels_str[100];
 623     int bitrate;
 624
 625     if (encode)
 626         p = avcodec_find_encoder(enc->codec_id);
 627     else
 628         p = avcodec_find_decoder(enc->codec_id);
 629
 630     if (p) {
 631         codec_name = p->name;
 632         if (!encode && enc->codec_id == CODEC_ID_MP3) {
 633             if (enc->sub_id == 2)
 634                 codec_name = "mp2";
 635             else if (enc->sub_id == 1)
 636                 codec_name = "mp1";
 637         }
 638     } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
 639         /* fake mpeg2 transport stream codec (currently not
 640            registered) */
 641         codec_name = "mpeg2ts";
 642     } else if (enc->codec_name[0] != '\0') {
 643         codec_name = enc->codec_name;
 644     } else {
 645         /* output avi tags */
 646         if (enc->codec_type == CODEC_TYPE_VIDEO) {
 647             snprintf(buf1, sizeof(buf1), "%c%c%c%c",
 648                      enc->codec_tag & 0xff,
 649                      (enc->codec_tag >> 8) & 0xff,
 650                      (enc->codec_tag >> 16) & 0xff,
 651                      (enc->codec_tag >> 24) & 0xff);
 652         } else {
 653             snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
 654         }
 655         codec_name = buf1;
 656     }
 657
 658     switch(enc->codec_type) {
 659     case CODEC_TYPE_VIDEO:
 660         snprintf(buf, buf_size,
 661                  "Video: %s%s",
 662                  codec_name, enc->mb_decision ? " (hq)" : "");
 663         if (enc->codec_id == CODEC_ID_RAWVIDEO) {
 664             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 665                      ", %s",
 666                      avcodec_get_pix_fmt_name(enc->pix_fmt));
 667         }
 668         if (enc->width) {
 669             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 670                      ", %dx%d, %0.2f fps",
 671                      enc->width, enc->height,
 672                      (float)enc->frame_rate / enc->frame_rate_base);
 673         }
 674         if (encode) {
 675             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 676                      ", q=%d-%d", enc->qmin, enc->qmax);
 677         }
 678         bitrate = enc->bit_rate;
 679         break;
 680     case CODEC_TYPE_AUDIO:
 681         snprintf(buf, buf_size,
 682                  "Audio: %s",
 683                  codec_name);
 684         switch (enc->channels) {
 685             case 1:
 686                 strcpy(channels_str, "mono");
 687                 break;
 688             case 2:
 689                 strcpy(channels_str, "stereo");
 690                 break;
 691             case 6:
 692                 strcpy(channels_str, "5:1");
 693                 break;
 694             default:
 695                 sprintf(channels_str, "%d channels", enc->channels);
 696                 break;
 697         }
 698         if (enc->sample_rate) {
 699             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 700                      ", %d Hz, %s",
 701                      enc->sample_rate,
 702                      channels_str);
 703         }
 704
 705         /* for PCM codecs, compute bitrate directly */
 706         switch(enc->codec_id) {
 707         case CODEC_ID_PCM_S16LE:
 708         case CODEC_ID_PCM_S16BE:
 709         case CODEC_ID_PCM_U16LE:
 710         case CODEC_ID_PCM_U16BE:
 711             bitrate = enc->sample_rate * enc->channels * 16;
 712             break;
 713         case CODEC_ID_PCM_S8:
 714         case CODEC_ID_PCM_U8:
 715         case CODEC_ID_PCM_ALAW:
 716         case CODEC_ID_PCM_MULAW:
 717             bitrate = enc->sample_rate * enc->channels * 8;
 718             break;
 719         default:
 720             bitrate = enc->bit_rate;
 721             break;
 722         }
 723         break;
 724     case CODEC_TYPE_DATA:
 725         snprintf(buf, buf_size, "Data: %s", codec_name);
 726         bitrate = enc->bit_rate;
 727         break;
 728     default:
 729         av_abort();
 730     }
 731     if (encode) {
 732         if (enc->flags & CODEC_FLAG_PASS1)
 733             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 734                      ", pass 1");
 735         if (enc->flags & CODEC_FLAG_PASS2)
 736             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 737                      ", pass 2");
 738     }
 739     if (bitrate != 0) {
 740         snprintf(buf + strlen(buf), buf_size - strlen(buf),
 741                  ", %d kb/s", bitrate / 1000);
 742     }
 743 }
 744
 745 unsigned avcodec_version( void )
 746 {
 747   return LIBAVCODEC_VERSION_INT;
 748 }
 749
 750 unsigned avcodec_build( void )
 751 {
 752   return LIBAVCODEC_BUILD;
 753 }
 754
 755 /* must be called before any other functions */
 756 void avcodec_init(void)
 757 {
 758     static int inited = 0;
 759
 760     if (inited != 0)
 761         return;
 762     inited = 1;
 763
 764     dsputil_static_init();
 765 }
 766
 767 /**
 768  * Flush buffers, should be called when seeking or when swicthing to a different stream.
 769  */
 770 void avcodec_flush_buffers(AVCodecContext *avctx)
 771 {
 772     if(avctx->codec->flush)
 773         avctx->codec->flush(avctx);
 774 }
 775
 776 void avcodec_default_free_buffers(AVCodecContext *s){
 777     int i, j;
 778
 779     if(s->internal_buffer==NULL) return;
 780
 781     for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
 782         InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
 783         for(j=0; j<4; j++){
 784             av_freep(&buf->base[j]);
 785             buf->data[j]= NULL;
 786         }
 787     }
 788     av_freep(&s->internal_buffer);
 789
 790     s->internal_buffer_count=0;
 791 }
 792
 793 char av_get_pict_type_char(int pict_type){
 794     switch(pict_type){
 795     case I_TYPE: return 'I';
 796     case P_TYPE: return 'P';
 797     case B_TYPE: return 'B';
 798     case S_TYPE: return 'S';
 799     case SI_TYPE:return 'i';
 800     case SP_TYPE:return 'p';
 801     default:     return '?';
 802     }
 803 }
 804
 805 int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max){
 806     AVRational a0={0,1}, a1={1,0};
 807     int sign= (nom<0) ^ (den<0);
 808     int64_t gcd= ff_gcd(ABS(nom), ABS(den));
 809
 810     nom = ABS(nom)/gcd;
 811     den = ABS(den)/gcd;
 812     if(nom<=max && den<=max){
 813         a1= (AVRational){nom, den};
 814         den=0;
 815     }
 816
 817     while(den){
 818         int64_t x       = nom / den;
 819         int64_t next_den= nom - den*x;
 820         int64_t a2n= x*a1.num + a0.num;
 821         int64_t a2d= x*a1.den + a0.den;
 822
 823         if(a2n > max || a2d > max) break;
 824
 825         a0= a1;
 826         a1= (AVRational){a2n, a2d};
 827         nom= den;
 828         den= next_den;
 829     }
 830     assert(ff_gcd(a1.num, a1.den) == 1);
 831
 832     *dst_nom = sign ? -a1.num : a1.num;
 833     *dst_den = a1.den;
 834
 835     return den==0;
 836 }
 837
 838 int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd){
 839     AVInteger ai;
 840     int64_t r=0;
 841     assert(c > 0);
 842     assert(b >=0);
 843     assert(rnd >=0 && rnd<=5 && rnd!=4);
 844
 845     if(a<0) return -av_rescale_rnd(-a, b, c, rnd ^ ((rnd>>1)&1));
 846
 847     if(rnd==AV_ROUND_NEAR_INF) r= c/2;
 848     else if(rnd&1)             r= c-1;
 849
 850     if(b<=INT_MAX && c<=INT_MAX){
 851         if(a<=INT_MAX)
 852             return (a * b + r)/c;
 853         else
 854             return a/c*b + (a%c*b + r)/c;
 855     }
 856
 857     ai= av_mul_i(av_int2i(a), av_int2i(b));
 858     ai= av_add_i(ai, av_int2i(r));
 859
 860     return av_i2int(av_div_i(ai, av_int2i(c)));
 861 }
 862
 863 int64_t av_rescale(int64_t a, int64_t b, int64_t c){
 864     return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
 865 }
 866
 867 /* av_log API */
 868
 869 static int av_log_level = AV_LOG_DEBUG;
 870
 871 static void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl)
 872 {
 873     static int print_prefix=1;
 874     AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
 875     if(level>av_log_level)
 876         return;
 877 #undef fprintf
 878     if(print_prefix && avc) {
 879             fprintf(stderr, "[%s @ %p]", avc->item_name(ptr), avc);
 880     }
 881 #define fprintf please_use_av_log
 882
 883     print_prefix= strstr(fmt, "\n") != NULL;
 884
 885     vfprintf(stderr, fmt, vl);
 886 }
 887
 888 static void (*av_log_callback)(void*, int, const char*, va_list) = av_log_default_callback;
 889
 890 void av_log(void* avcl, int level, const char *fmt, ...)
 891 {
 892     va_list vl;
 893     va_start(vl, fmt);
 894     av_vlog(avcl, level, fmt, vl);
 895     va_end(vl);
 896 }
 897
 898 void av_vlog(void* avcl, int level, const char *fmt, va_list vl)
 899 {
 900     av_log_callback(avcl, level, fmt, vl);
 901 }
 902
 903 int av_log_get_level(void)
 904 {
 905     return av_log_level;
 906 }
 907
 908 void av_log_set_level(int level)
 909 {
 910     av_log_level = level;
 911 }
 912
 913 void av_log_set_callback(void (*callback)(void*, int, const char*, va_list))
 914 {
 915     av_log_callback = callback;
 916 }
 917
 918 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
 919 int avcodec_thread_init(AVCodecContext *s, int thread_count){
 920     return -1;
 921 }
 922 #endif