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