FFmpeg
atrac1.c
Go to the documentation of this file.
1 /*
2  * ATRAC1 compatible decoder
3  * Copyright (c) 2009 Maxim Poliakovski
4  * Copyright (c) 2009 Benjamin Larsson
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * ATRAC1 compatible decoder.
26  * This decoder handles raw ATRAC1 data and probably SDDS data.
27  */
28 
29 /* Many thanks to Tim Craig for all the help! */
30 
31 #include <math.h>
32 #include <stddef.h>
33 #include <stdio.h>
34 
35 #include "libavutil/float_dsp.h"
36 #include "libavutil/mem_internal.h"
37 
38 #include "avcodec.h"
39 #include "get_bits.h"
40 #include "fft.h"
41 #include "internal.h"
42 #include "sinewin.h"
43 
44 #include "atrac.h"
45 #include "atrac1data.h"
46 
47 #define AT1_MAX_BFU 52 ///< max number of block floating units in a sound unit
48 #define AT1_SU_SIZE 212 ///< number of bytes in a sound unit
49 #define AT1_SU_SAMPLES 512 ///< number of samples in a sound unit
50 #define AT1_FRAME_SIZE AT1_SU_SIZE * 2
51 #define AT1_SU_MAX_BITS AT1_SU_SIZE * 8
52 #define AT1_MAX_CHANNELS 2
53 
54 #define AT1_QMF_BANDS 3
55 #define IDX_LOW_BAND 0
56 #define IDX_MID_BAND 1
57 #define IDX_HIGH_BAND 2
58 
59 /**
60  * Sound unit struct, one unit is used per channel
61  */
62 typedef struct AT1SUCtx {
63  int log2_block_count[AT1_QMF_BANDS]; ///< log2 number of blocks in a band
64  int num_bfus; ///< number of Block Floating Units
65  float* spectrum[2];
66  DECLARE_ALIGNED(32, float, spec1)[AT1_SU_SAMPLES]; ///< mdct buffer
67  DECLARE_ALIGNED(32, float, spec2)[AT1_SU_SAMPLES]; ///< mdct buffer
68  DECLARE_ALIGNED(32, float, fst_qmf_delay)[46]; ///< delay line for the 1st stacked QMF filter
69  DECLARE_ALIGNED(32, float, snd_qmf_delay)[46]; ///< delay line for the 2nd stacked QMF filter
70  DECLARE_ALIGNED(32, float, last_qmf_delay)[256+39]; ///< delay line for the last stacked QMF filter
71 } AT1SUCtx;
72 
73 /**
74  * The atrac1 context, holds all needed parameters for decoding
75  */
76 typedef struct AT1Ctx {
77  AT1SUCtx SUs[AT1_MAX_CHANNELS]; ///< channel sound unit
78  DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES]; ///< the mdct spectrum buffer
79 
80  DECLARE_ALIGNED(32, float, low)[256];
81  DECLARE_ALIGNED(32, float, mid)[256];
82  DECLARE_ALIGNED(32, float, high)[512];
83  float* bands[3];
85  void (*vector_fmul_window)(float *dst, const float *src0,
86  const float *src1, const float *win, int len);
87 } AT1Ctx;
88 
89 /** size of the transform in samples in the long mode for each QMF band */
90 static const uint16_t samples_per_band[3] = {128, 128, 256};
91 static const uint8_t mdct_long_nbits[3] = {7, 7, 8};
92 
93 
94 static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits,
95  int rev_spec)
96 {
97  FFTContext* mdct_context = &q->mdct_ctx[nbits - 5 - (nbits > 6)];
98  int transf_size = 1 << nbits;
99 
100  if (rev_spec) {
101  int i;
102  for (i = 0; i < transf_size / 2; i++)
103  FFSWAP(float, spec[i], spec[transf_size - 1 - i]);
104  }
105  mdct_context->imdct_half(mdct_context, out, spec);
106 }
107 
108 
110 {
111  int band_num, band_samples, log2_block_count, nbits, num_blocks, block_size;
112  unsigned int start_pos, ref_pos = 0, pos = 0;
113 
114  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
115  float *prev_buf;
116  int j;
117 
118  band_samples = samples_per_band[band_num];
119  log2_block_count = su->log2_block_count[band_num];
120 
121  /* number of mdct blocks in the current QMF band: 1 - for long mode */
122  /* 4 for short mode(low/middle bands) and 8 for short mode(high band)*/
123  num_blocks = 1 << log2_block_count;
124 
125  if (num_blocks == 1) {
126  /* mdct block size in samples: 128 (long mode, low & mid bands), */
127  /* 256 (long mode, high band) and 32 (short mode, all bands) */
128  block_size = band_samples >> log2_block_count;
129 
130  /* calc transform size in bits according to the block_size_mode */
131  nbits = mdct_long_nbits[band_num] - log2_block_count;
132 
133  if (nbits != 5 && nbits != 7 && nbits != 8)
134  return AVERROR_INVALIDDATA;
135  } else {
136  block_size = 32;
137  nbits = 5;
138  }
139 
140  start_pos = 0;
141  prev_buf = &su->spectrum[1][ref_pos + band_samples - 16];
142  for (j=0; j < num_blocks; j++) {
143  at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);
144 
145  /* overlap and window */
146  q->vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
147  &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
148 
149  prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];
150  start_pos += block_size;
151  pos += block_size;
152  }
153 
154  if (num_blocks == 1)
155  memcpy(q->bands[band_num] + 32, &su->spectrum[0][ref_pos + 16], 240 * sizeof(float));
156 
157  ref_pos += band_samples;
158  }
159 
160  /* Swap buffers so the mdct overlap works */
161  FFSWAP(float*, su->spectrum[0], su->spectrum[1]);
162 
163  return 0;
164 }
165 
166 /**
167  * Parse the block size mode byte
168  */
169 
170 static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])
171 {
172  int log2_block_count_tmp, i;
173 
174  for (i = 0; i < 2; i++) {
175  /* low and mid band */
176  log2_block_count_tmp = get_bits(gb, 2);
177  if (log2_block_count_tmp & 1)
178  return AVERROR_INVALIDDATA;
179  log2_block_cnt[i] = 2 - log2_block_count_tmp;
180  }
181 
182  /* high band */
183  log2_block_count_tmp = get_bits(gb, 2);
184  if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)
185  return AVERROR_INVALIDDATA;
186  log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;
187 
188  skip_bits(gb, 2);
189  return 0;
190 }
191 
192 
194  float spec[AT1_SU_SAMPLES])
195 {
196  int bits_used, band_num, bfu_num, i;
197  uint8_t idwls[AT1_MAX_BFU]; ///< the word length indexes for each BFU
198  uint8_t idsfs[AT1_MAX_BFU]; ///< the scalefactor indexes for each BFU
199 
200  /* parse the info byte (2nd byte) telling how much BFUs were coded */
201  su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];
202 
203  /* calc number of consumed bits:
204  num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)
205  + info_byte_copy(8bits) + log2_block_count_copy(8bits) */
206  bits_used = su->num_bfus * 10 + 32 +
207  bfu_amount_tab2[get_bits(gb, 2)] +
208  (bfu_amount_tab3[get_bits(gb, 3)] << 1);
209 
210  /* get word length index (idwl) for each BFU */
211  for (i = 0; i < su->num_bfus; i++)
212  idwls[i] = get_bits(gb, 4);
213 
214  /* get scalefactor index (idsf) for each BFU */
215  for (i = 0; i < su->num_bfus; i++)
216  idsfs[i] = get_bits(gb, 6);
217 
218  /* zero idwl/idsf for empty BFUs */
219  for (i = su->num_bfus; i < AT1_MAX_BFU; i++)
220  idwls[i] = idsfs[i] = 0;
221 
222  /* read in the spectral data and reconstruct MDCT spectrum of this channel */
223  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
224  for (bfu_num = bfu_bands_t[band_num]; bfu_num < bfu_bands_t[band_num+1]; bfu_num++) {
225  int pos;
226 
227  int num_specs = specs_per_bfu[bfu_num];
228  int word_len = !!idwls[bfu_num] + idwls[bfu_num];
229  float scale_factor = ff_atrac_sf_table[idsfs[bfu_num]];
230  bits_used += word_len * num_specs; /* add number of bits consumed by current BFU */
231 
232  /* check for bitstream overflow */
233  if (bits_used > AT1_SU_MAX_BITS)
234  return AVERROR_INVALIDDATA;
235 
236  /* get the position of the 1st spec according to the block size mode */
237  pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];
238 
239  if (word_len) {
240  float max_quant = 1.0 / (float)((1 << (word_len - 1)) - 1);
241 
242  for (i = 0; i < num_specs; i++) {
243  /* read in a quantized spec and convert it to
244  * signed int and then inverse quantization
245  */
246  spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;
247  }
248  } else { /* word_len = 0 -> empty BFU, zero all specs in the empty BFU */
249  memset(&spec[pos], 0, num_specs * sizeof(float));
250  }
251  }
252  }
253 
254  return 0;
255 }
256 
257 
258 static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx* su, float *pOut)
259 {
260  float temp[256];
261  float iqmf_temp[512 + 46];
262 
263  /* combine low and middle bands */
264  ff_atrac_iqmf(q->bands[0], q->bands[1], 128, temp, su->fst_qmf_delay, iqmf_temp);
265 
266  /* delay the signal of the high band by 39 samples */
267  memcpy( su->last_qmf_delay, &su->last_qmf_delay[256], sizeof(float) * 39);
268  memcpy(&su->last_qmf_delay[39], q->bands[2], sizeof(float) * 256);
269 
270  /* combine (low + middle) and high bands */
271  ff_atrac_iqmf(temp, su->last_qmf_delay, 256, pOut, su->snd_qmf_delay, iqmf_temp);
272 }
273 
274 
275 static int atrac1_decode_frame(AVCodecContext *avctx, void *data,
276  int *got_frame_ptr, AVPacket *avpkt)
277 {
278  AVFrame *frame = data;
279  const uint8_t *buf = avpkt->data;
280  int buf_size = avpkt->size;
281  AT1Ctx *q = avctx->priv_data;
282  int ch, ret;
283  GetBitContext gb;
284 
285 
286  if (buf_size < 212 * avctx->channels) {
287  av_log(avctx, AV_LOG_ERROR, "Not enough data to decode!\n");
288  return AVERROR_INVALIDDATA;
289  }
290 
291  /* get output buffer */
292  frame->nb_samples = AT1_SU_SAMPLES;
293  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
294  return ret;
295 
296  for (ch = 0; ch < avctx->channels; ch++) {
297  AT1SUCtx* su = &q->SUs[ch];
298 
299  init_get_bits(&gb, &buf[212 * ch], 212 * 8);
300 
301  /* parse block_size_mode, 1st byte */
302  ret = at1_parse_bsm(&gb, su->log2_block_count);
303  if (ret < 0)
304  return ret;
305 
306  ret = at1_unpack_dequant(&gb, su, q->spec);
307  if (ret < 0)
308  return ret;
309 
310  ret = at1_imdct_block(su, q);
311  if (ret < 0)
312  return ret;
313  at1_subband_synthesis(q, su, (float *)frame->extended_data[ch]);
314  }
315 
316  *got_frame_ptr = 1;
317 
318  return avctx->block_align;
319 }
320 
321 
323 {
324  AT1Ctx *q = avctx->priv_data;
325 
326  ff_mdct_end(&q->mdct_ctx[0]);
327  ff_mdct_end(&q->mdct_ctx[1]);
328  ff_mdct_end(&q->mdct_ctx[2]);
329 
330  return 0;
331 }
332 
333 
335 {
336  AT1Ctx *q = avctx->priv_data;
337  AVFloatDSPContext *fdsp;
338  int ret;
339 
341 
342  if (avctx->channels < 1 || avctx->channels > AT1_MAX_CHANNELS) {
343  av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",
344  avctx->channels);
345  return AVERROR(EINVAL);
346  }
347 
348  if (avctx->block_align <= 0) {
349  av_log(avctx, AV_LOG_ERROR, "Unsupported block align.");
350  return AVERROR_PATCHWELCOME;
351  }
352 
353  /* Init the mdct transforms */
354  if ((ret = ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15))) ||
355  (ret = ff_mdct_init(&q->mdct_ctx[1], 8, 1, -1.0/ (1 << 15))) ||
356  (ret = ff_mdct_init(&q->mdct_ctx[2], 9, 1, -1.0/ (1 << 15)))) {
357  av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
358  return ret;
359  }
360 
362 
364 
366  if (!fdsp)
367  return AVERROR(ENOMEM);
369  av_free(fdsp);
370 
371  q->bands[0] = q->low;
372  q->bands[1] = q->mid;
373  q->bands[2] = q->high;
374 
375  /* Prepare the mdct overlap buffers */
376  q->SUs[0].spectrum[0] = q->SUs[0].spec1;
377  q->SUs[0].spectrum[1] = q->SUs[0].spec2;
378  q->SUs[1].spectrum[0] = q->SUs[1].spec1;
379  q->SUs[1].spectrum[1] = q->SUs[1].spec2;
380 
381  return 0;
382 }
383 
384 
386  .name = "atrac1",
387  .long_name = NULL_IF_CONFIG_SMALL("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
388  .type = AVMEDIA_TYPE_AUDIO,
389  .id = AV_CODEC_ID_ATRAC1,
390  .priv_data_size = sizeof(AT1Ctx),
392  .close = atrac1_decode_end,
394  .capabilities = AV_CODEC_CAP_DR1,
395  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
398 };
AVCodec
AVCodec.
Definition: codec.h:197
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
mdct_long_nbits
static const uint8_t mdct_long_nbits[3]
Definition: atrac1.c:91
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: internal.h:42
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AT1_MAX_BFU
#define AT1_MAX_BFU
max number of block floating units in a sound unit
Definition: atrac1.c:47
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
AT1_SU_SAMPLES
#define AT1_SU_SAMPLES
number of samples in a sound unit
Definition: atrac1.c:49
mem_internal.h
bfu_bands_t
static const uint8_t bfu_bands_t[4]
number of BFUs in each QMF band
Definition: atrac1data.h:38
out
FILE * out
Definition: movenc.c:54
atrac1data.h
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
AT1_QMF_BANDS
#define AT1_QMF_BANDS
Definition: atrac1.c:54
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
AT1Ctx::spec
float spec[AT1_SU_SAMPLES]
the mdct spectrum buffer
Definition: atrac1.c:78
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
data
const char data[16]
Definition: mxf.c:143
AT1SUCtx::num_bfus
int num_bfus
number of Block Floating Units
Definition: atrac1.c:64
at1_imdct
static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits, int rev_spec)
Definition: atrac1.c:94
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:161
AT1Ctx
The atrac1 context, holds all needed parameters for decoding.
Definition: atrac1.c:76
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
AT1SUCtx::spec2
float spec2[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:67
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
AT1SUCtx
Sound unit struct, one unit is used per channel.
Definition: atrac1.c:62
IDX_HIGH_BAND
#define IDX_HIGH_BAND
Definition: atrac1.c:57
at1_imdct_block
static int at1_imdct_block(AT1SUCtx *su, AT1Ctx *q)
Definition: atrac1.c:109
su
#define su(width, name)
Definition: cbs_av1.c:554
GetBitContext
Definition: get_bits.h:62
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:459
AT1Ctx::vector_fmul_window
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Definition: atrac1.c:85
AT1SUCtx::fst_qmf_delay
float fst_qmf_delay[46]
delay line for the 1st stacked QMF filter
Definition: atrac1.c:68
bfu_start_long
static const uint16_t bfu_start_long[52]
start position of each BFU in the MDCT spectrum for the long mode
Definition: atrac1data.h:51
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
atrac1_decode_frame
static int atrac1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac1.c:275
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
atrac.h
bfu_start_short
static const uint16_t bfu_start_short[52]
start position of each BFU in the MDCT spectrum for the short mode
Definition: atrac1data.h:58
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AT1_SU_MAX_BITS
#define AT1_SU_MAX_BITS
Definition: atrac1.c:51
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:360
channels
channels
Definition: aptx.h:33
get_bits.h
at1_unpack_dequant
static int at1_unpack_dequant(GetBitContext *gb, AT1SUCtx *su, float spec[AT1_SU_SAMPLES])
Definition: atrac1.c:193
bfu_amount_tab1
static const uint8_t bfu_amount_tab1[8]
Definition: atrac1data.h:33
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AT1Ctx::SUs
AT1SUCtx SUs[AT1_MAX_CHANNELS]
channel sound unit
Definition: atrac1.c:77
ff_atrac_sf_table
float ff_atrac_sf_table[64]
Definition: atrac.c:36
AT1_MAX_CHANNELS
#define AT1_MAX_CHANNELS
Definition: atrac1.c:52
float_dsp.h
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:103
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1648
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:374
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:116
AT1Ctx::low
float low[256]
Definition: atrac1.c:80
at1_parse_bsm
static int at1_parse_bsm(GetBitContext *gb, int log2_block_cnt[AT1_QMF_BANDS])
Parse the block size mode byte.
Definition: atrac1.c:170
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:996
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:162
AT1SUCtx::spec1
float spec1[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:66
bfu_amount_tab2
static const uint8_t bfu_amount_tab2[4]
Definition: atrac1data.h:34
AVFloatDSPContext
Definition: float_dsp.h:24
AT1SUCtx::log2_block_count
int log2_block_count[AT1_QMF_BANDS]
log2 number of blocks in a band
Definition: atrac1.c:63
AT1SUCtx::spectrum
float * spectrum[2]
Definition: atrac1.c:65
sinewin.h
ff_atrac_generate_tables
av_cold void ff_atrac_generate_tables(void)
Generate common tables.
Definition: atrac.c:61
AT1Ctx::high
float high[512]
Definition: atrac1.c:82
specs_per_bfu
static const uint8_t specs_per_bfu[52]
number of spectral lines in each BFU block floating unit = group of spectral frequencies having the s...
Definition: atrac1data.h:44
src0
#define src0
Definition: h264pred.c:139
bfu_amount_tab3
static const uint8_t bfu_amount_tab3[8]
Definition: atrac1data.h:35
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:989
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
src1
#define src1
Definition: h264pred.c:140
AV_CODEC_ID_ATRAC1
@ AV_CODEC_ID_ATRAC1
Definition: codec_id.h:468
FFTContext
Definition: fft.h:83
i
int i
Definition: input.c:406
AT1SUCtx::snd_qmf_delay
float snd_qmf_delay[46]
delay line for the 2nd stacked QMF filter
Definition: atrac1.c:69
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: internal.h:50
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
len
int len
Definition: vorbis_enc_data.h:426
atrac1_decode_init
static av_cold int atrac1_decode_init(AVCodecContext *avctx)
Definition: atrac1.c:334
avcodec.h
atrac1_decode_end
static av_cold int atrac1_decode_end(AVCodecContext *avctx)
Definition: atrac1.c:322
ret
ret
Definition: filter_design.txt:187
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1025
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
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
AT1SUCtx::last_qmf_delay
float last_qmf_delay[256+39]
delay line for the last stacked QMF filter
Definition: atrac1.c:70
AT1Ctx::mid
float mid[256]
Definition: atrac1.c:81
pos
unsigned int pos
Definition: spdifenc.c:412
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:379
ff_init_ff_sine_windows
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
Definition: sinewin_tablegen.h:101
temp
else temp
Definition: vf_mcdeint.c:259
ff_atrac1_decoder
const AVCodec ff_atrac1_decoder
Definition: atrac1.c:385
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:268
AVFloatDSPContext::vector_fmul_window
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AVPacket
This structure stores compressed data.
Definition: packet.h:350
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
AT1Ctx::mdct_ctx
FFTContext mdct_ctx[3]
Definition: atrac1.c:84
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
at1_subband_synthesis
static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx *su, float *pOut)
Definition: atrac1.c:258
AT1Ctx::bands
float * bands[3]
Definition: atrac1.c:83
ff_atrac_iqmf
void ff_atrac_iqmf(float *inlo, float *inhi, unsigned int nIn, float *pOut, float *delayBuf, float *temp)
Quadrature mirror synthesis filter.
Definition: atrac.c:128
samples_per_band
static const uint16_t samples_per_band[3]
size of the transform in samples in the long mode for each QMF band
Definition: atrac1.c:90