Line data Source code
1 : /***********************************************************************
2 : Copyright (c) 2006-2011, Skype Limited. All rights reserved.
3 : Redistribution and use in source and binary forms, with or without
4 : modification, are permitted provided that the following conditions
5 : are met:
6 : - Redistributions of source code must retain the above copyright notice,
7 : this list of conditions and the following disclaimer.
8 : - Redistributions in binary form must reproduce the above copyright
9 : notice, this list of conditions and the following disclaimer in the
10 : documentation and/or other materials provided with the distribution.
11 : - Neither the name of Internet Society, IETF or IETF Trust, nor the
12 : names of specific contributors, may be used to endorse or promote
13 : products derived from this software without specific prior written
14 : permission.
15 : THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 : AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 : IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 : ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 : LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 : CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 : SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 : INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 : CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 : ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 : POSSIBILITY OF SUCH DAMAGE.
26 : ***********************************************************************/
27 :
28 : #ifdef HAVE_CONFIG_H
29 : #include "config.h"
30 : #endif
31 :
32 : #include "main_FLP.h"
33 :
34 : /* Wrappers. Calls flp / fix code */
35 :
36 : /* Convert AR filter coefficients to NLSF parameters */
37 0 : void silk_A2NLSF_FLP(
38 : opus_int16 *NLSF_Q15, /* O NLSF vector [ LPC_order ] */
39 : const silk_float *pAR, /* I LPC coefficients [ LPC_order ] */
40 : const opus_int LPC_order /* I LPC order */
41 : )
42 : {
43 : opus_int i;
44 : opus_int32 a_fix_Q16[ MAX_LPC_ORDER ];
45 :
46 0 : for( i = 0; i < LPC_order; i++ ) {
47 0 : a_fix_Q16[ i ] = silk_float2int( pAR[ i ] * 65536.0f );
48 : }
49 :
50 0 : silk_A2NLSF( NLSF_Q15, a_fix_Q16, LPC_order );
51 0 : }
52 :
53 : /* Convert LSF parameters to AR prediction filter coefficients */
54 0 : void silk_NLSF2A_FLP(
55 : silk_float *pAR, /* O LPC coefficients [ LPC_order ] */
56 : const opus_int16 *NLSF_Q15, /* I NLSF vector [ LPC_order ] */
57 : const opus_int LPC_order, /* I LPC order */
58 : int arch /* I Run-time architecture */
59 : )
60 : {
61 : opus_int i;
62 : opus_int16 a_fix_Q12[ MAX_LPC_ORDER ];
63 :
64 0 : silk_NLSF2A( a_fix_Q12, NLSF_Q15, LPC_order, arch );
65 :
66 0 : for( i = 0; i < LPC_order; i++ ) {
67 0 : pAR[ i ] = ( silk_float )a_fix_Q12[ i ] * ( 1.0f / 4096.0f );
68 : }
69 0 : }
70 :
71 : /******************************************/
72 : /* Floating-point NLSF processing wrapper */
73 : /******************************************/
74 0 : void silk_process_NLSFs_FLP(
75 : silk_encoder_state *psEncC, /* I/O Encoder state */
76 : silk_float PredCoef[ 2 ][ MAX_LPC_ORDER ], /* O Prediction coefficients */
77 : opus_int16 NLSF_Q15[ MAX_LPC_ORDER ], /* I/O Normalized LSFs (quant out) (0 - (2^15-1)) */
78 : const opus_int16 prev_NLSF_Q15[ MAX_LPC_ORDER ] /* I Previous Normalized LSFs (0 - (2^15-1)) */
79 : )
80 : {
81 : opus_int i, j;
82 : opus_int16 PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ];
83 :
84 0 : silk_process_NLSFs( psEncC, PredCoef_Q12, NLSF_Q15, prev_NLSF_Q15);
85 :
86 0 : for( j = 0; j < 2; j++ ) {
87 0 : for( i = 0; i < psEncC->predictLPCOrder; i++ ) {
88 0 : PredCoef[ j ][ i ] = ( silk_float )PredCoef_Q12[ j ][ i ] * ( 1.0f / 4096.0f );
89 : }
90 : }
91 0 : }
92 :
93 : /****************************************/
94 : /* Floating-point Silk NSQ wrapper */
95 : /****************************************/
96 0 : void silk_NSQ_wrapper_FLP(
97 : silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
98 : silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
99 : SideInfoIndices *psIndices, /* I/O Quantization indices */
100 : silk_nsq_state *psNSQ, /* I/O Noise Shaping Quantzation state */
101 : opus_int8 pulses[], /* O Quantized pulse signal */
102 : const silk_float x[] /* I Prefiltered input signal */
103 : )
104 : {
105 : opus_int i, j;
106 : opus_int16 x16[ MAX_FRAME_LENGTH ];
107 : opus_int32 Gains_Q16[ MAX_NB_SUBFR ];
108 : silk_DWORD_ALIGN opus_int16 PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ];
109 : opus_int16 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ];
110 : opus_int LTP_scale_Q14;
111 :
112 : /* Noise shaping parameters */
113 : opus_int16 AR_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ];
114 : opus_int32 LF_shp_Q14[ MAX_NB_SUBFR ]; /* Packs two int16 coefficients per int32 value */
115 : opus_int Lambda_Q10;
116 : opus_int Tilt_Q14[ MAX_NB_SUBFR ];
117 : opus_int HarmShapeGain_Q14[ MAX_NB_SUBFR ];
118 :
119 : /* Convert control struct to fix control struct */
120 : /* Noise shape parameters */
121 0 : for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
122 0 : for( j = 0; j < psEnc->sCmn.shapingLPCOrder; j++ ) {
123 0 : AR_Q13[ i * MAX_SHAPE_LPC_ORDER + j ] = silk_float2int( psEncCtrl->AR[ i * MAX_SHAPE_LPC_ORDER + j ] * 8192.0f );
124 : }
125 : }
126 :
127 0 : for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
128 0 : LF_shp_Q14[ i ] = silk_LSHIFT32( silk_float2int( psEncCtrl->LF_AR_shp[ i ] * 16384.0f ), 16 ) |
129 0 : (opus_uint16)silk_float2int( psEncCtrl->LF_MA_shp[ i ] * 16384.0f );
130 0 : Tilt_Q14[ i ] = (opus_int)silk_float2int( psEncCtrl->Tilt[ i ] * 16384.0f );
131 0 : HarmShapeGain_Q14[ i ] = (opus_int)silk_float2int( psEncCtrl->HarmShapeGain[ i ] * 16384.0f );
132 : }
133 0 : Lambda_Q10 = ( opus_int )silk_float2int( psEncCtrl->Lambda * 1024.0f );
134 :
135 : /* prediction and coding parameters */
136 0 : for( i = 0; i < psEnc->sCmn.nb_subfr * LTP_ORDER; i++ ) {
137 0 : LTPCoef_Q14[ i ] = (opus_int16)silk_float2int( psEncCtrl->LTPCoef[ i ] * 16384.0f );
138 : }
139 :
140 0 : for( j = 0; j < 2; j++ ) {
141 0 : for( i = 0; i < psEnc->sCmn.predictLPCOrder; i++ ) {
142 0 : PredCoef_Q12[ j ][ i ] = (opus_int16)silk_float2int( psEncCtrl->PredCoef[ j ][ i ] * 4096.0f );
143 : }
144 : }
145 :
146 0 : for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
147 0 : Gains_Q16[ i ] = silk_float2int( psEncCtrl->Gains[ i ] * 65536.0f );
148 0 : silk_assert( Gains_Q16[ i ] > 0 );
149 : }
150 :
151 0 : if( psIndices->signalType == TYPE_VOICED ) {
152 0 : LTP_scale_Q14 = silk_LTPScales_table_Q14[ psIndices->LTP_scaleIndex ];
153 : } else {
154 0 : LTP_scale_Q14 = 0;
155 : }
156 :
157 : /* Convert input to fix */
158 0 : for( i = 0; i < psEnc->sCmn.frame_length; i++ ) {
159 0 : x16[ i ] = silk_float2int( x[ i ] );
160 : }
161 :
162 : /* Call NSQ */
163 0 : if( psEnc->sCmn.nStatesDelayedDecision > 1 || psEnc->sCmn.warping_Q16 > 0 ) {
164 0 : silk_NSQ_del_dec( &psEnc->sCmn, psNSQ, psIndices, x16, pulses, PredCoef_Q12[ 0 ], LTPCoef_Q14,
165 : AR_Q13, HarmShapeGain_Q14, Tilt_Q14, LF_shp_Q14, Gains_Q16, psEncCtrl->pitchL, Lambda_Q10, LTP_scale_Q14, psEnc->sCmn.arch );
166 : } else {
167 0 : silk_NSQ( &psEnc->sCmn, psNSQ, psIndices, x16, pulses, PredCoef_Q12[ 0 ], LTPCoef_Q14,
168 : AR_Q13, HarmShapeGain_Q14, Tilt_Q14, LF_shp_Q14, Gains_Q16, psEncCtrl->pitchL, Lambda_Q10, LTP_scale_Q14, psEnc->sCmn.arch );
169 : }
170 0 : }
171 :
172 : /***********************************************/
173 : /* Floating-point Silk LTP quantiation wrapper */
174 : /***********************************************/
175 0 : void silk_quant_LTP_gains_FLP(
176 : silk_float B[ MAX_NB_SUBFR * LTP_ORDER ], /* O Quantized LTP gains */
177 : opus_int8 cbk_index[ MAX_NB_SUBFR ], /* O Codebook index */
178 : opus_int8 *periodicity_index, /* O Periodicity index */
179 : opus_int32 *sum_log_gain_Q7, /* I/O Cumulative max prediction gain */
180 : silk_float *pred_gain_dB, /* O LTP prediction gain */
181 : const silk_float XX[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* I Correlation matrix */
182 : const silk_float xX[ MAX_NB_SUBFR * LTP_ORDER ], /* I Correlation vector */
183 : const opus_int subfr_len, /* I Number of samples per subframe */
184 : const opus_int nb_subfr, /* I Number of subframes */
185 : int arch /* I Run-time architecture */
186 : )
187 : {
188 : opus_int i, pred_gain_dB_Q7;
189 : opus_int16 B_Q14[ MAX_NB_SUBFR * LTP_ORDER ];
190 : opus_int32 XX_Q17[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];
191 : opus_int32 xX_Q17[ MAX_NB_SUBFR * LTP_ORDER ];
192 :
193 0 : for( i = 0; i < nb_subfr * LTP_ORDER * LTP_ORDER; i++ ) {
194 0 : XX_Q17[ i ] = (opus_int32)silk_float2int( XX[ i ] * 131072.0f );
195 : }
196 0 : for( i = 0; i < nb_subfr * LTP_ORDER; i++ ) {
197 0 : xX_Q17[ i ] = (opus_int32)silk_float2int( xX[ i ] * 131072.0f );
198 : }
199 :
200 0 : silk_quant_LTP_gains( B_Q14, cbk_index, periodicity_index, sum_log_gain_Q7, &pred_gain_dB_Q7, XX_Q17, xX_Q17, subfr_len, nb_subfr, arch );
201 :
202 0 : for( i = 0; i < nb_subfr * LTP_ORDER; i++ ) {
203 0 : B[ i ] = (silk_float)B_Q14[ i ] * ( 1.0f / 16384.0f );
204 : }
205 :
206 0 : *pred_gain_dB = (silk_float)pred_gain_dB_Q7 * ( 1.0f / 128.0f );
207 0 : }
|
