Updated celt to last master before opus merge. (e18de77)

This commit is contained in:
Jordan Cristiano 2018-02-19 21:17:25 -05:00
parent a968c9fe89
commit 81e9eb3ac4
52 changed files with 471 additions and 438 deletions

View File

@ -1,89 +0,0 @@
/* Copyright (C) 2003 Jean-Marc Valin */
/**
@file fixed_c5x.h
@brief Fixed-point operations for the TI C5x DSP family
*/
/*
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef FIXED_C5X_H
#define FIXED_C5X_H
#include "dsplib.h"
#undef IMUL32
static inline long IMUL32(long i, long j)
{
long ac0, ac1;
ac0 = _lmpy(i>>16,j);
ac1 = ac0 + _lmpy(i,j>>16);
return _lmpyu(i,j) + (ac1<<16);
}
#undef MAX16
#define MAX16(a,b) _max(a,b)
#undef MIN16
#define MIN16(a,b) _min(a,b)
#undef MAX32
#define MAX32(a,b) _lmax(a,b)
#undef MIN32
#define MIN32(a,b) _lmin(a,b)
#undef VSHR32
#define VSHR32(a, shift) _lshl(a,-(shift))
#undef MULT16_16_Q15
#define MULT16_16_Q15(a,b) (_smpy(a,b))
#undef MULT16_16SU
#define MULT16_16SU(a,b) _lmpysu(a,b)
#undef MULT_16_16
#define MULT_16_16(a,b) _lmpy(a,b)
/* FIXME: This is technically incorrect and is bound to cause problems. Is there any cleaner solution? */
#undef MULT16_32_Q15
#define MULT16_32_Q15(a,b) ADD32(SHL(MULT16_16((a),SHR((b),16)),1), SHR(MULT16_16SU((a),(b)),15))
#define celt_ilog2(x) (30 - _lnorm(x))
#define OVERRIDE_CELT_ILOG2
#define celt_maxabs16(x, len) MAX16(maxval((DATA *)x, len),-minval((DATA *)x, len))
#define OVERRIDE_CELT_MAXABS16
#define OVERRIDE_FIND_MAX16
static inline int find_max16(celt_word16 *x, int len)
{
DATA max_corr16 = -VERY_LARGE16;
DATA pitch16 = 0;
maxvec((DATA *)x, len, &max_corr16, &pitch16);
return pitch16;
}
#endif /* FIXED_C5X_H */

View File

@ -1,80 +0,0 @@
/* Copyright (C) 2008 CSIRO */
/**
@file fixed_c6x.h
@brief Fixed-point operations for the TI C6x DSP family
*/
/*
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef FIXED_C6X_H
#define FIXED_C6X_H
#undef MULT16_16SU
#define MULT16_16SU(a,b) _mpysu(a,b)
#undef MULT_16_16
#define MULT_16_16(a,b) _mpy(a,b)
#define celt_ilog2(x) (30 - _norm(x))
#define OVERRIDE_CELT_ILOG2
#undef MULT16_32_Q15
#define MULT16_32_Q15(a,b) (_mpylill(a, b) >> 15)
#if 0
#include "dsplib.h"
#undef MAX16
#define MAX16(a,b) _max(a,b)
#undef MIN16
#define MIN16(a,b) _min(a,b)
#undef MAX32
#define MAX32(a,b) _lmax(a,b)
#undef MIN32
#define MIN32(a,b) _lmin(a,b)
#undef VSHR32
#define VSHR32(a, shift) _lshl(a,-(shift))
#undef MULT16_16_Q15
#define MULT16_16_Q15(a,b) (_smpy(a,b))
#define celt_maxabs16(x, len) MAX16(maxval((DATA *)x, len),-minval((DATA *)x, len))
#define OVERRIDE_CELT_MAXABS16
#define OVERRIDE_FIND_MAX16
static inline int find_max16(celt_word16 *x, int len)
{
DATA max_corr16 = -VERY_LARGE16;
DATA pitch16 = 0;
maxvec((DATA *)x, len, &max_corr16, &pitch16);
return pitch16;
}
#endif
#endif /* FIXED_C6X_H */

10
external/celt-e18de77/README.Win32 vendored Normal file
View File

@ -0,0 +1,10 @@
Here are a few tips for building on Windows:
1) Create a config.h file that defines out things that defines out all the
features that your compiler doesn't understand (e.g. inline, restrict).
It also needs to define the CELT_BUILD macro
2) Define the HAVE_CONFIG_H macro in the project build options (NOT in config.h)
3) If you want things to be a lot easier, just use a compiler that supports
C99, such as gcc

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, 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, 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, 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; int i;
celt_int32 remaining_bits; celt_int32 remaining_bits;

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, 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, 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, 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); void stereo_decision(const CELTMode *m, celt_norm * restrict X, int *stereo_mode, int len, int M);

View File

@ -61,6 +61,40 @@ static const unsigned char spread_icdf[4] = {25, 23, 2, 0};
static const unsigned char tapset_icdf[3]={2,1,0}; static const unsigned char tapset_icdf[3]={2,1,0};
static const unsigned char toOpusTable[20] = {
0xE0, 0xE8, 0xF0, 0xF8,
0xC0, 0xC8, 0xD0, 0xD8,
0xA0, 0xA8, 0xB0, 0xB8,
0x00, 0x00, 0x00, 0x00,
0x80, 0x88, 0x90, 0x98,
};
static const unsigned char fromOpusTable[16] = {
0x80, 0x88, 0x90, 0x98,
0x40, 0x48, 0x50, 0x58,
0x20, 0x28, 0x30, 0x38,
0x00, 0x08, 0x10, 0x18
};
static inline int toOpus(unsigned char c)
{
int ret=0;
if (c<0xA0)
ret = toOpusTable[c>>3];
if (ret == 0)
return -1;
else
return ret|(c&0x7);
}
static inline int fromOpus(unsigned char c)
{
if (c<0x80)
return -1;
else
return fromOpusTable[(c>>3)-16] | (c&0x7);
}
#define COMBFILTER_MAXPERIOD 1024 #define COMBFILTER_MAXPERIOD 1024
#define COMBFILTER_MINPERIOD 15 #define COMBFILTER_MINPERIOD 15
@ -108,14 +142,16 @@ struct CELTEncoder {
celt_int32 bitrate; celt_int32 bitrate;
int vbr; int vbr;
int signalling;
int constrained_vbr; /* If zero, VBR can do whatever it likes with the rate */ int constrained_vbr; /* If zero, VBR can do whatever it likes with the rate */
int loss_rate;
/* Everything beyond this point gets cleared on a reset */ /* Everything beyond this point gets cleared on a reset */
#define ENCODER_RESET_START rng #define ENCODER_RESET_START rng
ec_uint32 rng; celt_uint32 rng;
int spread_decision; int spread_decision;
int delayedIntra; celt_word32 delayedIntra;
int tonal_average; int tonal_average;
int lastCodedBands; int lastCodedBands;
int hf_average; int hf_average;
@ -226,6 +262,8 @@ CELTEncoder *celt_encoder_init_custom(CELTEncoder *st, const CELTMode *mode, int
st->upsample = 1; st->upsample = 1;
st->start = 0; st->start = 0;
st->end = st->mode->effEBands; st->end = st->mode->effEBands;
st->signalling = 1;
st->constrained_vbr = 1; st->constrained_vbr = 1;
st->clip = 1; st->clip = 1;
@ -317,9 +355,9 @@ static int transient_analysis(const celt_word32 * restrict in, int len, int C,
for (i=0;i<N;i++) for (i=0;i<N;i++)
{ {
int j; int j;
float max_abs=0; celt_word16 max_abs=0;
for (j=0;j<block;j++) for (j=0;j<block;j++)
max_abs = MAX32(max_abs, tmp[i*block+j]); max_abs = MAX16(max_abs, ABS16(tmp[i*block+j]));
bins[i] = max_abs; bins[i] = max_abs;
} }
for (i=0;i<N;i++) for (i=0;i<N;i++)
@ -687,8 +725,8 @@ static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM,
int tf_select_rsv; int tf_select_rsv;
int tf_changed; int tf_changed;
int logp; int logp;
ec_uint32 budget; celt_uint32 budget;
ec_uint32 tell; celt_uint32 tell;
budget = enc->storage*8; budget = enc->storage*8;
tell = ec_tell(enc); tell = ec_tell(enc);
logp = isTransient ? 2 : 4; logp = isTransient ? 2 : 4;
@ -727,8 +765,8 @@ static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM,
int tf_select_rsv; int tf_select_rsv;
int tf_changed; int tf_changed;
int logp; int logp;
ec_uint32 budget; celt_uint32 budget;
ec_uint32 tell; celt_uint32 tell;
budget = dec->storage*8; budget = dec->storage*8;
tell = ec_tell(dec); tell = ec_tell(dec);
@ -915,13 +953,11 @@ int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, i
int anti_collapse_rsv; int anti_collapse_rsv;
int anti_collapse_on=0; int anti_collapse_on=0;
int silence=0; int silence=0;
SAVE_STACK; ALLOC_STACK;
if (nbCompressedBytes<2 || pcm==NULL) if (nbCompressedBytes<2 || pcm==NULL)
return CELT_BAD_ARG; return CELT_BAD_ARG;
/* Can't produce more than 1275 output bytes */
nbCompressedBytes = IMIN(nbCompressedBytes,1275);
frame_size *= st->upsample; frame_size *= st->upsample;
for (LM=0;LM<=st->mode->maxLM;LM++) for (LM=0;LM<=st->mode->maxLM;LM++)
if (st->mode->shortMdctSize<<LM==frame_size) if (st->mode->shortMdctSize<<LM==frame_size)
@ -946,13 +982,37 @@ int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, i
tell=ec_tell(enc); tell=ec_tell(enc);
nbFilledBytes=(tell+4)>>3; nbFilledBytes=(tell+4)>>3;
} }
if (st->signalling && enc==NULL)
{
int tmp = (st->mode->effEBands-st->end)>>1;
st->end = IMAX(1, st->mode->effEBands-tmp);
compressed[0] = tmp<<5;
compressed[0] |= LM<<3;
compressed[0] |= (C==2)<<2;
/* Convert "standard mode" to Opus header */
if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
{
int c0 = toOpus(compressed[0]);
if (c0<0)
return CELT_BAD_ARG;
compressed[0] = c0;
}
compressed++;
nbCompressedBytes--;
}
/* Can't produce more than 1275 output bytes */
nbCompressedBytes = IMIN(nbCompressedBytes,1275);
nbAvailableBytes = nbCompressedBytes - nbFilledBytes; nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
if (st->vbr) if (st->vbr)
{ {
celt_int32 den=st->mode->Fs>>BITRES; celt_int32 den=st->mode->Fs>>BITRES;
vbr_rate=(st->bitrate*frame_size+(den>>1))/den; vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
effectiveBytes = vbr_rate>>3; if (st->signalling)
vbr_rate -= 8<<BITRES;
effectiveBytes = vbr_rate>>(3+BITRES);
} else { } else {
celt_int32 tmp; celt_int32 tmp;
vbr_rate = 0; vbr_rate = 0;
@ -960,7 +1020,7 @@ int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, i
if (tell>1) if (tell>1)
tmp += tell; tmp += tell;
nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes, nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
(tmp+4*st->mode->Fs)/(8*st->mode->Fs))); (tmp+4*st->mode->Fs)/(8*st->mode->Fs)-!!st->signalling));
effectiveBytes = nbCompressedBytes; effectiveBytes = nbCompressedBytes;
} }
@ -1083,6 +1143,12 @@ int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, i
if (pitch_index > COMBFILTER_MAXPERIOD-2) if (pitch_index > COMBFILTER_MAXPERIOD-2)
pitch_index = COMBFILTER_MAXPERIOD-2; pitch_index = COMBFILTER_MAXPERIOD-2;
gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1); gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
if (st->loss_rate>2)
gain1 = HALF32(gain1);
if (st->loss_rate>4)
gain1 = HALF32(gain1);
if (st->loss_rate>8)
gain1 = 0;
prefilter_tapset = st->tapset_decision; prefilter_tapset = st->tapset_decision;
} else { } else {
gain1 = 0; gain1 = 0;
@ -1238,7 +1304,7 @@ int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, i
quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE, quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
oldBandE, total_bits, error, enc, oldBandE, total_bits, error, enc,
C, LM, nbAvailableBytes, st->force_intra, C, LM, nbAvailableBytes, st->force_intra,
&st->delayedIntra, st->complexity >= 4); &st->delayedIntra, st->complexity >= 4, st->loss_rate);
tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc); tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
@ -1366,17 +1432,23 @@ int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, i
nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes); nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes; nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
if(silence)
{
nbAvailableBytes = 2;
target = 2*8<<BITRES;
}
/* By how much did we "miss" the target on that frame */ /* By how much did we "miss" the target on that frame */
delta = target - vbr_rate; delta = target - vbr_rate;
target=nbAvailableBytes<<(BITRES+3); target=nbAvailableBytes<<(BITRES+3);
/*If the frame is silent we don't adjust our drift, otherwise
the encoder will shoot to very high rates after hitting a
span of silence, but we do allow the bitres to refill.
This means that we'll undershoot our target in CVBR/VBR modes
on files with lots of silence. */
if(silence)
{
nbAvailableBytes = 2;
target = 2*8<<BITRES;
delta = 0;
}
if (st->vbr_count < 970) if (st->vbr_count < 970)
{ {
st->vbr_count++; st->vbr_count++;
@ -1603,9 +1675,12 @@ int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, i
it's already filled with zeros */ it's already filled with zeros */
ec_enc_done(enc); ec_enc_done(enc);
if (st->signalling)
nbCompressedBytes++;
RESTORE_STACK; RESTORE_STACK;
if (ec_get_error(enc)) if (ec_get_error(enc))
return CELT_CORRUPTED_DATA; return CELT_INTERNAL_ERROR;
else else
return nbCompressedBytes; return nbCompressedBytes;
} }
@ -1618,7 +1693,6 @@ int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int
int j, ret, C, N; int j, ret, C, N;
VARDECL(celt_int16, in); VARDECL(celt_int16, in);
ALLOC_STACK; ALLOC_STACK;
SAVE_STACK;
if (pcm==NULL) if (pcm==NULL)
return CELT_BAD_ARG; return CELT_BAD_ARG;
@ -1647,7 +1721,6 @@ int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int f
int j, ret, C, N; int j, ret, C, N;
VARDECL(celt_sig, in); VARDECL(celt_sig, in);
ALLOC_STACK; ALLOC_STACK;
SAVE_STACK;
if (pcm==NULL) if (pcm==NULL)
return CELT_BAD_ARG; return CELT_BAD_ARG;
@ -1688,14 +1761,6 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
va_start(ap, request); va_start(ap, request);
switch (request) switch (request)
{ {
case CELT_GET_MODE_REQUEST:
{
const CELTMode ** value = va_arg(ap, const CELTMode**);
if (value==0)
goto bad_arg;
*value=st->mode;
}
break;
case CELT_SET_COMPLEXITY_REQUEST: case CELT_SET_COMPLEXITY_REQUEST:
{ {
int value = va_arg(ap, celt_int32); int value = va_arg(ap, celt_int32);
@ -1729,6 +1794,14 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
st->force_intra = value==0; st->force_intra = value==0;
} }
break; break;
case CELT_SET_LOSS_PERC_REQUEST:
{
int value = va_arg(ap, celt_int32);
if (value<0 || value>100)
goto bad_arg;
st->loss_rate = value;
}
break;
case CELT_SET_VBR_CONSTRAINT_REQUEST: case CELT_SET_VBR_CONSTRAINT_REQUEST:
{ {
celt_int32 value = va_arg(ap, celt_int32); celt_int32 value = va_arg(ap, celt_int32);
@ -1775,6 +1848,22 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
st->clip = value; st->clip = value;
} }
break; break;
#ifdef OPUS_BUILD
case CELT_SET_SIGNALLING_REQUEST:
{
celt_int32 value = va_arg(ap, celt_int32);
st->signalling = value;
}
break;
case CELT_GET_MODE_REQUEST:
{
const CELTMode ** value = va_arg(ap, const CELTMode**);
if (value==0)
goto bad_arg;
*value=st->mode;
}
break;
#endif
default: default:
goto bad_request; goto bad_request;
} }
@ -1806,11 +1895,13 @@ struct CELTDecoder {
int downsample; int downsample;
int start, end; int start, end;
int signalling;
/* Everything beyond this point gets cleared on a reset */ /* Everything beyond this point gets cleared on a reset */
#define DECODER_RESET_START rng #define DECODER_RESET_START rng
ec_uint32 rng; celt_uint32 rng;
int error;
int last_pitch_index; int last_pitch_index;
int loss_count; int loss_count;
int postfilter_period; int postfilter_period;
@ -1824,10 +1915,10 @@ struct CELTDecoder {
celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */ celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
/* celt_word16 lpc[], Size = channels*LPC_ORDER */ /* celt_word16 lpc[], Size = channels*LPC_ORDER */
/* celt_word16 oldEBands[], Size = channels*mode->nbEBands */ /* celt_word16 oldEBands[], Size = 2*mode->nbEBands */
/* celt_word16 oldLogE[], Size = channels*mode->nbEBands */ /* celt_word16 oldLogE[], Size = 2*mode->nbEBands */
/* celt_word16 oldLogE2[], Size = channels*mode->nbEBands */ /* celt_word16 oldLogE2[], Size = 2*mode->nbEBands */
/* celt_word16 backgroundLogE[], Size = channels*mode->nbEBands */ /* celt_word16 backgroundLogE[], Size = 2*mode->nbEBands */
}; };
int celt_decoder_get_size(int channels) int celt_decoder_get_size(int channels)
@ -1841,7 +1932,7 @@ int celt_decoder_get_size_custom(const CELTMode *mode, int channels)
int size = sizeof(struct CELTDecoder) int size = sizeof(struct CELTDecoder)
+ (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig) + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
+ channels*LPC_ORDER*sizeof(celt_word16) + channels*LPC_ORDER*sizeof(celt_word16)
+ 4*channels*mode->nbEBands*sizeof(celt_word16); + 4*2*mode->nbEBands*sizeof(celt_word16);
return size; return size;
} }
@ -1906,6 +1997,7 @@ CELTDecoder *celt_decoder_init_custom(CELTDecoder *st, const CELTMode *mode, int
st->downsample = 1; st->downsample = 1;
st->start = 0; st->start = 0;
st->end = st->mode->effEBands; st->end = st->mode->effEBands;
st->signalling = 1;
st->loss_count = 0; st->loss_count = 0;
@ -1959,6 +2051,11 @@ static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict p
VARDECL(celt_norm, X); VARDECL(celt_norm, X);
VARDECL(celt_ener, bandE); VARDECL(celt_ener, bandE);
celt_uint32 seed; celt_uint32 seed;
int effEnd;
effEnd = st->end;
if (effEnd > st->mode->effEBands)
effEnd = st->mode->effEBands;
ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */ ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */
@ -1967,18 +2064,42 @@ static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict p
log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C); log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
seed = st->rng; seed = st->rng;
for (i=0;i<C*N;i++) for (c=0;c<C;c++)
{ {
seed = lcg_rand(seed); for (i=0;i<(st->mode->eBands[st->start]<<LM);i++)
X[i] = (celt_int32)(seed)>>20; X[c*N+i] = 0;
for (i=0;i<st->mode->effEBands;i++)
{
int j;
int boffs;
int blen;
boffs = N*c+(st->mode->eBands[i]<<LM);
blen = (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
for (j=0;j<blen;j++)
{
seed = lcg_rand(seed);
X[boffs+j] = (celt_int32)(seed)>>20;
}
renormalise_vector(X+boffs, blen, Q15ONE);
}
for (i=(st->mode->eBands[st->end]<<LM);i<N;i++)
X[c*N+i] = 0;
} }
st->rng = seed; st->rng = seed;
for (c=0;c<C;c++)
for (i=0;i<st->mode->nbEBands;i++)
renormalise_vector(X+N*c+(st->mode->eBands[i]<<LM), (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM, Q15ONE);
denormalise_bands(st->mode, X, freq, bandE, st->mode->nbEBands, C, 1<<LM); denormalise_bands(st->mode, X, freq, bandE, st->mode->effEBands, C, 1<<LM);
c=0; do
for (i=0;i<st->mode->eBands[st->start]<<LM;i++)
freq[c*N+i] = 0;
while (++c<C);
c=0; do {
int bound = st->mode->eBands[effEnd]<<LM;
if (st->downsample!=1)
bound = IMIN(bound, N/st->downsample);
for (i=bound;i<N;i++)
freq[c*N+i] = 0;
} while (++c<C);
compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM); compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
plc = 0; plc = 0;
} else if (st->loss_count == 0) } else if (st->loss_count == 0)
@ -2194,20 +2315,10 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
int anti_collapse_rsv; int anti_collapse_rsv;
int anti_collapse_on=0; int anti_collapse_on=0;
int silence; int silence;
const int C = CHANNELS(st->stream_channels); int C = CHANNELS(st->stream_channels);
ALLOC_STACK;
SAVE_STACK;
if (len<0 || len>1275 || pcm==NULL)
return CELT_BAD_ARG;
frame_size *= st->downsample; frame_size *= st->downsample;
for (LM=0;LM<=st->mode->maxLM;LM++)
if (st->mode->shortMdctSize<<LM==frame_size)
break;
if (LM>st->mode->maxLM)
return CELT_BAD_ARG;
M=1<<LM;
c=0; do { c=0; do {
decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap); decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
@ -2215,10 +2326,43 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE; overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
} while (++c<CC); } while (++c<CC);
lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC); lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC);
oldBandE = lpc+CC*LPC_ORDER; oldBandE = lpc+LPC_ORDER;
oldLogE = oldBandE + CC*st->mode->nbEBands; oldLogE = oldBandE + 2*st->mode->nbEBands;
oldLogE2 = oldLogE + CC*st->mode->nbEBands; oldLogE2 = oldLogE + 2*st->mode->nbEBands;
backgroundLogE = oldLogE2 + CC*st->mode->nbEBands; backgroundLogE = oldLogE2 + 2*st->mode->nbEBands;
if (st->signalling && data!=NULL)
{
int data0=data[0];
/* Convert "standard mode" to Opus header */
if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
{
data0 = fromOpus(data0);
if (data0<0)
return CELT_CORRUPTED_DATA;
}
st->end = IMAX(1, st->mode->effEBands-2*(data0>>5));
LM = (data0>>3)&0x3;
C = 1 + ((data0>>2)&0x1);
data++;
len--;
if (LM>st->mode->maxLM)
return CELT_CORRUPTED_DATA;
if (frame_size < st->mode->shortMdctSize<<LM)
return CELT_BUFFER_TOO_SMALL;
else
frame_size = st->mode->shortMdctSize<<LM;
} else {
for (LM=0;LM<=st->mode->maxLM;LM++)
if (st->mode->shortMdctSize<<LM==frame_size)
break;
if (LM>st->mode->maxLM)
return CELT_BAD_ARG;
}
M=1<<LM;
if (len<0 || len>1275 || pcm==NULL)
return CELT_BAD_ARG;
N = M*st->mode->shortMdctSize; N = M*st->mode->shortMdctSize;
@ -2226,23 +2370,23 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
if (effEnd > st->mode->effEBands) if (effEnd > st->mode->effEBands)
effEnd = st->mode->effEBands; effEnd = st->mode->effEBands;
ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */ ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
ALLOC(X, CC*N, celt_norm); /**< Interleaved normalised MDCTs */ ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */
ALLOC(bandE, st->mode->nbEBands*CC, celt_ener); ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
c=0; do c=0; do
for (i=0;i<M*st->mode->eBands[st->start];i++) for (i=0;i<M*st->mode->eBands[st->start];i++)
X[c*N+i] = 0; X[c*N+i] = 0;
while (++c<CC); while (++c<C);
c=0; do c=0; do
for (i=M*st->mode->eBands[effEnd];i<N;i++) for (i=M*st->mode->eBands[effEnd];i<N;i++)
X[c*N+i] = 0; X[c*N+i] = 0;
while (++c<CC); while (++c<C);
if (data == NULL || len<=1) if (data == NULL || len<=1)
{ {
celt_decode_lost(st, pcm, N, LM); celt_decode_lost(st, pcm, N, LM);
RESTORE_STACK; RESTORE_STACK;
return CELT_OK; return frame_size/st->downsample;
} }
if (len<0) { if (len<0) {
RESTORE_STACK; RESTORE_STACK;
@ -2255,11 +2399,7 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
dec = &_dec; dec = &_dec;
} }
if (C>CC) if (C<CC)
{
RESTORE_STACK;
return CELT_CORRUPTED_DATA;
} else if (C<CC)
{ {
for (i=0;i<st->mode->nbEBands;i++) for (i=0;i<st->mode->nbEBands;i++)
oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]); oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]);
@ -2395,7 +2535,7 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
fine_quant, fine_priority, len*8-ec_tell(dec), dec, C); fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
if (anti_collapse_on) if (anti_collapse_on)
anti_collapse(st->mode, X, collapse_masks, LM, C, CC, N, anti_collapse(st->mode, X, collapse_masks, LM, C, C, N,
st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng); st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C); log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
@ -2436,6 +2576,11 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
for (i=0;i<N;i++) for (i=0;i<N;i++)
freq[N+i] = freq[i]; freq[N+i] = freq[i];
} }
if (CC==1&&C==2)
{
for (i=0;i<N;i++)
freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
}
/* Compute inverse MDCTs */ /* Compute inverse MDCTs */
compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM); compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
@ -2467,7 +2612,7 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
} }
#endif /* ENABLE_POSTFILTER */ #endif /* ENABLE_POSTFILTER */
if (CC==2&&C==1) { if (C==1) {
for (i=0;i<st->mode->nbEBands;i++) for (i=0;i<st->mode->nbEBands;i++)
oldBandE[st->mode->nbEBands+i]=oldBandE[i]; oldBandE[st->mode->nbEBands+i]=oldBandE[i];
} }
@ -2479,17 +2624,17 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
oldBandE[c*st->mode->nbEBands+i]=0; oldBandE[c*st->mode->nbEBands+i]=0;
for (i=st->end;i<st->mode->nbEBands;i++) for (i=st->end;i<st->mode->nbEBands;i++)
oldBandE[c*st->mode->nbEBands+i]=0; oldBandE[c*st->mode->nbEBands+i]=0;
} while (++c<CC); } while (++c<2);
if (!isTransient) if (!isTransient)
{ {
for (i=0;i<CC*st->mode->nbEBands;i++) for (i=0;i<2*st->mode->nbEBands;i++)
oldLogE2[i] = oldLogE[i]; oldLogE2[i] = oldLogE[i];
for (i=0;i<CC*st->mode->nbEBands;i++) for (i=0;i<2*st->mode->nbEBands;i++)
oldLogE[i] = oldBandE[i]; oldLogE[i] = oldBandE[i];
for (i=0;i<CC*st->mode->nbEBands;i++) for (i=0;i<2*st->mode->nbEBands;i++)
backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]); backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
} else { } else {
for (i=0;i<CC*st->mode->nbEBands;i++) for (i=0;i<2*st->mode->nbEBands;i++)
oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]); oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
} }
st->rng = dec->rng; st->rng = dec->rng;
@ -2497,10 +2642,11 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
deemphasis(out_syn, pcm, N, CC, st->downsample, st->mode->preemph, st->preemph_memD); deemphasis(out_syn, pcm, N, CC, st->downsample, st->mode->preemph, st->preemph_memD);
st->loss_count = 0; st->loss_count = 0;
RESTORE_STACK; RESTORE_STACK;
if (ec_tell(dec) > 8*len || ec_get_error(dec)) if (ec_tell(dec) > 8*len)
return CELT_CORRUPTED_DATA; return CELT_INTERNAL_ERROR;
else if(ec_get_error(dec))
return CELT_OK; st->error = 1;
return frame_size/st->downsample;
} }
#ifdef FIXED_POINT #ifdef FIXED_POINT
@ -2511,7 +2657,6 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
int j, ret, C, N; int j, ret, C, N;
VARDECL(celt_int16, out); VARDECL(celt_int16, out);
ALLOC_STACK; ALLOC_STACK;
SAVE_STACK;
if (pcm==NULL) if (pcm==NULL)
return CELT_BAD_ARG; return CELT_BAD_ARG;
@ -2521,8 +2666,8 @@ int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *da
ALLOC(out, C*N, celt_int16); ALLOC(out, C*N, celt_int16);
ret=celt_decode_with_ec(st, data, len, out, frame_size, dec); ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
if (ret==0) if (ret>0)
for (j=0;j<C*N;j++) for (j=0;j<C*ret;j++)
pcm[j]=out[j]*(1.f/32768.f); pcm[j]=out[j]*(1.f/32768.f);
RESTORE_STACK; RESTORE_STACK;
@ -2536,7 +2681,6 @@ int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, in
int j, ret, C, N; int j, ret, C, N;
VARDECL(celt_sig, out); VARDECL(celt_sig, out);
ALLOC_STACK; ALLOC_STACK;
SAVE_STACK;
if (pcm==NULL) if (pcm==NULL)
return CELT_BAD_ARG; return CELT_BAD_ARG;
@ -2547,8 +2691,8 @@ int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, in
ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec); ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
if (ret==0) if (ret>0)
for (j=0;j<C*N;j++) for (j=0;j<C*ret;j++)
pcm[j] = FLOAT2INT16 (out[j]); pcm[j] = FLOAT2INT16 (out[j]);
RESTORE_STACK; RESTORE_STACK;
@ -2575,14 +2719,6 @@ int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
va_start(ap, request); va_start(ap, request);
switch (request) switch (request)
{ {
case CELT_GET_MODE_REQUEST:
{
const CELTMode ** value = va_arg(ap, const CELTMode**);
if (value==0)
goto bad_arg;
*value=st->mode;
}
break;
case CELT_SET_START_BAND_REQUEST: case CELT_SET_START_BAND_REQUEST:
{ {
celt_int32 value = va_arg(ap, celt_int32); celt_int32 value = va_arg(ap, celt_int32);
@ -2607,6 +2743,23 @@ int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
st->stream_channels = value; st->stream_channels = value;
} }
break; break;
case CELT_GET_AND_CLEAR_ERROR_REQUEST:
{
int *value = va_arg(ap, int*);
if (value==NULL)
goto bad_arg;
*value=st->error;
st->error = 0;
}
break;
case CELT_GET_LOOKAHEAD_REQUEST:
{
int *value = va_arg(ap, int*);
if (value==NULL)
goto bad_arg;
*value = st->overlap/st->downsample;
}
break;
case CELT_RESET_STATE: case CELT_RESET_STATE:
{ {
CELT_MEMSET((char*)&st->DECODER_RESET_START, 0, CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
@ -2614,6 +2767,22 @@ int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
((char*)&st->DECODER_RESET_START - (char*)st)); ((char*)&st->DECODER_RESET_START - (char*)st));
} }
break; break;
#ifdef OPUS_BUILD
case CELT_GET_MODE_REQUEST:
{
const CELTMode ** value = va_arg(ap, const CELTMode**);
if (value==0)
goto bad_arg;
*value=st->mode;
}
break;
case CELT_SET_SIGNALLING_REQUEST:
{
celt_int32 value = va_arg(ap, celt_int32);
st->signalling = value;
}
break;
#endif
default: default:
goto bad_request; goto bad_request;
} }
@ -2632,7 +2801,7 @@ const char *celt_strerror(int error)
static const char *error_strings[8] = { static const char *error_strings[8] = {
"success", "success",
"invalid argument", "invalid argument",
"invalid mode", "buffer too small",
"internal error", "internal error",
"corrupted stream", "corrupted stream",
"request not implemented", "request not implemented",

27
external/celt-e18de77/config.h vendored Normal file
View File

@ -0,0 +1,27 @@
#ifndef CONFIG_H
#define CONFIG_H
#define CELT_BUILD 1
#define restrict
#define inline __inline
#define USE_ALLOCA 1
/* Comment out the next line for floating-point code */
//#define FIXED_POINT 1
#define OPUS_BUILD 1
/* Get rid of the CELT VS compile warnings */
#if 1
#pragma warning(disable : 4018)// signed/unsigned mismatch
#pragma warning(disable : 4244)// conversion from 'double' to 'celt_word16', possible loss of data
#pragma warning(disable : 4267)// conversion from 'size_t' to 'int', possible loss of data
#pragma warning(disable : 4305)// truncation from 'double' to 'const float'
#pragma warning(disable : 4311)// pointer truncation from 'char *' to 'long'
#pragma warning(disable : 4554)// check operator precedence for possible error; use parentheses to clarify precedence
#pragma warning(disable : 4996)// This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
#endif
#endif CONFIG_H

View File

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

View File

@ -35,7 +35,7 @@
#include "entenc.h" #include "entenc.h"
#include "entdec.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); void get_required_bits(celt_int16 *bits, int N, int K, int frac);

View File

@ -26,6 +26,7 @@
*/ */
/*Some common macros for potential platform-specific optimization.*/ /*Some common macros for potential platform-specific optimization.*/
#include "celt_types.h"
#include <math.h> #include <math.h>
#include <limits.h> #include <limits.h>
#if !defined(_ecintrin_H) #if !defined(_ecintrin_H)
@ -81,6 +82,9 @@
All other code should use EC_ILOG() instead.*/ All other code should use EC_ILOG() instead.*/
#if defined(_MSC_VER) #if defined(_MSC_VER)
# include <intrin.h> # include <intrin.h>
/*In _DEBUG mode this is not an intrinsic by default.*/
# pragma intrinsic(_BitScanReverse)
static __inline int ec_bsr(unsigned long _x){ static __inline int ec_bsr(unsigned long _x){
unsigned long ret; unsigned long ret;
_BitScanReverse(&ret,_x); _BitScanReverse(&ret,_x);
@ -91,7 +95,7 @@ static __inline int ec_bsr(unsigned long _x){
#elif defined(ENABLE_TI_DSPLIB) #elif defined(ENABLE_TI_DSPLIB)
# include "dsplib.h" # include "dsplib.h"
# define EC_CLZ0 (31) # define EC_CLZ0 (31)
# define EC_CLZ(_x) (_lnorm(x)) # define EC_CLZ(_x) (_lnorm(_x))
#elif defined(__GNUC_PREREQ) #elif defined(__GNUC_PREREQ)
# if __GNUC_PREREQ(3,4) # if __GNUC_PREREQ(3,4)
# if INT_MAX>=2147483647 # if INT_MAX>=2147483647
@ -111,6 +115,8 @@ static __inline int ec_bsr(unsigned long _x){
When we need to, it can be special cased.*/ When we need to, it can be special cased.*/
# define EC_ILOG(_x) (EC_CLZ0-EC_CLZ(_x)) # define EC_ILOG(_x) (EC_CLZ0-EC_CLZ(_x))
#else #else
int ec_ilog(celt_uint32 _v);
# define EC_ILOG(_x) (ec_ilog(_x)) # define EC_ILOG(_x) (ec_ilog(_x))
#endif #endif

View File

@ -34,7 +34,7 @@
#if !defined(EC_CLZ) #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 /*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 1,000,000,000 random 32-bit integers, edging out a similar version with
branches, and a 256-entry LUT version.*/ branches, and a 256-entry LUT version.*/
@ -59,11 +59,11 @@ int ec_ilog(ec_uint32 _v){
#endif #endif
ec_uint32 ec_tell_frac(ec_ctx *_this){ celt_uint32 ec_tell_frac(ec_ctx *_this){
ec_uint32 nbits; celt_uint32 nbits;
ec_uint32 r; celt_uint32 r;
int l; int l;
int i; int i;
/*To handle the non-integral number of bits still left in the encoder/decoder /*To handle the non-integral number of bits still left in the encoder/decoder
state, we compute the worst-case number of bits of val that must be state, we compute the worst-case number of bits of val that must be
encoded to ensure that the value is inside the range for any possible encoded to ensure that the value is inside the range for any possible

View File

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

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

View File

@ -35,7 +35,7 @@
/*Initializes the decoder. /*Initializes the decoder.
_buf: The input buffer to use. _buf: The input buffer to use.
Return: 0 on success, or a negative value on error.*/ 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. /*Calculates the cumulative frequency for the next symbol.
This can then be fed into the probability model to determine what that 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). _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. This must be at least one, and no more than 2**32-1.
Return: The decoded bits.*/ 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. /*Extracts a sequence of raw bits from the stream.
The bits must have been encoded with ec_enc_bits(). 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. _ftb: The number of bits to extract.
This must be between 0 and 25, inclusive. This must be between 0 and 25, inclusive.
Return: The decoded bits.*/ 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 #endif

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

View File

@ -35,7 +35,7 @@
/*Initializes the encoder. /*Initializes the encoder.
_buf: The buffer to store output bytes in. _buf: The buffer to store output bytes in.
_size: The size of the buffer, in chars.*/ _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. /*Encodes a symbol given its frequency information.
The frequency information must be discernable by the decoder, assuming it The frequency information must be discernable by the decoder, assuming it
has read only the previous symbols from the stream. 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. _fl: The integer to encode.
_ft: The number of integers that can be encoded (one more than the max). _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.*/ 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. /*Encodes a sequence of raw bits in the stream.
_fl: The bits to encode. _fl: The bits to encode.
_ftb: The number of bits to encode. _ftb: The number of bits to encode.
This must be between 0 and 25, inclusive.*/ 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 /*Overwrites a few bits at the very start of an existing stream, after they
have already been encoded. 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. _size: The number of bytes in the new buffer.
This must be large enough to contain the bits already written, and This must be large enough to contain the bits already written, and
must be no larger than the existing size.*/ 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. /*Indicates that there are no more symbols to encode.
All reamining output bytes are flushed to the output buffer. All reamining output bytes are flushed to the output buffer.

View File

@ -55,7 +55,8 @@ int celt_header_init(CELTHeader *header, const CELTMode *m, int frame_size, int
CELT_COPY(header->codec_id, "CELT ", 8); CELT_COPY(header->codec_id, "CELT ", 8);
CELT_COPY(header->codec_version, "experimental ", 20); CELT_COPY(header->codec_version, "experimental ", 20);
celt_mode_info(m, CELT_GET_BITSTREAM_VERSION, &header->version_id); /* FIXME: Set that to zero when we freeze */
header->version_id = 0x80001000;
header->header_size = 56; header->header_size = 56;
header->sample_rate = m->Fs; header->sample_rate = m->Fs;
header->nb_channels = channels; header->nb_channels = channels;

View File

@ -50,7 +50,8 @@ extern "C" {
#endif #endif
#define _celt_check_int(x) (((void)((x) == (celt_int32)0)), (celt_int32)(x)) #define _celt_check_int(x) (((void)((x) == (celt_int32)0)), (celt_int32)(x))
#define _celt_check_mode_ptr_ptr(ptr) ((ptr) + ((ptr) - (CELTMode**)(ptr))) #define _celt_check_mode_ptr_ptr(ptr) ((ptr) + ((ptr) - (const CELTMode**)(ptr)))
#define _celt_check_int_ptr(ptr) ((ptr) + ((ptr) - (int*)(ptr)))
/* Error codes */ /* Error codes */
/** No error */ /** No error */
@ -58,7 +59,7 @@ extern "C" {
/** An (or more) invalid argument (e.g. out of range) */ /** An (or more) invalid argument (e.g. out of range) */
#define CELT_BAD_ARG -1 #define CELT_BAD_ARG -1
/** The mode struct passed is invalid */ /** The mode struct passed is invalid */
#define CELT_INVALID_MODE -2 #define CELT_BUFFER_TOO_SMALL -2
/** An internal error was detected */ /** An internal error was detected */
#define CELT_INTERNAL_ERROR -3 #define CELT_INTERNAL_ERROR -3
/** The data passed (e.g. compressed data to decoder) is corrupted */ /** The data passed (e.g. compressed data to decoder) is corrupted */
@ -70,10 +71,8 @@ extern "C" {
/** Memory allocation has failed */ /** Memory allocation has failed */
#define CELT_ALLOC_FAIL -7 #define CELT_ALLOC_FAIL -7
/* Requests */
#define CELT_GET_MODE_REQUEST 1 /* Encoder/decoder Requests */
/** Get the CELTMode used by an encoder or decoder */
#define CELT_GET_MODE(x) CELT_GET_MODE_REQUEST, _celt_check_mode_ptr_ptr(x)
#define CELT_SET_COMPLEXITY_REQUEST 2 #define CELT_SET_COMPLEXITY_REQUEST 2
/** Controls the complexity from 0-10 (int) */ /** Controls the complexity from 0-10 (int) */
@ -91,8 +90,8 @@ extern "C" {
/** Set the target VBR rate in bits per second(int); 0=CBR (default) */ /** Set the target VBR rate in bits per second(int); 0=CBR (default) */
#define CELT_SET_BITRATE(x) CELT_SET_BITRATE_REQUEST, _celt_check_int(x) #define CELT_SET_BITRATE(x) CELT_SET_BITRATE_REQUEST, _celt_check_int(x)
/** Reset the encoder/decoder memories to zero*/
#define CELT_RESET_STATE_REQUEST 8 #define CELT_RESET_STATE_REQUEST 8
/** Reset the encoder/decoder memories to zero*/
#define CELT_RESET_STATE CELT_RESET_STATE_REQUEST #define CELT_RESET_STATE CELT_RESET_STATE_REQUEST
#define CELT_SET_VBR_CONSTRAINT_REQUEST 10 #define CELT_SET_VBR_CONSTRAINT_REQUEST 10
@ -104,22 +103,25 @@ extern "C" {
#define CELT_SET_INPUT_CLIPPING_REQUEST 14 #define CELT_SET_INPUT_CLIPPING_REQUEST 14
#define CELT_SET_INPUT_CLIPPING(x) CELT_SET_INPUT_CLIPPING_REQUEST, _celt_check_int(x) #define CELT_SET_INPUT_CLIPPING(x) CELT_SET_INPUT_CLIPPING_REQUEST, _celt_check_int(x)
#define CELT_GET_AND_CLEAR_ERROR_REQUEST 15
#define CELT_GET_AND_CLEAR_ERROR(x) CELT_GET_AND_CLEAR_ERROR_REQUEST, _celt_check_int_ptr(x)
#define CELT_GET_LOOKAHEAD_REQUEST 17
#define CELT_GET_LOOKAHEAD(x) CELT_GET_LOOKAHEAD_REQUEST, _celt_check_int_ptr(x)
#define CELT_SET_CHANNELS_REQUEST 18
#define CELT_SET_CHANNELS(x) CELT_SET_CHANNELS_REQUEST, _celt_check_int(x)
#define CELT_SET_LOSS_PERC_REQUEST 20
#define CELT_SET_LOSS_PERC(x) CELT_SET_LOSS_PERC_REQUEST, _celt_check_int(x)
/* Internal */
#define CELT_SET_START_BAND_REQUEST 10000 #define CELT_SET_START_BAND_REQUEST 10000
#define CELT_SET_START_BAND(x) CELT_SET_START_BAND_REQUEST, _celt_check_int(x) #define CELT_SET_START_BAND(x) CELT_SET_START_BAND_REQUEST, _celt_check_int(x)
#define CELT_SET_END_BAND_REQUEST 10001 #define CELT_SET_END_BAND_REQUEST 10001
#define CELT_SET_END_BAND(x) CELT_SET_END_BAND_REQUEST, _celt_check_int(x) #define CELT_SET_END_BAND(x) CELT_SET_END_BAND_REQUEST, _celt_check_int(x)
#define CELT_SET_CHANNELS_REQUEST 10002
#define CELT_SET_CHANNELS(x) CELT_SET_CHANNELS_REQUEST, _celt_check_int(x)
/** GET the lookahead used in the current mode */
#define CELT_GET_LOOKAHEAD 1001
/** GET the sample rate used in the current mode */
#define CELT_GET_SAMPLE_RATE 1003
/** GET the bit-stream version for compatibility check */
#define CELT_GET_BITSTREAM_VERSION 2000
/** Contains the state of an encoder. One encoder state is needed /** Contains the state of an encoder. One encoder state is needed
@ -163,9 +165,6 @@ EXPORT CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error);
*/ */
EXPORT void celt_mode_destroy(CELTMode *mode); EXPORT void celt_mode_destroy(CELTMode *mode);
/** Query information from a mode */
EXPORT int celt_mode_info(const CELTMode *mode, int request, celt_int32 *value);
/* Encoder stuff */ /* Encoder stuff */
EXPORT int celt_encoder_get_size(int channels); EXPORT int celt_encoder_get_size(int channels);

View File

@ -644,10 +644,13 @@ kiss_fft_state *kiss_fft_alloc(int nfft,void * mem,size_t * lenmem )
void kiss_fft_free(const kiss_fft_state *cfg) void kiss_fft_free(const kiss_fft_state *cfg)
{ {
celt_free((celt_int16*)cfg->bitrev); if (cfg)
if (cfg->shift < 0) {
celt_free((kiss_twiddle_cpx*)cfg->twiddles); celt_free((celt_int16*)cfg->bitrev);
celt_free((kiss_fft_state*)cfg); if (cfg->shift < 0)
celt_free((kiss_twiddle_cpx*)cfg->twiddles);
celt_free((kiss_fft_state*)cfg);
}
} }
#endif /* CUSTOM_MODES */ #endif /* CUSTOM_MODES */

View File

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

View File

@ -74,25 +74,6 @@ static const unsigned char band_allocation[] = {
#endif #endif
int celt_mode_info(const CELTMode *mode, int request, celt_int32 *value)
{
switch (request)
{
case CELT_GET_LOOKAHEAD:
*value = mode->overlap;
break;
case CELT_GET_BITSTREAM_VERSION:
*value = CELT_BITSTREAM_VERSION;
break;
case CELT_GET_SAMPLE_RATE:
*value = mode->Fs;
break;
default:
return CELT_UNIMPLEMENTED;
}
return CELT_OK;
}
#ifdef CUSTOM_MODES #ifdef CUSTOM_MODES
/* Defining 25 critical bands for the full 0-20 kHz audio bandwidth /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
@ -243,23 +224,12 @@ static void compute_allocation_table(CELTMode *mode)
CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error) CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
{ {
int i; int i;
CELTMode *mode=NULL;
#ifdef CUSTOM_MODES #ifdef CUSTOM_MODES
CELTMode *mode=NULL;
int res; int res;
celt_word16 *window; celt_word16 *window;
celt_int16 *logN; celt_int16 *logN;
int LM; int LM;
#endif
#ifdef STDIN_TUNING
scanf("%d ", &MIN_BINS);
scanf("%d ", &BITALLOC_SIZE);
band_allocation = celt_alloc(sizeof(int)*BARK_BANDS*BITALLOC_SIZE);
for (i=0;i<BARK_BANDS*BITALLOC_SIZE;i++)
{
scanf("%d ", band_allocation+i);
}
#endif
#ifdef CUSTOM_MODES
ALLOC_STACK; ALLOC_STACK;
#if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA) #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
if (global_stack==NULL) if (global_stack==NULL)
@ -308,7 +278,7 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
if ((celt_int32)frame_size*1000 < Fs) if ((celt_int32)frame_size*1000 < Fs)
{ {
if (error) if (error)
*error = CELT_INVALID_MODE; *error = CELT_BAD_ARG;
return NULL; return NULL;
} }
@ -330,7 +300,7 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
if ((celt_int32)(frame_size>>LM)*300 > Fs) if ((celt_int32)(frame_size>>LM)*300 > Fs)
{ {
if (error) if (error)
*error = CELT_INVALID_MODE; *error = CELT_BAD_ARG;
return NULL; return NULL;
} }
@ -425,7 +395,7 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
return mode; return mode;
failure: failure:
if (error) if (error)
*error = CELT_INVALID_MODE; *error = CELT_ALLOC_FAIL;
if (mode!=NULL) if (mode!=NULL)
celt_mode_destroy(mode); celt_mode_destroy(mode);
return NULL; return NULL;

View File

@ -100,6 +100,13 @@ struct CELTMode {
#endif #endif
#ifdef OPUS_BUILD #ifdef OPUS_BUILD
#define CELT_SET_SIGNALLING_REQUEST 10003
#define CELT_SET_SIGNALLING(x) CELT_SET_SIGNALLING_REQUEST, _celt_check_int(x)
#define CELT_GET_MODE_REQUEST 10004
/** Get the CELTMode used by an encoder or decoder */
#define CELT_GET_MODE(x) CELT_GET_MODE_REQUEST, _celt_check_mode_ptr_ptr(x)
/* Prototypes for _ec versions of the encoder/decoder calls (not public) */ /* Prototypes for _ec versions of the encoder/decoder calls (not public) */
int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc); int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc);
int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc); int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc);

View File

@ -139,7 +139,7 @@ static const unsigned char e_prob_model[4][2][42] = {
static const unsigned char small_energy_icdf[3]={2,1,0}; static const unsigned char small_energy_icdf[3]={2,1,0};
static int intra_decision(const celt_word16 *eBands, celt_word16 *oldEBands, int start, int end, int len, int C) static celt_word32 loss_distortion(const celt_word16 *eBands, celt_word16 *oldEBands, int start, int end, int len, int C)
{ {
int c, i; int c, i;
celt_word32 dist = 0; celt_word32 dist = 0;
@ -150,12 +150,12 @@ static int intra_decision(const celt_word16 *eBands, celt_word16 *oldEBands, int
dist = MAC16_16(dist, d,d); dist = MAC16_16(dist, d,d);
} }
} while (++c<C); } while (++c<C);
return SHR32(dist,2*DB_SHIFT-4) > 2*C*(end-start); return MIN32(200,SHR32(dist,2*DB_SHIFT-4));
} }
static int quant_coarse_energy_impl(const CELTMode *m, int start, int end, static int quant_coarse_energy_impl(const CELTMode *m, int start, int end,
const celt_word16 *eBands, celt_word16 *oldEBands, 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, const unsigned char *prob_model, celt_word16 *error, ec_enc *enc,
int _C, int LM, int intra, celt_word16 max_decay) int _C, int LM, int intra, celt_word16 max_decay)
{ {
@ -258,9 +258,9 @@ 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, 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, celt_word16 *error, ec_enc *enc, int _C, int LM, int nbAvailableBytes,
int force_intra, int *delayedIntra, int two_pass) int force_intra, celt_word32 *delayedIntra, int two_pass, int loss_rate)
{ {
const int C = CHANNELS(_C); const int C = CHANNELS(_C);
int intra; int intra;
@ -268,15 +268,15 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
VARDECL(celt_word16, oldEBands_intra); VARDECL(celt_word16, oldEBands_intra);
VARDECL(celt_word16, error_intra); VARDECL(celt_word16, error_intra);
ec_enc enc_start_state; ec_enc enc_start_state;
ec_uint32 tell; celt_uint32 tell;
int badness1=0; int badness1=0;
celt_int32 intra_bias;
celt_word32 new_distortion;
SAVE_STACK; SAVE_STACK;
intra = force_intra || (*delayedIntra && nbAvailableBytes > (end-start)*C); intra = force_intra || (!two_pass && *delayedIntra>2*C*(end-start) && nbAvailableBytes > (end-start)*C);
if (/*shortBlocks || */intra_decision(eBands, oldEBands, start, effEnd, m->nbEBands, C)) intra_bias = ((budget**delayedIntra*loss_rate)/(C*512));
*delayedIntra = 1; new_distortion = loss_distortion(eBands, oldEBands, start, effEnd, m->nbEBands, C);
else
*delayedIntra = 0;
tell = ec_tell(enc); tell = ec_tell(enc);
if (tell+3 > budget) if (tell+3 > budget)
@ -307,8 +307,8 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
{ {
ec_enc enc_intra_state; ec_enc enc_intra_state;
int tell_intra; int tell_intra;
ec_uint32 nstart_bytes; celt_uint32 nstart_bytes;
ec_uint32 nintra_bytes; celt_uint32 nintra_bytes;
int badness2; int badness2;
VARDECL(unsigned char, intra_bits); VARDECL(unsigned char, intra_bits);
@ -329,7 +329,7 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
badness2 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands, budget, badness2 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands, budget,
tell, e_prob_model[LM][intra], error, enc, C, LM, 0, max_decay); tell, e_prob_model[LM][intra], error, enc, C, LM, 0, max_decay);
if (two_pass && (badness1 < badness2 || (badness1 == badness2 && ec_tell_frac(enc) > tell_intra))) if (two_pass && (badness1 < badness2 || (badness1 == badness2 && ec_tell_frac(enc)+intra_bias > tell_intra)))
{ {
*enc = enc_intra_state; *enc = enc_intra_state;
/* Copy intra bits to bit-stream */ /* Copy intra bits to bit-stream */
@ -337,11 +337,19 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
intra_bits, nintra_bytes - nstart_bytes); intra_bits, nintra_bytes - nstart_bytes);
CELT_COPY(oldEBands, oldEBands_intra, C*m->nbEBands); CELT_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
CELT_COPY(error, error_intra, C*m->nbEBands); CELT_COPY(error, error_intra, C*m->nbEBands);
intra = 1;
} }
} else { } else {
CELT_COPY(oldEBands, oldEBands_intra, C*m->nbEBands); CELT_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
CELT_COPY(error, error_intra, C*m->nbEBands); CELT_COPY(error, error_intra, C*m->nbEBands);
} }
if (intra)
*delayedIntra = new_distortion;
else
*delayedIntra = ADD32(MULT16_32_Q15(MULT16_16_Q15(pred_coef[LM], pred_coef[LM]),*delayedIntra),
new_distortion);
RESTORE_STACK; RESTORE_STACK;
} }
@ -421,8 +429,8 @@ void unquant_coarse_energy(const CELTMode *m, int start, int end, celt_word16 *o
celt_word16 coef; celt_word16 coef;
celt_word16 beta; celt_word16 beta;
const int C = CHANNELS(_C); const int C = CHANNELS(_C);
ec_int32 budget; celt_int32 budget;
ec_int32 tell; celt_int32 tell;
if (intra) if (intra)

View File

@ -45,9 +45,10 @@ unsigned char *quant_prob_alloc(const CELTMode *m);
void quant_prob_free(const celt_int16 *freq); void quant_prob_free(const celt_int16 *freq);
void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd, 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, celt_word16 *error, ec_enc *enc, int _C, int LM,
int nbAvailableBytes, int force_intra, int *delayedIntra, int two_pass); int nbAvailableBytes, int force_intra, celt_word32 *delayedIntra,
int two_pass, int loss_rate);
void quant_fine_energy(const CELTMode *m, int start, int end, celt_word16 *oldEBands, celt_word16 *error, int *fine_quant, ec_enc *enc, int _C); void quant_fine_energy(const CELTMode *m, int start, int end, celt_word16 *oldEBands, celt_word16 *error, int *fine_quant, ec_enc *enc, int _C);

View File

@ -523,7 +523,7 @@ static inline int interp_bits2pulses(const CELTMode *m, int start, int end, int
} }
int compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stereo, int compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stereo,
int total, celt_int32 *balance, int *pulses, int *ebits, int *fine_priority, int _C, int LM, ec_ctx *ec, int encode, int prev) celt_int32 total, celt_int32 *balance, int *pulses, int *ebits, int *fine_priority, int _C, int LM, ec_ctx *ec, int encode, int prev)
{ {
int lo, hi, len, j; int lo, hi, len, j;
const int C = CHANNELS(_C); const int C = CHANNELS(_C);
@ -584,18 +584,19 @@ int compute_allocation(const CELTMode *m, int start, int end, const int *offsets
int mid = (lo+hi) >> 1; int mid = (lo+hi) >> 1;
for (j=end;j-->start;) for (j=end;j-->start;)
{ {
int bitsj;
int N = m->eBands[j+1]-m->eBands[j]; int N = m->eBands[j+1]-m->eBands[j];
bits1[j] = C*N*m->allocVectors[mid*len+j]<<LM>>2; bitsj = C*N*m->allocVectors[mid*len+j]<<LM>>2;
if (bits1[j] > 0) if (bitsj > 0)
bits1[j] = IMAX(0, bits1[j] + trim_offset[j]); bitsj = IMAX(0, bitsj + trim_offset[j]);
bits1[j] += offsets[j]; bitsj += offsets[j];
if (bits1[j] >= thresh[j] || done) if (bitsj >= thresh[j] || done)
{ {
done = 1; done = 1;
/* Don't allocate more than we can actually use */ /* Don't allocate more than we can actually use */
psum += IMIN(bits1[j], cap[j]); psum += IMIN(bitsj, cap[j]);
} else { } else {
if (bits1[j] >= C<<BITRES) if (bitsj >= C<<BITRES)
psum += C<<BITRES; psum += C<<BITRES;
} }
} }
@ -610,20 +611,23 @@ int compute_allocation(const CELTMode *m, int start, int end, const int *offsets
/*printf ("interp between %d and %d\n", lo, hi);*/ /*printf ("interp between %d and %d\n", lo, hi);*/
for (j=start;j<end;j++) for (j=start;j<end;j++)
{ {
int bits1j, bits2j;
int N = m->eBands[j+1]-m->eBands[j]; int N = m->eBands[j+1]-m->eBands[j];
bits1[j] = C*N*m->allocVectors[lo*len+j]<<LM>>2; bits1j = C*N*m->allocVectors[lo*len+j]<<LM>>2;
bits2[j] = hi>=m->nbAllocVectors ? bits2j = hi>=m->nbAllocVectors ?
cap[j] : C*N*m->allocVectors[hi*len+j]<<LM>>2; cap[j] : C*N*m->allocVectors[hi*len+j]<<LM>>2;
if (bits1[j] > 0) if (bits1j > 0)
bits1[j] = IMAX(0, bits1[j] + trim_offset[j]); bits1j = IMAX(0, bits1j + trim_offset[j]);
if (bits2[j] > 0) if (bits2j > 0)
bits2[j] = IMAX(0, bits2[j] + trim_offset[j]); bits2j = IMAX(0, bits2j + trim_offset[j]);
if (lo > 0) if (lo > 0)
bits1[j] += offsets[j]; bits1j += offsets[j];
bits2[j] += offsets[j]; bits2j += offsets[j];
if (offsets[j]>0) if (offsets[j]>0)
skip_start = j; skip_start = j;
bits2[j] = IMAX(0,bits2[j]-bits1[j]); bits2j = IMAX(0,bits2j-bits1j);
bits1[j] = bits1j;
bits2[j] = bits2j;
} }
codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap, codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap,
total, balance, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv, total, balance, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv,

View File

@ -125,14 +125,14 @@ extern char *global_stack_top;
#define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1)) #define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1))
#define PUSH(stack, size, type) (VALGRIND_MAKE_MEM_NOACCESS(stack, global_stack_top-stack),ALIGN((stack),sizeof(type)/sizeof(char)),VALGRIND_MAKE_MEM_UNDEFINED(stack, ((size)*sizeof(type)/sizeof(char))),(stack)+=(2*(size)*sizeof(type)/sizeof(char)),(type*)((stack)-(2*(size)*sizeof(type)/sizeof(char)))) #define PUSH(stack, size, type) (VALGRIND_MAKE_MEM_NOACCESS(stack, global_stack_top-stack),ALIGN((stack),sizeof(type)/sizeof(char)),VALGRIND_MAKE_MEM_UNDEFINED(stack, ((size)*sizeof(type)/sizeof(char))),(stack)+=(2*(size)*sizeof(type)/sizeof(char)),(type*)((stack)-(2*(size)*sizeof(type)/sizeof(char))))
#define RESTORE_STACK ((global_stack = _saved_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack)) #define RESTORE_STACK ((global_stack = _saved_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack))
#define ALLOC_STACK ((global_stack = (global_stack==0) ? ((global_stack_top=celt_alloc_scratch(GLOBAL_STACK_SIZE*2)+(GLOBAL_STACK_SIZE*2))-(GLOBAL_STACK_SIZE*2)) : global_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack)) #define ALLOC_STACK char *_saved_stack; ((global_stack = (global_stack==0) ? ((global_stack_top=celt_alloc_scratch(GLOBAL_STACK_SIZE*2)+(GLOBAL_STACK_SIZE*2))-(GLOBAL_STACK_SIZE*2)) : global_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack)); _saved_stack = global_stack;
#else #else
#define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1)) #define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1))
#define PUSH(stack, size, type) (ALIGN((stack),sizeof(type)/sizeof(char)),(stack)+=(size)*(sizeof(type)/sizeof(char)),(type*)((stack)-(size)*(sizeof(type)/sizeof(char)))) #define PUSH(stack, size, type) (ALIGN((stack),sizeof(type)/sizeof(char)),(stack)+=(size)*(sizeof(type)/sizeof(char)),(type*)((stack)-(size)*(sizeof(type)/sizeof(char))))
#define RESTORE_STACK (global_stack = _saved_stack) #define RESTORE_STACK (global_stack = _saved_stack)
#define ALLOC_STACK (global_stack = (global_stack==0) ? celt_alloc_scratch(GLOBAL_STACK_SIZE) : global_stack) #define ALLOC_STACK char *_saved_stack; (global_stack = (global_stack==0) ? celt_alloc_scratch(GLOBAL_STACK_SIZE) : global_stack); _saved_stack = global_stack;
#endif /*ENABLE_VALGRIND*/ #endif /*ENABLE_VALGRIND*/

View File

@ -1,5 +1,5 @@
local base_dir = (solution().basedir .. "/external/celt-0.11.1/") local base_dir = (solution().basedir .. "/external/celt-e18de77/")
group "external" group "external"
project "celt" project "celt"
@ -9,9 +9,10 @@ group "external"
defines defines
{ {
"restrict=",
"CUSTOM_MODES", "CUSTOM_MODES",
"CUSTOM_MODES_ONLY" "CUSTOM_MODES_ONLY",
"DISABLE_FLOAT_API",
"HAVE_CONFIG_H"
} }
includedirs includedirs
{ {