FFmpeg coverage

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