54 #define MIN_CHANNELS 1 55 #define MAX_CHANNELS 8 56 #define MAX_JS_PAIRS 8 / 2 58 #define JOINT_STEREO 0x12 61 #define SAMPLES_PER_FRAME 1024 64 #define ATRAC3_VLC_BITS 8 110 float temp_buf[1070];
146 for (i = 0; i < 128; i++)
147 FFSWAP(
float, input[i], input[255 - i]);
164 uint32_t *
output = (uint32_t *)out;
166 off = (intptr_t)input & 3;
167 buf = (
const uint32_t *)(input - off);
169 c =
av_be2ne32((0x537F6103U >> (off * 8)) | (0x537F6103U << (32 - (off * 8))));
173 for (i = 0; i < bytes / 4; i++)
174 output[i] = c ^ buf[i];
188 for (i = 0, j = 255; i < 128; i++, j--) {
189 float wi = sin(((i + 0.5) / 256.0 - 0.5) *
M_PI) + 1.0;
190 float wj = sin(((j + 0.5) / 256.0 - 0.5) *
M_PI) + 1.0;
191 float w = 0.5 * (wi * wi + wj * wj);
218 int coding_flag,
int *mantissas,
221 int i,
code, huff_symb;
226 if (coding_flag != 0) {
231 for (i = 0; i < num_codes; i++) {
239 for (i = 0; i < num_codes; i++) {
251 for (i = 0; i < num_codes; i++) {
256 for (i = 0; i < num_codes; i++) {
257 huff_symb =
get_vlc2(gb, spectral_coeff_tab[selector - 1].
table,
273 int num_subbands, coding_mode,
i, j,
first, last, subband_size;
274 int subband_vlc_index[32], sf_index[32];
282 for (i = 0; i <= num_subbands; i++)
283 subband_vlc_index[i] =
get_bits(gb, 3);
286 for (i = 0; i <= num_subbands; i++) {
287 if (subband_vlc_index[i] != 0)
291 for (i = 0; i <= num_subbands; i++) {
295 subband_size = last -
first;
297 if (subband_vlc_index[i] != 0) {
302 mantissas, subband_size);
309 for (j = 0; first < last; first++, j++)
310 output[first] = mantissas[j] * scale_factor;
313 memset(output + first, 0, subband_size *
sizeof(*output));
333 int nb_components, coding_mode_selector, coding_mode;
334 int band_flags[4], mantissa[8];
335 int component_count = 0;
340 if (nb_components == 0)
343 coding_mode_selector =
get_bits(gb, 2);
344 if (coding_mode_selector == 2)
347 coding_mode = coding_mode_selector & 1;
349 for (i = 0; i < nb_components; i++) {
350 int coded_values_per_component, quant_step_index;
352 for (b = 0; b <= num_bands; b++)
355 coded_values_per_component =
get_bits(gb, 3);
358 if (quant_step_index <= 1)
361 if (coding_mode_selector == 3)
364 for (b = 0; b < (num_bands + 1) * 4; b++) {
365 int coded_components;
367 if (band_flags[b >> 2] == 0)
372 for (c = 0; c < coded_components; c++) {
374 int sf_index, coded_values, max_coded_values;
378 if (component_count >= 64)
384 coded_values = coded_values_per_component + 1;
385 coded_values =
FFMIN(max_coded_values, coded_values);
391 mantissa, coded_values);
396 for (m = 0; m < coded_values; m++)
397 cmp->
coef[m] = mantissa[m] * scale_factor;
404 return component_count;
421 for (b = 0; b <= num_bands; b++) {
429 if (j && loc[j] <= loc[j - 1])
436 gain[b].num_points = 0;
452 int i, j, last_pos = -1;
455 for (i = 0; i < num_components; i++) {
456 last_pos =
FFMAX(components[i].
pos + components[i].num_coefs, last_pos);
457 input = components[
i].
coef;
458 output = &spectrum[components[
i].
pos];
460 for (j = 0; j < components[
i].num_coefs; j++)
461 output[j] += input[j];
467 #define INTERPOLATE(old, new, nsample) \ 468 ((old) + (nsample) * 0.125 * ((new) - (old))) 473 int i, nsample, band;
474 float mc1_l, mc1_r, mc2_l, mc2_r;
476 for (i = 0, band = 0; band < 4 * 256; band += 256, i++) {
477 int s1 = prev_code[
i];
478 int s2 = curr_code[
i];
489 for (; nsample < band + 8; nsample++) {
490 float c1 = su1[nsample];
491 float c2 = su2[nsample];
492 c2 = c1 *
INTERPOLATE(mc1_l, mc2_l, nsample - band) +
495 su2[nsample] = c1 * 2.0 -
c2;
502 for (; nsample < band + 256; nsample++) {
503 float c1 = su1[nsample];
504 float c2 = su2[nsample];
505 su1[nsample] = c2 * 2.0;
506 su2[nsample] = (c1 -
c2) * 2.0;
510 for (; nsample < band + 256; nsample++) {
511 float c1 = su1[nsample];
512 float c2 = su2[nsample];
513 su1[nsample] = (c1 +
c2) * 2.0;
514 su2[nsample] = c2 * -2.0;
519 for (; nsample < band + 256; nsample++) {
520 float c1 = su1[nsample];
521 float c2 = su2[nsample];
522 su1[nsample] = c1 +
c2;
523 su2[nsample] = c1 -
c2;
538 ch[0] = (index & 7) / 7.0;
539 ch[1] = sqrt(2 - ch[0] * ch[0]);
541 FFSWAP(
float, ch[0], ch[1]);
551 if (p3[1] != 7 || p3[3] != 7) {
555 for (band = 256; band < 4 * 256; band += 256) {
556 for (nsample = band; nsample < band + 8; nsample++) {
557 su1[nsample] *=
INTERPOLATE(w[0][0], w[0][1], nsample - band);
558 su2[nsample] *=
INTERPOLATE(w[1][0], w[1][1], nsample - band);
560 for(; nsample < band + 256; nsample++) {
561 su1[nsample] *= w[1][0];
562 su2[nsample] *= w[1][1];
578 int channel_num,
int coding_mode)
580 int band,
ret, num_subbands, last_tonal, num_bands;
584 if (coding_mode ==
JOINT_STEREO && (channel_num % 2) == 1) {
619 num_bands =
FFMAX((last_tonal + 256) >> 8, num_bands);
623 for (band = 0; band < 4; band++) {
625 if (band <= num_bands)
634 256, &output[band * 256]);
656 int js_pair, js_block_align;
660 for (ch = 0; ch < avctx->
channels; ch = ch + 2) {
662 js_databuf = databuf + js_pair * js_block_align;
666 js_databuf, js_block_align * 8);
679 for (i = 0; i < js_block_align / 2; i++, ptr1++, ptr2--)
682 const uint8_t *ptr2 = js_databuf + js_block_align - 1;
683 for (i = 0; i < js_block_align; i++)
689 for (i = 4; *ptr1 == 0xF8; i++, ptr1++) {
690 if (i >= js_block_align)
707 for (i = 0; i < 4; i++) {
729 for (i = 0; i < avctx->
channels; i++) {
743 for (i = 0; i < avctx->
channels; i++) {
744 float *p1 = out_samples[
i];
745 float *p2 = p1 + 256;
746 float *p3 = p2 + 256;
747 float *p4 = p3 + 256;
757 int size,
float **out_samples)
766 for (i = 0; i < avctx->
channels; i++) {
777 for (i = 0; i < avctx->
channels; i++) {
778 float *p1 = out_samples[
i];
779 float *p2 = p1 + 256;
780 float *p3 = p2 + 256;
781 float *p4 = p3 + 256;
791 int *got_frame_ptr,
AVPacket *avpkt)
795 int buf_size = avpkt->
size;
800 if (buf_size < avctx->block_align) {
802 "Frame too small (%d bytes). Truncated file?\n", buf_size);
831 int *got_frame_ptr,
AVPacket *avpkt)
862 for (i = 0; i < 7; i++) {
867 &hufftabs[0][0], 2, 1,
878 int version, delay, samples_per_frame, frame_factor;
897 bytestream_get_le16(&edata_ptr));
901 bytestream_get_le16(&edata_ptr));
902 frame_factor = bytestream_get_le16(&edata_ptr);
904 bytestream_get_le16(&edata_ptr));
923 version = bytestream_get_be32(&edata_ptr);
924 samples_per_frame = bytestream_get_be16(&edata_ptr);
925 delay = bytestream_get_be16(&edata_ptr);
948 if (delay != 0x88E) {
993 for (i = 0; i < 4; i++) {
1033 .long_name =
NULL_IF_CONFIG_SMALL(
"ATRAC3 AL (Adaptive TRansform Acoustic Coding 3 Advanced Lossless)"),
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
static void reverse_matrixing(float *su1, float *su2, int *prev_code, int *curr_code)
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
ptrdiff_t const GLvoid * data
uint8_t * decoded_bytes_buffer
data buffers
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static int add_tonal_components(float *spectrum, int num_components, TonalComponent *components)
Combine the tonal band spectrum and regular band spectrum.
static const uint8_t clc_length_tab[8]
static av_cold int init(AVCodecContext *avctx)
#define avpriv_request_sample(...)
#define SAMPLES_PER_FRAME
TonalComponent components[64]
void ff_atrac_iqmf(float *inlo, float *inhi, unsigned int nIn, float *pOut, float *delayBuf, float *temp)
Quadrature mirror synthesis filter.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static void imlt(ATRAC3Context *q, float *input, float *output, int odd_band)
Regular 512 points IMDCT without overlapping, with the exception of the swapping of odd bands caused ...
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
static int get_sbits(GetBitContext *s, int n)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Macro definitions for various function/variable attributes.
int lev_code[7]
level at corresponding control point
float ff_atrac_sf_table[64]
#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
The exact code depends on how similar the blocks are and how related they are to the block
static void channel_weighting(float *su1, float *su2, int *p3)
static float mdct_window[MDCT_SIZE]
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
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats...
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static const int8_t mantissa_clc_tab[4]
static VLC_TYPE atrac3_vlc_table[7 *1<< ATRAC3_VLC_BITS][2]
int matrix_coeff_index_now[MAX_JS_PAIRS][4]
static const float inv_max_quant[8]
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
bitstream reader API header.
int loc_code[7]
location of gain control points
static int atrac3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
static const uint16_t table[]
static int decode_spectrum(GetBitContext *gb, float *output)
Restore the quantized band spectrum coefficients.
static int get_bits_left(GetBitContext *gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int matrix_coeff_index_next[MAX_JS_PAIRS][4]
int flags
AV_CODEC_FLAG_*.
const char * name
Name of the codec implementation.
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Gain compensation context structure.
av_cold void ff_atrac_init_gain_compensation(AtracGCContext *gctx, int id2exp_offset, int loc_scale)
Initialize gain compensation context.
float spectrum[SAMPLES_PER_FRAME]
AVCodec ff_atrac3al_decoder
static const uint16_t subband_tab[33]
static int decode_frame(AVCodecContext *avctx, const uint8_t *databuf, float **out_samples)
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static void get_channel_weights(int index, int flag, float ch[2])
static const int8_t mantissa_vlc_tab[18]
float prev_frame[SAMPLES_PER_FRAME]
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
float imdct_buf[SAMPLES_PER_FRAME]
static int decode_bytes(const uint8_t *input, uint8_t *out, int bytes)
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
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.
static av_always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby, const int size, const int h, int ref_index, int src_index, me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags)
compares a block (either a full macroblock or a partition thereof) against a proposed motion-compensa...
static int decode_gain_control(GetBitContext *gb, GainBlock *block, int num_bands)
Decode gain parameters for the coded bands.
Gain control parameters for one subband.
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
static void read_quant_spectral_coeffs(GetBitContext *gb, int selector, int coding_flag, int *mantissas, int num_codes)
Mantissa decoding.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
main external API structure.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
int coding_mode
stream data
Replacements for frequently missing libm functions.
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
static av_cold int atrac3_decode_close(AVCodecContext *avctx)
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
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.
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
static av_cold void init_imdct_window(void)
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 it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
int num_points
number of gain control points
static av_cold int atrac3_decode_init(AVCodecContext *avctx)
static int atrac3al_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
common internal api header.
int scrambled_stream
extradata
#define INIT_VLC_USE_NEW_STATIC
static VLC spectral_coeff_tab[7]
static int al_decode_frame(AVCodecContext *avctx, const uint8_t *databuf, int size, float **out_samples)
float delay_buf1[46]
qmf delay buffers
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
AVCodec ff_atrac3_decoder
static const float matrix_coeffs[8]
int channels
number of audio channels
static int ff_thread_once(char *control, void(*routine)(void))
VLC_TYPE(* table)[2]
code, bits
#define INTERPOLATE(old, new, nsample)
void ff_atrac_gain_compensation(AtracGCContext *gctx, float *in, float *prev, AtracGainInfo *gc_now, AtracGainInfo *gc_next, int num_samples, float *out)
Apply gain compensation and perform the MDCT overlapping part.
av_cold void ff_atrac_generate_tables(void)
Generate common tables.
static enum AVSampleFormat sample_fmts[]
static av_cold void atrac3_init_static_data(void)
int weighting_delay[MAX_JS_PAIRS][6]
static const uint8_t huff_tab_sizes[7]
#define FFSWAP(type, a, b)
int matrix_coeff_index_prev[MAX_JS_PAIRS][4]
joint-stereo related variables
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 uint8_t atrac3_hufftabs[][2]
ATRAC3 AKA RealAudio 8 compatible decoder data.
uint8_t ** extended_data
pointers to the data planes/channels.
This structure stores compressed data.
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 int decode_tonal_components(GetBitContext *gb, TonalComponent *components, int num_bands)
Restore the quantized tonal components.
static int decode_channel_sound_unit(ATRAC3Context *q, GetBitContext *gb, ChannelUnit *snd, float *output, int channel_num, int coding_mode)
Decode a Sound Unit.
void * av_mallocz_array(size_t nmemb, size_t size)