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[21] = {
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[21] = {
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 #define REGION_SIZE 20
357 
358 typedef struct SirenContext {
360 
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->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 * 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 * REGION_SIZE);
627 
628  if (category == 5 || category == 6) {
629  i = 0;
630  for (j = 0; j < REGION_SIZE; j++) {
631  if (*coefs_ptr != 0)
632  i++;
633  coefs_ptr++;
634  }
635 
636  if (category == 5) {
637  noise = decoder_standard_deviation[region] * noise_category5[i];
638  } else
639  noise = decoder_standard_deviation[region] * noise_category6[i];
640  } else if (category == 7) {
641  noise = decoder_standard_deviation[region] * 0.70711f;
642  } else {
643  noise = 0;
644  }
645 
646  coefs_ptr = coefs + (region * REGION_SIZE);
647 
648  if (category == 5 || category == 6 || category == 7) {
649  dw1 = get_dw(s);
650  dw2 = get_dw(s);
651 
652  for (j = 0; j < 10; j++) {
653  if (category == 7 || *coefs_ptr == 0)
654  *coefs_ptr = dw1 & 1 ? noise : -noise;
655  coefs_ptr++;
656  dw1 >>= 1;
657 
658  if (category == 7 || *coefs_ptr == 0)
659  *coefs_ptr = dw2 & 1 ? noise : -noise;
660  coefs_ptr++;
661  dw2 >>= 1;
662  }
663  }
664  }
665 
666  return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb);
667 }
668 
669 static int siren_decode(AVCodecContext *avctx, void *data,
670  int *got_frame, AVPacket *avpkt)
671 {
672  SirenContext *s = avctx->priv_data;
673  GetBitContext *gb = &s->gb;
674  AVFrame *frame = data;
675  int ret, number_of_valid_coefs = 20 * s->number_of_regions;
676  int frame_error = 0, rate_control = 0;
677 
678  if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
679  return ret;
680 
684 
685  rate_control = get_bits(gb, 4);
686 
689  s->category_balance);
690  if (ret < 0)
691  return ret;
692 
693  for (int i = 0; i < rate_control; i++)
695 
698  s->imdct_in, s->scale_factor);
699  if (ret < 0)
700  return ret;
701 
702  if (get_bits_left(gb) > 0) {
703  do {
704  frame_error |= !get_bits1(gb);
705  } while (get_bits_left(gb) > 0);
706  } else if (get_bits_left(gb) < 0 &&
707  rate_control + 1 < s->rate_control_possibilities) {
708  frame_error = 1;
709  }
710 
711  for (int i = 0; i < s->number_of_regions; i++) {
712  if (s->absolute_region_power_index[i] > 33 ||
713  s->absolute_region_power_index[i] < -31)
714  frame_error = 1;
715  }
716 
717  if (frame_error) {
718  memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
719  memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
720  } else {
721  memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
722  }
723 
724  frame->nb_samples = FRAME_SIZE;
725  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
726  return ret;
727 
728  for (int i = 0; i < 320; i += 2)
729  s->imdct_in[i] *= -1;
730 
731  s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
732  s->fdsp->vector_fmul_window((float *)frame->data[0],
733  s->imdct_prev + (FRAME_SIZE >> 1),
734  s->imdct_out, s->window,
735  FRAME_SIZE >> 1);
736  FFSWAP(float *, s->imdct_out, s->imdct_prev);
737 
738  *got_frame = 1;
739 
740  return avpkt->size;
741 }
742 
743 static av_cold void siren_flush(AVCodecContext *avctx)
744 {
745  SirenContext *s = avctx->priv_data;
746 
747  memset(s->backup_frame, 0, sizeof(s->backup_frame));
748  memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
749  memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
750 }
751 
753 {
754  SirenContext *s = avctx->priv_data;
755 
756  av_freep(&s->fdsp);
757  av_tx_uninit(&s->tx_ctx);
758 
759  return 0;
760 }
761 
763  .name = "siren",
764  .long_name = NULL_IF_CONFIG_SMALL("Siren"),
765  .priv_data_size = sizeof(SirenContext),
767  .id = AV_CODEC_ID_SIREN,
768  .init = siren_init,
769  .close = siren_close,
770  .decode = siren_decode,
771  .flush = siren_flush,
772  .capabilities = AV_CODEC_CAP_CHANNEL_CONF |
774  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
776 };
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:49
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:146
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define av_clip_uintp2
Definition: common.h:146
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
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:259
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static const uint16_t decoder_tree3[1040]
Definition: siren.c:216
int size
Definition: packet.h:370
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:363
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:448
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
#define FF_ARRAY_ELEMS(a)
static void error(const char *err)
int absolute_region_power_index[32]
Definition: siren.c:369
fg index
AVCodec.
Definition: codec.h:197
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:41
float * window
Definition: siren.c:381
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
uint8_t
static int get_dw(SirenContext *s)
Definition: siren.c:543
#define av_cold
Definition: attributes.h:88
float delta
#define REGION_SIZE
Definition: siren.c:356
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:364
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
#define av_clip
Definition: common.h:122
unsigned dw4
Definition: siren.c:367
uint8_t * data
Definition: packet.h:369
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:365
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:99
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:117
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
static const float noise_category6[21]
Definition: siren.c:350
const char * name
Name of the codec implementation.
Definition: codec.h:204
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
static const float noise_category5[21]
Definition: siren.c:345
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
#define powf(x, y)
Definition: libm.h:50
static av_cold void siren_flush(AVCodecContext *avctx)
Definition: siren.c:743
#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:361
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:669
#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:752
main external API structure.
Definition: avcodec.h:536
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
float imdct_buf[4][FRAME_SIZE]
Definition: siren.c:380
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
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: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 (i)MDCTs with an odd length are currently...
Definition: tx.c:160
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:332
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:563
Standard MDCT with sample data type of float and a scale type of float.
Definition: tx.h:58
static int rate_control(AVCodecContext *avctx, void *arg)
Definition: vc2enc.c:615
int channels
number of audio channels
Definition: avcodec.h:1197
#define av_freep(p)
#define FFSWAP(type, a, b)
Definition: common.h:108
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:346
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...
Definition: codec.h:52
GetBitContext gb
Definition: siren.c:359
int i
Definition: input.c:407
int category_balance[32]
Definition: siren.c:372
AVCodec ff_siren_decoder
Definition: siren.c:762
int esf_adjustment
Definition: siren.c:362