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_internal.h" |
22 |
|
|
#include "libavutil/tx.h" |
23 |
|
|
|
24 |
|
|
#include "avcodec.h" |
25 |
|
|
#include "bytestream.h" |
26 |
|
|
#include "codec_internal.h" |
27 |
|
|
#include "decode.h" |
28 |
|
|
#include "get_bits.h" |
29 |
|
|
#include "hca_data.h" |
30 |
|
|
|
31 |
|
|
typedef struct ChannelContext { |
32 |
|
|
float base[128]; |
33 |
|
|
DECLARE_ALIGNED(32, float, imdct_in)[128]; |
34 |
|
|
DECLARE_ALIGNED(32, float, imdct_out)[128]; |
35 |
|
|
DECLARE_ALIGNED(32, float, imdct_prev)[128]; |
36 |
|
|
int8_t scale_factors[128]; |
37 |
|
|
uint8_t scale[128]; |
38 |
|
|
int8_t intensity[8]; |
39 |
|
|
int8_t *hfr_scale; |
40 |
|
|
unsigned count; |
41 |
|
|
int chan_type; |
42 |
|
|
} ChannelContext; |
43 |
|
|
|
44 |
|
|
typedef struct HCAContext { |
45 |
|
|
const AVCRC *crc_table; |
46 |
|
|
|
47 |
|
|
ChannelContext ch[16]; |
48 |
|
|
|
49 |
|
|
uint8_t ath[128]; |
50 |
|
|
|
51 |
|
|
int ath_type; |
52 |
|
|
unsigned hfr_group_count; |
53 |
|
|
uint8_t track_count; |
54 |
|
|
uint8_t channel_config; |
55 |
|
|
uint8_t total_band_count; |
56 |
|
|
uint8_t base_band_count; |
57 |
|
|
uint8_t stereo_band_count; |
58 |
|
|
uint8_t bands_per_hfr_group; |
59 |
|
|
|
60 |
|
|
av_tx_fn tx_fn; |
61 |
|
|
AVTXContext *tx_ctx; |
62 |
|
|
AVFloatDSPContext *fdsp; |
63 |
|
|
} HCAContext; |
64 |
|
|
|
65 |
|
✗ |
static void ath_init1(uint8_t *ath, int sample_rate) |
66 |
|
|
{ |
67 |
|
|
unsigned int index; |
68 |
|
✗ |
unsigned int acc = 0; |
69 |
|
|
|
70 |
|
✗ |
for (int i = 0; i < 128; i++) { |
71 |
|
✗ |
acc += sample_rate; |
72 |
|
✗ |
index = acc >> 13; |
73 |
|
|
|
74 |
|
✗ |
if (index >= 654) { |
75 |
|
✗ |
memset(ath+i, 0xFF, (128 - i)); |
76 |
|
✗ |
break; |
77 |
|
|
} |
78 |
|
|
|
79 |
|
✗ |
ath[i] = ath_base_curve[index]; |
80 |
|
|
} |
81 |
|
|
} |
82 |
|
|
|
83 |
|
✗ |
static int ath_init(uint8_t *ath, int type, int sample_rate) |
84 |
|
|
{ |
85 |
|
✗ |
switch (type) { |
86 |
|
✗ |
case 0: |
87 |
|
|
/* nothing to do */ |
88 |
|
✗ |
break; |
89 |
|
✗ |
case 1: |
90 |
|
✗ |
ath_init1(ath, sample_rate); |
91 |
|
✗ |
break; |
92 |
|
✗ |
default: |
93 |
|
✗ |
return AVERROR_INVALIDDATA; |
94 |
|
|
} |
95 |
|
|
|
96 |
|
✗ |
return 0; |
97 |
|
|
} |
98 |
|
|
|
99 |
|
✗ |
static inline unsigned ceil2(unsigned a, unsigned b) |
100 |
|
|
{ |
101 |
|
✗ |
return (b > 0) ? (a / b + ((a % b) ? 1 : 0)) : 0; |
102 |
|
|
} |
103 |
|
|
|
104 |
|
✗ |
static av_cold int decode_init(AVCodecContext *avctx) |
105 |
|
|
{ |
106 |
|
✗ |
HCAContext *c = avctx->priv_data; |
107 |
|
✗ |
GetByteContext gb0, *const gb = &gb0; |
108 |
|
✗ |
int8_t r[16] = { 0 }; |
109 |
|
✗ |
float scale = 1.f / 8.f; |
110 |
|
|
unsigned b, chunk; |
111 |
|
|
int version, ret; |
112 |
|
|
|
113 |
|
✗ |
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; |
114 |
|
✗ |
c->crc_table = av_crc_get_table(AV_CRC_16_ANSI); |
115 |
|
|
|
116 |
|
✗ |
if (avctx->ch_layout.nb_channels <= 0 || avctx->ch_layout.nb_channels > 16) |
117 |
|
✗ |
return AVERROR(EINVAL); |
118 |
|
|
|
119 |
|
✗ |
if (avctx->extradata_size < 36) |
120 |
|
✗ |
return AVERROR_INVALIDDATA; |
121 |
|
✗ |
bytestream2_init(gb, avctx->extradata, avctx->extradata_size); |
122 |
|
|
|
123 |
|
✗ |
bytestream2_skipu(gb, 4); |
124 |
|
✗ |
version = bytestream2_get_be16(gb); |
125 |
|
✗ |
bytestream2_skipu(gb, 2); |
126 |
|
|
|
127 |
|
✗ |
c->ath_type = version >= 0x200 ? 0 : 1; |
128 |
|
|
|
129 |
|
✗ |
if (bytestream2_get_be32u(gb) != MKBETAG('f', 'm', 't', 0)) |
130 |
|
✗ |
return AVERROR_INVALIDDATA; |
131 |
|
✗ |
bytestream2_skipu(gb, 4); |
132 |
|
✗ |
bytestream2_skipu(gb, 4); |
133 |
|
✗ |
bytestream2_skipu(gb, 4); |
134 |
|
|
|
135 |
|
✗ |
chunk = bytestream2_get_be32u(gb); |
136 |
|
✗ |
if (chunk == MKBETAG('c', 'o', 'm', 'p')) { |
137 |
|
✗ |
bytestream2_skipu(gb, 2); |
138 |
|
✗ |
bytestream2_skipu(gb, 1); |
139 |
|
✗ |
bytestream2_skipu(gb, 1); |
140 |
|
✗ |
c->track_count = bytestream2_get_byteu(gb); |
141 |
|
✗ |
c->channel_config = bytestream2_get_byteu(gb); |
142 |
|
✗ |
c->total_band_count = bytestream2_get_byteu(gb); |
143 |
|
✗ |
c->base_band_count = bytestream2_get_byteu(gb); |
144 |
|
✗ |
c->stereo_band_count = bytestream2_get_byte (gb); |
145 |
|
✗ |
c->bands_per_hfr_group = bytestream2_get_byte (gb); |
146 |
|
✗ |
} else if (chunk == MKBETAG('d', 'e', 'c', 0)) { |
147 |
|
✗ |
bytestream2_skipu(gb, 2); |
148 |
|
✗ |
bytestream2_skipu(gb, 1); |
149 |
|
✗ |
bytestream2_skipu(gb, 1); |
150 |
|
✗ |
c->total_band_count = bytestream2_get_byteu(gb) + 1; |
151 |
|
✗ |
c->base_band_count = bytestream2_get_byteu(gb) + 1; |
152 |
|
✗ |
c->track_count = bytestream2_peek_byteu(gb) >> 4; |
153 |
|
✗ |
c->channel_config = bytestream2_get_byteu(gb) & 0xF; |
154 |
|
✗ |
if (!bytestream2_get_byteu(gb)) |
155 |
|
✗ |
c->base_band_count = c->total_band_count; |
156 |
|
✗ |
c->stereo_band_count = c->total_band_count - c->base_band_count; |
157 |
|
✗ |
c->bands_per_hfr_group = 0; |
158 |
|
|
} else |
159 |
|
✗ |
return AVERROR_INVALIDDATA; |
160 |
|
|
|
161 |
|
✗ |
if (c->total_band_count > FF_ARRAY_ELEMS(c->ch->imdct_in)) |
162 |
|
✗ |
return AVERROR_INVALIDDATA; |
163 |
|
|
|
164 |
|
|
|
165 |
|
✗ |
while (bytestream2_get_bytes_left(gb) >= 4) { |
166 |
|
✗ |
chunk = bytestream2_get_be32u(gb); |
167 |
|
✗ |
if (chunk == MKBETAG('v', 'b', 'r', 0)) { |
168 |
|
✗ |
bytestream2_skip(gb, 2 + 2); |
169 |
|
✗ |
} else if (chunk == MKBETAG('a', 't', 'h', 0)) { |
170 |
|
✗ |
c->ath_type = bytestream2_get_be16(gb); |
171 |
|
✗ |
} else if (chunk == MKBETAG('r', 'v', 'a', 0)) { |
172 |
|
✗ |
bytestream2_skip(gb, 4); |
173 |
|
✗ |
} else if (chunk == MKBETAG('c', 'o', 'm', 'm')) { |
174 |
|
✗ |
bytestream2_skip(gb, bytestream2_get_byte(gb) * 8); |
175 |
|
✗ |
} else if (chunk == MKBETAG('c', 'i', 'p', 'h')) { |
176 |
|
✗ |
bytestream2_skip(gb, 2); |
177 |
|
✗ |
} else if (chunk == MKBETAG('l', 'o', 'o', 'p')) { |
178 |
|
✗ |
bytestream2_skip(gb, 4 + 4 + 2 + 2); |
179 |
|
✗ |
} else if (chunk == MKBETAG('p', 'a', 'd', 0)) { |
180 |
|
✗ |
break; |
181 |
|
|
} else { |
182 |
|
✗ |
break; |
183 |
|
|
} |
184 |
|
|
} |
185 |
|
|
|
186 |
|
✗ |
ret = ath_init(c->ath, c->ath_type, avctx->sample_rate); |
187 |
|
✗ |
if (ret < 0) |
188 |
|
✗ |
return ret; |
189 |
|
|
|
190 |
|
✗ |
if (!c->track_count) |
191 |
|
✗ |
c->track_count = 1; |
192 |
|
|
|
193 |
|
✗ |
b = avctx->ch_layout.nb_channels / c->track_count; |
194 |
|
✗ |
if (c->stereo_band_count && b > 1) { |
195 |
|
✗ |
int8_t *x = r; |
196 |
|
|
|
197 |
|
✗ |
for (int i = 0; i < c->track_count; i++, x+=b) { |
198 |
|
✗ |
switch (b) { |
199 |
|
✗ |
case 2: |
200 |
|
|
case 3: |
201 |
|
✗ |
x[0] = 1; |
202 |
|
✗ |
x[1] = 2; |
203 |
|
✗ |
break; |
204 |
|
✗ |
case 4: |
205 |
|
✗ |
x[0]=1; x[1] = 2; |
206 |
|
✗ |
if (c->channel_config == 0) { |
207 |
|
✗ |
x[2]=1; |
208 |
|
✗ |
x[3]=2; |
209 |
|
|
} |
210 |
|
✗ |
break; |
211 |
|
✗ |
case 5: |
212 |
|
✗ |
x[0]=1; x[1] = 2; |
213 |
|
✗ |
if (c->channel_config <= 2) { |
214 |
|
✗ |
x[3]=1; |
215 |
|
✗ |
x[4]=2; |
216 |
|
|
} |
217 |
|
✗ |
break; |
218 |
|
✗ |
case 6: |
219 |
|
|
case 7: |
220 |
|
✗ |
x[0] = 1; x[1] = 2; x[4] = 1; x[5] = 2; |
221 |
|
✗ |
break; |
222 |
|
✗ |
case 8: |
223 |
|
✗ |
x[0] = 1; x[1] = 2; x[4] = 1; x[5] = 2; x[6] = 1; x[7] = 2; |
224 |
|
✗ |
break; |
225 |
|
|
} |
226 |
|
|
} |
227 |
|
|
} |
228 |
|
|
|
229 |
|
✗ |
if (c->total_band_count < c->base_band_count) |
230 |
|
✗ |
return AVERROR_INVALIDDATA; |
231 |
|
|
|
232 |
|
✗ |
c->hfr_group_count = ceil2(c->total_band_count - (c->base_band_count + c->stereo_band_count), |
233 |
|
✗ |
c->bands_per_hfr_group); |
234 |
|
|
|
235 |
|
✗ |
if (c->base_band_count + c->stereo_band_count + (unsigned long)c->hfr_group_count > 128ULL) |
236 |
|
✗ |
return AVERROR_INVALIDDATA; |
237 |
|
|
|
238 |
|
✗ |
for (int i = 0; i < avctx->ch_layout.nb_channels; i++) { |
239 |
|
✗ |
c->ch[i].chan_type = r[i]; |
240 |
|
✗ |
c->ch[i].count = c->base_band_count + ((r[i] != 2) ? c->stereo_band_count : 0); |
241 |
|
✗ |
c->ch[i].hfr_scale = &c->ch[i].scale_factors[c->base_band_count + c->stereo_band_count]; |
242 |
|
✗ |
if (c->ch[i].count > 128) |
243 |
|
✗ |
return AVERROR_INVALIDDATA; |
244 |
|
|
} |
245 |
|
|
|
246 |
|
✗ |
c->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT); |
247 |
|
✗ |
if (!c->fdsp) |
248 |
|
✗ |
return AVERROR(ENOMEM); |
249 |
|
|
|
250 |
|
✗ |
return av_tx_init(&c->tx_ctx, &c->tx_fn, AV_TX_FLOAT_MDCT, 1, 128, &scale, 0); |
251 |
|
|
} |
252 |
|
|
|
253 |
|
✗ |
static void run_imdct(HCAContext *c, ChannelContext *ch, int index, float *out) |
254 |
|
|
{ |
255 |
|
✗ |
c->tx_fn(c->tx_ctx, ch->imdct_out, ch->imdct_in, sizeof(float)); |
256 |
|
|
|
257 |
|
✗ |
c->fdsp->vector_fmul_window(out, ch->imdct_prev + (128 >> 1), |
258 |
|
✗ |
ch->imdct_out, window, 128 >> 1); |
259 |
|
|
|
260 |
|
✗ |
memcpy(ch->imdct_prev, ch->imdct_out, 128 * sizeof(float)); |
261 |
|
|
} |
262 |
|
|
|
263 |
|
✗ |
static void apply_intensity_stereo(HCAContext *s, ChannelContext *ch1, ChannelContext *ch2, |
264 |
|
|
int index, unsigned band_count, unsigned base_band_count, |
265 |
|
|
unsigned stereo_band_count) |
266 |
|
|
{ |
267 |
|
✗ |
float ratio_l = intensity_ratio_table[ch2->intensity[index]]; |
268 |
|
✗ |
float ratio_r = ratio_l - 2.0f; |
269 |
|
✗ |
float *c1 = &ch1->imdct_in[base_band_count]; |
270 |
|
✗ |
float *c2 = &ch2->imdct_in[base_band_count]; |
271 |
|
|
|
272 |
|
✗ |
if (ch1->chan_type != 1 || !stereo_band_count) |
273 |
|
✗ |
return; |
274 |
|
|
|
275 |
|
✗ |
for (int i = 0; i < band_count; i++) { |
276 |
|
✗ |
*(c2++) = *c1 * ratio_r; |
277 |
|
✗ |
*(c1++) *= ratio_l; |
278 |
|
|
} |
279 |
|
|
} |
280 |
|
|
|
281 |
|
✗ |
static void reconstruct_hfr(HCAContext *s, ChannelContext *ch, |
282 |
|
|
unsigned hfr_group_count, |
283 |
|
|
unsigned bands_per_hfr_group, |
284 |
|
|
unsigned start_band, unsigned total_band_count) |
285 |
|
|
{ |
286 |
|
✗ |
if (ch->chan_type == 2 || !bands_per_hfr_group) |
287 |
|
✗ |
return; |
288 |
|
|
|
289 |
|
✗ |
for (int i = 0, k = start_band, l = start_band - 1; i < hfr_group_count; i++){ |
290 |
|
✗ |
for (int j = 0; j < bands_per_hfr_group && k < total_band_count && l >= 0; j++, k++, l--){ |
291 |
|
✗ |
ch->imdct_in[k] = scale_conversion_table[ scale_conv_bias + |
292 |
|
✗ |
av_clip_intp2(ch->hfr_scale[i] - ch->scale_factors[l], 6) ] * ch->imdct_in[l]; |
293 |
|
|
} |
294 |
|
|
} |
295 |
|
|
|
296 |
|
✗ |
ch->imdct_in[127] = 0; |
297 |
|
|
} |
298 |
|
|
|
299 |
|
✗ |
static void dequantize_coefficients(HCAContext *c, ChannelContext *ch, |
300 |
|
|
GetBitContext *gb) |
301 |
|
|
{ |
302 |
|
✗ |
for (int i = 0; i < ch->count; i++) { |
303 |
|
✗ |
unsigned scale = ch->scale[i]; |
304 |
|
✗ |
int nb_bits = max_bits_table[scale]; |
305 |
|
✗ |
int value = get_bitsz(gb, nb_bits); |
306 |
|
|
float factor; |
307 |
|
|
|
308 |
|
✗ |
if (scale > 7) { |
309 |
|
✗ |
value = (1 - ((value & 1) << 1)) * (value >> 1); |
310 |
|
✗ |
if (!value) |
311 |
|
✗ |
skip_bits_long(gb, -1); |
312 |
|
✗ |
factor = value; |
313 |
|
|
} else { |
314 |
|
✗ |
value += scale << 4; |
315 |
|
✗ |
skip_bits_long(gb, quant_spectrum_bits[value] - nb_bits); |
316 |
|
✗ |
factor = quant_spectrum_value[value]; |
317 |
|
|
} |
318 |
|
✗ |
ch->imdct_in[i] = factor * ch->base[i]; |
319 |
|
|
} |
320 |
|
|
|
321 |
|
✗ |
memset(ch->imdct_in + ch->count, 0, sizeof(ch->imdct_in) - ch->count * sizeof(ch->imdct_in[0])); |
322 |
|
|
} |
323 |
|
|
|
324 |
|
✗ |
static void unpack(HCAContext *c, ChannelContext *ch, |
325 |
|
|
GetBitContext *gb, |
326 |
|
|
unsigned hfr_group_count, |
327 |
|
|
int packed_noise_level, |
328 |
|
|
const uint8_t *ath) |
329 |
|
|
{ |
330 |
|
✗ |
int delta_bits = get_bits(gb, 3); |
331 |
|
|
|
332 |
|
✗ |
if (delta_bits > 5) { |
333 |
|
✗ |
for (int i = 0; i < ch->count; i++) |
334 |
|
✗ |
ch->scale_factors[i] = get_bits(gb, 6); |
335 |
|
✗ |
} else if (delta_bits) { |
336 |
|
✗ |
int factor = get_bits(gb, 6); |
337 |
|
✗ |
int max_value = (1 << delta_bits) - 1; |
338 |
|
✗ |
int half_max = max_value >> 1; |
339 |
|
|
|
340 |
|
✗ |
ch->scale_factors[0] = factor; |
341 |
|
✗ |
for (int i = 1; i < ch->count; i++){ |
342 |
|
✗ |
int delta = get_bits(gb, delta_bits); |
343 |
|
|
|
344 |
|
✗ |
if (delta == max_value) { |
345 |
|
✗ |
factor = get_bits(gb, 6); |
346 |
|
|
} else { |
347 |
|
✗ |
factor += delta - half_max; |
348 |
|
|
} |
349 |
|
✗ |
factor = av_clip_uintp2(factor, 6); |
350 |
|
|
|
351 |
|
✗ |
ch->scale_factors[i] = factor; |
352 |
|
|
} |
353 |
|
|
} else { |
354 |
|
✗ |
memset(ch->scale_factors, 0, 128); |
355 |
|
|
} |
356 |
|
|
|
357 |
|
✗ |
if (ch->chan_type == 2){ |
358 |
|
✗ |
ch->intensity[0] = get_bits(gb, 4); |
359 |
|
✗ |
if (ch->intensity[0] < 15) { |
360 |
|
✗ |
for (int i = 1; i < 8; i++) |
361 |
|
✗ |
ch->intensity[i] = get_bits(gb, 4); |
362 |
|
|
} |
363 |
|
|
} else { |
364 |
|
✗ |
for (int i = 0; i < hfr_group_count; i++) |
365 |
|
✗ |
ch->hfr_scale[i] = get_bits(gb, 6); |
366 |
|
|
} |
367 |
|
|
|
368 |
|
✗ |
for (int i = 0; i < ch->count; i++) { |
369 |
|
✗ |
int scale = ch->scale_factors[i]; |
370 |
|
|
|
371 |
|
✗ |
if (scale) { |
372 |
|
✗ |
scale = c->ath[i] + ((packed_noise_level + i) >> 8) - ((scale * 5) >> 1) + 2; |
373 |
|
✗ |
scale = scale_table[av_clip(scale, 0, 58)]; |
374 |
|
|
} |
375 |
|
✗ |
ch->scale[i] = scale; |
376 |
|
|
} |
377 |
|
|
|
378 |
|
✗ |
memset(ch->scale + ch->count, 0, sizeof(ch->scale) - ch->count); |
379 |
|
|
|
380 |
|
✗ |
for (int i = 0; i < ch->count; i++) |
381 |
|
✗ |
ch->base[i] = dequantizer_scaling_table[ch->scale_factors[i]] * quant_step_size[ch->scale[i]]; |
382 |
|
|
} |
383 |
|
|
|
384 |
|
✗ |
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, |
385 |
|
|
int *got_frame_ptr, AVPacket *avpkt) |
386 |
|
|
{ |
387 |
|
✗ |
HCAContext *c = avctx->priv_data; |
388 |
|
|
int ch, ret, packed_noise_level; |
389 |
|
✗ |
GetBitContext gb0, *const gb = &gb0; |
390 |
|
|
float **samples; |
391 |
|
|
|
392 |
|
✗ |
if (avctx->err_recognition & AV_EF_CRCCHECK) { |
393 |
|
✗ |
if (av_crc(c->crc_table, 0, avpkt->data, avpkt->size)) |
394 |
|
✗ |
return AVERROR_INVALIDDATA; |
395 |
|
|
} |
396 |
|
|
|
397 |
|
✗ |
if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0) |
398 |
|
✗ |
return ret; |
399 |
|
|
|
400 |
|
✗ |
if (get_bits(gb, 16) != 0xFFFF) |
401 |
|
✗ |
return AVERROR_INVALIDDATA; |
402 |
|
|
|
403 |
|
✗ |
frame->nb_samples = 1024; |
404 |
|
✗ |
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
405 |
|
✗ |
return ret; |
406 |
|
✗ |
samples = (float **)frame->extended_data; |
407 |
|
|
|
408 |
|
✗ |
packed_noise_level = (get_bits(gb, 9) << 8) - get_bits(gb, 7); |
409 |
|
|
|
410 |
|
✗ |
for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) |
411 |
|
✗ |
unpack(c, &c->ch[ch], gb, c->hfr_group_count, packed_noise_level, c->ath); |
412 |
|
|
|
413 |
|
✗ |
for (int i = 0; i < 8; i++) { |
414 |
|
✗ |
for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) |
415 |
|
✗ |
dequantize_coefficients(c, &c->ch[ch], gb); |
416 |
|
✗ |
for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) |
417 |
|
✗ |
reconstruct_hfr(c, &c->ch[ch], c->hfr_group_count, c->bands_per_hfr_group, |
418 |
|
✗ |
c->stereo_band_count + c->base_band_count, c->total_band_count); |
419 |
|
✗ |
for (ch = 0; ch < avctx->ch_layout.nb_channels - 1; ch++) |
420 |
|
✗ |
apply_intensity_stereo(c, &c->ch[ch], &c->ch[ch+1], i, |
421 |
|
✗ |
c->total_band_count - c->base_band_count, |
422 |
|
✗ |
c->base_band_count, c->stereo_band_count); |
423 |
|
✗ |
for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) |
424 |
|
✗ |
run_imdct(c, &c->ch[ch], i, samples[ch] + i * 128); |
425 |
|
|
} |
426 |
|
|
|
427 |
|
✗ |
*got_frame_ptr = 1; |
428 |
|
|
|
429 |
|
✗ |
return avpkt->size; |
430 |
|
|
} |
431 |
|
|
|
432 |
|
✗ |
static av_cold int decode_close(AVCodecContext *avctx) |
433 |
|
|
{ |
434 |
|
✗ |
HCAContext *c = avctx->priv_data; |
435 |
|
|
|
436 |
|
✗ |
av_freep(&c->fdsp); |
437 |
|
✗ |
av_tx_uninit(&c->tx_ctx); |
438 |
|
|
|
439 |
|
✗ |
return 0; |
440 |
|
|
} |
441 |
|
|
|
442 |
|
|
const FFCodec ff_hca_decoder = { |
443 |
|
|
.p.name = "hca", |
444 |
|
|
CODEC_LONG_NAME("CRI HCA"), |
445 |
|
|
.p.type = AVMEDIA_TYPE_AUDIO, |
446 |
|
|
.p.id = AV_CODEC_ID_HCA, |
447 |
|
|
.priv_data_size = sizeof(HCAContext), |
448 |
|
|
.init = decode_init, |
449 |
|
|
FF_CODEC_DECODE_CB(decode_frame), |
450 |
|
|
.close = decode_close, |
451 |
|
|
.p.capabilities = AV_CODEC_CAP_DR1, |
452 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP, |
453 |
|
|
.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, |
454 |
|
|
AV_SAMPLE_FMT_NONE }, |
455 |
|
|
}; |
456 |
|
|
|