FFmpeg
siren.c
Go to the documentation of this file.
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/tx.h"
25 #include "libavutil/float_dsp.h"
26 
27 #include "avcodec.h"
28 #include "get_bits.h"
29 #include "internal.h"
30 #include "mathops.h"
31 
32 static const uint8_t index_table[8] = {4, 4, 3, 3, 2, 2, 1, 0};
33 static const uint8_t vector_dimension[8] = { 2, 2, 2, 4, 4, 5, 5, 1 };
34 static const uint8_t number_of_vectors[8] = { 10, 10, 10, 5, 5, 4, 4, 20 };
35 static const uint8_t expected_bits_table[8] = { 52, 47, 43, 37, 29, 22, 16, 0 };
36 static const int8_t differential_decoder_tree[27][24][2] = {
37  {
38  {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {11, -12}, {-11, -10}, {-8, -9}, {-7, -6}, {-13, 12},
39  {-5, -4}, {0, 13}, {-3, -14}, {-2, 14}, {-1, 15}, {-15, 16}, {-16, 17}, {-17, 18}, {19, 20},
40  {21, 22}, {-18, -19}, {-20, -21}, {-22, -23}, {-32, -32}
41  },
42  {
43  {1, 2}, {3, 4}, {5, 6}, {7, 8}, {-10, -9}, {-8, -11}, {-7, -6}, {9, -5}, {10, -12}, {-4, 11},
44  {-13, -3}, {12, -2}, {13, -14}, {-1, 14}, {15, -15}, {0, 16}, {-16, 17}, {-17, 18}, {-18, 19},
45  {20, 21},{22, -19}, {-20, -21}, {-22, -23}, {-32, -32}
46  },
47  {
48  {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {-12, 11}, {-11, -13}, {-10, -9}, {12, -14}, {-8, -7},
49  {-15, -6}, {13, -5}, {-16, -4}, {14, -17}, {15, -3}, {16, -18}, {-2, 17}, {18, -19}, {-1, 19},
50  {-20, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}
51  },
52  {
53  {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {7, -12}, {8, -9}, {9, -13}, {-14, 10}, {-8, -15}, {-16, 11},
54  {-7, 12}, {-17, -6}, {13, 14}, {-18, 15}, {-5, -4}, {16, 17}, {-3, -2}, {-19, 18}, {-1, 19},
55  {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
56  },
57  {
58  {1, 2}, {3, 4}, {5, 6}, {-12, -11}, {-13, 7}, {8, -14}, {-10, 9}, {10, -15}, {-9, 11}, {-8, 12},
59  {-16, 13}, {-7, -6}, {-17, 14}, {-5, -18}, {15, -4}, {16, -19}, {17, -3}, {-20, 18}, {-2, 19},
60  {-21, 20}, {0, 21}, {22, -1}, {-22, -23}, {-32, -32}
61  },
62  {
63  {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-12, -10}, {-13, -9}, {8, 9}, {-14, -8}, {10, -15}, {-7, 11},
64  {-16, 12}, {-6, -17}, {13, 14}, {-5, 15}, {-18, 16}, {-4, 17}, {-3, -19}, {18, -2}, {-20, 19},
65  {-1, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}
66  },
67  {
68  {1, 2}, {3, 4}, {5, -12}, {6, -11}, {-10, -13}, {-9, 7}, {8, -14}, {9, -8}, {-15, 10}, {-7, -16},
69  {11, -6}, {12, -17}, {13, -5}, {-18, 14}, {15, -4}, {-19, 16}, {17, -3}, {-20, 18}, {19, 20},
70  {21, 22}, {0, -2}, {-1, -21}, {-22, -23}, {-32, -32}
71  },
72  {
73  {1, 2}, {3, 4}, {5, -12}, {6, -13}, {-11, -10}, {7, -14}, {8, -9}, {9, -15}, {-8, 10}, {-7, -16},
74  {11, 12}, {-6, -17}, {-5, 13}, {14, 15}, {-18, -4}, {-19, 16}, {-3, 17}, {18, -2}, {-20, 19},
75  {20, 21}, {22, 0}, {-1, -21}, {-22, -23}, {-32, -32}
76  },
77  {
78  {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {-12, -9}, {7, 8}, {-13, -8}, {9, -14}, {-7, 10}, {-6, -15},
79  {11, 12}, {-5, -16}, {13, 14}, {-17, 15}, {-4, 16}, {17, -18}, {18, -3}, {-2, 19}, {-1, 0},
80  {-19, 20}, {-20, 21}, {22, -21}, {-22, -23}, {-32, -32}
81  },
82  {
83  {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-10, -12}, {-9, 8}, {-8, -13}, {9, -7}, {10, -14}, {-6, 11},
84  {-15, 12}, {-5, 13}, {-16, -4}, {14, 15}, {-17, -3}, {-18, 16}, {17, -19}, {-2, 18}, {-20, 19},
85  {-1, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
86  },
87  {
88  {1, 2}, {3, 4}, {5, -12}, {6, -11}, {7, 8}, {-10, -13}, {-9, 9}, {-8, -14}, {10, -7}, {11, -15},
89  {-6, 12}, {-5, 13}, {-4, -16}, {14, 15}, {-3, -17}, {16, 17}, {-18, -2}, {18, -19}, {-1, 19},
90  {-20, 20}, {-21, 21}, {22, 0}, {-22, -23}, {-32, -32}
91  },
92  {
93  {1, 2}, {3, 4}, {5, -12}, {-13, 6}, {-11, 7}, {-14, 8}, {-10, 9}, {-15, -9}, {-8, 10}, {-7, -16},
94  {11, -6}, {12, -5}, {-17, 13}, {14, -18}, {15, -4}, {16, -19}, {17, -3}, {18, -2}, {19, -1},
95  {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
96  },
97  {
98  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
99  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
100  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
101  },
102  {
103  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
104  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
105  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
106  },
107  {
108  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
109  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
110  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
111  },
112  {
113  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
114  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
115  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
116  },
117  {
118  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
119  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
120  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
121  },
122  {
123  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
124  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
125  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
126  },
127  {
128  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
129  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
130  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
131  },
132  {
133  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
134  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
135  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
136  },
137  {
138  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
139  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
140  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
141  },
142  {
143  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
144  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
145  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
146  },
147  {
148  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
149  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
150  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
151  },
152  {
153  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
154  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
155  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
156  },
157  {
158  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
159  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
160  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
161  },
162  {
163  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
164  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
165  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
166  },
167  {
168  {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
169  {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
170  {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
171  },
172 };
173 
174 static const uint16_t decoder_tree0[360] = {
175  2, 1, 4, 6, 8, 10, 12, 14, 16, 18, 33, 3, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 35, 40,
176  42, 44, 46, 5, 48, 65, 50, 52, 54, 56, 58, 60, 62, 64, 37, 66, 67, 68, 97, 70, 72, 74, 7,
177  76, 78, 80, 82, 84, 86, 88, 99, 90, 39, 92, 94, 96, 129, 98, 9, 100, 102, 104, 106, 108,
178  110, 112, 41, 161, 69, 114, 116, 118, 131, 120, 122, 11, 124, 126, 128, 193, 130, 132, 71,
179  134, 43, 136, 138, 140, 163, 101, 13, 142, 144, 146, 148, 150, 152, 154, 225, 156, 158, 195,
180  160, 162, 45, 164, 15, 166, 73, 168, 170, 133, 47, 172, 257, 174, 176, 178, 75, 103, 180, 165,
181  182, 17, 227, 184, 105, 49, 135, 186, 289, 188, 259, 190, 192, 194, 196, 198, 291, 77, 200,
182  202, 197, 107, 204, 19, 51, 229, 206, 167, 208, 210, 212, 214, 21, 79, 81, 109, 216, 218, 220,
183  222, 53, 137, 224, 199, 226, 323, 321, 169, 228, 111, 230, 232, 139, 261, 234, 83, 236, 201,
184  238, 240, 293, 242, 353, 231, 141, 244, 246, 113, 23, 355, 85, 248, 55, 115, 250, 263, 252,
185  254, 203, 171, 256, 258, 233, 235, 143, 357, 325, 260, 295, 262, 173, 145, 177, 87, 264, 327,
186  267, 266, 268, 175, 270, 272, 117, 297, 274, 265, 147, 179, 205, 276, 207, 237, 269, 278, 57,
187  59, 387, 209, 280, 282, 149, 329, 385, 284, 25, 286, 239, 119, 288, 27, 290, 292, 299, 294, 359,
188  89, 296, 298, 419, 181, 300, 331, 271, 417, 211, 361, 151, 389, 241, 302, 304, 303, 306, 308,
189  421, 91, 310, 312, 391, 314, 121, 316, 333, 318, 275, 213, 301, 243, 183, 335, 320, 363, 322,
190  215, 324, 393, 273, 337, 153, 326, 423, 365, 328, 367, 247, 395, 185, 123, 330, 425, 245, 155,
191  332, 334, 305, 397, 336, 277, 217, 338, 340, 339, 427, 342, 344, 346, 307, 399, 187, 348, 309,
192  341, 350, 369, 279, 311, 429, 249, 219, 352, 354, 356, 358, 431, 373, 401, 371, 313, 281, 433,
193  343, 403, 251, 283
194 };
195 
196 static const uint16_t decoder_tree1[188] = {
197  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,
198  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,
199  78, 80, 129, 41, 131, 82, 9, 71, 84, 86, 101, 88, 90, 92, 94, 96, 161, 43, 11, 73, 98, 103, 100,
200  163, 102, 104, 106, 108, 133, 110, 105, 112, 75, 114, 45, 13, 116, 165, 118, 195, 135, 193, 120, 77,
201  122, 47, 124, 167, 225, 126, 79, 107, 227, 128, 137, 197, 15, 130, 169, 199, 132, 109, 134, 17, 139,
202  49, 136, 229, 138, 140, 81, 259, 142, 144, 171, 146, 141, 148, 111, 150, 201, 231, 152, 51, 257, 289,
203  154, 19, 113, 156, 261, 158, 203, 173, 263, 143, 160, 291, 235, 83, 162, 233, 265, 164, 205, 166, 293,
204  145, 168, 175, 177, 237, 115, 295, 170, 207, 172, 267, 174, 176, 297, 147, 178, 180, 269, 182, 271,
205  209, 299, 239, 179, 184, 301, 241, 211, 0, 0
206 };
207 
208 static const uint16_t decoder_tree2[96] = {
209  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,
210  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,
211  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,
212  75, 89, 61, 86, 103, 88, 77, 90, 105, 91, 92, 107, 93, 0, 0
213 };
214 
215 static const uint16_t decoder_tree3[1040] = {
216  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,
217  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,
218  84, 86, 131, 88, 1155, 1043, 1041, 90, 92, 5, 94, 96, 98, 100, 102, 104, 21, 106, 108, 2049, 2177, 110, 112, 114,
219  116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 33, 144, 163, 146, 148, 150, 152, 154, 161,
220  156, 35, 158, 1297, 160, 162, 273, 257, 164, 166, 149, 168, 1281, 170, 172, 2193, 174, 176, 178, 1299, 180, 1045,
221  182, 184, 1173, 186, 3201, 188, 190, 192, 194, 2195, 1187, 23, 2179, 196, 7, 198, 275, 200, 2051, 202, 2065, 204,
222  206, 1029, 1185, 208, 210, 1157, 37, 3073, 2067, 133, 212, 214, 2321, 216, 165, 218, 1059, 220, 1283, 222, 2305,
223  224, 226, 228, 230, 259, 232, 234, 2323, 236, 1409, 1057, 1315, 238, 240, 242, 244, 246, 1425, 248, 1313, 250, 252,
224  254, 256, 258, 260, 289, 262, 264, 1189, 266, 268, 179, 151, 270, 272, 274, 276, 278, 291, 280, 282, 9, 385, 284,
225  286, 177, 49, 401, 1061, 288, 290, 292, 51, 294, 296, 298, 300, 302, 304, 25, 306, 2083, 39, 308, 310, 3329, 167,
226  312, 314, 1175, 316, 318, 1203, 135, 320, 322, 324, 326, 328, 2211, 2307, 330, 1301, 332, 334, 1047, 336, 338, 2449,
227  3217, 340, 1427, 2209, 53, 342, 2339, 3345, 344, 346, 348, 403, 181, 4097, 2197, 350, 2181, 1285, 1317, 1031, 352,
228  354, 356, 3089, 358, 360, 4225, 277, 362, 364, 366, 368, 2069, 370, 3203, 293, 1201, 305, 372, 3219, 307, 2433, 374,
229  376, 378, 380, 2081, 1411, 382, 384, 3075, 1443, 513, 386, 387, 388, 390, 1331, 261, 392, 394, 396, 398, 400, 1441,
230  1075, 67, 1159, 402, 404, 406, 408, 410, 412, 414, 3347, 2325, 416, 65, 418, 420, 422, 424, 426, 2053, 193, 1073, 428,
231  430, 432, 1537, 1329, 2337, 2213, 434, 417, 183, 41, 436, 438, 440, 442, 444, 446, 448, 450, 195, 2435, 452, 2085, 1063,
232  1191, 454, 456, 458, 460, 419, 2071, 1553, 3091, 55, 137, 462, 464, 466, 468, 470, 472, 474, 476, 478, 2309, 4113, 480,
233  482, 484, 486, 2451, 2465, 1205, 153, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518,
234  520, 522, 524, 1333, 526, 1555, 2467, 2227, 3205, 3331, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 529, 309,
235  1303, 3473, 3457, 389, 1569, 1445, 1077, 69, 2199, 1539, 4353, 550, 552, 554, 556, 558, 560, 562, 1459, 4241, 3221, 1429,
236  2341, 279, 3475, 169, 564, 545, 3105, 323, 2353, 2097, 3235, 421, 2229, 3107, 3233, 566, 568, 570, 572, 574, 576, 578,
237  580, 582, 584, 586, 588, 590, 592, 594, 596, 2099, 1091, 531, 2437, 4227, 405, 197, 263, 1287, 2577, 1049, 1571, 598, 600,
238  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,
239  1345, 1219, 3077, 1457, 2225, 2579, 515, 2561, 2469, 433, 1221, 2183, 4243, 652, 654, 656, 658, 660, 662, 664, 666, 668,
240  670, 1217, 3333, 3093, 435, 321, 4369, 1089, 2055, 4099, 3361, 1319, 547, 1161, 1177, 672, 2355, 4115, 1413, 4257, 3349,
241  2453, 3109, 2357, 2215, 3363, 1079, 1207, 311, 1033, 1347, 1065, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696,
242  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,
243  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,
244  798, 800, 802, 804, 806, 808, 810, 812, 814, 2593, 2565, 4261, 3253, 437, 325, 3489, 2311, 4259, 1431, 2087, 2563, 295, 2343,
245  449, 199, 265, 2201, 4371, 1193, 816, 533, 1557, 2581, 2241, 3365, 3491, 3603, 549, 2101, 1461, 1093, 2117, 3459, 3079, 4481,
246  3095, 2327, 3461, 4129, 3249, 1447, 2471, 2231, 71, 4497, 2609, 1289, 393, 3251, 2073, 3097, 2371, 1305, 2089, 818, 820, 822,
247  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,
248  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,
249  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,
250  974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018,
251  1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 4161, 4273, 3507, 3493, 4517, 2497, 1573, 2597, 3621, 4531, 4627, 3523,
252  3125, 4149, 4529, 3139, 4515, 451, 4277, 2113, 4163, 4499, 3381, 4405, 1473, 4373, 2485, 3509, 565, 1589, 2613, 3585, 3123,
253  4403, 3141, 4147, 563, 2245, 3269, 4357, 1349, 2373, 3397, 453, 1477, 2501, 2481, 579, 1601, 3477, 4103, 3265, 2243, 1587,
254  3207, 4231, 3267, 4501, 1475, 3335, 4359, 391, 1415, 2439, 3463, 4487, 519, 1543, 2567, 3591, 4609, 4289, 4611, 2499, 4119,
255  4385, 4145, 4401, 3223, 4247, 3379, 577, 3393, 3351, 4375, 407, 1585, 2455, 3479, 4503, 535, 1559, 2583, 3607, 3605, 4513,
256  4485, 3111, 4135, 3121, 517, 3377, 3239, 4263, 1541, 4291, 4229, 3367, 4391, 423, 2115, 4131, 3495, 551, 1575, 2599, 3635, 3395,
257  2103, 3127, 4151, 3589, 4101, 1603, 3255, 4279, 3601, 1335, 2359, 3383, 439, 1463, 2487, 3511, 567, 1591, 4133, 1095, 2119, 3143,
258  2369, 1223, 2247, 3271, 327, 1351, 2375, 455, 1479, 3137, 3521, 2057, 3081, 4105, 4387, 3505, 2185, 3209, 4233, 3587, 4355, 2313,
259  3337, 3237, 1417, 2441, 3465, 521, 1545, 3617, 3633, 561, 4625, 4121, 2611, 2483, 2595, 3225, 4249, 281, 4245, 2329, 3353, 409,
260  1433, 2457, 3481, 537, 1561, 4483, 3619, 4389, 3113, 4275, 4117, 2217, 3241, 297, 1321, 2345, 3369, 425, 1449, 2473, 57, 1081,
261  2105, 3129, 185, 1209, 2233, 3257, 313, 1337, 2361, 441, 1465, 73, 1097, 201, 1225, 0, 0
262 };
263 
264 static const uint16_t decoder_tree4[416] = {
265  2, 4, 6, 1, 8, 10, 12, 14, 16, 18, 20, 22, 24, 3, 129, 26, 28, 9, 33, 30, 32,
266  34, 36, 11, 161, 38, 40, 42, 41, 44, 46, 131, 43, 169, 35, 48, 137, 50, 52, 54, 56, 139,
267  163, 171, 58, 60, 62, 64, 5, 66, 68, 70, 257, 72, 74, 76, 13, 78, 80, 289, 82, 84, 17,
268  86, 88, 65, 90, 201, 19, 92, 94, 51, 193, 96, 98, 49, 100, 73, 102, 104, 106, 45, 108, 110,
269  297, 112, 114, 116, 37, 203, 118, 120, 179, 122, 177, 124, 265, 126, 75, 133, 259, 291, 147, 128, 67,
270  195, 130, 141, 173, 299, 132, 145, 134, 165, 136, 138, 140, 142, 7, 144, 146, 21, 267, 148, 53, 150,
271  321, 152, 154, 15, 156, 81, 158, 160, 385, 162, 417, 164, 166, 168, 83, 170, 172, 329, 174, 211, 176,
272  27, 178, 180, 182, 209, 184, 186, 188, 190, 25, 192, 331, 194, 196, 105, 57, 198, 97, 200, 202, 323,
273  225, 59, 149, 204, 206, 233, 307, 208, 77, 181, 210, 212, 214, 216, 218, 220, 222, 47, 224, 226, 69,
274  228, 230, 197, 232, 425, 393, 205, 275, 293, 39, 234, 236, 238, 305, 135, 155, 301, 143, 240, 242, 235,
275  395, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 273, 269, 185, 264, 266, 268, 270, 272, 274, 276,
276  261, 153, 278, 280, 282, 187, 337, 387, 107, 284, 427, 227, 167, 419, 286, 288, 290, 292, 294, 296, 298,
277  300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 115,
278  99, 85, 213, 29, 113, 23, 89, 241, 61, 449, 339, 175, 340, 342, 344, 346, 348, 350, 352, 354, 356,
279  358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398,
280  400, 402, 404, 406, 408, 410, 412, 414, 389, 361, 457, 465, 429, 451, 333, 109, 277, 243, 263, 295, 199,
281  283, 151, 55, 183, 229, 357, 363, 123, 491, 397, 411, 251, 313, 441, 467, 345, 433, 461, 219, 237, 365,
282  435, 353, 347, 405, 409, 217, 309, 437, 369, 371, 341, 117, 245, 249, 157, 285, 403, 189, 317, 93, 221,
283  315, 401, 481, 391, 489, 121, 421, 423, 71, 483, 327, 103, 231, 443, 459, 271, 399, 355, 91, 303, 431,
284  79, 207, 335, 111, 239, 281, 325, 279, 453, 101, 311, 87, 215, 31, 159, 63, 191
285 };
286 
287 static const uint16_t decoder_tree5[384] = {
288  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,
289  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,
290  76, 78, 80, 681, 171, 82, 84, 555, 86, 675, 88, 651, 5, 90, 92, 1025, 94, 96, 98, 683, 13,
291  100, 17, 102, 104, 106, 65, 108, 110, 257, 112, 114, 1153, 19, 116, 118, 120, 122, 124, 49, 126, 128,
292  769, 289, 130, 132, 134, 73, 136, 138, 140, 142, 193, 144, 146, 148, 150, 152, 154, 517, 156, 158, 37,
293  51, 160, 201, 162, 145, 164, 166, 168, 133, 170, 801, 45, 172, 174, 1057, 176, 178, 67, 180, 1027, 577,
294  182, 184, 186, 188, 190, 192, 194, 196, 198, 259, 200, 202, 204, 525, 177, 265, 141, 206, 208, 210, 212,
295  195, 297, 214, 75, 216, 1033, 203, 585, 1155, 1185, 267, 1161, 549, 218, 220, 657, 777, 147, 222, 224, 226,
296  228, 230, 232, 234, 236, 238, 240, 587, 645, 165, 242, 244, 246, 248, 250, 771, 291, 252, 579, 1065, 1035,
297  705, 531, 529, 659, 173, 254, 561, 653, 256, 713, 677, 557, 258, 260, 262, 264, 266, 268, 270, 272, 274,
298  276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 707, 1059, 809, 715, 563, 179, 691, 1193,
299  21, 779, 1067, 299, 1187, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332,
300  334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374,
301  376, 378, 380, 83, 69, 1281, 803, 321, 1195, 1163, 811, 1323, 689, 1321, 1099, 305, 835, 1227, 331, 843, 785,
302  593, 1043, 1291, 1283, 1171, 275, 787, 1217, 833, 1075, 1313, 1219, 1203, 307, 819, 841, 595, 211, 723, 721, 817,
303  1029, 329, 81, 1157, 261, 773, 1097, 1089, 1061, 1169, 1091, 1189, 293, 805, 1201, 581, 197, 709, 1289, 273, 1037,
304  1315, 1041, 1165, 269, 781, 209, 1073, 1069, 323, 685, 1197, 301, 813, 77, 589, 205, 717, 1225, 533, 149, 661,
305  53, 565, 181, 693, 0, 0
306 };
307 
308 static const uint16_t decoder_tree6[62] = {
309  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,
310  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,
311  61, 47, 59, 63
312 };
313 
314 static const uint16_t *const decoder_tables[7] = {
322 };
323 
324 static const int decoder_tables_elements[7] = {
332 };
333 
334 static const float mlt_quant[7][14] = {
335  { 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 },
336  { 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 },
337  { 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 },
338  { 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 },
339  { 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 },
340  { 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 },
341  { 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 }
342 };
343 
344 static const float noise_category5[20] = {
345  0.70711f, 0.6179f, 0.5005f, 0.3220f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f,
346  0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f
347 };
348 
349 static const float noise_category6[20] = {
350  0.70711f, 0.5686f, 0.3563f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f,
351  0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f
352 };
353 
354 #define FRAME_SIZE 320
355 
356 typedef struct SirenContext {
358 
365 
366  unsigned dw1, dw2, dw3, dw4;
367 
374 
378 
380  float *window;
381  float *imdct_in;
382  float *imdct_out;
383  float *imdct_prev;
384 } SirenContext;
385 
387 {
388  const float scale = 1.0f / (22.f * 32768.f);
389  SirenContext *s = avctx->priv_data;
390  int i;
391 
392  s->imdct_in = s->imdct_buf[0];
393  s->imdct_out = s->imdct_buf[1];
394  s->imdct_prev = s->imdct_buf[2];
395  s->window = s->imdct_buf[3];
396 
397  avctx->channels = 1;
399  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
400 
402  s->esf_adjustment = 7;
403  s->number_of_regions = 14;
404  s->scale_factor = 22;
405  s->region_size = 20;
406  s->dw1 = s->dw2 = s->dw3 = s->dw4 = 1;
407 
408  for (i = 0; i < 64; i++) {
409  float region_power = powf(10, (i - 24) * 0.3010299957);
410 
411  s->standard_deviation[i] = sqrtf(region_power);
412  }
413 
414  for (i = 0; i < FRAME_SIZE; i++) {
415  float angle = ((i + 0.5f) * M_PI_2) / 320.f;
416  s->window[i] = sinf(angle);
417  }
418 
420  if (!s->fdsp)
421  return AVERROR(ENOMEM);
422 
423  return av_tx_init(&s->tx_ctx, &s->tx_fn, AV_TX_FLOAT_MDCT, 1, FRAME_SIZE, &scale, 0);
424 }
425 
429 {
430  absolute_region_power_index[0] = (int)get_bits(gb, 5) - esf_adjustment;
431  absolute_region_power_index[0] = av_clip(absolute_region_power_index[0], -24, 39);
432  decoder_standard_deviation[0] = s->standard_deviation[absolute_region_power_index[0] + 24];
433 
434  for (int i = 1; i < number_of_regions; i++) {
435  int index = 0;
436 
437  do {
438  index = differential_decoder_tree[i - 1][index][get_bits1(gb)];
439  } while (index > 0);
440 
441  absolute_region_power_index[i] = av_clip(absolute_region_power_index[i - 1] - index - 12, -24, 39);
442  decoder_standard_deviation[i] = s->standard_deviation[absolute_region_power_index[i] + 24];
443  }
444 
445  return get_bits_count(gb);
446 }
447 
448 static int categorize_regions(int number_of_regions, int number_of_available_bits,
450  int *category_balance)
451 {
452  int region, delta, i, temp;
453  int expected_number_of_code_bits;
454  int min, max;
455  int offset, num_rate_control_possibilities = 16,
456  raw_value, raw_max_idx = 0, raw_min_idx = 0;
457  int max_rate_categories[28];
458  int min_rate_categories[28];
459  int temp_category_balances[64];
460  int *min_rate_ptr = NULL;
461  int *max_rate_ptr = NULL;
462 
463  offset = -32;
464  for (delta = 32; number_of_regions > 0 && delta > 0; delta /= 2) {
465  expected_number_of_code_bits = 0;
466  for (region = 0; region < number_of_regions; region++) {
467  i = (delta + offset -
468  absolute_region_power_index[region]) >> 1;
469  i = av_clip_uintp2(i, 3);
470  power_categories[region] = i;
471  expected_number_of_code_bits += expected_bits_table[i];
472 
473  }
474  if (expected_number_of_code_bits >= number_of_available_bits - 32)
475  offset += delta;
476  }
477 
478  expected_number_of_code_bits = 0;
479  for (region = 0; region < number_of_regions; region++) {
480  i = (offset - absolute_region_power_index[region]) >> 1;
481  i = av_clip_uintp2(i, 3);
482  max_rate_categories[region] = min_rate_categories[region] =
483  power_categories[region] = i;
484  expected_number_of_code_bits += expected_bits_table[i];
485  }
486 
487  min = max = expected_number_of_code_bits;
488  min_rate_ptr = max_rate_ptr =
489  temp_category_balances + num_rate_control_possibilities;
490  for (i = 0; i < num_rate_control_possibilities - 1; i++) {
491  if (min + max > number_of_available_bits * 2) {
492  raw_value = -99;
493  for (region = number_of_regions - 1; region >= 0; region--) {
494  if (min_rate_categories[region] < 7) {
495  temp =
496  offset - absolute_region_power_index[region] -
497  2 * min_rate_categories[region];
498  if (temp > raw_value) {
499  raw_value = temp;
500  raw_min_idx = region;
501  }
502  }
503  }
504  if (raw_value == -99)
505  return AVERROR_INVALIDDATA;
506  *min_rate_ptr++ = raw_min_idx;
507  min +=
508  expected_bits_table[min_rate_categories[raw_min_idx] + 1] -
509  expected_bits_table[min_rate_categories[raw_min_idx]];
510  min_rate_categories[raw_min_idx]++;
511  } else {
512  raw_value = 99;
513  for (region = 0; region < number_of_regions; region++) {
514  if (max_rate_categories[region] > 0) {
515  temp =
516  offset - absolute_region_power_index[region] -
517  2 * max_rate_categories[region];
518  if (temp < raw_value) {
519  raw_value = temp;
520  raw_max_idx = region;
521  }
522  }
523  }
524  if (raw_value == 99)
525  return AVERROR_INVALIDDATA;
526 
527  *--max_rate_ptr = raw_max_idx;
528  max += expected_bits_table[max_rate_categories[raw_max_idx] - 1] -
529  expected_bits_table[max_rate_categories[raw_max_idx]];
530  max_rate_categories[raw_max_idx]--;
531  }
532  }
533 
534  for (region = 0; region < number_of_regions; region++)
535  power_categories[region] = max_rate_categories[region];
536 
537  for (i = 0; i < num_rate_control_possibilities - 1; i++)
538  category_balance[i] = *max_rate_ptr++;
539 
540  return 0;
541 }
542 
543 static int get_dw(SirenContext *s)
544 {
545  int ret = s->dw1 + s->dw4;
546 
547  if ((ret & 0x8000) != 0)
548  ret++;
549 
550  s->dw1 = s->dw2;
551  s->dw2 = s->dw3;
552  s->dw3 = s->dw4;
553  s->dw4 = ret;
554 
555  return ret;
556 }
557 
559  int number_of_available_bits, float *decoder_standard_deviation,
560  int *power_categories, float *coefs, int scale_factor)
561 {
562  GetBitContext *gb = &s->gb;
563  float *coefs_ptr;
564  float decoded_value;
565  float noise;
566  const uint16_t *decoder_tree;
567  int region;
568  int category;
569  int i, j;
570  int index;
571  int error = 0;
572  int dw1;
573  int dw2;
574 
575  for (region = 0; region < number_of_regions; region++) {
576  category = power_categories[region];
577  coefs_ptr = coefs + (region * s->region_size);
578 
579  if (category >= 0 && category < 7) {
580  decoder_tree = decoder_tables[category];
581 
582  for (i = 0; i < number_of_vectors[category]; i++) {
583  index = 0;
584  do {
585  if (get_bits_left(gb) <= 0) {
586  error = 1;
587  break;
588  }
589 
590  if (index + show_bits1(gb) >= decoder_tables_elements[category]) {
591  error = 1;
592  break;
593  }
594  index = decoder_tree[index + get_bits1(gb)];
595  } while ((index & 1) == 0);
596 
597  index >>= 1;
598 
599  if (error == 0 && get_bits_left(gb) >= 0) {
600  for (j = 0; j < vector_dimension[category]; j++) {
601  decoded_value = mlt_quant[category][index & ((1 << index_table[category]) - 1)];
602  index >>= index_table[category];
603 
604  if (decoded_value) {
605  if (!get_bits1(gb))
606  decoded_value *= -decoder_standard_deviation[region];
607  else
608  decoded_value *= decoder_standard_deviation[region];
609  }
610 
611  *coefs_ptr++ = decoded_value * scale_factor;
612  }
613  } else {
614  error = 1;
615  break;
616  }
617  }
618 
619  if (error == 1) {
620  for (j = region + 1; j < number_of_regions; j++)
621  power_categories[j] = 7;
622  category = 7;
623  }
624  }
625 
626  coefs_ptr = coefs + (region * s->region_size);
627 
628  if (category == 5) {
629  i = 0;
630  for (j = 0; j < s->region_size; j++) {
631  if (*coefs_ptr != 0)
632  i++;
633  coefs_ptr++;
634  }
635 
636  noise = decoder_standard_deviation[region] * noise_category5[i];
637  } else if (category == 6) {
638  i = 0;
639  for (j = 0; j < s->region_size; j++) {
640  if (*coefs_ptr++ != 0)
641  i++;
642  }
643 
644  noise = decoder_standard_deviation[region] * noise_category6[i];
645  } else if (category == 7) {
646  noise = decoder_standard_deviation[region] * 0.70711f;
647  } else {
648  noise = 0;
649  }
650 
651  coefs_ptr = coefs + (region * s->region_size);
652 
653  if (category == 5 || category == 6 || category == 7) {
654  dw1 = get_dw(s);
655  dw2 = get_dw(s);
656 
657  for (j = 0; j < 10; j++) {
658  if (category == 7 || *coefs_ptr == 0)
659  *coefs_ptr = dw1 & 1 ? noise : -noise;
660  coefs_ptr++;
661  dw1 >>= 1;
662 
663  if (category == 7 || *coefs_ptr == 0)
664  *coefs_ptr = dw2 & 1 ? noise : -noise;
665  coefs_ptr++;
666  dw2 >>= 1;
667  }
668  }
669  }
670 
671  return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb);
672 }
673 
674 static int siren_decode(AVCodecContext *avctx, void *data,
675  int *got_frame, AVPacket *avpkt)
676 {
677  SirenContext *s = avctx->priv_data;
678  GetBitContext *gb = &s->gb;
679  AVFrame *frame = data;
680  int ret, number_of_valid_coefs = 20 * s->number_of_regions;
681  int frame_error = 0, rate_control = 0;
682 
683  if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
684  return ret;
685 
689 
690  rate_control = get_bits(gb, 4);
691 
694  s->category_balance);
695  if (ret < 0)
696  return ret;
697 
698  for (int i = 0; i < rate_control; i++)
700 
703  s->imdct_in, s->scale_factor);
704  if (ret < 0)
705  return ret;
706 
707  if (get_bits_left(gb) > 0) {
708  do {
709  frame_error |= !get_bits1(gb);
710  } while (get_bits_left(gb) > 0);
711  } else if (get_bits_left(gb) < 0 &&
712  rate_control + 1 < s->rate_control_possibilities) {
713  frame_error = 1;
714  }
715 
716  for (int i = 0; i < s->number_of_regions; i++) {
717  if (s->absolute_region_power_index[i] > 33 ||
718  s->absolute_region_power_index[i] < -31)
719  frame_error = 1;
720  }
721 
722  if (frame_error) {
723  memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
724  memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
725  } else {
726  memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
727  }
728 
729  frame->nb_samples = FRAME_SIZE;
730  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
731  return ret;
732 
733  for (int i = 0; i < 320; i += 2)
734  s->imdct_in[i] *= -1;
735 
736  s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
737  s->fdsp->vector_fmul_window((float *)frame->data[0],
738  s->imdct_prev + (FRAME_SIZE >> 1),
739  s->imdct_out, s->window,
740  FRAME_SIZE >> 1);
741  FFSWAP(float *, s->imdct_out, s->imdct_prev);
742 
743  *got_frame = 1;
744 
745  return avpkt->size;
746 }
747 
748 static av_cold void siren_flush(AVCodecContext *avctx)
749 {
750  SirenContext *s = avctx->priv_data;
751 
752  memset(s->backup_frame, 0, sizeof(s->backup_frame));
753  memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
754  memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
755 }
756 
758 {
759  SirenContext *s = avctx->priv_data;
760 
761  av_freep(&s->fdsp);
762  av_tx_uninit(&s->tx_ctx);
763 
764  return 0;
765 }
766 
768  .name = "siren",
769  .long_name = NULL_IF_CONFIG_SMALL("Siren"),
770  .priv_data_size = sizeof(SirenContext),
772  .id = AV_CODEC_ID_SIREN,
773  .init = siren_init,
774  .close = siren_close,
775  .decode = siren_decode,
776  .flush = siren_flush,
777  .capabilities = AV_CODEC_CAP_DR1,
778  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
780 };
category
Definition: openal-dec.c:248
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:533
unsigned dw3
Definition: siren.c:366
static const uint16_t decoder_tree2[96]
Definition: siren.c:208
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets ctx to NULL, does nothing when ctx == NULL.
Definition: tx.c:110
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
float * imdct_in
Definition: siren.c:381
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
else temp
Definition: vf_mcdeint.c:256
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static const uint16_t decoder_tree3[1040]
Definition: siren.c:215
int size
Definition: packet.h:364
static int decode_envelope(SirenContext *s, GetBitContext *gb, int number_of_regions, float *decoder_standard_deviation, int *absolute_region_power_index, int esf_adjustment)
Definition: siren.c:426
int number_of_regions
Definition: siren.c:361
GLint GLenum type
Definition: opengl_enc.c:104
unsigned dw2
Definition: siren.c:366
AVFloatDSPContext * fdsp
Definition: siren.c:375
static int categorize_regions(int number_of_regions, int number_of_available_bits, int *absolute_region_power_index, int *power_categories, int *category_balance)
Definition: siren.c:448
static void error(const char *err)
int absolute_region_power_index[32]
Definition: siren.c:368
int region_size
Definition: siren.c:364
AVCodec.
Definition: codec.h:190
static const uint16_t *const decoder_tables[7]
Definition: siren.c:314
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static const uint8_t index_table[8]
Definition: siren.c:32
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
float * window
Definition: siren.c:380
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
uint8_t
static int get_dw(SirenContext *s)
Definition: siren.c:543
#define av_cold
Definition: attributes.h:88
float delta
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int scale_factor
Definition: siren.c:362
static const float noise_category6[20]
Definition: siren.c:349
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
unsigned dw4
Definition: siren.c:366
uint8_t * data
Definition: packet.h:363
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
bitstream reader API header.
#define FRAME_SIZE
Definition: siren.c:354
#define max(a, b)
Definition: cuda_runtime.h:33
static const uint8_t expected_bits_table[8]
Definition: siren.c:35
static av_cold int siren_init(AVCodecContext *avctx)
Definition: siren.c:386
int sample_rate_bits
Definition: siren.c:363
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
static const float mlt_quant[7][14]
Definition: siren.c:334
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:92
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
AVTXContext * tx_ctx
Definition: siren.c:377
int power_categories[32]
Definition: siren.c:370
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
const char * name
Name of the codec implementation.
Definition: codec.h:197
float decoder_standard_deviation[32]
Definition: siren.c:369
float backup_frame[FRAME_SIZE]
Definition: siren.c:373
float * imdct_prev
Definition: siren.c:383
static const uint8_t number_of_vectors[8]
Definition: siren.c:34
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
#define powf(x, y)
Definition: libm.h:50
static av_cold void siren_flush(AVCodecContext *avctx)
Definition: siren.c:748
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
#define M_PI_2
Definition: mathematics.h:55
static const uint16_t decoder_tree4[416]
Definition: siren.c:264
int rate_control_possibilities
Definition: siren.c:359
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
static const uint16_t decoder_tree5[384]
Definition: siren.c:287
static const uint8_t vector_dimension[8]
Definition: siren.c:33
static int siren_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: siren.c:674
#define FF_ARRAY_ELEMS(a)
#define sinf(x)
Definition: libm.h:419
static const uint16_t decoder_tree0[360]
Definition: siren.c:174
Libavcodec external API header.
static const int8_t differential_decoder_tree[27][24][2]
Definition: siren.c:36
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static av_cold int siren_close(AVCodecContext *avctx)
Definition: siren.c:757
main external API structure.
Definition: avcodec.h:531
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1879
float imdct_buf[4][FRAME_SIZE]
Definition: siren.c:379
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static const float noise_category5[20]
Definition: siren.c:344
int index
Definition: gxfenc.c:89
unsigned dw1
Definition: siren.c:366
static int decode_vector(SirenContext *s, int number_of_regions, int number_of_available_bits, float *decoder_standard_deviation, int *power_categories, float *coefs, int scale_factor)
Definition: siren.c:558
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration Currently power of two lengths from 2 to ...
Definition: tx.c:123
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:36
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
static const uint16_t decoder_tree6[62]
Definition: siren.c:308
int
static const uint16_t decoder_tree1[188]
Definition: siren.c:196
common internal api header.
static const int decoder_tables_elements[7]
Definition: siren.c:324
float * imdct_out
Definition: siren.c:382
av_tx_fn tx_fn
Definition: siren.c:376
void * priv_data
Definition: avcodec.h:558
Standard MDCT with sample data type of float and a scale type of float.
Definition: tx.h:55
static int rate_control(AVCodecContext *avctx, void *arg)
Definition: vc2enc.c:615
int channels
number of audio channels
Definition: avcodec.h:1192
#define av_freep(p)
#define FFSWAP(type, a, b)
Definition: common.h:99
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define AV_CH_LAYOUT_MONO
float min
float standard_deviation[64]
Definition: siren.c:372
This structure stores compressed data.
Definition: packet.h:340
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
GetBitContext gb
Definition: siren.c:357
int i
Definition: input.c:407
int category_balance[32]
Definition: siren.c:371
AVCodec ff_siren_decoder
Definition: siren.c:767
int esf_adjustment
Definition: siren.c:360