| /* |
| ** Copyright 2003-2010, VisualOn, Inc. |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| /*********************************************************************** |
| * File: apisf_2s.c * |
| * * |
| * Description: Coding/Decodeing of ISF parameters with predication |
| * The ISF vector is quantized using two-stage VQ with split-by-2 * |
| * in 1st stage and split-by-5(or 3) in the second stage * |
| * * |
| ************************************************************************/ |
| |
| #include "typedef.h" |
| #include "basic_op.h" |
| #include "cnst.h" |
| #include "acelp.h" |
| #include "qpisf_2s.tab" /* Codebooks of isfs */ |
| |
| #define MU 10923 /* Prediction factor (1.0/3.0) in Q15 */ |
| #define N_SURV_MAX 4 /* 4 survivors max */ |
| #define ALPHA 29491 /* 0. 9 in Q15 */ |
| #define ONE_ALPHA (32768-ALPHA) /* (1.0 - ALPHA) in Q15 */ |
| |
| /* private functions */ |
| static void VQ_stage1( |
| Word16 * x, /* input : ISF residual vector */ |
| Word16 * dico, /* input : quantization codebook */ |
| Word16 dim, /* input : dimention of vector */ |
| Word16 dico_size, /* input : size of quantization codebook */ |
| Word16 * index, /* output: indices of survivors */ |
| Word16 surv /* input : number of survivor */ |
| ); |
| |
| /************************************************************************** |
| * Function: Qpisf_2s_46B() * |
| * * |
| * Description: Quantization of isf parameters with prediction. (46 bits) * |
| * * |
| * The isf vector is quantized using two-stage VQ with split-by-2 in * |
| * 1st stage and split-by-5 in the second stage. * |
| ***************************************************************************/ |
| |
| void Qpisf_2s_46b( |
| Word16 * isf1, /* (i) Q15 : ISF in the frequency domain (0..0.5) */ |
| Word16 * isf_q, /* (o) Q15 : quantized ISF (0..0.5) */ |
| Word16 * past_isfq, /* (io)Q15 : past ISF quantizer */ |
| Word16 * indice, /* (o) : quantization indices */ |
| Word16 nb_surv /* (i) : number of survivor (1, 2, 3 or 4) */ |
| ) |
| { |
| Word16 tmp_ind[5]; |
| Word16 surv1[N_SURV_MAX]; /* indices of survivors from 1st stage */ |
| Word32 i, k, temp, min_err, distance; |
| Word16 isf[ORDER]; |
| Word16 isf_stage2[ORDER]; |
| |
| for (i = 0; i < ORDER; i++) |
| { |
| isf[i] = vo_sub(isf1[i], mean_isf[i]); |
| isf[i] = vo_sub(isf[i], vo_mult(MU, past_isfq[i])); |
| } |
| |
| VQ_stage1(&isf[0], dico1_isf, 9, SIZE_BK1, surv1, nb_surv); |
| |
| distance = MAX_32; |
| |
| for (k = 0; k < nb_surv; k++) |
| { |
| for (i = 0; i < 9; i++) |
| { |
| isf_stage2[i] = vo_sub(isf[i], dico1_isf[i + surv1[k] * 9]); |
| } |
| tmp_ind[0] = Sub_VQ(&isf_stage2[0], dico21_isf, 3, SIZE_BK21, &min_err); |
| temp = min_err; |
| tmp_ind[1] = Sub_VQ(&isf_stage2[3], dico22_isf, 3, SIZE_BK22, &min_err); |
| temp = vo_L_add(temp, min_err); |
| tmp_ind[2] = Sub_VQ(&isf_stage2[6], dico23_isf, 3, SIZE_BK23, &min_err); |
| temp = vo_L_add(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(&isf[9], dico2_isf, 7, SIZE_BK2, surv1, nb_surv); |
| |
| distance = MAX_32; |
| |
| for (k = 0; k < nb_surv; k++) |
| { |
| for (i = 0; i < 7; i++) |
| { |
| isf_stage2[i] = vo_sub(isf[9 + i], dico2_isf[i + surv1[k] * 7]); |
| } |
| |
| tmp_ind[0] = Sub_VQ(&isf_stage2[0], dico24_isf, 3, SIZE_BK24, &min_err); |
| temp = min_err; |
| tmp_ind[1] = Sub_VQ(&isf_stage2[3], dico25_isf, 4, SIZE_BK25, &min_err); |
| temp = vo_L_add(temp, min_err); |
| |
| if(temp < distance) |
| { |
| distance = temp; |
| indice[1] = surv1[k]; |
| for (i = 0; i < 2; i++) |
| { |
| indice[i + 5] = tmp_ind[i]; |
| } |
| } |
| } |
| |
| Dpisf_2s_46b(indice, isf_q, past_isfq, isf_q, isf_q, 0, 0); |
| |
| return; |
| } |
| |
| /***************************************************************************** |
| * Function: Qpisf_2s_36B() * |
| * * |
| * Description: Quantization of isf parameters with prediction. (36 bits) * |
| * * |
| * The isf vector is quantized using two-stage VQ with split-by-2 in * |
| * 1st stage and split-by-3 in the second stage. * |
| ******************************************************************************/ |
| |
| void Qpisf_2s_36b( |
| Word16 * isf1, /* (i) Q15 : ISF in the frequency domain (0..0.5) */ |
| Word16 * isf_q, /* (o) Q15 : quantized ISF (0..0.5) */ |
| Word16 * past_isfq, /* (io)Q15 : past ISF quantizer */ |
| Word16 * indice, /* (o) : quantization indices */ |
| Word16 nb_surv /* (i) : number of survivor (1, 2, 3 or 4) */ |
| ) |
| { |
| Word16 i, k, tmp_ind[5]; |
| Word16 surv1[N_SURV_MAX]; /* indices of survivors from 1st stage */ |
| Word32 temp, min_err, distance; |
| Word16 isf[ORDER]; |
| Word16 isf_stage2[ORDER]; |
| |
| for (i = 0; i < ORDER; i++) |
| { |
| isf[i] = vo_sub(isf1[i], mean_isf[i]); |
| isf[i] = vo_sub(isf[i], vo_mult(MU, past_isfq[i])); |
| } |
| |
| VQ_stage1(&isf[0], dico1_isf, 9, SIZE_BK1, surv1, nb_surv); |
| |
| distance = MAX_32; |
| |
| for (k = 0; k < nb_surv; k++) |
| { |
| for (i = 0; i < 9; i++) |
| { |
| isf_stage2[i] = vo_sub(isf[i], dico1_isf[i + surv1[k] * 9]); |
| } |
| |
| tmp_ind[0] = Sub_VQ(&isf_stage2[0], dico21_isf_36b, 5, SIZE_BK21_36b, &min_err); |
| temp = min_err; |
| tmp_ind[1] = Sub_VQ(&isf_stage2[5], dico22_isf_36b, 4, SIZE_BK22_36b, &min_err); |
| temp = vo_L_add(temp, min_err); |
| |
| if(temp < distance) |
| { |
| distance = temp; |
| indice[0] = surv1[k]; |
| for (i = 0; i < 2; i++) |
| { |
| indice[i + 2] = tmp_ind[i]; |
| } |
| } |
| } |
| |
| VQ_stage1(&isf[9], dico2_isf, 7, SIZE_BK2, surv1, nb_surv); |
| distance = MAX_32; |
| |
| for (k = 0; k < nb_surv; k++) |
| { |
| for (i = 0; i < 7; i++) |
| { |
| isf_stage2[i] = vo_sub(isf[9 + i], dico2_isf[i + surv1[k] * 7]); |
| } |
| |
| tmp_ind[0] = Sub_VQ(&isf_stage2[0], dico23_isf_36b, 7, SIZE_BK23_36b, &min_err); |
| temp = min_err; |
| |
| if(temp < distance) |
| { |
| distance = temp; |
| indice[1] = surv1[k]; |
| indice[4] = tmp_ind[0]; |
| } |
| } |
| |
| Dpisf_2s_36b(indice, isf_q, past_isfq, isf_q, isf_q, 0, 0); |
| |
| return; |
| } |
| |
| /********************************************************************* |
| * Function: Dpisf_2s_46b() * |
| * * |
| * Description: Decoding of ISF parameters * |
| **********************************************************************/ |
| |
| void Dpisf_2s_46b( |
| Word16 * indice, /* input: quantization indices */ |
| Word16 * isf_q, /* output: quantized ISF in frequency domain (0..0.5) */ |
| Word16 * past_isfq, /* i/0 : past ISF quantizer */ |
| Word16 * isfold, /* input : past quantized ISF */ |
| Word16 * isf_buf, /* input : isf buffer */ |
| Word16 bfi, /* input : Bad frame indicator */ |
| Word16 enc_dec |
| ) |
| { |
| Word16 ref_isf[M], tmp; |
| Word32 i, j, L_tmp; |
| |
| 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]; |
| } |
| |
| for (i = 0; i < 3; i++) |
| { |
| isf_q[i] = add1(isf_q[i], dico21_isf[indice[2] * 3 + i]); |
| isf_q[i + 3] = add1(isf_q[i + 3], dico22_isf[indice[3] * 3 + i]); |
| isf_q[i + 6] = add1(isf_q[i + 6], dico23_isf[indice[4] * 3 + i]); |
| isf_q[i + 9] = add1(isf_q[i + 9], dico24_isf[indice[5] * 3 + i]); |
| } |
| |
| for (i = 0; i < 4; i++) |
| { |
| isf_q[i + 12] = add1(isf_q[i + 12], dico25_isf[indice[6] * 4 + i]); |
| } |
| |
| for (i = 0; i < ORDER; i++) |
| { |
| tmp = isf_q[i]; |
| isf_q[i] = add1(tmp, mean_isf[i]); |
| isf_q[i] = add1(isf_q[i], vo_mult(MU, past_isfq[i])); |
| past_isfq[i] = tmp; |
| } |
| |
| if (enc_dec) |
| { |
| for (i = 0; i < M; i++) |
| { |
| for (j = (L_MEANBUF - 1); j > 0; j--) |
| { |
| isf_buf[j * M + i] = isf_buf[(j - 1) * M + i]; |
| } |
| isf_buf[i] = isf_q[i]; |
| } |
| } |
| } else |
| { /* bad frame */ |
| for (i = 0; i < M; i++) |
| { |
| L_tmp = mean_isf[i] << 14; |
| for (j = 0; j < L_MEANBUF; j++) |
| { |
| L_tmp += (isf_buf[j * M + i] << 14); |
| } |
| ref_isf[i] = vo_round(L_tmp); |
| } |
| |
| /* use the past ISFs slightly shifted towards their mean */ |
| for (i = 0; i < ORDER; i++) |
| { |
| isf_q[i] = add1(vo_mult(ALPHA, isfold[i]), vo_mult(ONE_ALPHA, ref_isf[i])); |
| } |
| |
| /* estimate past quantized residual to be used in next frame */ |
| for (i = 0; i < ORDER; i++) |
| { |
| tmp = add1(ref_isf[i], vo_mult(past_isfq[i], MU)); /* predicted ISF */ |
| past_isfq[i] = vo_sub(isf_q[i], tmp); |
| past_isfq[i] = (past_isfq[i] >> 1); /* past_isfq[i] *= 0.5 */ |
| } |
| } |
| |
| Reorder_isf(isf_q, ISF_GAP, ORDER); |
| return; |
| } |
| |
| /********************************************************************* |
| * Function: Disf_2s_36b() * |
| * * |
| * Description: Decoding of ISF parameters * |
| *********************************************************************/ |
| |
| void Dpisf_2s_36b( |
| Word16 * indice, /* input: quantization indices */ |
| Word16 * isf_q, /* output: quantized ISF in frequency domain (0..0.5) */ |
| Word16 * past_isfq, /* i/0 : past ISF quantizer */ |
| Word16 * isfold, /* input : past quantized ISF */ |
| Word16 * isf_buf, /* input : isf buffer */ |
| Word16 bfi, /* input : Bad frame indicator */ |
| Word16 enc_dec |
| ) |
| { |
| Word16 ref_isf[M], tmp; |
| Word32 i, j, L_tmp; |
| |
| 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]; |
| } |
| |
| for (i = 0; i < 5; i++) |
| { |
| isf_q[i] = add1(isf_q[i], dico21_isf_36b[indice[2] * 5 + i]); |
| } |
| for (i = 0; i < 4; i++) |
| { |
| isf_q[i + 5] = add1(isf_q[i + 5], dico22_isf_36b[indice[3] * 4 + i]); |
| } |
| for (i = 0; i < 7; i++) |
| { |
| isf_q[i + 9] = add1(isf_q[i + 9], dico23_isf_36b[indice[4] * 7 + i]); |
| } |
| |
| for (i = 0; i < ORDER; i++) |
| { |
| tmp = isf_q[i]; |
| isf_q[i] = add1(tmp, mean_isf[i]); |
| isf_q[i] = add1(isf_q[i], vo_mult(MU, past_isfq[i])); |
| past_isfq[i] = tmp; |
| } |
| |
| |
| if (enc_dec) |
| { |
| for (i = 0; i < M; i++) |
| { |
| for (j = (L_MEANBUF - 1); j > 0; j--) |
| { |
| isf_buf[j * M + i] = isf_buf[(j - 1) * M + i]; |
| } |
| isf_buf[i] = isf_q[i]; |
| } |
| } |
| } else |
| { /* bad frame */ |
| for (i = 0; i < M; i++) |
| { |
| L_tmp = (mean_isf[i] << 14); |
| for (j = 0; j < L_MEANBUF; j++) |
| { |
| L_tmp += (isf_buf[j * M + i] << 14); |
| } |
| ref_isf[i] = vo_round(L_tmp); |
| } |
| |
| /* use the past ISFs slightly shifted towards their mean */ |
| for (i = 0; i < ORDER; i++) |
| { |
| isf_q[i] = add1(vo_mult(ALPHA, isfold[i]), vo_mult(ONE_ALPHA, ref_isf[i])); |
| } |
| |
| /* estimate past quantized residual to be used in next frame */ |
| for (i = 0; i < ORDER; i++) |
| { |
| tmp = add1(ref_isf[i], vo_mult(past_isfq[i], MU)); /* predicted ISF */ |
| past_isfq[i] = vo_sub(isf_q[i], tmp); |
| past_isfq[i] = past_isfq[i] >> 1; /* past_isfq[i] *= 0.5 */ |
| } |
| } |
| |
| Reorder_isf(isf_q, ISF_GAP, ORDER); |
| |
| return; |
| } |
| |
| |
| /*************************************************************************** |
| * Function: Reorder_isf() * |
| * * |
| * Description: To make sure that the isfs are properly order and to * |
| * keep a certain minimum distance between consecutive isfs. * |
| *--------------------------------------------------------------------------* |
| * Argument description in/out * |
| * * |
| * isf[] vector of isfs i/o * |
| * min_dist minimum required distance i * |
| * n LPC order i * |
| ****************************************************************************/ |
| |
| void Reorder_isf( |
| Word16 * isf, /* (i/o) Q15: ISF in the frequency domain (0..0.5) */ |
| Word16 min_dist, /* (i) Q15 : minimum distance to keep */ |
| Word16 n /* (i) : number of ISF */ |
| ) |
| { |
| Word32 i; |
| Word16 isf_min; |
| |
| isf_min = min_dist; |
| for (i = 0; i < n - 1; i++) |
| { |
| if(isf[i] < isf_min) |
| { |
| isf[i] = isf_min; |
| } |
| isf_min = (isf[i] + min_dist); |
| } |
| return; |
| } |
| |
| |
| Word16 Sub_VQ( /* output: return quantization index */ |
| Word16 * x, /* input : ISF residual vector */ |
| Word16 * dico, /* input : quantization codebook */ |
| Word16 dim, /* input : dimention of vector */ |
| Word16 dico_size, /* input : size of quantization codebook */ |
| Word32 * distance /* output: error of quantization */ |
| ) |
| { |
| Word16 temp, *p_dico; |
| Word32 i, j, index; |
| Word32 dist_min, dist; |
| |
| dist_min = MAX_32; |
| p_dico = dico; |
| |
| index = 0; |
| for (i = 0; i < dico_size; i++) |
| { |
| dist = 0; |
| |
| for (j = 0; j < dim; j++) |
| { |
| temp = x[j] - (*p_dico++); |
| dist += (temp * temp)<<1; |
| } |
| |
| if(dist < dist_min) |
| { |
| dist_min = dist; |
| index = i; |
| } |
| } |
| |
| *distance = dist_min; |
| |
| /* Reading the selected vector */ |
| p_dico = &dico[index * dim]; |
| for (j = 0; j < dim; j++) |
| { |
| x[j] = *p_dico++; |
| } |
| |
| return index; |
| } |
| |
| |
| static void VQ_stage1( |
| Word16 * x, /* input : ISF residual vector */ |
| Word16 * dico, /* input : quantization codebook */ |
| Word16 dim, /* input : dimention of vector */ |
| Word16 dico_size, /* input : size of quantization codebook */ |
| Word16 * index, /* output: indices of survivors */ |
| Word16 surv /* input : number of survivor */ |
| ) |
| { |
| Word16 temp, *p_dico; |
| Word32 i, j, k, l; |
| Word32 dist_min[N_SURV_MAX], dist; |
| |
| dist_min[0] = MAX_32; |
| dist_min[1] = MAX_32; |
| dist_min[2] = MAX_32; |
| dist_min[3] = MAX_32; |
| index[0] = 0; |
| index[1] = 1; |
| index[2] = 2; |
| index[3] = 3; |
| |
| p_dico = dico; |
| |
| for (i = 0; i < dico_size; i++) |
| { |
| dist = 0; |
| for (j = 0; j < dim; j++) |
| { |
| temp = x[j] - (*p_dico++); |
| dist += (temp * temp)<<1; |
| } |
| |
| 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; |
| } |
| |
| |
| |
| |
