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

   1 /*
   2  * utils for libavcodec
   3  * Copyright (c) 2001 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include "avcodec.h"
  20 #include "dsputil.h"
  21 #include "mpegvideo.h"
  22
  23 void *av_mallocz(int size)
  24 {
  25     void *ptr;
  26     ptr = av_malloc(size);
  27     if (!ptr)
  28         return NULL;
  29     memset(ptr, 0, size);
  30     return ptr;
  31 }
  32
  33 /* cannot call it directly because of 'void **' casting is not automatic */
  34 void __av_freep(void **ptr)
  35 {
  36     av_free(*ptr);
  37     *ptr = NULL;
  38 }
  39
  40 /* encoder management */
  41 AVCodec *first_avcodec;
  42
  43 void register_avcodec(AVCodec *format)
  44 {
  45     AVCodec **p;
  46     p = &first_avcodec;
  47     while (*p != NULL) p = &(*p)->next;
  48     *p = format;
  49     format->next = NULL;
  50 }
  51
  52 void avcodec_get_context_defaults(AVCodecContext *s){
  53     s->bit_rate= 800*1000;
  54     s->bit_rate_tolerance= s->bit_rate*10;
  55     s->qmin= 2;
  56     s->qmax= 31;
  57     s->rc_eq= "tex^qComp";
  58     s->qcompress= 0.5;
  59     s->max_qdiff= 3;
  60     s->b_quant_factor=1.25;
  61     s->b_quant_offset=1.25;
  62     s->i_quant_factor=-0.8;
  63     s->i_quant_offset=0.0;
  64     s->error_concealment= 3;
  65     s->error_resilience= 1;
  66     s->workaround_bugs= FF_BUG_AUTODETECT;
  67     s->frame_rate = 25 * FRAME_RATE_BASE;
  68     s->gop_size= 50;
  69     s->me_method= ME_EPZS;
  70 }
  71
  72 /**
  73  * allocates a AVCodecContext and set it to defaults.
  74  * this can be deallocated by simply calling free()
  75  */
  76 AVCodecContext *avcodec_alloc_context(void){
  77     AVCodecContext *avctx= av_mallocz(sizeof(AVCodecContext));
  78
  79     if(avctx==NULL) return NULL;
  80
  81     avcodec_get_context_defaults(avctx);
  82
  83     return avctx;
  84 }
  85
  86 int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
  87 {
  88     int ret;
  89
  90     avctx->codec = codec;
  91     avctx->frame_number = 0;
  92     if (codec->priv_data_size > 0) {
  93         avctx->priv_data = av_mallocz(codec->priv_data_size);
  94         if (!avctx->priv_data)
  95             return -ENOMEM;
  96     } else {
  97         avctx->priv_data = NULL;
  98     }
  99     ret = avctx->codec->init(avctx);
 100     if (ret < 0) {
 101         av_freep(&avctx->priv_data);
 102         return ret;
 103     }
 104     return 0;
 105 }
 106
 107 int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size,
 108                          const short *samples)
 109 {
 110     int ret;
 111
 112     ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
 113     avctx->frame_number++;
 114     return ret;
 115 }
 116
 117 int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size,
 118                          const AVPicture *pict)
 119 {
 120     int ret;
 121
 122     ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
 123     avctx->frame_number++;
 124     return ret;
 125 }
 126
 127 /* decode a frame. return -1 if error, otherwise return the number of
 128    bytes used. If no frame could be decompressed, *got_picture_ptr is
 129    zero. Otherwise, it is non zero */
 130 int avcodec_decode_video(AVCodecContext *avctx, AVPicture *picture,
 131                          int *got_picture_ptr,
 132                          UINT8 *buf, int buf_size)
 133 {
 134     int ret;
 135
 136     ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
 137                                buf, buf_size);
 138     if (*got_picture_ptr)
 139         avctx->frame_number++;
 140     return ret;
 141 }
 142
 143 /* decode an audio frame. return -1 if error, otherwise return the
 144    *number of bytes used. If no frame could be decompressed,
 145    *frame_size_ptr is zero. Otherwise, it is the decompressed frame
 146    *size in BYTES. */
 147 int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples,
 148                          int *frame_size_ptr,
 149                          UINT8 *buf, int buf_size)
 150 {
 151     int ret;
 152
 153     ret = avctx->codec->decode(avctx, samples, frame_size_ptr,
 154                                buf, buf_size);
 155     avctx->frame_number++;
 156     return ret;
 157 }
 158
 159 int avcodec_close(AVCodecContext *avctx)
 160 {
 161     if (avctx->codec->close)
 162         avctx->codec->close(avctx);
 163     av_freep(&avctx->priv_data);
 164     avctx->codec = NULL;
 165     return 0;
 166 }
 167
 168 AVCodec *avcodec_find_encoder(enum CodecID id)
 169 {
 170     AVCodec *p;
 171     p = first_avcodec;
 172     while (p) {
 173         if (p->encode != NULL && p->id == id)
 174             return p;
 175         p = p->next;
 176     }
 177     return NULL;
 178 }
 179
 180 AVCodec *avcodec_find_encoder_by_name(const char *name)
 181 {
 182     AVCodec *p;
 183     p = first_avcodec;
 184     while (p) {
 185         if (p->encode != NULL && strcmp(name,p->name) == 0)
 186             return p;
 187         p = p->next;
 188     }
 189     return NULL;
 190 }
 191
 192 AVCodec *avcodec_find_decoder(enum CodecID id)
 193 {
 194     AVCodec *p;
 195     p = first_avcodec;
 196     while (p) {
 197         if (p->decode != NULL && p->id == id)
 198             return p;
 199         p = p->next;
 200     }
 201     return NULL;
 202 }
 203
 204 AVCodec *avcodec_find_decoder_by_name(const char *name)
 205 {
 206     AVCodec *p;
 207     p = first_avcodec;
 208     while (p) {
 209         if (p->decode != NULL && strcmp(name,p->name) == 0)
 210             return p;
 211         p = p->next;
 212     }
 213     return NULL;
 214 }
 215
 216 AVCodec *avcodec_find(enum CodecID id)
 217 {
 218     AVCodec *p;
 219     p = first_avcodec;
 220     while (p) {
 221         if (p->id == id)
 222             return p;
 223         p = p->next;
 224     }
 225     return NULL;
 226 }
 227
 228 const char *pix_fmt_str[] = {
 229     "yuv420p",
 230     "yuv422",
 231     "rgb24",
 232     "bgr24",
 233     "yuv422p",
 234     "yuv444p",
 235     "rgba32",
 236     "bgra32",
 237     "yuv410p",
 238     "yuv411p",
 239 };
 240
 241 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
 242 {
 243     const char *codec_name;
 244     AVCodec *p;
 245     char buf1[32];
 246     char channels_str[100];
 247     int bitrate;
 248
 249     if (encode)
 250         p = avcodec_find_encoder(enc->codec_id);
 251     else
 252         p = avcodec_find_decoder(enc->codec_id);
 253
 254     if (p) {
 255         codec_name = p->name;
 256     } else if (enc->codec_name[0] != '\0') {
 257         codec_name = enc->codec_name;
 258     } else {
 259         /* output avi tags */
 260         if (enc->codec_type == CODEC_TYPE_VIDEO) {
 261             snprintf(buf1, sizeof(buf1), "%c%c%c%c",
 262                      enc->codec_tag & 0xff,
 263                      (enc->codec_tag >> 8) & 0xff,
 264                      (enc->codec_tag >> 16) & 0xff,
 265                      (enc->codec_tag >> 24) & 0xff);
 266         } else {
 267             snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
 268         }
 269         codec_name = buf1;
 270     }
 271
 272     switch(enc->codec_type) {
 273     case CODEC_TYPE_VIDEO:
 274         snprintf(buf, buf_size,
 275                  "Video: %s%s",
 276                  codec_name, enc->flags & CODEC_FLAG_HQ ? " (hq)" : "");
 277         if (enc->codec_id == CODEC_ID_RAWVIDEO) {
 278             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 279                      ", %s",
 280                      pix_fmt_str[enc->pix_fmt]);
 281         }
 282         if (enc->width) {
 283             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 284                      ", %dx%d, %0.2f fps",
 285                      enc->width, enc->height,
 286                      (float)enc->frame_rate / FRAME_RATE_BASE);
 287         }
 288         if (encode) {
 289             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 290                      ", q=%d-%d", enc->qmin, enc->qmax);
 291         }
 292         bitrate = enc->bit_rate;
 293         break;
 294     case CODEC_TYPE_AUDIO:
 295         snprintf(buf, buf_size,
 296                  "Audio: %s",
 297                  codec_name);
 298         switch (enc->channels) {
 299             case 1:
 300                 strcpy(channels_str, "mono");
 301                 break;
 302             case 2:
 303                 strcpy(channels_str, "stereo");
 304                 break;
 305             case 6:
 306                 strcpy(channels_str, "5:1");
 307                 break;
 308             default:
 309                 sprintf(channels_str, "%d channels", enc->channels);
 310                 break;
 311         }
 312         if (enc->sample_rate) {
 313             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 314                      ", %d Hz, %s",
 315                      enc->sample_rate,
 316                      channels_str);
 317         }
 318
 319         /* for PCM codecs, compute bitrate directly */
 320         switch(enc->codec_id) {
 321         case CODEC_ID_PCM_S16LE:
 322         case CODEC_ID_PCM_S16BE:
 323         case CODEC_ID_PCM_U16LE:
 324         case CODEC_ID_PCM_U16BE:
 325             bitrate = enc->sample_rate * enc->channels * 16;
 326             break;
 327         case CODEC_ID_PCM_S8:
 328         case CODEC_ID_PCM_U8:
 329         case CODEC_ID_PCM_ALAW:
 330         case CODEC_ID_PCM_MULAW:
 331             bitrate = enc->sample_rate * enc->channels * 8;
 332             break;
 333         default:
 334             bitrate = enc->bit_rate;
 335             break;
 336         }
 337         break;
 338     default:
 339         av_abort();
 340     }
 341     if (encode) {
 342         if (enc->flags & CODEC_FLAG_PASS1)
 343             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 344                      ", pass 1");
 345         if (enc->flags & CODEC_FLAG_PASS2)
 346             snprintf(buf + strlen(buf), buf_size - strlen(buf),
 347                      ", pass 2");
 348     }
 349     if (bitrate != 0) {
 350         snprintf(buf + strlen(buf), buf_size - strlen(buf),
 351                  ", %d kb/s", bitrate / 1000);
 352     }
 353 }
 354
 355 /* Picture field are filled with 'ptr' addresses */
 356 void avpicture_fill(AVPicture *picture, UINT8 *ptr,
 357                     int pix_fmt, int width, int height)
 358 {
 359     int size;
 360
 361     size = width * height;
 362     switch(pix_fmt) {
 363     case PIX_FMT_YUV420P:
 364         picture->data[0] = ptr;
 365         picture->data[1] = picture->data[0] + size;
 366         picture->data[2] = picture->data[1] + size / 4;
 367         picture->linesize[0] = width;
 368         picture->linesize[1] = width / 2;
 369         picture->linesize[2] = width / 2;
 370         break;
 371     case PIX_FMT_YUV422P:
 372         picture->data[0] = ptr;
 373         picture->data[1] = picture->data[0] + size;
 374         picture->data[2] = picture->data[1] + size / 2;
 375         picture->linesize[0] = width;
 376         picture->linesize[1] = width / 2;
 377         picture->linesize[2] = width / 2;
 378         break;
 379     case PIX_FMT_YUV444P:
 380         picture->data[0] = ptr;
 381         picture->data[1] = picture->data[0] + size;
 382         picture->data[2] = picture->data[1] + size;
 383         picture->linesize[0] = width;
 384         picture->linesize[1] = width;
 385         picture->linesize[2] = width;
 386         break;
 387     case PIX_FMT_RGB24:
 388     case PIX_FMT_BGR24:
 389         picture->data[0] = ptr;
 390         picture->data[1] = NULL;
 391         picture->data[2] = NULL;
 392         picture->linesize[0] = width * 3;
 393         break;
 394     case PIX_FMT_RGBA32:
 395     case PIX_FMT_BGRA32:
 396         picture->data[0] = ptr;
 397         picture->data[1] = NULL;
 398         picture->data[2] = NULL;
 399         picture->linesize[0] = width * 4;
 400         break;
 401     case PIX_FMT_YUV422:
 402         picture->data[0] = ptr;
 403         picture->data[1] = NULL;
 404         picture->data[2] = NULL;
 405         picture->linesize[0] = width * 2;
 406         break;
 407     default:
 408         picture->data[0] = NULL;
 409         picture->data[1] = NULL;
 410         picture->data[2] = NULL;
 411         break;
 412     }
 413 }
 414
 415 int avpicture_get_size(int pix_fmt, int width, int height)
 416 {
 417     int size;
 418
 419     size = width * height;
 420     switch(pix_fmt) {
 421     case PIX_FMT_YUV420P:
 422         size = (size * 3) / 2;
 423         break;
 424     case PIX_FMT_YUV422P:
 425         size = (size * 2);
 426         break;
 427     case PIX_FMT_YUV444P:
 428         size = (size * 3);
 429         break;
 430     case PIX_FMT_RGB24:
 431     case PIX_FMT_BGR24:
 432         size = (size * 3);
 433         break;
 434     case PIX_FMT_RGBA32:
 435     case PIX_FMT_BGRA32:
 436         size = (size * 4);
 437         break;
 438     case PIX_FMT_YUV422:
 439         size = (size * 2);
 440         break;
 441     default:
 442         size = -1;
 443         break;
 444     }
 445     return size;
 446 }
 447
 448 unsigned avcodec_version( void )
 449 {
 450   return LIBAVCODEC_VERSION_INT;
 451 }
 452
 453 unsigned avcodec_build( void )
 454 {
 455   return LIBAVCODEC_BUILD;
 456 }
 457
 458 /* must be called before any other functions */
 459 void avcodec_init(void)
 460 {
 461     static int inited = 0;
 462
 463     if (inited != 0)
 464         return;
 465     inited = 1;
 466
 467     dsputil_init();
 468 }
 469
 470 /* this should be called after seeking and before trying to decode the next frame */
 471 void avcodec_flush_buffers(AVCodecContext *avctx)
 472 {
 473     MpegEncContext *s = avctx->priv_data;
 474     s->num_available_buffers=0;
 475 }
 476
 477
 478 static int raw_encode_init(AVCodecContext *s)
 479 {
 480     return 0;
 481 }
 482
 483 static int raw_decode_frame(AVCodecContext *avctx,
 484                             void *data, int *data_size,
 485                             UINT8 *buf, int buf_size)
 486 {
 487     return -1;
 488 }
 489
 490 static int raw_encode_frame(AVCodecContext *avctx,
 491                             unsigned char *frame, int buf_size, void *data)
 492 {
 493     return -1;
 494 }
 495
 496 AVCodec rawvideo_codec = {
 497     "rawvideo",
 498     CODEC_TYPE_VIDEO,
 499     CODEC_ID_RAWVIDEO,
 500     0,
 501     raw_encode_init,
 502     raw_encode_frame,
 503     NULL,
 504     raw_decode_frame,
 505 };