FFmpeg: libavcodec/siren.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /