GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/siren.c Lines: 0 229 0.0 %
Date: 2021-04-15 16:04:23 Branches: 0 136 0.0 %

Line Branch Exec Source
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
};