Initial Skype commit taken from FreeSwitch, which got it from the IETF draft.
[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     SKP_Silk_range_coder_state      *psRC,          /* I/O  Range coder state               */\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     SKP_Silk_range_encoder( psRC, RateLevelIndex, SKP_Silk_rate_levels_CDF[ sigtype ] );\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             SKP_Silk_range_encoder( psRC, sum_pulses[ i ], cdf_ptr );\r
179         } else {\r
180             SKP_Silk_range_encoder( psRC, MAX_PULSES + 1, cdf_ptr );\r
181             for( k = 0; k < nRshifts[ i ] - 1; k++ ) {\r
182                 SKP_Silk_range_encoder( psRC, MAX_PULSES + 1, SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ] );\r
183             }\r
184             SKP_Silk_range_encoder( psRC, sum_pulses[ i ], SKP_Silk_pulses_per_block_CDF[ N_RATE_LEVELS - 1 ] );\r
185         }\r
186     }\r
187 \r
188     /******************/\r
189     /* Shell Encoding */\r
190     /******************/\r
191     for( i = 0; i < iter; i++ ) {\r
192         if( sum_pulses[ i ] > 0 ) {\r
193             SKP_Silk_shell_encoder( psRC, &abs_pulses[ i * SHELL_CODEC_FRAME_LENGTH ] );\r
194         }\r
195     }\r
196 \r
197     /****************/\r
198     /* LSB Encoding */\r
199     /****************/\r
200     for( i = 0; i < iter; i++ ) {\r
201         if( nRshifts[ i ] > 0 ) {\r
202             pulses_ptr = &q[ i * SHELL_CODEC_FRAME_LENGTH ];\r
203             nLS = nRshifts[ i ] - 1;\r
204             for( k = 0; k < SHELL_CODEC_FRAME_LENGTH; k++ ) {\r
205                 abs_q = (SKP_int8)SKP_abs( pulses_ptr[ k ] );\r
206                 for( j = nLS; j > 0; j-- ) {\r
207                     bit = SKP_RSHIFT( abs_q, j ) & 1;\r
208                     SKP_Silk_range_encoder( psRC, bit, SKP_Silk_lsb_CDF );\r
209                 }\r
210                 bit = abs_q & 1;\r
211                 SKP_Silk_range_encoder( psRC, bit, SKP_Silk_lsb_CDF );\r
212             }\r
213         }\r
214     }\r
215 \r
216 #if! USE_CELT_PVQ\r
217     /****************/\r
218     /* Encode signs */\r
219     /****************/\r
220     SKP_Silk_encode_signs( psRC, q, frame_length, sigtype, QuantOffsetType, RateLevelIndex );\r
221 #endif\r
222 }\r