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