removed prefilter
[opus.git] / silk / fixed / encode_frame_FIX.c
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_FIX.h"
33 #include "stack_alloc.h"
34 #include "tuning_parameters.h"
35
36 /* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate           */
37 static OPUS_INLINE void silk_LBRR_encode_FIX(
38     silk_encoder_state_FIX          *psEnc,                                 /* I/O  Pointer to Silk FIX encoder state                                           */
39     silk_encoder_control_FIX        *psEncCtrl,                             /* I/O  Pointer to Silk FIX encoder control struct                                  */
40     const opus_int16                x16[],                                  /* I    Input signal                                                                */
41     opus_int                        condCoding                              /* I    The type of conditional coding used so far for this frame                   */
42 );
43
44 void silk_encode_do_VAD_FIX(
45     silk_encoder_state_FIX          *psEnc                                  /* I/O  Pointer to Silk FIX encoder state                                           */
46 )
47 {
48     /****************************/
49     /* Voice Activity Detection */
50     /****************************/
51     silk_VAD_GetSA_Q8( &psEnc->sCmn, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.arch );
52
53     /**************************************************/
54     /* Convert speech activity into VAD and DTX flags */
55     /**************************************************/
56     if( psEnc->sCmn.speech_activity_Q8 < SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ) ) {
57         psEnc->sCmn.indices.signalType = TYPE_NO_VOICE_ACTIVITY;
58         psEnc->sCmn.noSpeechCounter++;
59         if( psEnc->sCmn.noSpeechCounter < NB_SPEECH_FRAMES_BEFORE_DTX ) {
60             psEnc->sCmn.inDTX = 0;
61         } else if( psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NB_SPEECH_FRAMES_BEFORE_DTX ) {
62             psEnc->sCmn.noSpeechCounter = NB_SPEECH_FRAMES_BEFORE_DTX;
63             psEnc->sCmn.inDTX           = 0;
64         }
65         psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 0;
66     } else {
67         psEnc->sCmn.noSpeechCounter    = 0;
68         psEnc->sCmn.inDTX              = 0;
69         psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
70         psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
71     }
72 }
73
74 /****************/
75 /* Encode frame */
76 /****************/
77 opus_int silk_encode_frame_FIX(
78     silk_encoder_state_FIX          *psEnc,                                 /* I/O  Pointer to Silk FIX encoder state                                           */
79     opus_int32                      *pnBytesOut,                            /* O    Pointer to number of payload bytes;                                         */
80     ec_enc                          *psRangeEnc,                            /* I/O  compressor data structure                                                   */
81     opus_int                        condCoding,                             /* I    The type of conditional coding to use                                       */
82     opus_int                        maxBits,                                /* I    If > 0: maximum number of output bits                                       */
83     opus_int                        useCBR                                  /* I    Flag to force constant-bitrate operation                                    */
84 )
85 {
86     silk_encoder_control_FIX sEncCtrl;
87     opus_int     i, iter, maxIter, found_upper, found_lower, ret = 0;
88     opus_int16   *x_frame;
89     ec_enc       sRangeEnc_copy, sRangeEnc_copy2;
90     silk_nsq_state sNSQ_copy, sNSQ_copy2;
91     opus_int32   seed_copy, nBits, nBits_lower, nBits_upper, gainMult_lower, gainMult_upper;
92     opus_int32   gainsID, gainsID_lower, gainsID_upper;
93     opus_int16   gainMult_Q8;
94     opus_int16   ec_prevLagIndex_copy;
95     opus_int     ec_prevSignalType_copy;
96     opus_int8    LastGainIndex_copy2;
97     SAVE_STACK;
98
99     /* This is totally unnecessary but many compilers (including gcc) are too dumb to realise it */
100     LastGainIndex_copy2 = nBits_lower = nBits_upper = gainMult_lower = gainMult_upper = 0;
101
102     psEnc->sCmn.indices.Seed = psEnc->sCmn.frameCounter++ & 3;
103
104     /**************************************************************/
105     /* Set up Input Pointers, and insert frame in input buffer   */
106     /*************************************************************/
107     /* start of frame to encode */
108     x_frame = psEnc->x_buf + psEnc->sCmn.ltp_mem_length;
109
110     /***************************************/
111     /* Ensure smooth bandwidth transitions */
112     /***************************************/
113     silk_LP_variable_cutoff( &psEnc->sCmn.sLP, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );
114
115     /*******************************************/
116     /* Copy new frame to front of input buffer */
117     /*******************************************/
118     silk_memcpy( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length * sizeof( opus_int16 ) );
119
120     if( !psEnc->sCmn.prefillFlag ) {
121         VARDECL( opus_int16, res_pitch );
122         VARDECL( opus_uint8, ec_buf_copy );
123         opus_int16 *res_pitch_frame;
124
125         ALLOC( res_pitch,
126                psEnc->sCmn.la_pitch + psEnc->sCmn.frame_length
127                    + psEnc->sCmn.ltp_mem_length, opus_int16 );
128         /* start of pitch LPC residual frame */
129         res_pitch_frame = res_pitch + psEnc->sCmn.ltp_mem_length;
130
131         /*****************************************/
132         /* Find pitch lags, initial LPC analysis */
133         /*****************************************/
134         silk_find_pitch_lags_FIX( psEnc, &sEncCtrl, res_pitch, x_frame - psEnc->sCmn.ltp_mem_length, psEnc->sCmn.arch );
135
136         /************************/
137         /* Noise shape analysis */
138         /************************/
139         silk_noise_shape_analysis_FIX( psEnc, &sEncCtrl, res_pitch_frame, x_frame, psEnc->sCmn.arch );
140
141         /***************************************************/
142         /* Find linear prediction coefficients (LPC + LTP) */
143         /***************************************************/
144         silk_find_pred_coefs_FIX( psEnc, &sEncCtrl, res_pitch_frame, x_frame, condCoding );
145
146         /****************************************/
147         /* Process gains                        */
148         /****************************************/
149         silk_process_gains_FIX( psEnc, &sEncCtrl, condCoding );
150
151         /****************************************/
152         /* Low Bitrate Redundant Encoding       */
153         /****************************************/
154         silk_LBRR_encode_FIX( psEnc, &sEncCtrl, x_frame, condCoding );
155
156         /* Loop over quantizer and entropy coding to control bitrate */
157         maxIter = 6;
158         gainMult_Q8 = SILK_FIX_CONST( 1, 8 );
159         found_lower = 0;
160         found_upper = 0;
161         gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );
162         gainsID_lower = -1;
163         gainsID_upper = -1;
164         /* Copy part of the input state */
165         silk_memcpy( &sRangeEnc_copy, psRangeEnc, sizeof( ec_enc ) );
166         silk_memcpy( &sNSQ_copy, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
167         seed_copy = psEnc->sCmn.indices.Seed;
168         ec_prevLagIndex_copy = psEnc->sCmn.ec_prevLagIndex;
169         ec_prevSignalType_copy = psEnc->sCmn.ec_prevSignalType;
170         ALLOC( ec_buf_copy, 1275, opus_uint8 );
171         for( iter = 0; ; iter++ ) {
172             if( gainsID == gainsID_lower ) {
173                 nBits = nBits_lower;
174             } else if( gainsID == gainsID_upper ) {
175                 nBits = nBits_upper;
176             } else {
177                 /* Restore part of the input state */
178                 if( iter > 0 ) {
179                     silk_memcpy( psRangeEnc, &sRangeEnc_copy, sizeof( ec_enc ) );
180                     silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy, sizeof( silk_nsq_state ) );
181                     psEnc->sCmn.indices.Seed = seed_copy;
182                     psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
183                     psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
184                 }
185
186                 /*****************************************/
187                 /* Noise shaping quantization            */
188                 /*****************************************/
189                 if( psEnc->sCmn.nStatesDelayedDecision > 1 || psEnc->sCmn.warping_Q16 > 0 ) {
190                     silk_NSQ_del_dec( &psEnc->sCmn, &psEnc->sCmn.sNSQ, &psEnc->sCmn.indices, x_frame, psEnc->sCmn.pulses,
191                            sEncCtrl.PredCoef_Q12[ 0 ], sEncCtrl.LTPCoef_Q14, sEncCtrl.AR_Q13, sEncCtrl.HarmShapeGain_Q14,
192                            sEncCtrl.Tilt_Q14, sEncCtrl.LF_shp_Q14, sEncCtrl.Gains_Q16, sEncCtrl.pitchL, sEncCtrl.Lambda_Q10, sEncCtrl.LTP_scale_Q14,
193                            psEnc->sCmn.arch );
194                 } else {
195                     silk_NSQ( &psEnc->sCmn, &psEnc->sCmn.sNSQ, &psEnc->sCmn.indices, x_frame, psEnc->sCmn.pulses,
196                             sEncCtrl.PredCoef_Q12[ 0 ], sEncCtrl.LTPCoef_Q14, sEncCtrl.AR_Q13, sEncCtrl.HarmShapeGain_Q14,
197                             sEncCtrl.Tilt_Q14, sEncCtrl.LF_shp_Q14, sEncCtrl.Gains_Q16, sEncCtrl.pitchL, sEncCtrl.Lambda_Q10, sEncCtrl.LTP_scale_Q14,
198                             psEnc->sCmn.arch);
199                 }
200
201                 /****************************************/
202                 /* Encode Parameters                    */
203                 /****************************************/
204                 silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );
205
206                 /****************************************/
207                 /* Encode Excitation Signal             */
208                 /****************************************/
209                 silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
210                     psEnc->sCmn.pulses, psEnc->sCmn.frame_length );
211
212                 nBits = ec_tell( psRangeEnc );
213
214                 if( useCBR == 0 && iter == 0 && nBits <= maxBits ) {
215                     break;
216                 }
217             }
218
219             if( iter == maxIter ) {
220                 if( found_lower && ( gainsID == gainsID_lower || nBits > maxBits ) ) {
221                     /* Restore output state from earlier iteration that did meet the bitrate budget */
222                     silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
223                     silk_assert( sRangeEnc_copy2.offs <= 1275 );
224                     silk_memcpy( psRangeEnc->buf, ec_buf_copy, sRangeEnc_copy2.offs );
225                     silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy2, sizeof( silk_nsq_state ) );
226                     psEnc->sShape.LastGainIndex = LastGainIndex_copy2;
227                 }
228                 break;
229             }
230
231             if( nBits > maxBits ) {
232                 if( found_lower == 0 && iter >= 2 ) {
233                     /* Adjust the quantizer's rate/distortion tradeoff and discard previous "upper" results */
234                     sEncCtrl.Lambda_Q10 = silk_ADD_RSHIFT32( sEncCtrl.Lambda_Q10, sEncCtrl.Lambda_Q10, 1 );
235                     found_upper = 0;
236                     gainsID_upper = -1;
237                 } else {
238                     found_upper = 1;
239                     nBits_upper = nBits;
240                     gainMult_upper = gainMult_Q8;
241                     gainsID_upper = gainsID;
242                 }
243             } else if( nBits < maxBits - 5 ) {
244                 found_lower = 1;
245                 nBits_lower = nBits;
246                 gainMult_lower = gainMult_Q8;
247                 if( gainsID != gainsID_lower ) {
248                     gainsID_lower = gainsID;
249                     /* Copy part of the output state */
250                     silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
251                     silk_assert( psRangeEnc->offs <= 1275 );
252                     silk_memcpy( ec_buf_copy, psRangeEnc->buf, psRangeEnc->offs );
253                     silk_memcpy( &sNSQ_copy2, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
254                     LastGainIndex_copy2 = psEnc->sShape.LastGainIndex;
255                 }
256             } else {
257                 /* Within 5 bits of budget: close enough */
258                 break;
259             }
260
261             if( ( found_lower & found_upper ) == 0 ) {
262                 /* Adjust gain according to high-rate rate/distortion curve */
263                 opus_int32 gain_factor_Q16;
264                 gain_factor_Q16 = silk_log2lin( silk_LSHIFT( nBits - maxBits, 7 ) / psEnc->sCmn.frame_length + SILK_FIX_CONST( 16, 7 ) );
265                 gain_factor_Q16 = silk_min_32( gain_factor_Q16, SILK_FIX_CONST( 2, 16 ) );
266                 if( nBits > maxBits ) {
267                     gain_factor_Q16 = silk_max_32( gain_factor_Q16, SILK_FIX_CONST( 1.3, 16 ) );
268                 }
269                 gainMult_Q8 = silk_SMULWB( gain_factor_Q16, gainMult_Q8 );
270             } else {
271                 /* Adjust gain by interpolating */
272                 gainMult_Q8 = gainMult_lower + silk_DIV32_16( silk_MUL( gainMult_upper - gainMult_lower, maxBits - nBits_lower ), nBits_upper - nBits_lower );
273                 /* New gain multplier must be between 25% and 75% of old range (note that gainMult_upper < gainMult_lower) */
274                 if( gainMult_Q8 > silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 ) ) {
275                     gainMult_Q8 = silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 );
276                 } else
277                 if( gainMult_Q8 < silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 ) ) {
278                     gainMult_Q8 = silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 );
279                 }
280             }
281
282             for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
283                 sEncCtrl.Gains_Q16[ i ] = silk_LSHIFT_SAT32( silk_SMULWB( sEncCtrl.GainsUnq_Q16[ i ], gainMult_Q8 ), 8 );
284             }
285
286             /* Quantize gains */
287             psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
288             silk_gains_quant( psEnc->sCmn.indices.GainsIndices, sEncCtrl.Gains_Q16,
289                   &psEnc->sShape.LastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
290
291             /* Unique identifier of gains vector */
292             gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );
293         }
294     }
295
296     /* Update input buffer */
297     silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
298         ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( opus_int16 ) );
299
300     /* Exit without entropy coding */
301     if( psEnc->sCmn.prefillFlag ) {
302         /* No payload */
303         *pnBytesOut = 0;
304         RESTORE_STACK;
305         return ret;
306     }
307
308     /* Parameters needed for next frame */
309     psEnc->sCmn.prevLag        = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];
310     psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType;
311
312     /****************************************/
313     /* Finalize payload                     */
314     /****************************************/
315     psEnc->sCmn.first_frame_after_reset = 0;
316     /* Payload size */
317     *pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
318
319     RESTORE_STACK;
320     return ret;
321 }
322
323 /* Low-Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode excitation at lower bitrate  */
324 static OPUS_INLINE void silk_LBRR_encode_FIX(
325     silk_encoder_state_FIX          *psEnc,                                 /* I/O  Pointer to Silk FIX encoder state                                           */
326     silk_encoder_control_FIX        *psEncCtrl,                             /* I/O  Pointer to Silk FIX encoder control struct                                  */
327     const opus_int16                x16[],                                  /* I    Input signal                                                                */
328     opus_int                        condCoding                              /* I    The type of conditional coding used so far for this frame                   */
329 )
330 {
331     opus_int32   TempGains_Q16[ MAX_NB_SUBFR ];
332     SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];
333     silk_nsq_state sNSQ_LBRR;
334
335     /*******************************************/
336     /* Control use of inband LBRR              */
337     /*******************************************/
338     if( psEnc->sCmn.LBRR_enabled && psEnc->sCmn.speech_activity_Q8 > SILK_FIX_CONST( LBRR_SPEECH_ACTIVITY_THRES, 8 ) ) {
339         psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
340
341         /* Copy noise shaping quantizer state and quantization indices from regular encoding */
342         silk_memcpy( &sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
343         silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
344
345         /* Save original gains */
346         silk_memcpy( TempGains_Q16, psEncCtrl->Gains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );
347
348         if( psEnc->sCmn.nFramesEncoded == 0 || psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) {
349             /* First frame in packet or previous frame not LBRR coded */
350             psEnc->sCmn.LBRRprevLastGainIndex = psEnc->sShape.LastGainIndex;
351
352             /* Increase Gains to get target LBRR rate */
353             psIndices_LBRR->GainsIndices[ 0 ] = psIndices_LBRR->GainsIndices[ 0 ] + psEnc->sCmn.LBRR_GainIncreases;
354             psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
355         }
356
357         /* Decode to get gains in sync with decoder         */
358         /* Overwrite unquantized gains with quantized gains */
359         silk_gains_dequant( psEncCtrl->Gains_Q16, psIndices_LBRR->GainsIndices,
360             &psEnc->sCmn.LBRRprevLastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
361
362         /*****************************************/
363         /* Noise shaping quantization            */
364         /*****************************************/
365         if( psEnc->sCmn.nStatesDelayedDecision > 1 || psEnc->sCmn.warping_Q16 > 0 ) {
366             silk_NSQ_del_dec( &psEnc->sCmn, &sNSQ_LBRR, psIndices_LBRR, x16,
367                 psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], psEncCtrl->PredCoef_Q12[ 0 ], psEncCtrl->LTPCoef_Q14,
368                 psEncCtrl->AR_Q13, psEncCtrl->HarmShapeGain_Q14, psEncCtrl->Tilt_Q14, psEncCtrl->LF_shp_Q14,
369                 psEncCtrl->Gains_Q16, psEncCtrl->pitchL, psEncCtrl->Lambda_Q10, psEncCtrl->LTP_scale_Q14, psEnc->sCmn.arch );
370         } else {
371             silk_NSQ( &psEnc->sCmn, &sNSQ_LBRR, psIndices_LBRR, x16,
372                 psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], psEncCtrl->PredCoef_Q12[ 0 ], psEncCtrl->LTPCoef_Q14,
373                 psEncCtrl->AR_Q13, psEncCtrl->HarmShapeGain_Q14, psEncCtrl->Tilt_Q14, psEncCtrl->LF_shp_Q14,
374                 psEncCtrl->Gains_Q16, psEncCtrl->pitchL, psEncCtrl->Lambda_Q10, psEncCtrl->LTP_scale_Q14, psEnc->sCmn.arch );
375         }
376
377         /* Restore original gains */
378         silk_memcpy( psEncCtrl->Gains_Q16, TempGains_Q16, psEnc->sCmn.nb_subfr * sizeof( opus_int32 ) );
379     }
380 }