Fixing silk fixed point
[opus.git] / silk / silk_shell_coder.c
1 /***********************************************************************\r
2 Copyright (c) 2006-2011, 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 "silk_main.h"\r
29 \r
30 /* shell coder; pulse-subframe length is hardcoded */\r
31 \r
32 SKP_INLINE void combine_pulses(\r
33     SKP_int         *out,   /* O:   combined pulses vector [len] */\r
34     const SKP_int   *in,    /* I:   input vector       [2 * len] */\r
35     const SKP_int   len     /* I:   number of OUTPUT samples     */\r
36 )\r
37 {\r
38     SKP_int k;\r
39     for( k = 0; k < len; k++ ) {\r
40         out[ k ] = in[ 2 * k ] + in[ 2 * k + 1 ];\r
41     }\r
42 }\r
43 \r
44 SKP_INLINE void encode_split(\r
45     ec_enc                      *psRangeEnc,    /* I/O  compressor data structure                   */\r
46     const SKP_int               p_child1,       /* I:   pulse amplitude of first child subframe     */\r
47     const SKP_int               p,              /* I:   pulse amplitude of current subframe         */\r
48     const SKP_uint8             *shell_table    /* I:   table of shell cdfs                         */\r
49 )\r
50 {\r
51     if( p > 0 ) {\r
52         ec_enc_icdf( psRangeEnc, p_child1, &shell_table[ silk_shell_code_table_offsets[ p ] ], 8 );\r
53     }\r
54 }\r
55 \r
56 SKP_INLINE void decode_split(\r
57     SKP_int                     *p_child1,      /* O:   pulse amplitude of first child subframe     */\r
58     SKP_int                     *p_child2,      /* O:   pulse amplitude of second child subframe    */\r
59     ec_dec                      *psRangeDec,    /* I/O  Compressor data structure                   */\r
60     const SKP_int               p,              /* I:   pulse amplitude of current subframe         */\r
61     const SKP_uint8             *shell_table    /* I:   table of shell cdfs                         */\r
62 )\r
63 {\r
64     if( p > 0 ) {\r
65         p_child1[ 0 ] = ec_dec_icdf( psRangeDec, &shell_table[ silk_shell_code_table_offsets[ p ] ], 8 );\r
66         p_child2[ 0 ] = p - p_child1[ 0 ];\r
67     } else {\r
68         p_child1[ 0 ] = 0;\r
69         p_child2[ 0 ] = 0;\r
70     }\r
71 }\r
72 \r
73 /* Shell encoder, operates on one shell code frame of 16 pulses */\r
74 void silk_shell_encoder(\r
75     ec_enc                      *psRangeEnc,        /* I/O  compressor data structure                   */\r
76     const SKP_int               *pulses0            /* I    data: nonnegative pulse amplitudes          */\r
77 )\r
78 {\r
79     SKP_int pulses1[ 8 ], pulses2[ 4 ], pulses3[ 2 ], pulses4[ 1 ];\r
80 \r
81     /* this function operates on one shell code frame of 16 pulses */\r
82     SKP_assert( SHELL_CODEC_FRAME_LENGTH == 16 );\r
83 \r
84     /* tree representation per pulse-subframe */\r
85     combine_pulses( pulses1, pulses0, 8 );\r
86     combine_pulses( pulses2, pulses1, 4 );\r
87     combine_pulses( pulses3, pulses2, 2 );\r
88     combine_pulses( pulses4, pulses3, 1 );\r
89 \r
90     encode_split( psRangeEnc, pulses3[  0 ], pulses4[ 0 ], silk_shell_code_table3 );\r
91 \r
92     encode_split( psRangeEnc, pulses2[  0 ], pulses3[ 0 ], silk_shell_code_table2 );\r
93 \r
94     encode_split( psRangeEnc, pulses1[  0 ], pulses2[ 0 ], silk_shell_code_table1 );\r
95     encode_split( psRangeEnc, pulses0[  0 ], pulses1[ 0 ], silk_shell_code_table0 );\r
96     encode_split( psRangeEnc, pulses0[  2 ], pulses1[ 1 ], silk_shell_code_table0 );\r
97 \r
98     encode_split( psRangeEnc, pulses1[  2 ], pulses2[ 1 ], silk_shell_code_table1 );\r
99     encode_split( psRangeEnc, pulses0[  4 ], pulses1[ 2 ], silk_shell_code_table0 );\r
100     encode_split( psRangeEnc, pulses0[  6 ], pulses1[ 3 ], silk_shell_code_table0 );\r
101 \r
102     encode_split( psRangeEnc, pulses2[  2 ], pulses3[ 1 ], silk_shell_code_table2 );\r
103 \r
104     encode_split( psRangeEnc, pulses1[  4 ], pulses2[ 2 ], silk_shell_code_table1 );\r
105     encode_split( psRangeEnc, pulses0[  8 ], pulses1[ 4 ], silk_shell_code_table0 );\r
106     encode_split( psRangeEnc, pulses0[ 10 ], pulses1[ 5 ], silk_shell_code_table0 );\r
107 \r
108     encode_split( psRangeEnc, pulses1[  6 ], pulses2[ 3 ], silk_shell_code_table1 );\r
109     encode_split( psRangeEnc, pulses0[ 12 ], pulses1[ 6 ], silk_shell_code_table0 );\r
110     encode_split( psRangeEnc, pulses0[ 14 ], pulses1[ 7 ], silk_shell_code_table0 );\r
111 }\r
112 \r
113 \r
114 /* Shell decoder, operates on one shell code frame of 16 pulses */\r
115 void silk_shell_decoder(\r
116     SKP_int                         *pulses0,           /* O    data: nonnegative pulse amplitudes          */\r
117     ec_dec                          *psRangeDec,        /* I/O  Compressor data structure                   */\r
118     const SKP_int                   pulses4             /* I    number of pulses per pulse-subframe         */\r
119 )\r
120 {\r
121     SKP_int pulses3[ 2 ], pulses2[ 4 ], pulses1[ 8 ];\r
122 \r
123     /* this function operates on one shell code frame of 16 pulses */\r
124     SKP_assert( SHELL_CODEC_FRAME_LENGTH == 16 );\r
125 \r
126     decode_split( &pulses3[  0 ], &pulses3[  1 ], psRangeDec, pulses4,      silk_shell_code_table3 );\r
127 \r
128     decode_split( &pulses2[  0 ], &pulses2[  1 ], psRangeDec, pulses3[ 0 ], silk_shell_code_table2 );\r
129 \r
130     decode_split( &pulses1[  0 ], &pulses1[  1 ], psRangeDec, pulses2[ 0 ], silk_shell_code_table1 );\r
131     decode_split( &pulses0[  0 ], &pulses0[  1 ], psRangeDec, pulses1[ 0 ], silk_shell_code_table0 );\r
132     decode_split( &pulses0[  2 ], &pulses0[  3 ], psRangeDec, pulses1[ 1 ], silk_shell_code_table0 );\r
133 \r
134     decode_split( &pulses1[  2 ], &pulses1[  3 ], psRangeDec, pulses2[ 1 ], silk_shell_code_table1 );\r
135     decode_split( &pulses0[  4 ], &pulses0[  5 ], psRangeDec, pulses1[ 2 ], silk_shell_code_table0 );\r
136     decode_split( &pulses0[  6 ], &pulses0[  7 ], psRangeDec, pulses1[ 3 ], silk_shell_code_table0 );\r
137 \r
138     decode_split( &pulses2[  2 ], &pulses2[  3 ], psRangeDec, pulses3[ 1 ], silk_shell_code_table2 );\r
139 \r
140     decode_split( &pulses1[  4 ], &pulses1[  5 ], psRangeDec, pulses2[ 2 ], silk_shell_code_table1 );\r
141     decode_split( &pulses0[  8 ], &pulses0[  9 ], psRangeDec, pulses1[ 4 ], silk_shell_code_table0 );\r
142     decode_split( &pulses0[ 10 ], &pulses0[ 11 ], psRangeDec, pulses1[ 5 ], silk_shell_code_table0 );\r
143 \r
144     decode_split( &pulses1[  6 ], &pulses1[  7 ], psRangeDec, pulses2[ 3 ], silk_shell_code_table1 );\r
145     decode_split( &pulses0[ 12 ], &pulses0[ 13 ], psRangeDec, pulses1[ 6 ], silk_shell_code_table0 );\r
146     decode_split( &pulses0[ 14 ], &pulses0[ 15 ], psRangeDec, pulses1[ 7 ], silk_shell_code_table0 );\r
147 }\r