SILK update
[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 \r
92     SKP_memset( pulses_comb, 0, 8 * sizeof( SKP_int ) ); // Fixing Valgrind reported problem\r
93 \r
94     /****************************/\r
95     /* Prepare for shell coding */\r
96     /****************************/\r
97     /* Calculate number of shell blocks */\r
98     SKP_assert( 1 << LOG2_SHELL_CODEC_FRAME_LENGTH == SHELL_CODEC_FRAME_LENGTH );\r
99     iter = SKP_RSHIFT( frame_length, LOG2_SHELL_CODEC_FRAME_LENGTH );\r
100     if( iter * SHELL_CODEC_FRAME_LENGTH < frame_length ){\r
101         SKP_assert( frame_length == 12 * 10 ); /* Make sure only happens for 10 ms @ 12 kHz */\r
102         iter++;\r
103         SKP_memset( &q[ frame_length ], 0, SHELL_CODEC_FRAME_LENGTH * sizeof(SKP_int8));\r
104     }\r
105 \r
106     /* Take the absolute value of the pulses */\r
107     for( i = 0; i < iter * SHELL_CODEC_FRAME_LENGTH; i+=4 ) {\r
108         abs_pulses[i+0] = ( SKP_int )SKP_abs( q[ i + 0 ] );\r
109         abs_pulses[i+1] = ( SKP_int )SKP_abs( q[ i + 1 ] );\r
110         abs_pulses[i+2] = ( SKP_int )SKP_abs( q[ i + 2 ] );\r
111         abs_pulses[i+3] = ( SKP_int )SKP_abs( q[ i + 3 ] );\r
112     }\r
113 \r
114     /* Calc sum pulses per shell code frame */\r
115     abs_pulses_ptr = abs_pulses;\r
116     for( i = 0; i < iter; i++ ) {\r
117         nRshifts[ i ] = 0;\r
118 \r
119         while( 1 ) {\r
120             /* 1+1 -> 2 */\r
121             scale_down = combine_and_check( pulses_comb, abs_pulses_ptr, SKP_Silk_max_pulses_table[ 0 ], 8 );\r
122 \r
123             /* 2+2 -> 4 */\r
124             scale_down += combine_and_check( pulses_comb, pulses_comb, SKP_Silk_max_pulses_table[ 1 ], 4 );\r
125 \r
126             /* 4+4 -> 8 */\r
127             scale_down += combine_and_check( pulses_comb, pulses_comb, SKP_Silk_max_pulses_table[ 2 ], 2 );\r
128 \r
129             /* 8+8 -> 16 */\r
130             sum_pulses[ i ] = pulses_comb[ 0 ] + pulses_comb[ 1 ];\r
131             if( sum_pulses[ i ] > SKP_Silk_max_pulses_table[ 3 ] ) {\r
132                 scale_down++;\r
133             }\r
134 \r
135             if( scale_down ) {\r
136                 /* We need to down scale the quantization signal */\r
137                 nRshifts[ i ]++;                \r
138                 for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {\r
139                     abs_pulses_ptr[ k ] = SKP_RSHIFT( abs_pulses_ptr[ k ], 1 );\r
140                 }\r
141             } else {\r
142                 /* Jump out of while(1) loop and go to next shell coding frame */\r
143                 break;\r
144             }\r
145         }\r
146         abs_pulses_ptr += SHELL_CODEC_FRAME_LENGTH;\r
147     }\r
148 \r
149     /**************/\r
150     /* Rate level */\r
151     /**************/\r
152     /* find rate level that leads to fewest bits for coding of pulses per block info */\r
153     minSumBits_Q6 = SKP_int32_MAX;\r
154     for( k = 0; k < N_RATE_LEVELS - 1; k++ ) {\r
155         nBits_ptr  = SKP_Silk_pulses_per_block_BITS_Q6[ k ];\r
156         sumBits_Q6 = SKP_Silk_rate_levels_BITS_Q6[sigtype][ k ];\r
157         for( i = 0; i < iter; i++ ) {\r
158             if( nRshifts[ i ] > 0 ) {\r
159                 sumBits_Q6 += nBits_ptr[ MAX_PULSES + 1 ];\r
160             } else {\r
161                 sumBits_Q6 += nBits_ptr[ sum_pulses[ i ] ];\r
162             }\r
163         }\r
164         if( sumBits_Q6 < minSumBits_Q6 ) {\r
165             minSumBits_Q6 = sumBits_Q6;\r
166             RateLevelIndex = k;\r
167         }\r
168     }\r
169     ec_encode_bin( psRangeEnc, SKP_Silk_rate_levels_CDF[ sigtype ][ RateLevelIndex ], \r
170         SKP_Silk_rate_levels_CDF[ sigtype ][ RateLevelIndex + 1 ], 16 );\r
171 \r
172     /***************************************************/\r
173     /* Sum-Weighted-Pulses Encoding                    */\r
174     /***************************************************/\r
175     cdf_ptr = SKP_Silk_pulses_per_block_CDF[ RateLevelIndex ];\r
176     for( i = 0; i < iter; i++ ) {\r
177         if( nRshifts[ i ] == 0 ) {\r
178             ec_encode_bin( psRangeEnc, cdf_ptr[ sum_pulses[ i ] ], cdf_ptr[ sum_pulses[ i ] + 1 ], 16 );\r
179         } else {\r
180             ec_encode_bin( psRangeEnc, cdf_ptr[ MAX_PULSES + 1 ], cdf_ptr[ MAX_PULSES + 2 ], 16 );\r
181             for( k = 0; k < nRshifts[ i ] - 1; k++ ) {\r
182                 ec_encode_bin( psRangeEnc, SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ][ MAX_PULSES + 1 ], \r
183                     SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ][ MAX_PULSES + 2 ], 16 );\r
184             }\r
185             ec_encode_bin( psRangeEnc, SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ][ sum_pulses[ i ] ], \r
186                 SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ][ sum_pulses[ i ] + 1 ], 16 );\r
187         }\r
188     }\r
189 \r
190     /******************/\r
191     /* Shell Encoding */\r
192     /******************/\r
193     for( i = 0; i < iter; i++ ) {\r
194         if( sum_pulses[ i ] > 0 ) {\r
195             SKP_Silk_shell_encoder( psRangeEnc, &abs_pulses[ i * SHELL_CODEC_FRAME_LENGTH ] );\r
196         }\r
197     }\r
198 \r
199     /****************/\r
200     /* LSB Encoding */\r
201     /****************/\r
202     for( i = 0; i < iter; i++ ) {\r
203         if( nRshifts[ i ] > 0 ) {\r
204             pulses_ptr = &q[ i * SHELL_CODEC_FRAME_LENGTH ];\r
205             nLS = nRshifts[ i ] - 1;\r
206             for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {\r
207                 abs_q = (SKP_int8)SKP_abs( pulses_ptr[ k ] );\r
208                 for( j = nLS; j > 0; j-- ) {\r
209                     bit = SKP_RSHIFT( abs_q, j ) & 1;\r
210                     ec_enc_bit_prob( psRangeEnc, bit, 65536 - SKP_Silk_lsb_CDF[ 1 ] );\r
211                 }\r
212                 bit = abs_q & 1;\r
213                 ec_enc_bit_prob( psRangeEnc, bit, 65536 - SKP_Silk_lsb_CDF[ 1 ] );\r
214             }\r
215         }\r
216     }\r
217 \r
218 #if! USE_CELT_PVQ\r
219     /****************/\r
220     /* Encode signs */\r
221     /****************/\r
222     SKP_Silk_encode_signs( psRangeEnc, q, frame_length, sigtype, QuantOffsetType, RateLevelIndex );\r
223 #endif\r
224 }\r