Fixes some issues in the MF range coder on systems were ints are 16 bits.
authorTimothy B.B Terriberry <tterribe@xiph.org>
Sun, 19 Oct 2008 18:24:53 +0000 (14:24 -0400)
committerJean-Marc Valin <jean-marc.valin@usherbrooke.ca>
Mon, 20 Oct 2008 00:01:34 +0000 (20:01 -0400)
libcelt/mfrngdec.c
libcelt/mfrngenc.c
libcelt/rangedec.c
libcelt/rangeenc.c

index 7026b39..08b88a0 100644 (file)
@@ -141,8 +141,7 @@ static int ec_dec_in(ec_dec *_this){
   ret=ec_byte_read1(_this->buf);
   if(ret<0){
     ret=0;
-    /*Needed to make sure the above conditional only triggers once, and to keep
-       oc_dec_tell() operating correctly.*/
+    /*Needed to keep oc_dec_tell() operating correctly.*/
     ec_byte_adv1(_this->buf);
   }
   return ret;
@@ -179,16 +178,19 @@ void ec_dec_init(ec_dec *_this,ec_byte_buffer *_buf){
 }
 
 unsigned ec_decode(ec_dec *_this,unsigned _ft){
-  unsigned d;
+  ec_uint32 ft;
+  ec_uint32 d;
+  unsigned  e;
   /*Step 1: Compute the normalization factor for the frequency counts.*/
   _this->nrm=EC_ILOG(_this->rng)-EC_ILOG(_ft);
-  _ft<<=_this->nrm;
-  d=_ft>_this->rng;
-  _ft>>=d;
-  _this->nrm-=d;
+  ft=(ec_uint32)_ft<<_this->nrm;
+  e=ft>_this->rng;
+  ft>>=e;
+  _this->nrm-=e;
   /*Step 2: invert the partition function.*/
-  d=_this->rng-_ft;
-  return EC_MAXI((int)(_this->dif>>1),(int)(_this->dif-d))>>_this->nrm;
+  d=_this->rng-ft;
+  return EC_MAXI((ec_int32)(_this->dif>>1),(ec_int32)(_this->dif-d))>>
+   _this->nrm;
   /*Step 3: The caller locates the range [fl,fh) containing the return value
      and calls ec_dec_update().*/
 }
@@ -198,16 +200,19 @@ unsigned ec_decode_bin(ec_dec *_this,unsigned bits){
 }
 
 void ec_dec_update(ec_dec *_this,unsigned _fl,unsigned _fh,unsigned _ft){
-  unsigned r;
-  unsigned s;
-  unsigned d;
+  ec_uint32 fl;
+  ec_uint32 fh;
+  ec_uint32 ft;
+  ec_uint32 r;
+  ec_uint32 s;
+  ec_uint32 d;
   /*Step 4: Evaluate the two partition function values.*/
-  _fl<<=_this->nrm;
-  _fh<<=_this->nrm;
-  _ft<<=_this->nrm;
-  d=_this->rng-_ft;
-  r=_fh+EC_MINI(_fh,d);
-  s=_fl+EC_MINI(_fl,d);
+  fl=(ec_uint32)_fl<<_this->nrm;
+  fh=(ec_uint32)_fh<<_this->nrm;
+  ft=(ec_uint32)_ft<<_this->nrm;
+  d=_this->rng-ft;
+  r=fh+EC_MINI(fh,d);
+  s=fl+EC_MINI(fl,d);
   /*Step 5: Update the interval.*/
   _this->rng=r-s;
   _this->dif-=s;
@@ -219,7 +224,8 @@ long ec_dec_tell(ec_dec *_this,int _b){
   ec_uint32 r;
   int       l;
   long      nbits;
-  nbits=ec_byte_bytes(_this->buf)-(EC_CODE_BITS+EC_SYM_BITS-1)/EC_SYM_BITS<<3;
+  nbits=(ec_byte_bytes(_this->buf)-(EC_CODE_BITS+EC_SYM_BITS-1)/EC_SYM_BITS)*
+   EC_SYM_BITS;
   /*To handle the non-integral number of bits still left in the encoder state,
      we compute the number of bits of low that must be encoded to ensure that
      the value is inside the range for any possible subsequent bits.
index 3f36954..2607460 100644 (file)
@@ -92,10 +92,14 @@ void ec_enc_init(ec_enc *_this,ec_byte_buffer *_buf){
 }
 
 void ec_encode(ec_enc *_this,unsigned _fl,unsigned _fh,unsigned _ft){
-  unsigned r;
-  unsigned s;
-  unsigned d;
-  int      nrm;
+  ec_uint32 fl;
+  ec_uint32 fh;
+  ec_uint32 ft;
+  ec_uint32 r;
+  ec_uint32 s;
+  ec_uint32 d;
+  int       e;
+  int       nrm;
   /*Step 1: we want ft in the range of [rng/2,rng).
     The high-order bits of the rng and ft are computed via a logarithm.
     This could also be done on some architectures with some custom assembly,
@@ -104,18 +108,18 @@ void ec_encode(ec_enc *_this,unsigned _fl,unsigned _fh,unsigned _ft){
   /*Having the same high order bit may be too much.
     We may need to shift one less to ensure that ft is actually in the proper
      range.*/
-  _ft<<=nrm;
-  d=_ft>_this->rng;
-  _ft>>=d;
-  nrm-=d;
+  ft=(ec_uint32)_ft<<nrm;
+  e=ft>_this->rng;
+  ft>>=e;
+  nrm-=e;
   /*We then scale everything by the computed power of 2.*/
-  _fl<<=nrm;
-  _fh<<=nrm;
+  fl=(ec_uint32)_fl<<nrm;
+  fh=(ec_uint32)_fh<<nrm;
   /*Step 2: compute the two values of the partition function.
     d is the splitting point of the interval [0,ft).*/
-  d=_this->rng-_ft;
-  r=_fh+EC_MINI(_fh,d);
-  s=_fl+EC_MINI(_fl,d);
+  d=_this->rng-ft;
+  r=fh+EC_MINI(fh,d);
+  s=fl+EC_MINI(fl,d);
   /*Step 3: Update the end-point and range of the interval.*/
   _this->low+=s;
   _this->rng=r-s;
@@ -131,7 +135,7 @@ long ec_enc_tell(ec_enc *_this,int _b){
   ec_uint32 r;
   int       l;
   long      nbits;
-  nbits=ec_byte_bytes(_this->buf)+(_this->rem>=0)+_this->ext<<3;
+  nbits=(ec_byte_bytes(_this->buf)+(_this->rem>=0)+_this->ext)*EC_SYM_BITS;
   /*To handle the non-integral number of bits still left in the encoder state,
      we compute the number of bits of low that must be encoded to ensure that
      the value is inside the range for any possible subsequent bits.
index 3fd5bd5..ca3b7b5 100644 (file)
@@ -124,8 +124,7 @@ static int ec_dec_in(ec_dec *_this){
   ret=ec_byte_read1(_this->buf);
   if(ret<0){
     ret=0;
-    /*Needed to make sure the above conditional only triggers once, and to keep
-       oc_dec_tell() operating correctly.*/
+    /*Needed to keep oc_dec_tell() operating correctly.*/
     ec_byte_adv1(_this->buf);
   }
   return ret;
@@ -190,7 +189,8 @@ long ec_dec_tell(ec_dec *_this,int _b){
   ec_uint32 r;
   int       l;
   long      nbits;
-  nbits=ec_byte_bytes(_this->buf)-(EC_CODE_BITS+EC_SYM_BITS-1)/EC_SYM_BITS<<3;
+  nbits=(ec_byte_bytes(_this->buf)-(EC_CODE_BITS+EC_SYM_BITS-1)/EC_SYM_BITS)*
+   EC_SYM_BITS;
   /*To handle the non-integral number of bits still left in the encoder state,
      we compute the number of bits of low that must be encoded to ensure that
      the value is inside the range for any possible subsequent bits.
index 51e1ffe..ff5d71d 100644 (file)
@@ -109,7 +109,7 @@ long ec_enc_tell(ec_enc *_this,int _b){
   ec_uint32 r;
   int       l;
   long      nbits;
-  nbits=ec_byte_bytes(_this->buf)+(_this->rem>=0)+_this->ext<<3;
+  nbits=(ec_byte_bytes(_this->buf)+(_this->rem>=0)+_this->ext)*EC_SYM_BITS;
   /*To handle the non-integral number of bits still left in the encoder state,
      we compute the number of bits of low that must be encoded to ensure that
      the value is inside the range for any possible subsequent bits.