FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/siren.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 0 256 0.0%
Branches: 0 160 0.0%

Line Branch Exec Source
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) <= 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 && get_bits_left(gb) >= 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_bits1(gb))
618 decoded_value *= -decoder_standard_deviation[region];
619 else
620 decoded_value *= decoder_standard_deviation[region];
621 }
622
623 *coefs_ptr++ = decoded_value * scale_factor;
624 }
625 } else {
626 error = 1;
627 break;
628 }
629 }
630
631 if (error == 1) {
632 for (j = region + 1; j < number_of_regions; j++)
633 power_categories[j] = 7;
634 category = 7;
635 }
636 }
637
638 coefs_ptr = coefs + (region * REGION_SIZE);
639
640 if (category == 5 && s->microsoft) {
641 i = 0;
642 for (j = 0; j < REGION_SIZE; j++) {
643 if (*coefs_ptr != 0) {
644 i++;
645 if (fabs(*coefs_ptr) > 2.0 * decoder_standard_deviation[region]) {
646 i += 3;
647 }
648 }
649 coefs_ptr++;
650 }
651 if (i >= FF_ARRAY_ELEMS(noise_category5)) {
652 error = 1;
653 break;
654 }
655
656 noise = decoder_standard_deviation[region] * noise_category5[i];
657 } else
658 if (category == 5 || category == 6) {
659 i = 0;
660 for (j = 0; j < REGION_SIZE; j++) {
661 if (*coefs_ptr != 0)
662 i++;
663 coefs_ptr++;
664 }
665
666 if (category == 5) {
667 noise = decoder_standard_deviation[region] * noise_category5[i];
668 } else
669 noise = decoder_standard_deviation[region] * noise_category6[i];
670 } else if (category == 7) {
671 noise = decoder_standard_deviation[region] * 0.70711f;
672 } else {
673 noise = 0;
674 }
675
676 coefs_ptr = coefs + (region * REGION_SIZE);
677
678 if (category == 5 || category == 6 || category == 7) {
679 dw1 = get_dw(s);
680 dw2 = get_dw(s);
681
682 for (j = 0; j < 10; j++) {
683 if (category == 7 || *coefs_ptr == 0)
684 *coefs_ptr = dw1 & 1 ? noise : -noise;
685 coefs_ptr++;
686 dw1 >>= 1;
687
688 if (category == 7 || *coefs_ptr == 0)
689 *coefs_ptr = dw2 & 1 ? noise : -noise;
690 coefs_ptr++;
691 dw2 >>= 1;
692 }
693 }
694 }
695
696 return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb);
697 }
698
699 static int siren_decode(AVCodecContext *avctx, void *data,
700 int *got_frame, AVPacket *avpkt)
701 {
702 SirenContext *s = avctx->priv_data;
703 GetBitContext *gb = &s->gb;
704 AVFrame *frame = data;
705 int ret, number_of_valid_coefs = REGION_SIZE * s->number_of_regions;
706 int frame_error = 0, rate_control = 0;
707 int bits_per_frame;
708
709 if (s->microsoft) {
710 bits_per_frame = avctx->sample_rate / 50;
711
712 if (avpkt->size < bits_per_frame / 8)
713 return AVERROR_INVALIDDATA;
714
715 if ((ret = init_get_bits(gb, avpkt->data, bits_per_frame - s->checksum_bits)) < 0)
716 return ret;
717 } else
718 if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
719 return ret;
720
721 skip_bits(gb, s->sample_rate_bits);
722
723 decode_envelope(s, gb, s->number_of_regions,
724 s->decoder_standard_deviation,
725 s->absolute_region_power_index, s->esf_adjustment);
726
727 rate_control = get_bits(gb, 4);
728
729 ret = categorize_regions(s->number_of_regions, get_bits_left(gb),
730 s->absolute_region_power_index, s->power_categories,
731 s->category_balance);
732 if (ret < 0)
733 return ret;
734
735 for (int i = 0; i < rate_control; i++)
736 s->power_categories[s->category_balance[i]]++;
737
738 ret = decode_vector(s, s->number_of_regions,
739 s->decoder_standard_deviation, s->power_categories,
740 s->imdct_in, s->scale_factor);
741 if (ret < 0 && !s->microsoft)
742 return ret;
743
744 if (get_bits_left(gb) > 0) {
745 do {
746 frame_error |= !get_bits1(gb);
747 } while (get_bits_left(gb) > 0);
748 } else if (get_bits_left(gb) < 0 &&
749 rate_control + 1 < s->rate_control_possibilities) {
750 frame_error = 1;
751 }
752
753 for (int i = 0; i < s->number_of_regions; i++) {
754 if (s->absolute_region_power_index[i] > 33 ||
755 s->absolute_region_power_index[i] < -31)
756 frame_error = 1;
757 }
758
759 skip_bits(gb, s->checksum_bits);
760
761 if (frame_error) {
762 memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
763 memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
764 } else {
765 memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
766 }
767
768 frame->nb_samples = FRAME_SIZE;
769 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
770 return ret;
771
772 for (int i = 0; i < FRAME_SIZE; i += 2)
773 s->imdct_in[i] *= -1;
774
775 s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
776 s->fdsp->vector_fmul_window((float *)frame->data[0],
777 s->imdct_prev + (FRAME_SIZE >> 1),
778 s->imdct_out, s->window,
779 FRAME_SIZE >> 1);
780 FFSWAP(float *, s->imdct_out, s->imdct_prev);
781
782 *got_frame = 1;
783
784 return s->microsoft ? bits_per_frame / 8 : avpkt->size;
785 }
786
787 static av_cold void siren_flush(AVCodecContext *avctx)
788 {
789 SirenContext *s = avctx->priv_data;
790
791 memset(s->backup_frame, 0, sizeof(s->backup_frame));
792 memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
793 memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
794 }
795
796 static av_cold int siren_close(AVCodecContext *avctx)
797 {
798 SirenContext *s = avctx->priv_data;
799
800 av_freep(&s->fdsp);
801 av_tx_uninit(&s->tx_ctx);
802
803 return 0;
804 }
805
806 const AVCodec ff_siren_decoder = {
807 .name = "siren",
808 .long_name = NULL_IF_CONFIG_SMALL("Siren"),
809 .priv_data_size = sizeof(SirenContext),
810 .type = AVMEDIA_TYPE_AUDIO,
811 .id = AV_CODEC_ID_SIREN,
812 .init = siren_init,
813 .close = siren_close,
814 .decode = siren_decode,
815 .flush = siren_flush,
816 .capabilities = AV_CODEC_CAP_CHANNEL_CONF |
817 AV_CODEC_CAP_DR1,
818 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
819 FF_CODEC_CAP_INIT_CLEANUP,
820 };
821
822 const AVCodec ff_msnsiren_decoder = {
823 .name = "msnsiren",
824 .long_name = NULL_IF_CONFIG_SMALL("MSN Siren"),
825 .priv_data_size = sizeof(SirenContext),
826 .type = AVMEDIA_TYPE_AUDIO,
827 .id = AV_CODEC_ID_MSNSIREN,
828 .init = siren_init,
829 .close = siren_close,
830 .decode = siren_decode,
831 .flush = siren_flush,
832 .capabilities = AV_CODEC_CAP_CHANNEL_CONF |
833 AV_CODEC_CAP_DR1,
834 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
835 FF_CODEC_CAP_INIT_CLEANUP,
836 };
837