53 #define IMC_BLOCK_SIZE 64 54 #define IMC_FRAME_ID 0x21 101 void (*butterflies_float)(
float *av_restrict v1,
float *av_restrict v2,
int len);
109 float weights1[31], weights2[31];
116 #define IMC_VLC_BITS 9 117 #define VLC_TABLES_SIZE 9512 123 return 3.5 * atan((freq / 7500.0) * (freq / 7500.0)) + 13.0 * atan(freq * 0.00076);
128 double freqmin[32], freqmid[32], freqmax[32];
129 double scale = sampling_rate / (256.0 * 2.0 * 2.0);
130 double nyquist_freq = sampling_rate * 0.5;
131 double freq, bark, prev_bark = 0,
tf,
tb;
134 for (i = 0; i < 32; i++) {
139 tb = bark - prev_bark;
148 while (
tf < nyquist_freq) {
160 if (tb <= bark - 0.5)
166 for (i = 0; i < 32; i++) {
168 for (j = 31; j > 0 && freq <= freqmid[j]; j--);
172 for (j = 0; j < 32 && freq >= freqmid[j]; j++);
180 for (
int i = 0,
offset = 0;
i < 4 ;
i++) {
181 for (
int j = 0; j < 4; j++) {
203 "Strange sample rate of %i, file likely corrupt or " 204 "needing a new table derivation method.\n",
217 for (j = 0; j < avctx->
channels; j++) {
220 for (i = 0; i <
BANDS; i++)
229 for (i = 0; i <
COEFFS; i++)
231 for (i = 0; i < COEFFS / 2; i++) {
235 r1 = sin((i * 4.0 + 1.0) / 1024.0 *
M_PI);
236 r2 = cos((i * 4.0 + 1.0) / 1024.0 *
M_PI);
249 for (i = 0; i < 30; i++)
288 float snr_limit = 1.e-30;
292 for (i = 0; i <
BANDS; i++) {
293 flcoeffs5[
i] = workT2[
i] = 0.0;
295 workT1[
i] = flcoeffs1[
i] * flcoeffs1[
i];
296 flcoeffs3[
i] = 2.0 * flcoeffs2[
i];
299 flcoeffs3[
i] = -30000.0;
301 workT3[
i] = bandWidthT[
i] * workT1[
i] * 0.01;
302 if (workT3[i] <= snr_limit)
306 for (i = 0; i <
BANDS; i++) {
307 for (cnt2 = i; cnt2 < q->
cyclTab[
i]; cnt2++)
308 flcoeffs5[cnt2] = flcoeffs5[cnt2] + workT3[i];
309 workT2[cnt2 - 1] = workT2[cnt2 - 1] + workT3[
i];
312 for (i = 1; i <
BANDS; i++) {
313 accum = (workT2[i - 1] + accum) * q->
weights1[i - 1];
314 flcoeffs5[i] += accum;
317 for (i = 0; i <
BANDS; i++)
320 for (i = 0; i <
BANDS; i++) {
321 for (cnt2 = i - 1; cnt2 > q->
cyclTab2[
i]; cnt2--)
322 flcoeffs5[cnt2] += workT3[i];
323 workT2[cnt2+1] += workT3[
i];
328 for (i = BANDS-2; i >= 0; i--) {
329 accum = (workT2[i+1] + accum) * q->
weights2[i];
330 flcoeffs5[i] += accum;
345 s = stream_format_code >> 1;
346 hufftab[0] = &huffman_vlc[
s][0];
347 hufftab[1] = &huffman_vlc[
s][1];
348 hufftab[2] = &huffman_vlc[
s][2];
349 hufftab[3] = &huffman_vlc[
s][3];
352 if (stream_format_code & 4)
356 for (i = start; i <
BANDS; i++) {
359 if (levlCoeffs[i] == 17)
371 for (i = 1; i <
BANDS; i++)
382 flcoeffs1[0] = 20000.0 /
exp2 (levlCoeffBuf[0] * 0.18945);
383 flcoeffs2[0] =
log2f(flcoeffs1[0]);
387 for (i = 1; i <
BANDS; i++) {
388 level = levlCoeffBuf[
i];
395 else if (level <= 24)
401 tmp2 += 0.83048 *
level;
418 for (i = 0; i <
BANDS; i++) {
420 if (levlCoeffBuf[i] < 16) {
422 flcoeffs2[
i] = (levlCoeffBuf[
i] - 7) * 0.83048 + flcoeffs2[i];
424 flcoeffs1[
i] = old_floor[
i];
436 flcoeffs1[
pos] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945);
437 flcoeffs2[
pos] =
log2f(flcoeffs1[pos]);
438 tmp = flcoeffs1[
pos];
439 tmp2 = flcoeffs2[
pos];
442 for (i = 0; i <
BANDS; i++) {
445 level = *levlCoeffBuf++;
446 flcoeffs1[
i] = tmp *
powf(10.0, -level * 0.4375);
447 flcoeffs2[
i] = tmp2 - 1.4533435415 *
level;
455 int stream_format_code,
int freebits,
int flag)
458 const float limit = -1.e20;
467 float lowest = 1.e10;
473 for (i = 0; i <
BANDS; i++)
476 for (i = 0; i < BANDS - 1; i++) {
485 highest = highest * 0.25;
487 for (i = 0; i <
BANDS; i++) {
504 if (stream_format_code & 0x2) {
511 for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS - 1; i++) {
520 summa = (summa * 0.5 - freebits) / iacc;
523 for (i = 0; i < BANDS / 2; i++) {
524 rres = summer - freebits;
525 if ((rres >= -8) && (rres <= 8))
531 for (j = (stream_format_code & 0x2) ? 4 : 0; j <
BANDS; j++) {
532 cwlen = av_clipf(((chctx->
flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);
543 if (freebits < summer)
550 summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
553 for (i = (stream_format_code & 0x2) ? 4 : 0; i <
BANDS; i++) {
558 if (freebits > summer) {
559 for (i = 0; i <
BANDS; i++) {
567 if (highest <= -1.e20)
573 for (i = 0; i <
BANDS; i++) {
574 if (workT[i] > highest) {
580 if (highest > -1.e20) {
581 workT[found_indx] -= 2.0;
583 workT[found_indx] = -1.e20;
585 for (j =
band_tab[found_indx]; j < band_tab[found_indx + 1] && (freebits > summer); j++) {
590 }
while (freebits > summer);
592 if (freebits < summer) {
593 for (i = 0; i <
BANDS; i++) {
597 if (stream_format_code & 0x2) {
603 while (freebits < summer) {
606 for (i = 0; i <
BANDS; i++) {
607 if (workT[i] < lowest) {
614 workT[low_indx] = lowest + 2.0;
617 workT[low_indx] = 1.e20;
619 for (j =
band_tab[low_indx]; j <
band_tab[low_indx+1] && (freebits < summer); j++) {
636 for (i = 0; i <
BANDS; i++) {
643 for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
674 if (j < band_tab[i + 1]) {
695 for (i = 0; i <
BANDS; i++) {
700 while (corrected < summer) {
701 if (highest <= -1.e20)
706 for (i = 0; i <
BANDS; i++) {
707 if (workT[i] > highest) {
713 if (highest > -1.e20) {
714 workT[found_indx] -= 2.0;
715 if (++(chctx->
bitsBandT[found_indx]) == 6)
716 workT[found_indx] = -1.e20;
718 for (j =
band_tab[found_indx]; j <
band_tab[found_indx+1] && (corrected < summer); j++) {
736 for (i = 0; i <
COEFFS / 2; i++) {
748 for (i = 0; i <
COEFFS / 2; i++) {
762 int stream_format_code)
765 int middle_value, cw_len, max_size;
766 const float *quantizer;
768 for (i = 0; i <
BANDS; i++) {
776 max_size = 1 << cw_len;
777 middle_value = max_size >> 1;
804 int i, j, cw_len, cw;
806 for (i = 0; i <
BANDS; i++) {
817 "Potential problem on band %i, coefficient %i" 818 ": cw_len=%i\n", i, j, cw_len);
834 for (i = 0; i <
BANDS; i++) {
840 if (((
int)((band_tab[i + 1] - band_tab[i]) * 1.5) > chctx->
sumLenArr[i]) && (chctx->
sumLenArr[i] > 0))
846 for (i = 0; i <
BANDS; i++) {
858 for (i = 0; i <
BANDS; i++) {
875 int stream_format_code;
876 int imc_hdr,
i, j,
ret;
879 int counter, bitscount;
885 if (imc_hdr & 0x18) {
892 if (stream_format_code & 0x04)
896 for (i = 0; i <
BANDS; i++)
904 if (stream_format_code & 0x1)
909 if (stream_format_code & 0x1)
912 else if (stream_format_code & 0x4)
919 for(i=0; i<
BANDS; i++) {
929 if (stream_format_code & 0x1) {
930 for (i = 0; i <
BANDS; i++) {
937 for (i = 0; i <
BANDS; i++) {
946 for (i = 0; i < BANDS - 1; i++)
957 if (stream_format_code & 0x2) {
964 for (i = 1; i < 4; i++) {
965 if (stream_format_code & 0x1)
978 if (!(stream_format_code & 0x2))
990 if (stream_format_code & 0x1) {
991 for (i = 0; i <
BANDS; i++)
997 for (i = 0; i <
BANDS; i++) {
1023 int *got_frame_ptr,
AVPacket *avpkt)
1027 int buf_size = avpkt->
size;
1036 if (buf_size < IMC_BLOCK_SIZE * avctx->
channels) {
1046 for (i = 0; i < avctx->
channels; i++) {
1086 #if CONFIG_IMC_DECODER 1103 #if CONFIG_IAC_DECODER int skipFlags[COEFFS]
skip coefficient decoding or not
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
int codewords[COEFFS]
raw codewords read from bitstream
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
ptrdiff_t const GLvoid * data
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
int skipFlagRaw[BANDS]
skip flags are stored in raw form or not
static av_cold int init(AVCodecContext *avctx)
#define avpriv_request_sample(...)
float mdct_sine_window[COEFFS]
MDCT tables.
static const uint8_t imc_huffman_lens[4][4][18]
int skipFlagCount[BANDS]
skipped coefficients per band
static const float imc_weights2[31]
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
#define AV_CH_LAYOUT_STEREO
static void imc_read_level_coeffs(IMCContext *q, int stream_format_code, int *levlCoeffs)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static av_cold void imc_init_static(void)
#define LOCAL_ALIGNED_16(t, v,...)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
enum AVSampleFormat sample_fmt
audio sample format
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
int bandFlagsBuf[BANDS]
flags for each band
static av_cold int imc_decode_close(AVCodecContext *avctx)
static const int8_t cyclTab[32]
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
static int get_bits_count(const GetBitContext *s)
static const float imc_weights1[31]
bitstream reader API header.
static void imc_get_skip_coeff(IMCContext *q, IMCChannel *chctx)
static void imc_refine_bit_allocation(IMCContext *q, IMCChannel *chctx)
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void(* fft_permute)(struct FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling fft_calc().
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
static const float *const imc_exp_tab2
static void imc_decode_level_coefficients_raw(IMCContext *q, int *levlCoeffBuf, float *flcoeffs1, float *flcoeffs2)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static void imc_imdct256(IMCContext *q, IMCChannel *chctx, int channels)
int flags
AV_CODEC_FLAG_*.
static void imc_calculate_coeffs(IMCContext *q, float *flcoeffs1, float *flcoeffs2, int *bandWidthT, float *flcoeffs3, float *flcoeffs5)
const char * name
Name of the codec implementation.
uint64_t channel_layout
Audio channel layout.
static const int8_t cyclTab2[32]
static int imc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
static void imc_decode_level_coefficients2(IMCContext *q, int *levlCoeffBuf, float *old_floor, float *flcoeffs1, float *flcoeffs2)
common internal API header
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
static const uint16_t band_tab[33]
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
int bitsBandT[BANDS]
how many bits per codeword in band
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
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
float last_fft_im[COEFFS]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static const uint8_t imc_huffman_syms[4][4][18]
void(* butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len)
static void imc_get_coeffs(AVCodecContext *avctx, IMCContext *q, IMCChannel *chctx)
#define AV_LOG_INFO
Standard information.
static const float xTab[14]
FFTComplex samples[COEFFS/2]
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
static int inverse_quant_coeff(IMCContext *q, IMCChannel *chctx, int stream_format_code)
int sample_rate
samples per second
void AAC_RENAME() ff_sine_window_init(INTFLOAT *window, int n)
Generate a sine window.
main external API structure.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
void(* butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len)
Calculate the sum and difference of two vectors of floats.
static double freq2bark(double freq)
static unsigned int get_bits1(GetBitContext *s)
int bandWidthT[BANDS]
codewords per band
static av_cold void flush(AVCodecContext *avctx)
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static VLC huffman_vlc[4][4]
static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2]
static const float imc_quantizer1[4][8]
static av_cold void iac_generate_tabs(IMCContext *q, int sampling_rate)
internal math functions header
common internal api header.
static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
void(* fft_calc)(struct FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in ff_fft_init().
static int bit_allocation(IMCContext *q, IMCChannel *chctx, int stream_format_code, int freebits, int flag)
Perform bit allocation depending on bits available.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static const uint8_t imc_cb_select[4][32]
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
int channels
number of audio channels
static int ff_thread_once(char *control, void(*routine)(void))
VLC_TYPE(* table)[2]
code, bits
static enum AVSampleFormat sample_fmts[]
Filter the word “frame” indicates either a video frame or a group of audio samples
static void imc_adjust_bit_allocation(IMCContext *q, IMCChannel *chctx, int summer)
Increase highest' band coefficient sizes as some bits won't be used.
static const float imc_quantizer2[2][56]
int sumLenArr[BANDS]
bits for all coeffs in band
static const uint8_t imc_huffman_sizes[4]
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
uint8_t ** extended_data
pointers to the data planes/channels.
#define AV_CH_LAYOUT_MONO
#define INIT_VLC_STATIC_OVERLONG
static void imc_read_level_coeffs_raw(IMCContext *q, int stream_format_code, int *levlCoeffs)
This structure stores compressed data.
static void imc_decode_level_coefficients(IMCContext *q, int *levlCoeffBuf, float *flcoeffs1, float *flcoeffs2)
int skipFlagBits[BANDS]
bits used to code skip flags
static av_cold int imc_decode_init(AVCodecContext *avctx)
int nb_samples
number of audio samples (per channel) described by this frame
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static const float imc_exp_tab[32]
int CWlengthT[COEFFS]
how many bits in each codeword