devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

Further optimization of atrac3 codec. Refacturate gainCompensateAndOverlap(), avoid multiplication if not needed, unroll loops. Speeds up codec by 1.1 MHz (+2%) on ARM.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@24668 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Andree Buschmann 2010-02-15 16:11:49 +00:00
parent ad1ba429b9
commit 51a8be1a0f
1 changed files with 145 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

183
apps/codecs/libatrac/atrac3.c
View file

@ -59,6 +59,7 @@ static int32_t qmf_window[48] IBSS_ATTR;
static VLC spectral_coeff_tab[7]; static VLC spectral_coeff_tab[7];
static channel_unit channel_units[2] IBSS_ATTR_LARGE_IRAM; static channel_unit channel_units[2] IBSS_ATTR_LARGE_IRAM;
/** /**
* Matrixing within quadrature mirror synthesis filter. * Matrixing within quadrature mirror synthesis filter.
* *
@ -91,6 +92,7 @@ static channel_unit channel_units[2] IBSS_ATTR_LARGE_IRAM;
} }
#endif #endif
/** /**
* Matrixing within quadrature mirror synthesis filter. * Matrixing within quadrature mirror synthesis filter.
* *
@ -195,6 +197,7 @@ static channel_unit channel_units[2] IBSS_ATTR_LARGE_IRAM;
} }
#endif #endif
/** /**
* IMDCT windowing. * IMDCT windowing.
* *
@ -214,6 +217,7 @@ atrac3_imdct_windowing(int32_t *buffer,
} }
} }
/** /**
* Quadrature mirror synthesis filter. * Quadrature mirror synthesis filter.
* *
@ -240,12 +244,13 @@ static void iqmf (int32_t *inlo, int32_t *inhi, unsigned int nIn, int32_t *pOut,
memcpy(delayBuf, temp + (nIn << 1), 46*sizeof(int32_t)); memcpy(delayBuf, temp + (nIn << 1), 46*sizeof(int32_t));
} }
/** /**
* Regular 512 points IMDCT without overlapping, with the exception of the swapping of odd bands * Regular 512 points IMDCT without overlapping, with the exception of the swapping of odd bands
* caused by the reverse spectra of the QMF. * caused by the reverse spectra of the QMF.
* *
* @param pInput float input * @param pInput input
* @param pOutput float output * @param pOutput output
* @param odd_band 1 if the band is an odd band * @param odd_band 1 if the band is an odd band
*/ */
@ -274,7 +279,7 @@ static int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes){
uint32_t* obuf = (uint32_t*) out; uint32_t* obuf = (uint32_t*) out;
#if ((defined(TEST) || defined(SIMULATOR)) && !defined(CPU_ARM)) #if ((defined(TEST) || defined(SIMULATOR)) && !defined(CPU_ARM))
off = 0; //no check for memory alignment of inbuffer off = 0; /* no check for memory alignment of inbuffer */
#else #else
off = (intptr_t)inbuffer & 3; off = (intptr_t)inbuffer & 3;
#endif /* TEST */ #endif /* TEST */
@ -306,6 +311,7 @@ static void init_atrac3_transforms(void) {
} }
} }
/** /**
* Mantissa decoding * Mantissa decoding
* *
@ -338,7 +344,7 @@ static void readQuantSpectralCoeffs (GetBitContext *gb, int selector, int coding
} else { } else {
for (cnt = 0; cnt < numCodes; cnt++) { for (cnt = 0; cnt < numCodes; cnt++) {
if (numBits) if (numBits)
code = get_bits(gb, numBits); //numBits is always 4 in this case code = get_bits(gb, numBits); /* numBits is always 4 in this case */
else else
code = 0; code = 0;
mantissas[cnt*2] = seTab_0[code >> 2]; mantissas[cnt*2] = seTab_0[code >> 2];
@ -366,6 +372,7 @@ static void readQuantSpectralCoeffs (GetBitContext *gb, int selector, int coding
} }
} }
/** /**
* Restore the quantized band spectrum coefficients * Restore the quantized band spectrum coefficients
* *
@ -382,8 +389,8 @@ int decodeSpectrum (GetBitContext *gb, int32_t *pOut)
int mantissas[128]; int mantissas[128];
int32_t SF; int32_t SF;
numSubbands = get_bits(gb, 5); // number of coded subbands numSubbands = get_bits(gb, 5); /* number of coded subbands */
codingMode = get_bits1(gb); // coding Mode: 0 - VLC/ 1-CLC codingMode = get_bits1(gb); /* coding Mode: 0 - VLC/ 1-CLC */
/* Get the VLC selector table for the subbands, 0 means not coded. */ /* Get the VLC selector table for the subbands, 0 means not coded. */
for (cnt = 0; cnt <= numSubbands; cnt++) for (cnt = 0; cnt <= numSubbands; cnt++)
@ -437,6 +444,7 @@ int decodeSpectrum (GetBitContext *gb, int32_t *pOut)
return numSubbands; return numSubbands;
} }
/** /**
* Restore the quantized tonal components * Restore the quantized tonal components
* *
@ -517,6 +525,7 @@ static int decodeTonalComponents (GetBitContext *gb, tonal_component *pComponent
return component_count; return component_count;
} }
/** /**
* Decode gain parameters for the coded bands * Decode gain parameters for the coded bands
* *
@ -554,21 +563,125 @@ static int decodeGainControl (GetBitContext *gb, gain_block *pGb, int numBands)
return 0; return 0;
} }
/**
* Apply fix (constant) gain and overlap for sample[start...255].
*
* @param pIn input buffer
* @param pPrev previous buffer to perform overlap against
* @param pOut output buffer
* @param start index to start with (always a multiple of 8)
* @param gain gain to apply
*/
static void applyFixGain (int32_t *pIn, int32_t *pPrev, int32_t *pOut,
int32_t start, int32_t gain)
{
int32_t i = start;
/* start is always a multiple of 8 and therefore allows us to unroll the
* loop to 8 calculation per loop
*/
if (ONE_16 == gain) {
/* gain1 = 1.0 -> no multiplication needed, just adding */
/* Remark: This path is called >90%. */
do {
pOut[i] = pIn[i] + pPrev[i]; i++;
pOut[i] = pIn[i] + pPrev[i]; i++;
pOut[i] = pIn[i] + pPrev[i]; i++;
pOut[i] = pIn[i] + pPrev[i]; i++;
pOut[i] = pIn[i] + pPrev[i]; i++;
pOut[i] = pIn[i] + pPrev[i]; i++;
pOut[i] = pIn[i] + pPrev[i]; i++;
pOut[i] = pIn[i] + pPrev[i]; i++;
} while (i<256);
} else {
/* gain1 != 1.0 -> we need to do a multiplication */
/* Remark: This path is called seldom. */
do {
pOut[i] = fixmul16(pIn[i], gain) + pPrev[i]; i++;
pOut[i] = fixmul16(pIn[i], gain) + pPrev[i]; i++;
pOut[i] = fixmul16(pIn[i], gain) + pPrev[i]; i++;
pOut[i] = fixmul16(pIn[i], gain) + pPrev[i]; i++;
pOut[i] = fixmul16(pIn[i], gain) + pPrev[i]; i++;
pOut[i] = fixmul16(pIn[i], gain) + pPrev[i]; i++;
pOut[i] = fixmul16(pIn[i], gain) + pPrev[i]; i++;
pOut[i] = fixmul16(pIn[i], gain) + pPrev[i]; i++;
} while (i<256);
}
}
/**
* Apply variable gain and overlap. Returns sample index after applying gain,
* resulting sample index is always a multiple of 8.
*
* @param pIn input buffer
* @param pPrev previous buffer to perform overlap against
* @param pOut output buffer
* @param start index to start with (always a multiple of 8)
* @param end end index for first loop (always a multiple of 8)
* @param gain1 current bands gain to apply
* @param gain2 next bands gain to apply
* @param gain_inc stepwise adaption from gain1 to gain2
*/
static int applyVariableGain (int32_t *pIn, int32_t *pPrev, int32_t *pOut,
int32_t start, int32_t end,
int32_t gain1, int32_t gain2, int32_t gain_inc)
{
int32_t i = start;
/* Apply fix gains until end index is reached */
do {
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
} while (i < end);
/* Interpolation is done over next eight samples */
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
gain2 = fixmul16(gain2, gain_inc);
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
gain2 = fixmul16(gain2, gain_inc);
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
gain2 = fixmul16(gain2, gain_inc);
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
gain2 = fixmul16(gain2, gain_inc);
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
gain2 = fixmul16(gain2, gain_inc);
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
gain2 = fixmul16(gain2, gain_inc);
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
gain2 = fixmul16(gain2, gain_inc);
pOut[i] = fixmul16((fixmul16(pIn[i], gain1) + pPrev[i]), gain2); i++;
gain2 = fixmul16(gain2, gain_inc);
return i;
}
/** /**
* Apply gain parameters and perform the MDCT overlapping part * Apply gain parameters and perform the MDCT overlapping part
* *
* @param pIn input float buffer * @param pIn input buffer
* @param pPrev previous float buffer to perform overlap against * @param pPrev previous buffer to perform overlap against
* @param pOut output float buffer * @param pOut output buffer
* @param pGain1 current band gain info * @param pGain1 current band gain info
* @param pGain2 next band gain info * @param pGain2 next band gain info
*/ */
static void gainCompensateAndOverlap (int32_t *pIn, int32_t *pPrev, int32_t *pOut, gain_info *pGain1, gain_info *pGain2) static void gainCompensateAndOverlap (int32_t *pIn, int32_t *pPrev, int32_t *pOut,
gain_info *pGain1, gain_info *pGain2)
{ {
/* gain compensation function */ /* gain compensation function */
int32_t gain1, gain2, gain_inc; int32_t gain1, gain2, gain_inc;
int cnt, numdata, nsample, startLoc, endLoc; int cnt, numdata, nsample, startLoc;
if (pGain2->num_gain_data == 0) if (pGain2->num_gain_data == 0)
gain1 = ONE_16; gain1 = ONE_16;
@ -576,41 +689,35 @@ static void gainCompensateAndOverlap (int32_t *pIn, int32_t *pPrev, int32_t *pOu
gain1 = gain_tab1[pGain2->levcode[0]]; gain1 = gain_tab1[pGain2->levcode[0]];
if (pGain1->num_gain_data == 0) { if (pGain1->num_gain_data == 0) {
for (cnt = 0; cnt < 256; cnt++) /* Remark: This path is called >90%. */
pOut[cnt] = fixmul16(pIn[cnt], gain1) + pPrev[cnt]; /* Apply gain for all samples from 0...255 */
applyFixGain(pIn, pPrev, pOut, 0, gain1);
} else { } else {
/* Remark: This path is called seldom. */
numdata = pGain1->num_gain_data; numdata = pGain1->num_gain_data;
pGain1->loccode[numdata] = 32; pGain1->loccode[numdata] = 32;
pGain1->levcode[numdata] = 4; pGain1->levcode[numdata] = 4;
nsample = 0; // current sample = 0 nsample = 0; /* starting loop with =0 */
for (cnt = 0; cnt < numdata; cnt++) { for (cnt = 0; cnt < numdata; cnt++) {
startLoc = pGain1->loccode[cnt] * 8; startLoc = pGain1->loccode[cnt] * 8;
endLoc = startLoc + 8;
gain2 = gain_tab1[pGain1->levcode[cnt]]; gain2 = gain_tab1[pGain1->levcode[cnt]];
gain_inc = gain_tab2[(pGain1->levcode[cnt+1] - pGain1->levcode[cnt])+15]; gain_inc = gain_tab2[(pGain1->levcode[cnt+1] - pGain1->levcode[cnt])+15];
/* interpolate */ /* Apply variable gain (gain1 -> gain2) to samples */
for (; nsample < startLoc; nsample++) nsample = applyVariableGain(pIn, pPrev, pOut, nsample, startLoc, gain1, gain2, gain_inc);
pOut[nsample] = fixmul16((fixmul16(pIn[nsample], gain1) + pPrev[nsample]), gain2);
/* interpolation is done over eight samples */
for (; nsample < endLoc; nsample++) {
pOut[nsample] = fixmul16((fixmul16(pIn[nsample], gain1) + pPrev[nsample]),gain2);
gain2 = fixmul16(gain2, gain_inc);
}
} }
/* Apply gain for the residual samples from nsample...255 */
for (; nsample < 256; nsample++) applyFixGain(pIn, pPrev, pOut, nsample, gain1);
pOut[nsample] = fixmul16(pIn[nsample], gain1) + pPrev[nsample];
} }
/* Delay for the overlapping part. */ /* Delay for the overlapping part. */
memcpy(pPrev, &pIn[256], 256*sizeof(int32_t)); memcpy(pPrev, &pIn[256], 256*sizeof(int32_t));
} }
/** /**
* Combine the tonal band spectrum and regular band spectrum * Combine the tonal band spectrum and regular band spectrum
* Return position of the last tonal coefficient * Return position of the last tonal coefficient
@ -639,6 +746,7 @@ static int addTonalComponents (int32_t *pSpectrum, int numComponents, tonal_comp
return lastPos; return lastPos;
} }
/** /**
* Linear equidistant interpolation between two points x and y. 7 interpolation * Linear equidistant interpolation between two points x and y. 7 interpolation
* points can be calculated. Result is scaled by <<16. * points can be calculated. Result is scaled by <<16.
@ -712,7 +820,7 @@ static void reverseMatrixing(int32_t *su1, int32_t *su2, int *pPrevCode, int *pC
} }
break; break;
default: default:
//assert(0); /* assert(0) */;
break; break;
} }
} }
@ -755,18 +863,16 @@ static void channelWeighting (int32_t *su1, int32_t *su2, int *p3)
} }
} }
/** /**
* Decode a Sound Unit * Decode a Sound Unit
* *
* @param gb the GetBit context * @param gb the GetBit context
* @param pSnd the channel unit to be used * @param pSnd the channel unit to be used
* @param pOut the decoded samples before IQMF in float representation * @param pOut the decoded samples before IQMF
* @param channelNum channel number * @param channelNum channel number
* @param codingMode the coding mode (JOINT_STEREO or regular stereo/mono) * @param codingMode the coding mode (JOINT_STEREO or regular stereo/mono)
*/ */
static int decodeChannelSoundUnit (GetBitContext *gb, channel_unit *pSnd, int32_t *pOut, int channelNum, int codingMode) static int decodeChannelSoundUnit (GetBitContext *gb, channel_unit *pSnd, int32_t *pOut, int channelNum, int codingMode)
{ {
int band, result=0, numSubbands, lastTonal, numBands; int band, result=0, numSubbands, lastTonal, numBands;
@ -807,8 +913,9 @@ static int decodeChannelSoundUnit (GetBitContext *gb, channel_unit *pSnd, int32_
/* Perform the IMDCT step without overlapping. */ /* Perform the IMDCT step without overlapping. */
if (band <= numBands) { if (band <= numBands) {
IMLT(&(pSnd->spectrum[band*256]), pSnd->IMDCT_buf); IMLT(&(pSnd->spectrum[band*256]), pSnd->IMDCT_buf);
} else } else {
memset(pSnd->IMDCT_buf, 0, 512 * sizeof(int32_t)); memset(pSnd->IMDCT_buf, 0, 512 * sizeof(int32_t));
}
/* gain compensation and overlapping */ /* gain compensation and overlapping */
gainCompensateAndOverlap (pSnd->IMDCT_buf, &(pSnd->prevFrame[band*256]), &(pOut[band*256]), gainCompensateAndOverlap (pSnd->IMDCT_buf, &(pSnd->prevFrame[band*256]), &(pOut[band*256]),
@ -982,12 +1089,12 @@ int atrac3_decode_init(ATRAC3Context *q, RMContext *rmctx)
/* Take care of the codec-specific extradata. */ /* Take care of the codec-specific extradata. */
if (rmctx->extradata_size == 14) { if (rmctx->extradata_size == 14) {
/* Parse the extradata, WAV format */ /* Parse the extradata, WAV format */
DEBUGF("[0-1] %d\n",rm_get_uint16le(&edata_ptr[0])); //Unknown value always 1 DEBUGF("[0-1] %d\n",rm_get_uint16le(&edata_ptr[0])); /* Unknown value always 1 */
q->samples_per_channel = rm_get_uint32le(&edata_ptr[2]); q->samples_per_channel = rm_get_uint32le(&edata_ptr[2]);
q->codingMode = rm_get_uint16le(&edata_ptr[6]); q->codingMode = rm_get_uint16le(&edata_ptr[6]);
DEBUGF("[8-9] %d\n",rm_get_uint16le(&edata_ptr[8])); //Dupe of coding mode DEBUGF("[8-9] %d\n",rm_get_uint16le(&edata_ptr[8])); /* Dupe of coding mode */
q->frame_factor = rm_get_uint16le(&edata_ptr[10]); //Unknown always 1 q->frame_factor = rm_get_uint16le(&edata_ptr[10]); /* Unknown always 1 */
DEBUGF("[12-13] %d\n",rm_get_uint16le(&edata_ptr[12])); //Unknown always 0 DEBUGF("[12-13] %d\n",rm_get_uint16le(&edata_ptr[12])); /* Unknown always 0 */
/* setup */ /* setup */
q->samples_per_frame = 1024 * q->channels; q->samples_per_frame = 1024 * q->channels;