25 #define FFT_FIXED_32 1 45 #define MAX_CHANNELS 6 46 #define DCA_MAX_FRAME_SIZE 16384 47 #define DCA_HEADER_SIZE 13 48 #define DCA_LFE_SAMPLES 8 50 #define DCAENC_SUBBANDS 32 52 #define SUBSUBFRAMES 2 53 #define SUBBAND_SAMPLES (SUBFRAMES * SUBSUBFRAMES * 8) 56 #define COS_T(x) (c->cos_table[(x) & 2047]) 116 double f1 = f / 1000;
118 return -3.64 * pow(f1, -0.8)
119 + 6.8 *
exp(-0.6 * (f1 - 3.4) * (f1 - 3.4))
120 - 6.0 *
exp(-0.15 * (f1 - 8.7) * (f1 - 8.7))
121 - 0.0006 * (f1 * f1) * (f1 * f1);
126 double h = (f -
fc[
i]) /
erb[i];
130 return 20 * log10(h);
167 int i, j, k, min_frame_bits;
186 "encoder will guess the layout, but it " 187 "might be incorrect.\n");
222 for (i = 0; i < 9; i++) {
253 for (i = 1; i < 512; i++) {
260 for (i = 0; i < 2048; i++)
263 for (k = 0; k < 32; k++) {
264 for (j = 0; j < 8; j++) {
270 for (i = 0; i < 512; i++) {
275 for (i = 0; i < 9; i++) {
276 for (j = 0; j <
AUBANDS; j++) {
277 for (k = 0; k < 256; k++) {
285 for (i = 0; i < 256; i++) {
289 for (j = 0; j < 8; j++) {
291 for (i = 0; i < 512; i++) {
293 accum += reconst * cos(2 *
M_PI * (i + 0.5 - 256) * (j + 0.5) / 512);
297 for (j = 0; j < 8; j++) {
299 for (i = 0; i < 512; i++) {
301 accum += reconst * cos(2 *
M_PI * (i + 0.5 - 256) * (j + 0.5) / 512);
321 int ch, subs,
i, k, j;
337 memset(accum, 0, 64 *
sizeof(
int32_t));
339 for (k = 0, i = hist_start, j = 0;
340 i < 512; k = (k + 1) & 63, i++, j++)
342 for (i = 0; i < hist_start; k = (k + 1) & 63, i++, j++)
345 for (k = 16; k < 32; k++)
346 accum[k] = accum[k] - accum[31 - k];
347 for (k = 32; k < 48; k++)
348 accum[k] = accum[k] + accum[95 - k];
350 for (band = 0; band < 32; band++) {
352 for (i = 16; i < 48; i++) {
353 int s = (2 * band + 1) * (2 * (i + 16) + 1);
357 c->
subband[ch][band][subs] = ((band + 1) & 2) ? -resp : resp;
361 for (i = 0; i < 32; i++)
362 hist[i + hist_start] = input[(subs * 32 + i) * c->
channels + chi];
364 hist_start = (hist_start + 32) & 511;
384 for (i = hist_start, j = 0; i < 512; i++, j++)
386 for (i = 0; i < hist_start; i++, j++)
392 for (i = 0; i < 64; i++)
393 hist[i + hist_start] = input[(lfes * 64 + i) * c->
channels + lfech];
395 hist_start = (hist_start + 64) & 511;
404 for (i = 1024; i > 0; i >>= 1) {
428 for (i = 0; i < 512; i++)
432 for (i = 0; i < 256; i++) {
451 for (j = 0; j < 256; j++)
452 out_cb_unnorm[j] = -2047;
454 for (i = 0; i <
AUBANDS; i++) {
456 for (j = 0; j < 256; j++)
457 denom =
add_cb(c, denom, power[j] + c->
auf[samplerate_index][i][j]);
458 for (j = 0; j < 256; j++)
459 out_cb_unnorm[j] =
add_cb(c, out_cb_unnorm[j],
460 -denom + c->
auf[samplerate_index][i][j]);
463 for (j = 0; j < 256; j++)
464 out_cb[j] =
add_cb(c, out_cb[j], -out_cb_unnorm[j] - ca_cb - cs_cb);
477 for (f = 0; f < 4; f++)
478 walk(c, 0, 0, f, 0, -2047, channel, arg);
480 for (f = 0; f < 8; f++)
481 walk(c, band, band - 1, 8 * band - 4 + f,
492 for (f = 0; f < 4; f++)
493 walk(c, 31, 31, 256 - 4 + f, 0, -2047, channel, arg);
495 for (f = 0; f < 8; f++)
496 walk(c, band, band + 1, 8 * band + 4 + f,
513 int i, k, band, ch, ssf;
516 for (i = 0; i < 256; i++)
524 for (i = 0, k = 128 + 256 * ssf; k < 512; i++, k++)
526 for (k -= 512; i < 512; i++, k++)
527 data[i] = input[k * c->
channels + chi];
530 for (i = 0; i < 256; i++) {
539 for (band = 0; band < 32; band++) {
550 for (sample = 0; sample <
len; sample++) {
563 for (band = 0; band < 32; band++)
581 for (band = 0; band < 32; band++) {
585 if (pred_vq_id >= 0) {
597 #define USED_1ABITS 1 598 #define USED_26ABITS 4 616 int our_nscale, try_remove;
625 for (try_remove = 64; try_remove > 0; try_remove >>= 1) {
632 our_nscale -= try_remove;
635 if (our_nscale >= 125)
651 &c->
quant[ch][band]);
667 for (band = 0; band < 32; band++)
677 for (band = 0; band < 32; band++) {
699 uint32_t clc_bits[DCA_CODE_BOOKS],
705 uint32_t t,
bits = 0;
709 av_assert0(!((!!vlc_bits[i][0]) ^ (!!clc_bits[i])));
710 if (vlc_bits[i][0] == 0) {
717 best_sel_bits[
i] = vlc_bits[
i][0];
720 if (best_sel_bits[i] > vlc_bits[i][sel] && vlc_bits[i][sel]) {
721 best_sel_bits[
i] = vlc_bits[
i][sel];
722 best_sel_id[
i] = sel;
727 t = best_sel_bits[
i] + 2;
728 if (t < clc_bits[i]) {
729 res[
i] = best_sel_id[
i];
732 res[
i] = ff_dca_quant_index_group_size[
i];
748 for (i = 0; i <
bands; i++) {
749 if (abits[i] > 12 || abits[i] == 0) {
772 uint32_t bits_counter = 0;
781 for (band = 0; band < 32; band++) {
784 if (snr_cb >= 1312) {
785 c->
abits[ch][band] = 26;
787 }
else if (snr_cb >= 222) {
788 c->
abits[ch][band] = 8 +
mul32(snr_cb - 222, 69000000);
790 }
else if (snr_cb >= 0) {
791 c->
abits[ch][band] = 2 +
mul32(snr_cb, 106000000);
793 }
else if (forbid_zero || snr_cb >= -140) {
794 c->
abits[ch][band] = 1;
797 c->
abits[ch][band] = 0;
809 for (band = 0; band < 32; band++) {
813 &c->
quant[ch][band]);
823 for (band = 0; band < 32; band++) {
827 huff_bit_count_accum[ch][c->
abits[ch][band] - 1]);
837 clc_bit_count_accum[ch],
876 for (down =
snr_fudge >> 1; down; down >>= 1) {
892 for (k = 0; k < 512; k++)
893 for (ch = 0; ch < c->
channels; ch++) {
908 for (ch = 0; ch < c->
channels; ch++) {
909 for (band = 0; band < 32; band++) {
1074 int i, j, sum,
bits, sel;
1081 sel, c->
abits[ch][band] - 1);
1086 if (c->
abits[ch][band] <= 7) {
1087 for (i = 0; i < 8; i += 4) {
1089 for (j = 3; j >= 0; j--) {
1091 sum += c->
quantized[ch][band][ss * 8 + i + j];
1100 for (i = 0; i < 8; i++) {
1108 int i, band,
ss, ch;
1143 if (c->
abits[ch][band])
1150 if (c->
abits[ch][band])
1171 if (c->
abits[ch][band])
1218 *got_packet_ptr = 1;
1222 #define DCAENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM 1230 .
class_name =
"DCA (DTS Coherent Acoustics)",
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
av_cold int ff_dcaadpcm_init(DCAADPCMEncContext *s)
static int32_t find_peak(DCAEncContext *c, const int32_t *in, int len)
int32_t diff_peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS]
expected peak of residual signal
This structure describes decoded (raw) audio or video data.
uint32_t ff_dca_vlc_calc_alloc_bits(int *values, uint8_t n, uint8_t sel)
ptrdiff_t const GLvoid * data
int32_t eff_masking_curve_cb[256]
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define AV_LOG_WARNING
Something somehow does not look correct.
static void put_frame_header(DCAEncContext *c)
const uint32_t ff_dca_lossy_quant[32]
int64_t bit_rate
the average bitrate
#define LIBAVUTIL_VERSION_INT
static av_cold int init(AVCodecContext *avctx)
const int8_t * channel_order_tab
channel reordering table, lfe and non lfe
static const uint8_t bitstream_sfreq[]
const char * av_default_item_name(void *ptr)
Return the context name.
static const uint16_t erb[]
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
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
static int calc_one_scale(DCAEncContext *c, int32_t peak_cb, int abits, softfloat *quant)
static void shift_history(DCAEncContext *c, const int32_t *input)
#define AV_CH_LAYOUT_STEREO
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
static void walk_band_high(DCAEncContext *c, int band, int channel, walk_band_t walk, int32_t *arg)
#define AV_CH_LAYOUT_5POINT0
CompressionOptions options
int abits[MAX_CHANNELS][DCAENC_SUBBANDS]
static av_cold int encode_close(AVCodecContext *avctx)
const float ff_dca_fir_32bands_nonperfect[512]
static void walk_band_low(DCAEncContext *c, int band, int channel, walk_band_t walk, int32_t *arg)
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
int ff_dcaadpcm_do_real(int pred_vq_index, softfloat quant, int32_t scale_factor, int32_t step_size, const int32_t *prev_hist, const int32_t *in, int32_t *next_hist, int32_t *out, int len, int32_t peak)
static int32_t quantize_value(int32_t value, softfloat quant)
softfloat quant[MAX_CHANNELS][DCAENC_SUBBANDS]
static void accumulate_huff_bit_consumption(int abits, int32_t *quantized, uint32_t *result)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static int32_t get_cb(DCAEncContext *c, int32_t in)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
static double cb(void *priv, double x, double y)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
static void calc_masking(DCAEncContext *c, const int32_t *input)
static const softfloat stepsize_inv[27]
const uint32_t ff_dca_bit_rates[32]
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
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
#define LOCAL_ALIGNED_32(t, v,...)
GLsizei GLboolean const GLfloat * value
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
int32_t masking_curve_cb[SUBSUBFRAMES][256]
int32_t cb_to_level[2048]
static void adjust_jnd(DCAEncContext *c, const int32_t in[512], int32_t out_cb[256])
static void ff_dca_core_dequantize(int32_t *output, const int32_t *input, int32_t step_size, int32_t scale, int residual, int len)
#define AV_COPY128U(d, s)
int scale_factor[MAX_CHANNELS][DCAENC_SUBBANDS]
static void adpcm_analysis(DCAEncContext *c)
#define AV_CH_LAYOUT_5POINT1
static const softfloat scalefactor_inv[128]
static void lfe_downsample(DCAEncContext *c, const int32_t *input)
#define fc(width, name, range_min, range_max)
static double hom(double f)
int32_t band_masking_cb[32]
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.
static void put_subframe(DCAEncContext *c, int subframe)
int32_t auf[9][AUBANDS][256]
static const int snr_fudge
const uint8_t ff_dca_quant_index_group_size[DCA_CODE_BOOKS]
const uint32_t ff_dca_lossless_quant[32]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static uint32_t set_best_abits_code(int abits[DCAENC_SUBBANDS], int bands, int32_t *res)
const float ff_dca_lfe_fir_64[256]
static void update_band_masking(DCAEncContext *c, int band1, int band2, int f, int32_t spectrum1, int32_t spectrum2, int channel, int32_t *arg)
void(* mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
const uint32_t ff_dca_quant_levels[32]
static int32_t add_cb(DCAEncContext *c, int32_t a, int32_t b)
uint64_t channel_layout
Audio channel layout.
static int put_bits_count(PutBitContext *s)
static const unsigned short cos_table[(1<< COS_TABLE_BITS)+2]
#define ss(width, name, subs,...)
static void assign_bits(DCAEncContext *c)
audio channel layout utility functions
static int subband_bufer_alloc(DCAEncContext *c)
int32_t prediction_mode[MAX_CHANNELS][DCAENC_SUBBANDS]
static void calc_lfe_scales(DCAEncContext *c)
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
DCAADPCMEncContext adpcm_ctx
uint32_t ff_dca_vlc_calc_quant_bits(int *values, uint8_t n, uint8_t sel, uint8_t table)
void(* walk_band_t)(DCAEncContext *c, int band1, int band2, int f, int32_t spectrum1, int32_t spectrum2, int channel, int32_t *arg)
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
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static void quantize_adpcm_subband(DCAEncContext *c, int ch, int band)
#define DCA_MAX_FRAME_SIZE
int consumed_adpcm_bits
Number of bits to transmit ADPCM related info.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
const uint32_t ff_dca_scale_factor_quant7[128]
static int32_t mul32(int32_t a, int32_t b)
int frame_size
Number of samples per channel in an audio frame.
int32_t band_spectrum_tab[2][8]
static int init_quantization_noise(DCAEncContext *c, int noise, int forbid_zero)
static const int8_t channel_reorder_lfe[7][5]
static void put_primary_audio_header(DCAEncContext *c)
static void find_peaks(DCAEncContext *c)
void ff_dca_vlc_enc_quant(PutBitContext *pb, int *values, uint8_t n, uint8_t sel, uint8_t table)
Libavcodec external API header.
const int32_t * band_spectrum
AVSampleFormat
Audio sample formats.
int32_t history[MAX_CHANNELS][512]
int sample_rate
samples per second
main external API structure.
static const float bands[]
static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static void quantize_adpcm(DCAEncContext *c)
static void calc_power(DCAEncContext *c, const int32_t in[2 *256], int32_t power[256])
Describe the class of an AVClass context structure.
static const AVOption options[]
int ff_dcaadpcm_subband_analysis(const DCAADPCMEncContext *s, const int32_t *in, int len, int *diff)
const uint8_t ff_dca_quant_index_sel_nbits[DCA_CODE_BOOKS]
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
int32_t worst_quantization_noise
static int encode_init(AVCodecContext *avctx)
static void fill_in_adpcm_bufer(DCAEncContext *c)
static void quantize_pcm(DCAEncContext *c)
#define DCA_BITALLOC_12_COUNT
static int noise(AVBSFContext *ctx, AVPacket *pkt)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static void subband_transform(DCAEncContext *c, const int32_t *input)
internal math functions header
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
common internal and external API header
channel
Use these values when setting the channel map with ebur128_set_channel().
static void subband_bufer_free(DCAEncContext *c)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
int32_t quant_index_sel[MAX_CHANNELS][DCA_CODE_BOOKS]
int32_t quantized[MAX_CHANNELS][DCAENC_SUBBANDS][SUBBAND_SAMPLES]
int channels
number of audio channels
static int32_t norm__(int64_t a, int bits)
int32_t * subband[MAX_CHANNELS][DCAENC_SUBBANDS]
static const double coeff[2][5]
static const int8_t channel_reorder_nolfe[7][5]
static float add(float src0, float src1)
and forward the result(frame or status change) to the corresponding input.If nothing is possible
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
static enum AVSampleFormat sample_fmts[]
Filter the word “frame” indicates either a video frame or a group of audio samples
static uint32_t set_best_code(uint32_t vlc_bits[DCA_CODE_BOOKS][7], uint32_t clc_bits[DCA_CODE_BOOKS], int32_t res[DCA_CODE_BOOKS])
const int32_t * band_interpolation
int32_t downsampled_lfe[DCA_LFE_SAMPLES]
int32_t peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS]
int32_t bit_allocation_sel[MAX_CHANNELS]
av_cold void ff_dcaadpcm_free(DCAADPCMEncContext *s)
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
#define FFSWAP(type, a, b)
static const AVCodecDefault defaults[]
static const uint8_t lfe_index[7]
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
static const int bit_consumption[27]
const float ff_dca_fir_32bands_perfect[512]
int32_t adpcm_history[MAX_CHANNELS][DCAENC_SUBBANDS][DCA_ADPCM_COEFFS *2]
#define AV_CH_LAYOUT_MONO
static double val(void *priv, double ch)
This structure stores compressed data.
static const AVClass dcaenc_class
void ff_dca_vlc_enc_alloc(PutBitContext *pb, int *values, uint8_t n, uint8_t sel)
int nb_samples
number of audio samples (per channel) described by this frame
static double gammafilter(int i, double f)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int32_t band_interpolation_tab[2][512]
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 layout
static int32_t get_step_size(DCAEncContext *c, int ch, int band)