FFmpeg: libavcodec/hcadec.c Source File

FFmpeg

[フレーム]

libavcodec

hcadec.c

Go to the documentation of this file.

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 */

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"

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"

32 #define HCA_MASK 0x7f7f7f7f

33 #define MAX_CHANNELS 16

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;

49 typedef struct HCAContext {

50 const AVCRC *crc_table;

52 ChannelContext ch[MAX_CHANNELS];

54 uint8_t ath[128];

55 uint8_t cipher[256];

56 uint64_t key;

57 uint16_t subkey;

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;

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;

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;

80 key >>= 4;

81 for (int i = 0; i < 16; i++) {

82 key = (key * mul + add) & 0xF;

83 r[i] = key;

84 }

85 }

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];

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--;

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 } else if (chunk == MKBETAG('d', 'e', 'c', 0)) {

249 bytestream2_skipu(gb, 2);

250 bytestream2_skipu(gb, 1);

251 bytestream2_skipu(gb, 1);

252 c->total_band_count = bytestream2_get_byteu(gb) + 1;

253 c->base_band_count = bytestream2_get_byteu(gb) + 1;

254 c->track_count = bytestream2_peek_byteu(gb) >> 4;

255 c->channel_config = bytestream2_get_byteu(gb) & 0xF;

256 if (!bytestream2_get_byteu(gb))

257 c->base_band_count = c->total_band_count;

258 c->stereo_band_count = c->total_band_count - c->base_band_count;

259 c->bands_per_hfr_group = 0;

260 } else

261 return AVERROR_INVALIDDATA;

262

263 if (c->total_band_count > FF_ARRAY_ELEMS(c->ch->imdct_in))

264 return AVERROR_INVALIDDATA;

265

266 while (bytestream2_get_bytes_left(gb) >= 4) {

267 chunk = bytestream2_get_be32u(gb) & HCA_MASK;

268 if (chunk == MKBETAG('v', 'b', 'r', 0)) {

269 bytestream2_skip(gb, 2 + 2);

270 } else if (chunk == MKBETAG('a', 't', 'h', 0)) {

271 c->ath_type = bytestream2_get_be16(gb);

272 } else if (chunk == MKBETAG('r', 'v', 'a', 0)) {

273 bytestream2_skip(gb, 4);

274 } else if (chunk == MKBETAG('c', 'o', 'm', 'm')) {

275 bytestream2_skip(gb, bytestream2_get_byte(gb) * 8);

276 } else if (chunk == MKBETAG('c', 'i', 'p', 'h')) {

277 c->ciph_type = bytestream2_get_be16(gb);

278 } else if (chunk == MKBETAG('l', 'o', 'o', 'p')) {

279 bytestream2_skip(gb, 4 + 4 + 2 + 2);

280 } else if (chunk == MKBETAG('p', 'a', 'd', 0)) {

281 break;

282 } else {

283 break;

284 }

285 }

286

287 if (bytestream2_get_bytes_left(gb) >= 10) {

288 bytestream2_skip(gb, bytestream2_get_bytes_left(gb) - 10);

289 c->key = bytestream2_get_be64u(gb);

290 c->subkey = bytestream2_get_be16u(gb);

291 }

292

293 cipher_init(c->cipher, c->ciph_type, c->key, c->subkey);

294

295 ret = ath_init(c->ath, c->ath_type, avctx->sample_rate);

296 if (ret < 0)

297 return ret;

298

299 if (!c->track_count)

300 c->track_count = 1;

301

302 b = avctx->ch_layout.nb_channels / c->track_count;

303 if (c->stereo_band_count && b > 1) {

304 int8_t *x = r;

305

306 for (int i = 0; i < c->track_count; i++, x+=b) {

307 switch (b) {

308 case 2:

309 case 3:

310 x[0] = 1;

311 x[1] = 2;

312 break;

313 case 4:

314 x[0]=1; x[1] = 2;

315 if (c->channel_config == 0) {

316 x[2]=1;

317 x[3]=2;

318 }

319 break;

320 case 5:

321 x[0]=1; x[1] = 2;

322 if (c->channel_config <= 2) {

323 x[3]=1;

324 x[4]=2;

325 }

326 break;

327 case 6:

328 case 7:

329 x[0] = 1; x[1] = 2; x[4] = 1; x[5] = 2;

330 break;

331 case 8:

332 x[0] = 1; x[1] = 2; x[4] = 1; x[5] = 2; x[6] = 1; x[7] = 2;

333 break;

334 }

335 }

336 }

337

338 if (c->total_band_count < c->base_band_count)

339 return AVERROR_INVALIDDATA;

340

341 hfr_group_count = ceil2(c->total_band_count - (c->base_band_count + c->stereo_band_count),

342 c->bands_per_hfr_group);

343

344 if (c->base_band_count + c->stereo_band_count + (uint64_t)hfr_group_count > 128ULL)

345 return AVERROR_INVALIDDATA;

346 c->hfr_group_count = hfr_group_count;

347

348 for (int i = 0; i < avctx->ch_layout.nb_channels; i++) {

349 c->ch[i].chan_type = r[i];

350 c->ch[i].count = c->base_band_count + ((r[i] != 2) ? c->stereo_band_count : 0);

351 c->ch[i].hfr_scale = &c->ch[i].scale_factors[c->base_band_count + c->stereo_band_count];

352 if (c->ch[i].count > 128)

353 return AVERROR_INVALIDDATA;

354 }

355

356 // Done last to signal init() finished

357 c->crc_table = av_crc_get_table(AV_CRC_16_ANSI);

358

359 return 0;

360 }

361

362 static av_cold int decode_init(AVCodecContext *avctx)

363 {

364 HCAContext *c = avctx->priv_data;

365 float scale = 1.f / 8.f;

366 int ret;

367

368 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

369

370 if (avctx->ch_layout.nb_channels <= 0 || avctx->ch_layout.nb_channels > FF_ARRAY_ELEMS(c->ch))

371 return AVERROR(EINVAL);

372

373 c->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);

374 if (!c->fdsp)

375 return AVERROR(ENOMEM);

376

377 ret = av_tx_init(&c->tx_ctx, &c->tx_fn, AV_TX_FLOAT_MDCT, 1, 128, &scale, 0);

378 if (ret < 0)

379 return ret;

380

381 if (avctx->extradata_size != 0 && avctx->extradata_size < 36)

382 return AVERROR_INVALIDDATA;

383

384 if (!avctx->extradata_size)

385 return 0;

386

387 return init_hca(avctx, avctx->extradata, avctx->extradata_size);

388 }

389

390 static void run_imdct(HCAContext *c, ChannelContext *ch, int index, float *out)

391 {

392 c->tx_fn(c->tx_ctx, ch->imdct_out, ch->imdct_in, sizeof(float));

393

394 c->fdsp->vector_fmul_window(out, ch->imdct_prev + (128 >> 1),

395 ch->imdct_out, window, 128 >> 1);

396

397 memcpy(ch->imdct_prev, ch->imdct_out, 128 * sizeof(float));

398 }

399

400 static void apply_intensity_stereo(HCAContext *s, ChannelContext *ch1, ChannelContext *ch2,

401 int index, unsigned band_count, unsigned base_band_count,

402 unsigned stereo_band_count)

403 {

404 float ratio_l = intensity_ratio_table[ch2->intensity[index]];

405 float ratio_r = ratio_l - 2.0f;

406 float *c1 = &ch1->imdct_in[base_band_count];

407 float *c2 = &ch2->imdct_in[base_band_count];

408

409 if (ch1->chan_type != 1 || !stereo_band_count)

410 return;

411

412 for (int i = 0; i < band_count; i++) {

413 c2[i] = c1[i] * ratio_r;

414 c1[i] *= ratio_l;

415 }

416 }

417

418 static void reconstruct_hfr(HCAContext *s, ChannelContext *ch,

419 unsigned hfr_group_count,

420 unsigned bands_per_hfr_group,

421 unsigned start_band, unsigned total_band_count)

422 {

423 if (ch->chan_type == 2 || !bands_per_hfr_group)

424 return;

425

426 for (int i = 0, k = start_band, l = start_band - 1; i < hfr_group_count; i++){

427 for (int j = 0; j < bands_per_hfr_group && k < total_band_count && l >= 0; j++, k++, l--){

428 ch->imdct_in[k] = scale_conversion_table[ scale_conv_bias +

429 av_clip_intp2(ch->hfr_scale[i] - ch->scale_factors[l], 6) ] * ch->imdct_in[l];

430 }

431 }

432

433 ch->imdct_in[127] = 0;

434 }

435

436 static void dequantize_coefficients(HCAContext *c, ChannelContext *ch,

437 GetBitContext *gb)

438 {

439 const float *base = ch->base;

440 float *factors = ch->factors;

441 float *out = ch->imdct_in;

442

443 for (int i = 0; i < ch->count; i++) {

444 unsigned scale = ch->scale[i];

445 int nb_bits = max_bits_table[scale];

446 int value = get_bitsz(gb, nb_bits);

447 float factor;

448

449 if (scale > 7) {

450 value = (1 - ((value & 1) << 1)) * (value >> 1);

451 if (!value)

452 skip_bits_long(gb, -1);

453 factor = value;

454 } else {

455 value += scale << 4;

456 skip_bits_long(gb, quant_spectrum_bits[value] - nb_bits);

457 factor = quant_spectrum_value[value];

458 }

459 factors[i] = factor;

460 }

461

462 memset(factors + ch->count, 0, 512 - ch->count * sizeof(*factors));

463 c->fdsp->vector_fmul(out, factors, base, 128);

464 }

465

466 static void unpack(HCAContext *c, ChannelContext *ch,

467 GetBitContext *gb,

468 unsigned hfr_group_count,

469 int packed_noise_level,

470 const uint8_t *ath)

471 {

472 int delta_bits = get_bits(gb, 3);

473

474 if (delta_bits > 5) {

475 for (int i = 0; i < ch->count; i++)

476 ch->scale_factors[i] = get_bits(gb, 6);

477 } else if (delta_bits) {

478 int factor = get_bits(gb, 6);

479 int max_value = (1 << delta_bits) - 1;

480 int half_max = max_value >> 1;

481

482 ch->scale_factors[0] = factor;

483 for (int i = 1; i < ch->count; i++){

484 int delta = get_bits(gb, delta_bits);

485

486 if (delta == max_value) {

487 factor = get_bits(gb, 6);

488 } else {

489 factor += delta - half_max;

490 }

491 factor = av_clip_uintp2(factor, 6);

492

493 ch->scale_factors[i] = factor;

494 }

495 } else {

496 memset(ch->scale_factors, 0, 128);

497 }

498

499 if (ch->chan_type == 2){

500 ch->intensity[0] = get_bits(gb, 4);

501 if (ch->intensity[0] < 15) {

502 for (int i = 1; i < 8; i++)

503 ch->intensity[i] = get_bits(gb, 4);

504 }

505 } else {

506 for (int i = 0; i < hfr_group_count; i++)

507 ch->hfr_scale[i] = get_bits(gb, 6);

508 }

509

510 for (int i = 0; i < ch->count; i++) {

511 int scale = ch->scale_factors[i];

512

513 if (scale) {

514 scale = c->ath[i] + ((packed_noise_level + i) >> 8) - ((scale * 5) >> 1) + 2;

515 scale = scale_table[av_clip(scale, 0, 58)];

516 }

517 ch->scale[i] = scale;

518 }

519

520 memset(ch->scale + ch->count, 0, sizeof(ch->scale) - ch->count);

521

522 for (int i = 0; i < ch->count; i++)

523 ch->base[i] = dequantizer_scaling_table[ch->scale_factors[i]] * quant_step_size[ch->scale[i]];

524 }

525

526 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,

527 int *got_frame_ptr, AVPacket *avpkt)

528 {

529 HCAContext *c = avctx->priv_data;

530 int ch, offset = 0, ret, packed_noise_level;

531 GetBitContext gb0, *const gb = &gb0;

532 float **samples;

533

534 if (avpkt->size <= 8)

535 return AVERROR_INVALIDDATA;

536

537 if (AV_RN16(avpkt->data) != 0xFFFF) {

538 if ((AV_RL32(avpkt->data)) != MKTAG('H','C','A',0)) {

539 return AVERROR_INVALIDDATA;

540 } else if (AV_RB16(avpkt->data + 6) <= avpkt->size) {

541 ret = init_hca(avctx, avpkt->data, AV_RB16(avpkt->data + 6));

542 if (ret < 0) {

543 c->crc_table = NULL; // signal that init has not finished

544 return ret;

545 }

546 offset = AV_RB16(avpkt->data + 6);

547 if (offset == avpkt->size)

548 return avpkt->size;

549 } else {

550 return AVERROR_INVALIDDATA;

551 }

552 }

553

554 if (!c->crc_table)

555 return AVERROR_INVALIDDATA;

556

557 if (c->key || c->subkey) {

558 uint8_t *data, *cipher = c->cipher;

559

560 if ((ret = av_packet_make_writable(avpkt)) < 0)

561 return ret;

562 data = avpkt->data;

563 for (int n = 0; n < avpkt->size; n++)

564 data[n] = cipher[data[n]];

565 }

566

567 if (avctx->err_recognition & AV_EF_CRCCHECK) {

568 if (av_crc(c->crc_table, 0, avpkt->data + offset, avpkt->size - offset))

569 return AVERROR_INVALIDDATA;

570 }

571

572 if ((ret = init_get_bits8(gb, avpkt->data + offset, avpkt->size - offset)) < 0)

573 return ret;

574

575 if (get_bits(gb, 16) != 0xFFFF)

576 return AVERROR_INVALIDDATA;

577

578 frame->nb_samples = 1024;

579 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

580 return ret;

581 samples = (float **)frame->extended_data;

582

583 packed_noise_level = (get_bits(gb, 9) << 8) - get_bits(gb, 7);

584

585 for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)

586 unpack(c, &c->ch[ch], gb, c->hfr_group_count, packed_noise_level, c->ath);

587

588 for (int i = 0; i < 8; i++) {

589 for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)

590 dequantize_coefficients(c, &c->ch[ch], gb);

591 for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)

592 reconstruct_hfr(c, &c->ch[ch], c->hfr_group_count, c->bands_per_hfr_group,

593 c->stereo_band_count + c->base_band_count, c->total_band_count);

594 for (ch = 0; ch < avctx->ch_layout.nb_channels - 1; ch++)

595 apply_intensity_stereo(c, &c->ch[ch], &c->ch[ch+1], i,

596 c->total_band_count - c->base_band_count,

597 c->base_band_count, c->stereo_band_count);

598 for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)

599 run_imdct(c, &c->ch[ch], i, samples[ch] + i * 128);

600 }

601

602 *got_frame_ptr = 1;

603

604 return avpkt->size;

605 }

606

607 static av_cold int decode_close(AVCodecContext *avctx)

608 {

609 HCAContext *c = avctx->priv_data;

610

611 av_freep(&c->fdsp);

612 av_tx_uninit(&c->tx_ctx);

613

614 return 0;

615 }

616

617 static av_cold void decode_flush(AVCodecContext *avctx)

618 {

619 HCAContext *c = avctx->priv_data;

620

621 for (int ch = 0; ch < MAX_CHANNELS; ch++)

622 memset(c->ch[ch].imdct_prev, 0, sizeof(c->ch[ch].imdct_prev));

623 }

624

625 const FFCodec ff_hca_decoder = {

626 .p.name = "hca",

627 CODEC_LONG_NAME("CRI HCA"),

628 .p.type = AVMEDIA_TYPE_AUDIO,

629 .p.id = AV_CODEC_ID_HCA,

630 .priv_data_size = sizeof(HCAContext),

631 .init = decode_init,

632 FF_CODEC_DECODE_CB(decode_frame),

633 .flush = decode_flush,

634 .close = decode_close,

635 .p.capabilities = AV_CODEC_CAP_DR1,

636 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

637 .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,

638 AV_SAMPLE_FMT_NONE },

639 };

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:278

ChannelContext::hfr_scale

int8_t * hfr_scale

Definition: hcadec.c:44

MAX_CHANNELS

#define MAX_CHANNELS

Definition: hcadec.c:33

av_clip

#define av_clip

Definition: common.h:100

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:43

const char * r

Definition: vf_curves.c:127

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

mem_internal.h

out

FILE * out

Definition: movenc.c:55

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1056

GetByteContext

Definition: bytestream.h:33

#define u(width, name, range_min, range_max)

Definition: cbs_h2645.c:251

AVCRC

uint32_t AVCRC

Definition: crc.h:46

av_clip_uintp2

#define av_clip_uintp2

Definition: common.h:124

AVTXContext

Definition: tx_priv.h:235

AVCodecContext::err_recognition

int err_recognition

Error recognition; may misdetect some more or less valid parts as errors.

Definition: avcodec.h:1430

bytestream2_skipu

static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)

Definition: bytestream.h:174

AV_RN16

#define AV_RN16(p)

Definition: intreadwrite.h:356

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:389

AVPacket::data

uint8_t * data

Definition: packet.h:539

#define b

Definition: input.c:41

data

const char data[16]

Definition: mxf.c:148

init_hca

static int init_hca(AVCodecContext *avctx, const uint8_t *extradata, const int extradata_size)

Definition: hcadec.c:208

HCAContext::ch

ChannelContext ch[MAX_CHANNELS]

Definition: hcadec.c:52

FFCodec

Definition: codec_internal.h:127

base

uint8_t base

Definition: vp3data.h:128

ChannelContext::imdct_prev

float imdct_prev[128]

Definition: hcadec.c:40

static const uint64_t c1

Definition: murmur3.c:52

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

apply_intensity_stereo

static void apply_intensity_stereo(HCAContext *s, ChannelContext *ch1, ChannelContext *ch2, int index, unsigned band_count, unsigned base_band_count, unsigned stereo_band_count)

Definition: hcadec.c:400

HCAContext::key

uint64_t key

Definition: hcadec.c:56

av_tx_init

av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)

Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...

Definition: tx.c:903

crc.h

cipher_init56

static void cipher_init56(uint8_t *cipher, uint64_t keycode)

Definition: hcadec.c:87

bytestream2_skip

static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)

Definition: bytestream.h:168

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:335

window

static SDL_Window * window

Definition: ffplay.c:361

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1071

GetBitContext

Definition: get_bits.h:108

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:508

type

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type

Definition: writing_filters.txt:86

HCA_MASK

#define HCA_MASK

Definition: hcadec.c:32

ChannelContext::base

float base[128]

Definition: hcadec.c:36

HCAContext::bands_per_hfr_group

uint8_t bands_per_hfr_group

Definition: hcadec.c:67

HCAContext::hfr_group_count

unsigned hfr_group_count

Definition: hcadec.c:61

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:545

av_tx_fn

void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)

Function pointer to a function to perform the transform.

Definition: tx.h:151

unpack

static void unpack(HCAContext *c, ChannelContext *ch, GetBitContext *gb, unsigned hfr_group_count, int packed_noise_level, const uint8_t *ath)

Definition: hcadec.c:466

ath_init1

static void ath_init1(uint8_t *ath, int sample_rate)

Definition: hcadec.c:162

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

AV_TX_FLOAT_MDCT

@ AV_TX_FLOAT_MDCT

Standard MDCT with a sample data type of float, double or int32_t, respecively.

Definition: tx.h:68

HCAContext::total_band_count

uint8_t total_band_count

Definition: hcadec.c:64

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:311

HCAContext::tx_fn

av_tx_fn tx_fn

Definition: hcadec.c:70

#define s(width, name)

Definition: cbs_vp9.c:198

scale_conversion_table

static const float scale_conversion_table[]

Definition: hca_data.h:91

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

quant_spectrum_bits

static const uint8_t quant_spectrum_bits[]

Definition: hca_data.h:29

decode.h

get_bits.h

decode_frame

static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)

Definition: hcadec.c:526

HCAContext::ath_type

int ath_type

Definition: hcadec.c:59

key

const char * key

Definition: hwcontext_opencl.c:189

ath

static av_cold float ath(float f, float add)

Calculate ATH value for given frequency.

Definition: aacpsy.c:289

quant_spectrum_value

static const int8_t quant_spectrum_value[]

Definition: hca_data.h:41

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

dequantize_coefficients

static void dequantize_coefficients(HCAContext *c, ChannelContext *ch, GetBitContext *gb)

Definition: hcadec.c:436

AV_CRC_16_ANSI

@ AV_CRC_16_ANSI

Definition: crc.h:50

ChannelContext::chan_type

int chan_type

Definition: hcadec.c:46

HCAContext::ath

uint8_t ath[128]

Definition: hcadec.c:54

NULL

#define NULL

Definition: coverity.c:32

av_clip_intp2

#define av_clip_intp2

Definition: common.h:121

decode_init

static av_cold int decode_init(AVCodecContext *avctx)

Definition: hcadec.c:362

ChannelContext::imdct_out

float imdct_out[128]

Definition: hcadec.c:39

quant_step_size

static const float quant_step_size[]

Definition: hca_data.h:125

HCAContext::fdsp

AVFloatDSPContext * fdsp

Definition: hcadec.c:72

AV_EF_CRCCHECK

#define AV_EF_CRCCHECK

Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...

Definition: defs.h:48

seed

static unsigned int seed

Definition: videogen.c:78

index

int index

Definition: gxfenc.c:90

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

bytestream2_get_bytes_left

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:158

float_dsp.h

ath_init

static int ath_init(uint8_t *ath, int type, int sample_rate)

Definition: hcadec.c:180

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1719

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:540

dequantizer_scaling_table

static const float dequantizer_scaling_table[]

Definition: hca_data.h:113

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:109

HCAContext::stereo_band_count

uint8_t stereo_band_count

Definition: hcadec.c:66

scale_table

static const uint8_t scale_table[]

Definition: hca_data.h:53

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1063

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

ff_hca_decoder

const FFCodec ff_hca_decoder

Definition: hcadec.c:625

MKBETAG

#define MKBETAG(a, b, c, d)

Definition: macros.h:56

reconstruct_hfr

static void reconstruct_hfr(HCAContext *s, ChannelContext *ch, unsigned hfr_group_count, unsigned bands_per_hfr_group, unsigned start_band, unsigned total_band_count)

Definition: hcadec.c:418

AVFloatDSPContext

Definition: float_dsp.h:24

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

av_crc_get_table

const AVCRC * av_crc_get_table(AVCRCId crc_id)

Get an initialized standard CRC table.

Definition: crc.c:374

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

version

Definition: libkvazaar.c:321

HCAContext::base_band_count

uint8_t base_band_count

Definition: hcadec.c:65

av_tx_uninit

av_cold void av_tx_uninit(AVTXContext **ctx)

Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.

Definition: tx.c:295

HCAContext::crc_table

const AVCRC * crc_table

Definition: hcadec.c:50

decode_close

static av_cold int decode_close(AVCodecContext *avctx)

Definition: hcadec.c:607

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

ChannelContext::scale

uint8_t scale[128]

Definition: hcadec.c:42

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:529

hca_data.h

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

delta

float delta

Definition: vorbis_enc_data.h:430

value

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value

Definition: writing_filters.txt:86

ChannelContext::factors

float factors[128]

Definition: hcadec.c:37

ath_base_curve

static const uint8_t ath_base_curve[656]

Definition: hca_data.h:131

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

max_bits_table

static const uint8_t max_bits_table[]

Definition: hca_data.h:25

avcodec.h

ChannelContext::count

unsigned count

Definition: hcadec.c:45

HCAContext::track_count

uint8_t track_count

Definition: hcadec.c:62

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

HCAContext::subkey

uint16_t subkey

Definition: hcadec.c:57

ceil2

static unsigned ceil2(unsigned a, unsigned b)

Definition: hcadec.c:196

pos

unsigned int pos

Definition: spdifenc.c:414

HCAContext

Definition: hcadec.c:49

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

ChannelContext::intensity

int8_t intensity[8]

Definition: hcadec.c:43

AVCodecContext

main external API structure.

Definition: avcodec.h:451

static const uint64_t c2

Definition: murmur3.c:53

cipher_init

static void cipher_init(uint8_t *cipher, int type, uint64_t keycode, uint16_t subkey)

Definition: hcadec.c:145

av_crc

uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)

Calculate the CRC of a block.

Definition: crc.c:392

av_packet_make_writable

int av_packet_make_writable(AVPacket *pkt)

Create a writable reference for the data described by a given packet, avoiding data copy if possible.

Definition: packet.c:511

decode_flush

static av_cold void decode_flush(AVCodecContext *avctx)

Definition: hcadec.c:617

samples

Filter the word "frame" indicates either a video frame or a group of audio samples

Definition: filter_design.txt:8

ChannelContext::imdct_in

float imdct_in[128]

Definition: hcadec.c:38

ChannelContext

Definition: hcadec.c:35

ChannelContext::scale_factors

int8_t scale_factors[128]

Definition: hcadec.c:41

factor

static const int factor[16]

Definition: vf_pp7.c:80

cipher_init56_create_table

static void cipher_init56_create_table(uint8_t *r, uint8_t key)

Definition: hcadec.c:75

HCAContext::channel_config

uint8_t channel_config

Definition: hcadec.c:63

mem.h

get_bitsz

static av_always_inline int get_bitsz(GetBitContext *s, int n)

Read 0-25 bits.

Definition: get_bits.h:351

AV_CODEC_FLAG_BITEXACT

#define AV_CODEC_FLAG_BITEXACT

Use only bitexact stuff (except (I)DCT).

Definition: avcodec.h:342

intensity_ratio_table

static const float intensity_ratio_table[]

Definition: hca_data.h:85

HCAContext::tx_ctx

AVTXContext * tx_ctx

Definition: hcadec.c:71

scale

static void scale(int *out, const int *in, const int w, const int h, const int shift)

Definition: intra.c:291

AVPacket

This structure stores compressed data.

Definition: packet.h:516

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:478

HCAContext::cipher

uint8_t cipher[256]

Definition: hcadec.c:55

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

avpriv_float_dsp_alloc

av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)

Allocate a float DSP context.

Definition: float_dsp.c:146

bytestream.h

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:137

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

MKTAG

#define MKTAG(a, b, c, d)

Definition: macros.h:55

init_flush

static av_cold void init_flush(AVCodecContext *avctx)

Definition: hcadec.c:201

scale_conv_bias

static const int scale_conv_bias

Definition: hca_data.h:111

AV_CODEC_ID_HCA

@ AV_CODEC_ID_HCA

Definition: codec_id.h:533

run_imdct

static void run_imdct(HCAContext *c, ChannelContext *ch, int index, float *out)

Definition: hcadec.c:390

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:98

tx.h

HCAContext::ciph_type

int ciph_type

Definition: hcadec.c:60

Generated on Fri Aug 22 2025 13:58:23 for FFmpeg by doxygen 1.8.17