GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/siren.c Lines: 0 234 0.0 %
Date: 2021-01-20 23:14:43 Branches: 0 138 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[20] = {
346
    0.70711f, 0.6179f, 0.5005f, 0.3220f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f,
347
    0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f
348
};
349
350
static const float noise_category6[20] = {
351
    0.70711f, 0.5686f, 0.3563f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f,
352
    0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f
353
};
354
355
#define FRAME_SIZE 320
356
357
typedef struct SirenContext {
358
    GetBitContext gb;
359
360
    int rate_control_possibilities;
361
    int esf_adjustment;
362
    int number_of_regions;
363
    int scale_factor;
364
    int sample_rate_bits;
365
    int region_size;
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->region_size = 20;
407
    s->dw1 = s->dw2 = s->dw3 = s->dw4 = 1;
408
409
    for (i = 0; i < 64; i++) {
410
        float region_power = powf(10, (i - 24) * 0.3010299957);
411
412
        s->standard_deviation[i] = sqrtf(region_power);
413
    }
414
415
    for (i = 0; i < FRAME_SIZE; i++) {
416
        float angle = ((i + 0.5f) * M_PI_2) / 320.f;
417
        s->window[i] = sinf(angle);
418
    }
419
420
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
421
    if (!s->fdsp)
422
        return AVERROR(ENOMEM);
423
424
    return av_tx_init(&s->tx_ctx, &s->tx_fn, AV_TX_FLOAT_MDCT, 1, FRAME_SIZE, &scale, 0);
425
}
426
427
static int decode_envelope(SirenContext *s, GetBitContext *gb,
428
                           int number_of_regions, float *decoder_standard_deviation,
429
                           int *absolute_region_power_index, int esf_adjustment)
430
{
431
    absolute_region_power_index[0] = (int)get_bits(gb, 5) - esf_adjustment;
432
    absolute_region_power_index[0] = av_clip(absolute_region_power_index[0], -24, 39);
433
    decoder_standard_deviation[0] = s->standard_deviation[absolute_region_power_index[0] + 24];
434
435
    for (int i = 1; i < number_of_regions; i++) {
436
        int index = 0;
437
438
        do {
439
            index = differential_decoder_tree[i - 1][index][get_bits1(gb)];
440
        } while (index > 0);
441
442
        absolute_region_power_index[i] = av_clip(absolute_region_power_index[i - 1] - index - 12, -24, 39);
443
        decoder_standard_deviation[i] = s->standard_deviation[absolute_region_power_index[i] + 24];
444
    }
445
446
    return get_bits_count(gb);
447
}
448
449
static int categorize_regions(int number_of_regions, int number_of_available_bits,
450
                              int *absolute_region_power_index, int *power_categories,
451
                              int *category_balance)
452
{
453
    int region, delta, i, temp;
454
    int expected_number_of_code_bits;
455
    int min, max;
456
    int offset, num_rate_control_possibilities = 16,
457
        raw_value, raw_max_idx = 0, raw_min_idx = 0;
458
    int max_rate_categories[28];
459
    int min_rate_categories[28];
460
    int temp_category_balances[64];
461
    int *min_rate_ptr = NULL;
462
    int *max_rate_ptr = NULL;
463
464
    offset = -32;
465
    for (delta = 32; number_of_regions > 0 && delta > 0; delta /= 2) {
466
        expected_number_of_code_bits = 0;
467
        for (region = 0; region < number_of_regions; region++) {
468
            i = (delta + offset -
469
                 absolute_region_power_index[region]) >> 1;
470
            i = av_clip_uintp2(i, 3);
471
            power_categories[region] = i;
472
            expected_number_of_code_bits += expected_bits_table[i];
473
474
        }
475
        if (expected_number_of_code_bits >= number_of_available_bits - 32)
476
            offset += delta;
477
    }
478
479
    expected_number_of_code_bits = 0;
480
    for (region = 0; region < number_of_regions; region++) {
481
        i = (offset - absolute_region_power_index[region]) >> 1;
482
        i = av_clip_uintp2(i, 3);
483
        max_rate_categories[region] = min_rate_categories[region] =
484
            power_categories[region] = i;
485
        expected_number_of_code_bits += expected_bits_table[i];
486
    }
487
488
    min = max = expected_number_of_code_bits;
489
    min_rate_ptr = max_rate_ptr =
490
        temp_category_balances + num_rate_control_possibilities;
491
    for (i = 0; i < num_rate_control_possibilities - 1; i++) {
492
        if (min + max > number_of_available_bits * 2) {
493
            raw_value = -99;
494
            for (region = number_of_regions - 1; region >= 0; region--) {
495
                if (min_rate_categories[region] < 7) {
496
                    temp =
497
                        offset - absolute_region_power_index[region] -
498
                        2 * min_rate_categories[region];
499
                    if (temp > raw_value) {
500
                        raw_value = temp;
501
                        raw_min_idx = region;
502
                    }
503
                }
504
            }
505
            if (raw_value == -99)
506
                return AVERROR_INVALIDDATA;
507
            *min_rate_ptr++ = raw_min_idx;
508
            min +=
509
                expected_bits_table[min_rate_categories[raw_min_idx] + 1] -
510
                expected_bits_table[min_rate_categories[raw_min_idx]];
511
            min_rate_categories[raw_min_idx]++;
512
        } else {
513
            raw_value = 99;
514
            for (region = 0; region < number_of_regions; region++) {
515
                if (max_rate_categories[region] > 0) {
516
                    temp =
517
                        offset - absolute_region_power_index[region] -
518
                        2 * max_rate_categories[region];
519
                    if (temp < raw_value) {
520
                        raw_value = temp;
521
                        raw_max_idx = region;
522
                    }
523
                }
524
            }
525
            if (raw_value == 99)
526
                return AVERROR_INVALIDDATA;
527
528
            *--max_rate_ptr = raw_max_idx;
529
            max += expected_bits_table[max_rate_categories[raw_max_idx] - 1] -
530
                   expected_bits_table[max_rate_categories[raw_max_idx]];
531
            max_rate_categories[raw_max_idx]--;
532
        }
533
    }
534
535
    for (region = 0; region < number_of_regions; region++)
536
        power_categories[region] = max_rate_categories[region];
537
538
    for (i = 0; i < num_rate_control_possibilities - 1; i++)
539
        category_balance[i] = *max_rate_ptr++;
540
541
    return 0;
542
}
543
544
static int get_dw(SirenContext *s)
545
{
546
    int ret = s->dw1 + s->dw4;
547
548
    if ((ret & 0x8000) != 0)
549
        ret++;
550
551
    s->dw1 = s->dw2;
552
    s->dw2 = s->dw3;
553
    s->dw3 = s->dw4;
554
    s->dw4 = ret;
555
556
    return ret;
557
}
558
559
static int decode_vector(SirenContext *s, int number_of_regions,
560
                         int number_of_available_bits, float *decoder_standard_deviation,
561
                         int *power_categories, float *coefs, int scale_factor)
562
{
563
    GetBitContext *gb = &s->gb;
564
    float *coefs_ptr;
565
    float decoded_value;
566
    float noise;
567
    const uint16_t *decoder_tree;
568
    int region;
569
    int category;
570
    int i, j;
571
    int index;
572
    int error = 0;
573
    int dw1;
574
    int dw2;
575
576
    for (region = 0; region < number_of_regions; region++) {
577
        category = power_categories[region];
578
        coefs_ptr = coefs + (region * s->region_size);
579
580
        if (category >= 0 && category < 7) {
581
            decoder_tree = decoder_tables[category];
582
583
            for (i = 0; i < number_of_vectors[category]; i++) {
584
                index = 0;
585
                do {
586
                    if (get_bits_left(gb) <= 0) {
587
                        error = 1;
588
                        break;
589
                    }
590
591
                    if (index + show_bits1(gb) >= decoder_tables_elements[category]) {
592
                        error = 1;
593
                        break;
594
                    }
595
                    index = decoder_tree[index + get_bits1(gb)];
596
                } while ((index & 1) == 0);
597
598
                index >>= 1;
599
600
                if (error == 0 && get_bits_left(gb) >= 0) {
601
                    for (j = 0; j < vector_dimension[category]; j++) {
602
                        decoded_value = mlt_quant[category][index & ((1 << index_table[category]) - 1)];
603
                        index >>= index_table[category];
604
605
                        if (decoded_value) {
606
                            if (!get_bits1(gb))
607
                                decoded_value *= -decoder_standard_deviation[region];
608
                            else
609
                                decoded_value *= decoder_standard_deviation[region];
610
                        }
611
612
                        *coefs_ptr++ = decoded_value * scale_factor;
613
                    }
614
                } else {
615
                    error = 1;
616
                    break;
617
                }
618
            }
619
620
            if (error == 1) {
621
                for (j = region + 1; j < number_of_regions; j++)
622
                    power_categories[j] = 7;
623
                category = 7;
624
            }
625
        }
626
627
        coefs_ptr = coefs + (region * s->region_size);
628
629
        if (category == 5) {
630
            i = 0;
631
            for (j = 0; j < s->region_size; j++) {
632
                if (*coefs_ptr != 0)
633
                    i++;
634
                coefs_ptr++;
635
            }
636
637
            noise = decoder_standard_deviation[region] * noise_category5[i];
638
        } else if (category == 6) {
639
            i = 0;
640
            for (j = 0; j < s->region_size; j++) {
641
                if (*coefs_ptr++ != 0)
642
                    i++;
643
            }
644
645
            noise = decoder_standard_deviation[region] * noise_category6[i];
646
        } else if (category == 7) {
647
            noise = decoder_standard_deviation[region] * 0.70711f;
648
        } else {
649
            noise = 0;
650
        }
651
652
        coefs_ptr = coefs + (region * s->region_size);
653
654
        if (category == 5 || category == 6 || category == 7) {
655
            dw1 = get_dw(s);
656
            dw2 = get_dw(s);
657
658
            for (j = 0; j < 10; j++) {
659
                if (category == 7 || *coefs_ptr == 0)
660
                    *coefs_ptr = dw1 & 1 ? noise : -noise;
661
                coefs_ptr++;
662
                dw1 >>= 1;
663
664
                if (category == 7 || *coefs_ptr == 0)
665
                    *coefs_ptr = dw2 & 1 ? noise : -noise;
666
                coefs_ptr++;
667
                dw2 >>= 1;
668
            }
669
        }
670
    }
671
672
    return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb);
673
}
674
675
static int siren_decode(AVCodecContext *avctx, void *data,
676
                        int *got_frame, AVPacket *avpkt)
677
{
678
    SirenContext *s = avctx->priv_data;
679
    GetBitContext *gb = &s->gb;
680
    AVFrame *frame = data;
681
    int ret, number_of_valid_coefs = 20 * s->number_of_regions;
682
    int frame_error = 0, rate_control = 0;
683
684
    if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
685
        return ret;
686
687
    decode_envelope(s, gb, s->number_of_regions,
688
                    s->decoder_standard_deviation,
689
                    s->absolute_region_power_index, s->esf_adjustment);
690
691
    rate_control = get_bits(gb, 4);
692
693
    ret = categorize_regions(s->number_of_regions, get_bits_left(gb),
694
                             s->absolute_region_power_index, s->power_categories,
695
                             s->category_balance);
696
    if (ret < 0)
697
        return ret;
698
699
    for (int i = 0; i < rate_control; i++)
700
        s->power_categories[s->category_balance[i]]++;
701
702
    ret = decode_vector(s, s->number_of_regions, get_bits_left(gb),
703
                        s->decoder_standard_deviation, s->power_categories,
704
                        s->imdct_in, s->scale_factor);
705
    if (ret < 0)
706
        return ret;
707
708
    if (get_bits_left(gb) > 0) {
709
        do {
710
            frame_error |= !get_bits1(gb);
711
        } while (get_bits_left(gb) > 0);
712
    } else if (get_bits_left(gb) < 0 &&
713
               rate_control + 1 < s->rate_control_possibilities) {
714
        frame_error = 1;
715
    }
716
717
    for (int i = 0; i < s->number_of_regions; i++) {
718
        if (s->absolute_region_power_index[i] > 33 ||
719
            s->absolute_region_power_index[i] < -31)
720
            frame_error = 1;
721
    }
722
723
    if (frame_error) {
724
        memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
725
        memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
726
    } else {
727
        memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
728
    }
729
730
    frame->nb_samples = FRAME_SIZE;
731
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
732
        return ret;
733
734
    for (int i = 0; i < 320; i += 2)
735
        s->imdct_in[i] *= -1;
736
737
    s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
738
    s->fdsp->vector_fmul_window((float *)frame->data[0],
739
                                s->imdct_prev + (FRAME_SIZE >> 1),
740
                                s->imdct_out, s->window,
741
                                FRAME_SIZE >> 1);
742
    FFSWAP(float *, s->imdct_out, s->imdct_prev);
743
744
    *got_frame = 1;
745
746
    return avpkt->size;
747
}
748
749
static av_cold void siren_flush(AVCodecContext *avctx)
750
{
751
    SirenContext *s = avctx->priv_data;
752
753
    memset(s->backup_frame, 0, sizeof(s->backup_frame));
754
    memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
755
    memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
756
}
757
758
static av_cold int siren_close(AVCodecContext *avctx)
759
{
760
    SirenContext *s = avctx->priv_data;
761
762
    av_freep(&s->fdsp);
763
    av_tx_uninit(&s->tx_ctx);
764
765
    return 0;
766
}
767
768
AVCodec ff_siren_decoder = {
769
    .name           = "siren",
770
    .long_name      = NULL_IF_CONFIG_SMALL("Siren"),
771
    .priv_data_size = sizeof(SirenContext),
772
    .type           = AVMEDIA_TYPE_AUDIO,
773
    .id             = AV_CODEC_ID_SIREN,
774
    .init           = siren_init,
775
    .close          = siren_close,
776
    .decode         = siren_decode,
777
    .flush          = siren_flush,
778
    .capabilities   = AV_CODEC_CAP_CHANNEL_CONF |
779
                      AV_CODEC_CAP_DR1,
780
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
781
                      FF_CODEC_CAP_INIT_CLEANUP,
782
};