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 "codec_internal.h"
40 #include "get_bits.h"
41 #include "fft.h"
42 #include "internal.h"
43 #include "sinewin.h"
44 
45 #include "atrac.h"
46 #include "atrac1data.h"
47 
48 #define AT1_MAX_BFU 52 ///< max number of block floating units in a sound unit
49 #define AT1_SU_SIZE 212 ///< number of bytes in a sound unit
50 #define AT1_SU_SAMPLES 512 ///< number of samples in a sound unit
51 #define AT1_FRAME_SIZE AT1_SU_SIZE * 2
52 #define AT1_SU_MAX_BITS AT1_SU_SIZE * 8
53 #define AT1_MAX_CHANNELS 2
54 
55 #define AT1_QMF_BANDS 3
56 #define IDX_LOW_BAND 0
57 #define IDX_MID_BAND 1
58 #define IDX_HIGH_BAND 2
59 
60 /**
61  * Sound unit struct, one unit is used per channel
62  */
63 typedef struct AT1SUCtx {
64  int log2_block_count[AT1_QMF_BANDS]; ///< log2 number of blocks in a band
65  int num_bfus; ///< number of Block Floating Units
66  float* spectrum[2];
67  DECLARE_ALIGNED(32, float, spec1)[AT1_SU_SAMPLES]; ///< mdct buffer
68  DECLARE_ALIGNED(32, float, spec2)[AT1_SU_SAMPLES]; ///< mdct buffer
69  DECLARE_ALIGNED(32, float, fst_qmf_delay)[46]; ///< delay line for the 1st stacked QMF filter
70  DECLARE_ALIGNED(32, float, snd_qmf_delay)[46]; ///< delay line for the 2nd stacked QMF filter
71  DECLARE_ALIGNED(32, float, last_qmf_delay)[256+39]; ///< delay line for the last stacked QMF filter
72 } AT1SUCtx;
73 
74 /**
75  * The atrac1 context, holds all needed parameters for decoding
76  */
77 typedef struct AT1Ctx {
78  AT1SUCtx SUs[AT1_MAX_CHANNELS]; ///< channel sound unit
79  DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES]; ///< the mdct spectrum buffer
80 
81  DECLARE_ALIGNED(32, float, low)[256];
82  DECLARE_ALIGNED(32, float, mid)[256];
83  DECLARE_ALIGNED(32, float, high)[512];
84  float* bands[3];
86  void (*vector_fmul_window)(float *dst, const float *src0,
87  const float *src1, const float *win, int len);
88 } AT1Ctx;
89 
90 /** size of the transform in samples in the long mode for each QMF band */
91 static const uint16_t samples_per_band[3] = {128, 128, 256};
92 static const uint8_t mdct_long_nbits[3] = {7, 7, 8};
93 
94 
95 static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits,
96  int rev_spec)
97 {
98  FFTContext* mdct_context = &q->mdct_ctx[nbits - 5 - (nbits > 6)];
99  int transf_size = 1 << nbits;
100 
101  if (rev_spec) {
102  int i;
103  for (i = 0; i < transf_size / 2; i++)
104  FFSWAP(float, spec[i], spec[transf_size - 1 - i]);
105  }
106  mdct_context->imdct_half(mdct_context, out, spec);
107 }
108 
109 
111 {
112  int band_num, band_samples, log2_block_count, nbits, num_blocks, block_size;
113  unsigned int start_pos, ref_pos = 0, pos = 0;
114 
115  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
116  float *prev_buf;
117  int j;
118 
119  band_samples = samples_per_band[band_num];
120  log2_block_count = su->log2_block_count[band_num];
121 
122  /* number of mdct blocks in the current QMF band: 1 - for long mode */
123  /* 4 for short mode(low/middle bands) and 8 for short mode(high band)*/
124  num_blocks = 1 << log2_block_count;
125 
126  if (num_blocks == 1) {
127  /* mdct block size in samples: 128 (long mode, low & mid bands), */
128  /* 256 (long mode, high band) and 32 (short mode, all bands) */
129  block_size = band_samples >> log2_block_count;
130 
131  /* calc transform size in bits according to the block_size_mode */
132  nbits = mdct_long_nbits[band_num] - log2_block_count;
133 
134  if (nbits != 5 && nbits != 7 && nbits != 8)
135  return AVERROR_INVALIDDATA;
136  } else {
137  block_size = 32;
138  nbits = 5;
139  }
140 
141  start_pos = 0;
142  prev_buf = &su->spectrum[1][ref_pos + band_samples - 16];
143  for (j=0; j < num_blocks; j++) {
144  at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);
145 
146  /* overlap and window */
147  q->vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
148  &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
149 
150  prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];
151  start_pos += block_size;
152  pos += block_size;
153  }
154 
155  if (num_blocks == 1)
156  memcpy(q->bands[band_num] + 32, &su->spectrum[0][ref_pos + 16], 240 * sizeof(float));
157 
158  ref_pos += band_samples;
159  }
160 
161  /* Swap buffers so the mdct overlap works */
162  FFSWAP(float*, su->spectrum[0], su->spectrum[1]);
163 
164  return 0;
165 }
166 
167 /**
168  * Parse the block size mode byte
169  */
170 
171 static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])
172 {
173  int log2_block_count_tmp, i;
174 
175  for (i = 0; i < 2; i++) {
176  /* low and mid band */
177  log2_block_count_tmp = get_bits(gb, 2);
178  if (log2_block_count_tmp & 1)
179  return AVERROR_INVALIDDATA;
180  log2_block_cnt[i] = 2 - log2_block_count_tmp;
181  }
182 
183  /* high band */
184  log2_block_count_tmp = get_bits(gb, 2);
185  if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)
186  return AVERROR_INVALIDDATA;
187  log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;
188 
189  skip_bits(gb, 2);
190  return 0;
191 }
192 
193 
195  float spec[AT1_SU_SAMPLES])
196 {
197  int bits_used, band_num, bfu_num, i;
198  uint8_t idwls[AT1_MAX_BFU]; ///< the word length indexes for each BFU
199  uint8_t idsfs[AT1_MAX_BFU]; ///< the scalefactor indexes for each BFU
200 
201  /* parse the info byte (2nd byte) telling how much BFUs were coded */
202  su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];
203 
204  /* calc number of consumed bits:
205  num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)
206  + info_byte_copy(8bits) + log2_block_count_copy(8bits) */
207  bits_used = su->num_bfus * 10 + 32 +
208  bfu_amount_tab2[get_bits(gb, 2)] +
209  (bfu_amount_tab3[get_bits(gb, 3)] << 1);
210 
211  /* get word length index (idwl) for each BFU */
212  for (i = 0; i < su->num_bfus; i++)
213  idwls[i] = get_bits(gb, 4);
214 
215  /* get scalefactor index (idsf) for each BFU */
216  for (i = 0; i < su->num_bfus; i++)
217  idsfs[i] = get_bits(gb, 6);
218 
219  /* zero idwl/idsf for empty BFUs */
220  for (i = su->num_bfus; i < AT1_MAX_BFU; i++)
221  idwls[i] = idsfs[i] = 0;
222 
223  /* read in the spectral data and reconstruct MDCT spectrum of this channel */
224  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
225  for (bfu_num = bfu_bands_t[band_num]; bfu_num < bfu_bands_t[band_num+1]; bfu_num++) {
226  int pos;
227 
228  int num_specs = specs_per_bfu[bfu_num];
229  int word_len = !!idwls[bfu_num] + idwls[bfu_num];
230  float scale_factor = ff_atrac_sf_table[idsfs[bfu_num]];
231  bits_used += word_len * num_specs; /* add number of bits consumed by current BFU */
232 
233  /* check for bitstream overflow */
234  if (bits_used > AT1_SU_MAX_BITS)
235  return AVERROR_INVALIDDATA;
236 
237  /* get the position of the 1st spec according to the block size mode */
238  pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];
239 
240  if (word_len) {
241  float max_quant = 1.0 / (float)((1 << (word_len - 1)) - 1);
242 
243  for (i = 0; i < num_specs; i++) {
244  /* read in a quantized spec and convert it to
245  * signed int and then inverse quantization
246  */
247  spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;
248  }
249  } else { /* word_len = 0 -> empty BFU, zero all specs in the empty BFU */
250  memset(&spec[pos], 0, num_specs * sizeof(float));
251  }
252  }
253  }
254 
255  return 0;
256 }
257 
258 
259 static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx* su, float *pOut)
260 {
261  float temp[256];
262  float iqmf_temp[512 + 46];
263 
264  /* combine low and middle bands */
265  ff_atrac_iqmf(q->bands[0], q->bands[1], 128, temp, su->fst_qmf_delay, iqmf_temp);
266 
267  /* delay the signal of the high band by 39 samples */
268  memcpy( su->last_qmf_delay, &su->last_qmf_delay[256], sizeof(float) * 39);
269  memcpy(&su->last_qmf_delay[39], q->bands[2], sizeof(float) * 256);
270 
271  /* combine (low + middle) and high bands */
272  ff_atrac_iqmf(temp, su->last_qmf_delay, 256, pOut, su->snd_qmf_delay, iqmf_temp);
273 }
274 
275 
277  int *got_frame_ptr, AVPacket *avpkt)
278 {
279  const uint8_t *buf = avpkt->data;
280  int buf_size = avpkt->size;
281  AT1Ctx *q = avctx->priv_data;
282  int channels = avctx->ch_layout.nb_channels;
283  int ch, ret;
284  GetBitContext gb;
285 
286 
287  if (buf_size < 212 * channels) {
288  av_log(avctx, AV_LOG_ERROR, "Not enough data to decode!\n");
289  return AVERROR_INVALIDDATA;
290  }
291 
292  /* get output buffer */
293  frame->nb_samples = AT1_SU_SAMPLES;
294  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
295  return ret;
296 
297  for (ch = 0; ch < channels; ch++) {
298  AT1SUCtx* su = &q->SUs[ch];
299 
300  init_get_bits(&gb, &buf[212 * ch], 212 * 8);
301 
302  /* parse block_size_mode, 1st byte */
303  ret = at1_parse_bsm(&gb, su->log2_block_count);
304  if (ret < 0)
305  return ret;
306 
307  ret = at1_unpack_dequant(&gb, su, q->spec);
308  if (ret < 0)
309  return ret;
310 
311  ret = at1_imdct_block(su, q);
312  if (ret < 0)
313  return ret;
314  at1_subband_synthesis(q, su, (float *)frame->extended_data[ch]);
315  }
316 
317  *got_frame_ptr = 1;
318 
319  return avctx->block_align;
320 }
321 
322 
324 {
325  AT1Ctx *q = avctx->priv_data;
326 
327  ff_mdct_end(&q->mdct_ctx[0]);
328  ff_mdct_end(&q->mdct_ctx[1]);
329  ff_mdct_end(&q->mdct_ctx[2]);
330 
331  return 0;
332 }
333 
334 
336 {
337  AT1Ctx *q = avctx->priv_data;
338  AVFloatDSPContext *fdsp;
339  int channels = avctx->ch_layout.nb_channels;
340  int ret;
341 
343 
345  av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",
346  channels);
347  return AVERROR(EINVAL);
348  }
349 
350  if (avctx->block_align <= 0) {
351  av_log(avctx, AV_LOG_ERROR, "Unsupported block align.");
352  return AVERROR_PATCHWELCOME;
353  }
354 
355  /* Init the mdct transforms */
356  if ((ret = ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15))) ||
357  (ret = ff_mdct_init(&q->mdct_ctx[1], 8, 1, -1.0/ (1 << 15))) ||
358  (ret = ff_mdct_init(&q->mdct_ctx[2], 9, 1, -1.0/ (1 << 15)))) {
359  av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
360  return ret;
361  }
362 
364 
366 
368  if (!fdsp)
369  return AVERROR(ENOMEM);
371  av_free(fdsp);
372 
373  q->bands[0] = q->low;
374  q->bands[1] = q->mid;
375  q->bands[2] = q->high;
376 
377  /* Prepare the mdct overlap buffers */
378  q->SUs[0].spectrum[0] = q->SUs[0].spec1;
379  q->SUs[0].spectrum[1] = q->SUs[0].spec2;
380  q->SUs[1].spectrum[0] = q->SUs[1].spec1;
381  q->SUs[1].spectrum[1] = q->SUs[1].spec2;
382 
383  return 0;
384 }
385 
386 
388  .p.name = "atrac1",
389  .p.long_name = NULL_IF_CONFIG_SMALL("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
390  .p.type = AVMEDIA_TYPE_AUDIO,
391  .p.id = AV_CODEC_ID_ATRAC1,
392  .priv_data_size = sizeof(AT1Ctx),
394  .close = atrac1_decode_end,
396  .p.capabilities = AV_CODEC_CAP_DR1,
397  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
400 };
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
mdct_long_nbits
static const uint8_t mdct_long_nbits[3]
Definition: atrac1.c:92
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:39
AT1_MAX_BFU
#define AT1_MAX_BFU
max number of block floating units in a sound unit
Definition: atrac1.c:48
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:50
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
src1
const pixel * src1
Definition: h264pred_template.c:421
AT1_QMF_BANDS
#define AT1_QMF_BANDS
Definition: atrac1.c:55
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AT1Ctx::spec
float spec[AT1_SU_SAMPLES]
the mdct spectrum buffer
Definition: atrac1.c:79
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
AT1SUCtx::num_bfus
int num_bfus
number of Block Floating Units
Definition: atrac1.c:65
at1_imdct
static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits, int rev_spec)
Definition: atrac1.c:95
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:153
FFCodec
Definition: codec_internal.h:112
AT1Ctx
The atrac1 context, holds all needed parameters for decoding.
Definition: atrac1.c:77
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
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
init
static int init
Definition: av_tx.c:47
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:68
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:63
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
IDX_HIGH_BAND
#define IDX_HIGH_BAND
Definition: atrac1.c:58
at1_imdct_block
static int at1_imdct_block(AT1SUCtx *su, AT1Ctx *q)
Definition: atrac1.c:110
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
su
#define su(width, name)
Definition: cbs_av1.c:554
ff_atrac1_decoder
const FFCodec ff_atrac1_decoder
Definition: atrac1.c:387
GetBitContext
Definition: get_bits.h:62
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:469
AT1Ctx::vector_fmul_window
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Definition: atrac1.c:86
AT1SUCtx::fst_qmf_delay
float fst_qmf_delay[46]
delay line for the 1st stacked QMF filter
Definition: atrac1.c:69
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
float
float
Definition: af_crystalizer.c:122
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
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:52
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:360
channels
channels
Definition: aptx.h:32
get_bits.h
at1_unpack_dequant
static int at1_unpack_dequant(GetBitContext *gb, AT1SUCtx *su, float spec[AT1_SU_SAMPLES])
Definition: atrac1.c:194
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:78
ff_atrac_sf_table
float ff_atrac_sf_table[64]
Definition: atrac.c:36
AT1_MAX_CHANNELS
#define AT1_MAX_CHANNELS
Definition: atrac1.c:53
float_dsp.h
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:95
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
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
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:117
codec_internal.h
AT1Ctx::low
float low[256]
Definition: atrac1.c:81
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:171
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1014
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:154
AT1SUCtx::spec1
float spec1[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:67
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:64
AT1SUCtx::spectrum
float * spectrum[2]
Definition: atrac1.c:66
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:83
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
bfu_amount_tab3
static const uint8_t bfu_amount_tab3[8]
Definition: atrac1data.h:35
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
AV_CODEC_ID_ATRAC1
@ AV_CODEC_ID_ATRAC1
Definition: codec_id.h:472
FFTContext
Definition: fft.h:75
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AT1SUCtx::snd_qmf_delay
float snd_qmf_delay[46]
delay line for the 2nd stacked QMF filter
Definition: atrac1.c:70
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
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: codec_internal.h:31
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
len
int len
Definition: vorbis_enc_data.h:426
atrac1_decode_init
static av_cold int atrac1_decode_init(AVCodecContext *avctx)
Definition: atrac1.c:335
avcodec.h
atrac1_decode_end
static av_cold int atrac1_decode_end(AVCodecContext *avctx)
Definition: atrac1.c:323
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:1043
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:71
AT1Ctx::mid
float mid[256]
Definition: atrac1.c:82
pos
unsigned int pos
Definition: spdifenc.c:412
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:389
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:248
src0
const pixel *const src0
Definition: h264pred_template.c:420
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:278
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:33
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
AVPacket
This structure stores compressed data.
Definition: packet.h:351
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:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:259
atrac1_decode_frame
static int atrac1_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac1.c:276
AT1Ctx::bands
float * bands[3]
Definition: atrac1.c:84
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:91