avfilter/vf_histogram: add more color modes
[ffmpeg.git] / libavcodec / siren.c
1 /*
2  * Siren audio decoder
3  * Copyright (c) 2012 Youness Alaoui <kakaroto@kakaroto.homelinux.net>
4  * Copyright (c) 2018 Paul B Mahol
5  * Copyright (c) 2019 Lynne <dev@lynne.ee>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/tx.h"
26 #include "libavutil/float_dsp.h"
27 #include "libavutil/mem_internal.h"
28
29 #include "avcodec.h"
30 #include "get_bits.h"
31 #include "internal.h"
32 #include "mathops.h"
33
34 static const uint8_t index_table[8] = {4, 4, 3, 3, 2, 2, 1, 0};
35 static const uint8_t vector_dimension[8] = { 2, 2, 2, 4, 4, 5, 5, 1 };
36 static const uint8_t number_of_vectors[8] = { 10, 10, 10, 5, 5, 4, 4, 20 };
37 static const uint8_t expected_bits_table[8] = { 52, 47, 43, 37, 29, 22, 16, 0 };
38 static const int8_t differential_decoder_tree[27][24][2] = {
39     {
40         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {11, -12}, {-11, -10}, {-8, -9}, {-7, -6}, {-13, 12},
41         {-5, -4}, {0, 13}, {-3, -14}, {-2, 14}, {-1, 15}, {-15, 16}, {-16, 17}, {-17, 18}, {19, 20},
42         {21, 22}, {-18, -19}, {-20, -21}, {-22, -23}, {-32, -32}
43     },
44     {
45         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {-10, -9}, {-8, -11}, {-7, -6}, {9, -5}, {10, -12}, {-4, 11},
46         {-13, -3}, {12, -2}, {13, -14}, {-1, 14}, {15, -15}, {0, 16}, {-16, 17}, {-17, 18}, {-18, 19},
47         {20, 21},{22, -19}, {-20, -21}, {-22, -23}, {-32, -32}
48     },
49     {
50         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {-12, 11}, {-11, -13}, {-10, -9}, {12, -14}, {-8, -7},
51         {-15, -6}, {13, -5}, {-16, -4}, {14, -17}, {15, -3}, {16, -18}, {-2, 17}, {18, -19}, {-1, 19},
52         {-20, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}
53     },
54     {
55         {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {7, -12}, {8, -9}, {9, -13}, {-14, 10}, {-8, -15}, {-16, 11},
56         {-7, 12}, {-17, -6}, {13, 14}, {-18, 15}, {-5, -4}, {16, 17}, {-3, -2}, {-19, 18}, {-1, 19},
57         {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
58     },
59     {
60         {1, 2}, {3, 4}, {5, 6}, {-12, -11}, {-13, 7}, {8, -14}, {-10, 9}, {10, -15}, {-9, 11}, {-8, 12},
61         {-16, 13}, {-7, -6}, {-17, 14}, {-5, -18}, {15, -4}, {16, -19}, {17, -3}, {-20, 18}, {-2, 19},
62         {-21, 20}, {0, 21}, {22, -1}, {-22, -23}, {-32, -32}
63     },
64     {
65         {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-12, -10}, {-13, -9}, {8, 9}, {-14, -8}, {10, -15}, {-7, 11},
66         {-16, 12}, {-6, -17}, {13, 14}, {-5, 15}, {-18, 16}, {-4, 17}, {-3, -19}, {18, -2}, {-20, 19},
67         {-1, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}
68     },
69     {
70         {1, 2}, {3, 4}, {5, -12}, {6, -11}, {-10, -13}, {-9, 7}, {8, -14}, {9, -8}, {-15, 10}, {-7, -16},
71         {11, -6}, {12, -17}, {13, -5}, {-18, 14}, {15, -4}, {-19, 16}, {17, -3}, {-20, 18}, {19, 20},
72         {21, 22}, {0, -2}, {-1, -21}, {-22, -23}, {-32, -32}
73     },
74     {
75         {1, 2}, {3, 4}, {5, -12}, {6, -13}, {-11, -10}, {7, -14}, {8, -9}, {9, -15}, {-8, 10}, {-7, -16},
76         {11, 12}, {-6, -17}, {-5, 13}, {14, 15}, {-18, -4}, {-19, 16}, {-3, 17}, {18, -2}, {-20, 19},
77         {20, 21}, {22, 0}, {-1, -21}, {-22, -23}, {-32, -32}
78     },
79     {
80         {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {-12, -9}, {7, 8}, {-13, -8}, {9, -14}, {-7, 10}, {-6, -15},
81         {11, 12}, {-5, -16}, {13, 14}, {-17, 15}, {-4, 16}, {17, -18}, {18, -3}, {-2, 19}, {-1, 0},
82         {-19, 20}, {-20, 21}, {22, -21}, {-22, -23}, {-32, -32}
83     },
84     {
85         {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-10, -12}, {-9, 8}, {-8, -13}, {9, -7}, {10, -14}, {-6, 11},
86         {-15, 12}, {-5, 13}, {-16, -4}, {14, 15}, {-17, -3}, {-18, 16}, {17, -19}, {-2, 18}, {-20, 19},
87         {-1, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
88     },
89     {
90         {1, 2}, {3, 4}, {5, -12}, {6, -11}, {7, 8}, {-10, -13}, {-9, 9}, {-8, -14}, {10, -7}, {11, -15},
91         {-6, 12}, {-5, 13}, {-4, -16}, {14, 15}, {-3, -17}, {16, 17}, {-18, -2}, {18, -19}, {-1, 19},
92         {-20, 20}, {-21, 21}, {22, 0}, {-22, -23}, {-32, -32}
93     },
94     {
95         {1, 2}, {3, 4}, {5, -12}, {-13, 6}, {-11, 7}, {-14, 8}, {-10, 9}, {-15, -9}, {-8, 10}, {-7, -16},
96         {11, -6}, {12, -5}, {-17, 13}, {14, -18}, {15, -4}, {16, -19}, {17, -3}, {18, -2}, {19, -1},
97         {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
98     },
99     {
100         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
101         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
102         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
103     },
104     {
105         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
106         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
107         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
108     },
109     {
110         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
111         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
112         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
113     },
114     {
115         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
116         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
117         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
118     },
119     {
120         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
121         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
122         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
123     },
124     {
125         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
126         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
127         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
128     },
129     {
130         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
131         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
132         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
133     },
134     {
135         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
136         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
137         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
138     },
139     {
140         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
141         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
142         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
143     },
144     {
145         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
146         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
147         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
148     },
149     {
150         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
151         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
152         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
153     },
154     {
155         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
156         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
157         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
158     },
159     {
160         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
161         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
162         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
163     },
164     {
165         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
166         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
167         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
168     },
169     {
170         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
171         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
172         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
173     },
174 };
175
176 static const uint16_t decoder_tree0[360] = {
177     2, 1, 4, 6, 8, 10, 12, 14, 16, 18, 33, 3, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 35, 40,
178     42, 44, 46, 5, 48, 65, 50, 52, 54, 56, 58, 60, 62, 64, 37, 66, 67, 68, 97, 70, 72, 74, 7,
179     76, 78, 80, 82, 84, 86, 88, 99, 90, 39, 92, 94, 96, 129, 98, 9, 100, 102, 104, 106, 108,
180     110, 112, 41, 161, 69, 114, 116, 118, 131, 120, 122, 11, 124, 126, 128, 193, 130, 132, 71,
181     134, 43, 136, 138, 140, 163, 101, 13, 142, 144, 146, 148, 150, 152, 154, 225, 156, 158, 195,
182     160, 162, 45, 164, 15, 166, 73, 168, 170, 133, 47, 172, 257, 174, 176, 178, 75, 103, 180, 165,
183     182, 17, 227, 184, 105, 49, 135, 186, 289, 188, 259, 190, 192, 194, 196, 198, 291, 77, 200,
184     202, 197, 107, 204, 19, 51, 229, 206, 167, 208, 210, 212, 214, 21, 79, 81, 109, 216, 218, 220,
185     222, 53, 137, 224, 199, 226, 323, 321, 169, 228, 111, 230, 232, 139, 261, 234, 83, 236, 201,
186     238, 240, 293, 242, 353, 231, 141, 244, 246, 113, 23, 355, 85, 248, 55, 115, 250, 263, 252,
187     254, 203, 171, 256, 258, 233, 235, 143, 357, 325, 260, 295, 262, 173, 145, 177, 87, 264, 327,
188     267, 266, 268, 175, 270, 272, 117, 297, 274, 265, 147, 179, 205, 276, 207, 237, 269, 278, 57,
189     59, 387, 209, 280, 282, 149, 329, 385, 284, 25, 286, 239, 119, 288, 27, 290, 292, 299, 294, 359,
190     89, 296, 298, 419, 181, 300, 331, 271, 417, 211, 361, 151, 389, 241, 302, 304, 303, 306, 308,
191     421, 91, 310, 312, 391, 314, 121, 316, 333, 318, 275, 213, 301, 243, 183, 335, 320, 363, 322,
192     215, 324, 393, 273, 337, 153, 326, 423, 365, 328, 367, 247, 395, 185, 123, 330, 425, 245, 155,
193     332, 334, 305, 397, 336, 277, 217, 338, 340, 339, 427, 342, 344, 346, 307, 399, 187, 348, 309,
194     341, 350, 369, 279, 311, 429, 249, 219, 352, 354, 356, 358, 431, 373, 401, 371, 313, 281, 433,
195     343, 403, 251, 283
196 };
197
198 static const uint16_t decoder_tree1[188] = {
199     2, 1, 4, 6, 8, 10, 12, 14, 16, 3, 33, 18, 20, 22, 24, 26, 35, 28, 30, 32, 34, 36, 5, 65, 38, 40,
200     37, 42, 44, 46, 67, 48, 50, 52, 54, 56, 58, 60, 7, 62, 39, 97, 64, 69, 66, 99, 68, 70, 72, 74, 76,
201     78, 80, 129, 41, 131, 82, 9, 71, 84, 86, 101, 88, 90, 92, 94, 96, 161, 43, 11, 73, 98, 103, 100,
202     163, 102, 104, 106, 108, 133, 110, 105, 112, 75, 114, 45, 13, 116, 165, 118, 195, 135, 193, 120, 77,
203     122, 47, 124, 167, 225, 126, 79, 107, 227, 128, 137, 197, 15, 130, 169, 199, 132, 109, 134, 17, 139,
204     49, 136, 229, 138, 140, 81, 259, 142, 144, 171, 146, 141, 148, 111, 150, 201, 231, 152, 51, 257, 289,
205     154, 19, 113, 156, 261, 158, 203, 173, 263, 143, 160, 291, 235, 83, 162, 233, 265, 164, 205, 166, 293,
206     145, 168, 175, 177, 237, 115, 295, 170, 207, 172, 267, 174, 176, 297, 147, 178, 180, 269, 182, 271,
207     209, 299, 239, 179, 184, 301, 241, 211, 0, 0
208 };
209
210 static const uint16_t decoder_tree2[96] = {
211     2, 1, 4, 6, 8, 10, 12, 3, 17, 14, 19, 16, 18, 20, 22, 24, 26, 5, 21, 35, 33, 28, 30, 32, 34, 36, 38, 37,
212     40, 23, 51, 42, 7, 49, 44, 46, 48, 50, 39, 53, 52, 54, 56, 25, 67, 9, 58, 60, 65, 55, 41, 62, 64, 69, 66,
213     11, 27, 68, 57, 83, 70, 71, 81, 43, 72, 74, 13, 76, 85, 29, 73, 78, 99, 59, 87, 101, 80, 97, 45, 82, 84,
214     75, 89, 61, 86, 103, 88, 77, 90, 105, 91, 92, 107, 93, 0, 0
215 };
216
217 static const uint16_t decoder_tree3[1040] = {
218     2, 4, 6, 8, 10, 1, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 3, 36, 1025, 38, 40, 42, 44, 46, 48, 50,
219     129, 17, 52, 54, 1153, 19, 56, 58, 60, 62, 64, 66, 68, 145, 70, 72, 74, 76, 78, 1169, 1027, 147, 80, 82, 1171,
220     84, 86, 131, 88, 1155, 1043, 1041, 90, 92, 5, 94, 96, 98, 100, 102, 104, 21, 106, 108, 2049, 2177, 110, 112, 114,
221     116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 33, 144, 163, 146, 148, 150, 152, 154, 161,
222     156, 35, 158, 1297, 160, 162, 273, 257, 164, 166, 149, 168, 1281, 170, 172, 2193, 174, 176, 178, 1299, 180, 1045,
223     182, 184, 1173, 186, 3201, 188, 190, 192, 194, 2195, 1187, 23, 2179, 196, 7, 198, 275, 200, 2051, 202, 2065, 204,
224     206, 1029, 1185, 208, 210, 1157, 37, 3073, 2067, 133, 212, 214, 2321, 216, 165, 218, 1059, 220, 1283, 222, 2305,
225     224, 226, 228, 230, 259, 232, 234, 2323, 236, 1409, 1057, 1315, 238, 240, 242, 244, 246, 1425, 248, 1313, 250, 252,
226     254, 256, 258, 260, 289, 262, 264, 1189, 266, 268, 179, 151, 270, 272, 274, 276, 278, 291, 280, 282, 9, 385, 284,
227     286, 177, 49, 401, 1061, 288, 290, 292, 51, 294, 296, 298, 300, 302, 304, 25, 306, 2083, 39, 308, 310, 3329, 167,
228     312, 314, 1175, 316, 318, 1203, 135, 320, 322, 324, 326, 328, 2211, 2307, 330, 1301, 332, 334, 1047, 336, 338, 2449,
229     3217, 340, 1427, 2209, 53, 342, 2339, 3345, 344, 346, 348, 403, 181, 4097, 2197, 350, 2181, 1285, 1317, 1031, 352,
230     354, 356, 3089, 358, 360, 4225, 277, 362, 364, 366, 368, 2069, 370, 3203, 293, 1201, 305, 372, 3219, 307, 2433, 374,
231     376, 378, 380, 2081, 1411, 382, 384, 3075, 1443, 513, 386, 387, 388, 390, 1331, 261, 392, 394, 396, 398, 400, 1441,
232     1075, 67, 1159, 402, 404, 406, 408, 410, 412, 414, 3347, 2325, 416, 65, 418, 420, 422, 424, 426, 2053, 193, 1073, 428,
233     430, 432, 1537, 1329, 2337, 2213, 434, 417, 183, 41, 436, 438, 440, 442, 444, 446, 448, 450, 195, 2435, 452, 2085, 1063,
234     1191, 454, 456, 458, 460, 419, 2071, 1553, 3091, 55, 137, 462, 464, 466, 468, 470, 472, 474, 476, 478, 2309, 4113, 480,
235     482, 484, 486, 2451, 2465, 1205, 153, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518,
236     520, 522, 524, 1333, 526, 1555, 2467, 2227, 3205, 3331, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 529, 309,
237     1303, 3473, 3457, 389, 1569, 1445, 1077, 69, 2199, 1539, 4353, 550, 552, 554, 556, 558, 560, 562, 1459, 4241, 3221, 1429,
238     2341, 279, 3475, 169, 564, 545, 3105, 323, 2353, 2097, 3235, 421, 2229, 3107, 3233, 566, 568, 570, 572, 574, 576, 578,
239     580, 582, 584, 586, 588, 590, 592, 594, 596, 2099, 1091, 531, 2437, 4227, 405, 197, 263, 1287, 2577, 1049, 1571, 598, 600,
240     602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650,
241     1345, 1219, 3077, 1457, 2225, 2579, 515, 2561, 2469, 433, 1221, 2183, 4243, 652, 654, 656, 658, 660, 662, 664, 666, 668,
242     670, 1217, 3333, 3093, 435, 321, 4369, 1089, 2055, 4099, 3361, 1319, 547, 1161, 1177, 672, 2355, 4115, 1413, 4257, 3349,
243     2453, 3109, 2357, 2215, 3363, 1079, 1207, 311, 1033, 1347, 1065, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696,
244     698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746,
245     748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796,
246     798, 800, 802, 804, 806, 808, 810, 812, 814, 2593, 2565, 4261, 3253, 437, 325, 3489, 2311, 4259, 1431, 2087, 2563, 295, 2343,
247     449, 199, 265, 2201, 4371, 1193, 816, 533, 1557, 2581, 2241, 3365, 3491, 3603, 549, 2101, 1461, 1093, 2117, 3459, 3079, 4481,
248     3095, 2327, 3461, 4129, 3249, 1447, 2471, 2231, 71, 4497, 2609, 1289, 393, 3251, 2073, 3097, 2371, 1305, 2089, 818, 820, 822,
249     824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872,
250     874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922,
251     924, 926, 928, 930, 932, 934, 936, 938, 940, 942, 944, 946, 948, 950, 952, 954, 956, 958, 960, 962, 964, 966, 968, 970, 972,
252     974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018,
253     1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 4161, 4273, 3507, 3493, 4517, 2497, 1573, 2597, 3621, 4531, 4627, 3523,
254     3125, 4149, 4529, 3139, 4515, 451, 4277, 2113, 4163, 4499, 3381, 4405, 1473, 4373, 2485, 3509, 565, 1589, 2613, 3585, 3123,
255     4403, 3141, 4147, 563, 2245, 3269, 4357, 1349, 2373, 3397, 453, 1477, 2501, 2481, 579, 1601, 3477, 4103, 3265, 2243, 1587,
256     3207, 4231, 3267, 4501, 1475, 3335, 4359, 391, 1415, 2439, 3463, 4487, 519, 1543, 2567, 3591, 4609, 4289, 4611, 2499, 4119,
257     4385, 4145, 4401, 3223, 4247, 3379, 577, 3393, 3351, 4375, 407, 1585, 2455, 3479, 4503, 535, 1559, 2583, 3607, 3605, 4513,
258     4485, 3111, 4135, 3121, 517, 3377, 3239, 4263, 1541, 4291, 4229, 3367, 4391, 423, 2115, 4131, 3495, 551, 1575, 2599, 3635, 3395,
259     2103, 3127, 4151, 3589, 4101, 1603, 3255, 4279, 3601, 1335, 2359, 3383, 439, 1463, 2487, 3511, 567, 1591, 4133, 1095, 2119, 3143,
260     2369, 1223, 2247, 3271, 327, 1351, 2375, 455, 1479, 3137, 3521, 2057, 3081, 4105, 4387, 3505, 2185, 3209, 4233, 3587, 4355, 2313,
261     3337, 3237, 1417, 2441, 3465, 521, 1545, 3617, 3633, 561, 4625, 4121, 2611, 2483, 2595, 3225, 4249, 281, 4245, 2329, 3353, 409,
262     1433, 2457, 3481, 537, 1561, 4483, 3619, 4389, 3113, 4275, 4117, 2217, 3241, 297, 1321, 2345, 3369, 425, 1449, 2473, 57, 1081,
263     2105, 3129, 185, 1209, 2233, 3257, 313, 1337, 2361, 441, 1465, 73, 1097, 201, 1225, 0, 0
264 };
265
266 static const uint16_t decoder_tree4[416] = {
267     2, 4, 6, 1, 8, 10, 12, 14, 16, 18, 20, 22, 24, 3, 129, 26, 28, 9, 33, 30, 32,
268     34, 36, 11, 161, 38, 40, 42, 41, 44, 46, 131, 43, 169, 35, 48, 137, 50, 52, 54, 56, 139,
269     163, 171, 58, 60, 62, 64, 5, 66, 68, 70, 257, 72, 74, 76, 13, 78, 80, 289, 82, 84, 17,
270     86, 88, 65, 90, 201, 19, 92, 94, 51, 193, 96, 98, 49, 100, 73, 102, 104, 106, 45, 108, 110,
271     297, 112, 114, 116, 37, 203, 118, 120, 179, 122, 177, 124, 265, 126, 75, 133, 259, 291, 147, 128, 67,
272     195, 130, 141, 173, 299, 132, 145, 134, 165, 136, 138, 140, 142, 7, 144, 146, 21, 267, 148, 53, 150,
273     321, 152, 154, 15, 156, 81, 158, 160, 385, 162, 417, 164, 166, 168, 83, 170, 172, 329, 174, 211, 176,
274     27, 178, 180, 182, 209, 184, 186, 188, 190, 25, 192, 331, 194, 196, 105, 57, 198, 97, 200, 202, 323,
275     225, 59, 149, 204, 206, 233, 307, 208, 77, 181, 210, 212, 214, 216, 218, 220, 222, 47, 224, 226, 69,
276     228, 230, 197, 232, 425, 393, 205, 275, 293, 39, 234, 236, 238, 305, 135, 155, 301, 143, 240, 242, 235,
277     395, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 273, 269, 185, 264, 266, 268, 270, 272, 274, 276,
278     261, 153, 278, 280, 282, 187, 337, 387, 107, 284, 427, 227, 167, 419, 286, 288, 290, 292, 294, 296, 298,
279     300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 115,
280     99, 85, 213, 29, 113, 23, 89, 241, 61, 449, 339, 175, 340, 342, 344, 346, 348, 350, 352, 354, 356,
281     358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398,
282     400, 402, 404, 406, 408, 410, 412, 414, 389, 361, 457, 465, 429, 451, 333, 109, 277, 243, 263, 295, 199,
283     283, 151, 55, 183, 229, 357, 363, 123, 491, 397, 411, 251, 313, 441, 467, 345, 433, 461, 219, 237, 365,
284     435, 353, 347, 405, 409, 217, 309, 437, 369, 371, 341, 117, 245, 249, 157, 285, 403, 189, 317, 93, 221,
285     315, 401, 481, 391, 489, 121, 421, 423, 71, 483, 327, 103, 231, 443, 459, 271, 399, 355, 91, 303, 431,
286     79, 207, 335, 111, 239, 281, 325, 279, 453, 101, 311, 87, 215, 31, 159, 63, 191
287 };
288
289 static const uint16_t decoder_tree5[384] = {
290     2, 4, 1, 6, 8, 10, 12, 14, 16, 18, 20, 22, 3, 513, 24, 26, 28, 9, 129, 33, 30, 32, 34, 36, 38, 40, 11, 42, 641, 44, 46, 41,
291     161, 48, 515, 50, 52, 131, 54, 35, 545, 137, 56, 58, 60, 521, 62, 43, 673, 64, 169, 66, 68, 523, 70, 163, 643, 139, 553, 72, 649, 74, 547,
292     76, 78, 80, 681, 171, 82, 84, 555, 86, 675, 88, 651, 5, 90, 92, 1025, 94, 96, 98, 683, 13,
293     100, 17, 102, 104, 106, 65, 108, 110, 257, 112, 114, 1153, 19, 116, 118, 120, 122, 124, 49, 126, 128,
294     769, 289, 130, 132, 134, 73, 136, 138, 140, 142, 193, 144, 146, 148, 150, 152, 154, 517, 156, 158, 37,
295     51, 160, 201, 162, 145, 164, 166, 168, 133, 170, 801, 45, 172, 174, 1057, 176, 178, 67, 180, 1027, 577,
296     182, 184, 186, 188, 190, 192, 194, 196, 198, 259, 200, 202, 204, 525, 177, 265, 141, 206, 208, 210, 212,
297     195, 297, 214, 75, 216, 1033, 203, 585, 1155, 1185, 267, 1161, 549, 218, 220, 657, 777, 147, 222, 224, 226,
298     228, 230, 232, 234, 236, 238, 240, 587, 645, 165, 242, 244, 246, 248, 250, 771, 291, 252, 579, 1065, 1035,
299     705, 531, 529, 659, 173, 254, 561, 653, 256, 713, 677, 557, 258, 260, 262, 264, 266, 268, 270, 272, 274,
300     276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 707, 1059, 809, 715, 563, 179, 691, 1193,
301     21, 779, 1067, 299, 1187, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332,
302     334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374,
303     376, 378, 380, 83, 69, 1281, 803, 321, 1195, 1163, 811, 1323, 689, 1321, 1099, 305, 835, 1227, 331, 843, 785,
304     593, 1043, 1291, 1283, 1171, 275, 787, 1217, 833, 1075, 1313, 1219, 1203, 307, 819, 841, 595, 211, 723, 721, 817,
305     1029, 329, 81, 1157, 261, 773, 1097, 1089, 1061, 1169, 1091, 1189, 293, 805, 1201, 581, 197, 709, 1289, 273, 1037,
306     1315, 1041, 1165, 269, 781, 209, 1073, 1069, 323, 685, 1197, 301, 813, 77, 589, 205, 717, 1225, 533, 149, 661,
307     53, 565, 181, 693, 0, 0
308 };
309
310 static const uint16_t decoder_tree6[62] = {
311     2, 1, 4, 6, 8, 10, 12, 14, 16, 3, 33, 5, 17, 9, 18, 20, 22, 24, 26, 28, 30, 32, 34, 7, 49, 13, 25, 36, 38, 11,
312     21, 41, 35, 37, 19, 40, 42, 44, 46, 48, 50, 15, 52, 57, 29, 27, 23, 53, 54, 51, 39, 45, 43, 56, 58, 31, 55, 60,
313     61, 47, 59, 63
314 };
315
316 static const uint16_t *const decoder_tables[7] = {
317     decoder_tree0,
318     decoder_tree1,
319     decoder_tree2,
320     decoder_tree3,
321     decoder_tree4,
322     decoder_tree5,
323     decoder_tree6,
324 };
325
326 static const int decoder_tables_elements[7] = {
327     FF_ARRAY_ELEMS(decoder_tree0),
328     FF_ARRAY_ELEMS(decoder_tree1),
329     FF_ARRAY_ELEMS(decoder_tree2),
330     FF_ARRAY_ELEMS(decoder_tree3),
331     FF_ARRAY_ELEMS(decoder_tree4),
332     FF_ARRAY_ELEMS(decoder_tree5),
333     FF_ARRAY_ELEMS(decoder_tree6),
334 };
335
336 static const float mlt_quant[7][14] = {
337     { 0.0f, 0.392f, 0.761f, 1.120f, 1.477f, 1.832f, 2.183f, 2.541f, 2.893f, 3.245f, 3.598f, 3.942f, 4.288f, 4.724f },
338     { 0.0f, 0.544f, 1.060f, 1.563f, 2.068f, 2.571f, 3.072f, 3.562f, 4.070f, 4.620f, 0.0f, 0.0f, 0.0f, 0.0f },
339     { 0.0f, 0.746f, 1.464f, 2.180f, 2.882f, 3.584f, 4.316f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },
340     { 0.0f, 1.006f, 2.000f, 2.993f, 3.985f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },
341     { 0.0f, 1.321f, 2.703f, 3.983f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },
342     { 0.0f, 1.657f, 3.491f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },
343     { 0.0f, 1.964f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }
344 };
345
346 static const float noise_category5[21] = {
347     0.70711f, 0.6179f, 0.5005f, 0.3220f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f,
348     0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f
349 };
350
351 static const float noise_category6[21] = {
352     0.70711f, 0.5686f, 0.3563f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f,
353     0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f
354 };
355
356 #define FRAME_SIZE 320
357 #define REGION_SIZE 20
358
359 typedef struct SirenContext {
360     GetBitContext gb;
361
362     int microsoft;
363     int rate_control_possibilities;
364     int esf_adjustment;
365     int number_of_regions;
366     int scale_factor;
367     int sample_rate_bits;
368     int checksum_bits;
369
370     unsigned dw1, dw2, dw3, dw4;
371
372     int absolute_region_power_index[32];
373     float decoder_standard_deviation[32];
374     int power_categories[32];
375     int category_balance[32];
376     float standard_deviation[64];
377     float backup_frame[FRAME_SIZE];
378
379     AVFloatDSPContext *fdsp;
380     av_tx_fn           tx_fn;
381     AVTXContext       *tx_ctx;
382
383     DECLARE_ALIGNED(32, float, imdct_buf)[4][FRAME_SIZE];
384     float          *window;
385     float          *imdct_in;
386     float          *imdct_out;
387     float          *imdct_prev;
388 } SirenContext;
389
390 static av_cold int siren_init(AVCodecContext *avctx)
391 {
392     const float scale = 1.0f / (22.f * 32768.f);
393     SirenContext *s = avctx->priv_data;
394     int i;
395
396     s->imdct_in   = s->imdct_buf[0];
397     s->imdct_out  = s->imdct_buf[1];
398     s->imdct_prev = s->imdct_buf[2];
399     s->window     = s->imdct_buf[3];
400
401     avctx->channels       = 1;
402     avctx->channel_layout = AV_CH_LAYOUT_MONO;
403     avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;
404
405     s->rate_control_possibilities = 16;
406     s->esf_adjustment = 7;
407     s->number_of_regions = 14;
408     s->scale_factor = 22;
409     s->dw1 = s->dw2 = s->dw3 = s->dw4 = 1;
410
411     for (i = 0; i < 64; i++) {
412         float region_power = powf(10, (i - 24) * 0.3010299957);
413
414         s->standard_deviation[i] = sqrtf(region_power);
415     }
416
417     for (i = 0; i < FRAME_SIZE; i++) {
418         float angle = ((i + 0.5f) * M_PI_2) / 320.f;
419         s->window[i] = sinf(angle);
420     }
421
422     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
423     if (!s->fdsp)
424         return AVERROR(ENOMEM);
425
426     s->microsoft = avctx->codec->id == AV_CODEC_ID_MSNSIREN;
427     if (s->microsoft) {
428         s->esf_adjustment = -2;
429         s->number_of_regions = 14;
430         s->scale_factor = 1;
431         s->sample_rate_bits = 2;
432         s->checksum_bits = 4;
433     }
434
435     return av_tx_init(&s->tx_ctx, &s->tx_fn, AV_TX_FLOAT_MDCT, 1, FRAME_SIZE, &scale, 0);
436 }
437
438 static int decode_envelope(SirenContext *s, GetBitContext *gb,
439                            int number_of_regions, float *decoder_standard_deviation,
440                            int *absolute_region_power_index, int esf_adjustment)
441 {
442     absolute_region_power_index[0] = (int)get_bits(gb, 5) - esf_adjustment;
443     absolute_region_power_index[0] = av_clip(absolute_region_power_index[0], -24, 39);
444     decoder_standard_deviation[0] = s->standard_deviation[absolute_region_power_index[0] + 24];
445
446     for (int i = 1; i < number_of_regions; i++) {
447         int index = 0;
448
449         do {
450             index = differential_decoder_tree[i - 1][index][get_bits1(gb)];
451         } while (index > 0);
452
453         absolute_region_power_index[i] = av_clip(absolute_region_power_index[i - 1] - index - 12, -24, 39);
454         decoder_standard_deviation[i] = s->standard_deviation[absolute_region_power_index[i] + 24];
455     }
456
457     return get_bits_count(gb);
458 }
459
460 static int categorize_regions(int number_of_regions, int number_of_available_bits,
461                               int *absolute_region_power_index, int *power_categories,
462                               int *category_balance)
463 {
464     int region, delta, i, temp;
465     int expected_number_of_code_bits;
466     int min, max;
467     int offset, num_rate_control_possibilities = 16,
468         raw_value, raw_max_idx = 0, raw_min_idx = 0;
469     int max_rate_categories[28];
470     int min_rate_categories[28];
471     int temp_category_balances[64];
472     int *min_rate_ptr = NULL;
473     int *max_rate_ptr = NULL;
474
475     offset = -32;
476     for (delta = 32; number_of_regions > 0 && delta > 0; delta /= 2) {
477         expected_number_of_code_bits = 0;
478         for (region = 0; region < number_of_regions; region++) {
479             i = (delta + offset -
480                  absolute_region_power_index[region]) >> 1;
481             i = av_clip_uintp2(i, 3);
482             power_categories[region] = i;
483             expected_number_of_code_bits += expected_bits_table[i];
484
485         }
486         if (expected_number_of_code_bits >= number_of_available_bits - 32)
487             offset += delta;
488     }
489
490     expected_number_of_code_bits = 0;
491     for (region = 0; region < number_of_regions; region++) {
492         i = (offset - absolute_region_power_index[region]) >> 1;
493         i = av_clip_uintp2(i, 3);
494         max_rate_categories[region] = min_rate_categories[region] =
495             power_categories[region] = i;
496         expected_number_of_code_bits += expected_bits_table[i];
497     }
498
499     min = max = expected_number_of_code_bits;
500     min_rate_ptr = max_rate_ptr =
501         temp_category_balances + num_rate_control_possibilities;
502     for (i = 0; i < num_rate_control_possibilities - 1; i++) {
503         if (min + max > number_of_available_bits * 2) {
504             raw_value = -99;
505             for (region = number_of_regions - 1; region >= 0; region--) {
506                 if (min_rate_categories[region] < 7) {
507                     temp =
508                         offset - absolute_region_power_index[region] -
509                         2 * min_rate_categories[region];
510                     if (temp > raw_value) {
511                         raw_value = temp;
512                         raw_min_idx = region;
513                     }
514                 }
515             }
516             if (raw_value == -99)
517                 return AVERROR_INVALIDDATA;
518             *min_rate_ptr++ = raw_min_idx;
519             min +=
520                 expected_bits_table[min_rate_categories[raw_min_idx] + 1] -
521                 expected_bits_table[min_rate_categories[raw_min_idx]];
522             min_rate_categories[raw_min_idx]++;
523         } else {
524             raw_value = 99;
525             for (region = 0; region < number_of_regions; region++) {
526                 if (max_rate_categories[region] > 0) {
527                     temp =
528                         offset - absolute_region_power_index[region] -
529                         2 * max_rate_categories[region];
530                     if (temp < raw_value) {
531                         raw_value = temp;
532                         raw_max_idx = region;
533                     }
534                 }
535             }
536             if (raw_value == 99)
537                 return AVERROR_INVALIDDATA;
538
539             *--max_rate_ptr = raw_max_idx;
540             max += expected_bits_table[max_rate_categories[raw_max_idx] - 1] -
541                    expected_bits_table[max_rate_categories[raw_max_idx]];
542             max_rate_categories[raw_max_idx]--;
543         }
544     }
545
546     for (region = 0; region < number_of_regions; region++)
547         power_categories[region] = max_rate_categories[region];
548
549     for (i = 0; i < num_rate_control_possibilities - 1; i++)
550         category_balance[i] = *max_rate_ptr++;
551
552     return 0;
553 }
554
555 static int get_dw(SirenContext *s)
556 {
557     int ret = s->dw1 + s->dw4;
558
559     if ((ret & 0x8000) != 0)
560         ret++;
561
562     s->dw1 = s->dw2;
563     s->dw2 = s->dw3;
564     s->dw3 = s->dw4;
565     s->dw4 = ret;
566
567     return ret;
568 }
569
570 static int decode_vector(SirenContext *s, int number_of_regions,
571                          float *decoder_standard_deviation,
572                          int *power_categories, float *coefs, int scale_factor)
573 {
574     GetBitContext *gb = &s->gb;
575     float *coefs_ptr;
576     float decoded_value;
577     float noise;
578     const uint16_t *decoder_tree;
579     int region;
580     int category;
581     int i, j;
582     int index;
583     int error = 0;
584     int dw1;
585     int dw2;
586
587     for (region = 0; region < number_of_regions; region++) {
588         category = power_categories[region];
589         coefs_ptr = coefs + (region * REGION_SIZE);
590
591         if (category >= 0 && category < 7) {
592             decoder_tree = decoder_tables[category];
593
594             for (i = 0; i < number_of_vectors[category]; i++) {
595                 index = 0;
596                 do {
597                     if (get_bits_left(gb) - s->checksum_bits <= 0) {
598                         error = 1;
599                         break;
600                     }
601
602                     if (index + show_bits1(gb) >= decoder_tables_elements[category]) {
603                         error = 1;
604                         break;
605                     }
606                     index = decoder_tree[index + get_bits1(gb)];
607                 } while ((index & 1) == 0);
608
609                 index >>= 1;
610
611                 if (error == 0) {
612                     for (j = 0; j < vector_dimension[category]; j++) {
613                         decoded_value = mlt_quant[category][index & ((1 << index_table[category]) - 1)];
614                         index >>= index_table[category];
615
616                         if (decoded_value) {
617                             if (get_bits_left(gb) - s->checksum_bits <= 0) {
618                                 error = 1;
619                                 break;
620                             }
621                             if (!get_bits1(gb))
622                                 decoded_value *= -decoder_standard_deviation[region];
623                             else
624                                 decoded_value *= decoder_standard_deviation[region];
625                         }
626
627                         *coefs_ptr++ = decoded_value * scale_factor;
628                     }
629                 } else {
630                     error = 1;
631                     break;
632                 }
633             }
634
635             if (error == 1) {
636                 for (j = region + 1; j < number_of_regions; j++)
637                     power_categories[j] = 7;
638                 category = 7;
639             }
640         }
641
642         coefs_ptr = coefs + (region * REGION_SIZE);
643
644         if (category == 5 && s->microsoft) {
645             i = 0;
646             for (j = 0; j < REGION_SIZE; j++) {
647                 if (*coefs_ptr != 0) {
648                     i++;
649                     if (fabs(*coefs_ptr) > 2.0 * decoder_standard_deviation[region]) {
650                         i += 3;
651                     }
652                 }
653                 coefs_ptr++;
654             }
655             if (i >= FF_ARRAY_ELEMS(noise_category5)) {
656                 error = 1;
657                 break;
658             }
659
660             noise = decoder_standard_deviation[region] * noise_category5[i];
661         } else
662         if (category == 5 || category == 6) {
663             i = 0;
664             for (j = 0; j < REGION_SIZE; j++) {
665                 if (*coefs_ptr != 0)
666                     i++;
667                 coefs_ptr++;
668             }
669
670             if (category == 5) {
671                 noise = decoder_standard_deviation[region] * noise_category5[i];
672             } else
673                 noise = decoder_standard_deviation[region] * noise_category6[i];
674         } else if (category == 7) {
675             noise = decoder_standard_deviation[region] * 0.70711f;
676         } else {
677             noise = 0;
678         }
679
680         coefs_ptr = coefs + (region * REGION_SIZE);
681
682         if (category == 5 || category == 6 || category == 7) {
683             dw1 = get_dw(s);
684             dw2 = get_dw(s);
685
686             for (j = 0; j < 10; j++) {
687                 if (category == 7 || *coefs_ptr == 0)
688                     *coefs_ptr = dw1 & 1 ? noise : -noise;
689                 coefs_ptr++;
690                 dw1 >>= 1;
691
692                 if (category == 7 || *coefs_ptr == 0)
693                     *coefs_ptr = dw2 & 1 ? noise : -noise;
694                 coefs_ptr++;
695                 dw2 >>= 1;
696             }
697         }
698     }
699
700     return error == 1 ? AVERROR_INVALIDDATA : (get_bits_left(gb) - s->checksum_bits);
701 }
702
703 static int siren_decode(AVCodecContext *avctx, void *data,
704                         int *got_frame, AVPacket *avpkt)
705 {
706     SirenContext *s = avctx->priv_data;
707     GetBitContext *gb = &s->gb;
708     AVFrame *frame = data;
709     int ret, number_of_valid_coefs = REGION_SIZE * s->number_of_regions;
710     int frame_error = 0, rate_control = 0;
711     int bits_per_frame;
712
713     if (s->microsoft) {
714         bits_per_frame  = avctx->sample_rate / 50;
715
716         if (avpkt->size < bits_per_frame / 8)
717             return AVERROR_INVALIDDATA;
718
719         if ((ret = init_get_bits(gb, avpkt->data, bits_per_frame)) < 0)
720             return ret;
721     } else
722     if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
723         return ret;
724
725     skip_bits(gb, s->sample_rate_bits);
726
727     decode_envelope(s, gb, s->number_of_regions,
728                     s->decoder_standard_deviation,
729                     s->absolute_region_power_index, s->esf_adjustment);
730
731     rate_control = get_bits(gb, 4);
732
733     ret = categorize_regions(s->number_of_regions, get_bits_left(gb) - s->checksum_bits,
734                              s->absolute_region_power_index, s->power_categories,
735                              s->category_balance);
736     if (ret < 0)
737         return ret;
738
739     for (int i = 0; i < rate_control; i++)
740         s->power_categories[s->category_balance[i]]++;
741
742     ret = decode_vector(s, s->number_of_regions,
743                         s->decoder_standard_deviation, s->power_categories,
744                         s->imdct_in, s->scale_factor);
745     if (ret < 0 && !s->microsoft)
746         return ret;
747
748     if (get_bits_left(gb) - s->checksum_bits > 0) {
749         do {
750             frame_error |= !get_bits1(gb);
751         } while (get_bits_left(gb) - s->checksum_bits > 0);
752     } else if (get_bits_left(gb) - s->checksum_bits < 0 &&
753                rate_control + 1 < s->rate_control_possibilities) {
754         frame_error = 1;
755     }
756
757     for (int i = 0; i < s->number_of_regions; i++) {
758         if (s->absolute_region_power_index[i] > 33 ||
759             s->absolute_region_power_index[i] < -31)
760             frame_error = 1;
761     }
762
763     if ((avctx->err_recognition & AV_EF_CRCCHECK) && s->checksum_bits) {
764         static const uint16_t ChecksumTable[4] = {0x7F80, 0x7878, 0x6666, 0x5555};
765         int wpf, checksum, sum, calculated_checksum, temp1;
766
767         checksum = get_bits(gb, s->checksum_bits);
768
769         wpf = bits_per_frame / 16;
770         sum = 0;
771         for (int i = 0; i < wpf - 1; i++)
772             sum ^= AV_RB16(avpkt->data + i * 2) << (i % 15);
773         sum ^= (AV_RB16(avpkt->data + (wpf - 1) * 2) & ~checksum) << ((wpf - 1) % 15);
774         sum = (sum >> 15) ^ (sum & 0x7FFF);
775
776         calculated_checksum = 0;
777         for (int i = 0; i < 4; i++) {
778             temp1 = ChecksumTable[i] & sum;
779
780             for (int j = 8; j > 0; j >>= 1)
781                 temp1 ^= temp1 >> j;
782
783             calculated_checksum <<= 1;
784             calculated_checksum |= temp1 & 1;
785         }
786
787         if (checksum != calculated_checksum) {
788             av_log(avctx, AV_LOG_WARNING, "Invalid checksum\n");
789             if (avctx->err_recognition & AV_EF_EXPLODE)
790                 return AVERROR_INVALIDDATA;
791             frame_error = 1;
792         }
793     }
794
795     if (frame_error) {
796         memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
797         memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
798     } else {
799         memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
800     }
801
802     frame->nb_samples = FRAME_SIZE;
803     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
804         return ret;
805
806     for (int i = 0; i < FRAME_SIZE; i += 2)
807         s->imdct_in[i] *= -1;
808
809     s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
810     s->fdsp->vector_fmul_window((float *)frame->data[0],
811                                 s->imdct_prev + (FRAME_SIZE >> 1),
812                                 s->imdct_out, s->window,
813                                 FRAME_SIZE >> 1);
814     FFSWAP(float *, s->imdct_out, s->imdct_prev);
815
816     *got_frame = 1;
817
818     return s->microsoft ? bits_per_frame / 8 : avpkt->size;
819 }
820
821 static av_cold void siren_flush(AVCodecContext *avctx)
822 {
823     SirenContext *s = avctx->priv_data;
824
825     memset(s->backup_frame, 0, sizeof(s->backup_frame));
826     memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
827     memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
828 }
829
830 static av_cold int siren_close(AVCodecContext *avctx)
831 {
832     SirenContext *s = avctx->priv_data;
833
834     av_freep(&s->fdsp);
835     av_tx_uninit(&s->tx_ctx);
836
837     return 0;
838 }
839
840 const AVCodec ff_siren_decoder = {
841     .name           = "siren",
842     .long_name      = NULL_IF_CONFIG_SMALL("Siren"),
843     .priv_data_size = sizeof(SirenContext),
844     .type           = AVMEDIA_TYPE_AUDIO,
845     .id             = AV_CODEC_ID_SIREN,
846     .init           = siren_init,
847     .close          = siren_close,
848     .decode         = siren_decode,
849     .flush          = siren_flush,
850     .capabilities   = AV_CODEC_CAP_CHANNEL_CONF |
851                       AV_CODEC_CAP_DR1,
852     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
853                       FF_CODEC_CAP_INIT_CLEANUP,
854 };
855
856 const AVCodec ff_msnsiren_decoder = {
857     .name           = "msnsiren",
858     .long_name      = NULL_IF_CONFIG_SMALL("MSN Siren"),
859     .priv_data_size = sizeof(SirenContext),
860     .type           = AVMEDIA_TYPE_AUDIO,
861     .id             = AV_CODEC_ID_MSNSIREN,
862     .init           = siren_init,
863     .close          = siren_close,
864     .decode         = siren_decode,
865     .flush          = siren_flush,
866     .capabilities   = AV_CODEC_CAP_CHANNEL_CONF |
867                       AV_CODEC_CAP_DR1,
868     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
869                       FF_CODEC_CAP_INIT_CLEANUP,
870 };