indeo: Convert to the new bitstream reader
[libav.git] / libavcodec / indeo4.c
index ab42e7b..4b3f903 100644 (file)
@@ -29,7 +29,7 @@
 
 #define BITSTREAM_READER_LE
 #include "avcodec.h"
-#include "get_bits.h"
+#include "bitstream.h"
 #include "indeo4data.h"
 #include "internal.h"
 #include "ivi.h"
@@ -70,19 +70,19 @@ static const struct {
  *  - 4 wavelet bands per plane, size factor 1:4, code pattern: 2,3,3,3,3
  *  Anything else is either unsupported or corrupt.
  *
- *  @param[in,out] gb    the GetBit context
+ *  @param[in,out] bc    the Bitstream context
  *  @return        number of wavelet bands or 0 on error
  */
-static int decode_plane_subdivision(GetBitContext *gb)
+static int decode_plane_subdivision(BitstreamContext *bc)
 {
     int i;
 
-    switch (get_bits(gb, 2)) {
+    switch (bitstream_read(bc, 2)) {
     case 3:
         return 1;
     case 2:
         for (i = 0; i < 4; i++)
-            if (get_bits(gb, 2) != 3)
+            if (bitstream_read(bc, 2) != 3)
                 return 0;
         return 4;
     default:
@@ -107,13 +107,13 @@ static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
     int             pic_size_indx, i, p;
     IVIPicConfig    pic_conf;
 
-    if (get_bits(&ctx->gb, 18) != 0x3FFF8) {
+    if (bitstream_read(&ctx->bc, 18) != 0x3FFF8) {
         av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");
         return AVERROR_INVALIDDATA;
     }
 
     ctx->prev_frame_type = ctx->frame_type;
-    ctx->frame_type      = get_bits(&ctx->gb, 3);
+    ctx->frame_type      = bitstream_read(&ctx->bc, 3);
     if (ctx->frame_type == 7) {
         av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d\n", ctx->frame_type);
         return AVERROR_INVALIDDATA;
@@ -122,15 +122,15 @@ static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
     if (ctx->frame_type == IVI4_FRAMETYPE_BIDIR)
         ctx->has_b_frames = 1;
 
-    ctx->has_transp = get_bits1(&ctx->gb);
+    ctx->has_transp = bitstream_read_bit(&ctx->bc);
 
     /* unknown bit: Mac decoder ignores this bit, XANIM returns error */
-    if (get_bits1(&ctx->gb)) {
+    if (bitstream_read_bit(&ctx->bc)) {
         av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n");
         return AVERROR_INVALIDDATA;
     }
 
-    ctx->data_size = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 24) : 0;
+    ctx->data_size = bitstream_read_bit(&ctx->bc) ? bitstream_read(&ctx->bc, 24) : 0;
 
     /* null frames don't contain anything else so we just return */
     if (ctx->frame_type >= IVI4_FRAMETYPE_NULL_FIRST) {
@@ -141,32 +141,32 @@ static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
     /* Check key lock status. If enabled - ignore lock word.         */
     /* Usually we have to prompt the user for the password, but      */
     /* we don't do that because Indeo 4 videos can be decoded anyway */
-    if (get_bits1(&ctx->gb)) {
-        skip_bits_long(&ctx->gb, 32);
+    if (bitstream_read_bit(&ctx->bc)) {
+        bitstream_skip(&ctx->bc, 32);
         ff_dlog(avctx, "Password-protected clip!\n");
     }
 
-    pic_size_indx = get_bits(&ctx->gb, 3);
+    pic_size_indx = bitstream_read(&ctx->bc, 3);
     if (pic_size_indx == IVI4_PIC_SIZE_ESC) {
-        pic_conf.pic_height = get_bits(&ctx->gb, 16);
-        pic_conf.pic_width  = get_bits(&ctx->gb, 16);
+        pic_conf.pic_height = bitstream_read(&ctx->bc, 16);
+        pic_conf.pic_width  = bitstream_read(&ctx->bc, 16);
     } else {
         pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1];
         pic_conf.pic_width  = ivi4_common_pic_sizes[pic_size_indx * 2    ];
     }
 
     /* Decode tile dimensions. */
-    ctx->uses_tiling = get_bits1(&ctx->gb);
+    ctx->uses_tiling = bitstream_read_bit(&ctx->bc);
     if (ctx->uses_tiling) {
-        pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&ctx->gb, 4));
-        pic_conf.tile_width  = scale_tile_size(pic_conf.pic_width,  get_bits(&ctx->gb, 4));
+        pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, bitstream_read(&ctx->bc, 4));
+        pic_conf.tile_width  = scale_tile_size(pic_conf.pic_width,  bitstream_read(&ctx->bc, 4));
     } else {
         pic_conf.tile_height = pic_conf.pic_height;
         pic_conf.tile_width  = pic_conf.pic_width;
     }
 
     /* Decode chroma subsampling. We support only 4:4 aka YVU9. */
-    if (get_bits(&ctx->gb, 2)) {
+    if (bitstream_read(&ctx->bc, 2)) {
         av_log(avctx, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n");
         return AVERROR_INVALIDDATA;
     }
@@ -174,9 +174,9 @@ static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
     pic_conf.chroma_width  = (pic_conf.pic_width  + 3) >> 2;
 
     /* decode subdivision of the planes */
-    pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb);
+    pic_conf.luma_bands = decode_plane_subdivision(&ctx->bc);
     if (pic_conf.luma_bands)
-        pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb);
+        pic_conf.chroma_bands = decode_plane_subdivision(&ctx->bc);
     ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
     if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
         av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
@@ -210,40 +210,40 @@ static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
         }
     }
 
-    ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0;
+    ctx->frame_num = bitstream_read_bit(&ctx->bc) ? bitstream_read(&ctx->bc, 20) : 0;
 
     /* skip decTimeEst field if present */
-    if (get_bits1(&ctx->gb))
-        skip_bits(&ctx->gb, 8);
+    if (bitstream_read_bit(&ctx->bc))
+        bitstream_skip(&ctx->bc, 8);
 
     /* decode macroblock and block huffman codebooks */
-    if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_MB_HUFF,  &ctx->mb_vlc,  avctx) ||
-        ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF, &ctx->blk_vlc, avctx))
+    if (ff_ivi_dec_huff_desc(&ctx->bc, bitstream_read_bit(&ctx->bc), IVI_MB_HUFF,  &ctx->mb_vlc,  avctx) ||
+        ff_ivi_dec_huff_desc(&ctx->bc, bitstream_read_bit(&ctx->bc), IVI_BLK_HUFF, &ctx->blk_vlc, avctx))
         return AVERROR_INVALIDDATA;
 
-    ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
+    ctx->rvmap_sel = bitstream_read_bit(&ctx->bc) ? bitstream_read(&ctx->bc, 3) : 8;
 
-    ctx->in_imf = get_bits1(&ctx->gb);
-    ctx->in_q   = get_bits1(&ctx->gb);
+    ctx->in_imf = bitstream_read_bit(&ctx->bc);
+    ctx->in_q   = bitstream_read_bit(&ctx->bc);
 
-    ctx->pic_glob_quant = get_bits(&ctx->gb, 5);
+    ctx->pic_glob_quant = bitstream_read(&ctx->bc, 5);
 
     /* TODO: ignore this parameter if unused */
-    ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0;
+    ctx->unknown1 = bitstream_read_bit(&ctx->bc) ? bitstream_read(&ctx->bc, 3) : 0;
 
-    ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0;
+    ctx->checksum = bitstream_read_bit(&ctx->bc) ? bitstream_read(&ctx->bc, 16) : 0;
 
     /* skip picture header extension if any */
-    while (get_bits1(&ctx->gb)) {
+    while (bitstream_read_bit(&ctx->bc)) {
         ff_dlog(avctx, "Pic hdr extension encountered!\n");
-        skip_bits(&ctx->gb, 8);
+        bitstream_skip(&ctx->bc, 8);
     }
 
-    if (get_bits1(&ctx->gb)) {
+    if (bitstream_read_bit(&ctx->bc)) {
         av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n");
     }
 
-    align_get_bits(&ctx->gb);
+    bitstream_align(&ctx->bc);
 
     return 0;
 }
@@ -263,22 +263,22 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
     int plane, band_num, indx, transform_id, scan_indx;
     int i;
 
-    plane    = get_bits(&ctx->gb, 2);
-    band_num = get_bits(&ctx->gb, 4);
+    plane    = bitstream_read(&ctx->bc, 2);
+    band_num = bitstream_read(&ctx->bc, 4);
     if (band->plane != plane || band->band_num != band_num) {
         av_log(avctx, AV_LOG_ERROR, "Invalid band header sequence!\n");
         return AVERROR_INVALIDDATA;
     }
 
-    band->is_empty = get_bits1(&ctx->gb);
+    band->is_empty = bitstream_read_bit(&ctx->bc);
     if (!band->is_empty) {
         int old_blk_size = band->blk_size;
         /* skip header size
          * If header size is not given, header size is 4 bytes. */
-        if (get_bits1(&ctx->gb))
-            skip_bits(&ctx->gb, 16);
+        if (bitstream_read_bit(&ctx->bc))
+            bitstream_skip(&ctx->bc, 16);
 
-        band->is_halfpel = get_bits(&ctx->gb, 2);
+        band->is_halfpel = bitstream_read(&ctx->bc, 2);
         if (band->is_halfpel >= 2) {
             av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported mv resolution: %d!\n",
                    band->is_halfpel);
@@ -287,11 +287,11 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
         if (!band->is_halfpel)
             ctx->uses_fullpel = 1;
 
-        band->checksum_present = get_bits1(&ctx->gb);
+        band->checksum_present = bitstream_read_bit(&ctx->bc);
         if (band->checksum_present)
-            band->checksum = get_bits(&ctx->gb, 16);
+            band->checksum = bitstream_read(&ctx->bc, 16);
 
-        indx = get_bits(&ctx->gb, 2);
+        indx = bitstream_read(&ctx->bc, 2);
         if (indx == 3) {
             av_log(avctx, AV_LOG_ERROR, "Invalid block size!\n");
             return AVERROR_INVALIDDATA;
@@ -299,13 +299,13 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
         band->mb_size  = 16 >> indx;
         band->blk_size = 8 >> (indx >> 1);
 
-        band->inherit_mv     = get_bits1(&ctx->gb);
-        band->inherit_qdelta = get_bits1(&ctx->gb);
+        band->inherit_mv     = bitstream_read_bit(&ctx->bc);
+        band->inherit_qdelta = bitstream_read_bit(&ctx->bc);
 
-        band->glob_quant = get_bits(&ctx->gb, 5);
+        band->glob_quant = bitstream_read(&ctx->bc, 5);
 
-        if (!get_bits1(&ctx->gb) || ctx->frame_type == IVI4_FRAMETYPE_INTRA) {
-            transform_id = get_bits(&ctx->gb, 5);
+        if (!bitstream_read_bit(&ctx->bc) || ctx->frame_type == IVI4_FRAMETYPE_INTRA) {
+            transform_id = bitstream_read(&ctx->bc, 5);
             if (transform_id >= FF_ARRAY_ELEMS(transforms) ||
                 !transforms[transform_id].inv_trans) {
                 avpriv_request_sample(avctx, "Transform %d", transform_id);
@@ -331,7 +331,7 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
             if (band->blk_size != band->transform_size)
                 return AVERROR_INVALIDDATA;
 
-            scan_indx = get_bits(&ctx->gb, 4);
+            scan_indx = bitstream_read(&ctx->bc, 4);
             if (scan_indx == 15) {
                 av_log(avctx, AV_LOG_ERROR, "Custom scan pattern encountered!\n");
                 return AVERROR_INVALIDDATA;
@@ -344,7 +344,7 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
 
             band->scan = scan_index_to_tab[scan_indx];
 
-            band->quant_mat = get_bits(&ctx->gb, 5);
+            band->quant_mat = bitstream_read(&ctx->bc, 5);
             if (band->quant_mat >= FF_ARRAY_ELEMS(quant_index_to_tab)) {
 
                 if (band->quant_mat == 31)
@@ -370,20 +370,20 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
         }
 
         /* decode block huffman codebook */
-        if (!get_bits1(&ctx->gb))
+        if (!bitstream_read_bit(&ctx->bc))
             band->blk_vlc.tab = ctx->blk_vlc.tab;
         else
-            if (ff_ivi_dec_huff_desc(&ctx->gb, 1, IVI_BLK_HUFF,
+            if (ff_ivi_dec_huff_desc(&ctx->bc, 1, IVI_BLK_HUFF,
                                      &band->blk_vlc, avctx))
                 return AVERROR_INVALIDDATA;
 
         /* select appropriate rvmap table for this band */
-        band->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
+        band->rvmap_sel = bitstream_read_bit(&ctx->bc) ? bitstream_read(&ctx->bc, 3) : 8;
 
         /* decode rvmap probability corrections if any */
         band->num_corr = 0; /* there is no corrections */
-        if (get_bits1(&ctx->gb)) {
-            band->num_corr = get_bits(&ctx->gb, 8); /* get number of correction pairs */
+        if (bitstream_read_bit(&ctx->bc)) {
+            band->num_corr = bitstream_read(&ctx->bc, 8); /* get number of correction pairs */
             if (band->num_corr > 61) {
                 av_log(avctx, AV_LOG_ERROR, "Too many corrections: %d\n",
                        band->num_corr);
@@ -392,7 +392,7 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
 
             /* read correction pairs */
             for (i = 0; i < band->num_corr * 2; i++)
-                band->corr[i] = get_bits(&ctx->gb, 8);
+                band->corr[i] = bitstream_read(&ctx->bc, 8);
         }
     }
 
@@ -408,7 +408,7 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
     band->intra_scale = NULL;
     band->inter_scale = NULL;
 
-    align_get_bits(&ctx->gb);
+    bitstream_align(&ctx->bc);
 
     return 0;
 }
@@ -453,7 +453,7 @@ static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band,
             mb->b_mv_x   =
             mb->b_mv_y   = 0;
 
-            if (get_bits1(&ctx->gb)) {
+            if (bitstream_read_bit(&ctx->bc)) {
                 if (ctx->frame_type == IVI4_FRAMETYPE_INTRA) {
                     av_log(avctx, AV_LOG_ERROR, "Empty macroblock in an INTRA picture!\n");
                     return AVERROR_INVALIDDATA;
@@ -463,8 +463,9 @@ static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band,
 
                 mb->q_delta = 0;
                 if (!band->plane && !band->band_num && ctx->in_q) {
-                    mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
-                                           IVI_VLC_BITS, 1);
+                    mb->q_delta = bitstream_read_vlc(&ctx->bc,
+                                                     ctx->mb_vlc.tab->table,
+                                                     IVI_VLC_BITS, 1);
                     mb->q_delta = IVI_TOSIGNED(mb->q_delta);
                 }
 
@@ -489,18 +490,19 @@ static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band,
                            ctx->frame_type == IVI4_FRAMETYPE_INTRA1) {
                     mb->type = 0; /* mb_type is always INTRA for intra-frames */
                 } else {
-                    mb->type = get_bits(&ctx->gb, mb_type_bits);
+                    mb->type = bitstream_read(&ctx->bc, mb_type_bits);
                 }
 
-                mb->cbp = get_bits(&ctx->gb, blks_per_mb);
+                mb->cbp = bitstream_read(&ctx->bc, blks_per_mb);
 
                 mb->q_delta = 0;
                 if (band->inherit_qdelta) {
                     if (ref_mb) mb->q_delta = ref_mb->q_delta;
                 } else if (mb->cbp || (!band->plane && !band->band_num &&
                            ctx->in_q)) {
-                    mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
-                                           IVI_VLC_BITS, 1);
+                    mb->q_delta = bitstream_read_vlc(&ctx->bc,
+                                                     ctx->mb_vlc.tab->table,
+                                                     IVI_VLC_BITS, 1);
                     mb->q_delta = IVI_TOSIGNED(mb->q_delta);
                 }
 
@@ -519,22 +521,24 @@ static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band,
                             }
                     } else {
                         /* decode motion vector deltas */
-                        mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
-                                            IVI_VLC_BITS, 1);
+                        mv_delta = bitstream_read_vlc(&ctx->bc,
+                                                      ctx->mb_vlc.tab->table,
+                                                      IVI_VLC_BITS, 1);
                         mv_y += IVI_TOSIGNED(mv_delta);
-                        mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
-                                            IVI_VLC_BITS, 1);
+                        mv_delta = bitstream_read_vlc(&ctx->bc,
+                                                      ctx->mb_vlc.tab->table,
+                                                      IVI_VLC_BITS, 1);
                         mv_x += IVI_TOSIGNED(mv_delta);
                         mb->mv_x = mv_x;
                         mb->mv_y = mv_y;
                         if (mb->type == 3) {
-                            mv_delta = get_vlc2(&ctx->gb,
-                                                ctx->mb_vlc.tab->table,
-                                                IVI_VLC_BITS, 1);
+                            mv_delta = bitstream_read_vlc(&ctx->bc,
+                                                          ctx->mb_vlc.tab->table,
+                                                          IVI_VLC_BITS, 1);
                             mv_y += IVI_TOSIGNED(mv_delta);
-                            mv_delta = get_vlc2(&ctx->gb,
-                                                ctx->mb_vlc.tab->table,
-                                                IVI_VLC_BITS, 1);
+                            mv_delta = bitstream_read_vlc(&ctx->bc,
+                                                          ctx->mb_vlc.tab->table,
+                                                          IVI_VLC_BITS, 1);
                             mv_x += IVI_TOSIGNED(mv_delta);
                             mb->b_mv_x = -mv_x;
                             mb->b_mv_y = -mv_y;
@@ -558,7 +562,7 @@ static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band,
         offs += row_offset;
     }
 
-    align_get_bits(&ctx->gb);
+    bitstream_align(&ctx->bc);
 
     return 0;
 }