FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/hcadec.c
Date: 2026-09-27 12:50:02
Exec Total Coverage
Lines: 0 358 0.0%
Functions: 0 17 0.0%
Branches: 0 204 0.0%
Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include "libavutil/crc.h"
20 #include "libavutil/float_dsp.h"
21 #include "libavutil/mem.h"
22 #include "libavutil/mem_internal.h"
23 #include "libavutil/tx.h"
24
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "codec_internal.h"
28 #include "decode.h"
29 #include "get_bits.h"
30 #include "hca_data.h"
31
32 #define HCA_MASK 0x7f7f7f7f
33 #define MAX_CHANNELS 16
34
35 typedef struct ChannelContext {
36 DECLARE_ALIGNED(32, float, base)[128];
37 DECLARE_ALIGNED(32, float, factors)[128];
38 DECLARE_ALIGNED(32, float, imdct_in)[128];
39 DECLARE_ALIGNED(32, float, imdct_out)[128];
40 DECLARE_ALIGNED(32, float, imdct_prev)[128];
41 int8_t scale_factors[128];
42 uint8_t scale[128];
43 int8_t intensity[8];
44 int8_t *hfr_scale;
45 unsigned count;
46 int chan_type;
47 } ChannelContext;
48
49 typedef struct HCAContext {
50 const AVCRC *crc_table;
51
52 ChannelContext ch[MAX_CHANNELS];
53
54 uint8_t ath[128];
55 uint8_t cipher[256];
56 uint64_t key;
57 uint16_t subkey;
58
59 int ath_type;
60 int ciph_type;
61 unsigned hfr_group_count;
62 uint8_t track_count;
63 uint8_t channel_config;
64 uint8_t total_band_count;
65 uint8_t base_band_count;
66 uint8_t stereo_band_count;
67 uint8_t bands_per_hfr_group;
68
69 // Set during init() and freed on close(). Untouched on init_flush()
70 av_tx_fn tx_fn;
71 AVTXContext *tx_ctx;
72 AVFloatDSPContext *fdsp;
73 } HCAContext;
74
75 ✗ static void cipher_init56_create_table(uint8_t *r, uint8_t key)
76 {
77 ✗ const int mul = ((key & 1) << 3) | 5;
78 ✗ const int add = (key & 0xE) | 1;
79
80 ✗ key >>= 4;
81 ✗ for (int i = 0; i < 16; i++) {
82 ✗ key = (key * mul + add) & 0xF;
83 ✗ r[i] = key;
84 }
85 ✗ }
86
87 ✗ static void cipher_init56(uint8_t *cipher, uint64_t keycode)
88 {
89 uint8_t base[256], base_r[16], base_c[16], kc[8], seed[16];
90
91 /* 56bit keycode encryption (given as a uint64_t number, but upper 8b aren't used) */
92 /* keycode = keycode - 1 */
93 ✗ if (keycode != 0)
94 ✗ keycode--;
95
96 /* init keycode table */
97 ✗ for (int r = 0; r < (8-1); r++) {
98 ✗ kc[r] = keycode & 0xFF;
99 ✗ keycode = keycode >> 8;
100 }
101
102 /* init seed table */
103 ✗ seed[ 0] = kc[1];
104 ✗ seed[ 1] = kc[1] ^ kc[6];
105 ✗ seed[ 2] = kc[2] ^ kc[3];
106 ✗ seed[ 3] = kc[2];
107 ✗ seed[ 4] = kc[2] ^ kc[1];
108 ✗ seed[ 5] = kc[3] ^ kc[4];
109 ✗ seed[ 6] = kc[3];
110 ✗ seed[ 7] = kc[3] ^ kc[2];
111 ✗ seed[ 8] = kc[4] ^ kc[5];
112 ✗ seed[ 9] = kc[4];
113 ✗ seed[10] = kc[4] ^ kc[3];
114 ✗ seed[11] = kc[5] ^ kc[6];
115 ✗ seed[12] = kc[5];
116 ✗ seed[13] = kc[5] ^ kc[4];
117 ✗ seed[14] = kc[6] ^ kc[1];
118 ✗ seed[15] = kc[6];
119
120 /* init base table */
121 ✗ cipher_init56_create_table(base_r, kc[0]);
122 ✗ for (int r = 0; r < 16; r++) {
123 uint8_t nb;
124 ✗ cipher_init56_create_table(base_c, seed[r]);
125 ✗ nb = base_r[r] << 4;
126 ✗ for (int c = 0; c < 16; c++)
127 ✗ base[r*16 + c] = nb | base_c[c]; /* combine nibbles */
128 }
129
130 /* final shuffle table */
131 {
132 ✗ unsigned x = 0;
133 ✗ unsigned pos = 1;
134
135 ✗ for (int i = 0; i < 256; i++) {
136 ✗ x = (x + 17) & 0xFF;
137 ✗ if (base[x] != 0 && base[x] != 0xFF)
138 ✗ cipher[pos++] = base[x];
139 }
140 ✗ cipher[0] = 0;
141 ✗ cipher[0xFF] = 0xFF;
142 }
143 ✗ }
144
145 ✗ static void cipher_init(uint8_t *cipher, int type, uint64_t keycode, uint16_t subkey)
146 {
147 ✗ switch (type) {
148 ✗ case 56:
149 ✗ if (keycode) {
150 ✗ if (subkey)
151 ✗ keycode = keycode * (((uint64_t)subkey<<16u)|((uint16_t)~subkey+2u));
152 ✗ cipher_init56(cipher, keycode);
153 }
154 ✗ break;
155 ✗ case 0:
156 ✗ for (int i = 0; i < 256; i++)
157 ✗ cipher[i] = i;
158 ✗ break;
159 }
160 ✗ }
161
162 ✗ static void ath_init1(uint8_t *ath, int sample_rate)
163 {
164 unsigned int index;
165 ✗ unsigned int acc = 0;
166
167 ✗ for (int i = 0; i < 128; i++) {
168 ✗ acc += sample_rate;
169 ✗ index = acc >> 13;
170
171 ✗ if (index >= 654) {
172 ✗ memset(ath+i, 0xFF, (128 - i));
173 ✗ break;
174 }
175
176 ✗ ath[i] = ath_base_curve[index];
177 }
178 ✗ }
179
180 ✗ static int ath_init(uint8_t *ath, int type, int sample_rate)
181 {
182 ✗ switch (type) {
183 ✗ case 0:
184 /* nothing to do */
185 ✗ break;
186 ✗ case 1:
187 ✗ ath_init1(ath, sample_rate);
188 ✗ break;
189 ✗ default:
190 ✗ return AVERROR_INVALIDDATA;
191 }
192
193 ✗ return 0;
194 }
195
196 ✗ static inline unsigned ceil2(unsigned a, unsigned b)
197 {
198 ✗ return (b > 0) ? (a / b + ((a % b) ? 1 : 0)) : 0;
199 }
200
201 ✗ static av_cold void init_flush(AVCodecContext *avctx)
202 {
203 ✗ HCAContext *c = avctx->priv_data;
204
205 ✗ memset(c, 0, offsetof(HCAContext, tx_fn));
206 ✗ }
207
208 ✗ static int init_hca(AVCodecContext *avctx, const uint8_t *extradata,
209 const int extradata_size)
210 {
211 ✗ HCAContext *c = avctx->priv_data;
212 ✗ GetByteContext gb0, *const gb = &gb0;
213 ✗ int8_t r[16] = { 0 };
214 unsigned b, chunk;
215 int version, ret;
216 unsigned hfr_group_count;
217
218 ✗ init_flush(avctx);
219
220 ✗ if (extradata_size < 36)
221 ✗ return AVERROR_INVALIDDATA;
222
223 ✗ bytestream2_init(gb, extradata, extradata_size);
224
225 ✗ bytestream2_skipu(gb, 4);
226 ✗ version = bytestream2_get_be16(gb);
227 ✗ bytestream2_skipu(gb, 2);
228
229 ✗ c->ath_type = version >= 0x200 ? 0 : 1;
230
231 ✗ if ((bytestream2_get_be32u(gb) & HCA_MASK) != MKBETAG('f', 'm', 't', 0))
232 ✗ return AVERROR_INVALIDDATA;
233 ✗ bytestream2_skipu(gb, 4);
234 ✗ bytestream2_skipu(gb, 4);
235 ✗ bytestream2_skipu(gb, 4);
236
237 ✗ chunk = bytestream2_get_be32u(gb) & HCA_MASK;
238 ✗ if (chunk == MKBETAG('c', 'o', 'm', 'p')) {
239 ✗ bytestream2_skipu(gb, 2);
240 ✗ bytestream2_skipu(gb, 1);
241 ✗ bytestream2_skipu(gb, 1);
242 ✗ c->track_count = bytestream2_get_byteu(gb);
243 ✗ c->channel_config = bytestream2_get_byteu(gb);
244 ✗ c->total_band_count = bytestream2_get_byteu(gb);
245 ✗ c->base_band_count = bytestream2_get_byteu(gb);
246 ✗ c->stereo_band_count = bytestream2_get_byte (gb);
247 ✗ c->bands_per_hfr_group = bytestream2_get_byte (gb);
248 ✗ bytestream2_skipu(gb, 2);
249 ✗ } else if (chunk == MKBETAG('d', 'e', 'c', 0)) {
250 ✗ bytestream2_skipu(gb, 2);
251 ✗ bytestream2_skipu(gb, 1);
252 ✗ bytestream2_skipu(gb, 1);
253 ✗ c->total_band_count = bytestream2_get_byteu(gb) + 1;
254 ✗ c->base_band_count = bytestream2_get_byteu(gb) + 1;
255 ✗ c->track_count = bytestream2_peek_byteu(gb) >> 4;
256 ✗ c->channel_config = bytestream2_get_byteu(gb) & 0xF;
257 ✗ if (!bytestream2_get_byteu(gb))
258 ✗ c->base_band_count = c->total_band_count;
259 ✗ c->stereo_band_count = c->total_band_count - c->base_band_count;
260 ✗ c->bands_per_hfr_group = 0;
261 } else
262 ✗ return AVERROR_INVALIDDATA;
263
264 ✗ if (c->total_band_count > FF_ARRAY_ELEMS(c->ch->imdct_in))
265 ✗ return AVERROR_INVALIDDATA;
266
267 ✗ while (bytestream2_get_bytes_left(gb) >= 4) {
268 ✗ chunk = bytestream2_get_be32u(gb) & HCA_MASK;
269 ✗ if (chunk == MKBETAG('v', 'b', 'r', 0)) {
270 ✗ bytestream2_skip(gb, 2 + 2);
271 ✗ } else if (chunk == MKBETAG('a', 't', 'h', 0)) {
272 ✗ c->ath_type = bytestream2_get_be16(gb);
273 ✗ } else if (chunk == MKBETAG('r', 'v', 'a', 0)) {
274 ✗ bytestream2_skip(gb, 4);
275 ✗ } else if (chunk == MKBETAG('c', 'o', 'm', 'm')) {
276 ✗ bytestream2_skip(gb, bytestream2_get_byte(gb) * 8);
277 ✗ } else if (chunk == MKBETAG('c', 'i', 'p', 'h')) {
278 ✗ c->ciph_type = bytestream2_get_be16(gb);
279 ✗ } else if (chunk == MKBETAG('l', 'o', 'o', 'p')) {
280 ✗ bytestream2_skip(gb, 4 + 4 + 2 + 2);
281 ✗ } else if (chunk == MKBETAG('p', 'a', 'd', 0)) {
282 ✗ break;
283 } else {
284 ✗ break;
285 }
286 }
287
288 ✗ if (bytestream2_get_bytes_left(gb) >= 10) {
289 ✗ bytestream2_skip(gb, bytestream2_get_bytes_left(gb) - 10);
290 ✗ c->key = bytestream2_get_be64u(gb);
291 ✗ c->subkey = bytestream2_get_be16u(gb);
292 }
293
294 ✗ cipher_init(c->cipher, c->ciph_type, c->key, c->subkey);
295
296 ✗ ret = ath_init(c->ath, c->ath_type, avctx->sample_rate);
297 ✗ if (ret < 0)
298 ✗ return ret;
299
300 ✗ if (!c->track_count)
301 ✗ c->track_count = 1;
302
303 ✗ b = avctx->ch_layout.nb_channels / c->track_count;
304 ✗ if (c->stereo_band_count && b > 1) {
305 ✗ int8_t *x = r;
306
307 ✗ for (int i = 0; i < c->track_count; i++, x+=b) {
308 ✗ switch (b) {
309 ✗ case 2:
310 case 3:
311 ✗ x[0] = 1;
312 ✗ x[1] = 2;
313 ✗ break;
314 ✗ case 4:
315 ✗ x[0]=1; x[1] = 2;
316 ✗ if (c->channel_config == 0) {
317 ✗ x[2]=1;
318 ✗ x[3]=2;
319 }
320 ✗ break;
321 ✗ case 5:
322 ✗ x[0]=1; x[1] = 2;
323 ✗ if (c->channel_config <= 2) {
324 ✗ x[3]=1;
325 ✗ x[4]=2;
326 }
327 ✗ break;
328 ✗ case 6:
329 case 7:
330 ✗ x[0] = 1; x[1] = 2; x[4] = 1; x[5] = 2;
331 ✗ break;
332 ✗ case 8:
333 ✗ x[0] = 1; x[1] = 2; x[4] = 1; x[5] = 2; x[6] = 1; x[7] = 2;
334 ✗ break;
335 }
336 }
337 }
338
339 ✗ if (c->total_band_count < c->base_band_count)
340 ✗ return AVERROR_INVALIDDATA;
341
342 ✗ hfr_group_count = ceil2(c->total_band_count - (c->base_band_count + c->stereo_band_count),
343 ✗ c->bands_per_hfr_group);
344
345 ✗ if (c->base_band_count + c->stereo_band_count + (uint64_t)hfr_group_count > 128ULL)
346 ✗ return AVERROR_INVALIDDATA;
347 ✗ c->hfr_group_count = hfr_group_count;
348
349 ✗ for (int i = 0; i < avctx->ch_layout.nb_channels; i++) {
350 ✗ c->ch[i].chan_type = r[i];
351 ✗ c->ch[i].count = c->base_band_count + ((r[i] != 2) ? c->stereo_band_count : 0);
352 ✗ c->ch[i].hfr_scale = &c->ch[i].scale_factors[c->base_band_count + c->stereo_band_count];
353 ✗ if (c->ch[i].count > 128)
354 ✗ return AVERROR_INVALIDDATA;
355 }
356
357 // Done last to signal init() finished
358 ✗ c->crc_table = av_crc_get_table(AV_CRC_16_ANSI);
359
360 ✗ return 0;
361 }
362
363 ✗ static av_cold int decode_init(AVCodecContext *avctx)
364 {
365 ✗ HCAContext *c = avctx->priv_data;
366 ✗ float scale = 1.f / 8.f;
367 int ret;
368
369 ✗ avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
370
371 ✗ if (avctx->ch_layout.nb_channels <= 0 || avctx->ch_layout.nb_channels > FF_ARRAY_ELEMS(c->ch))
372 ✗ return AVERROR(EINVAL);
373
374 ✗ c->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
375 ✗ if (!c->fdsp)
376 ✗ return AVERROR(ENOMEM);
377
378 ✗ ret = av_tx_init(&c->tx_ctx, &c->tx_fn, AV_TX_FLOAT_MDCT, 1, 128, &scale, 0);
379 ✗ if (ret < 0)
380 ✗ return ret;
381
382 ✗ if (avctx->extradata_size != 0 && avctx->extradata_size < 36)
383 ✗ return AVERROR_INVALIDDATA;
384
385 ✗ if (!avctx->extradata_size)
386 ✗ return 0;
387
388 ✗ return init_hca(avctx, avctx->extradata, avctx->extradata_size);
389 }
390
391 ✗ static void run_imdct(HCAContext *c, ChannelContext *ch, int index, float *out)
392 {
393 ✗ c->tx_fn(c->tx_ctx, ch->imdct_out, ch->imdct_in, sizeof(float));
394
395 ✗ c->fdsp->vector_fmul_window(out, ch->imdct_prev + (128 >> 1),
396 ✗ ch->imdct_out, window, 128 >> 1);
397
398 ✗ memcpy(ch->imdct_prev, ch->imdct_out, 128 * sizeof(float));
399 ✗ }
400
401 ✗ static void apply_intensity_stereo(HCAContext *s, ChannelContext *ch1, ChannelContext *ch2,
402 int index, unsigned band_count, unsigned base_band_count,
403 unsigned stereo_band_count)
404 {
405 ✗ float ratio_l = intensity_ratio_table[ch2->intensity[index]];
406 ✗ float ratio_r = ratio_l - 2.0f;
407 ✗ float *c1 = &ch1->imdct_in[base_band_count];
408 ✗ float *c2 = &ch2->imdct_in[base_band_count];
409
410 ✗ if (ch1->chan_type != 1 || !stereo_band_count)
411 ✗ return;
412
413 ✗ for (int i = 0; i < band_count; i++) {
414 ✗ c2[i] = c1[i] * ratio_r;
415 ✗ c1[i] *= ratio_l;
416 }
417 }
418
419 ✗ static void reconstruct_hfr(HCAContext *s, ChannelContext *ch,
420 unsigned hfr_group_count,
421 unsigned bands_per_hfr_group,
422 unsigned start_band, unsigned total_band_count)
423 {
424 ✗ if (ch->chan_type == 2 || !bands_per_hfr_group)
425 ✗ return;
426
427 ✗ for (int i = 0, k = start_band, l = start_band - 1; i < hfr_group_count; i++){
428 ✗ for (int j = 0; j < bands_per_hfr_group && k < total_band_count && l >= 0; j++, k++, l--){
429 ✗ ch->imdct_in[k] = scale_conversion_table[ scale_conv_bias +
430 ✗ av_clip_intp2(ch->hfr_scale[i] - ch->scale_factors[l], 6) ] * ch->imdct_in[l];
431 }
432 }
433
434 ✗ ch->imdct_in[127] = 0;
435 }
436
437 ✗ static void dequantize_coefficients(HCAContext *c, ChannelContext *ch,
438 GetBitContext *gb)
439 {
440 ✗ const float *base = ch->base;
441 ✗ float *factors = ch->factors;
442 ✗ float *out = ch->imdct_in;
443
444 ✗ for (int i = 0; i < ch->count; i++) {
445 ✗ unsigned scale = ch->scale[i];
446 ✗ int nb_bits = max_bits_table[scale];
447 ✗ int value = get_bitsz(gb, nb_bits);
448 float factor;
449
450 ✗ if (scale > 7) {
451 ✗ value = (1 - ((value & 1) << 1)) * (value >> 1);
452 ✗ if (!value)
453 ✗ skip_bits_long(gb, -1);
454 ✗ factor = value;
455 } else {
456 ✗ value += scale << 4;
457 ✗ skip_bits_long(gb, quant_spectrum_bits[value] - nb_bits);
458 ✗ factor = quant_spectrum_value[value];
459 }
460 ✗ factors[i] = factor;
461 }
462
463 ✗ memset(factors + ch->count, 0, 512 - ch->count * sizeof(*factors));
464 ✗ c->fdsp->vector_fmul(out, factors, base, 128);
465 ✗ }
466
467 ✗ static void unpack(HCAContext *c, ChannelContext *ch,
468 GetBitContext *gb,
469 unsigned hfr_group_count,
470 int packed_noise_level,
471 const uint8_t *ath)
472 {
473 ✗ int delta_bits = get_bits(gb, 3);
474
475 ✗ if (delta_bits > 5) {
476 ✗ for (int i = 0; i < ch->count; i++)
477 ✗ ch->scale_factors[i] = get_bits(gb, 6);
478 ✗ } else if (delta_bits) {
479 ✗ int factor = get_bits(gb, 6);
480 ✗ int max_value = (1 << delta_bits) - 1;
481 ✗ int half_max = max_value >> 1;
482
483 ✗ ch->scale_factors[0] = factor;
484 ✗ for (int i = 1; i < ch->count; i++){
485 ✗ int delta = get_bits(gb, delta_bits);
486
487 ✗ if (delta == max_value) {
488 ✗ factor = get_bits(gb, 6);
489 } else {
490 ✗ factor += delta - half_max;
491 }
492 ✗ factor = av_clip_uintp2(factor, 6);
493
494 ✗ ch->scale_factors[i] = factor;
495 }
496 } else {
497 ✗ memset(ch->scale_factors, 0, 128);
498 }
499
500 ✗ if (ch->chan_type == 2){
501 ✗ ch->intensity[0] = get_bits(gb, 4);
502 ✗ if (ch->intensity[0] < 15) {
503 ✗ for (int i = 1; i < 8; i++)
504 ✗ ch->intensity[i] = get_bits(gb, 4);
505 }
506 } else {
507 ✗ for (int i = 0; i < hfr_group_count; i++)
508 ✗ ch->hfr_scale[i] = get_bits(gb, 6);
509 }
510
511 ✗ for (int i = 0; i < ch->count; i++) {
512 ✗ int scale = ch->scale_factors[i];
513
514 ✗ if (scale) {
515 ✗ scale = c->ath[i] + ((packed_noise_level + i) >> 8) - ((scale * 5) >> 1) + 2;
516 ✗ scale = scale_table[av_clip(scale, 0, 58)];
517 }
518 ✗ ch->scale[i] = scale;
519 }
520
521 ✗ memset(ch->scale + ch->count, 0, sizeof(ch->scale) - ch->count);
522
523 ✗ for (int i = 0; i < ch->count; i++)
524 ✗ ch->base[i] = dequantizer_scaling_table[ch->scale_factors[i]] * quant_step_size[ch->scale[i]];
525 ✗ }
526
527 ✗ static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
528 int *got_frame_ptr, AVPacket *avpkt)
529 {
530 ✗ HCAContext *c = avctx->priv_data;
531 ✗ int ch, offset = 0, ret, packed_noise_level;
532 ✗ GetBitContext gb0, *const gb = &gb0;
533 float **samples;
534
535 ✗ if (avpkt->size <= 8)
536 ✗ return AVERROR_INVALIDDATA;
537
538 ✗ if (AV_RN16(avpkt->data) != 0xFFFF) {
539 ✗ if ((AV_RL32(avpkt->data)) != MKTAG('H','C','A',0)) {
540 ✗ return AVERROR_INVALIDDATA;
541 ✗ } else if (AV_RB16(avpkt->data + 6) <= avpkt->size) {
542 ✗ ret = init_hca(avctx, avpkt->data, AV_RB16(avpkt->data + 6));
543 ✗ if (ret < 0) {
544 ✗ c->crc_table = NULL; // signal that init has not finished
545 ✗ return ret;
546 }
547 ✗ offset = AV_RB16(avpkt->data + 6);
548 ✗ if (offset == avpkt->size)
549 ✗ return avpkt->size;
550 } else {
551 ✗ return AVERROR_INVALIDDATA;
552 }
553 }
554
555 ✗ if (!c->crc_table)
556 ✗ return AVERROR_INVALIDDATA;
557
558 ✗ if (c->key || c->subkey) {
559 ✗ uint8_t *data, *cipher = c->cipher;
560
561 ✗ if ((ret = av_packet_make_writable(avpkt)) < 0)
562 ✗ return ret;
563 ✗ data = avpkt->data;
564 ✗ for (int n = 0; n < avpkt->size; n++)
565 ✗ data[n] = cipher[data[n]];
566 }
567
568 ✗ if (avctx->err_recognition & AV_EF_CRCCHECK) {
569 ✗ if (av_crc(c->crc_table, 0, avpkt->data + offset, avpkt->size - offset))
570 ✗ return AVERROR_INVALIDDATA;
571 }
572
573 ✗ if ((ret = init_get_bits8(gb, avpkt->data + offset, avpkt->size - offset)) < 0)
574 ✗ return ret;
575
576 ✗ if (get_bits(gb, 16) != 0xFFFF)
577 ✗ return AVERROR_INVALIDDATA;
578
579 ✗ frame->nb_samples = 1024;
580 ✗ if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
581 ✗ return ret;
582 ✗ samples = (float **)frame->extended_data;
583
584 ✗ packed_noise_level = (get_bits(gb, 9) << 8) - get_bits(gb, 7);
585
586 ✗ for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
587 ✗ unpack(c, &c->ch[ch], gb, c->hfr_group_count, packed_noise_level, c->ath);
588
589 ✗ for (int i = 0; i < 8; i++) {
590 ✗ for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
591 ✗ dequantize_coefficients(c, &c->ch[ch], gb);
592 ✗ for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
593 ✗ reconstruct_hfr(c, &c->ch[ch], c->hfr_group_count, c->bands_per_hfr_group,
594 ✗ c->stereo_band_count + c->base_band_count, c->total_band_count);
595 ✗ for (ch = 0; ch < avctx->ch_layout.nb_channels - 1; ch++)
596 ✗ apply_intensity_stereo(c, &c->ch[ch], &c->ch[ch+1], i,
597 ✗ c->total_band_count - c->base_band_count,
598 ✗ c->base_band_count, c->stereo_band_count);
599 ✗ for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
600 ✗ run_imdct(c, &c->ch[ch], i, samples[ch] + i * 128);
601 }
602
603 ✗ *got_frame_ptr = 1;
604
605 ✗ return avpkt->size;
606 }
607
608 ✗ static av_cold int decode_close(AVCodecContext *avctx)
609 {
610 ✗ HCAContext *c = avctx->priv_data;
611
612 ✗ av_freep(&c->fdsp);
613 ✗ av_tx_uninit(&c->tx_ctx);
614
615 ✗ return 0;
616 }
617
618 ✗ static av_cold void decode_flush(AVCodecContext *avctx)
619 {
620 ✗ HCAContext *c = avctx->priv_data;
621
622 ✗ for (int ch = 0; ch < MAX_CHANNELS; ch++)
623 ✗ memset(c->ch[ch].imdct_prev, 0, sizeof(c->ch[ch].imdct_prev));
624 ✗ }
625
626 const FFCodec ff_hca_decoder = {
627 .p.name = "hca",
628 CODEC_LONG_NAME("CRI HCA"),
629 .p.type = AVMEDIA_TYPE_AUDIO,
630 .p.id = AV_CODEC_ID_HCA,
631 .priv_data_size = sizeof(HCAContext),
632 .init = decode_init,
633 FF_CODEC_DECODE_CB(decode_frame),
634 .flush = decode_flush,
635 .close = decode_close,
636 .p.capabilities = AV_CODEC_CAP_DR1,
637 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
638 };
639