Fixes a high bit-rate corruption
[opus.git] / src_common / SKP_Silk_encode_pulses.c
1 /***********************************************************************\r
2 Copyright (c) 2006-2010, Skype Limited. All rights reserved. \r
3 Redistribution and use in source and binary forms, with or without \r
4 modification, (subject to the limitations in the disclaimer below) \r
5 are permitted provided that the following conditions are met:\r
6 - Redistributions of source code must retain the above copyright notice,\r
7 this list of conditions and the following disclaimer.\r
8 - Redistributions in binary form must reproduce the above copyright \r
9 notice, this list of conditions and the following disclaimer in the \r
10 documentation and/or other materials provided with the distribution.\r
11 - Neither the name of Skype Limited, nor the names of specific \r
12 contributors, may be used to endorse or promote products derived from \r
13 this software without specific prior written permission.\r
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
26 ***********************************************************************/\r
27 \r
28 #include "SKP_Silk_main.h"\r
29 \r
30 /* Tables generated with pyramid_combinations_generalized_tree.m  */\r
31 /* Pyramid L1 norm */\r
32 static const float PVQ_W_SIGNS_BITS[ 32 ] = \r
33 {\r
34      0.0000f,  5.0000f,  9.0000f, 12.4179f, 15.4263f, 18.1210f, 20.5637f, 22.7972f,\r
35     24.8536f, 26.7576f, 28.5290f, 30.1838f, 31.7353f, 33.1949f, 34.5719f, 35.8747f,\r
36     37.1102f, 38.2847f, 39.4034f, 40.4712f, 41.4922f, 42.4702f, 43.4083f, 44.3097f,\r
37     45.1769f, 46.0123f, 46.8181f, 47.5961f, 48.3483f, 49.0762f, 49.7813f, 50.4648f\r
38 };\r
39 \r
40 static const float PVQ_WO_SIGNS_BITS[ 32 ] = \r
41 {\r
42      0.0000f,  4.0000f,  7.0875f,  9.6724f, 11.9204f, 13.9204f, 15.7277f, 17.3798f, \r
43     18.9033f, 20.3184f, 21.6403f, 22.8813f, 24.0512f, 25.1582f, 26.2088f, 27.2088f, \r
44     28.1630f, 29.0755f, 29.9500f, 30.7895f, 31.5969f, 32.3745f, 33.1245f, 33.8489f, \r
45     34.5493f, 35.2274f, 35.8845f, 36.5219f, 37.1408f, 37.7423f, 38.3273f, 38.8966f\r
46 };\r
47 \r
48 /*********************************************/\r
49 /* Encode quantization indices of excitation */\r
50 /*********************************************/\r
51 \r
52 SKP_INLINE SKP_int combine_and_check(       /* return ok */\r
53     SKP_int         *pulses_comb,           /* O */\r
54     const SKP_int   *pulses_in,             /* I */\r
55     SKP_int         max_pulses,             /* I    max value for sum of pulses */\r
56     SKP_int         len                     /* I    number of output values */\r
57\r
58 {\r
59     SKP_int k, sum;\r
60 \r
61     for( k = 0; k < len; k++ ) {\r
62         sum = pulses_in[ 2 * k ] + pulses_in[ 2 * k + 1 ];\r
63         if( sum > max_pulses ) {\r
64             return 1;\r
65         }\r
66         pulses_comb[ k ] = sum;\r
67     }\r
68 \r
69     return 0;\r
70 }\r
71 \r
72 /* Encode quantization indices of excitation */\r
73 void SKP_Silk_encode_pulses(\r
74     ec_enc                      *psRangeEnc,        /* I/O  compressor data structure                   */\r
75     const SKP_int               sigtype,            /* I    Sigtype                                     */\r
76     const SKP_int               QuantOffsetType,    /* I    QuantOffsetType                             */\r
77     SKP_int8                    q[],                /* I    quantization indices                        */\r
78     const SKP_int               frame_length        /* I    Frame length                                */\r
79 )\r
80 {\r
81     SKP_int   i, k, j, iter, bit, nLS, scale_down, RateLevelIndex = 0;\r
82     SKP_int32 abs_q, minSumBits_Q6, sumBits_Q6;\r
83     SKP_int   abs_pulses[ MAX_FRAME_LENGTH ];\r
84     SKP_int   sum_pulses[ MAX_NB_SHELL_BLOCKS ];\r
85     SKP_int   nRshifts[   MAX_NB_SHELL_BLOCKS ];\r
86     SKP_int   pulses_comb[ 8 ];\r
87     SKP_int   *abs_pulses_ptr;\r
88     const SKP_int8 *pulses_ptr;\r
89     const SKP_uint16 *cdf_ptr;\r
90     const SKP_int16 *nBits_ptr;\r
91     //extern SKP_int nbits_extra;\r
92 \r
93     SKP_memset( pulses_comb, 0, 8 * sizeof( SKP_int ) ); // Fixing Valgrind reported problem\r
94 \r
95     /****************************/\r
96     /* Prepare for shell coding */\r
97     /****************************/\r
98     /* Calculate number of shell blocks */\r
99     SKP_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH );\r
100     iter = SKP_RSHIFT( frame_length, LOG2_SHELL_CODEC_FRAME_LENGTH );\r
101     if( iter * SHELL_CODEC_FRAME_LENGTH < frame_length ){\r
102         SKP_assert( frame_length == 12 * 10 ); /* Make sure only happens for 10 ms @ 12 kHz */\r
103         iter++;\r
104         SKP_memset( &q[ frame_length ], 0, SHELL_CODEC_FRAME_LENGTH * sizeof(SKP_int8));\r
105     }\r
106 \r
107     /* Take the absolute value of the pulses */\r
108     for( i = 0; i < iter * SHELL_CODEC_FRAME_LENGTH; i+=4 ) {\r
109         abs_pulses[i+0] = ( SKP_int )SKP_abs( q[ i + 0 ] );\r
110         abs_pulses[i+1] = ( SKP_int )SKP_abs( q[ i + 1 ] );\r
111         abs_pulses[i+2] = ( SKP_int )SKP_abs( q[ i + 2 ] );\r
112         abs_pulses[i+3] = ( SKP_int )SKP_abs( q[ i + 3 ] );\r
113     }\r
114 \r
115     /* Calc sum pulses per shell code frame */\r
116     abs_pulses_ptr = abs_pulses;\r
117     for( i = 0; i < iter; i++ ) {\r
118         nRshifts[ i ] = 0;\r
119 \r
120         while( 1 ) {\r
121             /* 1+1 -> 2 */\r
122             scale_down = combine_and_check( pulses_comb, abs_pulses_ptr, SKP_Silk_max_pulses_table[ 0 ], 8 );\r
123 \r
124             /* 2+2 -> 4 */\r
125             scale_down += combine_and_check( pulses_comb, pulses_comb, SKP_Silk_max_pulses_table[ 1 ], 4 );\r
126 \r
127             /* 4+4 -> 8 */\r
128             scale_down += combine_and_check( pulses_comb, pulses_comb, SKP_Silk_max_pulses_table[ 2 ], 2 );\r
129 \r
130             /* 8+8 -> 16 */\r
131             sum_pulses[ i ] = pulses_comb[ 0 ] + pulses_comb[ 1 ];\r
132             if( sum_pulses[ i ] > SKP_Silk_max_pulses_table[ 3 ] ) {\r
133                 scale_down++;\r
134             }\r
135 \r
136             if( scale_down ) {\r
137                 /* We need to down scale the quantization signal */\r
138                 nRshifts[ i ]++;                \r
139                 for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {\r
140                     abs_pulses_ptr[ k ] = SKP_RSHIFT( abs_pulses_ptr[ k ], 1 );\r
141                 }\r
142             } else {\r
143                 /* Jump out of while(1) loop and go to next shell coding frame */\r
144                 break;\r
145             }\r
146         }\r
147         abs_pulses_ptr += SHELL_CODEC_FRAME_LENGTH;\r
148     }\r
149 \r
150     /**************/\r
151     /* Rate level */\r
152     /**************/\r
153     /* find rate level that leads to fewest bits for coding of pulses per block info */\r
154     minSumBits_Q6 = SKP_int32_MAX;\r
155     for( k = 0; k < N_RATE_LEVELS - 1; k++ ) {\r
156         nBits_ptr  = SKP_Silk_pulses_per_block_BITS_Q6[ k ];\r
157         sumBits_Q6 = SKP_Silk_rate_levels_BITS_Q6[sigtype][ k ];\r
158         for( i = 0; i < iter; i++ ) {\r
159             if( nRshifts[ i ] > 0 ) {\r
160                 sumBits_Q6 += nBits_ptr[ MAX_PULSES + 1 ];\r
161             } else {\r
162                 sumBits_Q6 += nBits_ptr[ sum_pulses[ i ] ];\r
163             }\r
164         }\r
165         if( sumBits_Q6 < minSumBits_Q6 ) {\r
166             minSumBits_Q6 = sumBits_Q6;\r
167             RateLevelIndex = k;\r
168         }\r
169     }\r
170     ec_encode_bin( psRangeEnc, SKP_Silk_rate_levels_CDF[ sigtype ][ RateLevelIndex ], \r
171         SKP_Silk_rate_levels_CDF[ sigtype ][ RateLevelIndex + 1 ], 16 );\r
172 \r
173     /***************************************************/\r
174     /* Sum-Weighted-Pulses Encoding                    */\r
175     /***************************************************/\r
176     cdf_ptr = SKP_Silk_pulses_per_block_CDF[ RateLevelIndex ];\r
177     for( i = 0; i < iter; i++ ) {\r
178         if( nRshifts[ i ] == 0 ) {\r
179             ec_encode_bin( psRangeEnc, cdf_ptr[ sum_pulses[ i ] ], cdf_ptr[ sum_pulses[ i ] + 1 ], 16 );\r
180         } else {\r
181             ec_encode_bin( psRangeEnc, cdf_ptr[ MAX_PULSES + 1 ], cdf_ptr[ MAX_PULSES + 2 ], 16 );\r
182             for( k = 0; k < nRshifts[ i ] - 1; k++ ) {\r
183                 ec_encode_bin( psRangeEnc, SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ][ MAX_PULSES + 1 ], \r
184                     SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ][ MAX_PULSES + 2 ], 16 );\r
185             }\r
186             ec_encode_bin( psRangeEnc, SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ][ sum_pulses[ i ] ], \r
187                 SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ][ sum_pulses[ i ] + 1 ], 16 );\r
188         }\r
189     }\r
190 \r
191     /******************/\r
192     /* Shell Encoding */\r
193     /******************/\r
194     for( i = 0; i < iter; i++ ) {\r
195         if( sum_pulses[ i ] > 0 ) {\r
196             SKP_Silk_shell_encoder( psRangeEnc, &abs_pulses[ i * SHELL_CODEC_FRAME_LENGTH ] );\r
197         }\r
198     }\r
199 \r
200     /****************/\r
201     /* LSB Encoding */\r
202     /****************/\r
203     for( i = 0; i < iter; i++ ) {\r
204         if( nRshifts[ i ] > 0 ) {\r
205             pulses_ptr = &q[ i * SHELL_CODEC_FRAME_LENGTH ];\r
206             nLS = nRshifts[ i ] - 1;\r
207             for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {\r
208                 abs_q = (SKP_int8)SKP_abs( pulses_ptr[ k ] );\r
209                 for( j = nLS; j > 0; j-- ) {\r
210                     bit = SKP_RSHIFT( abs_q, j ) & 1;\r
211                     ec_enc_bit_prob( psRangeEnc, bit, 65536 - SKP_Silk_lsb_CDF[ 1 ] );\r
212                 }\r
213                 bit = abs_q & 1;\r
214                 ec_enc_bit_prob( psRangeEnc, bit, 65536 - SKP_Silk_lsb_CDF[ 1 ] );\r
215             }\r
216         }\r
217     }\r
218 \r
219 #if! USE_CELT_PVQ\r
220     /****************/\r
221     /* Encode signs */\r
222     /****************/\r
223     SKP_Silk_encode_signs( psRangeEnc, q, frame_length, sigtype, QuantOffsetType, RateLevelIndex );\r
224 #endif\r
225 }\r