1 |
|
|
/* |
2 |
|
|
* COOK compatible decoder |
3 |
|
|
* Copyright (c) 2003 Sascha Sommer |
4 |
|
|
* Copyright (c) 2005 Benjamin Larsson |
5 |
|
|
* |
6 |
|
|
* This file is part of FFmpeg. |
7 |
|
|
* |
8 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
9 |
|
|
* modify it under the terms of the GNU Lesser General Public |
10 |
|
|
* License as published by the Free Software Foundation; either |
11 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
12 |
|
|
* |
13 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
14 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 |
|
|
* Lesser General Public License for more details. |
17 |
|
|
* |
18 |
|
|
* You should have received a copy of the GNU Lesser General Public |
19 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
20 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
21 |
|
|
*/ |
22 |
|
|
|
23 |
|
|
/** |
24 |
|
|
* @file |
25 |
|
|
* Cook compatible decoder. Bastardization of the G.722.1 standard. |
26 |
|
|
* This decoder handles RealNetworks, RealAudio G2 data. |
27 |
|
|
* Cook is identified by the codec name cook in RM files. |
28 |
|
|
* |
29 |
|
|
* To use this decoder, a calling application must supply the extradata |
30 |
|
|
* bytes provided from the RM container; 8+ bytes for mono streams and |
31 |
|
|
* 16+ for stereo streams (maybe more). |
32 |
|
|
* |
33 |
|
|
* Codec technicalities (all this assume a buffer length of 1024): |
34 |
|
|
* Cook works with several different techniques to achieve its compression. |
35 |
|
|
* In the timedomain the buffer is divided into 8 pieces and quantized. If |
36 |
|
|
* two neighboring pieces have different quantization index a smooth |
37 |
|
|
* quantization curve is used to get a smooth overlap between the different |
38 |
|
|
* pieces. |
39 |
|
|
* To get to the transformdomain Cook uses a modulated lapped transform. |
40 |
|
|
* The transform domain has 50 subbands with 20 elements each. This |
41 |
|
|
* means only a maximum of 50*20=1000 coefficients are used out of the 1024 |
42 |
|
|
* available. |
43 |
|
|
*/ |
44 |
|
|
|
45 |
|
|
#include "libavutil/channel_layout.h" |
46 |
|
|
#include "libavutil/lfg.h" |
47 |
|
|
#include "libavutil/mem_internal.h" |
48 |
|
|
|
49 |
|
|
#include "audiodsp.h" |
50 |
|
|
#include "avcodec.h" |
51 |
|
|
#include "get_bits.h" |
52 |
|
|
#include "bytestream.h" |
53 |
|
|
#include "fft.h" |
54 |
|
|
#include "internal.h" |
55 |
|
|
#include "sinewin.h" |
56 |
|
|
#include "unary.h" |
57 |
|
|
|
58 |
|
|
#include "cookdata.h" |
59 |
|
|
|
60 |
|
|
/* the different Cook versions */ |
61 |
|
|
#define MONO 0x1000001 |
62 |
|
|
#define STEREO 0x1000002 |
63 |
|
|
#define JOINT_STEREO 0x1000003 |
64 |
|
|
#define MC_COOK 0x2000000 |
65 |
|
|
|
66 |
|
|
#define SUBBAND_SIZE 20 |
67 |
|
|
#define MAX_SUBPACKETS 5 |
68 |
|
|
|
69 |
|
|
#define QUANT_VLC_BITS 9 |
70 |
|
|
#define COUPLING_VLC_BITS 6 |
71 |
|
|
|
72 |
|
|
typedef struct cook_gains { |
73 |
|
|
int *now; |
74 |
|
|
int *previous; |
75 |
|
|
} cook_gains; |
76 |
|
|
|
77 |
|
|
typedef struct COOKSubpacket { |
78 |
|
|
int ch_idx; |
79 |
|
|
int size; |
80 |
|
|
int num_channels; |
81 |
|
|
int cookversion; |
82 |
|
|
int subbands; |
83 |
|
|
int js_subband_start; |
84 |
|
|
int js_vlc_bits; |
85 |
|
|
int samples_per_channel; |
86 |
|
|
int log2_numvector_size; |
87 |
|
|
unsigned int channel_mask; |
88 |
|
|
VLC channel_coupling; |
89 |
|
|
int joint_stereo; |
90 |
|
|
int bits_per_subpacket; |
91 |
|
|
int bits_per_subpdiv; |
92 |
|
|
int total_subbands; |
93 |
|
|
int numvector_size; // 1 << log2_numvector_size; |
94 |
|
|
|
95 |
|
|
float mono_previous_buffer1[1024]; |
96 |
|
|
float mono_previous_buffer2[1024]; |
97 |
|
|
|
98 |
|
|
cook_gains gains1; |
99 |
|
|
cook_gains gains2; |
100 |
|
|
int gain_1[9]; |
101 |
|
|
int gain_2[9]; |
102 |
|
|
int gain_3[9]; |
103 |
|
|
int gain_4[9]; |
104 |
|
|
} COOKSubpacket; |
105 |
|
|
|
106 |
|
|
typedef struct cook { |
107 |
|
|
/* |
108 |
|
|
* The following 5 functions provide the lowlevel arithmetic on |
109 |
|
|
* the internal audio buffers. |
110 |
|
|
*/ |
111 |
|
|
void (*scalar_dequant)(struct cook *q, int index, int quant_index, |
112 |
|
|
int *subband_coef_index, int *subband_coef_sign, |
113 |
|
|
float *mlt_p); |
114 |
|
|
|
115 |
|
|
void (*decouple)(struct cook *q, |
116 |
|
|
COOKSubpacket *p, |
117 |
|
|
int subband, |
118 |
|
|
float f1, float f2, |
119 |
|
|
float *decode_buffer, |
120 |
|
|
float *mlt_buffer1, float *mlt_buffer2); |
121 |
|
|
|
122 |
|
|
void (*imlt_window)(struct cook *q, float *buffer1, |
123 |
|
|
cook_gains *gains_ptr, float *previous_buffer); |
124 |
|
|
|
125 |
|
|
void (*interpolate)(struct cook *q, float *buffer, |
126 |
|
|
int gain_index, int gain_index_next); |
127 |
|
|
|
128 |
|
|
void (*saturate_output)(struct cook *q, float *out); |
129 |
|
|
|
130 |
|
|
AVCodecContext* avctx; |
131 |
|
|
AudioDSPContext adsp; |
132 |
|
|
GetBitContext gb; |
133 |
|
|
/* stream data */ |
134 |
|
|
int num_vectors; |
135 |
|
|
int samples_per_channel; |
136 |
|
|
/* states */ |
137 |
|
|
AVLFG random_state; |
138 |
|
|
int discarded_packets; |
139 |
|
|
|
140 |
|
|
/* transform data */ |
141 |
|
|
FFTContext mdct_ctx; |
142 |
|
|
float* mlt_window; |
143 |
|
|
|
144 |
|
|
/* VLC data */ |
145 |
|
|
VLC envelope_quant_index[13]; |
146 |
|
|
VLC sqvh[7]; // scalar quantization |
147 |
|
|
|
148 |
|
|
/* generate tables and related variables */ |
149 |
|
|
int gain_size_factor; |
150 |
|
|
float gain_table[31]; |
151 |
|
|
|
152 |
|
|
/* data buffers */ |
153 |
|
|
|
154 |
|
|
uint8_t* decoded_bytes_buffer; |
155 |
|
|
DECLARE_ALIGNED(32, float, mono_mdct_output)[2048]; |
156 |
|
|
float decode_buffer_1[1024]; |
157 |
|
|
float decode_buffer_2[1024]; |
158 |
|
|
float decode_buffer_0[1060]; /* static allocation for joint decode */ |
159 |
|
|
|
160 |
|
|
const float *cplscales[5]; |
161 |
|
|
int num_subpackets; |
162 |
|
|
COOKSubpacket subpacket[MAX_SUBPACKETS]; |
163 |
|
|
} COOKContext; |
164 |
|
|
|
165 |
|
|
static float pow2tab[127]; |
166 |
|
|
static float rootpow2tab[127]; |
167 |
|
|
|
168 |
|
|
/*************** init functions ***************/ |
169 |
|
|
|
170 |
|
|
/* table generator */ |
171 |
|
6 |
static av_cold void init_pow2table(void) |
172 |
|
|
{ |
173 |
|
|
/* fast way of computing 2^i and 2^(0.5*i) for -63 <= i < 64 */ |
174 |
|
|
int i; |
175 |
|
|
static const float exp2_tab[2] = {1, M_SQRT2}; |
176 |
|
6 |
float exp2_val = powf(2, -63); |
177 |
|
6 |
float root_val = powf(2, -32); |
178 |
✓✓ |
768 |
for (i = -63; i < 64; i++) { |
179 |
✓✓ |
762 |
if (!(i & 1)) |
180 |
|
378 |
root_val *= 2; |
181 |
|
762 |
pow2tab[63 + i] = exp2_val; |
182 |
|
762 |
rootpow2tab[63 + i] = root_val * exp2_tab[i & 1]; |
183 |
|
762 |
exp2_val *= 2; |
184 |
|
|
} |
185 |
|
6 |
} |
186 |
|
|
|
187 |
|
|
/* table generator */ |
188 |
|
6 |
static av_cold void init_gain_table(COOKContext *q) |
189 |
|
|
{ |
190 |
|
|
int i; |
191 |
|
6 |
q->gain_size_factor = q->samples_per_channel / 8; |
192 |
✓✓ |
192 |
for (i = 0; i < 31; i++) |
193 |
|
186 |
q->gain_table[i] = pow(pow2tab[i + 48], |
194 |
|
186 |
(1.0 / (double) q->gain_size_factor)); |
195 |
|
6 |
} |
196 |
|
|
|
197 |
|
124 |
static av_cold int build_vlc(VLC *vlc, int nb_bits, const uint8_t counts[16], |
198 |
|
|
const void *syms, int symbol_size, int offset, |
199 |
|
|
void *logctx) |
200 |
|
|
{ |
201 |
|
|
uint8_t lens[MAX_COOK_VLC_ENTRIES]; |
202 |
|
124 |
unsigned num = 0; |
203 |
|
|
|
204 |
✓✓ |
2108 |
for (int i = 0; i < 16; i++) |
205 |
✓✓ |
11636 |
for (unsigned count = num + counts[i]; num < count; num++) |
206 |
|
9652 |
lens[num] = i + 1; |
207 |
|
|
|
208 |
|
124 |
return ff_init_vlc_from_lengths(vlc, nb_bits, num, lens, 1, |
209 |
|
|
syms, symbol_size, symbol_size, |
210 |
|
|
offset, 0, logctx); |
211 |
|
|
} |
212 |
|
|
|
213 |
|
6 |
static av_cold int init_cook_vlc_tables(COOKContext *q) |
214 |
|
|
{ |
215 |
|
|
int i, result; |
216 |
|
|
|
217 |
|
6 |
result = 0; |
218 |
✓✓ |
84 |
for (i = 0; i < 13; i++) { |
219 |
|
78 |
result |= build_vlc(&q->envelope_quant_index[i], QUANT_VLC_BITS, |
220 |
|
78 |
envelope_quant_index_huffcounts[i], |
221 |
|
78 |
envelope_quant_index_huffsyms[i], 1, -12, q->avctx); |
222 |
|
|
} |
223 |
|
6 |
av_log(q->avctx, AV_LOG_DEBUG, "sqvh VLC init\n"); |
224 |
✓✓ |
48 |
for (i = 0; i < 7; i++) { |
225 |
✓✓ |
42 |
int sym_size = 1 + (i == 3); |
226 |
|
42 |
result |= build_vlc(&q->sqvh[i], vhvlcsize_tab[i], |
227 |
|
42 |
cvh_huffcounts[i], |
228 |
|
42 |
cvh_huffsyms[i], sym_size, 0, q->avctx); |
229 |
|
|
} |
230 |
|
|
|
231 |
✓✓ |
12 |
for (i = 0; i < q->num_subpackets; i++) { |
232 |
✓✓ |
6 |
if (q->subpacket[i].joint_stereo == 1) { |
233 |
|
8 |
result |= build_vlc(&q->subpacket[i].channel_coupling, COUPLING_VLC_BITS, |
234 |
|
4 |
ccpl_huffcounts[q->subpacket[i].js_vlc_bits - 2], |
235 |
|
4 |
ccpl_huffsyms[q->subpacket[i].js_vlc_bits - 2], 1, |
236 |
|
4 |
0, q->avctx); |
237 |
|
4 |
av_log(q->avctx, AV_LOG_DEBUG, "subpacket %i Joint-stereo VLC used.\n", i); |
238 |
|
|
} |
239 |
|
|
} |
240 |
|
|
|
241 |
|
6 |
av_log(q->avctx, AV_LOG_DEBUG, "VLC tables initialized.\n"); |
242 |
|
6 |
return result; |
243 |
|
|
} |
244 |
|
|
|
245 |
|
6 |
static av_cold int init_cook_mlt(COOKContext *q) |
246 |
|
|
{ |
247 |
|
|
int j, ret; |
248 |
|
6 |
int mlt_size = q->samples_per_channel; |
249 |
|
|
|
250 |
✗✓ |
6 |
if ((q->mlt_window = av_malloc_array(mlt_size, sizeof(*q->mlt_window))) == 0) |
251 |
|
|
return AVERROR(ENOMEM); |
252 |
|
|
|
253 |
|
|
/* Initialize the MLT window: simple sine window. */ |
254 |
|
6 |
ff_sine_window_init(q->mlt_window, mlt_size); |
255 |
✓✓ |
6150 |
for (j = 0; j < mlt_size; j++) |
256 |
|
6144 |
q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel); |
257 |
|
|
|
258 |
|
|
/* Initialize the MDCT. */ |
259 |
✗✓ |
6 |
if ((ret = ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size) + 1, 1, 1.0 / 32768.0))) { |
260 |
|
|
av_freep(&q->mlt_window); |
261 |
|
|
return ret; |
262 |
|
|
} |
263 |
|
6 |
av_log(q->avctx, AV_LOG_DEBUG, "MDCT initialized, order = %d.\n", |
264 |
|
6 |
av_log2(mlt_size) + 1); |
265 |
|
|
|
266 |
|
6 |
return 0; |
267 |
|
|
} |
268 |
|
|
|
269 |
|
6 |
static av_cold void init_cplscales_table(COOKContext *q) |
270 |
|
|
{ |
271 |
|
|
int i; |
272 |
✓✓ |
36 |
for (i = 0; i < 5; i++) |
273 |
|
30 |
q->cplscales[i] = cplscales[i]; |
274 |
|
6 |
} |
275 |
|
|
|
276 |
|
|
/*************** init functions end ***********/ |
277 |
|
|
|
278 |
|
|
#define DECODE_BYTES_PAD1(bytes) (3 - ((bytes) + 3) % 4) |
279 |
|
|
#define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes))) |
280 |
|
|
|
281 |
|
|
/** |
282 |
|
|
* Cook indata decoding, every 32 bits are XORed with 0x37c511f2. |
283 |
|
|
* Why? No idea, some checksum/error detection method maybe. |
284 |
|
|
* |
285 |
|
|
* Out buffer size: extra bytes are needed to cope with |
286 |
|
|
* padding/misalignment. |
287 |
|
|
* Subpackets passed to the decoder can contain two, consecutive |
288 |
|
|
* half-subpackets, of identical but arbitrary size. |
289 |
|
|
* 1234 1234 1234 1234 extraA extraB |
290 |
|
|
* Case 1: AAAA BBBB 0 0 |
291 |
|
|
* Case 2: AAAA ABBB BB-- 3 3 |
292 |
|
|
* Case 3: AAAA AABB BBBB 2 2 |
293 |
|
|
* Case 4: AAAA AAAB BBBB BB-- 1 5 |
294 |
|
|
* |
295 |
|
|
* Nice way to waste CPU cycles. |
296 |
|
|
* |
297 |
|
|
* @param inbuffer pointer to byte array of indata |
298 |
|
|
* @param out pointer to byte array of outdata |
299 |
|
|
* @param bytes number of bytes |
300 |
|
|
*/ |
301 |
|
240 |
static inline int decode_bytes(const uint8_t *inbuffer, uint8_t *out, int bytes) |
302 |
|
|
{ |
303 |
|
|
static const uint32_t tab[4] = { |
304 |
|
|
AV_BE2NE32C(0x37c511f2u), AV_BE2NE32C(0xf237c511u), |
305 |
|
|
AV_BE2NE32C(0x11f237c5u), AV_BE2NE32C(0xc511f237u), |
306 |
|
|
}; |
307 |
|
|
int i, off; |
308 |
|
|
uint32_t c; |
309 |
|
|
const uint32_t *buf; |
310 |
|
240 |
uint32_t *obuf = (uint32_t *) out; |
311 |
|
|
/* FIXME: 64 bit platforms would be able to do 64 bits at a time. |
312 |
|
|
* I'm too lazy though, should be something like |
313 |
|
|
* for (i = 0; i < bitamount / 64; i++) |
314 |
|
|
* (int64_t) out[i] = 0x37c511f237c511f2 ^ av_be2ne64(int64_t) in[i]); |
315 |
|
|
* Buffer alignment needs to be checked. */ |
316 |
|
|
|
317 |
|
240 |
off = (intptr_t) inbuffer & 3; |
318 |
|
240 |
buf = (const uint32_t *) (inbuffer - off); |
319 |
|
240 |
c = tab[off]; |
320 |
|
240 |
bytes += 3 + off; |
321 |
✓✓ |
11520 |
for (i = 0; i < bytes / 4; i++) |
322 |
|
11280 |
obuf[i] = c ^ buf[i]; |
323 |
|
|
|
324 |
|
240 |
return off; |
325 |
|
|
} |
326 |
|
|
|
327 |
|
6 |
static av_cold int cook_decode_close(AVCodecContext *avctx) |
328 |
|
|
{ |
329 |
|
|
int i; |
330 |
|
6 |
COOKContext *q = avctx->priv_data; |
331 |
|
6 |
av_log(avctx, AV_LOG_DEBUG, "Deallocating memory.\n"); |
332 |
|
|
|
333 |
|
|
/* Free allocated memory buffers. */ |
334 |
|
6 |
av_freep(&q->mlt_window); |
335 |
|
6 |
av_freep(&q->decoded_bytes_buffer); |
336 |
|
|
|
337 |
|
|
/* Free the transform. */ |
338 |
|
6 |
ff_mdct_end(&q->mdct_ctx); |
339 |
|
|
|
340 |
|
|
/* Free the VLC tables. */ |
341 |
✓✓ |
84 |
for (i = 0; i < 13; i++) |
342 |
|
78 |
ff_free_vlc(&q->envelope_quant_index[i]); |
343 |
✓✓ |
48 |
for (i = 0; i < 7; i++) |
344 |
|
42 |
ff_free_vlc(&q->sqvh[i]); |
345 |
✓✓ |
12 |
for (i = 0; i < q->num_subpackets; i++) |
346 |
|
6 |
ff_free_vlc(&q->subpacket[i].channel_coupling); |
347 |
|
|
|
348 |
|
6 |
av_log(avctx, AV_LOG_DEBUG, "Memory deallocated.\n"); |
349 |
|
|
|
350 |
|
6 |
return 0; |
351 |
|
|
} |
352 |
|
|
|
353 |
|
|
/** |
354 |
|
|
* Fill the gain array for the timedomain quantization. |
355 |
|
|
* |
356 |
|
|
* @param gb pointer to the GetBitContext |
357 |
|
|
* @param gaininfo array[9] of gain indexes |
358 |
|
|
*/ |
359 |
|
240 |
static void decode_gain_info(GetBitContext *gb, int *gaininfo) |
360 |
|
|
{ |
361 |
|
|
int i, n; |
362 |
|
|
|
363 |
|
240 |
n = get_unary(gb, 0, get_bits_left(gb)); // amount of elements*2 to update |
364 |
|
|
|
365 |
|
240 |
i = 0; |
366 |
✓✓ |
241 |
while (n--) { |
367 |
|
1 |
int index = get_bits(gb, 3); |
368 |
✓✗ |
1 |
int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1; |
369 |
|
|
|
370 |
✓✓ |
8 |
while (i <= index) |
371 |
|
7 |
gaininfo[i++] = gain; |
372 |
|
|
} |
373 |
✓✓ |
2393 |
while (i <= 8) |
374 |
|
2153 |
gaininfo[i++] = 0; |
375 |
|
240 |
} |
376 |
|
|
|
377 |
|
|
/** |
378 |
|
|
* Create the quant index table needed for the envelope. |
379 |
|
|
* |
380 |
|
|
* @param q pointer to the COOKContext |
381 |
|
|
* @param quant_index_table pointer to the array |
382 |
|
|
*/ |
383 |
|
240 |
static int decode_envelope(COOKContext *q, COOKSubpacket *p, |
384 |
|
|
int *quant_index_table) |
385 |
|
|
{ |
386 |
|
|
int i, j, vlc_index; |
387 |
|
|
|
388 |
|
240 |
quant_index_table[0] = get_bits(&q->gb, 6) - 6; // This is used later in categorize |
389 |
|
|
|
390 |
✓✓ |
10320 |
for (i = 1; i < p->total_subbands; i++) { |
391 |
|
10080 |
vlc_index = i; |
392 |
✓✓ |
10080 |
if (i >= p->js_subband_start * 2) { |
393 |
|
7440 |
vlc_index -= p->js_subband_start; |
394 |
|
|
} else { |
395 |
|
2640 |
vlc_index /= 2; |
396 |
✓✓ |
2640 |
if (vlc_index < 1) |
397 |
|
240 |
vlc_index = 1; |
398 |
|
|
} |
399 |
✓✓ |
10080 |
if (vlc_index > 13) |
400 |
|
5520 |
vlc_index = 13; // the VLC tables >13 are identical to No. 13 |
401 |
|
|
|
402 |
|
10080 |
j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index - 1].table, |
403 |
|
|
QUANT_VLC_BITS, 2); |
404 |
|
10080 |
quant_index_table[i] = quant_index_table[i - 1] + j; // differential encoding |
405 |
✓✗✗✓
|
10080 |
if (quant_index_table[i] > 63 || quant_index_table[i] < -63) { |
406 |
|
|
av_log(q->avctx, AV_LOG_ERROR, |
407 |
|
|
"Invalid quantizer %d at position %d, outside [-63, 63] range\n", |
408 |
|
|
quant_index_table[i], i); |
409 |
|
|
return AVERROR_INVALIDDATA; |
410 |
|
|
} |
411 |
|
|
} |
412 |
|
|
|
413 |
|
240 |
return 0; |
414 |
|
|
} |
415 |
|
|
|
416 |
|
|
/** |
417 |
|
|
* Calculate the category and category_index vector. |
418 |
|
|
* |
419 |
|
|
* @param q pointer to the COOKContext |
420 |
|
|
* @param quant_index_table pointer to the array |
421 |
|
|
* @param category pointer to the category array |
422 |
|
|
* @param category_index pointer to the category_index array |
423 |
|
|
*/ |
424 |
|
240 |
static void categorize(COOKContext *q, COOKSubpacket *p, const int *quant_index_table, |
425 |
|
|
int *category, int *category_index) |
426 |
|
|
{ |
427 |
|
|
int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j; |
428 |
|
240 |
int exp_index2[102] = { 0 }; |
429 |
|
240 |
int exp_index1[102] = { 0 }; |
430 |
|
|
|
431 |
|
240 |
int tmp_categorize_array[128 * 2] = { 0 }; |
432 |
|
240 |
int tmp_categorize_array1_idx = p->numvector_size; |
433 |
|
240 |
int tmp_categorize_array2_idx = p->numvector_size; |
434 |
|
|
|
435 |
|
240 |
bits_left = p->bits_per_subpacket - get_bits_count(&q->gb); |
436 |
|
|
|
437 |
✓✗ |
240 |
if (bits_left > q->samples_per_channel) |
438 |
|
240 |
bits_left = q->samples_per_channel + |
439 |
|
240 |
((bits_left - q->samples_per_channel) * 5) / 8; |
440 |
|
|
|
441 |
|
240 |
bias = -32; |
442 |
|
|
|
443 |
|
|
/* Estimate bias. */ |
444 |
✓✓ |
1680 |
for (i = 32; i > 0; i = i / 2) { |
445 |
|
1440 |
num_bits = 0; |
446 |
|
1440 |
index = 0; |
447 |
✓✓ |
63360 |
for (j = p->total_subbands; j > 0; j--) { |
448 |
|
61920 |
exp_idx = av_clip_uintp2((i - quant_index_table[index] + bias) / 2, 3); |
449 |
|
61920 |
index++; |
450 |
|
61920 |
num_bits += expbits_tab[exp_idx]; |
451 |
|
|
} |
452 |
✓✓ |
1440 |
if (num_bits >= bits_left - 32) |
453 |
|
1333 |
bias += i; |
454 |
|
|
} |
455 |
|
|
|
456 |
|
|
/* Calculate total number of bits. */ |
457 |
|
240 |
num_bits = 0; |
458 |
✓✓ |
10560 |
for (i = 0; i < p->total_subbands; i++) { |
459 |
|
10320 |
exp_idx = av_clip_uintp2((bias - quant_index_table[i]) / 2, 3); |
460 |
|
10320 |
num_bits += expbits_tab[exp_idx]; |
461 |
|
10320 |
exp_index1[i] = exp_idx; |
462 |
|
10320 |
exp_index2[i] = exp_idx; |
463 |
|
|
} |
464 |
|
240 |
tmpbias1 = tmpbias2 = num_bits; |
465 |
|
|
|
466 |
✓✓ |
30720 |
for (j = 1; j < p->numvector_size; j++) { |
467 |
✓✓ |
30480 |
if (tmpbias1 + tmpbias2 > 2 * bits_left) { /* ---> */ |
468 |
|
16408 |
int max = -999999; |
469 |
|
16408 |
index = -1; |
470 |
✓✓ |
721952 |
for (i = 0; i < p->total_subbands; i++) { |
471 |
✓✓ |
705544 |
if (exp_index1[i] < 7) { |
472 |
|
543313 |
v = (-2 * exp_index1[i]) - quant_index_table[i] + bias; |
473 |
✓✓ |
543313 |
if (v >= max) { |
474 |
|
186262 |
max = v; |
475 |
|
186262 |
index = i; |
476 |
|
|
} |
477 |
|
|
} |
478 |
|
|
} |
479 |
✗✓ |
16408 |
if (index == -1) |
480 |
|
|
break; |
481 |
|
16408 |
tmp_categorize_array[tmp_categorize_array1_idx++] = index; |
482 |
|
16408 |
tmpbias1 -= expbits_tab[exp_index1[index]] - |
483 |
|
16408 |
expbits_tab[exp_index1[index] + 1]; |
484 |
|
16408 |
++exp_index1[index]; |
485 |
|
|
} else { /* <--- */ |
486 |
|
14072 |
int min = 999999; |
487 |
|
14072 |
index = -1; |
488 |
✓✓ |
619168 |
for (i = 0; i < p->total_subbands; i++) { |
489 |
✓✓ |
605096 |
if (exp_index2[i] > 0) { |
490 |
|
527917 |
v = (-2 * exp_index2[i]) - quant_index_table[i] + bias; |
491 |
✓✓ |
527917 |
if (v < min) { |
492 |
|
31097 |
min = v; |
493 |
|
31097 |
index = i; |
494 |
|
|
} |
495 |
|
|
} |
496 |
|
|
} |
497 |
✗✓ |
14072 |
if (index == -1) |
498 |
|
|
break; |
499 |
|
14072 |
tmp_categorize_array[--tmp_categorize_array2_idx] = index; |
500 |
|
14072 |
tmpbias2 -= expbits_tab[exp_index2[index]] - |
501 |
|
14072 |
expbits_tab[exp_index2[index] - 1]; |
502 |
|
14072 |
--exp_index2[index]; |
503 |
|
|
} |
504 |
|
|
} |
505 |
|
|
|
506 |
✓✓ |
10560 |
for (i = 0; i < p->total_subbands; i++) |
507 |
|
10320 |
category[i] = exp_index2[i]; |
508 |
|
|
|
509 |
✓✓ |
30720 |
for (i = 0; i < p->numvector_size - 1; i++) |
510 |
|
30480 |
category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++]; |
511 |
|
240 |
} |
512 |
|
|
|
513 |
|
|
|
514 |
|
|
/** |
515 |
|
|
* Expand the category vector. |
516 |
|
|
* |
517 |
|
|
* @param q pointer to the COOKContext |
518 |
|
|
* @param category pointer to the category array |
519 |
|
|
* @param category_index pointer to the category_index array |
520 |
|
|
*/ |
521 |
|
240 |
static inline void expand_category(COOKContext *q, int *category, |
522 |
|
|
int *category_index) |
523 |
|
|
{ |
524 |
|
|
int i; |
525 |
✓✓ |
15141 |
for (i = 0; i < q->num_vectors; i++) |
526 |
|
|
{ |
527 |
|
14901 |
int idx = category_index[i]; |
528 |
✗✓ |
14901 |
if (++category[idx] >= FF_ARRAY_ELEMS(dither_tab)) |
529 |
|
|
--category[idx]; |
530 |
|
|
} |
531 |
|
240 |
} |
532 |
|
|
|
533 |
|
|
/** |
534 |
|
|
* The real requantization of the mltcoefs |
535 |
|
|
* |
536 |
|
|
* @param q pointer to the COOKContext |
537 |
|
|
* @param index index |
538 |
|
|
* @param quant_index quantisation index |
539 |
|
|
* @param subband_coef_index array of indexes to quant_centroid_tab |
540 |
|
|
* @param subband_coef_sign signs of coefficients |
541 |
|
|
* @param mlt_p pointer into the mlt buffer |
542 |
|
|
*/ |
543 |
|
10320 |
static void scalar_dequant_float(COOKContext *q, int index, int quant_index, |
544 |
|
|
int *subband_coef_index, int *subband_coef_sign, |
545 |
|
|
float *mlt_p) |
546 |
|
|
{ |
547 |
|
|
int i; |
548 |
|
|
float f1; |
549 |
|
|
|
550 |
✓✓ |
216720 |
for (i = 0; i < SUBBAND_SIZE; i++) { |
551 |
✓✓ |
206400 |
if (subband_coef_index[i]) { |
552 |
|
67248 |
f1 = quant_centroid_tab[index][subband_coef_index[i]]; |
553 |
✓✓ |
67248 |
if (subband_coef_sign[i]) |
554 |
|
33713 |
f1 = -f1; |
555 |
|
|
} else { |
556 |
|
|
/* noise coding if subband_coef_index[i] == 0 */ |
557 |
|
139152 |
f1 = dither_tab[index]; |
558 |
✓✓ |
139152 |
if (av_lfg_get(&q->random_state) < 0x80000000) |
559 |
|
69511 |
f1 = -f1; |
560 |
|
|
} |
561 |
|
206400 |
mlt_p[i] = f1 * rootpow2tab[quant_index + 63]; |
562 |
|
|
} |
563 |
|
10320 |
} |
564 |
|
|
/** |
565 |
|
|
* Unpack the subband_coef_index and subband_coef_sign vectors. |
566 |
|
|
* |
567 |
|
|
* @param q pointer to the COOKContext |
568 |
|
|
* @param category pointer to the category array |
569 |
|
|
* @param subband_coef_index array of indexes to quant_centroid_tab |
570 |
|
|
* @param subband_coef_sign signs of coefficients |
571 |
|
|
*/ |
572 |
|
8969 |
static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category, |
573 |
|
|
int *subband_coef_index, int *subband_coef_sign) |
574 |
|
|
{ |
575 |
|
|
int i, j; |
576 |
|
|
int vlc, vd, tmp, result; |
577 |
|
|
|
578 |
|
8969 |
vd = vd_tab[category]; |
579 |
|
8969 |
result = 0; |
580 |
✓✓ |
65444 |
for (i = 0; i < vpr_tab[category]; i++) { |
581 |
|
56475 |
vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3); |
582 |
✗✓ |
56475 |
if (p->bits_per_subpacket < get_bits_count(&q->gb)) { |
583 |
|
|
vlc = 0; |
584 |
|
|
result = 1; |
585 |
|
|
} |
586 |
✓✓ |
235855 |
for (j = vd - 1; j >= 0; j--) { |
587 |
|
179380 |
tmp = (vlc * invradix_tab[category]) / 0x100000; |
588 |
|
179380 |
subband_coef_index[vd * i + j] = vlc - tmp * (kmax_tab[category] + 1); |
589 |
|
179380 |
vlc = tmp; |
590 |
|
|
} |
591 |
✓✓ |
235855 |
for (j = 0; j < vd; j++) { |
592 |
✓✓ |
179380 |
if (subband_coef_index[i * vd + j]) { |
593 |
✓✗ |
67248 |
if (get_bits_count(&q->gb) < p->bits_per_subpacket) { |
594 |
|
67248 |
subband_coef_sign[i * vd + j] = get_bits1(&q->gb); |
595 |
|
|
} else { |
596 |
|
|
result = 1; |
597 |
|
|
subband_coef_sign[i * vd + j] = 0; |
598 |
|
|
} |
599 |
|
|
} else { |
600 |
|
112132 |
subband_coef_sign[i * vd + j] = 0; |
601 |
|
|
} |
602 |
|
|
} |
603 |
|
|
} |
604 |
|
8969 |
return result; |
605 |
|
|
} |
606 |
|
|
|
607 |
|
|
|
608 |
|
|
/** |
609 |
|
|
* Fill the mlt_buffer with mlt coefficients. |
610 |
|
|
* |
611 |
|
|
* @param q pointer to the COOKContext |
612 |
|
|
* @param category pointer to the category array |
613 |
|
|
* @param quant_index_table pointer to the array |
614 |
|
|
* @param mlt_buffer pointer to mlt coefficients |
615 |
|
|
*/ |
616 |
|
240 |
static void decode_vectors(COOKContext *q, COOKSubpacket *p, int *category, |
617 |
|
|
int *quant_index_table, float *mlt_buffer) |
618 |
|
|
{ |
619 |
|
|
/* A zero in this table means that the subband coefficient is |
620 |
|
|
random noise coded. */ |
621 |
|
|
int subband_coef_index[SUBBAND_SIZE]; |
622 |
|
|
/* A zero in this table means that the subband coefficient is a |
623 |
|
|
positive multiplicator. */ |
624 |
|
|
int subband_coef_sign[SUBBAND_SIZE]; |
625 |
|
|
int band, j; |
626 |
|
240 |
int index = 0; |
627 |
|
|
|
628 |
✓✓ |
10560 |
for (band = 0; band < p->total_subbands; band++) { |
629 |
|
10320 |
index = category[band]; |
630 |
✓✓ |
10320 |
if (category[band] < 7) { |
631 |
✗✓ |
8969 |
if (unpack_SQVH(q, p, category[band], subband_coef_index, subband_coef_sign)) { |
632 |
|
|
index = 7; |
633 |
|
|
for (j = 0; j < p->total_subbands; j++) |
634 |
|
|
category[band + j] = 7; |
635 |
|
|
} |
636 |
|
|
} |
637 |
✓✓ |
10320 |
if (index >= 7) { |
638 |
|
1351 |
memset(subband_coef_index, 0, sizeof(subband_coef_index)); |
639 |
|
1351 |
memset(subband_coef_sign, 0, sizeof(subband_coef_sign)); |
640 |
|
|
} |
641 |
|
10320 |
q->scalar_dequant(q, index, quant_index_table[band], |
642 |
|
|
subband_coef_index, subband_coef_sign, |
643 |
|
10320 |
&mlt_buffer[band * SUBBAND_SIZE]); |
644 |
|
|
} |
645 |
|
|
|
646 |
|
|
/* FIXME: should this be removed, or moved into loop above? */ |
647 |
✗✓ |
240 |
if (p->total_subbands * SUBBAND_SIZE >= q->samples_per_channel) |
648 |
|
|
return; |
649 |
|
|
} |
650 |
|
|
|
651 |
|
|
|
652 |
|
240 |
static int mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer) |
653 |
|
|
{ |
654 |
|
240 |
int category_index[128] = { 0 }; |
655 |
|
240 |
int category[128] = { 0 }; |
656 |
|
|
int quant_index_table[102]; |
657 |
|
|
int res, i; |
658 |
|
|
|
659 |
✗✓ |
240 |
if ((res = decode_envelope(q, p, quant_index_table)) < 0) |
660 |
|
|
return res; |
661 |
|
240 |
q->num_vectors = get_bits(&q->gb, p->log2_numvector_size); |
662 |
|
240 |
categorize(q, p, quant_index_table, category, category_index); |
663 |
|
240 |
expand_category(q, category, category_index); |
664 |
✓✓ |
10560 |
for (i=0; i<p->total_subbands; i++) { |
665 |
✗✓ |
10320 |
if (category[i] > 7) |
666 |
|
|
return AVERROR_INVALIDDATA; |
667 |
|
|
} |
668 |
|
240 |
decode_vectors(q, p, category, quant_index_table, mlt_buffer); |
669 |
|
|
|
670 |
|
240 |
return 0; |
671 |
|
|
} |
672 |
|
|
|
673 |
|
|
|
674 |
|
|
/** |
675 |
|
|
* the actual requantization of the timedomain samples |
676 |
|
|
* |
677 |
|
|
* @param q pointer to the COOKContext |
678 |
|
|
* @param buffer pointer to the timedomain buffer |
679 |
|
|
* @param gain_index index for the block multiplier |
680 |
|
|
* @param gain_index_next index for the next block multiplier |
681 |
|
|
*/ |
682 |
|
14 |
static void interpolate_float(COOKContext *q, float *buffer, |
683 |
|
|
int gain_index, int gain_index_next) |
684 |
|
|
{ |
685 |
|
|
int i; |
686 |
|
|
float fc1, fc2; |
687 |
|
14 |
fc1 = pow2tab[gain_index + 63]; |
688 |
|
|
|
689 |
✓✓ |
14 |
if (gain_index == gain_index_next) { // static gain |
690 |
✓✓ |
1548 |
for (i = 0; i < q->gain_size_factor; i++) |
691 |
|
1536 |
buffer[i] *= fc1; |
692 |
|
|
} else { // smooth gain |
693 |
|
2 |
fc2 = q->gain_table[15 + (gain_index_next - gain_index)]; |
694 |
✓✓ |
258 |
for (i = 0; i < q->gain_size_factor; i++) { |
695 |
|
256 |
buffer[i] *= fc1; |
696 |
|
256 |
fc1 *= fc2; |
697 |
|
|
} |
698 |
|
|
} |
699 |
|
14 |
} |
700 |
|
|
|
701 |
|
|
/** |
702 |
|
|
* Apply transform window, overlap buffers. |
703 |
|
|
* |
704 |
|
|
* @param q pointer to the COOKContext |
705 |
|
|
* @param inbuffer pointer to the mltcoefficients |
706 |
|
|
* @param gains_ptr current and previous gains |
707 |
|
|
* @param previous_buffer pointer to the previous buffer to be used for overlapping |
708 |
|
|
*/ |
709 |
|
480 |
static void imlt_window_float(COOKContext *q, float *inbuffer, |
710 |
|
|
cook_gains *gains_ptr, float *previous_buffer) |
711 |
|
|
{ |
712 |
|
480 |
const float fc = pow2tab[gains_ptr->previous[0] + 63]; |
713 |
|
|
int i; |
714 |
|
|
/* The weird thing here, is that the two halves of the time domain |
715 |
|
|
* buffer are swapped. Also, the newest data, that we save away for |
716 |
|
|
* next frame, has the wrong sign. Hence the subtraction below. |
717 |
|
|
* Almost sounds like a complex conjugate/reverse data/FFT effect. |
718 |
|
|
*/ |
719 |
|
|
|
720 |
|
|
/* Apply window and overlap */ |
721 |
✓✓ |
492000 |
for (i = 0; i < q->samples_per_channel; i++) |
722 |
|
491520 |
inbuffer[i] = inbuffer[i] * fc * q->mlt_window[i] - |
723 |
|
491520 |
previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i]; |
724 |
|
480 |
} |
725 |
|
|
|
726 |
|
|
/** |
727 |
|
|
* The modulated lapped transform, this takes transform coefficients |
728 |
|
|
* and transforms them into timedomain samples. |
729 |
|
|
* Apply transform window, overlap buffers, apply gain profile |
730 |
|
|
* and buffer management. |
731 |
|
|
* |
732 |
|
|
* @param q pointer to the COOKContext |
733 |
|
|
* @param inbuffer pointer to the mltcoefficients |
734 |
|
|
* @param gains_ptr current and previous gains |
735 |
|
|
* @param previous_buffer pointer to the previous buffer to be used for overlapping |
736 |
|
|
*/ |
737 |
|
480 |
static void imlt_gain(COOKContext *q, float *inbuffer, |
738 |
|
|
cook_gains *gains_ptr, float *previous_buffer) |
739 |
|
|
{ |
740 |
|
480 |
float *buffer0 = q->mono_mdct_output; |
741 |
|
480 |
float *buffer1 = q->mono_mdct_output + q->samples_per_channel; |
742 |
|
|
int i; |
743 |
|
|
|
744 |
|
|
/* Inverse modified discrete cosine transform */ |
745 |
|
480 |
q->mdct_ctx.imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer); |
746 |
|
|
|
747 |
|
480 |
q->imlt_window(q, buffer1, gains_ptr, previous_buffer); |
748 |
|
|
|
749 |
|
|
/* Apply gain profile */ |
750 |
✓✓ |
4320 |
for (i = 0; i < 8; i++) |
751 |
✓✓✗✓
|
3840 |
if (gains_ptr->now[i] || gains_ptr->now[i + 1]) |
752 |
|
14 |
q->interpolate(q, &buffer1[q->gain_size_factor * i], |
753 |
|
14 |
gains_ptr->now[i], gains_ptr->now[i + 1]); |
754 |
|
|
|
755 |
|
|
/* Save away the current to be previous block. */ |
756 |
|
480 |
memcpy(previous_buffer, buffer0, |
757 |
|
480 |
q->samples_per_channel * sizeof(*previous_buffer)); |
758 |
|
480 |
} |
759 |
|
|
|
760 |
|
|
|
761 |
|
|
/** |
762 |
|
|
* function for getting the jointstereo coupling information |
763 |
|
|
* |
764 |
|
|
* @param q pointer to the COOKContext |
765 |
|
|
* @param decouple_tab decoupling array |
766 |
|
|
*/ |
767 |
|
240 |
static int decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab) |
768 |
|
|
{ |
769 |
|
|
int i; |
770 |
|
240 |
int vlc = get_bits1(&q->gb); |
771 |
|
240 |
int start = cplband[p->js_subband_start]; |
772 |
|
240 |
int end = cplband[p->subbands - 1]; |
773 |
|
240 |
int length = end - start + 1; |
774 |
|
|
|
775 |
✗✓ |
240 |
if (start > end) |
776 |
|
|
return 0; |
777 |
|
|
|
778 |
✓✓ |
240 |
if (vlc) |
779 |
✓✓ |
1806 |
for (i = 0; i < length; i++) |
780 |
|
1677 |
decouple_tab[start + i] = get_vlc2(&q->gb, |
781 |
|
|
p->channel_coupling.table, |
782 |
|
|
COUPLING_VLC_BITS, 3); |
783 |
|
|
else |
784 |
✓✓ |
1554 |
for (i = 0; i < length; i++) { |
785 |
|
1443 |
int v = get_bits(&q->gb, p->js_vlc_bits); |
786 |
✗✓ |
1443 |
if (v == (1<<p->js_vlc_bits)-1) { |
787 |
|
|
av_log(q->avctx, AV_LOG_ERROR, "decouple value too large\n"); |
788 |
|
|
return AVERROR_INVALIDDATA; |
789 |
|
|
} |
790 |
|
1443 |
decouple_tab[start + i] = v; |
791 |
|
|
} |
792 |
|
240 |
return 0; |
793 |
|
|
} |
794 |
|
|
|
795 |
|
|
/** |
796 |
|
|
* function decouples a pair of signals from a single signal via multiplication. |
797 |
|
|
* |
798 |
|
|
* @param q pointer to the COOKContext |
799 |
|
|
* @param subband index of the current subband |
800 |
|
|
* @param f1 multiplier for channel 1 extraction |
801 |
|
|
* @param f2 multiplier for channel 2 extraction |
802 |
|
|
* @param decode_buffer input buffer |
803 |
|
|
* @param mlt_buffer1 pointer to left channel mlt coefficients |
804 |
|
|
* @param mlt_buffer2 pointer to right channel mlt coefficients |
805 |
|
|
*/ |
806 |
|
7440 |
static void decouple_float(COOKContext *q, |
807 |
|
|
COOKSubpacket *p, |
808 |
|
|
int subband, |
809 |
|
|
float f1, float f2, |
810 |
|
|
float *decode_buffer, |
811 |
|
|
float *mlt_buffer1, float *mlt_buffer2) |
812 |
|
|
{ |
813 |
|
|
int j, tmp_idx; |
814 |
✓✓ |
156240 |
for (j = 0; j < SUBBAND_SIZE; j++) { |
815 |
|
148800 |
tmp_idx = ((p->js_subband_start + subband) * SUBBAND_SIZE) + j; |
816 |
|
148800 |
mlt_buffer1[SUBBAND_SIZE * subband + j] = f1 * decode_buffer[tmp_idx]; |
817 |
|
148800 |
mlt_buffer2[SUBBAND_SIZE * subband + j] = f2 * decode_buffer[tmp_idx]; |
818 |
|
|
} |
819 |
|
7440 |
} |
820 |
|
|
|
821 |
|
|
/** |
822 |
|
|
* function for decoding joint stereo data |
823 |
|
|
* |
824 |
|
|
* @param q pointer to the COOKContext |
825 |
|
|
* @param mlt_buffer1 pointer to left channel mlt coefficients |
826 |
|
|
* @param mlt_buffer2 pointer to right channel mlt coefficients |
827 |
|
|
*/ |
828 |
|
240 |
static int joint_decode(COOKContext *q, COOKSubpacket *p, |
829 |
|
|
float *mlt_buffer_left, float *mlt_buffer_right) |
830 |
|
|
{ |
831 |
|
|
int i, j, res; |
832 |
|
240 |
int decouple_tab[SUBBAND_SIZE] = { 0 }; |
833 |
|
240 |
float *decode_buffer = q->decode_buffer_0; |
834 |
|
|
int idx, cpl_tmp; |
835 |
|
|
float f1, f2; |
836 |
|
|
const float *cplscale; |
837 |
|
|
|
838 |
|
240 |
memset(decode_buffer, 0, sizeof(q->decode_buffer_0)); |
839 |
|
|
|
840 |
|
|
/* Make sure the buffers are zeroed out. */ |
841 |
|
240 |
memset(mlt_buffer_left, 0, 1024 * sizeof(*mlt_buffer_left)); |
842 |
|
240 |
memset(mlt_buffer_right, 0, 1024 * sizeof(*mlt_buffer_right)); |
843 |
✗✓ |
240 |
if ((res = decouple_info(q, p, decouple_tab)) < 0) |
844 |
|
|
return res; |
845 |
✗✓ |
240 |
if ((res = mono_decode(q, p, decode_buffer)) < 0) |
846 |
|
|
return res; |
847 |
|
|
/* The two channels are stored interleaved in decode_buffer. */ |
848 |
✓✓ |
1680 |
for (i = 0; i < p->js_subband_start; i++) { |
849 |
✓✓ |
30240 |
for (j = 0; j < SUBBAND_SIZE; j++) { |
850 |
|
28800 |
mlt_buffer_left[i * 20 + j] = decode_buffer[i * 40 + j]; |
851 |
|
28800 |
mlt_buffer_right[i * 20 + j] = decode_buffer[i * 40 + 20 + j]; |
852 |
|
|
} |
853 |
|
|
} |
854 |
|
|
|
855 |
|
|
/* When we reach js_subband_start (the higher frequencies) |
856 |
|
|
the coefficients are stored in a coupling scheme. */ |
857 |
|
240 |
idx = (1 << p->js_vlc_bits) - 1; |
858 |
✓✓ |
7680 |
for (i = p->js_subband_start; i < p->subbands; i++) { |
859 |
|
7440 |
cpl_tmp = cplband[i]; |
860 |
|
7440 |
idx -= decouple_tab[cpl_tmp]; |
861 |
|
7440 |
cplscale = q->cplscales[p->js_vlc_bits - 2]; // choose decoupler table |
862 |
|
7440 |
f1 = cplscale[decouple_tab[cpl_tmp] + 1]; |
863 |
|
7440 |
f2 = cplscale[idx]; |
864 |
|
7440 |
q->decouple(q, p, i, f1, f2, decode_buffer, |
865 |
|
|
mlt_buffer_left, mlt_buffer_right); |
866 |
|
7440 |
idx = (1 << p->js_vlc_bits) - 1; |
867 |
|
|
} |
868 |
|
|
|
869 |
|
240 |
return 0; |
870 |
|
|
} |
871 |
|
|
|
872 |
|
|
/** |
873 |
|
|
* First part of subpacket decoding: |
874 |
|
|
* decode raw stream bytes and read gain info. |
875 |
|
|
* |
876 |
|
|
* @param q pointer to the COOKContext |
877 |
|
|
* @param inbuffer pointer to raw stream data |
878 |
|
|
* @param gains_ptr array of current/prev gain pointers |
879 |
|
|
*/ |
880 |
|
240 |
static inline void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p, |
881 |
|
|
const uint8_t *inbuffer, |
882 |
|
|
cook_gains *gains_ptr) |
883 |
|
|
{ |
884 |
|
|
int offset; |
885 |
|
|
|
886 |
|
240 |
offset = decode_bytes(inbuffer, q->decoded_bytes_buffer, |
887 |
|
240 |
p->bits_per_subpacket / 8); |
888 |
|
240 |
init_get_bits(&q->gb, q->decoded_bytes_buffer + offset, |
889 |
|
|
p->bits_per_subpacket); |
890 |
|
240 |
decode_gain_info(&q->gb, gains_ptr->now); |
891 |
|
|
|
892 |
|
|
/* Swap current and previous gains */ |
893 |
|
240 |
FFSWAP(int *, gains_ptr->now, gains_ptr->previous); |
894 |
|
240 |
} |
895 |
|
|
|
896 |
|
|
/** |
897 |
|
|
* Saturate the output signal and interleave. |
898 |
|
|
* |
899 |
|
|
* @param q pointer to the COOKContext |
900 |
|
|
* @param out pointer to the output vector |
901 |
|
|
*/ |
902 |
|
476 |
static void saturate_output_float(COOKContext *q, float *out) |
903 |
|
|
{ |
904 |
|
476 |
q->adsp.vector_clipf(out, q->mono_mdct_output + q->samples_per_channel, |
905 |
|
476 |
FFALIGN(q->samples_per_channel, 8), -1.0f, 1.0f); |
906 |
|
476 |
} |
907 |
|
|
|
908 |
|
|
|
909 |
|
|
/** |
910 |
|
|
* Final part of subpacket decoding: |
911 |
|
|
* Apply modulated lapped transform, gain compensation, |
912 |
|
|
* clip and convert to integer. |
913 |
|
|
* |
914 |
|
|
* @param q pointer to the COOKContext |
915 |
|
|
* @param decode_buffer pointer to the mlt coefficients |
916 |
|
|
* @param gains_ptr array of current/prev gain pointers |
917 |
|
|
* @param previous_buffer pointer to the previous buffer to be used for overlapping |
918 |
|
|
* @param out pointer to the output buffer |
919 |
|
|
*/ |
920 |
|
480 |
static inline void mlt_compensate_output(COOKContext *q, float *decode_buffer, |
921 |
|
|
cook_gains *gains_ptr, float *previous_buffer, |
922 |
|
|
float *out) |
923 |
|
|
{ |
924 |
|
480 |
imlt_gain(q, decode_buffer, gains_ptr, previous_buffer); |
925 |
✓✓ |
480 |
if (out) |
926 |
|
476 |
q->saturate_output(q, out); |
927 |
|
480 |
} |
928 |
|
|
|
929 |
|
|
|
930 |
|
|
/** |
931 |
|
|
* Cook subpacket decoding. This function returns one decoded subpacket, |
932 |
|
|
* usually 1024 samples per channel. |
933 |
|
|
* |
934 |
|
|
* @param q pointer to the COOKContext |
935 |
|
|
* @param inbuffer pointer to the inbuffer |
936 |
|
|
* @param outbuffer pointer to the outbuffer |
937 |
|
|
*/ |
938 |
|
240 |
static int decode_subpacket(COOKContext *q, COOKSubpacket *p, |
939 |
|
|
const uint8_t *inbuffer, float **outbuffer) |
940 |
|
|
{ |
941 |
|
240 |
int sub_packet_size = p->size; |
942 |
|
|
int res; |
943 |
|
|
|
944 |
|
240 |
memset(q->decode_buffer_1, 0, sizeof(q->decode_buffer_1)); |
945 |
|
240 |
decode_bytes_and_gain(q, p, inbuffer, &p->gains1); |
946 |
|
|
|
947 |
✓✗ |
240 |
if (p->joint_stereo) { |
948 |
✗✓ |
240 |
if ((res = joint_decode(q, p, q->decode_buffer_1, q->decode_buffer_2)) < 0) |
949 |
|
|
return res; |
950 |
|
|
} else { |
951 |
|
|
if ((res = mono_decode(q, p, q->decode_buffer_1)) < 0) |
952 |
|
|
return res; |
953 |
|
|
|
954 |
|
|
if (p->num_channels == 2) { |
955 |
|
|
decode_bytes_and_gain(q, p, inbuffer + sub_packet_size / 2, &p->gains2); |
956 |
|
|
if ((res = mono_decode(q, p, q->decode_buffer_2)) < 0) |
957 |
|
|
return res; |
958 |
|
|
} |
959 |
|
|
} |
960 |
|
|
|
961 |
✓✓ |
240 |
mlt_compensate_output(q, q->decode_buffer_1, &p->gains1, |
962 |
|
240 |
p->mono_previous_buffer1, |
963 |
|
238 |
outbuffer ? outbuffer[p->ch_idx] : NULL); |
964 |
|
|
|
965 |
✓✗ |
240 |
if (p->num_channels == 2) { |
966 |
✓✗ |
240 |
if (p->joint_stereo) |
967 |
✓✓ |
240 |
mlt_compensate_output(q, q->decode_buffer_2, &p->gains1, |
968 |
|
240 |
p->mono_previous_buffer2, |
969 |
|
238 |
outbuffer ? outbuffer[p->ch_idx + 1] : NULL); |
970 |
|
|
else |
971 |
|
|
mlt_compensate_output(q, q->decode_buffer_2, &p->gains2, |
972 |
|
|
p->mono_previous_buffer2, |
973 |
|
|
outbuffer ? outbuffer[p->ch_idx + 1] : NULL); |
974 |
|
|
} |
975 |
|
|
|
976 |
|
240 |
return 0; |
977 |
|
|
} |
978 |
|
|
|
979 |
|
|
|
980 |
|
240 |
static int cook_decode_frame(AVCodecContext *avctx, void *data, |
981 |
|
|
int *got_frame_ptr, AVPacket *avpkt) |
982 |
|
|
{ |
983 |
|
240 |
AVFrame *frame = data; |
984 |
|
240 |
const uint8_t *buf = avpkt->data; |
985 |
|
240 |
int buf_size = avpkt->size; |
986 |
|
240 |
COOKContext *q = avctx->priv_data; |
987 |
|
240 |
float **samples = NULL; |
988 |
|
|
int i, ret; |
989 |
|
240 |
int offset = 0; |
990 |
|
240 |
int chidx = 0; |
991 |
|
|
|
992 |
✗✓ |
240 |
if (buf_size < avctx->block_align) |
993 |
|
|
return buf_size; |
994 |
|
|
|
995 |
|
|
/* get output buffer */ |
996 |
✓✓ |
240 |
if (q->discarded_packets >= 2) { |
997 |
|
238 |
frame->nb_samples = q->samples_per_channel; |
998 |
✗✓ |
238 |
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
999 |
|
|
return ret; |
1000 |
|
238 |
samples = (float **)frame->extended_data; |
1001 |
|
|
} |
1002 |
|
|
|
1003 |
|
|
/* estimate subpacket sizes */ |
1004 |
|
240 |
q->subpacket[0].size = avctx->block_align; |
1005 |
|
|
|
1006 |
✗✓ |
240 |
for (i = 1; i < q->num_subpackets; i++) { |
1007 |
|
|
q->subpacket[i].size = 2 * buf[avctx->block_align - q->num_subpackets + i]; |
1008 |
|
|
q->subpacket[0].size -= q->subpacket[i].size + 1; |
1009 |
|
|
if (q->subpacket[0].size < 0) { |
1010 |
|
|
av_log(avctx, AV_LOG_DEBUG, |
1011 |
|
|
"frame subpacket size total > avctx->block_align!\n"); |
1012 |
|
|
return AVERROR_INVALIDDATA; |
1013 |
|
|
} |
1014 |
|
|
} |
1015 |
|
|
|
1016 |
|
|
/* decode supbackets */ |
1017 |
✓✓ |
480 |
for (i = 0; i < q->num_subpackets; i++) { |
1018 |
|
240 |
q->subpacket[i].bits_per_subpacket = (q->subpacket[i].size * 8) >> |
1019 |
|
240 |
q->subpacket[i].bits_per_subpdiv; |
1020 |
|
240 |
q->subpacket[i].ch_idx = chidx; |
1021 |
|
240 |
av_log(avctx, AV_LOG_DEBUG, |
1022 |
|
|
"subpacket[%i] size %i js %i %i block_align %i\n", |
1023 |
|
|
i, q->subpacket[i].size, q->subpacket[i].joint_stereo, offset, |
1024 |
|
|
avctx->block_align); |
1025 |
|
|
|
1026 |
✗✓ |
240 |
if ((ret = decode_subpacket(q, &q->subpacket[i], buf + offset, samples)) < 0) |
1027 |
|
|
return ret; |
1028 |
|
240 |
offset += q->subpacket[i].size; |
1029 |
|
240 |
chidx += q->subpacket[i].num_channels; |
1030 |
|
480 |
av_log(avctx, AV_LOG_DEBUG, "subpacket[%i] %i %i\n", |
1031 |
|
240 |
i, q->subpacket[i].size * 8, get_bits_count(&q->gb)); |
1032 |
|
|
} |
1033 |
|
|
|
1034 |
|
|
/* Discard the first two frames: no valid audio. */ |
1035 |
✓✓ |
240 |
if (q->discarded_packets < 2) { |
1036 |
|
2 |
q->discarded_packets++; |
1037 |
|
2 |
*got_frame_ptr = 0; |
1038 |
|
2 |
return avctx->block_align; |
1039 |
|
|
} |
1040 |
|
|
|
1041 |
|
238 |
*got_frame_ptr = 1; |
1042 |
|
|
|
1043 |
|
238 |
return avctx->block_align; |
1044 |
|
|
} |
1045 |
|
|
|
1046 |
|
6 |
static void dump_cook_context(COOKContext *q) |
1047 |
|
|
{ |
1048 |
|
|
//int i=0; |
1049 |
|
|
#define PRINT(a, b) ff_dlog(q->avctx, " %s = %d\n", a, b); |
1050 |
|
|
ff_dlog(q->avctx, "COOKextradata\n"); |
1051 |
|
|
ff_dlog(q->avctx, "cookversion=%x\n", q->subpacket[0].cookversion); |
1052 |
|
6 |
if (q->subpacket[0].cookversion > STEREO) { |
1053 |
|
|
PRINT("js_subband_start", q->subpacket[0].js_subband_start); |
1054 |
|
|
PRINT("js_vlc_bits", q->subpacket[0].js_vlc_bits); |
1055 |
|
|
} |
1056 |
|
|
ff_dlog(q->avctx, "COOKContext\n"); |
1057 |
|
|
PRINT("nb_channels", q->avctx->channels); |
1058 |
|
|
PRINT("bit_rate", (int)q->avctx->bit_rate); |
1059 |
|
|
PRINT("sample_rate", q->avctx->sample_rate); |
1060 |
|
|
PRINT("samples_per_channel", q->subpacket[0].samples_per_channel); |
1061 |
|
|
PRINT("subbands", q->subpacket[0].subbands); |
1062 |
|
|
PRINT("js_subband_start", q->subpacket[0].js_subband_start); |
1063 |
|
|
PRINT("log2_numvector_size", q->subpacket[0].log2_numvector_size); |
1064 |
|
|
PRINT("numvector_size", q->subpacket[0].numvector_size); |
1065 |
|
|
PRINT("total_subbands", q->subpacket[0].total_subbands); |
1066 |
|
6 |
} |
1067 |
|
|
|
1068 |
|
|
/** |
1069 |
|
|
* Cook initialization |
1070 |
|
|
* |
1071 |
|
|
* @param avctx pointer to the AVCodecContext |
1072 |
|
|
*/ |
1073 |
|
6 |
static av_cold int cook_decode_init(AVCodecContext *avctx) |
1074 |
|
|
{ |
1075 |
|
6 |
COOKContext *q = avctx->priv_data; |
1076 |
|
|
GetByteContext gb; |
1077 |
|
6 |
int s = 0; |
1078 |
|
6 |
unsigned int channel_mask = 0; |
1079 |
|
6 |
int samples_per_frame = 0; |
1080 |
|
|
int ret; |
1081 |
|
6 |
q->avctx = avctx; |
1082 |
|
|
|
1083 |
|
|
/* Take care of the codec specific extradata. */ |
1084 |
✗✓ |
6 |
if (avctx->extradata_size < 8) { |
1085 |
|
|
av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n"); |
1086 |
|
|
return AVERROR_INVALIDDATA; |
1087 |
|
|
} |
1088 |
|
6 |
av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size); |
1089 |
|
|
|
1090 |
|
6 |
bytestream2_init(&gb, avctx->extradata, avctx->extradata_size); |
1091 |
|
|
|
1092 |
|
|
/* Take data from the AVCodecContext (RM container). */ |
1093 |
✗✓ |
6 |
if (!avctx->channels) { |
1094 |
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); |
1095 |
|
|
return AVERROR_INVALIDDATA; |
1096 |
|
|
} |
1097 |
|
|
|
1098 |
✗✓ |
6 |
if (avctx->block_align >= INT_MAX / 8) |
1099 |
|
|
return AVERROR(EINVAL); |
1100 |
|
|
|
1101 |
|
|
/* Initialize RNG. */ |
1102 |
|
6 |
av_lfg_init(&q->random_state, 0); |
1103 |
|
|
|
1104 |
|
6 |
ff_audiodsp_init(&q->adsp); |
1105 |
|
|
|
1106 |
✓✓ |
12 |
while (bytestream2_get_bytes_left(&gb)) { |
1107 |
✗✓ |
6 |
if (s >= FFMIN(MAX_SUBPACKETS, avctx->block_align)) { |
1108 |
|
|
avpriv_request_sample(avctx, "subpackets > %d", FFMIN(MAX_SUBPACKETS, avctx->block_align)); |
1109 |
|
|
return AVERROR_PATCHWELCOME; |
1110 |
|
|
} |
1111 |
|
|
/* 8 for mono, 16 for stereo, ? for multichannel |
1112 |
|
|
Swap to right endianness so we don't need to care later on. */ |
1113 |
|
6 |
q->subpacket[s].cookversion = bytestream2_get_be32(&gb); |
1114 |
|
6 |
samples_per_frame = bytestream2_get_be16(&gb); |
1115 |
|
6 |
q->subpacket[s].subbands = bytestream2_get_be16(&gb); |
1116 |
|
6 |
bytestream2_get_be32(&gb); // Unknown unused |
1117 |
|
6 |
q->subpacket[s].js_subband_start = bytestream2_get_be16(&gb); |
1118 |
✗✓ |
6 |
if (q->subpacket[s].js_subband_start >= 51) { |
1119 |
|
|
av_log(avctx, AV_LOG_ERROR, "js_subband_start %d is too large\n", q->subpacket[s].js_subband_start); |
1120 |
|
|
return AVERROR_INVALIDDATA; |
1121 |
|
|
} |
1122 |
|
6 |
q->subpacket[s].js_vlc_bits = bytestream2_get_be16(&gb); |
1123 |
|
|
|
1124 |
|
|
/* Initialize extradata related variables. */ |
1125 |
|
6 |
q->subpacket[s].samples_per_channel = samples_per_frame / avctx->channels; |
1126 |
|
6 |
q->subpacket[s].bits_per_subpacket = avctx->block_align * 8; |
1127 |
|
|
|
1128 |
|
|
/* Initialize default data states. */ |
1129 |
|
6 |
q->subpacket[s].log2_numvector_size = 5; |
1130 |
|
6 |
q->subpacket[s].total_subbands = q->subpacket[s].subbands; |
1131 |
|
6 |
q->subpacket[s].num_channels = 1; |
1132 |
|
|
|
1133 |
|
|
/* Initialize version-dependent variables */ |
1134 |
|
|
|
1135 |
|
6 |
av_log(avctx, AV_LOG_DEBUG, "subpacket[%i].cookversion=%x\n", s, |
1136 |
|
|
q->subpacket[s].cookversion); |
1137 |
|
6 |
q->subpacket[s].joint_stereo = 0; |
1138 |
✗✓✓✗ ✗ |
6 |
switch (q->subpacket[s].cookversion) { |
1139 |
|
|
case MONO: |
1140 |
|
|
if (avctx->channels != 1) { |
1141 |
|
|
avpriv_request_sample(avctx, "Container channels != 1"); |
1142 |
|
|
return AVERROR_PATCHWELCOME; |
1143 |
|
|
} |
1144 |
|
|
av_log(avctx, AV_LOG_DEBUG, "MONO\n"); |
1145 |
|
|
break; |
1146 |
|
2 |
case STEREO: |
1147 |
✗✓ |
2 |
if (avctx->channels != 1) { |
1148 |
|
|
q->subpacket[s].bits_per_subpdiv = 1; |
1149 |
|
|
q->subpacket[s].num_channels = 2; |
1150 |
|
|
} |
1151 |
|
2 |
av_log(avctx, AV_LOG_DEBUG, "STEREO\n"); |
1152 |
|
2 |
break; |
1153 |
|
4 |
case JOINT_STEREO: |
1154 |
✗✓ |
4 |
if (avctx->channels != 2) { |
1155 |
|
|
avpriv_request_sample(avctx, "Container channels != 2"); |
1156 |
|
|
return AVERROR_PATCHWELCOME; |
1157 |
|
|
} |
1158 |
|
4 |
av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n"); |
1159 |
✓✗ |
4 |
if (avctx->extradata_size >= 16) { |
1160 |
|
4 |
q->subpacket[s].total_subbands = q->subpacket[s].subbands + |
1161 |
|
4 |
q->subpacket[s].js_subband_start; |
1162 |
|
4 |
q->subpacket[s].joint_stereo = 1; |
1163 |
|
4 |
q->subpacket[s].num_channels = 2; |
1164 |
|
|
} |
1165 |
✓✗ |
4 |
if (q->subpacket[s].samples_per_channel > 256) { |
1166 |
|
4 |
q->subpacket[s].log2_numvector_size = 6; |
1167 |
|
|
} |
1168 |
✓✗ |
4 |
if (q->subpacket[s].samples_per_channel > 512) { |
1169 |
|
4 |
q->subpacket[s].log2_numvector_size = 7; |
1170 |
|
|
} |
1171 |
|
4 |
break; |
1172 |
|
|
case MC_COOK: |
1173 |
|
|
av_log(avctx, AV_LOG_DEBUG, "MULTI_CHANNEL\n"); |
1174 |
|
|
channel_mask |= q->subpacket[s].channel_mask = bytestream2_get_be32(&gb); |
1175 |
|
|
|
1176 |
|
|
if (av_get_channel_layout_nb_channels(q->subpacket[s].channel_mask) > 1) { |
1177 |
|
|
q->subpacket[s].total_subbands = q->subpacket[s].subbands + |
1178 |
|
|
q->subpacket[s].js_subband_start; |
1179 |
|
|
q->subpacket[s].joint_stereo = 1; |
1180 |
|
|
q->subpacket[s].num_channels = 2; |
1181 |
|
|
q->subpacket[s].samples_per_channel = samples_per_frame >> 1; |
1182 |
|
|
|
1183 |
|
|
if (q->subpacket[s].samples_per_channel > 256) { |
1184 |
|
|
q->subpacket[s].log2_numvector_size = 6; |
1185 |
|
|
} |
1186 |
|
|
if (q->subpacket[s].samples_per_channel > 512) { |
1187 |
|
|
q->subpacket[s].log2_numvector_size = 7; |
1188 |
|
|
} |
1189 |
|
|
} else |
1190 |
|
|
q->subpacket[s].samples_per_channel = samples_per_frame; |
1191 |
|
|
|
1192 |
|
|
break; |
1193 |
|
|
default: |
1194 |
|
|
avpriv_request_sample(avctx, "Cook version %d", |
1195 |
|
|
q->subpacket[s].cookversion); |
1196 |
|
|
return AVERROR_PATCHWELCOME; |
1197 |
|
|
} |
1198 |
|
|
|
1199 |
✗✓✗✗
|
6 |
if (s > 1 && q->subpacket[s].samples_per_channel != q->samples_per_channel) { |
1200 |
|
|
av_log(avctx, AV_LOG_ERROR, "different number of samples per channel!\n"); |
1201 |
|
|
return AVERROR_INVALIDDATA; |
1202 |
|
|
} else |
1203 |
|
6 |
q->samples_per_channel = q->subpacket[0].samples_per_channel; |
1204 |
|
|
|
1205 |
|
|
|
1206 |
|
|
/* Initialize variable relations */ |
1207 |
|
6 |
q->subpacket[s].numvector_size = (1 << q->subpacket[s].log2_numvector_size); |
1208 |
|
|
|
1209 |
|
|
/* Try to catch some obviously faulty streams, otherwise it might be exploitable */ |
1210 |
✗✓ |
6 |
if (q->subpacket[s].total_subbands > 53) { |
1211 |
|
|
avpriv_request_sample(avctx, "total_subbands > 53"); |
1212 |
|
|
return AVERROR_PATCHWELCOME; |
1213 |
|
|
} |
1214 |
|
|
|
1215 |
✓✗ |
6 |
if ((q->subpacket[s].js_vlc_bits > 6) || |
1216 |
✗✓ |
6 |
(q->subpacket[s].js_vlc_bits < 2 * q->subpacket[s].joint_stereo)) { |
1217 |
|
|
av_log(avctx, AV_LOG_ERROR, "js_vlc_bits = %d, only >= %d and <= 6 allowed!\n", |
1218 |
|
|
q->subpacket[s].js_vlc_bits, 2 * q->subpacket[s].joint_stereo); |
1219 |
|
|
return AVERROR_INVALIDDATA; |
1220 |
|
|
} |
1221 |
|
|
|
1222 |
✗✓ |
6 |
if (q->subpacket[s].subbands > 50) { |
1223 |
|
|
avpriv_request_sample(avctx, "subbands > 50"); |
1224 |
|
|
return AVERROR_PATCHWELCOME; |
1225 |
|
|
} |
1226 |
✗✓ |
6 |
if (q->subpacket[s].subbands == 0) { |
1227 |
|
|
avpriv_request_sample(avctx, "subbands = 0"); |
1228 |
|
|
return AVERROR_PATCHWELCOME; |
1229 |
|
|
} |
1230 |
|
6 |
q->subpacket[s].gains1.now = q->subpacket[s].gain_1; |
1231 |
|
6 |
q->subpacket[s].gains1.previous = q->subpacket[s].gain_2; |
1232 |
|
6 |
q->subpacket[s].gains2.now = q->subpacket[s].gain_3; |
1233 |
|
6 |
q->subpacket[s].gains2.previous = q->subpacket[s].gain_4; |
1234 |
|
|
|
1235 |
✗✓ |
6 |
if (q->num_subpackets + q->subpacket[s].num_channels > q->avctx->channels) { |
1236 |
|
|
av_log(avctx, AV_LOG_ERROR, "Too many subpackets %d for channels %d\n", q->num_subpackets, q->avctx->channels); |
1237 |
|
|
return AVERROR_INVALIDDATA; |
1238 |
|
|
} |
1239 |
|
|
|
1240 |
|
6 |
q->num_subpackets++; |
1241 |
|
6 |
s++; |
1242 |
|
|
} |
1243 |
|
|
|
1244 |
|
|
/* Try to catch some obviously faulty streams, otherwise it might be exploitable */ |
1245 |
✓✗✓✗
|
6 |
if (q->samples_per_channel != 256 && q->samples_per_channel != 512 && |
1246 |
✗✓ |
6 |
q->samples_per_channel != 1024) { |
1247 |
|
|
avpriv_request_sample(avctx, "samples_per_channel = %d", |
1248 |
|
|
q->samples_per_channel); |
1249 |
|
|
return AVERROR_PATCHWELCOME; |
1250 |
|
|
} |
1251 |
|
|
|
1252 |
|
|
/* Generate tables */ |
1253 |
|
6 |
init_pow2table(); |
1254 |
|
6 |
init_gain_table(q); |
1255 |
|
6 |
init_cplscales_table(q); |
1256 |
|
|
|
1257 |
✗✓ |
6 |
if ((ret = init_cook_vlc_tables(q))) |
1258 |
|
|
return ret; |
1259 |
|
|
|
1260 |
|
|
/* Pad the databuffer with: |
1261 |
|
|
DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(), |
1262 |
|
|
AV_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */ |
1263 |
|
6 |
q->decoded_bytes_buffer = |
1264 |
|
6 |
av_mallocz(avctx->block_align |
1265 |
|
6 |
+ DECODE_BYTES_PAD1(avctx->block_align) |
1266 |
|
6 |
+ AV_INPUT_BUFFER_PADDING_SIZE); |
1267 |
✗✓ |
6 |
if (!q->decoded_bytes_buffer) |
1268 |
|
|
return AVERROR(ENOMEM); |
1269 |
|
|
|
1270 |
|
|
/* Initialize transform. */ |
1271 |
✗✓ |
6 |
if ((ret = init_cook_mlt(q))) |
1272 |
|
|
return ret; |
1273 |
|
|
|
1274 |
|
|
/* Initialize COOK signal arithmetic handling */ |
1275 |
|
|
if (1) { |
1276 |
|
6 |
q->scalar_dequant = scalar_dequant_float; |
1277 |
|
6 |
q->decouple = decouple_float; |
1278 |
|
6 |
q->imlt_window = imlt_window_float; |
1279 |
|
6 |
q->interpolate = interpolate_float; |
1280 |
|
6 |
q->saturate_output = saturate_output_float; |
1281 |
|
|
} |
1282 |
|
|
|
1283 |
|
6 |
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; |
1284 |
✗✓ |
6 |
if (channel_mask) |
1285 |
|
|
avctx->channel_layout = channel_mask; |
1286 |
|
|
else |
1287 |
✓✓ |
6 |
avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; |
1288 |
|
|
|
1289 |
|
|
|
1290 |
|
6 |
dump_cook_context(q); |
1291 |
|
|
|
1292 |
|
6 |
return 0; |
1293 |
|
|
} |
1294 |
|
|
|
1295 |
|
|
AVCodec ff_cook_decoder = { |
1296 |
|
|
.name = "cook", |
1297 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("Cook / Cooker / Gecko (RealAudio G2)"), |
1298 |
|
|
.type = AVMEDIA_TYPE_AUDIO, |
1299 |
|
|
.id = AV_CODEC_ID_COOK, |
1300 |
|
|
.priv_data_size = sizeof(COOKContext), |
1301 |
|
|
.init = cook_decode_init, |
1302 |
|
|
.close = cook_decode_close, |
1303 |
|
|
.decode = cook_decode_frame, |
1304 |
|
|
.capabilities = AV_CODEC_CAP_DR1, |
1305 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP, |
1306 |
|
|
.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, |
1307 |
|
|
AV_SAMPLE_FMT_NONE }, |
1308 |
|
|
}; |