eden-emu/opus
18
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Eliminate the ec_int32 and ec_uint32 typedefs.

Browse source 
These were used because the entropy coder originally came from
 outside libcelt, and thus did not have a common type system.
It's now undergone enough modification that it's not ever likely to
 be used as-is in another codec without some porting effort, so
 there's no real reason to maintain the typedefs separately.
Hopefully we'll replace these all again somedate with a common set
 of Opus typedefs, but for now this will do.

This fixes an issue caused by commit 6c8acbf1, which moved the
 ec_ilog() prototype from entcode.h to ecintrin.h, where the
 ec_uint32 typedef was not yet available.
Thanks to John Ridges for the report.
This commit is contained in:
Timothy B. Terriberry 2011-03-02 16:24:32 -08:00 • committed by Jean-Marc Valin
parent 115fa35a9d
commit 9bac8c17d5
15 changed files with 83 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

2
libcelt/bands.c
View file

@ -1161,7 +1161,7 @@ static unsigned quant_band(int encode, const CELTMode *m, int i, celt_norm *X, c
void quant_all_bands(int encode, const CELTMode *m, int start, int end,
celt_norm *_X, celt_norm *_Y, unsigned char *collapse_masks, const celt_ener *bandE, int *pulses,
int shortBlocks, int spread, int dual_stereo, int intensity, int *tf_res, int resynth,
celt_int32 total_bits, celt_int32 balance, ec_ctx *ec, int LM, int codedBands, ec_uint32 *seed)
celt_int32 total_bits, celt_int32 balance, ec_ctx *ec, int LM, int codedBands, celt_uint32 *seed)
{
int i;
celt_int32 remaining_bits;

2
libcelt/bands.h
View file

@ -84,7 +84,7 @@ void haar1(celt_norm *X, int N0, int stride);
void quant_all_bands(int encode, const CELTMode *m, int start, int end,
celt_norm * X, celt_norm * Y, unsigned char *collapse_masks, const celt_ener *bandE, int *pulses,
int time_domain, int fold, int dual_stereo, int intensity, int *tf_res, int resynth,
celt_int32 total_bits, celt_int32 balance, ec_ctx *ec, int M, int codedBands, ec_uint32 *seed);
celt_int32 total_bits, celt_int32 balance, ec_ctx *ec, int M, int codedBands, celt_uint32 *seed);
void stereo_decision(const CELTMode *m, celt_norm * restrict X, int *stereo_mode, int len, int M);

12
libcelt/celt.c
View file

@ -113,7 +113,7 @@ struct CELTEncoder {
/* Everything beyond this point gets cleared on a reset */
#define ENCODER_RESET_START rng
ec_uint32 rng;
celt_uint32 rng;
int spread_decision;
int delayedIntra;
int tonal_average;
@ -687,8 +687,8 @@ static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM,
int tf_select_rsv;
int tf_changed;
int logp;
ec_uint32 budget;
ec_uint32 tell;
celt_uint32 budget;
celt_uint32 tell;
budget = enc->storage*8;
tell = ec_tell(enc);
logp = isTransient ? 2 : 4;
@ -727,8 +727,8 @@ static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM,
int tf_select_rsv;
int tf_changed;
int logp;
ec_uint32 budget;
ec_uint32 tell;
celt_uint32 budget;
celt_uint32 tell;
budget = dec->storage*8;
tell = ec_tell(dec);
@ -1810,7 +1810,7 @@ struct CELTDecoder {
/* Everything beyond this point gets cleared on a reset */
#define DECODER_RESET_START rng
ec_uint32 rng;
celt_uint32 rng;
int last_pitch_index;
int loss_count;
int postfilter_period;

2
libcelt/cwrs.c
View file

@ -42,7 +42,7 @@
with frac bits of fractional precision.
Tested for all possible 32-bit inputs with frac=4, where the maximum
overestimation is 0.06254243 bits.*/
int log2_frac(ec_uint32 val, int frac)
int log2_frac(celt_uint32 val, int frac)
{
int l;
l=EC_ILOG(val);

2
libcelt/cwrs.h
View file

@ -35,7 +35,7 @@
#include "entenc.h"
#include "entdec.h"
int log2_frac(ec_uint32 val, int frac);
int log2_frac(celt_uint32 val, int frac);
void get_required_bits(celt_int16 *bits, int N, int K, int frac);

3
libcelt/ecintrin.h
View file

@ -26,6 +26,7 @@
*/
/*Some common macros for potential platform-specific optimization.*/
#include "celt_types.h"
#include <math.h>
#include <limits.h>
#if !defined(_ecintrin_H)
@ -114,7 +115,7 @@ static __inline int ec_bsr(unsigned long _x){
When we need to, it can be special cased.*/
# define EC_ILOG(_x) (EC_CLZ0-EC_CLZ(_x))
#else
int ec_ilog(ec_uint32 _v);
int ec_ilog(celt_uint32 _v);
# define EC_ILOG(_x) (ec_ilog(_x))
#endif

8
libcelt/entcode.c
View file

@ -34,7 +34,7 @@
#if !defined(EC_CLZ)
int ec_ilog(ec_uint32 _v){
int ec_ilog(celt_uint32 _v){
/*On a Pentium M, this branchless version tested as the fastest on
1,000,000,000 random 32-bit integers, edging out a similar version with
branches, and a 256-entry LUT version.*/
@ -59,9 +59,9 @@ int ec_ilog(ec_uint32 _v){
#endif
ec_uint32 ec_tell_frac(ec_ctx *_this){
ec_uint32 nbits;
ec_uint32 r;
celt_uint32 ec_tell_frac(ec_ctx *_this){
celt_uint32 nbits;
celt_uint32 r;
int l;
int i;
/*To handle the non-integral number of bits still left in the encoder/decoder

22
libcelt/entcode.h
View file

@ -35,8 +35,8 @@
typedef celt_int32 ec_int32;
typedef celt_uint32 ec_uint32;
/*OPT: ec_window must be at least 32 bits, but if you have fast arithmetic on a
larger type, you can speed up the decoder by using it here.*/
typedef celt_uint32 ec_window;
typedef struct ec_ctx ec_ctx;
typedef struct ec_ctx ec_enc;
@ -44,8 +44,6 @@ typedef struct ec_ctx ec_dec;
/*OPT: This must be at least 32 bits, but if you have fast arithmetic on a
larger type, you can speed up the decoder by using it for ec_window.*/
# define EC_WINDOW_SIZE ((int)sizeof(ec_window)*CHAR_BIT)
/*The number of bits to use for the range-coded part of unsigned integers.*/
@ -64,9 +62,9 @@ struct ec_ctx{
/*Buffered input/output.*/
unsigned char *buf;
/*The size of the buffer.*/
ec_uint32 storage;
celt_uint32 storage;
/*The offset at which the last byte containing raw bits was read/written.*/
ec_uint32 end_offs;
celt_uint32 end_offs;
/*Bits that will be read from/written at the end.*/
ec_window end_window;
/*Number of valid bits in end_window.*/
@ -75,16 +73,16 @@ struct ec_ctx{
This does not include partial bits currently in the range coder.*/
int nbits_total;
/*The offset at which the next range coder byte will be read/written.*/
ec_uint32 offs;
celt_uint32 offs;
/*The number of values in the current range.*/
ec_uint32 rng;
celt_uint32 rng;
/*In the decoder: the difference between the top of the current range and
the input value, minus one.
In the encoder: the low end of the current range.*/
ec_uint32 val;
celt_uint32 val;
/*In the decoder: the saved normalization factor from ec_decode().
In the encoder: the number of oustanding carry propagating symbols.*/
ec_uint32 ext;
celt_uint32 ext;
/*A buffered input/output symbol, awaiting carry propagation.*/
int rem;
/*Nonzero if an error occurred.*/
@ -97,7 +95,7 @@ static inline void ec_reset(ec_ctx *_this){
_this->offs=_this->end_offs=0;
}
static inline ec_uint32 ec_range_bytes(ec_ctx *_this){
static inline celt_uint32 ec_range_bytes(ec_ctx *_this){
return _this->offs;
}
@ -125,6 +123,6 @@ static inline int ec_tell(ec_ctx *_this){
Return: The number of bits scaled by 2**BITRES.
This will always be slightly larger than the exact value (e.g., all
rounding error is in the positive direction).*/
ec_uint32 ec_tell_frac(ec_ctx *_this);
celt_uint32 ec_tell_frac(ec_ctx *_this);
#endif

30
libcelt/entdec.c
View file

@ -125,7 +125,7 @@ static void ec_dec_normalize(ec_dec *_this){
}
}
void ec_dec_init(ec_dec *_this,unsigned char *_buf,ec_uint32 _storage){
void ec_dec_init(ec_dec *_this,unsigned char *_buf,celt_uint32 _storage){
_this->buf=_buf;
_this->storage=_storage;
_this->end_offs=0;
@ -160,7 +160,7 @@ unsigned ec_decode_bin(ec_dec *_this,unsigned _bits){
}
void ec_dec_update(ec_dec *_this,unsigned _fl,unsigned _fh,unsigned _ft){
ec_uint32 s;
celt_uint32 s;
s=IMUL32(_this->ext,_ft-_fh);
_this->val-=s;
_this->rng=_fl>0?IMUL32(_this->ext,_fh-_fl):_this->rng-s;
@ -169,9 +169,9 @@ void ec_dec_update(ec_dec *_this,unsigned _fl,unsigned _fh,unsigned _ft){
/*The probability of having a "one" is 1/(1<<_logp).*/
int ec_dec_bit_logp(ec_dec *_this,unsigned _logp){
ec_uint32 r;
ec_uint32 d;
ec_uint32 s;
celt_uint32 r;
celt_uint32 d;
celt_uint32 s;
int ret;
r=_this->rng;
d=_this->val;
@ -184,10 +184,10 @@ int ec_dec_bit_logp(ec_dec *_this,unsigned _logp){
}
int ec_dec_icdf(ec_dec *_this,const unsigned char *_icdf,unsigned _ftb){
ec_uint32 r;
ec_uint32 d;
ec_uint32 s;
ec_uint32 t;
celt_uint32 r;
celt_uint32 d;
celt_uint32 s;
celt_uint32 t;
int ret;
s=_this->rng;
d=_this->val;
@ -204,7 +204,7 @@ int ec_dec_icdf(ec_dec *_this,const unsigned char *_icdf,unsigned _ftb){
return ret;
}
ec_uint32 ec_dec_uint(ec_dec *_this,ec_uint32 _ft){
celt_uint32 ec_dec_uint(ec_dec *_this,celt_uint32 _ft){
unsigned ft;
unsigned s;
int ftb;
@ -213,12 +213,12 @@ ec_uint32 ec_dec_uint(ec_dec *_this,ec_uint32 _ft){
_ft--;
ftb=EC_ILOG(_ft);
if(ftb>EC_UINT_BITS){
ec_uint32 t;
celt_uint32 t;
ftb-=EC_UINT_BITS;
ft=(unsigned)(_ft>>ftb)+1;
s=ec_decode(_this,ft);
ec_dec_update(_this,s,s+1,ft);
t=(ec_uint32)s<<ftb|ec_dec_bits(_this,ftb);
t=(celt_uint32)s<<ftb|ec_dec_bits(_this,ftb);
if(t<=_ft)return t;
_this->error=1;
return _ft;
@ -231,10 +231,10 @@ ec_uint32 ec_dec_uint(ec_dec *_this,ec_uint32 _ft){
}
}
ec_uint32 ec_dec_bits(ec_dec *_this,unsigned _bits){
celt_uint32 ec_dec_bits(ec_dec *_this,unsigned _bits){
ec_window window;
int available;
ec_uint32 ret;
celt_uint32 ret;
window=_this->end_window;
available=_this->nend_bits;
if(available<_bits){
@ -244,7 +244,7 @@ ec_uint32 ec_dec_bits(ec_dec *_this,unsigned _bits){
}
while(available<=EC_WINDOW_SIZE-EC_SYM_BITS);
}
ret=(ec_uint32)window&((ec_uint32)1<<_bits)-1;
ret=(celt_uint32)window&((celt_uint32)1<<_bits)-1;
window>>=_bits;
available-=_bits;
_this->end_window=window;

6
libcelt/entdec.h
View file

@ -35,7 +35,7 @@
/*Initializes the decoder.
_buf: The input buffer to use.
Return: 0 on success, or a negative value on error.*/
void ec_dec_init(ec_dec *_this,unsigned char *_buf,ec_uint32 _storage);
void ec_dec_init(ec_dec *_this,unsigned char *_buf,celt_uint32 _storage);
/*Calculates the cumulative frequency for the next symbol.
This can then be fed into the probability model to determine what that
@ -89,7 +89,7 @@ int ec_dec_icdf(ec_dec *_this,const unsigned char *_icdf,unsigned _ftb);
_ft: The number of integers that can be decoded (one more than the max).
This must be at least one, and no more than 2**32-1.
Return: The decoded bits.*/
ec_uint32 ec_dec_uint(ec_dec *_this,ec_uint32 _ft);
celt_uint32 ec_dec_uint(ec_dec *_this,celt_uint32 _ft);
/*Extracts a sequence of raw bits from the stream.
The bits must have been encoded with ec_enc_bits().
@ -97,6 +97,6 @@ ec_uint32 ec_dec_uint(ec_dec *_this,ec_uint32 _ft);
_ftb: The number of bits to extract.
This must be between 0 and 25, inclusive.
Return: The decoded bits.*/
ec_uint32 ec_dec_bits(ec_dec *_this,unsigned _ftb);
celt_uint32 ec_dec_bits(ec_dec *_this,unsigned _ftb);
#endif

30
libcelt/entenc.c
View file

@ -114,7 +114,7 @@ static void ec_enc_normalize(ec_enc *_this){
}
}
void ec_enc_init(ec_enc *_this,unsigned char *_buf,ec_uint32 _size){
void ec_enc_init(ec_enc *_this,unsigned char *_buf,celt_uint32 _size){
_this->buf=_buf;
_this->end_offs=0;
_this->end_window=0;
@ -131,7 +131,7 @@ void ec_enc_init(ec_enc *_this,unsigned char *_buf,ec_uint32 _size){
}
void ec_encode(ec_enc *_this,unsigned _fl,unsigned _fh,unsigned _ft){
ec_uint32 r;
celt_uint32 r;
r=_this->rng/_ft;
if(_fl>0){
_this->val+=_this->rng-IMUL32(r,(_ft-_fl));
@ -142,7 +142,7 @@ void ec_encode(ec_enc *_this,unsigned _fl,unsigned _fh,unsigned _ft){
}
void ec_encode_bin(ec_enc *_this,unsigned _fl,unsigned _fh,unsigned _bits){
ec_uint32 r;
celt_uint32 r;
r=_this->rng>>_bits;
if(_fl>0){
_this->val+=_this->rng-IMUL32(r,((1<<_bits)-_fl));
@ -154,9 +154,9 @@ void ec_encode_bin(ec_enc *_this,unsigned _fl,unsigned _fh,unsigned _bits){
/*The probability of having a "one" is 1/(1<<_logp).*/
void ec_enc_bit_logp(ec_enc *_this,int _val,unsigned _logp){
ec_uint32 r;
ec_uint32 s;
ec_uint32 l;
celt_uint32 r;
celt_uint32 s;
celt_uint32 l;
r=_this->rng;
l=_this->val;
s=r>>_logp;
@ -167,7 +167,7 @@ void ec_enc_bit_logp(ec_enc *_this,int _val,unsigned _logp){
}
void ec_enc_icdf(ec_enc *_this,int _s,const unsigned char *_icdf,unsigned _ftb){
ec_uint32 r;
celt_uint32 r;
r=_this->rng>>_ftb;
if(_s>0){
_this->val+=_this->rng-IMUL32(r,_icdf[_s-1]);
@ -177,7 +177,7 @@ void ec_enc_icdf(ec_enc *_this,int _s,const unsigned char *_icdf,unsigned _ftb){
ec_enc_normalize(_this);
}
void ec_enc_uint(ec_enc *_this,ec_uint32 _fl,ec_uint32 _ft){
void ec_enc_uint(ec_enc *_this,celt_uint32 _fl,celt_uint32 _ft){
unsigned ft;
unsigned fl;
int ftb;
@ -190,12 +190,12 @@ void ec_enc_uint(ec_enc *_this,ec_uint32 _fl,ec_uint32 _ft){
ft=(_ft>>ftb)+1;
fl=(unsigned)(_fl>>ftb);
ec_encode(_this,fl,fl+1,ft);
ec_enc_bits(_this,_fl&((ec_uint32)1<<ftb)-1,ftb);
ec_enc_bits(_this,_fl&((celt_uint32)1<<ftb)-1,ftb);
}
else ec_encode(_this,_fl,_fl+1,_ft+1);
}
void ec_enc_bits(ec_enc *_this,ec_uint32 _fl,unsigned _bits){
void ec_enc_bits(ec_enc *_this,celt_uint32 _fl,unsigned _bits){
ec_window window;
int used;
window=_this->end_window;
@ -231,14 +231,14 @@ void ec_enc_patch_initial_bits(ec_enc *_this,unsigned _val,unsigned _nbits){
}
else if(_this->rng<=EC_CODE_TOP>>shift){
/*The renormalization loop has never been run.*/
_this->val=_this->val&~((ec_uint32)mask<<EC_CODE_SHIFT)|
(ec_uint32)_val<<EC_CODE_SHIFT+shift;
_this->val=_this->val&~((celt_uint32)mask<<EC_CODE_SHIFT)|
(celt_uint32)_val<<EC_CODE_SHIFT+shift;
}
/*The encoder hasn't even encoded _nbits of data yet.*/
else _this->error=-1;
}
void ec_enc_shrink(ec_enc *_this,ec_uint32 _size){
void ec_enc_shrink(ec_enc *_this,celt_uint32 _size){
celt_assert(_this->offs+_this->end_offs<=_size);
CELT_MOVE(_this->buf+_size-_this->end_offs,
_this->buf+_this->storage-_this->end_offs,_this->end_offs);
@ -248,8 +248,8 @@ void ec_enc_shrink(ec_enc *_this,ec_uint32 _size){
void ec_enc_done(ec_enc *_this){
ec_window window;
int used;
ec_uint32 msk;
ec_uint32 end;
celt_uint32 msk;
celt_uint32 end;
int l;
/*We output the minimum number of bits that ensures that the symbols encoded
thus far will be decoded correctly regardless of the bits that follow.*/

8
libcelt/entenc.h
View file

@ -35,7 +35,7 @@
/*Initializes the encoder.
_buf: The buffer to store output bytes in.
_size: The size of the buffer, in chars.*/
void ec_enc_init(ec_enc *_this,unsigned char *_buf,ec_uint32 _size);
void ec_enc_init(ec_enc *_this,unsigned char *_buf,celt_uint32 _size);
/*Encodes a symbol given its frequency information.
The frequency information must be discernable by the decoder, assuming it
has read only the previous symbols from the stream.
@ -70,13 +70,13 @@ void ec_enc_icdf(ec_enc *_this,int _s,const unsigned char *_icdf,unsigned _ftb);
_fl: The integer to encode.
_ft: The number of integers that can be encoded (one more than the max).
This must be at least one, and no more than 2**32-1.*/
void ec_enc_uint(ec_enc *_this,ec_uint32 _fl,ec_uint32 _ft);
void ec_enc_uint(ec_enc *_this,celt_uint32 _fl,celt_uint32 _ft);
/*Encodes a sequence of raw bits in the stream.
_fl: The bits to encode.
_ftb: The number of bits to encode.
This must be between 0 and 25, inclusive.*/
void ec_enc_bits(ec_enc *_this,ec_uint32 _fl,unsigned _ftb);
void ec_enc_bits(ec_enc *_this,celt_uint32 _fl,unsigned _ftb);
/*Overwrites a few bits at the very start of an existing stream, after they
have already been encoded.
@ -102,7 +102,7 @@ void ec_enc_patch_initial_bits(ec_enc *_this,unsigned _val,unsigned _nbits);
_size: The number of bytes in the new buffer.
This must be large enough to contain the bits already written, and
must be no larger than the existing size.*/
void ec_enc_shrink(ec_enc *_this,ec_uint32 _size);
void ec_enc_shrink(ec_enc *_this,celt_uint32 _size);
/*Indicates that there are no more symbols to encode.
All reamining output bytes are flushed to the output buffer.

6
libcelt/mfrngcod.h
View file

@ -40,17 +40,17 @@
/*Bits to shift by to move a symbol into the high-order position.*/
# define EC_CODE_SHIFT (EC_CODE_BITS-EC_SYM_BITS-1)
/*Carry bit of the high-order range symbol.*/
# define EC_CODE_TOP (((ec_uint32)1U)<<EC_CODE_BITS-1)
# define EC_CODE_TOP (((celt_uint32)1U)<<EC_CODE_BITS-1)
/*Low-order bit of the high-order range symbol.*/
# define EC_CODE_BOT (EC_CODE_TOP>>EC_SYM_BITS)
/*Code for which propagating carries are possible.*/
# define EC_CODE_CARRY (((ec_uint32)EC_SYM_MAX)<<EC_CODE_SHIFT)
# define EC_CODE_CARRY (((celt_uint32)EC_SYM_MAX)<<EC_CODE_SHIFT)
/*The number of bits available for the last, partial symbol in the code field.*/
# define EC_CODE_EXTRA ((EC_CODE_BITS-2)%EC_SYM_BITS+1)
/*A mask for the bits available in the coding buffer.
This allows different platforms to use a variable with more bits, if it is
convenient.
We will only use EC_CODE_BITS of it.*/
# define EC_CODE_MASK ((((ec_uint32)1U)<<EC_CODE_BITS-1)-1<<1|1)
# define EC_CODE_MASK ((((celt_uint32)1U)<<EC_CODE_BITS-1)-1<<1|1)
#endif

14
libcelt/quant_bands.c
View file

@ -155,7 +155,7 @@ static int intra_decision(const celt_word16 *eBands, celt_word16 *oldEBands, int
static int quant_coarse_energy_impl(const CELTMode *m, int start, int end,
const celt_word16 *eBands, celt_word16 *oldEBands,
ec_int32 budget, ec_int32 tell,
celt_int32 budget, celt_int32 tell,
const unsigned char *prob_model, celt_word16 *error, ec_enc *enc,
int _C, int LM, int intra, celt_word16 max_decay)
{
@ -258,7 +258,7 @@ static int quant_coarse_energy_impl(const CELTMode *m, int start, int end,
}
void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
const celt_word16 *eBands, celt_word16 *oldEBands, ec_uint32 budget,
const celt_word16 *eBands, celt_word16 *oldEBands, celt_uint32 budget,
celt_word16 *error, ec_enc *enc, int _C, int LM, int nbAvailableBytes,
int force_intra, int *delayedIntra, int two_pass)
{
@ -268,7 +268,7 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
VARDECL(celt_word16, oldEBands_intra);
VARDECL(celt_word16, error_intra);
ec_enc enc_start_state;
ec_uint32 tell;
celt_uint32 tell;
int badness1=0;
SAVE_STACK;
@ -307,8 +307,8 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
{
ec_enc enc_intra_state;
int tell_intra;
ec_uint32 nstart_bytes;
ec_uint32 nintra_bytes;
celt_uint32 nstart_bytes;
celt_uint32 nintra_bytes;
int badness2;
VARDECL(unsigned char, intra_bits);
@ -421,8 +421,8 @@ void unquant_coarse_energy(const CELTMode *m, int start, int end, celt_word16 *o
celt_word16 coef;
celt_word16 beta;
const int C = CHANNELS(_C);
ec_int32 budget;
ec_int32 tell;
celt_int32 budget;
celt_int32 tell;
if (intra)

2
libcelt/quant_bands.h
View file

@ -45,7 +45,7 @@ unsigned char *quant_prob_alloc(const CELTMode *m);
void quant_prob_free(const celt_int16 *freq);
void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
const celt_word16 *eBands, celt_word16 *oldEBands, ec_uint32 budget,
const celt_word16 *eBands, celt_word16 *oldEBands, celt_uint32 budget,
celt_word16 *error, ec_enc *enc, int _C, int LM,
int nbAvailableBytes, int force_intra, int *delayedIntra, int two_pass);