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] = {
316  decoder_tree0,
317  decoder_tree1,
318  decoder_tree2,
319  decoder_tree3,
320  decoder_tree4,
321  decoder_tree5,
322  decoder_tree6,
323 };
324 
325 static const int decoder_tables_elements[7] = {
326  FF_ARRAY_ELEMS(decoder_tree0),
327  FF_ARRAY_ELEMS(decoder_tree1),
328  FF_ARRAY_ELEMS(decoder_tree2),
329  FF_ARRAY_ELEMS(decoder_tree3),
330  FF_ARRAY_ELEMS(decoder_tree4),
331  FF_ARRAY_ELEMS(decoder_tree5),
332  FF_ARRAY_ELEMS(decoder_tree6),
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 {
359  GetBitContext gb;
360 
361  int rate_control_possibilities;
362  int esf_adjustment;
363  int number_of_regions;
364  int scale_factor;
365  int sample_rate_bits;
366 
367  unsigned dw1, dw2, dw3, dw4;
368 
369  int absolute_region_power_index[32];
370  float decoder_standard_deviation[32];
371  int power_categories[32];
372  int category_balance[32];
373  float standard_deviation[64];
374  float backup_frame[FRAME_SIZE];
375 
376  AVFloatDSPContext *fdsp;
377  av_tx_fn tx_fn;
378  AVTXContext *tx_ctx;
379 
380  DECLARE_ALIGNED(32, float, imdct_buf)[4][FRAME_SIZE];
381  float *window;
382  float *imdct_in;
383  float *imdct_out;
384  float *imdct_prev;
385 } SirenContext;
386 
387 static av_cold int siren_init(AVCodecContext *avctx)
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;
399  avctx->channel_layout = AV_CH_LAYOUT_MONO;
400  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
401 
402  s->rate_control_possibilities = 16;
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 
419  s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
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 
426 static int decode_envelope(SirenContext *s, GetBitContext *gb,
427  int number_of_regions, float *decoder_standard_deviation,
428  int *absolute_region_power_index, int esf_adjustment)
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,
449  int *absolute_region_power_index, int *power_categories,
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 
558 static int decode_vector(SirenContext *s, int number_of_regions,
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 
681  decode_envelope(s, gb, s->number_of_regions,
682  s->decoder_standard_deviation,
683  s->absolute_region_power_index, s->esf_adjustment);
684 
685  rate_control = get_bits(gb, 4);
686 
687  ret = categorize_regions(s->number_of_regions, get_bits_left(gb),
688  s->absolute_region_power_index, s->power_categories,
689  s->category_balance);
690  if (ret < 0)
691  return ret;
692 
693  for (int i = 0; i < rate_control; i++)
694  s->power_categories[s->category_balance[i]]++;
695 
696  ret = decode_vector(s, s->number_of_regions, get_bits_left(gb),
697  s->decoder_standard_deviation, s->power_categories,
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 
752 static av_cold int siren_close(AVCodecContext *avctx)
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 
762 AVCodec ff_siren_decoder = {
763  .name = "siren",
764  .long_name = NULL_IF_CONFIG_SMALL("Siren"),
765  .priv_data_size = sizeof(SirenContext),
766  .type = AVMEDIA_TYPE_AUDIO,
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 |
773  AV_CODEC_CAP_DR1,
774  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
775  FF_CODEC_CAP_INIT_CLEANUP,
776 };
category
category
Definition: openal-dec.c:248
FF_CODEC_CAP_INIT_CLEANUP
#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
show_bits1
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:533
SirenContext::dw3
unsigned dw3
Definition: siren.c:367
decoder_tree2
static const uint16_t decoder_tree2[96]
Definition: siren.c:209
av_tx_uninit
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
NULL
#define NULL
Definition: coverity.c:32
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:146
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
SirenContext::imdct_in
float * imdct_in
Definition: siren.c:382
ret
ret
Definition: filter_design.txt:187
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
temp
else temp
Definition: vf_mcdeint.c:259
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
decoder_tree3
static const uint16_t decoder_tree3[1040]
Definition: siren.c:216
AVPacket::size
int size
Definition: packet.h:370
float_dsp.h
decode_envelope
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
SirenContext::number_of_regions
int number_of_regions
Definition: siren.c:363
type
GLint GLenum type
Definition: opengl_enc.c:104
SirenContext::dw2
unsigned dw2
Definition: siren.c:367
SirenContext::fdsp
AVFloatDSPContext * fdsp
Definition: siren.c:376
categorize_regions
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
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
SirenContext::absolute_region_power_index
int absolute_region_power_index[32]
Definition: siren.c:369
index
fg index
Definition: ffmpeg_filter.c:170
AVCodec
AVCodec.
Definition: codec.h:197
decoder_tables
static const uint16_t *const decoder_tables[7]
Definition: siren.c:315
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
index_table
static const uint8_t index_table[8]
Definition: siren.c:33
FF_CODEC_CAP_INIT_THREADSAFE
#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
SirenContext::window
float * window
Definition: siren.c:381
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
uint8_t
uint8_t
Definition: audio_convert.c:194
get_dw
static int get_dw(SirenContext *s)
Definition: siren.c:543
av_cold
#define av_cold
Definition: attributes.h:88
delta
float delta
Definition: vorbis_enc_data.h:457
REGION_SIZE
#define REGION_SIZE
Definition: siren.c:356
offset
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
Definition: writing_filters.txt:84
SirenContext::scale_factor
int scale_factor
Definition: siren.c:364
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
av_clip
#define av_clip
Definition: common.h:122
SirenContext::dw4
unsigned dw4
Definition: siren.c:367
AVPacket::data
uint8_t * data
Definition: packet.h:369
AV_CODEC_ID_SIREN
Definition: codec_id.h:517
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
get_bits.h
bitstream reader API header.
FRAME_SIZE
#define FRAME_SIZE
Definition: siren.c:355
max
#define max(a, b)
Definition: cuda_runtime.h:33
expected_bits_table
static const uint8_t expected_bits_table[8]
Definition: siren.c:36
siren_init
static av_cold int siren_init(AVCodecContext *avctx)
Definition: siren.c:387
SirenContext::sample_rate_bits
int sample_rate_bits
Definition: siren.c:365
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVFloatDSPContext::vector_fmul_window
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
mlt_quant
static const float mlt_quant[7][14]
Definition: siren.c:335
av_tx_fn
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
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
SirenContext::tx_ctx
AVTXContext * tx_ctx
Definition: siren.c:378
SirenContext::power_categories
int power_categories[32]
Definition: siren.c:371
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
noise_category6
static const float noise_category6[21]
Definition: siren.c:350
AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
SirenContext::decoder_standard_deviation
float decoder_standard_deviation[32]
Definition: siren.c:370
SirenContext::backup_frame
float backup_frame[FRAME_SIZE]
Definition: siren.c:374
SirenContext::imdct_prev
float * imdct_prev
Definition: siren.c:384
number_of_vectors
static const uint8_t number_of_vectors[8]
Definition: siren.c:35
noise_category5
static const float noise_category5[21]
Definition: siren.c:345
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
powf
#define powf(x, y)
Definition: libm.h:50
siren_flush
static av_cold void siren_flush(AVCodecContext *avctx)
Definition: siren.c:743
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
M_PI_2
#define M_PI_2
Definition: mathematics.h:55
decoder_tree4
static const uint16_t decoder_tree4[416]
Definition: siren.c:265
SirenContext::rate_control_possibilities
int rate_control_possibilities
Definition: siren.c:361
frame
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
Definition: filter_design.txt:255
s
#define s(width, name)
Definition: cbs_vp9.c:257
decoder_tree5
static const uint16_t decoder_tree5[384]
Definition: siren.c:288
vector_dimension
static const uint8_t vector_dimension[8]
Definition: siren.c:34
siren_decode
static int siren_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: siren.c:669
sinf
#define sinf(x)
Definition: libm.h:419
decoder_tree0
static const uint16_t decoder_tree0[360]
Definition: siren.c:175
avcodec.h
Libavcodec external API header.
differential_decoder_tree
static const int8_t differential_decoder_tree[27][24][2]
Definition: siren.c:37
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
siren_close
static av_cold int siren_close(AVCodecContext *avctx)
Definition: siren.c:752
AVCodecContext
main external API structure.
Definition: avcodec.h:536
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
SirenContext::imdct_buf
float imdct_buf[4][FRAME_SIZE]
Definition: siren.c:380
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
SirenContext::dw1
unsigned dw1
Definition: siren.c:367
decode_vector
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_tx_init
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
noise
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:36
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
decoder_tree6
static const uint16_t decoder_tree6[62]
Definition: siren.c:309
int
int
Definition: ffmpeg_filter.c:158
decoder_tree1
static const uint16_t decoder_tree1[188]
Definition: siren.c:197
internal.h
common internal api header.
decoder_tables_elements
static const int decoder_tables_elements[7]
Definition: siren.c:325
SirenContext::imdct_out
float * imdct_out
Definition: siren.c:383
SirenContext::tx_fn
av_tx_fn tx_fn
Definition: siren.c:377
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AV_TX_FLOAT_MDCT
Standard MDCT with sample data type of float and a scale type of float.
Definition: tx.h:58
rate_control
static int rate_control(AVCodecContext *avctx, void *arg)
Definition: vc2enc.c:615
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
AVERROR
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
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
min
float min
Definition: vorbis_enc_data.h:456
SirenContext::standard_deviation
float standard_deviation[64]
Definition: siren.c:373
AVPacket
This structure stores compressed data.
Definition: packet.h:346
mem_internal.h
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...
Definition: codec.h:52
SirenContext::gb
GetBitContext gb
Definition: siren.c:359
i
int i
Definition: input.c:407
SirenContext::category_balance
int category_balance[32]
Definition: siren.c:372
ff_siren_decoder
AVCodec ff_siren_decoder
Definition: siren.c:762
SirenContext::esf_adjustment
int esf_adjustment
Definition: siren.c:362
Generated on Mon Apr 12 2021 19:21:59 for FFmpeg by   doxygen 1.8.11