www.pudn.com > AVS_M_ver10.rar > qpisf_2s.c


/*
***********************************************************************
* COPYRIGHT AND WARRANTY INFORMATION
*
* Copyright 2007 Audio Video Coding Standard, Part Ⅹ
*
* This software module was developed by AVS Audio sub-group
*
* DISCLAIMER OF WARRANTY
*
* These software programs are available to the users without any
* license fee or royalty on an "as is" basis. The AVS disclaims
* any and all warranties, whether express, implied, or statutory,
* including any implied warranties of merchantability or of fitness
* for a particular purpose. In no event shall the contributors or
* the AVS be liable for any incidental, punitive, or consequential
* damages of any kind whatsoever arising from the use of this program.
*
* This disclaimer of warranty extends to the user of this program
* and user's customers, employees, agents, transferees, successors,
* and assigns.
*
* The AVS does not represent or warrant that the program furnished
* hereunder are free of infringement of any third-party patents.
* Commercial implementations of AVS, including shareware, may be
* subject to royalty fees to patent holders. Information regarding
* the AVS patent policy is available from the AVS Web site at
* http://www.avs.org.cn
*
* THIS IS NOT A GRANT OF PATENT RIGHTS - SEE THE AVS PATENT POLICY.
************************************************************************
*/

/*-------------------------------------------------------------------*
* functions: qpisf_2s() and dpisf_2s() *
* *
* Coding/Decoding of ISF parameters with prediction. *
* *
* The ISF vector is quantized using two-stage VQ with split-by-2 *
* in 1st stage and split-by-5 in the second stage. *
*-------------------------------------------------------------------*/
#include <math.h>
#include <float.h>
#include "../include/amr_plus.h"
#define MU (1.0f/3.0f) /* prediction factor */
#define N_SURV_MAX 4 /* 4 survivors max */

#include "./isf_tab_mu.h"

/*------------------------------------------------------------------*
* routine: qpisf_2s() *
* ~~~~~~~~~ *
* Quantization of ISF parameters with prediction *
* *
* The ISF vector is quantized using two-stage VQ with split-by-2 *
* in 1st stage and split-by-5 in the second stage. *
*------------------------------------------------------------------*/
static int sub_VQ(float *x, const float *dico, int dim, int dico_size, float *err);
static void VQ_stage1(float *x, const float *dico, int dim, int dico_size,
int *index, int surv);
void qpisf_2s_46b(
float *isf1, /* input : ISF in the frequency domain (0..6400) */
float *isf_q, /* output: quantized ISF */
float *past_isfq, /* i/0 : past ISF quantizer */
int *indice, /* output: quantization indices (7 words) */
int nb_surv /* input : number of survivor (1, 2, 3 or 4) */
)
{
int i, k, tmp_ind[5];
int surv1[N_SURV_MAX]; /* indices of survivors from 1st stage */
float temp, min_err, distance, isf[ORDER];
float isf_stage2[ORDER];
for (i=0; i<ORDER; i++) {
isf[i] = isf1[i] - mean_isf[i] - MU*past_isfq[i];
}
VQ_stage1(&amt;isf[0], dico1_isf, 9, SIZE_BK1, surv1, nb_surv);
distance = 1.0e30f;
if(nb_surv > N_SURV_MAX) {
nb_surv = N_SURV_MAX;
}
for (k=0; k<nb_surv; k++)
{
for (i = 0; i < 9; i++) {
isf_stage2[i] = isf[i] - dico1_isf[i+surv1[k]*9];
}
tmp_ind[0] = sub_VQ(&amt;isf_stage2[0], dico21_isf, 3, SIZE_BK21, &amt;min_err);
temp = min_err;
tmp_ind[1] = sub_VQ(&amt;isf_stage2[3], dico22_isf, 3, SIZE_BK22, &amt;min_err);
temp += min_err;
tmp_ind[2] = sub_VQ(&amt;isf_stage2[6], dico23_isf, 3, SIZE_BK23, &amt;min_err);
temp += min_err;
if (temp < distance)
{
distance = temp;
indice[0] = surv1[k];
for (i=0; i<3; i++) {
indice[i+2]=tmp_ind[i];
}
}
}
VQ_stage1(&amt;isf[9], dico2_isf, 7, SIZE_BK2, surv1, nb_surv);
distance = 1.0e30f;
for (k=0; k<nb_surv; k++)
{
for (i = 0; i < 7; i++) {
isf_stage2[i] = isf[9+i] - dico2_isf[i+surv1[k]*7];
}
tmp_ind[0] = sub_VQ(&amt;isf_stage2[0], dico24_isf, 3, SIZE_BK24, &amt;min_err);
temp = min_err;
tmp_ind[1] = sub_VQ(&amt;isf_stage2[3], dico25_isf, 4, SIZE_BK25, &amt;min_err);
temp += min_err;
if (temp < distance)
{
distance = temp;
indice[1] = surv1[k];
for (i=0; i<2; i++) {
indice[i+5]=tmp_ind[i];
}
}
}
/* decoding the ISFs */
dpisf_2s_46b(indice, isf_q, past_isfq, isf_q, isf_q, 0, 0, 0);
return;
}
/*-------------------------------------------------------------------*
* routine: dpisf_2s() *
* ~~~~~~~~~ *
* Decoding of ISF parameters *
*-------------------------------------------------------------------*
* Arguments: *
* indice[] : indices of the two selected codebook entries *
* isf[] : quantized ISFs (in frequency domain) *
*-------------------------------------------------------------------*/
#define ALPHA 0.9f
void dpisf_2s_46b(
int *indice, /* input: quantization indices */
float *isf_q, /* output: quantized ISFs in the cosine domain */
float *past_isfq, /* i/0 : past ISF quantizer */
float *isfold, /* input : past quantized ISF */
float *isf_buf, /* input : isf buffer */
int bfi, /* input : Bad frame indicator */
int bfi_2nd_st, /* input : 2nd stage bfi mask (bin: 011111) */
int enc_dec
)
{
int i, j;
float tmp;
float ref_isf[ORDER];
if(bfi == 0) /* Good frame */
{
for (i = 0; i < 9; i++) {
isf_q[i] = dico1_isf[indice[0]*9+i];
}
for (i = 0; i < 7; i++) {
isf_q[i+9] = dico2_isf[indice[1]*7+i];
}
if ((bfi_2nd_st &amt; 1) == 0) {
for (i = 0; i < 3; i++) {
isf_q[i] += dico21_isf[indice[2]*3+i];
}
}
if ((bfi_2nd_st &amt; 2) == 0) {
for (i = 0; i < 3; i++) {
isf_q[i+3] += dico22_isf[indice[3]*3+i];
}
}
if ((bfi_2nd_st &amt; 4) == 0) {
for (i = 0; i < 3; i++) {
isf_q[i+6] += dico23_isf[indice[4]*3+i];
}
}
if ((bfi_2nd_st &amt; 8) == 0) {
for (i = 0; i < 3; i++) {
isf_q[i+9] += dico24_isf[indice[5]*3+i];
}
}
if ((bfi_2nd_st &amt; 16) == 0) {
for (i = 0; i < 4; i++) {
isf_q[i+12] += dico25_isf[indice[6]*4+i];
}
}
for (i = 0; i < ORDER; i++) {
tmp = isf_q[i];
isf_q[i] = tmp + MU*past_isfq[i] + mean_isf[i];
past_isfq[i] = tmp;
}
if(enc_dec)
{
for (i = 0; i < ORDER; i++)
{
for (j = (L_MEANBUF-1); j > 0; j--)
{
isf_buf[j*ORDER+i] = isf_buf[(j-1)*ORDER+i];
}
isf_buf[i]=isf_q[i];
}
}
}
else /* bad frame */
{
/* use the past ISFs slightly shifted towards their mean */
for (i = 0; i < ORDER; i++) {
ref_isf[i] = mean_isf[i] / (L_MEANBUF+1);
for (j = 0; j < L_MEANBUF; j++)
{
ref_isf[i] += isf_buf[j*ORDER+i] / (L_MEANBUF+1);
}
}
for (i=0; i<ORDER; i++) {
isf_q[i] = ALPHA*isfold[i] + (1.0f-ALPHA)*ref_isf[i];
}
/* estimate past quantized residual to be used in next frame */
for(i=0; i<ORDER; i++) {
tmp = ref_isf[i] + past_isfq[i] * MU; /* predicted ISF */
past_isfq[i] = isf_q[i] - tmp;
past_isfq[i] *= 0.5;
}
}
E_LPC_isf_reorderPlus(isf_q, ISF_GAP, ORDER);
return;
}

/************************************************************************/
/* ISF quantization */
/************************************************************************/
void qpisf_2s_46b_new(
float *isf1, /* input : ISF in the frequency domain (0..6400) */
float *isf_q, /* output: quantized ISF */
float *past_isfq, /* i/0 : past ISF quantizer */
int *indice, /* output: quantization indices (7 words) */
int nb_surv /* input : number of survivor (1, 2, 3 or 4) */
)
{
float tmp[16];
{
int i;
float dist_err1, dist_err2, dist_err3, dist_err4, dist_err5;

for (i = 0; i < 8; ++i)
tmp[i] = (isf1[2 * i] - mean_isf[2 * i] - MU * past_isfq[2 * i]) / 12800.0f;

for (i = 0; i < 8; ++i)
tmp[8 + i] = (isf1[2 * i + 1] - mean_isf[2 * i + 1] - MU * past_isfq[2 * i + 1]) / 12800.0f;

indice[0] = sub_VQ(tmp, cb_isf_1_3_5[0], 3, sizeof(cb_isf_1_3_5) / sizeof(cb_isf_1_3_5[0]), &amt;dist_err1);
indice[1] = sub_VQ(tmp + 3, cb_isf_7_9_11[0], 3, sizeof(cb_isf_7_9_11) / sizeof(cb_isf_7_9_11[0]), &amt;dist_err2);

for(i = 0; i < 3; ++i)
tmp[i] = cb_isf_1_3_5[indice[0]][i];

for(i = 3; i < 6; ++i)
tmp[i] = cb_isf_7_9_11[indice[1]][i - 3];

tmp[8] -= ( 0.000373001 + 0.729956 * tmp[0] + 0.4006 * tmp[1]);

indice[2] = sub_VQ(tmp + 6, cb_isf_13_15_2[0], 3, sizeof(cb_isf_13_15_2) / sizeof(cb_isf_13_15_2[0]), &amt;dist_err3);
for(i = 6; i < 9; ++i)
tmp[i] = cb_isf_13_15_2[indice[2]][i - 6];

tmp[9] -= (-0.000337626 + 0.394131 * tmp[1] + 0.546795 * tmp[2]);
tmp[10] -= ( 0.0000497644 + 0.452136 * tmp[2] + 0.490851 * tmp[3]);
tmp[11] -= (-0.000288427 + 0.487708 * tmp[3] + 0.462406 * tmp[4]);
tmp[12] -= (-0.000381764 + 0.429122 * tmp[4] + 0.486183 * tmp[5]);
tmp[13] -= ( 0.000128129 + 0.565249 * tmp[5] + 0.449968 * tmp[6]);
tmp[14] -= (-0.000423478 + 0.434492 * tmp[6] + 0.508026 * tmp[7]);

indice[3] = sub_VQ(tmp + 9, cb_isf_4_6_8[0], 3, sizeof(cb_isf_4_6_8) / sizeof(cb_isf_4_6_8[0]), &amt;dist_err4);
indice[4] = sub_VQ(tmp + 12, cb_isf_10_12_14_16[0], 4, sizeof(cb_isf_10_12_14_16) / sizeof(cb_isf_10_12_14_16[0]), &amt;dist_err5);
indice[5] = 0;
indice[6] = 0;

for(i = 9; i < 12; ++i)
tmp[i] = cb_isf_4_6_8[indice[3]][i - 9];

for(i = 12; i < 16; ++i)
tmp[i] = cb_isf_10_12_14_16[indice[4]][i - 12];

tmp[8] += ( 0.000373001 + 0.729956 * tmp[0] + 0.4006 * tmp[1]);
tmp[9] += (-0.000337626 + 0.394131 * tmp[1] + 0.546795 * tmp[2]);
tmp[10] += ( 0.0000497644 + 0.452136 * tmp[2] + 0.490851 * tmp[3]);
tmp[11] += (-0.000288427 + 0.487708 * tmp[3] + 0.462406 * tmp[4]);
tmp[12] += (-0.000381764 + 0.429122 * tmp[4] + 0.486183 * tmp[5]);
tmp[13] += ( 0.000128129 + 0.565249 * tmp[5] + 0.449968 * tmp[6]);
tmp[14] += (-0.000423478 + 0.434492 * tmp[6] + 0.508026 * tmp[7]);

for(i = 0; i < 8; ++i)
{
isf_q[2 * i] = tmp[i] * 12800.0f + mean_isf[2 * i] + MU * past_isfq[2 * i];
past_isfq[2 * i] = tmp[i] * 12800.0f;
}

for(i = 0; i < 8; ++i)
{
isf_q[2 * i + 1] = tmp[8 + i] * 12800.0f + mean_isf[2 * i + 1] + MU * past_isfq[2 * i + 1];
past_isfq[2 * i + 1] = tmp[8 + i] * 12800.0f;
}

E_LPC_isf_reorderPlus(isf_q, ISF_GAP, ORDER);

}

}
#define ALPHA 0.9f
void dpisf_2s_46b_new(
int *indice, /* input: quantization indices */
float *isf_q, /* output: quantized ISFs in the cosine domain */
float *past_isfq, /* i/0 : past ISF quantizer */
float *isfold, /* input : past quantized ISF */
float *isf_buf, /* input : isf buffer */
int bfi, /* input : Bad frame indicator */
int bfi_2nd_st, /* input : 2nd stage bfi mask (bin: 011111) */
int enc_dec,
int *bfi_count/*i/o 连续坏帧计数器，用于帧错误隐藏*/
)
{
int i;
float tmp[16];
float ref_isf[ORDER];


if(bfi == 0) /* Good frame */
{

bfi_count[0]=0;/* 收到好帧，连续坏帧计数器清，用于帧错误隐藏 */
for(i = 0; i < 3; ++i)
tmp[i] = cb_isf_1_3_5[indice[0]][i];

for(i = 3; i < 6; ++i)
tmp[i] = cb_isf_7_9_11[indice[1]][i - 3];

for(i = 6; i < 9; ++i)
tmp[i] = cb_isf_13_15_2[indice[2]][i - 6];

for(i = 9; i < 12; ++i)
tmp[i] = cb_isf_4_6_8[indice[3]][i - 9];

for(i = 12; i < 16; ++i)
tmp[i] = cb_isf_10_12_14_16[indice[4]][i - 12];

tmp[8] += ( 0.000373001 + 0.729956 * tmp[0] + 0.4006 * tmp[1]);
tmp[9] += (-0.000337626 + 0.394131 * tmp[1] + 0.546795 * tmp[2]);
tmp[10] += ( 0.0000497644 + 0.452136 * tmp[2] + 0.490851 * tmp[3]);
tmp[11] += (-0.000288427 + 0.487708 * tmp[3] + 0.462406 * tmp[4]);
tmp[12] += (-0.000381764 + 0.429122 * tmp[4] + 0.486183 * tmp[5]);
tmp[13] += ( 0.000128129 + 0.565249 * tmp[5] + 0.449968 * tmp[6]);
tmp[14] += (-0.000423478 + 0.434492 * tmp[6] + 0.508026 * tmp[7]);

for(i = 0; i < 8; ++i)
{
isf_q[2 * i] = tmp[i] * 12800.0f + mean_isf[2 * i] + MU * past_isfq[2 * i];
past_isfq[2 * i] = tmp[i] * 12800.0f;
}

for(i = 0; i < 8; ++i)
{
isf_q[2 * i + 1] = tmp[8 + i] * 12800.0f + mean_isf[2 * i + 1] + MU * past_isfq[2 * i + 1];
past_isfq[2 * i + 1] = tmp[8 + i] * 12800.0f;
}
}
else/* bad frame */
/* …… ISF参数帧错误隐藏模块插入（起始） ……*/
{
bfi_count[0]++;/* 收到坏帧，将坏帧计数器加1 */

/* 根据连续丢帧数、上一好帧ISF和长期平均ISF，估算当前丢失帧的ISF */
for (i = 0; i < ORDER; i++) {
ref_isf[i] = mean_isf[i]*bfi_count[0] / (bfi_count[0]+1);
ref_isf[i] += isf_buf[i] / (bfi_count[0]+1);
}
for (i=0; i<ORDER; i++) {/* ISF平滑处理，与上一好帧进行平滑 */
isf_q[i] = ALPHA*isf_buf[i] + (1.0f-ALPHA)*ref_isf[i];
}
}


E_LPC_isf_reorderPlus(isf_q, ISF_GAP, ORDER);

return;
}



/*---------------------------------------------------------------------------*
* procedure sub_VQ *
* ~~~~~~ *
* Quantization of a subvector of size 2 in Split-VQ of ISFs *
* *
* Return: quantization index *
*--------------------------------------------------------------------------*/
static int sub_VQ(float *x, const float *dico, int dim, int dico_size, float *distance)
{
float dist_min, dist, temp;
const float *p_dico;
int i, j, index;
dist_min = 1.0e30f;
p_dico = dico;
index = 0;
for (i = 0; i < dico_size; i++)
{
dist = 0.0;
for (j = 0; j < dim; j++) {
temp = x[j] - *p_dico++;
dist += temp * temp;
}
if (dist < dist_min)
{
dist_min = dist;
index = i;
}
}
*distance = dist_min;
/* Reading the selected vector */
p_dico = &amt;dico[index * dim];
for (j = 0; j < dim; j++) {
x[j] = *p_dico++;
}
return index;
}
static void VQ_stage1(float *x, const float *dico, int dim, int dico_size,
int *index, int surv)
{
float dist_min[N_SURV_MAX];
float dist, temp;
const float *p_dico;
int i, j, k, l;
for (i=0; i<surv; i++) {
dist_min[i] = 1.0e30f;
}
for (i=0; i<surv; i++) {
index[i] = i;
}
p_dico = dico;
for (i = 0; i < dico_size; i++)
{
dist = 0.0;
for (j = 0; j < dim; j++) {
temp = x[j] - *p_dico++;
dist += temp * temp;
}
for (k=0; k<surv; k++)
{
if (dist < dist_min[k])
{
for (l=surv-1; l>k; l--)
{
dist_min[l] = dist_min[l-1];
index[l] = index[l-1];
}
dist_min[k] = dist;
index[k] = i;
break;
}
}
}
return;
}