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 
33 #include "libavutil/float_dsp.h"
34 #include "libavutil/mem_internal.h"
35 #include "libavutil/tx.h"
36 
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "decode.h"
40 #include "get_bits.h"
41 #include "sinewin.h"
42 
43 #include "atrac.h"
44 #include "atrac1data.h"
45 
46 #define AT1_MAX_BFU 52 ///< max number of block floating units in a sound unit
47 #define AT1_SU_SIZE 212 ///< number of bytes in a sound unit
48 #define AT1_SU_SAMPLES 512 ///< number of samples in a sound unit
49 #define AT1_FRAME_SIZE AT1_SU_SIZE * 2
50 #define AT1_SU_MAX_BITS AT1_SU_SIZE * 8
51 #define AT1_MAX_CHANNELS 2
52 
53 #define AT1_QMF_BANDS 3
54 #define IDX_LOW_BAND 0
55 #define IDX_MID_BAND 1
56 #define IDX_HIGH_BAND 2
57 
58 /**
59  * Sound unit struct, one unit is used per channel
60  */
61 typedef struct AT1SUCtx {
62  int log2_block_count[AT1_QMF_BANDS]; ///< log2 number of blocks in a band
63  int num_bfus; ///< number of Block Floating Units
64  float* spectrum[2];
65  DECLARE_ALIGNED(32, float, spec1)[AT1_SU_SAMPLES]; ///< mdct buffer
66  DECLARE_ALIGNED(32, float, spec2)[AT1_SU_SAMPLES]; ///< mdct buffer
67  DECLARE_ALIGNED(32, float, fst_qmf_delay)[46]; ///< delay line for the 1st stacked QMF filter
68  DECLARE_ALIGNED(32, float, snd_qmf_delay)[46]; ///< delay line for the 2nd stacked QMF filter
69  DECLARE_ALIGNED(32, float, last_qmf_delay)[256+39]; ///< delay line for the last stacked QMF filter
70 } AT1SUCtx;
71 
72 /**
73  * The atrac1 context, holds all needed parameters for decoding
74  */
75 typedef struct AT1Ctx {
76  AT1SUCtx SUs[AT1_MAX_CHANNELS]; ///< channel sound unit
77  DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES]; ///< the mdct spectrum buffer
78 
79  DECLARE_ALIGNED(32, float, low)[256];
80  DECLARE_ALIGNED(32, float, mid)[256];
81  DECLARE_ALIGNED(32, float, high)[512];
82  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  AVTXContext *mdct_context = q->mdct_ctx[nbits - 5 - (nbits > 6)];
98  av_tx_fn mdct_fn = q->mdct_fn[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_fn(mdct_context, out, spec, sizeof(float));
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 */
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  av_tx_uninit(&q->mdct_ctx[0]);
328  av_tx_uninit(&q->mdct_ctx[1]);
329  av_tx_uninit(&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  float scale = -1.0 / (1 << 15);
341  int ret;
342 
344 
346  av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",
347  channels);
348  return AVERROR(EINVAL);
349  }
350 
351  if (avctx->block_align <= 0) {
352  av_log(avctx, AV_LOG_ERROR, "Unsupported block align.");
353  return AVERROR_PATCHWELCOME;
354  }
355 
356  /* Init the mdct transforms */
357  if ((ret = av_tx_init(&q->mdct_ctx[0], &q->mdct_fn[0], AV_TX_FLOAT_MDCT,
358  1, 32, &scale, 0) < 0))
359  return ret;
360  if ((ret = av_tx_init(&q->mdct_ctx[1], &q->mdct_fn[1], AV_TX_FLOAT_MDCT,
361  1, 128, &scale, 0) < 0))
362  return ret;
363  if ((ret = av_tx_init(&q->mdct_ctx[2], &q->mdct_fn[2], AV_TX_FLOAT_MDCT,
364  1, 256, &scale, 0) < 0))
365  return ret;
366 
368 
370 
372  if (!fdsp)
373  return AVERROR(ENOMEM);
375  av_free(fdsp);
376 
377  q->bands[0] = q->low;
378  q->bands[1] = q->mid;
379  q->bands[2] = q->high;
380 
381  /* Prepare the mdct overlap buffers */
382  q->SUs[0].spectrum[0] = q->SUs[0].spec1;
383  q->SUs[0].spectrum[1] = q->SUs[0].spec2;
384  q->SUs[1].spectrum[0] = q->SUs[1].spec1;
385  q->SUs[1].spectrum[1] = q->SUs[1].spec2;
386 
387  return 0;
388 }
389 
390 
392  .p.name = "atrac1",
393  CODEC_LONG_NAME("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
394  .p.type = AVMEDIA_TYPE_AUDIO,
395  .p.id = AV_CODEC_ID_ATRAC1,
396  .priv_data_size = sizeof(AT1Ctx),
398  .close = atrac1_decode_end,
400  .p.capabilities = AV_CODEC_CAP_DR1,
401  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
403  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
404 };
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:91
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:42
AT1_MAX_BFU
#define AT1_MAX_BFU
max number of block floating units in a sound unit
Definition: atrac1.c:46
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:48
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
AVTXContext
Definition: tx_priv.h:235
AT1_QMF_BANDS
#define AT1_QMF_BANDS
Definition: atrac1.c:53
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
AT1Ctx::spec
float spec[AT1_SU_SAMPLES]
the mdct spectrum buffer
Definition: atrac1.c:77
AVPacket::data
uint8_t * data
Definition: packet.h:522
AT1SUCtx::num_bfus
int num_bfus
number of Block Floating Units
Definition: atrac1.c:63
at1_imdct
static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits, int rev_spec)
Definition: atrac1.c:94
FFCodec
Definition: codec_internal.h:127
AT1Ctx
The atrac1 context, holds all needed parameters for decoding.
Definition: atrac1.c:75
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:902
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:381
AT1SUCtx::spec2
float spec2[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:66
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
AT1SUCtx
Sound unit struct, one unit is used per channel.
Definition: atrac1.c:61
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
IDX_HIGH_BAND
#define IDX_HIGH_BAND
Definition: atrac1.c:56
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:1065
su
#define su(width, name)
Definition: cbs_av1.c:467
ff_atrac1_decoder
const FFCodec ff_atrac1_decoder
Definition: atrac1.c:391
GetBitContext
Definition: get_bits.h:108
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
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:67
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
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:151
float
float
Definition: af_crystalizer.c:121
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:287
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:50
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:320
AT1Ctx::mdct_fn
av_tx_fn mdct_fn[3]
Definition: atrac1.c:84
channels
channels
Definition: aptx.h:31
decode.h
get_bits.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
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:76
ff_atrac_sf_table
float ff_atrac_sf_table[64]
Definition: atrac.c:36
AT1Ctx::mdct_ctx
AVTXContext * mdct_ctx[3]
Definition: atrac1.c:83
AT1_MAX_CHANNELS
#define AT1_MAX_CHANNELS
Definition: atrac1.c:51
float_dsp.h
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1568
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:523
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
AT1Ctx::low
float low[256]
Definition: atrac1.c:79
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:1057
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AT1SUCtx::spec1
float spec1[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:65
bfu_amount_tab2
static const uint8_t bfu_amount_tab2[4]
Definition: atrac1data.h:34
AVFloatDSPContext
Definition: float_dsp.h:22
AT1SUCtx::log2_block_count
int log2_block_count[AT1_QMF_BANDS]
log2 number of blocks in a band
Definition: atrac1.c:62
AT1SUCtx::spectrum
float * spectrum[2]
Definition: atrac1.c:64
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:81
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
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:294
bfu_amount_tab3
static const uint8_t bfu_amount_tab3[8]
Definition: atrac1data.h:35
AV_CODEC_ID_ATRAC1
@ AV_CODEC_ID_ATRAC1
Definition: codec_id.h:486
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:455
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AT1SUCtx::snd_qmf_delay
float snd_qmf_delay[46]
delay line for the 2nd stacked QMF filter
Definition: atrac1.c:68
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:436
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
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:1083
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AT1SUCtx::last_qmf_delay
float last_qmf_delay[256+39]
delay line for the last stacked QMF filter
Definition: atrac1.c:69
AT1Ctx::mid
float mid[256]
Definition: atrac1.c:80
pos
unsigned int pos
Definition: spdifenc.c:413
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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:263
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:342
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:117
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:499
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
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:82
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
tx.h
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