CJPEGDecoderQuantTable::~CJPEGDecoderQuantTable(void)
{
m_initialized = 0;
ippsZero_8u(m_raw,sizeof(m_raw));
ippsZero_8u((Ipp8u*)m_qnt,sizeof(m_qnt));
return;
} // dtor
CJPEGDecoderQuantTable::CJPEGDecoderQuantTable(void)
{
m_id = 0;
m_precision = 0;
m_initialized = 0;
m_raw = (Ipp8u*)OWN_ALIGN_PTR(m_rbf,CPU_CACHE_LINE);
m_qnt = (Ipp16u*)OWN_ALIGN_PTR(m_qbf,CPU_CACHE_LINE); // align for max performance
ippsZero_8u(m_raw,sizeof(m_raw));
ippsZero_8u((Ipp8u*)m_qnt,sizeof(m_qnt));
return;
} // ctor
void PLC_init(G711_PLC_state *PLC)
{
ippsZero_8u((void*)PLC, sizeof(G711_PLC_state));
erasecnt = 0;
pitchbufend = &pitchbuf[HISTORYLEN];
ippsZero_16s(history, HISTORYLEN);
}
static USC_Status VAD_G729FP(USC_Handle handle, USC_PCMStream *in, USC_PCMStream *out, USC_FrameType *pVADDecision)
{
VADmemory *VadObj;
Ipp32s *pVD;
USC_CHECK_PTR(in);
USC_CHECK_PTR(out);
USC_CHECK_PTR(pVADDecision);
USC_CHECK_HANDLE(handle);
USC_BADARG(in->nbytes<G729_SPEECH_FRAME*sizeof(Ipp16s), USC_NoOperation);
USC_BADARG(in->pcmType.bitPerSample!=G729_BITS_PER_SAMPLE, USC_UnsupportedPCMType);
USC_BADARG(in->pcmType.sample_frequency!=G729_SAMPLE_FREQUENCY, USC_UnsupportedPCMType);
USC_BADARG(in->nbytes<G729_SPEECH_FRAME*sizeof(Ipp16s), USC_BadDataPointer);
pVD = (Ipp32s*)pVADDecision;
VadObj = (VADmemory *)((Ipp8s*)handle + sizeof(G729_Handle_Header));
if(G729FPVAD(VadObj,(const Ipp16s*)in->pBuffer,(Ipp16s*)out->pBuffer,pVD) != 0){
return USC_NoOperation;
}
if (*pVD == 0){
*pVADDecision = NODECISION;
ippsZero_8u((Ipp8u*)out->pBuffer, G729_SPEECH_FRAME*sizeof(Ipp16s));
} else if (*pVD == 1){
*pVADDecision = INACTIVE;
ippsZero_8u((Ipp8u*)out->pBuffer, G729_SPEECH_FRAME*sizeof(Ipp16s));
} else if (*pVD == 3) {
ippsCopy_8u((Ipp8u*)in->pBuffer,(Ipp8u*)out->pBuffer, G729_SPEECH_FRAME*sizeof(Ipp16s));
*pVADDecision = ACTIVE;
}
out->bitrate = in->bitrate;
in->nbytes = G729_SPEECH_FRAME*sizeof(Ipp16s);
out->nbytes = G729_SPEECH_FRAME*sizeof(Ipp16s);
return USC_NoError;
}
void Biquad::reset()
{
#if OS(DARWIN)
// Two extra samples for filter history
double* inputP = m_inputBuffer.data();
inputP[0] = 0;
inputP[1] = 0;
double* outputP = m_outputBuffer.data();
outputP[0] = 0;
outputP[1] = 0;
#elif USE(WEBAUDIO_IPP)
int bufferSize;
ippsIIRGetStateSize64f_BiQuad_32f(1, &bufferSize);
ippsZero_8u(m_ippInternalBuffer, bufferSize);
#else
m_x1 = m_x2 = m_y1 = m_y2 = 0;
#endif
}
static int
set_init(
char *nn_dst_val,
void *in_dst_val,
long long lb,
long long ub,
int ijoin_op
)
{
int status = 0;
// Set nn value as default = false
if ( nn_dst_val != NULL ) {
#ifdef ICC
ippsZero_8u(nn_dst_val+lb, (ub-lb));
#else
assign_const_I1(nn_dst_val+lb, (ub-lb), FALSE);
#endif
}
//------------------------------------
long long *dst_val = NULL;
long long *dst_val_I8 = NULL;
char *dst_val_I1 = NULL;
if ( in_dst_val != NULL ) {
dst_val = (long long *)in_dst_val; dst_val += lb;
switch ( ijoin_op ) {
case join_exists :
dst_val_I1 = (char *)in_dst_val; dst_val += lb;
assign_const_I1(dst_val_I1, (ub-lb), 0);
break;
case join_minidx :
case join_maxidx :
dst_val_I8 = (long long *)in_dst_val; dst_val += lb;
assign_const_I8(dst_val_I8, (ub-lb), -1);
break;
case join_sum :
case join_cnt :
dst_val_I8 = (long long *)in_dst_val; dst_val += lb;
assign_const_I8(dst_val_I8, (ub-lb), 0);
break;
case join_reg :
case join_or :
assign_const_I8(dst_val, (ub-lb), 0);
break;
case join_and :
assign_const_I8(dst_val, (ub-lb), 0xFFFFFFFFFFFFFFFF);
break;
/*---------------------------------------------------------*/
case join_min :
assign_const_I8(dst_val, (ub-lb), LLONG_MAX);
break;
/*---------------------------------------------------------*/
case join_max :
assign_const_I8(dst_val, (ub-lb), LLONG_MIN);
break;
/*---------------------------------------------------------*/
default :
go_BYE(-1);
break;
}
}
BYE:
return status ;
}
Ipp32s sbrEnvNoiseDec(sSBRDecComState * pSbr, Ipp32s ch) // optimization is needed!!!
{
Ipp16s delta, g_E;
Ipp32s i, l, k, n_r;
Ipp32s g;
Ipp32s flag_switch;
Ipp32s resolution[2];
sSBRFrameInfoState* pFIState = &( pSbr->sbrFIState[ch] );
sSBREnvDataState* pEDState = &(pSbr->sbrEDState[ch]);
Ipp32s nNoiseEnv = pFIState->nNoiseEnv;
Ipp32s nLoBand = pSbr->sbrFreqTabsState.nLoBand;
Ipp32s nHiBand = pSbr->sbrFreqTabsState.nHiBand;
Ipp32s nNoiseBand = pSbr->sbrFreqTabsState.nNoiseBand;
Ipp32s* pos = pEDState->vSizeEnv;
Ipp32s* posN = pEDState->vSizeNoise;
Ipp16s* vEnv = pEDState->bufEnvQuant;
Ipp16s* vNoise = pEDState->bufNoiseQuant;
Ipp32s* freqRes = pFIState->freqRes;
Ipp32s* pTable1 = pSbr->sbrFreqTabsState.fHiBandTab;
Ipp32s* pTable0 = pSbr->sbrFreqTabsState.fLoBandTab;
/* check */
if( pFIState->nEnv > MAX_NUM_ENV)
return SBR_ERR_REQUIREMENTS;
resolution[0] = nLoBand;
resolution[1] = nHiBand;
delta = ((ch == 1) && (pSbr->bs_coupling == 1)) ? 2 : 1;
/*
* calculate for l == 0
*/
n_r = resolution[freqRes[0]];
g = pFIState->freqResPrev[pFIState->nEnvPrev - 1];
flag_switch = pEDState->bs_df_env[0] * (freqRes[0] - g + 2);
switch (flag_switch) {
case 0: // bs_df_env[0] = 0
vEnv[0] = delta*vEnv[0];
for (k = 1; k < n_r; k++) {
vEnv[k] =vEnv[k-1] +vEnv[k]*delta;
}
break;
case 2: // bs_df_env[0] = 1 and freqRes(l)=g(l)
for (k = 0; k < n_r; k++) {
g_E = pEDState->bufEnvQuantPrev[k];
vEnv[k] = g_E + delta * (vEnv[k]);
}
break;
case 1: // bs_df_env[0] = 1 and freqRes(l)=0 and g(l)=1
for (k = 0; k < n_r; k++) {
i = LookUpI_parity(pTable1, pTable0, k, nHiBand);
g_E = pEDState->bufEnvQuantPrev[i];
vEnv[k] = g_E + delta * (vEnv[k]);
}
break;
case 3: // bs_df_env[0] = 1 and freqRes(l)=1 and g(l)=0
for (k = 0; k < n_r; k++) {
i = LookUpI_disparity(pTable1, pTable0, k, nLoBand);
g_E = pEDState->bufEnvQuantPrev[i];
vEnv[k] = g_E + delta * (vEnv[k]);
}
}
/*
* END!!! l==0 END!!!
*/
/*
* calcilate for l=1:nEnv
*/
for (l = 1; l < pFIState->nEnv; l++) {
n_r = resolution[freqRes[l]];
g = freqRes[l - 1];
flag_switch = pEDState->bs_df_env[l] * (freqRes[l] - g + 2);
switch (flag_switch) {
case 0: // bs_df_env[l] = 0
vEnv[pos[l]] = delta*vEnv[pos[l]];
for (k = 1; k < n_r; k++) {
vEnv[pos[l]+k] =vEnv[pos[l]+k-1] +vEnv[pos[l]+k] * delta;
}
break;
case 2: // bs_df_env[l] = 1 and r(l)=g(l)
for (k = 0; k < n_r; k++) {
g_E =vEnv[pos[l-1]+k];
vEnv[pos[l]+k] = g_E + delta * (vEnv[pos[l]+k]);
}
break;
case 1: // bs_df_env[l] = 1 and r(l)=0 and g(l)=1
for (k = 0; k < n_r; k++) {
i = LookUpI_parity(pTable1, pTable0, k, nHiBand);
g_E = vEnv[pos[l-1]+i];
vEnv[pos[l]+k] = g_E + delta * (vEnv[pos[l]+k]);
}
break;
case 3: // bs_df_env[l] = 1 and r(l)=1 and g(l)=0
for (k = 0; k < n_r; k++) {
i = LookUpI_disparity(pTable1, pTable0, k, nLoBand);
g_E = vEnv[pos[l-1]+i];
vEnv[pos[l]+k] = g_E + delta * (vEnv[pos[l]+k]);
}
} // end switch
} // end for
/* step(2): noise_dec */
if (pEDState->bs_df_noise[0] == 1) // and l==0
{
for (k = 0; k < nNoiseBand; k++) {
vNoise[posN[0]+k] = pEDState->bufNoiseQuantPrev[k] + delta * (vNoise[pos[0]+k]);
}
} else { // if(pSbr->SbrBSE.bs_df_noise[ch][0] == 0) and l==0
vNoise[posN[0]+0] = delta*vNoise[posN[0]+0];
for (k = 1; k < nNoiseBand; k++) {
vNoise[posN[0]+k] = vNoise[posN[0]+k-1] + delta * vNoise[posN[0]+k];
}
}
// noise
for (l = 1; l < nNoiseEnv; l++) {
if (pEDState->bs_df_noise[l] == 0) {
vNoise[posN[l]] = delta * vNoise[posN[l]];
for (k = 1; k < nNoiseBand; k++) {
vNoise[posN[l]+k] = delta * vNoise[posN[l]+k] + vNoise[posN[l]+k-1];
}
} else {
for (k = 0; k < nNoiseBand; k++) {
vNoise[posN[l]+k] = vNoise[posN[l-1]+k] + delta * (vNoise[posN[l]+k]);
}
}
}
/* -------------------------------- update ---------------------------- */
{
Ipp32s size = sizeof(Ipp16s);
ippsZero_8u((Ipp8u *)pEDState->bufEnvQuantPrev, size * MAX_NUM_ENV_VAL);
ippsZero_8u((Ipp8u *)pEDState->bufNoiseQuantPrev, size * MAX_NUM_ENV_VAL);
ippsZero_8u((Ipp8u *)pFIState->freqResPrev, sizeof(Ipp32s) * MAX_NUM_ENV);
ippsCopy_8u((const Ipp8u*)freqRes, (Ipp8u*)pFIState->freqResPrev, sizeof(Ipp32s) * pFIState->nEnv);
}
l = pFIState->nEnv - 1;
n_r = resolution[freqRes[l]];
for (k = 0; k < n_r; k++) {
pEDState->bufEnvQuantPrev[k] =vEnv[pos[l]+k];
}
l = nNoiseEnv - 1;
for (k = 0; k < nNoiseBand; k++)
pEDState->bufNoiseQuantPrev[k] = vNoise[posN[l]+k];
return 0; // OK
}
