vp8/decoder/dboolhuff.h

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11
  12 #ifndef DBOOLHUFF_H
  13 #define DBOOLHUFF_H
  14 #include <stddef.h>
  15 #include <limits.h>
  16 #include "vpx_ports/config.h"
  17 #include "vpx_ports/mem.h"
  18 #include "vpx/vpx_integer.h"
  19
  20 typedef size_t VP8_BD_VALUE;
  21
  22 # define VP8_BD_VALUE_SIZE ((int)sizeof(VP8_BD_VALUE)*CHAR_BIT)
  23 /*This is meant to be a large, positive constant that can still be efficiently
  24    loaded as an immediate (on platforms like ARM, for example).
  25   Even relatively modest values like 100 would work fine.*/
  26 # define VP8_LOTS_OF_BITS (0x40000000)
  27
  28
  29
  30 struct vp8_dboolhuff_rtcd_vtable;
  31
  32 typedef struct
  33 {
  34     const unsigned char *user_buffer_end;
  35     const unsigned char *user_buffer;
  36     VP8_BD_VALUE         value;
  37     int                  count;
  38     unsigned int         range;
  39 #if CONFIG_RUNTIME_CPU_DETECT
  40     struct vp8_dboolhuff_rtcd_vtable *rtcd;
  41 #endif
  42 } BOOL_DECODER;
  43
  44 #define prototype_dbool_start(sym) int sym(BOOL_DECODER *br, \
  45     const unsigned char *source, unsigned int source_sz)
  46 #define prototype_dbool_fill(sym) void sym(BOOL_DECODER *br)
  47 #define prototype_dbool_debool(sym) int sym(BOOL_DECODER *br, int probability)
  48 #define prototype_dbool_devalue(sym) int sym(BOOL_DECODER *br, int bits)
  49
  50 #if ARCH_ARM
  51 #include "arm/dboolhuff_arm.h"
  52 #endif
  53
  54 #ifndef vp8_dbool_start
  55 #define vp8_dbool_start vp8dx_start_decode_c
  56 #endif
  57
  58 #ifndef vp8_dbool_fill
  59 #define vp8_dbool_fill vp8dx_bool_decoder_fill_c
  60 #endif
  61
  62 #ifndef vp8_dbool_debool
  63 #define vp8_dbool_debool vp8dx_decode_bool_c
  64 #endif
  65
  66 #ifndef vp8_dbool_devalue
  67 #define vp8_dbool_devalue vp8dx_decode_value_c
  68 #endif
  69
  70 extern prototype_dbool_start(vp8_dbool_start);
  71 extern prototype_dbool_fill(vp8_dbool_fill);
  72 extern prototype_dbool_debool(vp8_dbool_debool);
  73 extern prototype_dbool_devalue(vp8_dbool_devalue);
  74
  75 typedef prototype_dbool_start((*vp8_dbool_start_fn_t));
  76 typedef prototype_dbool_fill((*vp8_dbool_fill_fn_t));
  77 typedef prototype_dbool_debool((*vp8_dbool_debool_fn_t));
  78 typedef prototype_dbool_devalue((*vp8_dbool_devalue_fn_t));
  79
  80 typedef struct vp8_dboolhuff_rtcd_vtable {
  81     vp8_dbool_start_fn_t   start;
  82     vp8_dbool_fill_fn_t    fill;
  83     vp8_dbool_debool_fn_t  debool;
  84     vp8_dbool_devalue_fn_t devalue;
  85 } vp8_dboolhuff_rtcd_vtable_t;
  86
  87 /* There are no processor-specific versions of these
  88  * functions right now. Disable RTCD to avoid using
  89  * function pointers which gives a speed boost
  90  */
  91 /*#ifdef ENABLE_RUNTIME_CPU_DETECT
  92 #define DBOOLHUFF_INVOKE(ctx,fn) (ctx)->fn
  93 #define IF_RTCD(x) (x)
  94 #else*/
  95 #define DBOOLHUFF_INVOKE(ctx,fn) vp8_dbool_##fn
  96 #define IF_RTCD(x) NULL
  97 /*#endif*/
  98
  99 DECLARE_ALIGNED(16, extern const unsigned char, vp8dx_bitreader_norm[256]);
 100
 101 /* wrapper functions to hide RTCD. static means inline means hopefully no
 102  * penalty
 103  */
 104 static int vp8dx_start_decode(BOOL_DECODER *br,
 105         struct vp8_dboolhuff_rtcd_vtable *rtcd,
 106         const unsigned char *source, unsigned int source_sz) {
 107 #if CONFIG_RUNTIME_CPU_DETECT
 108     br->rtcd = rtcd;
 109 #endif
 110     return DBOOLHUFF_INVOKE(rtcd, start)(br, source, source_sz);
 111 }
 112 static void vp8dx_bool_decoder_fill(BOOL_DECODER *br) {
 113     DBOOLHUFF_INVOKE(br->rtcd, fill)(br);
 114 }
 115
 116 /*The refill loop is used in several places, so define it in a macro to make
 117    sure they're all consistent.
 118   An inline function would be cleaner, but has a significant penalty, because
 119    multiple BOOL_DECODER fields must be modified, and the compiler is not smart
 120    enough to eliminate the stores to those fields and the subsequent reloads
 121    from them when inlining the function.*/
 122 #define VP8DX_BOOL_DECODER_FILL(_count,_value,_bufptr,_bufend) \
 123     do \
 124     { \
 125         int shift; \
 126         for(shift = VP8_BD_VALUE_SIZE - 8 - ((_count) + 8); shift >= 0; ) \
 127         { \
 128             if((_bufptr) >= (_bufend)) { \
 129                 (_count) = VP8_LOTS_OF_BITS; \
 130                 break; \
 131             } \
 132             (_count) += 8; \
 133             (_value) |= (VP8_BD_VALUE)*(_bufptr)++ << shift; \
 134             shift -= 8; \
 135         } \
 136     } \
 137     while(0)
 138
 139
 140 static int vp8dx_decode_bool(BOOL_DECODER *br, int probability) {
 141   /*
 142    * Until optimized versions of this function are available, we
 143    * keep the implementation in the header to allow inlining.
 144    *
 145    *return DBOOLHUFF_INVOKE(br->rtcd, debool)(br, probability);
 146    */
 147     unsigned int bit = 0;
 148     VP8_BD_VALUE value;
 149     unsigned int split;
 150     VP8_BD_VALUE bigsplit;
 151     int count;
 152     unsigned int range;
 153
 154     value = br->value;
 155     count = br->count;
 156     range = br->range;
 157
 158     split = 1 + (((range - 1) * probability) >> 8);
 159     bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8);
 160
 161     range = split;
 162
 163     if (value >= bigsplit)
 164     {
 165         range = br->range - split;
 166         value = value - bigsplit;
 167         bit = 1;
 168     }
 169
 170     /*if(range>=0x80)
 171     {
 172         br->value = value;
 173         br->range = range;
 174         return bit
 175     }*/
 176
 177     {
 178         register unsigned int shift = vp8dx_bitreader_norm[range];
 179         range <<= shift;
 180         value <<= shift;
 181         count -= shift;
 182     }
 183     br->value = value;
 184     br->count = count;
 185     br->range = range;
 186     if(count < 0)
 187         vp8dx_bool_decoder_fill(br);
 188     return bit;
 189 }
 190
 191 static int vp8_decode_value(BOOL_DECODER *br, int bits)
 192 {
 193   /*
 194    * Until optimized versions of this function are available, we
 195    * keep the implementation in the header to allow inlining.
 196    *
 197    *return DBOOLHUFF_INVOKE(br->rtcd, devalue)(br, bits);
 198    */
 199     int z = 0;
 200     int bit;
 201
 202     for (bit = bits - 1; bit >= 0; bit--)
 203     {
 204         z |= (vp8dx_decode_bool(br, 0x80) << bit);
 205     }
 206
 207     return z;
 208 }
 209 #endif