blob: 8e979604613a384b8387cb587f901fd96b36ea25 [file] [log] [blame]
/*
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
/*
* arith_routinslogist.c
*
* This C file contains arithmetic encode and decode logistic
*
*/
#include "modules/audio_coding/codecs/isac/fix/source/arith_routins.h"
/* Tables for piecewise linear cdf functions: y = k*x */
/* x Points for function piecewise() in Q15 */
static const int32_t kHistEdges[51] = {
-327680, -314573, -301466, -288359, -275252, -262144, -249037, -235930, -222823, -209716,
-196608, -183501, -170394, -157287, -144180, -131072, -117965, -104858, -91751, -78644,
-65536, -52429, -39322, -26215, -13108, 0, 13107, 26214, 39321, 52428,
65536, 78643, 91750, 104857, 117964, 131072, 144179, 157286, 170393, 183500,
196608, 209715, 222822, 235929, 249036, 262144, 275251, 288358, 301465, 314572,
327680
};
/* k Points for function piecewise() in Q0 */
static const uint16_t kCdfSlope[51] = {
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 13, 23, 47, 87, 154, 315, 700, 1088,
2471, 6064, 14221, 21463, 36634, 36924, 19750, 13270, 5806, 2312,
1095, 660, 316, 145, 86, 41, 32, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 2,
0
};
/* y Points for function piecewise() in Q0 */
static const uint16_t kCdfLogistic[51] = {
0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
20, 22, 24, 29, 38, 57, 92, 153, 279, 559,
994, 1983, 4408, 10097, 18682, 33336, 48105, 56005, 61313, 63636,
64560, 64998, 65262, 65389, 65447, 65481, 65497, 65510, 65512, 65514,
65516, 65518, 65520, 65522, 65524, 65526, 65528, 65530, 65532, 65534,
65535
};
/****************************************************************************
* WebRtcIsacfix_Piecewise(...)
*
* Piecewise linear function
*
* Input:
* - xinQ15 : input value x in Q15
*
* Return value : korresponding y-value in Q0
*/
static __inline uint16_t WebRtcIsacfix_Piecewise(int32_t xinQ15) {
int32_t ind;
int32_t qtmp1;
uint16_t qtmp2;
/* Find index for x-value */
qtmp1 = WEBRTC_SPL_SAT(kHistEdges[50],xinQ15,kHistEdges[0]);
ind = WEBRTC_SPL_MUL(5, qtmp1 - kHistEdges[0]);
ind >>= 16;
/* Calculate corresponding y-value ans return*/
qtmp1 = qtmp1 - kHistEdges[ind];
qtmp2 = (uint16_t)WEBRTC_SPL_RSHIFT_U32(
WEBRTC_SPL_UMUL_32_16(qtmp1,kCdfSlope[ind]), 15);
return (kCdfLogistic[ind] + qtmp2);
}
/****************************************************************************
* WebRtcIsacfix_EncLogisticMulti2(...)
*
* Arithmetic coding of spectrum.
*
* Input:
* - streamData : in-/output struct containing bitstream
* - dataQ7 : data vector in Q7
* - envQ8 : side info vector defining the width of the pdf
* in Q8
* - lenData : data vector length
*
* Return value : 0 if ok,
* <0 otherwise.
*/
int WebRtcIsacfix_EncLogisticMulti2(Bitstr_enc *streamData,
int16_t *dataQ7,
const uint16_t *envQ8,
const int16_t lenData)
{
uint32_t W_lower;
uint32_t W_upper;
uint16_t W_upper_LSB;
uint16_t W_upper_MSB;
uint16_t *streamPtr;
uint16_t *maxStreamPtr;
uint16_t *streamPtrCarry;
uint16_t negcarry;
uint32_t cdfLo;
uint32_t cdfHi;
int k;
/* point to beginning of stream buffer
* and set maximum streamPtr value */
streamPtr = streamData->stream + streamData->stream_index;
maxStreamPtr = streamData->stream + STREAM_MAXW16_60MS - 1;
W_upper = streamData->W_upper;
for (k = 0; k < lenData; k++)
{
/* compute cdf_lower and cdf_upper by evaluating the
* WebRtcIsacfix_Piecewise linear cdf */
cdfLo = WebRtcIsacfix_Piecewise(WEBRTC_SPL_MUL_16_U16(*dataQ7 - 64, *envQ8));
cdfHi = WebRtcIsacfix_Piecewise(WEBRTC_SPL_MUL_16_U16(*dataQ7 + 64, *envQ8));
/* test and clip if probability gets too small */
while ((cdfLo + 1) >= cdfHi) {
/* clip */
if (*dataQ7 > 0) {
*dataQ7 -= 128;
cdfHi = cdfLo;
cdfLo = WebRtcIsacfix_Piecewise(
WEBRTC_SPL_MUL_16_U16(*dataQ7 - 64, *envQ8));
} else {
*dataQ7 += 128;
cdfLo = cdfHi;
cdfHi = WebRtcIsacfix_Piecewise(
WEBRTC_SPL_MUL_16_U16(*dataQ7 + 64, *envQ8));
}
}
dataQ7++;
/* increment only once per 4 iterations */
envQ8 += (k & 1) & (k >> 1);
/* update interval */
W_upper_LSB = (uint16_t)W_upper;
W_upper_MSB = (uint16_t)WEBRTC_SPL_RSHIFT_U32(W_upper, 16);
W_lower = WEBRTC_SPL_UMUL_32_16(cdfLo, W_upper_MSB);
W_lower += (cdfLo * W_upper_LSB) >> 16;
W_upper = WEBRTC_SPL_UMUL_32_16(cdfHi, W_upper_MSB);
W_upper += (cdfHi * W_upper_LSB) >> 16;
/* shift interval such that it begins at zero */
W_upper -= ++W_lower;
/* add integer to bitstream */
streamData->streamval += W_lower;
/* handle carry */
if (streamData->streamval < W_lower)
{
/* propagate carry */
streamPtrCarry = streamPtr;
if (streamData->full == 0) {
negcarry = *streamPtrCarry;
negcarry += 0x0100;
*streamPtrCarry = negcarry;
while (!(negcarry))
{
negcarry = *--streamPtrCarry;
negcarry++;
*streamPtrCarry = negcarry;
}
} else {
while (!(++(*--streamPtrCarry)));
}
}
/* renormalize interval, store most significant byte of streamval and update streamval
* W_upper < 2^24 */
while ( !(W_upper & 0xFF000000) )
{
W_upper <<= 8;
if (streamData->full == 0) {
*streamPtr++ += (uint16_t) WEBRTC_SPL_RSHIFT_U32(
streamData->streamval, 24);
streamData->full = 1;
} else {
*streamPtr = (uint16_t)((streamData->streamval >> 24) << 8);
streamData->full = 0;
}
if( streamPtr > maxStreamPtr )
return -ISAC_DISALLOWED_BITSTREAM_LENGTH;
streamData->streamval <<= 8;
}
}
/* calculate new stream_index */
streamData->stream_index = streamPtr - streamData->stream;
streamData->W_upper = W_upper;
return 0;
}
/****************************************************************************
* WebRtcIsacfix_DecLogisticMulti2(...)
*
* Arithmetic decoding of spectrum.
*
* Input:
* - streamData : in-/output struct containing bitstream
* - envQ8 : side info vector defining the width of the pdf
* in Q8
* - lenData : data vector length
*
* Input/Output:
* - dataQ7 : input: dither vector, output: data vector
*
* Return value : number of bytes in the stream so far
* -1 if error detected
*/
int WebRtcIsacfix_DecLogisticMulti2(int16_t *dataQ7,
Bitstr_dec *streamData,
const int32_t *envQ8,
const int16_t lenData)
{
uint32_t W_lower;
uint32_t W_upper;
uint32_t W_tmp;
uint16_t W_upper_LSB;
uint16_t W_upper_MSB;
uint32_t streamVal;
uint16_t cdfTmp;
int32_t res;
int32_t inSqrt;
int32_t newRes;
const uint16_t *streamPtr;
int16_t candQ7;
int16_t envCount;
uint16_t tmpARSpecQ8 = 0;
int k, i;
int offset = 0;
/* point to beginning of stream buffer */
streamPtr = streamData->stream + streamData->stream_index;
W_upper = streamData->W_upper;
/* Check if it is first time decoder is called for this stream */
if (streamData->stream_index == 0)
{
/* read first word from bytestream */
streamVal = (uint32_t)(*streamPtr++) << 16;
streamVal |= *streamPtr++;
} else {
streamVal = streamData->streamval;
}
res = 1 << (WebRtcSpl_GetSizeInBits(envQ8[0]) >> 1);
envCount = 0;
/* code assumes lenData%4 == 0 */
for (k = 0; k < lenData; k += 4)
{
int k4;
/* convert to magnitude spectrum, by doing square-roots (modified from SPLIB) */
inSqrt = envQ8[envCount];
i = 10;
/* For safty reasons */
if (inSqrt < 0)
inSqrt=-inSqrt;
newRes = (inSqrt / res + res) >> 1;
do
{
res = newRes;
newRes = (inSqrt / res + res) >> 1;
} while (newRes != res && i-- > 0);
tmpARSpecQ8 = (uint16_t)newRes;
for(k4 = 0; k4 < 4; k4++)
{
/* find the integer *data for which streamVal lies in [W_lower+1, W_upper] */
W_upper_LSB = (uint16_t) (W_upper & 0x0000FFFF);
W_upper_MSB = (uint16_t) WEBRTC_SPL_RSHIFT_U32(W_upper, 16);
/* find first candidate by inverting the logistic cdf
* Input dither value collected from io-stream */
candQ7 = - *dataQ7 + 64;
cdfTmp = WebRtcIsacfix_Piecewise(WEBRTC_SPL_MUL_16_U16(candQ7, tmpARSpecQ8));
W_tmp = (uint32_t)cdfTmp * W_upper_MSB;
W_tmp += ((uint32_t)cdfTmp * (uint32_t)W_upper_LSB) >> 16;
if (streamVal > W_tmp)
{
W_lower = W_tmp;
candQ7 += 128;
cdfTmp = WebRtcIsacfix_Piecewise(WEBRTC_SPL_MUL_16_U16(candQ7, tmpARSpecQ8));
W_tmp = (uint32_t)cdfTmp * W_upper_MSB;
W_tmp += ((uint32_t)cdfTmp * (uint32_t)W_upper_LSB) >> 16;
while (streamVal > W_tmp)
{
W_lower = W_tmp;
candQ7 += 128;
cdfTmp = WebRtcIsacfix_Piecewise(
WEBRTC_SPL_MUL_16_U16(candQ7, tmpARSpecQ8));
W_tmp = (uint32_t)cdfTmp * W_upper_MSB;
W_tmp += ((uint32_t)cdfTmp * (uint32_t)W_upper_LSB) >> 16;
/* error check */
if (W_lower == W_tmp) {
return -1;
}
}
W_upper = W_tmp;
/* Output value put in dataQ7: another sample decoded */
*dataQ7 = candQ7 - 64;
}
else
{
W_upper = W_tmp;
candQ7 -= 128;
cdfTmp = WebRtcIsacfix_Piecewise(WEBRTC_SPL_MUL_16_U16(candQ7, tmpARSpecQ8));
W_tmp = (uint32_t)cdfTmp * W_upper_MSB;
W_tmp += ((uint32_t)cdfTmp * (uint32_t)W_upper_LSB) >> 16;
while ( !(streamVal > W_tmp) )
{
W_upper = W_tmp;
candQ7 -= 128;
cdfTmp = WebRtcIsacfix_Piecewise(
WEBRTC_SPL_MUL_16_U16(candQ7, tmpARSpecQ8));
W_tmp = (uint32_t)cdfTmp * W_upper_MSB;
W_tmp += ((uint32_t)cdfTmp * (uint32_t)W_upper_LSB) >> 16;
/* error check */
if (W_upper == W_tmp){
return -1;
}
}
W_lower = W_tmp;
/* Output value put in dataQ7: another sample decoded */
*dataQ7 = candQ7 + 64;
}
dataQ7++;
/* shift interval to start at zero */
W_upper -= ++W_lower;
/* add integer to bitstream */
streamVal -= W_lower;
/* renormalize interval and update streamVal
* W_upper < 2^24 */
while ( !(W_upper & 0xFF000000) )
{
if (streamPtr < streamData->stream + streamData->stream_size) {
/* read next byte from stream */
if (streamData->full == 0) {
streamVal = (streamVal << 8) | (*streamPtr++ & 0x00FF);
streamData->full = 1;
} else {
streamVal = (streamVal << 8) | (*streamPtr >> 8);
streamData->full = 0;
}
} else {
/* Intending to read outside the stream. This can happen for the last
* two or three bytes. It is how the algorithm is implemented. Do
* not read from the bit stream and insert zeros instead. */
streamVal <<= 8;
if (streamData->full == 0) {
offset++; // We would have incremented the pointer in this case.
streamData->full = 1;
} else {
streamData->full = 0;
}
}
W_upper <<= 8;
}
}
envCount++;
}
streamData->stream_index = streamPtr + offset - streamData->stream;
streamData->W_upper = W_upper;
streamData->streamval = streamVal;
/* find number of bytes in original stream (determined by current interval width) */
if ( W_upper > 0x01FFFFFF )
return (streamData->stream_index*2 - 3 + !streamData->full);
else
return (streamData->stream_index*2 - 2 + !streamData->full);
}