GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/siren.c Lines: 0 234 0.0 %
Date: 2020-10-23 17:01:47 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
27
#include "avcodec.h"
28
#include "get_bits.h"
29
#include "internal.h"
30
#include "mathops.h"
31
32
static const uint8_t index_table[8] = {4, 4, 3, 3, 2, 2, 1, 0};
33
static const uint8_t vector_dimension[8] = { 2, 2, 2, 4, 4, 5, 5, 1 };
34
static const uint8_t number_of_vectors[8] = { 10, 10, 10, 5, 5, 4, 4, 20 };
35
static const uint8_t expected_bits_table[8] = { 52, 47, 43, 37, 29, 22, 16, 0 };
36
static const int8_t differential_decoder_tree[27][24][2] = {
37
    {
38
        {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {11, -12}, {-11, -10}, {-8, -9}, {-7, -6}, {-13, 12},
39
        {-5, -4}, {0, 13}, {-3, -14}, {-2, 14}, {-1, 15}, {-15, 16}, {-16, 17}, {-17, 18}, {19, 20},
40
        {21, 22}, {-18, -19}, {-20, -21}, {-22, -23}, {-32, -32}
41
    },
42
    {
43
        {1, 2}, {3, 4}, {5, 6}, {7, 8}, {-10, -9}, {-8, -11}, {-7, -6}, {9, -5}, {10, -12}, {-4, 11},
44
        {-13, -3}, {12, -2}, {13, -14}, {-1, 14}, {15, -15}, {0, 16}, {-16, 17}, {-17, 18}, {-18, 19},
45
        {20, 21},{22, -19}, {-20, -21}, {-22, -23}, {-32, -32}
46
    },
47
    {
48
        {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {-12, 11}, {-11, -13}, {-10, -9}, {12, -14}, {-8, -7},
49
        {-15, -6}, {13, -5}, {-16, -4}, {14, -17}, {15, -3}, {16, -18}, {-2, 17}, {18, -19}, {-1, 19},
50
        {-20, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}
51
    },
52
    {
53
        {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {7, -12}, {8, -9}, {9, -13}, {-14, 10}, {-8, -15}, {-16, 11},
54
        {-7, 12}, {-17, -6}, {13, 14}, {-18, 15}, {-5, -4}, {16, 17}, {-3, -2}, {-19, 18}, {-1, 19},
55
        {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
56
    },
57
    {
58
        {1, 2}, {3, 4}, {5, 6}, {-12, -11}, {-13, 7}, {8, -14}, {-10, 9}, {10, -15}, {-9, 11}, {-8, 12},
59
        {-16, 13}, {-7, -6}, {-17, 14}, {-5, -18}, {15, -4}, {16, -19}, {17, -3}, {-20, 18}, {-2, 19},
60
        {-21, 20}, {0, 21}, {22, -1}, {-22, -23}, {-32, -32}
61
    },
62
    {
63
        {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-12, -10}, {-13, -9}, {8, 9}, {-14, -8}, {10, -15}, {-7, 11},
64
        {-16, 12}, {-6, -17}, {13, 14}, {-5, 15}, {-18, 16}, {-4, 17}, {-3, -19}, {18, -2}, {-20, 19},
65
        {-1, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}
66
    },
67
    {
68
        {1, 2}, {3, 4}, {5, -12}, {6, -11}, {-10, -13}, {-9, 7}, {8, -14}, {9, -8}, {-15, 10}, {-7, -16},
69
        {11, -6}, {12, -17}, {13, -5}, {-18, 14}, {15, -4}, {-19, 16}, {17, -3}, {-20, 18}, {19, 20},
70
        {21, 22}, {0, -2}, {-1, -21}, {-22, -23}, {-32, -32}
71
    },
72
    {
73
        {1, 2}, {3, 4}, {5, -12}, {6, -13}, {-11, -10}, {7, -14}, {8, -9}, {9, -15}, {-8, 10}, {-7, -16},
74
        {11, 12}, {-6, -17}, {-5, 13}, {14, 15}, {-18, -4}, {-19, 16}, {-3, 17}, {18, -2}, {-20, 19},
75
        {20, 21}, {22, 0}, {-1, -21}, {-22, -23}, {-32, -32}
76
    },
77
    {
78
        {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {-12, -9}, {7, 8}, {-13, -8}, {9, -14}, {-7, 10}, {-6, -15},
79
        {11, 12}, {-5, -16}, {13, 14}, {-17, 15}, {-4, 16}, {17, -18}, {18, -3}, {-2, 19}, {-1, 0},
80
        {-19, 20}, {-20, 21}, {22, -21}, {-22, -23}, {-32, -32}
81
    },
82
    {
83
        {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-10, -12}, {-9, 8}, {-8, -13}, {9, -7}, {10, -14}, {-6, 11},
84
        {-15, 12}, {-5, 13}, {-16, -4}, {14, 15}, {-17, -3}, {-18, 16}, {17, -19}, {-2, 18}, {-20, 19},
85
        {-1, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
86
    },
87
    {
88
        {1, 2}, {3, 4}, {5, -12}, {6, -11}, {7, 8}, {-10, -13}, {-9, 9}, {-8, -14}, {10, -7}, {11, -15},
89
        {-6, 12}, {-5, 13}, {-4, -16}, {14, 15}, {-3, -17}, {16, 17}, {-18, -2}, {18, -19}, {-1, 19},
90
        {-20, 20}, {-21, 21}, {22, 0}, {-22, -23}, {-32, -32}
91
    },
92
    {
93
        {1, 2}, {3, 4}, {5, -12}, {-13, 6}, {-11, 7}, {-14, 8}, {-10, 9}, {-15, -9}, {-8, 10}, {-7, -16},
94
        {11, -6}, {12, -5}, {-17, 13}, {14, -18}, {15, -4}, {16, -19}, {17, -3}, {18, -2}, {19, -1},
95
        {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
96
    },
97
    {
98
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
99
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
100
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
101
    },
102
    {
103
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
104
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
105
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
106
    },
107
    {
108
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
109
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
110
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
111
    },
112
    {
113
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
114
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
115
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
116
    },
117
    {
118
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
119
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
120
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
121
    },
122
    {
123
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
124
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
125
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
126
    },
127
    {
128
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
129
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
130
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
131
    },
132
    {
133
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
134
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
135
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
136
    },
137
    {
138
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
139
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
140
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
141
    },
142
    {
143
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
144
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
145
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
146
    },
147
    {
148
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
149
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
150
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
151
    },
152
    {
153
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
154
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
155
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
156
    },
157
    {
158
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
159
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
160
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
161
    },
162
    {
163
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
164
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
165
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
166
    },
167
    {
168
        {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
169
        {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
170
        {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
171
    },
172
};
173
174
static const uint16_t decoder_tree0[360] = {
175
    2, 1, 4, 6, 8, 10, 12, 14, 16, 18, 33, 3, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 35, 40,
176
    42, 44, 46, 5, 48, 65, 50, 52, 54, 56, 58, 60, 62, 64, 37, 66, 67, 68, 97, 70, 72, 74, 7,
177
    76, 78, 80, 82, 84, 86, 88, 99, 90, 39, 92, 94, 96, 129, 98, 9, 100, 102, 104, 106, 108,
178
    110, 112, 41, 161, 69, 114, 116, 118, 131, 120, 122, 11, 124, 126, 128, 193, 130, 132, 71,
179
    134, 43, 136, 138, 140, 163, 101, 13, 142, 144, 146, 148, 150, 152, 154, 225, 156, 158, 195,
180
    160, 162, 45, 164, 15, 166, 73, 168, 170, 133, 47, 172, 257, 174, 176, 178, 75, 103, 180, 165,
181
    182, 17, 227, 184, 105, 49, 135, 186, 289, 188, 259, 190, 192, 194, 196, 198, 291, 77, 200,
182
    202, 197, 107, 204, 19, 51, 229, 206, 167, 208, 210, 212, 214, 21, 79, 81, 109, 216, 218, 220,
183
    222, 53, 137, 224, 199, 226, 323, 321, 169, 228, 111, 230, 232, 139, 261, 234, 83, 236, 201,
184
    238, 240, 293, 242, 353, 231, 141, 244, 246, 113, 23, 355, 85, 248, 55, 115, 250, 263, 252,
185
    254, 203, 171, 256, 258, 233, 235, 143, 357, 325, 260, 295, 262, 173, 145, 177, 87, 264, 327,
186
    267, 266, 268, 175, 270, 272, 117, 297, 274, 265, 147, 179, 205, 276, 207, 237, 269, 278, 57,
187
    59, 387, 209, 280, 282, 149, 329, 385, 284, 25, 286, 239, 119, 288, 27, 290, 292, 299, 294, 359,
188
    89, 296, 298, 419, 181, 300, 331, 271, 417, 211, 361, 151, 389, 241, 302, 304, 303, 306, 308,
189
    421, 91, 310, 312, 391, 314, 121, 316, 333, 318, 275, 213, 301, 243, 183, 335, 320, 363, 322,
190
    215, 324, 393, 273, 337, 153, 326, 423, 365, 328, 367, 247, 395, 185, 123, 330, 425, 245, 155,
191
    332, 334, 305, 397, 336, 277, 217, 338, 340, 339, 427, 342, 344, 346, 307, 399, 187, 348, 309,
192
    341, 350, 369, 279, 311, 429, 249, 219, 352, 354, 356, 358, 431, 373, 401, 371, 313, 281, 433,
193
    343, 403, 251, 283
194
};
195
196
static const uint16_t decoder_tree1[188] = {
197
    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,
198
    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,
199
    78, 80, 129, 41, 131, 82, 9, 71, 84, 86, 101, 88, 90, 92, 94, 96, 161, 43, 11, 73, 98, 103, 100,
200
    163, 102, 104, 106, 108, 133, 110, 105, 112, 75, 114, 45, 13, 116, 165, 118, 195, 135, 193, 120, 77,
201
    122, 47, 124, 167, 225, 126, 79, 107, 227, 128, 137, 197, 15, 130, 169, 199, 132, 109, 134, 17, 139,
202
    49, 136, 229, 138, 140, 81, 259, 142, 144, 171, 146, 141, 148, 111, 150, 201, 231, 152, 51, 257, 289,
203
    154, 19, 113, 156, 261, 158, 203, 173, 263, 143, 160, 291, 235, 83, 162, 233, 265, 164, 205, 166, 293,
204
    145, 168, 175, 177, 237, 115, 295, 170, 207, 172, 267, 174, 176, 297, 147, 178, 180, 269, 182, 271,
205
    209, 299, 239, 179, 184, 301, 241, 211, 0, 0
206
};
207
208
static const uint16_t decoder_tree2[96] = {
209
    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,
210
    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,
211
    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,
212
    75, 89, 61, 86, 103, 88, 77, 90, 105, 91, 92, 107, 93, 0, 0
213
};
214
215
static const uint16_t decoder_tree3[1040] = {
216
    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,
217
    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,
218
    84, 86, 131, 88, 1155, 1043, 1041, 90, 92, 5, 94, 96, 98, 100, 102, 104, 21, 106, 108, 2049, 2177, 110, 112, 114,
219
    116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 33, 144, 163, 146, 148, 150, 152, 154, 161,
220
    156, 35, 158, 1297, 160, 162, 273, 257, 164, 166, 149, 168, 1281, 170, 172, 2193, 174, 176, 178, 1299, 180, 1045,
221
    182, 184, 1173, 186, 3201, 188, 190, 192, 194, 2195, 1187, 23, 2179, 196, 7, 198, 275, 200, 2051, 202, 2065, 204,
222
    206, 1029, 1185, 208, 210, 1157, 37, 3073, 2067, 133, 212, 214, 2321, 216, 165, 218, 1059, 220, 1283, 222, 2305,
223
    224, 226, 228, 230, 259, 232, 234, 2323, 236, 1409, 1057, 1315, 238, 240, 242, 244, 246, 1425, 248, 1313, 250, 252,
224
    254, 256, 258, 260, 289, 262, 264, 1189, 266, 268, 179, 151, 270, 272, 274, 276, 278, 291, 280, 282, 9, 385, 284,
225
    286, 177, 49, 401, 1061, 288, 290, 292, 51, 294, 296, 298, 300, 302, 304, 25, 306, 2083, 39, 308, 310, 3329, 167,
226
    312, 314, 1175, 316, 318, 1203, 135, 320, 322, 324, 326, 328, 2211, 2307, 330, 1301, 332, 334, 1047, 336, 338, 2449,
227
    3217, 340, 1427, 2209, 53, 342, 2339, 3345, 344, 346, 348, 403, 181, 4097, 2197, 350, 2181, 1285, 1317, 1031, 352,
228
    354, 356, 3089, 358, 360, 4225, 277, 362, 364, 366, 368, 2069, 370, 3203, 293, 1201, 305, 372, 3219, 307, 2433, 374,
229
    376, 378, 380, 2081, 1411, 382, 384, 3075, 1443, 513, 386, 387, 388, 390, 1331, 261, 392, 394, 396, 398, 400, 1441,
230
    1075, 67, 1159, 402, 404, 406, 408, 410, 412, 414, 3347, 2325, 416, 65, 418, 420, 422, 424, 426, 2053, 193, 1073, 428,
231
    430, 432, 1537, 1329, 2337, 2213, 434, 417, 183, 41, 436, 438, 440, 442, 444, 446, 448, 450, 195, 2435, 452, 2085, 1063,
232
    1191, 454, 456, 458, 460, 419, 2071, 1553, 3091, 55, 137, 462, 464, 466, 468, 470, 472, 474, 476, 478, 2309, 4113, 480,
233
    482, 484, 486, 2451, 2465, 1205, 153, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518,
234
    520, 522, 524, 1333, 526, 1555, 2467, 2227, 3205, 3331, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 529, 309,
235
    1303, 3473, 3457, 389, 1569, 1445, 1077, 69, 2199, 1539, 4353, 550, 552, 554, 556, 558, 560, 562, 1459, 4241, 3221, 1429,
236
    2341, 279, 3475, 169, 564, 545, 3105, 323, 2353, 2097, 3235, 421, 2229, 3107, 3233, 566, 568, 570, 572, 574, 576, 578,
237
    580, 582, 584, 586, 588, 590, 592, 594, 596, 2099, 1091, 531, 2437, 4227, 405, 197, 263, 1287, 2577, 1049, 1571, 598, 600,
238
    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,
239
    1345, 1219, 3077, 1457, 2225, 2579, 515, 2561, 2469, 433, 1221, 2183, 4243, 652, 654, 656, 658, 660, 662, 664, 666, 668,
240
    670, 1217, 3333, 3093, 435, 321, 4369, 1089, 2055, 4099, 3361, 1319, 547, 1161, 1177, 672, 2355, 4115, 1413, 4257, 3349,
241
    2453, 3109, 2357, 2215, 3363, 1079, 1207, 311, 1033, 1347, 1065, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696,
242
    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,
243
    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,
244
    798, 800, 802, 804, 806, 808, 810, 812, 814, 2593, 2565, 4261, 3253, 437, 325, 3489, 2311, 4259, 1431, 2087, 2563, 295, 2343,
245
    449, 199, 265, 2201, 4371, 1193, 816, 533, 1557, 2581, 2241, 3365, 3491, 3603, 549, 2101, 1461, 1093, 2117, 3459, 3079, 4481,
246
    3095, 2327, 3461, 4129, 3249, 1447, 2471, 2231, 71, 4497, 2609, 1289, 393, 3251, 2073, 3097, 2371, 1305, 2089, 818, 820, 822,
247
    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,
248
    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,
249
    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,
250
    974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018,
251
    1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 4161, 4273, 3507, 3493, 4517, 2497, 1573, 2597, 3621, 4531, 4627, 3523,
252
    3125, 4149, 4529, 3139, 4515, 451, 4277, 2113, 4163, 4499, 3381, 4405, 1473, 4373, 2485, 3509, 565, 1589, 2613, 3585, 3123,
253
    4403, 3141, 4147, 563, 2245, 3269, 4357, 1349, 2373, 3397, 453, 1477, 2501, 2481, 579, 1601, 3477, 4103, 3265, 2243, 1587,
254
    3207, 4231, 3267, 4501, 1475, 3335, 4359, 391, 1415, 2439, 3463, 4487, 519, 1543, 2567, 3591, 4609, 4289, 4611, 2499, 4119,
255
    4385, 4145, 4401, 3223, 4247, 3379, 577, 3393, 3351, 4375, 407, 1585, 2455, 3479, 4503, 535, 1559, 2583, 3607, 3605, 4513,
256
    4485, 3111, 4135, 3121, 517, 3377, 3239, 4263, 1541, 4291, 4229, 3367, 4391, 423, 2115, 4131, 3495, 551, 1575, 2599, 3635, 3395,
257
    2103, 3127, 4151, 3589, 4101, 1603, 3255, 4279, 3601, 1335, 2359, 3383, 439, 1463, 2487, 3511, 567, 1591, 4133, 1095, 2119, 3143,
258
    2369, 1223, 2247, 3271, 327, 1351, 2375, 455, 1479, 3137, 3521, 2057, 3081, 4105, 4387, 3505, 2185, 3209, 4233, 3587, 4355, 2313,
259
    3337, 3237, 1417, 2441, 3465, 521, 1545, 3617, 3633, 561, 4625, 4121, 2611, 2483, 2595, 3225, 4249, 281, 4245, 2329, 3353, 409,
260
    1433, 2457, 3481, 537, 1561, 4483, 3619, 4389, 3113, 4275, 4117, 2217, 3241, 297, 1321, 2345, 3369, 425, 1449, 2473, 57, 1081,
261
    2105, 3129, 185, 1209, 2233, 3257, 313, 1337, 2361, 441, 1465, 73, 1097, 201, 1225, 0, 0
262
};
263
264
static const uint16_t decoder_tree4[416] = {
265
    2, 4, 6, 1, 8, 10, 12, 14, 16, 18, 20, 22, 24, 3, 129, 26, 28, 9, 33, 30, 32,
266
    34, 36, 11, 161, 38, 40, 42, 41, 44, 46, 131, 43, 169, 35, 48, 137, 50, 52, 54, 56, 139,
267
    163, 171, 58, 60, 62, 64, 5, 66, 68, 70, 257, 72, 74, 76, 13, 78, 80, 289, 82, 84, 17,
268
    86, 88, 65, 90, 201, 19, 92, 94, 51, 193, 96, 98, 49, 100, 73, 102, 104, 106, 45, 108, 110,
269
    297, 112, 114, 116, 37, 203, 118, 120, 179, 122, 177, 124, 265, 126, 75, 133, 259, 291, 147, 128, 67,
270
    195, 130, 141, 173, 299, 132, 145, 134, 165, 136, 138, 140, 142, 7, 144, 146, 21, 267, 148, 53, 150,
271
    321, 152, 154, 15, 156, 81, 158, 160, 385, 162, 417, 164, 166, 168, 83, 170, 172, 329, 174, 211, 176,
272
    27, 178, 180, 182, 209, 184, 186, 188, 190, 25, 192, 331, 194, 196, 105, 57, 198, 97, 200, 202, 323,
273
    225, 59, 149, 204, 206, 233, 307, 208, 77, 181, 210, 212, 214, 216, 218, 220, 222, 47, 224, 226, 69,
274
    228, 230, 197, 232, 425, 393, 205, 275, 293, 39, 234, 236, 238, 305, 135, 155, 301, 143, 240, 242, 235,
275
    395, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 273, 269, 185, 264, 266, 268, 270, 272, 274, 276,
276
    261, 153, 278, 280, 282, 187, 337, 387, 107, 284, 427, 227, 167, 419, 286, 288, 290, 292, 294, 296, 298,
277
    300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 115,
278
    99, 85, 213, 29, 113, 23, 89, 241, 61, 449, 339, 175, 340, 342, 344, 346, 348, 350, 352, 354, 356,
279
    358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398,
280
    400, 402, 404, 406, 408, 410, 412, 414, 389, 361, 457, 465, 429, 451, 333, 109, 277, 243, 263, 295, 199,
281
    283, 151, 55, 183, 229, 357, 363, 123, 491, 397, 411, 251, 313, 441, 467, 345, 433, 461, 219, 237, 365,
282
    435, 353, 347, 405, 409, 217, 309, 437, 369, 371, 341, 117, 245, 249, 157, 285, 403, 189, 317, 93, 221,
283
    315, 401, 481, 391, 489, 121, 421, 423, 71, 483, 327, 103, 231, 443, 459, 271, 399, 355, 91, 303, 431,
284
    79, 207, 335, 111, 239, 281, 325, 279, 453, 101, 311, 87, 215, 31, 159, 63, 191
285
};
286
287
static const uint16_t decoder_tree5[384] = {
288
    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,
289
    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,
290
    76, 78, 80, 681, 171, 82, 84, 555, 86, 675, 88, 651, 5, 90, 92, 1025, 94, 96, 98, 683, 13,
291
    100, 17, 102, 104, 106, 65, 108, 110, 257, 112, 114, 1153, 19, 116, 118, 120, 122, 124, 49, 126, 128,
292
    769, 289, 130, 132, 134, 73, 136, 138, 140, 142, 193, 144, 146, 148, 150, 152, 154, 517, 156, 158, 37,
293
    51, 160, 201, 162, 145, 164, 166, 168, 133, 170, 801, 45, 172, 174, 1057, 176, 178, 67, 180, 1027, 577,
294
    182, 184, 186, 188, 190, 192, 194, 196, 198, 259, 200, 202, 204, 525, 177, 265, 141, 206, 208, 210, 212,
295
    195, 297, 214, 75, 216, 1033, 203, 585, 1155, 1185, 267, 1161, 549, 218, 220, 657, 777, 147, 222, 224, 226,
296
    228, 230, 232, 234, 236, 238, 240, 587, 645, 165, 242, 244, 246, 248, 250, 771, 291, 252, 579, 1065, 1035,
297
    705, 531, 529, 659, 173, 254, 561, 653, 256, 713, 677, 557, 258, 260, 262, 264, 266, 268, 270, 272, 274,
298
    276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 707, 1059, 809, 715, 563, 179, 691, 1193,
299
    21, 779, 1067, 299, 1187, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332,
300
    334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374,
301
    376, 378, 380, 83, 69, 1281, 803, 321, 1195, 1163, 811, 1323, 689, 1321, 1099, 305, 835, 1227, 331, 843, 785,
302
    593, 1043, 1291, 1283, 1171, 275, 787, 1217, 833, 1075, 1313, 1219, 1203, 307, 819, 841, 595, 211, 723, 721, 817,
303
    1029, 329, 81, 1157, 261, 773, 1097, 1089, 1061, 1169, 1091, 1189, 293, 805, 1201, 581, 197, 709, 1289, 273, 1037,
304
    1315, 1041, 1165, 269, 781, 209, 1073, 1069, 323, 685, 1197, 301, 813, 77, 589, 205, 717, 1225, 533, 149, 661,
305
    53, 565, 181, 693, 0, 0
306
};
307
308
static const uint16_t decoder_tree6[62] = {
309
    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,
310
    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,
311
    61, 47, 59, 63
312
};
313
314
static const uint16_t *const decoder_tables[7] = {
315
    decoder_tree0,
316
    decoder_tree1,
317
    decoder_tree2,
318
    decoder_tree3,
319
    decoder_tree4,
320
    decoder_tree5,
321
    decoder_tree6,
322
};
323
324
static const int decoder_tables_elements[7] = {
325
    FF_ARRAY_ELEMS(decoder_tree0),
326
    FF_ARRAY_ELEMS(decoder_tree1),
327
    FF_ARRAY_ELEMS(decoder_tree2),
328
    FF_ARRAY_ELEMS(decoder_tree3),
329
    FF_ARRAY_ELEMS(decoder_tree4),
330
    FF_ARRAY_ELEMS(decoder_tree5),
331
    FF_ARRAY_ELEMS(decoder_tree6),
332
};
333
334
static const float mlt_quant[7][14] = {
335
    { 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 },
336
    { 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 },
337
    { 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 },
338
    { 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 },
339
    { 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 },
340
    { 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 },
341
    { 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 }
342
};
343
344
static const float noise_category5[20] = {
345
    0.70711f, 0.6179f, 0.5005f, 0.3220f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f,
346
    0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f
347
};
348
349
static const float noise_category6[20] = {
350
    0.70711f, 0.5686f, 0.3563f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f,
351
    0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f
352
};
353
354
#define FRAME_SIZE 320
355
356
typedef struct SirenContext {
357
    GetBitContext gb;
358
359
    int rate_control_possibilities;
360
    int esf_adjustment;
361
    int number_of_regions;
362
    int scale_factor;
363
    int sample_rate_bits;
364
    int region_size;
365
366
    unsigned dw1, dw2, dw3, dw4;
367
368
    int absolute_region_power_index[32];
369
    float decoder_standard_deviation[32];
370
    int power_categories[32];
371
    int category_balance[32];
372
    float standard_deviation[64];
373
    float backup_frame[FRAME_SIZE];
374
375
    AVFloatDSPContext *fdsp;
376
    av_tx_fn           tx_fn;
377
    AVTXContext       *tx_ctx;
378
379
    DECLARE_ALIGNED(32, float, imdct_buf)[4][FRAME_SIZE];
380
    float          *window;
381
    float          *imdct_in;
382
    float          *imdct_out;
383
    float          *imdct_prev;
384
} SirenContext;
385
386
static av_cold int siren_init(AVCodecContext *avctx)
387
{
388
    const float scale = 1.0f / (22.f * 32768.f);
389
    SirenContext *s = avctx->priv_data;
390
    int i;
391
392
    s->imdct_in   = s->imdct_buf[0];
393
    s->imdct_out  = s->imdct_buf[1];
394
    s->imdct_prev = s->imdct_buf[2];
395
    s->window     = s->imdct_buf[3];
396
397
    avctx->channels       = 1;
398
    avctx->channel_layout = AV_CH_LAYOUT_MONO;
399
    avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;
400
401
    s->rate_control_possibilities = 16;
402
    s->esf_adjustment = 7;
403
    s->number_of_regions = 14;
404
    s->scale_factor = 22;
405
    s->region_size = 20;
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 * s->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 * s->region_size);
627
628
        if (category == 5) {
629
            i = 0;
630
            for (j = 0; j < s->region_size; j++) {
631
                if (*coefs_ptr != 0)
632
                    i++;
633
                coefs_ptr++;
634
            }
635
636
            noise = decoder_standard_deviation[region] * noise_category5[i];
637
        } else if (category == 6) {
638
            i = 0;
639
            for (j = 0; j < s->region_size; j++) {
640
                if (*coefs_ptr++ != 0)
641
                    i++;
642
            }
643
644
            noise = decoder_standard_deviation[region] * noise_category6[i];
645
        } else if (category == 7) {
646
            noise = decoder_standard_deviation[region] * 0.70711f;
647
        } else {
648
            noise = 0;
649
        }
650
651
        coefs_ptr = coefs + (region * s->region_size);
652
653
        if (category == 5 || category == 6 || category == 7) {
654
            dw1 = get_dw(s);
655
            dw2 = get_dw(s);
656
657
            for (j = 0; j < 10; j++) {
658
                if (category == 7 || *coefs_ptr == 0)
659
                    *coefs_ptr = dw1 & 1 ? noise : -noise;
660
                coefs_ptr++;
661
                dw1 >>= 1;
662
663
                if (category == 7 || *coefs_ptr == 0)
664
                    *coefs_ptr = dw2 & 1 ? noise : -noise;
665
                coefs_ptr++;
666
                dw2 >>= 1;
667
            }
668
        }
669
    }
670
671
    return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb);
672
}
673
674
static int siren_decode(AVCodecContext *avctx, void *data,
675
                        int *got_frame, AVPacket *avpkt)
676
{
677
    SirenContext *s = avctx->priv_data;
678
    GetBitContext *gb = &s->gb;
679
    AVFrame *frame = data;
680
    int ret, number_of_valid_coefs = 20 * s->number_of_regions;
681
    int frame_error = 0, rate_control = 0;
682
683
    if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
684
        return ret;
685
686
    decode_envelope(s, gb, s->number_of_regions,
687
                    s->decoder_standard_deviation,
688
                    s->absolute_region_power_index, s->esf_adjustment);
689
690
    rate_control = get_bits(gb, 4);
691
692
    ret = categorize_regions(s->number_of_regions, get_bits_left(gb),
693
                             s->absolute_region_power_index, s->power_categories,
694
                             s->category_balance);
695
    if (ret < 0)
696
        return ret;
697
698
    for (int i = 0; i < rate_control; i++)
699
        s->power_categories[s->category_balance[i]]++;
700
701
    ret = decode_vector(s, s->number_of_regions, get_bits_left(gb),
702
                        s->decoder_standard_deviation, s->power_categories,
703
                        s->imdct_in, s->scale_factor);
704
    if (ret < 0)
705
        return ret;
706
707
    if (get_bits_left(gb) > 0) {
708
        do {
709
            frame_error |= !get_bits1(gb);
710
        } while (get_bits_left(gb) > 0);
711
    } else if (get_bits_left(gb) < 0 &&
712
               rate_control + 1 < s->rate_control_possibilities) {
713
        frame_error = 1;
714
    }
715
716
    for (int i = 0; i < s->number_of_regions; i++) {
717
        if (s->absolute_region_power_index[i] > 33 ||
718
            s->absolute_region_power_index[i] < -31)
719
            frame_error = 1;
720
    }
721
722
    if (frame_error) {
723
        memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
724
        memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
725
    } else {
726
        memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
727
    }
728
729
    frame->nb_samples = FRAME_SIZE;
730
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
731
        return ret;
732
733
    for (int i = 0; i < 320; i += 2)
734
        s->imdct_in[i] *= -1;
735
736
    s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
737
    s->fdsp->vector_fmul_window((float *)frame->data[0],
738
                                s->imdct_prev + (FRAME_SIZE >> 1),
739
                                s->imdct_out, s->window,
740
                                FRAME_SIZE >> 1);
741
    FFSWAP(float *, s->imdct_out, s->imdct_prev);
742
743
    *got_frame = 1;
744
745
    return avpkt->size;
746
}
747
748
static av_cold void siren_flush(AVCodecContext *avctx)
749
{
750
    SirenContext *s = avctx->priv_data;
751
752
    memset(s->backup_frame, 0, sizeof(s->backup_frame));
753
    memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
754
    memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
755
}
756
757
static av_cold int siren_close(AVCodecContext *avctx)
758
{
759
    SirenContext *s = avctx->priv_data;
760
761
    av_freep(&s->fdsp);
762
    av_tx_uninit(&s->tx_ctx);
763
764
    return 0;
765
}
766
767
AVCodec ff_siren_decoder = {
768
    .name           = "siren",
769
    .long_name      = NULL_IF_CONFIG_SMALL("Siren"),
770
    .priv_data_size = sizeof(SirenContext),
771
    .type           = AVMEDIA_TYPE_AUDIO,
772
    .id             = AV_CODEC_ID_SIREN,
773
    .init           = siren_init,
774
    .close          = siren_close,
775
    .decode         = siren_decode,
776
    .flush          = siren_flush,
777
    .capabilities   = AV_CODEC_CAP_DR1,
778
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
779
                      FF_CODEC_CAP_INIT_CLEANUP,
780
};