Mercurial > hg > sv-dependency-builds

comparison src/opus-1.3/silk/control_codec.c @ 69:7aeed7906520

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add Opus sources and macOS builds
author Chris Cannam
date Wed, 23 Jan 2019 13:48:08 +0000
parents
children
comparison
equal deleted inserted replaced
68:85d5306e114e 69:7aeed7906520
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 #ifdef FIXED_POINT
32 #include "main_FIX.h"
33 #define silk_encoder_state_Fxx silk_encoder_state_FIX
34 #else
35 #include "main_FLP.h"
36 #define silk_encoder_state_Fxx silk_encoder_state_FLP
37 #endif
38 #include "stack_alloc.h"
39 #include "tuning_parameters.h"
40 #include "pitch_est_defines.h"
41
42 static opus_int silk_setup_resamplers(
43 silk_encoder_state_Fxx *psEnc, /* I/O */
44 opus_int fs_kHz /* I */
45 );
46
47 static opus_int silk_setup_fs(
48 silk_encoder_state_Fxx *psEnc, /* I/O */
49 opus_int fs_kHz, /* I */
50 opus_int PacketSize_ms /* I */
51 );
52
53 static opus_int silk_setup_complexity(
54 silk_encoder_state *psEncC, /* I/O */
55 opus_int Complexity /* I */
56 );
57
58 static OPUS_INLINE opus_int silk_setup_LBRR(
59 silk_encoder_state *psEncC, /* I/O */
60 const silk_EncControlStruct *encControl /* I */
61 );
62
63
64 /* Control encoder */
65 opus_int silk_control_encoder(
66 silk_encoder_state_Fxx *psEnc, /* I/O Pointer to Silk encoder state */
67 silk_EncControlStruct *encControl, /* I Control structure */
68 const opus_int allow_bw_switch, /* I Flag to allow switching audio bandwidth */
69 const opus_int channelNb, /* I Channel number */
70 const opus_int force_fs_kHz
71 )
72 {
73 opus_int fs_kHz, ret = 0;
74
75 psEnc->sCmn.useDTX = encControl->useDTX;
76 psEnc->sCmn.useCBR = encControl->useCBR;
77 psEnc->sCmn.API_fs_Hz = encControl->API_sampleRate;
78 psEnc->sCmn.maxInternal_fs_Hz = encControl->maxInternalSampleRate;
79 psEnc->sCmn.minInternal_fs_Hz = encControl->minInternalSampleRate;
80 psEnc->sCmn.desiredInternal_fs_Hz = encControl->desiredInternalSampleRate;
81 psEnc->sCmn.useInBandFEC = encControl->useInBandFEC;
82 psEnc->sCmn.nChannelsAPI = encControl->nChannelsAPI;
83 psEnc->sCmn.nChannelsInternal = encControl->nChannelsInternal;
84 psEnc->sCmn.allow_bandwidth_switch = allow_bw_switch;
85 psEnc->sCmn.channelNb = channelNb;
86
87 if( psEnc->sCmn.controlled_since_last_payload != 0 && psEnc->sCmn.prefillFlag == 0 ) {
88 if( psEnc->sCmn.API_fs_Hz != psEnc->sCmn.prev_API_fs_Hz && psEnc->sCmn.fs_kHz > 0 ) {
89 /* Change in API sampling rate in the middle of encoding a packet */
90 ret += silk_setup_resamplers( psEnc, psEnc->sCmn.fs_kHz );
91 }
92 return ret;
93 }
94
95 /* Beyond this point we know that there are no previously coded frames in the payload buffer */
96
97 /********************************************/
98 /* Determine internal sampling rate */
99 /********************************************/
100 fs_kHz = silk_control_audio_bandwidth( &psEnc->sCmn, encControl );
101 if( force_fs_kHz ) {
102 fs_kHz = force_fs_kHz;
103 }
104 /********************************************/
105 /* Prepare resampler and buffered data */
106 /********************************************/
107 ret += silk_setup_resamplers( psEnc, fs_kHz );
108
109 /********************************************/
110 /* Set internal sampling frequency */
111 /********************************************/
112 ret += silk_setup_fs( psEnc, fs_kHz, encControl->payloadSize_ms );
113
114 /********************************************/
115 /* Set encoding complexity */
116 /********************************************/
117 ret += silk_setup_complexity( &psEnc->sCmn, encControl->complexity );
118
119 /********************************************/
120 /* Set packet loss rate measured by farend */
121 /********************************************/
122 psEnc->sCmn.PacketLoss_perc = encControl->packetLossPercentage;
123
124 /********************************************/
125 /* Set LBRR usage */
126 /********************************************/
127 ret += silk_setup_LBRR( &psEnc->sCmn, encControl );
128
129 psEnc->sCmn.controlled_since_last_payload = 1;
130
131 return ret;
132 }
133
134 static opus_int silk_setup_resamplers(
135 silk_encoder_state_Fxx *psEnc, /* I/O */
136 opus_int fs_kHz /* I */
137 )
138 {
139 opus_int ret = SILK_NO_ERROR;
140 SAVE_STACK;
141
142 if( psEnc->sCmn.fs_kHz != fs_kHz || psEnc->sCmn.prev_API_fs_Hz != psEnc->sCmn.API_fs_Hz )
143 {
144 if( psEnc->sCmn.fs_kHz == 0 ) {
145 /* Initialize the resampler for enc_API.c preparing resampling from API_fs_Hz to fs_kHz */
146 ret += silk_resampler_init( &psEnc->sCmn.resampler_state, psEnc->sCmn.API_fs_Hz, fs_kHz * 1000, 1 );
147 } else {
148 VARDECL( opus_int16, x_buf_API_fs_Hz );
149 VARDECL( silk_resampler_state_struct, temp_resampler_state );
150 #ifdef FIXED_POINT
151 opus_int16 *x_bufFIX = psEnc->x_buf;
152 #else
153 VARDECL( opus_int16, x_bufFIX );
154 opus_int32 new_buf_samples;
155 #endif
156 opus_int32 api_buf_samples;
157 opus_int32 old_buf_samples;
158 opus_int32 buf_length_ms;
159
160 buf_length_ms = silk_LSHIFT( psEnc->sCmn.nb_subfr * 5, 1 ) + LA_SHAPE_MS;
161 old_buf_samples = buf_length_ms * psEnc->sCmn.fs_kHz;
162
163 #ifndef FIXED_POINT
164 new_buf_samples = buf_length_ms * fs_kHz;
165 ALLOC( x_bufFIX, silk_max( old_buf_samples, new_buf_samples ),
166 opus_int16 );
167 silk_float2short_array( x_bufFIX, psEnc->x_buf, old_buf_samples );
168 #endif
169
170 /* Initialize resampler for temporary resampling of x_buf data to API_fs_Hz */
171 ALLOC( temp_resampler_state, 1, silk_resampler_state_struct );
172 ret += silk_resampler_init( temp_resampler_state, silk_SMULBB( psEnc->sCmn.fs_kHz, 1000 ), psEnc->sCmn.API_fs_Hz, 0 );
173
174 /* Calculate number of samples to temporarily upsample */
175 api_buf_samples = buf_length_ms * silk_DIV32_16( psEnc->sCmn.API_fs_Hz, 1000 );
176
177 /* Temporary resampling of x_buf data to API_fs_Hz */
178 ALLOC( x_buf_API_fs_Hz, api_buf_samples, opus_int16 );
179 ret += silk_resampler( temp_resampler_state, x_buf_API_fs_Hz, x_bufFIX, old_buf_samples );
180
181 /* Initialize the resampler for enc_API.c preparing resampling from API_fs_Hz to fs_kHz */
182 ret += silk_resampler_init( &psEnc->sCmn.resampler_state, psEnc->sCmn.API_fs_Hz, silk_SMULBB( fs_kHz, 1000 ), 1 );
183
184 /* Correct resampler state by resampling buffered data from API_fs_Hz to fs_kHz */
185 ret += silk_resampler( &psEnc->sCmn.resampler_state, x_bufFIX, x_buf_API_fs_Hz, api_buf_samples );
186
187 #ifndef FIXED_POINT
188 silk_short2float_array( psEnc->x_buf, x_bufFIX, new_buf_samples);
189 #endif
190 }
191 }
192
193 psEnc->sCmn.prev_API_fs_Hz = psEnc->sCmn.API_fs_Hz;
194
195 RESTORE_STACK;
196 return ret;
197 }
198
199 static opus_int silk_setup_fs(
200 silk_encoder_state_Fxx *psEnc, /* I/O */
201 opus_int fs_kHz, /* I */
202 opus_int PacketSize_ms /* I */
203 )
204 {
205 opus_int ret = SILK_NO_ERROR;
206
207 /* Set packet size */
208 if( PacketSize_ms != psEnc->sCmn.PacketSize_ms ) {
209 if( ( PacketSize_ms != 10 ) &&
210 ( PacketSize_ms != 20 ) &&
211 ( PacketSize_ms != 40 ) &&
212 ( PacketSize_ms != 60 ) ) {
213 ret = SILK_ENC_PACKET_SIZE_NOT_SUPPORTED;
214 }
215 if( PacketSize_ms <= 10 ) {
216 psEnc->sCmn.nFramesPerPacket = 1;
217 psEnc->sCmn.nb_subfr = PacketSize_ms == 10 ? 2 : 1;
218 psEnc->sCmn.frame_length = silk_SMULBB( PacketSize_ms, fs_kHz );
219 psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );
220 if( psEnc->sCmn.fs_kHz == 8 ) {
221 psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_NB_iCDF;
222 } else {
223 psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_iCDF;
224 }
225 } else {
226 psEnc->sCmn.nFramesPerPacket = silk_DIV32_16( PacketSize_ms, MAX_FRAME_LENGTH_MS );
227 psEnc->sCmn.nb_subfr = MAX_NB_SUBFR;
228 psEnc->sCmn.frame_length = silk_SMULBB( 20, fs_kHz );
229 psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz );
230 if( psEnc->sCmn.fs_kHz == 8 ) {
231 psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_NB_iCDF;
232 } else {
233 psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_iCDF;
234 }
235 }
236 psEnc->sCmn.PacketSize_ms = PacketSize_ms;
237 psEnc->sCmn.TargetRate_bps = 0; /* trigger new SNR computation */
238 }
239
240 /* Set internal sampling frequency */
241 celt_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );
242 celt_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 );
243 if( psEnc->sCmn.fs_kHz != fs_kHz ) {
244 /* reset part of the state */
245 silk_memset( &psEnc->sShape, 0, sizeof( psEnc->sShape ) );
246 silk_memset( &psEnc->sCmn.sNSQ, 0, sizeof( psEnc->sCmn.sNSQ ) );
247 silk_memset( psEnc->sCmn.prev_NLSFq_Q15, 0, sizeof( psEnc->sCmn.prev_NLSFq_Q15 ) );
248 silk_memset( &psEnc->sCmn.sLP.In_LP_State, 0, sizeof( psEnc->sCmn.sLP.In_LP_State ) );
249 psEnc->sCmn.inputBufIx = 0;
250 psEnc->sCmn.nFramesEncoded = 0;
251 psEnc->sCmn.TargetRate_bps = 0; /* trigger new SNR computation */
252
253 /* Initialize non-zero parameters */
254 psEnc->sCmn.prevLag = 100;
255 psEnc->sCmn.first_frame_after_reset = 1;
256 psEnc->sShape.LastGainIndex = 10;
257 psEnc->sCmn.sNSQ.lagPrev = 100;
258 psEnc->sCmn.sNSQ.prev_gain_Q16 = 65536;
259 psEnc->sCmn.prevSignalType = TYPE_NO_VOICE_ACTIVITY;
260
261 psEnc->sCmn.fs_kHz = fs_kHz;
262 if( psEnc->sCmn.fs_kHz == 8 ) {
263 if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {
264 psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_NB_iCDF;
265 } else {
266 psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_NB_iCDF;
267 }
268 } else {
269 if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {
270 psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_iCDF;
271 } else {
272 psEnc->sCmn.pitch_contour_iCDF = silk_pitch_contour_10_ms_iCDF;
273 }
274 }
275 if( psEnc->sCmn.fs_kHz == 8 || psEnc->sCmn.fs_kHz == 12 ) {
276 psEnc->sCmn.predictLPCOrder = MIN_LPC_ORDER;
277 psEnc->sCmn.psNLSF_CB = &silk_NLSF_CB_NB_MB;
278 } else {
279 psEnc->sCmn.predictLPCOrder = MAX_LPC_ORDER;
280 psEnc->sCmn.psNLSF_CB = &silk_NLSF_CB_WB;
281 }
282 psEnc->sCmn.subfr_length = SUB_FRAME_LENGTH_MS * fs_kHz;
283 psEnc->sCmn.frame_length = silk_SMULBB( psEnc->sCmn.subfr_length, psEnc->sCmn.nb_subfr );
284 psEnc->sCmn.ltp_mem_length = silk_SMULBB( LTP_MEM_LENGTH_MS, fs_kHz );
285 psEnc->sCmn.la_pitch = silk_SMULBB( LA_PITCH_MS, fs_kHz );
286 psEnc->sCmn.max_pitch_lag = silk_SMULBB( 18, fs_kHz );
287 if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {
288 psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz );
289 } else {
290 psEnc->sCmn.pitch_LPC_win_length = silk_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );
291 }
292 if( psEnc->sCmn.fs_kHz == 16 ) {
293 psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform8_iCDF;
294 } else if( psEnc->sCmn.fs_kHz == 12 ) {
295 psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform6_iCDF;
296 } else {
297 psEnc->sCmn.pitch_lag_low_bits_iCDF = silk_uniform4_iCDF;
298 }
299 }
300
301 /* Check that settings are valid */
302 celt_assert( ( psEnc->sCmn.subfr_length * psEnc->sCmn.nb_subfr ) == psEnc->sCmn.frame_length );
303
304 return ret;
305 }
306
307 static opus_int silk_setup_complexity(
308 silk_encoder_state *psEncC, /* I/O */
309 opus_int Complexity /* I */
310 )
311 {
312 opus_int ret = 0;
313
314 /* Set encoding complexity */
315 celt_assert( Complexity >= 0 && Complexity <= 10 );
316 if( Complexity < 1 ) {
317 psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX;
318 psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.8, 16 );
319 psEncC->pitchEstimationLPCOrder = 6;
320 psEncC->shapingLPCOrder = 12;
321 psEncC->la_shape = 3 * psEncC->fs_kHz;
322 psEncC->nStatesDelayedDecision = 1;
323 psEncC->useInterpolatedNLSFs = 0;
324 psEncC->NLSF_MSVQ_Survivors = 2;
325 psEncC->warping_Q16 = 0;
326 } else if( Complexity < 2 ) {
327 psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX;
328 psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.76, 16 );
329 psEncC->pitchEstimationLPCOrder = 8;
330 psEncC->shapingLPCOrder = 14;
331 psEncC->la_shape = 5 * psEncC->fs_kHz;
332 psEncC->nStatesDelayedDecision = 1;
333 psEncC->useInterpolatedNLSFs = 0;
334 psEncC->NLSF_MSVQ_Survivors = 3;
335 psEncC->warping_Q16 = 0;
336 } else if( Complexity < 3 ) {
337 psEncC->pitchEstimationComplexity = SILK_PE_MIN_COMPLEX;
338 psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.8, 16 );
339 psEncC->pitchEstimationLPCOrder = 6;
340 psEncC->shapingLPCOrder = 12;
341 psEncC->la_shape = 3 * psEncC->fs_kHz;
342 psEncC->nStatesDelayedDecision = 2;
343 psEncC->useInterpolatedNLSFs = 0;
344 psEncC->NLSF_MSVQ_Survivors = 2;
345 psEncC->warping_Q16 = 0;
346 } else if( Complexity < 4 ) {
347 psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX;
348 psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.76, 16 );
349 psEncC->pitchEstimationLPCOrder = 8;
350 psEncC->shapingLPCOrder = 14;
351 psEncC->la_shape = 5 * psEncC->fs_kHz;
352 psEncC->nStatesDelayedDecision = 2;
353 psEncC->useInterpolatedNLSFs = 0;
354 psEncC->NLSF_MSVQ_Survivors = 4;
355 psEncC->warping_Q16 = 0;
356 } else if( Complexity < 6 ) {
357 psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX;
358 psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.74, 16 );
359 psEncC->pitchEstimationLPCOrder = 10;
360 psEncC->shapingLPCOrder = 16;
361 psEncC->la_shape = 5 * psEncC->fs_kHz;
362 psEncC->nStatesDelayedDecision = 2;
363 psEncC->useInterpolatedNLSFs = 1;
364 psEncC->NLSF_MSVQ_Survivors = 6;
365 psEncC->warping_Q16 = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );
366 } else if( Complexity < 8 ) {
367 psEncC->pitchEstimationComplexity = SILK_PE_MID_COMPLEX;
368 psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.72, 16 );
369 psEncC->pitchEstimationLPCOrder = 12;
370 psEncC->shapingLPCOrder = 20;
371 psEncC->la_shape = 5 * psEncC->fs_kHz;
372 psEncC->nStatesDelayedDecision = 3;
373 psEncC->useInterpolatedNLSFs = 1;
374 psEncC->NLSF_MSVQ_Survivors = 8;
375 psEncC->warping_Q16 = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );
376 } else {
377 psEncC->pitchEstimationComplexity = SILK_PE_MAX_COMPLEX;
378 psEncC->pitchEstimationThreshold_Q16 = SILK_FIX_CONST( 0.7, 16 );
379 psEncC->pitchEstimationLPCOrder = 16;
380 psEncC->shapingLPCOrder = 24;
381 psEncC->la_shape = 5 * psEncC->fs_kHz;
382 psEncC->nStatesDelayedDecision = MAX_DEL_DEC_STATES;
383 psEncC->useInterpolatedNLSFs = 1;
384 psEncC->NLSF_MSVQ_Survivors = 16;
385 psEncC->warping_Q16 = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );
386 }
387
388 /* Do not allow higher pitch estimation LPC order than predict LPC order */
389 psEncC->pitchEstimationLPCOrder = silk_min_int( psEncC->pitchEstimationLPCOrder, psEncC->predictLPCOrder );
390 psEncC->shapeWinLength = SUB_FRAME_LENGTH_MS * psEncC->fs_kHz + 2 * psEncC->la_shape;
391 psEncC->Complexity = Complexity;
392
393 celt_assert( psEncC->pitchEstimationLPCOrder <= MAX_FIND_PITCH_LPC_ORDER );
394 celt_assert( psEncC->shapingLPCOrder <= MAX_SHAPE_LPC_ORDER );
395 celt_assert( psEncC->nStatesDelayedDecision <= MAX_DEL_DEC_STATES );
396 celt_assert( psEncC->warping_Q16 <= 32767 );
397 celt_assert( psEncC->la_shape <= LA_SHAPE_MAX );
398 celt_assert( psEncC->shapeWinLength <= SHAPE_LPC_WIN_MAX );
399
400 return ret;
401 }
402
403 static OPUS_INLINE opus_int silk_setup_LBRR(
404 silk_encoder_state *psEncC, /* I/O */
405 const silk_EncControlStruct *encControl /* I */
406 )
407 {
408 opus_int LBRR_in_previous_packet, ret = SILK_NO_ERROR;
409
410 LBRR_in_previous_packet = psEncC->LBRR_enabled;
411 psEncC->LBRR_enabled = encControl->LBRR_coded;
412 if( psEncC->LBRR_enabled ) {
413 /* Set gain increase for coding LBRR excitation */
414 if( LBRR_in_previous_packet == 0 ) {
415 /* Previous packet did not have LBRR, and was therefore coded at a higher bitrate */
416 psEncC->LBRR_GainIncreases = 7;
417 } else {
418 psEncC->LBRR_GainIncreases = silk_max_int( 7 - silk_SMULWB( (opus_int32)psEncC->PacketLoss_perc, SILK_FIX_CONST( 0.4, 16 ) ), 2 );
419 }
420 }
421
422 return ret;
423 }