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

   1 /*
   2  * Indeo Video Interactive v5 compatible decoder
   3  * Copyright (c) 2009 Maxim Poliakovski
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg 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.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg 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 FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file libavcodec/indeo5.c
  24  * Indeo Video Interactive version 5 decoder
  25  *
  26  * Indeo5 data is usually transported within .avi or .mov files.
  27  * Known FOURCCs: 'IV50'
  28  */
  29
  30 #define ALT_BITSTREAM_READER_LE
  31 #include "avcodec.h"
  32 #include "get_bits.h"
  33 #include "ivi_dsp.h"
  34 #include "ivi_common.h"
  35 #include "indeo5data.h"
  36
  37 /**
  38  *  Indeo5 frame types.
  39  */
  40 enum {
  41     FRAMETYPE_INTRA       = 0,
  42     FRAMETYPE_INTER       = 1,  ///< non-droppable P-frame
  43     FRAMETYPE_INTER_SCAL  = 2,  ///< droppable P-frame used in the scalability mode
  44     FRAMETYPE_INTER_NOREF = 3,  ///< droppable P-frame
  45     FRAMETYPE_NULL        = 4   ///< empty frame with no data
  46 };
  47
  48 #define IVI5_PIC_SIZE_ESC       15
  49
  50 #define IVI5_IS_PROTECTED       0x20
  51
  52 typedef struct {
  53     GetBitContext   gb;
  54     AVFrame         frame;
  55     RVMapDesc       rvmap_tabs[9];   ///< local corrected copy of the static rvmap tables
  56     IVIPlaneDesc    planes[3];       ///< color planes
  57     const uint8_t   *frame_data;     ///< input frame data pointer
  58     int             buf_switch;      ///< used to switch between three buffers
  59     int             dst_buf;
  60     int             ref_buf;
  61     uint32_t        frame_size;      ///< frame size in bytes
  62     int             frame_type;
  63     int             prev_frame_type; ///< frame type of the previous frame
  64     int             frame_num;
  65     uint32_t        pic_hdr_size;    ///< picture header size in bytes
  66     uint8_t         frame_flags;
  67     uint16_t        checksum;        ///< frame checksum
  68
  69     int16_t         mb_huff_sel;     ///< MB huffman table selector
  70     IVIHuffDesc     mb_huff_desc;    ///< MB table descriptor associated with the selector above
  71     VLC             *mb_vlc;         ///< ptr to the vlc table for decoding macroblock data
  72     VLC             mb_vlc_cust;     ///< custom macroblock vlc table
  73
  74     uint16_t        gop_hdr_size;
  75     uint8_t         gop_flags;
  76     int             is_scalable;
  77     uint32_t        lock_word;
  78     IVIPicConfig    pic_conf;
  79 } IVI5DecContext;
  80
  81 //! static vlc tables (initialized at startup)
  82 static VLC mb_vlc_tabs [8];
  83 static VLC blk_vlc_tabs[8];
  84
  85
  86 /**
  87  *  Decodes Indeo5 GOP (Group of pictures) header.
  88  *  This header is present in key frames only.
  89  *  It defines parameters for all frames in a GOP.
  90  *
  91  *  @param ctx      [in,out] ptr to the decoder context
  92  *  @param avctx    [in] ptr to the AVCodecContext
  93  *  @return         result code: 0 = OK, -1 = error
  94  */
  95 static int decode_gop_header(IVI5DecContext *ctx, AVCodecContext *avctx)
  96 {
  97     int             result, i, p, tile_size, pic_size_indx, mb_size, blk_size, blk_size_changed = 0;
  98     IVIBandDesc     *band, *band1, *band2;
  99     IVIPicConfig    pic_conf;
 100
 101     ctx->gop_flags = get_bits(&ctx->gb, 8);
 102
 103     ctx->gop_hdr_size = (ctx->gop_flags & 1) ? get_bits(&ctx->gb, 16) : 0;
 104
 105     if (ctx->gop_flags & IVI5_IS_PROTECTED)
 106         ctx->lock_word = get_bits_long(&ctx->gb, 32);
 107
 108     tile_size = (ctx->gop_flags & 0x40) ? 64 << get_bits(&ctx->gb, 2) : 0;
 109     if (tile_size > 256) {
 110         av_log(avctx, AV_LOG_ERROR, "Invalid tile size: %d\n", tile_size);
 111         return -1;
 112     }
 113
 114     /* decode number of wavelet bands */
 115     /* num_levels * 3 + 1 */
 116     pic_conf.luma_bands   = get_bits(&ctx->gb, 2) * 3 + 1;
 117     pic_conf.chroma_bands = get_bits1(&ctx->gb)   * 3 + 1;
 118     ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
 119     if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
 120         av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
 121                pic_conf.luma_bands, pic_conf.chroma_bands);
 122         return -1;
 123     }
 124
 125     pic_size_indx = get_bits(&ctx->gb, 4);
 126     if (pic_size_indx == IVI5_PIC_SIZE_ESC) {
 127         pic_conf.pic_height = get_bits(&ctx->gb, 13);
 128         pic_conf.pic_width  = get_bits(&ctx->gb, 13);
 129     } else {
 130         pic_conf.pic_height = ivi5_common_pic_sizes[pic_size_indx * 2 + 1] << 2;
 131         pic_conf.pic_width  = ivi5_common_pic_sizes[pic_size_indx * 2    ] << 2;
 132     }
 133
 134     if (ctx->gop_flags & 2) {
 135         av_log(avctx, AV_LOG_ERROR, "YV12 picture format not supported!\n");
 136         return -1;
 137     }
 138
 139     pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;
 140     pic_conf.chroma_width  = (pic_conf.pic_width  + 3) >> 2;
 141
 142     if (!tile_size) {
 143         pic_conf.tile_height = pic_conf.pic_height;
 144         pic_conf.tile_width  = pic_conf.pic_width;
 145     } else {
 146         pic_conf.tile_height = pic_conf.tile_width = tile_size;
 147     }
 148
 149     /* check if picture layout was changed and reallocate buffers */
 150     if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {
 151         result = ff_ivi_init_planes(ctx->planes, &pic_conf);
 152         if (result) {
 153             av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
 154             return -1;
 155         }
 156         ctx->pic_conf = pic_conf;
 157         blk_size_changed = 1; /* force reallocation of the internal structures */
 158     }
 159
 160     for (p = 0; p <= 1; p++) {
 161         for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) {
 162             band = &ctx->planes[p].bands[i];
 163
 164             band->is_halfpel = get_bits1(&ctx->gb);
 165
 166             mb_size  = get_bits1(&ctx->gb);
 167             blk_size = 8 >> get_bits1(&ctx->gb);
 168             mb_size  = blk_size << !mb_size;
 169
 170             blk_size_changed = mb_size != band->mb_size || blk_size != band->blk_size;
 171             if (blk_size_changed) {
 172                 band->mb_size  = mb_size;
 173                 band->blk_size = blk_size;
 174             }
 175
 176             if (get_bits1(&ctx->gb)) {
 177                 av_log(avctx, AV_LOG_ERROR, "Extended transform info encountered!\n");
 178                 return -1;
 179             }
 180
 181             /* select transform function and scan pattern according to plane and band number */
 182             switch ((p << 2) + i) {
 183             case 0:
 184                 band->inv_transform = ff_ivi_inverse_slant_8x8;
 185                 band->dc_transform  = ff_ivi_dc_slant_2d;
 186                 band->scan          = ivi5_scans8x8[0];
 187                 break;
 188
 189             case 1:
 190                 band->inv_transform = ff_ivi_row_slant8;
 191                 band->dc_transform  = ff_ivi_dc_row_slant;
 192                 band->scan          = ivi5_scans8x8[1];
 193                 break;
 194
 195             case 2:
 196                 band->inv_transform = ff_ivi_col_slant8;
 197                 band->dc_transform  = ff_ivi_dc_col_slant;
 198                 band->scan          = ivi5_scans8x8[2];
 199                 break;
 200
 201             case 3:
 202                 band->inv_transform = ff_ivi_put_pixels_8x8;
 203                 band->dc_transform  = ff_ivi_put_dc_pixel_8x8;
 204                 band->scan          = ivi5_scans8x8[2];
 205                 break;
 206
 207             case 4:
 208                 band->inv_transform = ff_ivi_inverse_slant_4x4;
 209                 band->dc_transform  = ff_ivi_dc_slant_2d;
 210                 band->scan          = ivi5_scan4x4;
 211                 break;
 212             }
 213
 214             band->is_2d_trans = band->inv_transform == ff_ivi_inverse_slant_8x8 ||
 215                                 band->inv_transform == ff_ivi_inverse_slant_4x4;
 216
 217             /* select dequant matrix according to plane and band number */
 218             if (!p) {
 219                 band->quant_mat = (pic_conf.luma_bands > 1) ? i+1 : 0;
 220             } else {
 221                 band->quant_mat = 5;
 222             }
 223
 224             if (get_bits(&ctx->gb, 2)) {
 225                 av_log(avctx, AV_LOG_ERROR, "End marker missing!\n");
 226                 return -1;
 227             }
 228         }
 229     }
 230
 231     /* copy chroma parameters into the 2nd chroma plane */
 232     for (i = 0; i < pic_conf.chroma_bands; i++) {
 233         band1 = &ctx->planes[1].bands[i];
 234         band2 = &ctx->planes[2].bands[i];
 235
 236         band2->width         = band1->width;
 237         band2->height        = band1->height;
 238         band2->mb_size       = band1->mb_size;
 239         band2->blk_size      = band1->blk_size;
 240         band2->is_halfpel    = band1->is_halfpel;
 241         band2->quant_mat     = band1->quant_mat;
 242         band2->scan          = band1->scan;
 243         band2->inv_transform = band1->inv_transform;
 244         band2->dc_transform  = band1->dc_transform;
 245         band2->is_2d_trans   = band1->is_2d_trans;
 246     }
 247
 248     /* reallocate internal structures if needed */
 249     if (blk_size_changed) {
 250         result = ff_ivi_init_tiles(ctx->planes, pic_conf.tile_width,
 251                                    pic_conf.tile_height);
 252         if (result) {
 253             av_log(avctx, AV_LOG_ERROR,
 254                    "Couldn't reallocate internal structures!\n");
 255             return -1;
 256         }
 257     }
 258
 259     if (ctx->gop_flags & 8) {
 260         if (get_bits(&ctx->gb, 3)) {
 261             av_log(avctx, AV_LOG_ERROR, "Alignment bits are not zero!\n");
 262             return -1;
 263         }
 264
 265         if (get_bits1(&ctx->gb))
 266             skip_bits_long(&ctx->gb, 24); /* skip transparency fill color */
 267     }
 268
 269     align_get_bits(&ctx->gb);
 270
 271     skip_bits(&ctx->gb, 23); /* FIXME: unknown meaning */
 272
 273     /* skip GOP extension if any */
 274     if (get_bits1(&ctx->gb)) {
 275         do {
 276             i = get_bits(&ctx->gb, 16);
 277         } while (i & 0x8000);
 278     }
 279
 280     align_get_bits(&ctx->gb);
 281
 282     return 0;
 283 }
 284
 285
 286 /**
 287  *  Skips a header extension.
 288  *
 289  *  @param gb   [in,out] the GetBit context
 290  */
 291 static inline void skip_hdr_extension(GetBitContext *gb)
 292 {
 293     int i, len;
 294
 295     do {
 296         len = get_bits(gb, 8);
 297         for (i = 0; i < len; i++) skip_bits(gb, 8);
 298     } while(len);
 299 }
 300
 301
 302 /**
 303  *  Decodes Indeo5 picture header.
 304  *
 305  *  @param ctx      [in,out] ptr to the decoder context
 306  *  @param avctx    [in] ptr to the AVCodecContext
 307  *  @return         result code: 0 = OK, -1 = error
 308  */
 309 static int decode_pic_hdr(IVI5DecContext *ctx, AVCodecContext *avctx)
 310 {
 311     int         result;
 312     IVIHuffDesc new_huff;
 313
 314     if (get_bits(&ctx->gb, 5) != 0x1F) {
 315         av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");
 316         return -1;
 317     }
 318
 319     ctx->prev_frame_type = ctx->frame_type;
 320     ctx->frame_type      = get_bits(&ctx->gb, 3);
 321     if (ctx->frame_type >= 5) {
 322         av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d \n", ctx->frame_type);
 323         return -1;
 324     }
 325
 326     ctx->frame_num = get_bits(&ctx->gb, 8);
 327
 328     if (ctx->frame_type == FRAMETYPE_INTRA) {
 329         if (decode_gop_header(ctx, avctx))
 330             return -1;
 331     }
 332
 333     if (ctx->frame_type != FRAMETYPE_NULL) {
 334         ctx->frame_flags = get_bits(&ctx->gb, 8);
 335
 336         ctx->pic_hdr_size = (ctx->frame_flags & 1) ? get_bits_long(&ctx->gb, 24) : 0;
 337
 338         ctx->checksum = (ctx->frame_flags & 0x10) ? get_bits(&ctx->gb, 16) : 0;
 339
 340         /* skip unknown extension if any */
 341         if (ctx->frame_flags & 0x20)
 342             skip_hdr_extension(&ctx->gb); /* XXX: untested */
 343
 344         /* decode macroblock huffman codebook */
 345         if (ctx->frame_flags & 0x40) {
 346             ctx->mb_huff_sel = ff_ivi_dec_huff_desc(&ctx->gb, &new_huff);
 347             if (ctx->mb_huff_sel != 7) {
 348                 ctx->mb_vlc = &mb_vlc_tabs[ctx->mb_huff_sel];
 349             } else {
 350                 if (ff_ivi_huff_desc_cmp(&new_huff, &ctx->mb_huff_desc)) {
 351                     ff_ivi_huff_desc_copy(&ctx->mb_huff_desc, &new_huff);
 352
 353                     if (ctx->mb_vlc_cust.table)
 354                         free_vlc(&ctx->mb_vlc_cust);
 355                     result = ff_ivi_create_huff_from_desc(&ctx->mb_huff_desc,
 356                                                           &ctx->mb_vlc_cust, 0);
 357                     if (result) {
 358                         av_log(avctx, AV_LOG_ERROR, "Error while initializing custom macroblock vlc table!\n");
 359                         return -1;
 360                     }
 361                 }
 362                 ctx->mb_vlc = &ctx->mb_vlc_cust;
 363             }
 364         } else {
 365             ctx->mb_vlc = &mb_vlc_tabs[7]; /* select the default macroblock huffman table */
 366         }
 367
 368         skip_bits(&ctx->gb, 3); /* FIXME: unknown meaning! */
 369     }
 370
 371     align_get_bits(&ctx->gb);
 372
 373     return 0;
 374 }
 375
 376
 377 /**
 378  *  Decodes Indeo5 band header.
 379  *
 380  *  @param ctx      [in,out] ptr to the decoder context
 381  *  @param band     [in,out] ptr to the band descriptor
 382  *  @param avctx    [in] ptr to the AVCodecContext
 383  *  @return         result code: 0 = OK, -1 = error
 384  */
 385 static int decode_band_hdr(IVI5DecContext *ctx, IVIBandDesc *band,
 386                            AVCodecContext *avctx)
 387 {
 388     int         i, result;
 389     uint8_t     band_flags;
 390     IVIHuffDesc new_huff;
 391
 392     band_flags = get_bits(&ctx->gb, 8);
 393
 394     if (band_flags & 1) {
 395         band->is_empty = 1;
 396         return 0;
 397     }
 398
 399     band->data_size = (ctx->frame_flags & 0x80) ? get_bits_long(&ctx->gb, 24) : 0;
 400
 401     band->inherit_mv     = band_flags & 2;
 402     band->inherit_qdelta = band_flags & 8;
 403     band->qdelta_present = band_flags & 4;
 404     if (!band->qdelta_present) band->inherit_qdelta = 1;
 405
 406     /* decode rvmap probability corrections if any */
 407     band->num_corr = 0; /* there are no corrections */
 408     if (band_flags & 0x10) {
 409         band->num_corr = get_bits(&ctx->gb, 8); /* get number of correction pairs */
 410         if (band->num_corr > 61) {
 411             av_log(avctx, AV_LOG_ERROR, "Too many corrections: %d\n",
 412                    band->num_corr);
 413             return -1;
 414         }
 415
 416         /* read correction pairs */
 417         for (i = 0; i < band->num_corr * 2; i++)
 418             band->corr[i] = get_bits(&ctx->gb, 8);
 419     }
 420
 421     /* select appropriate rvmap table for this band */
 422     band->rvmap_sel = (band_flags & 0x40) ? get_bits(&ctx->gb, 3) : 8;
 423
 424     /* decode block huffman codebook */
 425     if (band_flags & 0x80) {
 426         band->huff_sel = ff_ivi_dec_huff_desc(&ctx->gb, &new_huff);
 427         if (band->huff_sel != 7) {
 428             band->blk_vlc = &blk_vlc_tabs[band->huff_sel];
 429         } else {
 430             if (ff_ivi_huff_desc_cmp(&new_huff, &band->huff_desc)) {
 431                 ff_ivi_huff_desc_copy(&band->huff_desc, &new_huff);
 432
 433                 if (band->blk_vlc_cust.table)
 434                     free_vlc(&band->blk_vlc_cust);
 435                 result = ff_ivi_create_huff_from_desc(&band->huff_desc,
 436                                                       &band->blk_vlc_cust, 0);
 437                 if (result) {
 438                     av_log(avctx, AV_LOG_ERROR, "Error while initializing custom block vlc table!\n");
 439                     return -1;
 440                 }
 441             }
 442             band->blk_vlc = &band->blk_vlc_cust;
 443         }
 444     } else {
 445         band->blk_vlc = &blk_vlc_tabs[7]; /* select the default macroblock huffman table */
 446     }
 447
 448     band->checksum_present = get_bits1(&ctx->gb);
 449     if (band->checksum_present)
 450         band->checksum = get_bits(&ctx->gb, 16);
 451
 452     band->glob_quant = get_bits(&ctx->gb, 5);
 453
 454     /* skip unknown extension if any */
 455     if (band_flags & 0x20) { /* XXX: untested */
 456         align_get_bits(&ctx->gb);
 457         skip_hdr_extension(&ctx->gb);
 458     }
 459
 460     align_get_bits(&ctx->gb);
 461
 462     return 0;
 463 }
 464
 465
 466 /**
 467  *  Decodes info (block type, cbp, quant delta, motion vector)
 468  *  for all macroblocks in the current tile.
 469  *
 470  *  @param ctx      [in,out] ptr to the decoder context
 471  *  @param band     [in,out] ptr to the band descriptor
 472  *  @param tile     [in,out] ptr to the tile descriptor
 473  *  @param avctx    [in] ptr to the AVCodecContext
 474  *  @return         result code: 0 = OK, -1 = error
 475  */
 476 static int decode_mb_info(IVI5DecContext *ctx, IVIBandDesc *band,
 477                           IVITile *tile, AVCodecContext *avctx)
 478 {
 479     int         x, y, mv_x, mv_y, mv_delta, offs, mb_offset,
 480                 mv_scale, blks_per_mb;
 481     IVIMbInfo   *mb, *ref_mb;
 482     int         row_offset = band->mb_size * band->pitch;
 483
 484     mb     = tile->mbs;
 485     ref_mb = tile->ref_mbs;
 486     offs   = tile->ypos * band->pitch + tile->xpos;
 487
 488     /* scale factor for motion vectors */
 489     mv_scale = (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3);
 490     mv_x = mv_y = 0;
 491
 492     for (y = tile->ypos; y < (tile->ypos + tile->height); y += band->mb_size) {
 493         mb_offset = offs;
 494
 495         for (x = tile->xpos; x < (tile->xpos + tile->width); x += band->mb_size) {
 496             mb->xpos     = x;
 497             mb->ypos     = y;
 498             mb->buf_offs = mb_offset;
 499
 500             if (get_bits1(&ctx->gb)) {
 501                 if (ctx->frame_type == FRAMETYPE_INTRA) {
 502                     av_log(avctx, AV_LOG_ERROR, "Empty macroblock in an INTRA picture!\n");
 503                     return -1;
 504                 }
 505                 mb->type = 1; /* empty macroblocks are always INTER */
 506                 mb->cbp  = 0; /* all blocks are empty */
 507
 508                 mb->q_delta = 0;
 509                 if (!band->plane && !band->band_num && (ctx->frame_flags & 8)) {
 510                     mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc->table,
 511                                            IVI_VLC_BITS, 1);
 512                     mb->q_delta = IVI_TOSIGNED(mb->q_delta);
 513                 }
 514
 515                 mb->mv_x = mb->mv_y = 0; /* no motion vector coded */
 516                 if (band->inherit_mv){
 517                     /* motion vector inheritance */
 518                     if (mv_scale) {
 519                         mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
 520                         mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
 521                     } else {
 522                         mb->mv_x = ref_mb->mv_x;
 523                         mb->mv_y = ref_mb->mv_y;
 524                     }
 525                 }
 526             } else {
 527                 if (band->inherit_mv) {
 528                     mb->type = ref_mb->type; /* copy mb_type from corresponding reference mb */
 529                 } else if (ctx->frame_type == FRAMETYPE_INTRA) {
 530                     mb->type = 0; /* mb_type is always INTRA for intra-frames */
 531                 } else {
 532                     mb->type = get_bits1(&ctx->gb);
 533                 }
 534
 535                 blks_per_mb = band->mb_size != band->blk_size ? 4 : 1;
 536                 mb->cbp = get_bits(&ctx->gb, blks_per_mb);
 537
 538                 mb->q_delta = 0;
 539                 if (band->qdelta_present) {
 540                     if (band->inherit_qdelta) {
 541                         if (ref_mb) mb->q_delta = ref_mb->q_delta;
 542                     } else if (mb->cbp || (!band->plane && !band->band_num &&
 543                                            (ctx->frame_flags & 8))) {
 544                         mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc->table,
 545                                                IVI_VLC_BITS, 1);
 546                         mb->q_delta = IVI_TOSIGNED(mb->q_delta);
 547                     }
 548                 }
 549
 550                 if (!mb->type) {
 551                     mb->mv_x = mb->mv_y = 0; /* there is no motion vector in intra-macroblocks */
 552                 } else {
 553                     if (band->inherit_mv){
 554                         /* motion vector inheritance */
 555                         if (mv_scale) {
 556                             mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
 557                             mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
 558                         } else {
 559                             mb->mv_x = ref_mb->mv_x;
 560                             mb->mv_y = ref_mb->mv_y;
 561                         }
 562                     } else {
 563                         /* decode motion vector deltas */
 564                         mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc->table,
 565                                             IVI_VLC_BITS, 1);
 566                         mv_y += IVI_TOSIGNED(mv_delta);
 567                         mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc->table,
 568                                             IVI_VLC_BITS, 1);
 569                         mv_x += IVI_TOSIGNED(mv_delta);
 570                         mb->mv_x = mv_x;
 571                         mb->mv_y = mv_y;
 572                     }
 573                 }
 574             }
 575
 576             mb++;
 577             if (ref_mb)
 578                 ref_mb++;
 579             mb_offset += band->mb_size;
 580         }
 581
 582         offs += row_offset;
 583     }
 584
 585     align_get_bits(&ctx->gb);
 586
 587     return 0;
 588 }
 589
 590
 591 /**
 592  *  Decodes an Indeo5 band.
 593  *
 594  *  @param ctx      [in,out] ptr to the decoder context
 595  *  @param band     [in,out] ptr to the band descriptor
 596  *  @param avctx    [in] ptr to the AVCodecContext
 597  *  @return         result code: 0 = OK, -1 = error
 598  */
 599 static int decode_band(IVI5DecContext *ctx, int plane_num,
 600                        IVIBandDesc *band, AVCodecContext *avctx)
 601 {
 602     int         result, i, t, idx1, idx2;
 603     IVITile     *tile;
 604     uint16_t    chksum;
 605
 606     band->buf     = band->bufs[ctx->dst_buf];
 607     band->ref_buf = band->bufs[ctx->ref_buf];
 608     band->data_ptr = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);
 609
 610     result = decode_band_hdr(ctx, band, avctx);
 611     if (result) {
 612         av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",
 613                result);
 614         return -1;
 615     }
 616
 617     if (band->is_empty) {
 618         av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
 619         return -1;
 620     }
 621
 622     band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
 623
 624     /* apply corrections to the selected rvmap table if present */
 625     for (i = 0; i < band->num_corr; i++) {
 626         idx1 = band->corr[i*2];
 627         idx2 = band->corr[i*2+1];
 628         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
 629         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
 630     }
 631
 632     for (t = 0; t < band->num_tiles; t++) {
 633         tile = &band->tiles[t];
 634
 635         tile->is_empty = get_bits1(&ctx->gb);
 636         if (tile->is_empty) {
 637             ff_ivi_process_empty_tile(avctx, band, tile,
 638                                       (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));
 639             align_get_bits(&ctx->gb);
 640         } else {
 641             tile->data_size = ff_ivi_dec_tile_data_size(&ctx->gb);
 642
 643             result = decode_mb_info(ctx, band, tile, avctx);
 644             if (result < 0)
 645                 break;
 646
 647             if (band->blk_size == 8) {
 648                 band->intra_base  = &ivi5_base_quant_8x8_intra[band->quant_mat][0];
 649                 band->inter_base  = &ivi5_base_quant_8x8_inter[band->quant_mat][0];
 650                 band->intra_scale = &ivi5_scale_quant_8x8_intra[band->quant_mat][0];
 651                 band->inter_scale = &ivi5_scale_quant_8x8_inter[band->quant_mat][0];
 652             } else {
 653                 band->intra_base  = ivi5_base_quant_4x4_intra;
 654                 band->inter_base  = ivi5_base_quant_4x4_inter;
 655                 band->intra_scale = ivi5_scale_quant_4x4_intra;
 656                 band->inter_scale = ivi5_scale_quant_4x4_inter;
 657             }
 658
 659             result = ff_ivi_decode_blocks(&ctx->gb, band, tile);
 660             if (result < 0) {
 661                 av_log(avctx, AV_LOG_ERROR, "Corrupted blocks data encountered!\n");
 662                 break;
 663             }
 664         }
 665     }
 666
 667     /* restore the selected rvmap table by applying its corrections in reverse order */
 668     for (i = band->num_corr-1; i >= 0; i--) {
 669         idx1 = band->corr[i*2];
 670         idx2 = band->corr[i*2+1];
 671         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
 672         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
 673     }
 674
 675     if (IVI_DEBUG && band->checksum_present) {
 676         chksum = ivi_calc_band_checksum(band);
 677         if (chksum != band->checksum) {
 678             av_log(avctx, AV_LOG_ERROR,
 679                    "Band checksum mismatch! Plane %d, band %d, received: %x, calculated: %x\n",
 680                    band->plane, band->band_num, band->checksum, chksum);
 681         }
 682     }
 683
 684     return result;
 685 }
 686
 687
 688 /**
 689  *  Switches buffers.
 690  *
 691  *  @param ctx      [in,out] ptr to the decoder context
 692  *  @param avctx    [in] ptr to the AVCodecContext
 693  */
 694 static void switch_buffers(IVI5DecContext *ctx, AVCodecContext *avctx)
 695 {
 696     switch (ctx->frame_type) {
 697     case FRAMETYPE_INTRA:
 698         ctx->buf_switch = 0;
 699         ctx->dst_buf    = 0;
 700         ctx->ref_buf    = 0;
 701         break;
 702     case FRAMETYPE_INTER:
 703         ctx->buf_switch &= 1;
 704         /* swap buffers only if there were no droppable frames */
 705         if (ctx->prev_frame_type != FRAMETYPE_INTER_NOREF &&
 706             ctx->prev_frame_type != FRAMETYPE_INTER_SCAL)
 707             ctx->buf_switch ^= 1;
 708         ctx->dst_buf = ctx->buf_switch;
 709         ctx->ref_buf = ctx->buf_switch ^ 1;
 710         break;
 711     case FRAMETYPE_INTER_SCAL:
 712         if (ctx->prev_frame_type == FRAMETYPE_INTER_NOREF)
 713             break;
 714         if (ctx->prev_frame_type != FRAMETYPE_INTER_SCAL) {
 715             ctx->buf_switch ^= 1;
 716             ctx->dst_buf     = ctx->buf_switch;
 717             ctx->ref_buf     = ctx->buf_switch ^ 1;
 718         } else {
 719             ctx->buf_switch ^= 2;
 720             ctx->dst_buf = 2;
 721             ctx->ref_buf = ctx->buf_switch & 1;
 722             if (!(ctx->buf_switch & 2))
 723                 FFSWAP(int, ctx->dst_buf, ctx->ref_buf);
 724         }
 725         break;
 726     case FRAMETYPE_INTER_NOREF:
 727         if (ctx->prev_frame_type == FRAMETYPE_INTER_SCAL) {
 728             ctx->buf_switch ^= 2;
 729             ctx->dst_buf = 2;
 730             ctx->ref_buf = ctx->buf_switch & 1;
 731             if (!(ctx->buf_switch & 2))
 732                 FFSWAP(int, ctx->dst_buf, ctx->ref_buf);
 733         } else {
 734             ctx->buf_switch ^= 1;
 735             ctx->dst_buf     =  ctx->buf_switch & 1;
 736             ctx->ref_buf     = (ctx->buf_switch & 1) ^ 1;
 737         }
 738         break;
 739     case FRAMETYPE_NULL:
 740         return;
 741     default:
 742         av_log(avctx, AV_LOG_ERROR, "unsupported frame type: %d\n", ctx->frame_type);
 743     }
 744 }
 745
 746
 747 /**
 748  *  Initializes Indeo5 decoder.
 749  */
 750 static av_cold int decode_init(AVCodecContext *avctx)
 751 {
 752     IVI5DecContext  *ctx = avctx->priv_data;
 753     int             i, result;
 754
 755     /* initialize static vlc tables for macroblock/block signals */
 756     for (i = 0; i < 8; i++) {
 757         ff_ivi_create_huff_from_desc(&ff_ivi_mb_huff_desc[i],  &mb_vlc_tabs[i],  1);
 758         ff_ivi_create_huff_from_desc(&ff_ivi_blk_huff_desc[i], &blk_vlc_tabs[i], 1);
 759     }
 760
 761     /* copy rvmap tables in our context so we can apply changes to them */
 762     memcpy(ctx->rvmap_tabs, ff_ivi_rvmap_tabs, sizeof(ff_ivi_rvmap_tabs));
 763
 764     /* set the initial picture layout according to the basic profile:
 765        there is only one band per plane (no scalability), only one tile (no local decoding)
 766        and picture format = YVU9 */
 767     ctx->pic_conf.pic_width     = avctx->width;
 768     ctx->pic_conf.pic_height    = avctx->height;
 769     ctx->pic_conf.chroma_width  = (avctx->width  + 3) >> 2;
 770     ctx->pic_conf.chroma_height = (avctx->height + 3) >> 2;
 771     ctx->pic_conf.tile_width    = avctx->width;
 772     ctx->pic_conf.tile_height   = avctx->height;
 773     ctx->pic_conf.luma_bands    = ctx->pic_conf.chroma_bands = 1;
 774
 775     result = ff_ivi_init_planes(ctx->planes, &ctx->pic_conf);
 776     if (result) {
 777         av_log(avctx, AV_LOG_ERROR, "Couldn't allocate color planes!\n");
 778         return -1;
 779     }
 780
 781     avctx->pix_fmt = PIX_FMT_YUV410P;
 782
 783     return 0;
 784 }
 785
 786
 787 /**
 788  *  main decoder function
 789  */
 790 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 791                         AVPacket *avpkt)
 792 {
 793     IVI5DecContext  *ctx = avctx->priv_data;
 794     const uint8_t   *buf = avpkt->data;
 795     int             buf_size = avpkt->size;
 796     int             result, p, b;
 797
 798     init_get_bits(&ctx->gb, buf, buf_size * 8);
 799     ctx->frame_data = buf;
 800     ctx->frame_size = buf_size;
 801
 802     result = decode_pic_hdr(ctx, avctx);
 803     if (result) {
 804         av_log(avctx, AV_LOG_ERROR,
 805                "Error while decoding picture header: %d\n", result);
 806         return -1;
 807     }
 808
 809     if (ctx->gop_flags & IVI5_IS_PROTECTED) {
 810         av_log(avctx, AV_LOG_ERROR, "Password-protected clip!\n");
 811         return -1;
 812     }
 813
 814     switch_buffers(ctx, avctx);
 815
 816     //START_TIMER;
 817
 818     if (ctx->frame_type == FRAMETYPE_NULL) {
 819         ctx->frame_type = ctx->prev_frame_type;
 820     } else {
 821         for (p = 0; p < 3; p++) {
 822             for (b = 0; b < ctx->planes[p].num_bands; b++) {
 823                 result = decode_band(ctx, p, &ctx->planes[p].bands[b], avctx);
 824                 if (result) {
 825                     av_log(avctx, AV_LOG_ERROR,
 826                            "Error while decoding band: %d, plane: %d\n", b, p);
 827                     return -1;
 828                 }
 829             }
 830         }
 831     }
 832
 833     //STOP_TIMER("decode_planes");
 834
 835     if (ctx->frame.data[0])
 836         avctx->release_buffer(avctx, &ctx->frame);
 837
 838     ctx->frame.reference = 0;
 839     if (avctx->get_buffer(avctx, &ctx->frame) < 0) {
 840         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 841         return -1;
 842     }
 843
 844     if (ctx->is_scalable) {
 845         ff_ivi_recompose53 (&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0], 4);
 846     } else {
 847         ff_ivi_output_plane(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
 848     }
 849
 850     ff_ivi_output_plane(&ctx->planes[2], ctx->frame.data[1], ctx->frame.linesize[1]);
 851     ff_ivi_output_plane(&ctx->planes[1], ctx->frame.data[2], ctx->frame.linesize[2]);
 852
 853     *data_size = sizeof(AVFrame);
 854     *(AVFrame*)data = ctx->frame;
 855
 856     return buf_size;
 857 }
 858
 859
 860 /**
 861  *  Closes Indeo5 decoder and cleans up its context.
 862  */
 863 static av_cold int decode_close(AVCodecContext *avctx)
 864 {
 865     IVI5DecContext *ctx = avctx->priv_data;
 866
 867     ff_ivi_free_buffers(&ctx->planes[0]);
 868
 869     if (ctx->frame.data[0])
 870         avctx->release_buffer(avctx, &ctx->frame);
 871
 872     return 0;
 873 }
 874
 875
 876 AVCodec indeo5_decoder = {
 877     .name           = "indeo5",
 878     .type           = CODEC_TYPE_VIDEO,
 879     .id             = CODEC_ID_INDEO5,
 880     .priv_data_size = sizeof(IVI5DecContext),
 881     .init           = decode_init,
 882     .close          = decode_close,
 883     .decode         = decode_frame,
 884     .long_name      = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 5"),
 885 };