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/intreadwrite.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 "get_bits.h"
29 #include "internal.h"
30 #include "hca_data.h"
31 
32 typedef struct ChannelContext {
33  float base[128];
34  DECLARE_ALIGNED(32, float, imdct_in)[128];
35  DECLARE_ALIGNED(32, float, imdct_out)[128];
36  DECLARE_ALIGNED(32, float, imdct_prev)[128];
37  int8_t scale_factors[128];
38  uint8_t scale[128];
39  int8_t intensity[8];
40  int8_t *hfr_scale;
41  unsigned count;
42  int chan_type;
44 
45 typedef struct HCAContext {
46  const AVCRC *crc_table;
47 
49 
50  uint8_t ath[128];
51 
52  int ath_type;
53  unsigned hfr_group_count;
54  uint8_t track_count;
55  uint8_t channel_config;
57  uint8_t base_band_count;
60 
64 } HCAContext;
65 
66 static void ath_init1(uint8_t *ath, int sample_rate)
67 {
68  unsigned int index;
69  unsigned int acc = 0;
70 
71  for (int i = 0; i < 128; i++) {
72  acc += sample_rate;
73  index = acc >> 13;
74 
75  if (index >= 654) {
76  memset(ath+i, 0xFF, (128 - i));
77  break;
78  }
79 
81  }
82 }
83 
84 static int ath_init(uint8_t *ath, int type, int sample_rate)
85 {
86  switch (type) {
87  case 0:
88  /* nothing to do */
89  break;
90  case 1:
92  break;
93  default:
94  return AVERROR_INVALIDDATA;
95  }
96 
97  return 0;
98 }
99 
100 static inline unsigned ceil2(unsigned a, unsigned b)
101 {
102  return (b > 0) ? (a / b + ((a % b) ? 1 : 0)) : 0;
103 }
104 
106 {
107  HCAContext *c = avctx->priv_data;
108  GetByteContext gb0, *const gb = &gb0;
109  int8_t r[16] = { 0 };
110  float scale = 1.f / 8.f;
111  unsigned b, chunk;
112  int version, ret;
113 
115  c->crc_table = av_crc_get_table(AV_CRC_16_ANSI);
116 
117  if (avctx->ch_layout.nb_channels <= 0 || avctx->ch_layout.nb_channels > 16)
118  return AVERROR(EINVAL);
119 
120  if (avctx->extradata_size < 36)
121  return AVERROR_INVALIDDATA;
122  bytestream2_init(gb, avctx->extradata, avctx->extradata_size);
123 
124  bytestream2_skipu(gb, 4);
125  version = bytestream2_get_be16(gb);
126  bytestream2_skipu(gb, 2);
127 
128  c->ath_type = version >= 0x200 ? 0 : 1;
129 
130  if (bytestream2_get_be32u(gb) != MKBETAG('f', 'm', 't', 0))
131  return AVERROR_INVALIDDATA;
132  bytestream2_skipu(gb, 4);
133  bytestream2_skipu(gb, 4);
134  bytestream2_skipu(gb, 4);
135 
136  chunk = bytestream2_get_be32u(gb);
137  if (chunk == MKBETAG('c', 'o', 'm', 'p')) {
138  bytestream2_skipu(gb, 2);
139  bytestream2_skipu(gb, 1);
140  bytestream2_skipu(gb, 1);
141  c->track_count = bytestream2_get_byteu(gb);
142  c->channel_config = bytestream2_get_byteu(gb);
143  c->total_band_count = bytestream2_get_byteu(gb);
144  c->base_band_count = bytestream2_get_byteu(gb);
145  c->stereo_band_count = bytestream2_get_byte (gb);
146  c->bands_per_hfr_group = bytestream2_get_byte (gb);
147  } else if (chunk == MKBETAG('d', 'e', 'c', 0)) {
148  bytestream2_skipu(gb, 2);
149  bytestream2_skipu(gb, 1);
150  bytestream2_skipu(gb, 1);
151  c->total_band_count = bytestream2_get_byteu(gb) + 1;
152  c->base_band_count = bytestream2_get_byteu(gb) + 1;
153  c->track_count = bytestream2_peek_byteu(gb) >> 4;
154  c->channel_config = bytestream2_get_byteu(gb) & 0xF;
155  if (!bytestream2_get_byteu(gb))
156  c->base_band_count = c->total_band_count;
157  c->stereo_band_count = c->total_band_count - c->base_band_count;
158  c->bands_per_hfr_group = 0;
159  } else
160  return AVERROR_INVALIDDATA;
161 
162  if (c->total_band_count > FF_ARRAY_ELEMS(c->ch->imdct_in))
163  return AVERROR_INVALIDDATA;
164 
165 
166  while (bytestream2_get_bytes_left(gb) >= 4) {
167  chunk = bytestream2_get_be32u(gb);
168  if (chunk == MKBETAG('v', 'b', 'r', 0)) {
169  bytestream2_skip(gb, 2 + 2);
170  } else if (chunk == MKBETAG('a', 't', 'h', 0)) {
171  c->ath_type = bytestream2_get_be16(gb);
172  } else if (chunk == MKBETAG('r', 'v', 'a', 0)) {
173  bytestream2_skip(gb, 4);
174  } else if (chunk == MKBETAG('c', 'o', 'm', 'm')) {
175  bytestream2_skip(gb, bytestream2_get_byte(gb) * 8);
176  } else if (chunk == MKBETAG('c', 'i', 'p', 'h')) {
177  bytestream2_skip(gb, 2);
178  } else if (chunk == MKBETAG('l', 'o', 'o', 'p')) {
179  bytestream2_skip(gb, 4 + 4 + 2 + 2);
180  } else if (chunk == MKBETAG('p', 'a', 'd', 0)) {
181  break;
182  } else {
183  break;
184  }
185  }
186 
187  ret = ath_init(c->ath, c->ath_type, avctx->sample_rate);
188  if (ret < 0)
189  return ret;
190 
191  if (!c->track_count)
192  c->track_count = 1;
193 
194  b = avctx->ch_layout.nb_channels / c->track_count;
195  if (c->stereo_band_count && b > 1) {
196  int8_t *x = r;
197 
198  for (int i = 0; i < c->track_count; i++, x+=b) {
199  switch (b) {
200  case 2:
201  case 3:
202  x[0] = 1;
203  x[1] = 2;
204  break;
205  case 4:
206  x[0]=1; x[1] = 2;
207  if (c->channel_config == 0) {
208  x[2]=1;
209  x[3]=2;
210  }
211  break;
212  case 5:
213  x[0]=1; x[1] = 2;
214  if (c->channel_config <= 2) {
215  x[3]=1;
216  x[4]=2;
217  }
218  break;
219  case 6:
220  case 7:
221  x[0] = 1; x[1] = 2; x[4] = 1; x[5] = 2;
222  break;
223  case 8:
224  x[0] = 1; x[1] = 2; x[4] = 1; x[5] = 2; x[6] = 1; x[7] = 2;
225  break;
226  }
227  }
228  }
229 
230  if (c->total_band_count < c->base_band_count)
231  return AVERROR_INVALIDDATA;
232 
233  c->hfr_group_count = ceil2(c->total_band_count - (c->base_band_count + c->stereo_band_count),
234  c->bands_per_hfr_group);
235 
236  if (c->base_band_count + c->stereo_band_count + (unsigned long)c->hfr_group_count > 128ULL)
237  return AVERROR_INVALIDDATA;
238 
239  for (int i = 0; i < avctx->ch_layout.nb_channels; i++) {
240  c->ch[i].chan_type = r[i];
241  c->ch[i].count = c->base_band_count + ((r[i] != 2) ? c->stereo_band_count : 0);
242  c->ch[i].hfr_scale = &c->ch[i].scale_factors[c->base_band_count + c->stereo_band_count];
243  if (c->ch[i].count > 128)
244  return AVERROR_INVALIDDATA;
245  }
246 
248  if (!c->fdsp)
249  return AVERROR(ENOMEM);
250 
251  return av_tx_init(&c->tx_ctx, &c->tx_fn, AV_TX_FLOAT_MDCT, 1, 128, &scale, 0);
252 }
253 
254 static void run_imdct(HCAContext *c, ChannelContext *ch, int index, float *out)
255 {
256  c->tx_fn(c->tx_ctx, ch->imdct_out, ch->imdct_in, sizeof(float));
257 
258  c->fdsp->vector_fmul_window(out, ch->imdct_prev + (128 >> 1),
259  ch->imdct_out, window, 128 >> 1);
260 
261  memcpy(ch->imdct_prev, ch->imdct_out, 128 * sizeof(float));
262 }
263 
265  int index, unsigned band_count, unsigned base_band_count,
266  unsigned stereo_band_count)
267 {
268  float ratio_l = intensity_ratio_table[ch2->intensity[index]];
269  float ratio_r = ratio_l - 2.0f;
270  float *c1 = &ch1->imdct_in[base_band_count];
271  float *c2 = &ch2->imdct_in[base_band_count];
272 
273  if (ch1->chan_type != 1 || !stereo_band_count)
274  return;
275 
276  for (int i = 0; i < band_count; i++) {
277  *(c2++) = *c1 * ratio_r;
278  *(c1++) *= ratio_l;
279  }
280 }
281 
283  unsigned hfr_group_count,
284  unsigned bands_per_hfr_group,
285  unsigned start_band, unsigned total_band_count)
286 {
287  if (ch->chan_type == 2 || !bands_per_hfr_group)
288  return;
289 
290  for (int i = 0, k = start_band, l = start_band - 1; i < hfr_group_count; i++){
291  for (int j = 0; j < bands_per_hfr_group && k < total_band_count && l >= 0; j++, k++, l--){
293  av_clip_intp2(ch->hfr_scale[i] - ch->scale_factors[l], 6) ] * ch->imdct_in[l];
294  }
295  }
296 
297  ch->imdct_in[127] = 0;
298 }
299 
301  GetBitContext *gb)
302 {
303  for (int i = 0; i < ch->count; i++) {
304  unsigned scale = ch->scale[i];
305  int nb_bits = max_bits_table[scale];
306  int value = get_bitsz(gb, nb_bits);
307  float factor;
308 
309  if (scale > 7) {
310  value = (1 - ((value & 1) << 1)) * (value >> 1);
311  if (!value)
312  skip_bits_long(gb, -1);
313  factor = value;
314  } else {
315  value += scale << 4;
316  skip_bits_long(gb, quant_spectrum_bits[value] - nb_bits);
318  }
319  ch->imdct_in[i] = factor * ch->base[i];
320  }
321 
322  memset(ch->imdct_in + ch->count, 0, sizeof(ch->imdct_in) - ch->count * sizeof(ch->imdct_in[0]));
323 }
324 
325 static void unpack(HCAContext *c, ChannelContext *ch,
326  GetBitContext *gb,
327  unsigned hfr_group_count,
328  int packed_noise_level,
329  const uint8_t *ath)
330 {
331  int delta_bits = get_bits(gb, 3);
332 
333  if (delta_bits > 5) {
334  for (int i = 0; i < ch->count; i++)
335  ch->scale_factors[i] = get_bits(gb, 6);
336  } else if (delta_bits) {
337  int factor = get_bits(gb, 6);
338  int max_value = (1 << delta_bits) - 1;
339  int half_max = max_value >> 1;
340 
341  ch->scale_factors[0] = factor;
342  for (int i = 1; i < ch->count; i++){
343  int delta = get_bits(gb, delta_bits);
344 
345  if (delta == max_value) {
346  factor = get_bits(gb, 6);
347  } else {
348  factor += delta - half_max;
349  }
351 
352  ch->scale_factors[i] = factor;
353  }
354  } else {
355  memset(ch->scale_factors, 0, 128);
356  }
357 
358  if (ch->chan_type == 2){
359  ch->intensity[0] = get_bits(gb, 4);
360  if (ch->intensity[0] < 15) {
361  for (int i = 1; i < 8; i++)
362  ch->intensity[i] = get_bits(gb, 4);
363  }
364  } else {
365  for (int i = 0; i < hfr_group_count; i++)
366  ch->hfr_scale[i] = get_bits(gb, 6);
367  }
368 
369  for (int i = 0; i < ch->count; i++) {
370  int scale = ch->scale_factors[i];
371 
372  if (scale) {
373  scale = c->ath[i] + ((packed_noise_level + i) >> 8) - ((scale * 5) >> 1) + 2;
374  scale = scale_table[av_clip(scale, 0, 58)];
375  }
376  ch->scale[i] = scale;
377  }
378 
379  memset(ch->scale + ch->count, 0, sizeof(ch->scale) - ch->count);
380 
381  for (int i = 0; i < ch->count; i++)
383 }
384 
386  int *got_frame_ptr, AVPacket *avpkt)
387 {
388  HCAContext *c = avctx->priv_data;
389  int ch, ret, packed_noise_level;
390  GetBitContext gb0, *const gb = &gb0;
391  float **samples;
392 
393  if (avctx->err_recognition & AV_EF_CRCCHECK) {
394  if (av_crc(c->crc_table, 0, avpkt->data, avpkt->size))
395  return AVERROR_INVALIDDATA;
396  }
397 
398  if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
399  return ret;
400 
401  if (get_bits(gb, 16) != 0xFFFF)
402  return AVERROR_INVALIDDATA;
403 
404  frame->nb_samples = 1024;
405  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
406  return ret;
407  samples = (float **)frame->extended_data;
408 
409  packed_noise_level = (get_bits(gb, 9) << 8) - get_bits(gb, 7);
410 
411  for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
412  unpack(c, &c->ch[ch], gb, c->hfr_group_count, packed_noise_level, c->ath);
413 
414  for (int i = 0; i < 8; i++) {
415  for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
416  dequantize_coefficients(c, &c->ch[ch], gb);
417  for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
418  reconstruct_hfr(c, &c->ch[ch], c->hfr_group_count, c->bands_per_hfr_group,
419  c->stereo_band_count + c->base_band_count, c->total_band_count);
420  for (ch = 0; ch < avctx->ch_layout.nb_channels - 1; ch++)
421  apply_intensity_stereo(c, &c->ch[ch], &c->ch[ch+1], i,
422  c->total_band_count - c->base_band_count,
423  c->base_band_count, c->stereo_band_count);
424  for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
425  run_imdct(c, &c->ch[ch], i, samples[ch] + i * 128);
426  }
427 
428  *got_frame_ptr = 1;
429 
430  return avpkt->size;
431 }
432 
434 {
435  HCAContext *c = avctx->priv_data;
436 
437  av_freep(&c->fdsp);
438  av_tx_uninit(&c->tx_ctx);
439 
440  return 0;
441 }
442 
444  .p.name = "hca",
445  .p.long_name = NULL_IF_CONFIG_SMALL("CRI HCA"),
446  .p.type = AVMEDIA_TYPE_AUDIO,
447  .p.id = AV_CODEC_ID_HCA,
448  .priv_data_size = sizeof(HCAContext),
449  .init = decode_init,
451  .close = decode_close,
452  .p.capabilities = AV_CODEC_CAP_DR1,
454  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
456 };
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:292
ChannelContext::hfr_scale
int8_t * hfr_scale
Definition: hcadec.c:40
av_clip
#define av_clip
Definition: common.h:95
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:39
r
const char * r
Definition: vf_curves.c:116
acc
int acc
Definition: yuv2rgb.c:554
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:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:998
GetByteContext
Definition: bytestream.h:33
AVCRC
uint32_t AVCRC
Definition: crc.h:46
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:119
AVTXContext
Definition: tx_priv.h:201
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1344
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
b
#define b
Definition: input.c:34
FFCodec
Definition: codec_internal.h:112
ChannelContext::imdct_prev
float imdct_prev[128]
Definition: hcadec.c:36
c1
static const uint64_t c1
Definition: murmur3.c:51
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
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:264
sample_rate
sample_rate
Definition: ffmpeg_filter.c:153
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:649
init
static int init
Definition: av_tx.c:47
crc.h
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:380
window
static SDL_Window * window
Definition: ffplay.c:365
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
GetBitContext
Definition: get_bits.h:62
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:469
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
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
ChannelContext::base
float base[128]
Definition: hcadec.c:33
HCAContext::bands_per_hfr_group
uint8_t bands_per_hfr_group
Definition: hcadec.c:59
HCAContext::hfr_group_count
unsigned hfr_group_count
Definition: hcadec.c:53
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:678
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:111
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:325
ath_init1
static void ath_init1(uint8_t *ath, int sample_rate)
Definition: hcadec.c:66
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
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:56
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
HCAContext::tx_fn
av_tx_fn tx_fn
Definition: hcadec.c:61
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
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
get_bits.h
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: hcadec.c:385
HCAContext::ath_type
int ath_type
Definition: hcadec.c:52
ath
static av_cold float ath(float f, float add)
Calculate ATH value for given frequency.
Definition: aacpsy.c:292
quant_spectrum_value
static const int8_t quant_spectrum_value[]
Definition: hca_data.h:41
dequantize_coefficients
static void dequantize_coefficients(HCAContext *c, ChannelContext *ch, GetBitContext *gb)
Definition: hcadec.c:300
AV_CRC_16_ANSI
@ AV_CRC_16_ANSI
Definition: crc.h:50
ChannelContext::chan_type
int chan_type
Definition: hcadec.c:42
HCAContext::ath
uint8_t ath[128]
Definition: hcadec.c:50
av_clip_intp2
#define av_clip_intp2
Definition: common.h:116
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: hcadec.c:105
ChannelContext::imdct_out
float imdct_out[128]
Definition: hcadec.c:35
quant_step_size
static const float quant_step_size[]
Definition: hca_data.h:125
HCAContext::fdsp
AVFloatDSPContext * fdsp
Definition: hcadec.c:63
index
int index
Definition: gxfenc.c:89
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:84
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
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:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
dequantizer_scaling_table
static const float dequantizer_scaling_table[]
Definition: hca_data.h:113
codec_internal.h
HCAContext::stereo_band_count
uint8_t stereo_band_count
Definition: hcadec.c:58
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:1014
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
ff_hca_decoder
const FFCodec ff_hca_decoder
Definition: hcadec.c:443
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:282
AVFloatDSPContext
Definition: float_dsp.h:24
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
version
version
Definition: libkvazaar.c:313
HCAContext::base_band_count
uint8_t base_band_count
Definition: hcadec.c:57
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:251
HCAContext::crc_table
const AVCRC * crc_table
Definition: hcadec.c:46
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: hcadec.c:433
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
ChannelContext::scale
uint8_t scale[128]
Definition: hcadec.c:38
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:490
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
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: codec_internal.h:31
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:203
max_bits_table
static const uint8_t max_bits_table[]
Definition: hca_data.h:25
avcodec.h
ChannelContext::count
unsigned count
Definition: hcadec.c:41
HCAContext::track_count
uint8_t track_count
Definition: hcadec.c:54
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
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: avcodec.h:1352
ceil2
static unsigned ceil2(unsigned a, unsigned b)
Definition: hcadec.c:100
HCAContext
Definition: hcadec.c:45
ChannelContext::intensity
int8_t intensity[8]
Definition: hcadec.c:39
AVCodecContext
main external API structure.
Definition: avcodec.h:389
c2
static const uint64_t c2
Definition: murmur3.c:52
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
HCAContext::ch
ChannelContext ch[16]
Definition: hcadec.c:48
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:34
ChannelContext
Definition: hcadec.c:32
ChannelContext::scale_factors
int8_t scale_factors[128]
Definition: hcadec.c:37
factor
static const int factor[16]
Definition: vf_pp7.c:76
HCAContext::channel_config
uint8_t channel_config
Definition: hcadec.c:55
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:416
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:278
intensity_ratio_table
static const float intensity_ratio_table[]
Definition: hca_data.h:85
HCAContext::tx_ctx
AVTXContext * tx_ctx
Definition: hcadec.c:62
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
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
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:519
run_imdct
static void run_imdct(HCAContext *c, ChannelContext *ch, int index, float *out)
Definition: hcadec.c:254
tx.h