Blame - jni/libopus/silk/NSQ.c - jami-client-android

Alexandre Lision

744f742

2013-09-25 11:39:37 -0400

[diff] [blame]

1

/***********************************************************************

2

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

***********************************************************************/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "main.h"

static inline void silk_nsq_scale_states(

35

const silk_encoder_state *psEncC, /* I Encoder State */

36

silk_nsq_state *NSQ, /* I/O NSQ state */

37

const opus_int32 x_Q3[], /* I input in Q3 */

38

opus_int32 x_sc_Q10[], /* O input scaled with 1/Gain */

39

const opus_int16 sLTP[], /* I re-whitened LTP state in Q0 */

40

opus_int32 sLTP_Q15[], /* O LTP state matching scaled input */

41

opus_int subfr, /* I subframe number */

42

const opus_int LTP_scale_Q14, /* I */

43

const opus_int32 Gains_Q16[ MAX_NB_SUBFR ], /* I */

44

const opus_int pitchL[ MAX_NB_SUBFR ], /* I Pitch lag */

45

const opus_int signal_type /* I Signal type */

46

);

47

48

static inline void silk_noise_shape_quantizer(

49

silk_nsq_state *NSQ, /* I/O NSQ state */

50

opus_int signalType, /* I Signal type */

51

const opus_int32 x_sc_Q10[], /* I */

52

opus_int8 pulses[], /* O */

53

opus_int16 xq[], /* O */

54

opus_int32 sLTP_Q15[], /* I/O LTP state */

55

const opus_int16 a_Q12[], /* I Short term prediction coefs */

56

const opus_int16 b_Q14[], /* I Long term prediction coefs */

57

const opus_int16 AR_shp_Q13[], /* I Noise shaping AR coefs */

58

opus_int lag, /* I Pitch lag */

59

opus_int32 HarmShapeFIRPacked_Q14, /* I */

60

opus_int Tilt_Q14, /* I Spectral tilt */

61

opus_int32 LF_shp_Q14, /* I */

62

opus_int32 Gain_Q16, /* I */

63

opus_int Lambda_Q10, /* I */

64

opus_int offset_Q10, /* I */

65

opus_int length, /* I Input length */

66

opus_int shapingLPCOrder, /* I Noise shaping AR filter order */

67

opus_int predictLPCOrder /* I Prediction filter order */

);

void silk_NSQ(

const silk_encoder_state *psEncC, /* I/O Encoder State */

72

silk_nsq_state *NSQ, /* I/O NSQ state */

73

SideInfoIndices *psIndices, /* I/O Quantization Indices */

74

const opus_int32 x_Q3[], /* I Prefiltered input signal */

75

opus_int8 pulses[], /* O Quantized pulse signal */

76

const opus_int16 PredCoef_Q12[ 2 * MAX_LPC_ORDER ], /* I Short term prediction coefs */

77

const opus_int16 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ], /* I Long term prediction coefs */

78

const opus_int16 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ], /* I Noise shaping coefs */

79

const opus_int HarmShapeGain_Q14[ MAX_NB_SUBFR ], /* I Long term shaping coefs */

80

const opus_int Tilt_Q14[ MAX_NB_SUBFR ], /* I Spectral tilt */

81

const opus_int32 LF_shp_Q14[ MAX_NB_SUBFR ], /* I Low frequency shaping coefs */

82

const opus_int32 Gains_Q16[ MAX_NB_SUBFR ], /* I Quantization step sizes */

83

const opus_int pitchL[ MAX_NB_SUBFR ], /* I Pitch lags */

84

const opus_int Lambda_Q10, /* I Rate/distortion tradeoff */

85

const opus_int LTP_scale_Q14 /* I LTP state scaling */

86

)

87

{

88

opus_int k, lag, start_idx, LSF_interpolation_flag;

89

const opus_int16 *A_Q12, *B_Q14, *AR_shp_Q13;

90

opus_int16 *pxq;

91

opus_int32 sLTP_Q15[ 2 * MAX_FRAME_LENGTH ];

92

opus_int16 sLTP[ 2 * MAX_FRAME_LENGTH ];

93

opus_int32 HarmShapeFIRPacked_Q14;

94

opus_int offset_Q10;

95

opus_int32 x_sc_Q10[ MAX_SUB_FRAME_LENGTH ];

96

97

NSQ->rand_seed = psIndices->Seed;

98

99

/* Set unvoiced lag to the previous one, overwrite later for voiced */

100

lag = NSQ->lagPrev;

101

102

silk_assert( NSQ->prev_gain_Q16 != 0 );

103

104

offset_Q10 = silk_Quantization_Offsets_Q10[ psIndices->signalType >> 1 ][ psIndices->quantOffsetType ];

105

106

if( psIndices->NLSFInterpCoef_Q2 == 4 ) {

107

LSF_interpolation_flag = 0;

108

} else {

109

LSF_interpolation_flag = 1;

110

}

111

112

/* Set up pointers to start of sub frame */

113

NSQ->sLTP_shp_buf_idx = psEncC->ltp_mem_length;

114

NSQ->sLTP_buf_idx = psEncC->ltp_mem_length;

115

pxq = &NSQ->xq[ psEncC->ltp_mem_length ];

116

for( k = 0; k < psEncC->nb_subfr; k++ ) {

117

A_Q12 = &PredCoef_Q12[ (( k >> 1 ) | ( 1 - LSF_interpolation_flag )) * MAX_LPC_ORDER ];

118

B_Q14 = &LTPCoef_Q14[ k * LTP_ORDER ];

119

AR_shp_Q13 = &AR2_Q13[ k * MAX_SHAPE_LPC_ORDER ];

120

121

/* Noise shape parameters */

122

silk_assert( HarmShapeGain_Q14[ k ] >= 0 );

123

HarmShapeFIRPacked_Q14 = silk_RSHIFT( HarmShapeGain_Q14[ k ], 2 );

124

HarmShapeFIRPacked_Q14 |= silk_LSHIFT( (opus_int32)silk_RSHIFT( HarmShapeGain_Q14[ k ], 1 ), 16 );

125

126

NSQ->rewhite_flag = 0;

127

if( psIndices->signalType == TYPE_VOICED ) {

/* Voiced */

lag = pitchL[ k ];

/* Re-whitening */

if( ( k & ( 3 - silk_LSHIFT( LSF_interpolation_flag, 1 ) ) ) == 0 ) {

133

/* Rewhiten with new A coefs */

134

start_idx = psEncC->ltp_mem_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2;

135

silk_assert( start_idx > 0 );

136

137

silk_LPC_analysis_filter( &sLTP[ start_idx ], &NSQ->xq[ start_idx + k * psEncC->subfr_length ],

138

A_Q12, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder );

139

140

NSQ->rewhite_flag = 1;

141

NSQ->sLTP_buf_idx = psEncC->ltp_mem_length;

}

}

silk_nsq_scale_states( psEncC, NSQ, x_Q3, x_sc_Q10, sLTP, sLTP_Q15, k, LTP_scale_Q14, Gains_Q16, pitchL, psIndices->signalType );

146

147

silk_noise_shape_quantizer( NSQ, psIndices->signalType, x_sc_Q10, pulses, pxq, sLTP_Q15, A_Q12, B_Q14,

148

AR_shp_Q13, lag, HarmShapeFIRPacked_Q14, Tilt_Q14[ k ], LF_shp_Q14[ k ], Gains_Q16[ k ], Lambda_Q10,

149

offset_Q10, psEncC->subfr_length, psEncC->shapingLPCOrder, psEncC->predictLPCOrder );

150

151

x_Q3 += psEncC->subfr_length;

152

pulses += psEncC->subfr_length;

153

pxq += psEncC->subfr_length;

154

}

155

156

/* Update lagPrev for next frame */

157

NSQ->lagPrev = pitchL[ psEncC->nb_subfr - 1 ];

158

159

/* Save quantized speech and noise shaping signals */

160

/* DEBUG_STORE_DATA( enc.pcm, &NSQ->xq[ psEncC->ltp_mem_length ], psEncC->frame_length * sizeof( opus_int16 ) ) */

161

silk_memmove( NSQ->xq, &NSQ->xq[ psEncC->frame_length ], psEncC->ltp_mem_length * sizeof( opus_int16 ) );

162

silk_memmove( NSQ->sLTP_shp_Q14, &NSQ->sLTP_shp_Q14[ psEncC->frame_length ], psEncC->ltp_mem_length * sizeof( opus_int32 ) );

163

}

164

165

/***********************************/

166

/* silk_noise_shape_quantizer */

167

/***********************************/

168

static inline void silk_noise_shape_quantizer(

169

silk_nsq_state *NSQ, /* I/O NSQ state */

170

opus_int signalType, /* I Signal type */

171

const opus_int32 x_sc_Q10[], /* I */

172

opus_int8 pulses[], /* O */

173

opus_int16 xq[], /* O */

174

opus_int32 sLTP_Q15[], /* I/O LTP state */

175

const opus_int16 a_Q12[], /* I Short term prediction coefs */

176

const opus_int16 b_Q14[], /* I Long term prediction coefs */

177

const opus_int16 AR_shp_Q13[], /* I Noise shaping AR coefs */

178

opus_int lag, /* I Pitch lag */

179

opus_int32 HarmShapeFIRPacked_Q14, /* I */

180

opus_int Tilt_Q14, /* I Spectral tilt */

181

opus_int32 LF_shp_Q14, /* I */

182

opus_int32 Gain_Q16, /* I */

183

opus_int Lambda_Q10, /* I */

184

opus_int offset_Q10, /* I */

185

opus_int length, /* I Input length */

186

opus_int shapingLPCOrder, /* I Noise shaping AR filter order */

187

opus_int predictLPCOrder /* I Prediction filter order */

)

{

opus_int i, j;

opus_int32 LTP_pred_Q13, LPC_pred_Q10, n_AR_Q12, n_LTP_Q13;

192

opus_int32 n_LF_Q12, r_Q10, rr_Q10, q1_Q0, q1_Q10, q2_Q10, rd1_Q20, rd2_Q20;

193

opus_int32 exc_Q14, LPC_exc_Q14, xq_Q14, Gain_Q10;

194

opus_int32 tmp1, tmp2, sLF_AR_shp_Q14;

195

opus_int32 *psLPC_Q14, *shp_lag_ptr, *pred_lag_ptr;

196

197

shp_lag_ptr = &NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - lag + HARM_SHAPE_FIR_TAPS / 2 ];

198

pred_lag_ptr = &sLTP_Q15[ NSQ->sLTP_buf_idx - lag + LTP_ORDER / 2 ];

199

Gain_Q10 = silk_RSHIFT( Gain_Q16, 6 );

200

201

/* Set up short term AR state */

202

psLPC_Q14 = &NSQ->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - 1 ];

203

204

for( i = 0; i < length; i++ ) {

205

/* Generate dither */

206

NSQ->rand_seed = silk_RAND( NSQ->rand_seed );

207

208

/* Short-term prediction */

209

silk_assert( predictLPCOrder == 10 || predictLPCOrder == 16 );

210

/* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */

211

LPC_pred_Q10 = silk_RSHIFT( predictLPCOrder, 1 );

212

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ 0 ], a_Q12[ 0 ] );

213

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -1 ], a_Q12[ 1 ] );

214

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -2 ], a_Q12[ 2 ] );

215

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -3 ], a_Q12[ 3 ] );

216

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -4 ], a_Q12[ 4 ] );

217

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -5 ], a_Q12[ 5 ] );

218

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -6 ], a_Q12[ 6 ] );

219

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -7 ], a_Q12[ 7 ] );

220

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -8 ], a_Q12[ 8 ] );

221

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -9 ], a_Q12[ 9 ] );

222

if( predictLPCOrder == 16 ) {

223

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -10 ], a_Q12[ 10 ] );

224

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -11 ], a_Q12[ 11 ] );

225

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -12 ], a_Q12[ 12 ] );

226

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -13 ], a_Q12[ 13 ] );

227

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -14 ], a_Q12[ 14 ] );

228

LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -15 ], a_Q12[ 15 ] );

229

}

230

231

/* Long-term prediction */

232

if( signalType == TYPE_VOICED ) {

233

/* Unrolled loop */

234

/* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */

235

LTP_pred_Q13 = 2;

236

LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ 0 ], b_Q14[ 0 ] );

237

LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ -1 ], b_Q14[ 1 ] );

238

LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ -2 ], b_Q14[ 2 ] );

239

LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ -3 ], b_Q14[ 3 ] );

240

LTP_pred_Q13 = silk_SMLAWB( LTP_pred_Q13, pred_lag_ptr[ -4 ], b_Q14[ 4 ] );

pred_lag_ptr++;

} else {

LTP_pred_Q13 = 0;

}

/* Noise shape feedback */

247

silk_assert( ( shapingLPCOrder & 1 ) == 0 ); /* check that order is even */

248

tmp2 = psLPC_Q14[ 0 ];

249

tmp1 = NSQ->sAR2_Q14[ 0 ];

250

NSQ->sAR2_Q14[ 0 ] = tmp2;

251

n_AR_Q12 = silk_RSHIFT( shapingLPCOrder, 1 );

252

n_AR_Q12 = silk_SMLAWB( n_AR_Q12, tmp2, AR_shp_Q13[ 0 ] );

253

for( j = 2; j < shapingLPCOrder; j += 2 ) {

254

tmp2 = NSQ->sAR2_Q14[ j - 1 ];

255

NSQ->sAR2_Q14[ j - 1 ] = tmp1;

256

n_AR_Q12 = silk_SMLAWB( n_AR_Q12, tmp1, AR_shp_Q13[ j - 1 ] );

257

tmp1 = NSQ->sAR2_Q14[ j + 0 ];

258

NSQ->sAR2_Q14[ j + 0 ] = tmp2;

259

n_AR_Q12 = silk_SMLAWB( n_AR_Q12, tmp2, AR_shp_Q13[ j ] );

260

}

261

NSQ->sAR2_Q14[ shapingLPCOrder - 1 ] = tmp1;

262

n_AR_Q12 = silk_SMLAWB( n_AR_Q12, tmp1, AR_shp_Q13[ shapingLPCOrder - 1 ] );

263

264

n_AR_Q12 = silk_LSHIFT32( n_AR_Q12, 1 ); /* Q11 -> Q12 */

265

n_AR_Q12 = silk_SMLAWB( n_AR_Q12, NSQ->sLF_AR_shp_Q14, Tilt_Q14 );

266

267

n_LF_Q12 = silk_SMULWB( NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx - 1 ], LF_shp_Q14 );

268

n_LF_Q12 = silk_SMLAWT( n_LF_Q12, NSQ->sLF_AR_shp_Q14, LF_shp_Q14 );

269

270

silk_assert( lag > 0 || signalType != TYPE_VOICED );

271

272

/* Combine prediction and noise shaping signals */

273

tmp1 = silk_SUB32( silk_LSHIFT32( LPC_pred_Q10, 2 ), n_AR_Q12 ); /* Q12 */

274

tmp1 = silk_SUB32( tmp1, n_LF_Q12 ); /* Q12 */

275

if( lag > 0 ) {

276

/* Symmetric, packed FIR coefficients */

277

n_LTP_Q13 = silk_SMULWB( silk_ADD32( shp_lag_ptr[ 0 ], shp_lag_ptr[ -2 ] ), HarmShapeFIRPacked_Q14 );

278

n_LTP_Q13 = silk_SMLAWT( n_LTP_Q13, shp_lag_ptr[ -1 ], HarmShapeFIRPacked_Q14 );

279

n_LTP_Q13 = silk_LSHIFT( n_LTP_Q13, 1 );

280

shp_lag_ptr++;

281

282

tmp2 = silk_SUB32( LTP_pred_Q13, n_LTP_Q13 ); /* Q13 */

283

tmp1 = silk_ADD_LSHIFT32( tmp2, tmp1, 1 ); /* Q13 */

284

tmp1 = silk_RSHIFT_ROUND( tmp1, 3 ); /* Q10 */

285

} else {

286

tmp1 = silk_RSHIFT_ROUND( tmp1, 2 ); /* Q10 */

287

}

288

289

r_Q10 = silk_SUB32( x_sc_Q10[ i ], tmp1 ); /* residual error Q10 */

290

291

/* Flip sign depending on dither */

292

if ( NSQ->rand_seed < 0 ) {

293

r_Q10 = -r_Q10;

294

}

295

r_Q10 = silk_LIMIT_32( r_Q10, -(31 << 10), 30 << 10 );

296

297

/* Find two quantization level candidates and measure their rate-distortion */

298

q1_Q10 = silk_SUB32( r_Q10, offset_Q10 );

299

q1_Q0 = silk_RSHIFT( q1_Q10, 10 );

300

if( q1_Q0 > 0 ) {

301

q1_Q10 = silk_SUB32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 );

302

q1_Q10 = silk_ADD32( q1_Q10, offset_Q10 );

303

q2_Q10 = silk_ADD32( q1_Q10, 1024 );

304

rd1_Q20 = silk_SMULBB( q1_Q10, Lambda_Q10 );

305

rd2_Q20 = silk_SMULBB( q2_Q10, Lambda_Q10 );

306

} else if( q1_Q0 == 0 ) {

307

q1_Q10 = offset_Q10;

308

q2_Q10 = silk_ADD32( q1_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );

309

rd1_Q20 = silk_SMULBB( q1_Q10, Lambda_Q10 );

310

rd2_Q20 = silk_SMULBB( q2_Q10, Lambda_Q10 );

311

} else if( q1_Q0 == -1 ) {

312

q2_Q10 = offset_Q10;

313

q1_Q10 = silk_SUB32( q2_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );

314

rd1_Q20 = silk_SMULBB( -q1_Q10, Lambda_Q10 );

315

rd2_Q20 = silk_SMULBB( q2_Q10, Lambda_Q10 );

316

} else { /* Q1_Q0 < -1 */

317

q1_Q10 = silk_ADD32( silk_LSHIFT( q1_Q0, 10 ), QUANT_LEVEL_ADJUST_Q10 );

318

q1_Q10 = silk_ADD32( q1_Q10, offset_Q10 );

319

q2_Q10 = silk_ADD32( q1_Q10, 1024 );

320

rd1_Q20 = silk_SMULBB( -q1_Q10, Lambda_Q10 );

321

rd2_Q20 = silk_SMULBB( -q2_Q10, Lambda_Q10 );

322

}

323

rr_Q10 = silk_SUB32( r_Q10, q1_Q10 );

324

rd1_Q20 = silk_SMLABB( rd1_Q20, rr_Q10, rr_Q10 );

325

rr_Q10 = silk_SUB32( r_Q10, q2_Q10 );

326

rd2_Q20 = silk_SMLABB( rd2_Q20, rr_Q10, rr_Q10 );

327

328

if( rd2_Q20 < rd1_Q20 ) {

q1_Q10 = q2_Q10;

}

pulses[ i ] = (opus_int8)silk_RSHIFT_ROUND( q1_Q10, 10 );

333

334

/* Excitation */

335

exc_Q14 = silk_LSHIFT( q1_Q10, 4 );

336

if ( NSQ->rand_seed < 0 ) {

exc_Q14 = -exc_Q14;

}

/* Add predictions */

341

LPC_exc_Q14 = silk_ADD_LSHIFT32( exc_Q14, LTP_pred_Q13, 1 );

342

xq_Q14 = silk_ADD_LSHIFT32( LPC_exc_Q14, LPC_pred_Q10, 4 );

343

344

/* Scale XQ back to normal level before saving */

345

xq[ i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( silk_SMULWW( xq_Q14, Gain_Q10 ), 8 ) );

/* Update states */

psLPC_Q14++;

*psLPC_Q14 = xq_Q14;

sLF_AR_shp_Q14 = silk_SUB_LSHIFT32( xq_Q14, n_AR_Q12, 2 );

351

NSQ->sLF_AR_shp_Q14 = sLF_AR_shp_Q14;

352

353

NSQ->sLTP_shp_Q14[ NSQ->sLTP_shp_buf_idx ] = silk_SUB_LSHIFT32( sLF_AR_shp_Q14, n_LF_Q12, 2 );

354

sLTP_Q15[ NSQ->sLTP_buf_idx ] = silk_LSHIFT( LPC_exc_Q14, 1 );

355

NSQ->sLTP_shp_buf_idx++;

356

NSQ->sLTP_buf_idx++;

357

358

/* Make dither dependent on quantized signal */

359

NSQ->rand_seed = silk_ADD32_ovflw( NSQ->rand_seed, pulses[ i ] );

360

}

361

362

/* Update LPC synth buffer */

363

silk_memcpy( NSQ->sLPC_Q14, &NSQ->sLPC_Q14[ length ], NSQ_LPC_BUF_LENGTH * sizeof( opus_int32 ) );

364

}

365

366

static inline void silk_nsq_scale_states(

367

const silk_encoder_state *psEncC, /* I Encoder State */

368

silk_nsq_state *NSQ, /* I/O NSQ state */

369

const opus_int32 x_Q3[], /* I input in Q3 */

370

opus_int32 x_sc_Q10[], /* O input scaled with 1/Gain */

371

const opus_int16 sLTP[], /* I re-whitened LTP state in Q0 */

372

opus_int32 sLTP_Q15[], /* O LTP state matching scaled input */

373

opus_int subfr, /* I subframe number */

374

const opus_int LTP_scale_Q14, /* I */

375

const opus_int32 Gains_Q16[ MAX_NB_SUBFR ], /* I */

376

const opus_int pitchL[ MAX_NB_SUBFR ], /* I Pitch lag */

377

const opus_int signal_type /* I Signal type */

)

{

opus_int i, lag;

opus_int32 gain_adj_Q16, inv_gain_Q31, inv_gain_Q23;

382

383

lag = pitchL[ subfr ];

384

inv_gain_Q31 = silk_INVERSE32_varQ( silk_max( Gains_Q16[ subfr ], 1 ), 47 );

385

silk_assert( inv_gain_Q31 != 0 );

386

387

/* Calculate gain adjustment factor */

388

if( Gains_Q16[ subfr ] != NSQ->prev_gain_Q16 ) {

389

gain_adj_Q16 = silk_DIV32_varQ( NSQ->prev_gain_Q16, Gains_Q16[ subfr ], 16 );

390

} else {

391

gain_adj_Q16 = (opus_int32)1 << 16;

}

/* Scale input */

inv_gain_Q23 = silk_RSHIFT_ROUND( inv_gain_Q31, 8 );

396

for( i = 0; i < psEncC->subfr_length; i++ ) {

397

x_sc_Q10[ i ] = silk_SMULWW( x_Q3[ i ], inv_gain_Q23 );

398

}

399

400

/* Save inverse gain */

401

NSQ->prev_gain_Q16 = Gains_Q16[ subfr ];

402

403

/* After rewhitening the LTP state is un-scaled, so scale with inv_gain_Q16 */

404

if( NSQ->rewhite_flag ) {

405

if( subfr == 0 ) {

406

/* Do LTP downscaling */

407

inv_gain_Q31 = silk_LSHIFT( silk_SMULWB( inv_gain_Q31, LTP_scale_Q14 ), 2 );

408

}

409

for( i = NSQ->sLTP_buf_idx - lag - LTP_ORDER / 2; i < NSQ->sLTP_buf_idx; i++ ) {

410

silk_assert( i < MAX_FRAME_LENGTH );

411

sLTP_Q15[ i ] = silk_SMULWB( inv_gain_Q31, sLTP[ i ] );

}

}

/* Adjust for changing gain */

416

if( gain_adj_Q16 != (opus_int32)1 << 16 ) {

417

/* Scale long-term shaping state */

418

for( i = NSQ->sLTP_shp_buf_idx - psEncC->ltp_mem_length; i < NSQ->sLTP_shp_buf_idx; i++ ) {

419

NSQ->sLTP_shp_Q14[ i ] = silk_SMULWW( gain_adj_Q16, NSQ->sLTP_shp_Q14[ i ] );

420

}

421

422

/* Scale long-term prediction state */

423

if( signal_type == TYPE_VOICED && NSQ->rewhite_flag == 0 ) {

424

for( i = NSQ->sLTP_buf_idx - lag - LTP_ORDER / 2; i < NSQ->sLTP_buf_idx; i++ ) {

425

sLTP_Q15[ i ] = silk_SMULWW( gain_adj_Q16, sLTP_Q15[ i ] );

}

}

NSQ->sLF_AR_shp_Q14 = silk_SMULWW( gain_adj_Q16, NSQ->sLF_AR_shp_Q14 );

430

431

/* Scale short-term prediction and shaping states */

432

for( i = 0; i < NSQ_LPC_BUF_LENGTH; i++ ) {

433

NSQ->sLPC_Q14[ i ] = silk_SMULWW( gain_adj_Q16, NSQ->sLPC_Q14[ i ] );

434

}

435

for( i = 0; i < MAX_SHAPE_LPC_ORDER; i++ ) {

436

NSQ->sAR2_Q14[ i ] = silk_SMULWW( gain_adj_Q16, NSQ->sAR2_Q14[ i ] );

437

}

438

}

439

}