📄 qsidlsf.dsp
字号:
/************************************************************************/
/* $$01/10/2000 checked Quantize sidlsf module data and function */
/* $$01/16/2001 modified and printed,Author: Jason.wang (zhigang wang) */
/* $$01/16/2001 Email: wzg119@yeah.net, BP: 86+02195950-161452 */
/* $$01/16/2001 This modlue is not optimized! should be test on Emulator*/
/************************************************************************/
.MODULE/SEG=App_PM Qsidlsf;
/************************************************************************/
#include "ld8a.inc"
#include "vad.inc"
#include "dtx.inc"
#include "tab_dtx.inc"
#include "tab_ld8a.inc"
/************************************************************************/
.EXTERNAL lspSid_q,analy;
.EXTERNAL Enc_lsfqmem;
.EXTERNAL Lsp_lsf2;
.EXTERNAL Lsf_lsp2;
.EXTERNAL Get_wegt;
.EXTERNAL Lsp_stability;
.EXTERNAL Lsp_expand_1_2;
.EXTERNAL Lsp_prev_update;
.EXTERNAL Lsp_prev_compose;
.EXTERNAL Lsp_prev_extract;
/************************************************************************
* Functions lsfq_noise *
* $$01/10/2000 used only in encoder *
* Calling Parameters *
* I1 : unquantized lsp vector *
* I2 : memory of the lsf predictor *
* Return Values *
* lspSid_q: quantized lsp vector *
* I6 : indices *
* Altered Registers: MR,MF,SR,SE,SI,AR,AF,AX0,AX1,AY0,AY1,MX0 *
* MX1,MY0,MY1 *
* Computation Time : 18 cycles *
*************************************************************************/
.ENTRY lsfq_noise;
.VAR/DM/RAM/SEG=App_DMbuf lsf[M], lsfq[M];
.VAR/DM/RAM/SEG=App_DMbuf tmpbuf[M], weight[M];
.VAR/DM/RAM/SEG=App_DMbuf Clust[MODE],errlsf[M*MODE];
lsfq_noise: //CNTR=M;
I0=^lsf+M-1;
CNTR=M;
CALL Lsp_lsf2;
/*---------spacing to ~100Hz----------*/
I2=^lsf;
AR=DM(I2,M0);
AY0=L_LIMIT;
NONE=AR-AY0;
IF LT AR=PASS AY0;
// CNTR=M-1;
DM(I2,M0)=AR;
AY1=2*GAP3;
CNTR=M-1;
DO cal_lsf UNTIL CE;
AX0=DM(I2,M1);
AY0=DM(I2,M0);
AR=AY0-AX0;
NONE=AR-AY1;
IF GE JUMP cal_lsf;
AR=AX0+AY1;
DM(I2,M0)=AR;
cal_lsf: AY0=M_LIMIT;
AR=DM(I2,M2);
AY1=DM(I2,M1);
NONE=AR-AY0;
IF GT AR=PASS AY0;
DM(I2,M2)=AR;
NONE=AR-AY1;
IF GE JUMP wegt_con;
AY0=GAP3;
AR=AR-AY0;
DM(I2,M0)=AR;
/*--------get the lsf weighting-----------*/
wegt_con: I2=^lsf;
I4=^weight;
CALL Get_wegt;
/*---------quantize the lsf's----------------------*/
/*---------get the prediction error vector---------*/
// CNTR=MODE;
AR=PASS 0;
CNTR=MODE;
DO lspex_loop UNTIL CE;
MY0=MA_NP*M_2;
MR=AR * MY0(SS),AY0=AR;
I6=^noise_fg;
M5=MR0;
MODIFY(I6,M5);
MY0=M_2;
MR=AR * MY0(SS);
I5=^noise_fg_sum_inv;
M3=MR0;
M5=MR0;
I1=^lsf;
I0=^errlsf;
MODIFY(I0,M3);
MODIFY(I5,M5);
AR=^Enc_lsfqmem;
CALL Lsp_prev_extract;
lspex_loop: AR=AY0+1;
/*--------quantize the lsf and get the corresponding indices--*/
CALL Qnt_e;
M3=AR;
I6=DM(analy);
DM(I6,M4)=AR;
AR=DM(Clust);
DM(I6,M4)=AR;
AR=DM(Clust+1);
DM(I6,M4)=AR;
DM(analy)=I6;
/*---------guarantee minimum distance of 0.0012 (~10 in Q13)---*/
/*---------between tmpbuf[j] and tmpbuf[j+1]-------------------*/
AY0=10;
I1=^tmpbuf;
CALL Lsp_expand_1_2;
/*--------compute the quantized lsf vector--------------------*/
MX0=M3;
MR= MX0 * MY0(SS);
M5=MR0;
I4=^noise_fg_sum;
MODIFY(I4,M5);
MY0=MA_NP*M_2;
MR=MX0 * MY0(SS);
M5=MR0;
I0=^lsfq;
I1=^tmpbuf;
I5=^noise_fg;
MODIFY(I5,M5);
AR=^Enc_lsfqmem;
CALL Lsp_prev_compose;
/*--------update the prediction memory-----------*/
I1=^tmpbuf;
I0=^Enc_lsfqmem;
CALL Lsp_prev_update;
/*---------lsf stability check-----------*/
I0=^lsfq;
CALL Lsp_stability;
/*---------convert lsf to lsp-------------*/
// CNTR=M;
I1=^lsfq;
I0=^lspSid_q;
CNTR=M;
CALL Lsf_lsp2;
RTS;
/************************************************************************
* Qnt_e---quantized energy *
* $$01/10/2000 used only in encoder *
* *errlsf, : error lsf vector *
* *weight, : weighting vector *
* *tmpbuf, : quantized error lsf vector *
* *Clust, : quantizer indices *
* *MS : size of the quantizers *
* AR : predictor index *
*************************************************************************/
Qnt_e: AR=H#7FFF;
CALL New_ML_search_1;
AR=H#7FFF;
CALL New_ML_search_2;
/*--------backward path for the indices-------------*/
AR=DM(best_index1);
DM(Clust+1)=AR;
I3=^best_index0;
M3=DM(ptr_back1);
MODIFY(I3,M3);
AR=DM(I3,M1);
DM(Clust)=AR;
/*---------generating the quantized vector------------*/
M5=DM(Clust);
I5=^PtrTab_1;
MODIFY(I5,M5);
MX0=PM(I5,M5);
MY0=M_2;
MR=MX0 * MY0(SS);
M5=MR0;
// CNTR=M;
I5=^lspcb1;
I1=^tmpbuf;
MODIFY(I5,M5);
CNTR=M;
DO copy_cluster UNTIL CE;
AR=PM(I5,M4);
copy_cluster: DM(I1,M1)=AR;
nop;
I1=^tmpbuf;
// CNTR=M_2;
M5=DM(Clust+1);
I5=^PtrTab_2;
MODIFY(I5,M5);
MX0=PM(I5,M5);
MR=MX0 * MY0(SS);
M5=MR0;
I5=^lspcb2;
MODIFY(I5,M5);
CNTR=M_2;
DO add_qnte1 UNTIL CE;
AX0=DM(I1,M0),AY0=PM(I5,M4);
AR=AX0+AY0;
add_qnte1: DM(I1,M1)=AR;
nop;
M5=DM(Clust+1);
// CNTR=M_2;
I5=^PtrTab_2+16;
MODIFY(I5,M5);
MX0=PM(I5,M5);
MR=MX0 * MY0(SS);
M5=MR0;
I5=^lspcb2+M_2;
MODIFY(I5,M5);
CNTR=M_2;
DO add_qnte2 UNTIL CE;
AX0=DM(I1,M0),AY0=PM(I5,M4);
AR=AX0+AY0;
add_qnte2: DM(I1,M1)=AR;
/*---------this is the pointer to the best predictor--*/
I3=^ptr_back0;
MODIFY(I3,M3);
AR=DM(I3,M3);
RTS;
/************************************************************************
* Function New_ML_search_1 *
* $$01/10/2000 used only in encoder *
* $$01/11/2000 move table from dm area to pm area *
* Calling Parameters *
* *d_data : error vector (errlsf) *
* *PtrTab : quantizer table (PtrTab_1) *
* J = MODE : number of input vectors *
* K = 4 : number of candidates *
* MQ = 32 : size of quantizer *
* Return Values *
* *new_d_data : output vector (d_data0) *
* *best_index : best indices (best_index0) *
* *ptr_back : pointer for backtracking (ptr_back0) *
* Altered Registers: MR,MF,SR,SE,SI,AR,AF,AX0,AX1,AY0,AY1,MX0 *
* MX1,MY0,MY1 *
* Computation Time : 18 cycles *
*************************************************************************/
.VAR/DM/RAM/SEG=App_DMbuf min[R_LSFQ];
.VAR/DM/RAM/SEG=App_DMbuf d_data0[R_LSFQ*M];
.VAR/DM/RAM/SEG=App_DMbuf ptr_back0[R_LSFQ];
.VAR/DM/RAM/SEG=App_DMbuf best_index0[R_LSFQ];
.VAR/DM/RAM/SEG=App_DMbuf sum[R_LSFQ*R_LSFQ];
.VAR/DM/RAM/SEG=App_DMbuf min_index_p[R_LSFQ];
.VAR/DM/RAM/SEG=App_DMbuf min_index_m[R_LSFQ];
cross_mac: //CNTR=32;
I4=^PtrTab_1;
CNTR=32;
DO mac1_countm UNTIL CE;
AR=PM(I4,M4);
MR=AR * MY0(SS);
M5=MR0;
MR=0;
I1=AX1;
// CNTR=M;
I5=^lspcb1;
MODIFY(I5,M5);
CNTR=M;
DO mac1_countl UNTIL CE;
AX0=DM(I1,M1),AY0=PM(I5,M4);
AR=AX0-AY0;
mac1_countl: IF NOT MV MR=MR+AR*AR(SS);
IF MV SAT MR;
MR=MR1 * MY1(SS);
mac1_countm: DM(I0,M1)=MR1;
RTS;
New_ML_search_1: //CNTR=4;
I0=^min;
CNTR=4;
DO set_minq1 UNTIL CE;
set_minq1: DM(I0,M1)=AR;
/*-----------compute the errors----------------*/
I0=^sum;
MY0=M_2;
MY1=8644;
AX1=^errlsf;
CALL cross_mac;
AX1=^errlsf+M;
MY1=16572;
CALL cross_mac;
/*----------select the candidates-------------*/
// CNTR=4;
MY0=16;
I0=^min;
MX1=H#7FFF;
I1=^min_index_p;
I2=^min_index_m;
CNTR=4;
DO find1_countq UNTIL CE;
I3=^sum;
// CNTR=MODE;
AF=PASS 0,AY0=DM(I0,M0);
CNTR=MODE;
DO find1_countp UNTIL CE;
// CNTR=32;
AR=PASS 0;
CNTR=32;
DO find1_countm UNTIL CE;
AX0=DM(I3,M1);
AR=AX0-AY0,AY1=AR;
IF GE JUMP find1_countm;
AR=PASS AF,DM(I0,M0)=AX0;
DM(I1,M0)=AR;
DM(I2,M0)=AY1;
find1_countm: AR=AY1+1,AY0=DM(I0,M0);
find1_countp: AF=AF+1,MX0=DM(I1,M0);
I4=^sum;
MODIFY(I0,M1);
MR=MX0 * MY0(SS),AY0=DM(I2,M1);
AR=MR0+AY0,MX0=DM(I1,M1);
M5=AR;
MODIFY(I4,M5);
find1_countq: DM(I4,M4)=MX1;
nop;
{---------compute the candidates--------------}
MY0=M_2;
// CNTR=4;
I6=^d_data0;
I0=^ptr_back0;
I1=^min_index_p;
I2=^min_index_m;
I3=^best_index0;
CNTR=4;
DO best1_idx2 UNTIL CE;
CNTR=M;
I4=^errlsf;
MX0=DM(I1,M1);
MR=MX0 * MY0(SS),DM(I0,M1)=MX0;
M5=MR0;
MODIFY(I4,M5);
I5=^PtrTab_1;
AX1=DM(I2,M1);
M5=AX1;
MODIFY(I5,M5);
AR=PM(I5,M5);
I5=^lspcb1;
MR=AR * MY0(SS);
M5=MR0;
MODIFY(I5,M5);
DO best1_idx1 UNTIL CE;
AX0=DM(I4,M4);
AY0=PM(I5,M4);
AR=AX0-AY0;
best1_idx1: DM(I6,M4)=AR;
best1_idx2: DM(I3,M1)=AX1;
RTS;
/************************************************************************
* Function New_ML_search_2 *
* $$01/10/2000 used only in encoder *
* $$01/11/2000 move table from dm area to pm area *
* Calling Parameters *
* d_data, : error vector (d_data0) *
* *weight, : weighting vector (weight) *
* J = 4 : number of input vectors *
* K = 1 : number of candidates *
* *ptr_prd, : pointer for backtracking (ptr_back0) *
* PtrTab[2][16]: quantizer table (PtrTab_2) *
* MQ = 16 : size of quantizer *
* Return Values *
* *best_index, : best indices (best_index1) *
* *new_d_data, : output vector (d_data1) *
* *ptr_back, : pointer for backtracking (ptr_back1) *
* Altered Registers: MR,MF,SR,SE,SI,AR,AF,AX0,AX1,AY0,AY1,MX0 *
* MX1,MY0,MY1 *
* Computation Time : 18 cycles *
*************************************************************************/
.VAR/DM/RAM/SEG=App_DMbuf d_data1[R_LSFQ*M];
.VAR/DM/RAM/SEG=App_DMbuf best_index1[R_LSFQ];
.VAR/DM/RAM/SEG=App_DMbuf ptr_back1[R_LSFQ];
cross_half: AR=PASS MR0,MX0=PM(I4,M4);
// CNTR=M_2;
MR=MX0 * MY0(SS),AY0=MR1;
M5=MR0;
MR0=AR;
MR1=AY0;
I4=^lspcb2;
MODIFY(I4,M5);
MODIFY(I4,M6);
CNTR=M_2;
DO top_count UNTIL CE;
AX0=DM(I1,M1),AY0=PM(I4,M4);
MX0=PM(I5,M4);
MY0=DM(I0,M1);
AR=AX0-AY0,MX1=MR0;
AF=AF+1,MY1=MR1;
MR=MX0 * MX0(SS);
SR=LSHIFT MR0 BY 2(LO);
SR=SR OR ASHIFT MR1 BY 2(HI);
MF=SR1 * MY0(SS);
MR=AR * MF(SS),MY0=AR;
SR=LSHIFT MR0 BY 3(LO);
SR=SR OR ASHIFT MR1 BY 3(HI);
MR0=MX1;
MR1=MY1;
MR=MR+SR1 * MY0(SS);
top_count: IF MV SAT MR;
RTS;
New_ML_search_2: DM(min)=AR;
{-----------compute the errors----------------}
// CNTR=4;
I6=^sum;
AX1=^d_data0;
I2=^ptr_back0;
CNTR=4;
DO mac2_countp UNTIL CE;
// CNTR=16;
AY1=^PtrTab_2;
CNTR=16;
DO mac2_countm UNTIL CE;
I1=AX1;
I0=^weight;
I5=^noise_fg_sum;
MX0=DM(I2,M0);
MY0=M_2;
MR=MX0 * MY0(SS);
M5=MR0;
MODIFY(I5,M5);
M6=0;
I4=AY1;
MR=0;
CALL cross_half;
MY0=M_2;
M5=16;
I4=AY1;
MODIFY(I4,M5);
M6=M_2;
CALL cross_half;
AR=AY1+1,DM(I6,M4)=MR1;
mac2_countm: AY1=AR;
AX1=I1;
mac2_countp: MODIFY(I2,M1);
{----------select the candidates-------------}
I2=^sum;
// CNTR=4;
AR=PASS 0;
CNTR=4;
DO find2_countp UNTIL CE;
// CNTR=16;
AR=PASS 0,AX1=AR;
CNTR=16;
DO find2_countm UNTIL CE;
AY0=DM(min);
AX0=DM(I2,M1);
AR=AX0-AY0,AY1=AR;
IF GE JUMP find2_countm;
DM(min)=AX0;
DM(min_index_p)=AX1;
DM(min_index_m)=AY1;
find2_countm: AR=AY1+1;
find2_countp: AR=AX1+1;
MY0=8;
MX0=DM(min_index_p);
DM(ptr_back1)=MX0;
MR=MX0 * MY0(SS);
AY0=DM(min_index_m);
DM(best_index1)=AY0;
AR=MR0+AY0;
M3=AR;
I3=^sum;
MODIFY(I3,M3);
AR=H#7FFF;
DM(I3,M3)=AR;
{---------compute the candidates--------------}
MY0=M_2;
I0=^d_data1;
MR=MX0 * MY0(SS);
M3=MR0;
I3=^d_data0;
MODIFY(I3,M3);
M5=AY0;
I4=^PtrTab_2;
MODIFY(I4,M5);
MX0=PM(I4,M4);
MY0=M_2;
MR=MX0 * MY0(SS);
M5=MR0;
// CNTR=M_2;
I4=^lspcb2;
MODIFY(I4,M5);
CNTR=M_2;
DO best2_idx2 UNTIL CE;
AX0=DM(I3,M1),AY0=PM(I4,M4);
AR=AX0-AY0;
best2_idx2: DM(I0,M1)=AR;
I4=^PtrTab_2+16;
M5=DM(min_index_m);
MODIFY(I4,M5);
MX0=PM(I4,M4);
MR=MX0 * MY0(SS);
M5=MR0;
// CNTR=M_2;
I4=^lspcb2+M_2;
MODIFY(I4,M5);
CNTR=M_2;
DO best2_idx3 UNTIL CE;
AX0=DM(I3,M1),AY0=PM(I4,M4);
AR=AX0-AY0;
best2_idx3: DM(I0,M1)=AR;
RTS;
/**************************************************************************/
.ENDMOD;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -