FFmpeg
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  */
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;
48 
49 typedef struct HCAContext {
50  const AVCRC *crc_table;
51 
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;
65  uint8_t base_band_count;
68 
69  // Set during init() and freed on close(). Untouched on init_flush()
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;
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 
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:
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) {
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 
363 {
364  HCAContext *c = avctx->priv_data;
365  float scale = 1.f / 8.f;
366  int ret;
367 
369 
370  if (avctx->ch_layout.nb_channels <= 0 || avctx->ch_layout.nb_channels > FF_ARRAY_ELEMS(c->ch))
371  return AVERROR(EINVAL);
372 
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 
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 
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--){
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 
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);
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  }
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++)
524 }
525 
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 
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 
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 
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,
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,
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:99
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:42
r
const char * r
Definition: vf_curves.c:127
acc
int acc
Definition: yuv2rgb.c:553
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:1050
GetByteContext
Definition: bytestream.h:33
u
#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:123
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:1420
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:358
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:524
b
#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:126
base
uint8_t base
Definition: vp3data.h:128
ChannelContext::imdct_prev
float imdct_prev[128]
Definition: hcadec.c:40
c1
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:313
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
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
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:130
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
GetBitContext
Definition: get_bits.h:108
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
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:524
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:286
HCAContext::tx_fn
av_tx_fn tx_fn
Definition: hcadec.c:70
s
#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:271
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:120
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
c
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:1575
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:525
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:1057
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:22
a
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
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
i
#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:523
hca_data.h
AVSampleFormat
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
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:445
c2
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:509
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:79
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:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
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:135
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