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.h"
35 #include "libavutil/mem_internal.h"
36 #include "libavutil/tx.h"
37 
38 #include "avcodec.h"
39 #include "codec_internal.h"
40 #include "decode.h"
41 #include "get_bits.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];
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  AVTXContext *mdct_context = q->mdct_ctx[nbits - 5 - (nbits > 6)];
99  av_tx_fn mdct_fn = q->mdct_fn[nbits - 5 - (nbits > 6)];
100  int transf_size = 1 << nbits;
101 
102  if (rev_spec) {
103  int i;
104  for (i = 0; i < transf_size / 2; i++)
105  FFSWAP(float, spec[i], spec[transf_size - 1 - i]);
106  }
107  mdct_fn(mdct_context, out, spec, sizeof(float));
108 }
109 
110 
112 {
113  int band_num, band_samples, log2_block_count, nbits, num_blocks, block_size;
114  unsigned int start_pos, ref_pos = 0, pos = 0;
115 
116  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
117  float *prev_buf;
118  int j;
119 
120  band_samples = samples_per_band[band_num];
121  log2_block_count = su->log2_block_count[band_num];
122 
123  /* number of mdct blocks in the current QMF band: 1 - for long mode */
124  /* 4 for short mode(low/middle bands) and 8 for short mode(high band)*/
125  num_blocks = 1 << log2_block_count;
126 
127  if (num_blocks == 1) {
128  /* mdct block size in samples: 128 (long mode, low & mid bands), */
129  /* 256 (long mode, high band) and 32 (short mode, all bands) */
130  block_size = band_samples >> log2_block_count;
131 
132  /* calc transform size in bits according to the block_size_mode */
133  nbits = mdct_long_nbits[band_num] - log2_block_count;
134 
135  if (nbits != 5 && nbits != 7 && nbits != 8)
136  return AVERROR_INVALIDDATA;
137  } else {
138  block_size = 32;
139  nbits = 5;
140  }
141 
142  start_pos = 0;
143  prev_buf = &su->spectrum[1][ref_pos + band_samples - 16];
144  for (j=0; j < num_blocks; j++) {
145  at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);
146 
147  /* overlap and window */
148  q->vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
149  &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
150 
151  prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];
152  start_pos += block_size;
153  pos += block_size;
154  }
155 
156  if (num_blocks == 1)
157  memcpy(q->bands[band_num] + 32, &su->spectrum[0][ref_pos + 16], 240 * sizeof(float));
158 
159  ref_pos += band_samples;
160  }
161 
162  /* Swap buffers so the mdct overlap works */
163  FFSWAP(float*, su->spectrum[0], su->spectrum[1]);
164 
165  return 0;
166 }
167 
168 /**
169  * Parse the block size mode byte
170  */
171 
172 static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])
173 {
174  int log2_block_count_tmp, i;
175 
176  for (i = 0; i < 2; i++) {
177  /* low and mid band */
178  log2_block_count_tmp = get_bits(gb, 2);
179  if (log2_block_count_tmp & 1)
180  return AVERROR_INVALIDDATA;
181  log2_block_cnt[i] = 2 - log2_block_count_tmp;
182  }
183 
184  /* high band */
185  log2_block_count_tmp = get_bits(gb, 2);
186  if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)
187  return AVERROR_INVALIDDATA;
188  log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;
189 
190  skip_bits(gb, 2);
191  return 0;
192 }
193 
194 
196  float spec[AT1_SU_SAMPLES])
197 {
198  int bits_used, band_num, bfu_num, i;
199  uint8_t idwls[AT1_MAX_BFU]; ///< the word length indexes for each BFU
200  uint8_t idsfs[AT1_MAX_BFU]; ///< the scalefactor indexes for each BFU
201 
202  /* parse the info byte (2nd byte) telling how much BFUs were coded */
203  su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];
204 
205  /* calc number of consumed bits:
206  num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)
207  + info_byte_copy(8bits) + log2_block_count_copy(8bits) */
208  bits_used = su->num_bfus * 10 + 32 +
209  bfu_amount_tab2[get_bits(gb, 2)] +
210  (bfu_amount_tab3[get_bits(gb, 3)] << 1);
211 
212  /* get word length index (idwl) for each BFU */
213  for (i = 0; i < su->num_bfus; i++)
214  idwls[i] = get_bits(gb, 4);
215 
216  /* get scalefactor index (idsf) for each BFU */
217  for (i = 0; i < su->num_bfus; i++)
218  idsfs[i] = get_bits(gb, 6);
219 
220  /* zero idwl/idsf for empty BFUs */
221  for (i = su->num_bfus; i < AT1_MAX_BFU; i++)
222  idwls[i] = idsfs[i] = 0;
223 
224  /* read in the spectral data and reconstruct MDCT spectrum of this channel */
225  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
226  for (bfu_num = bfu_bands_t[band_num]; bfu_num < bfu_bands_t[band_num+1]; bfu_num++) {
227  int pos;
228 
229  int num_specs = specs_per_bfu[bfu_num];
230  int word_len = !!idwls[bfu_num] + idwls[bfu_num];
231  float scale_factor = ff_atrac_sf_table[idsfs[bfu_num]];
232  bits_used += word_len * num_specs; /* add number of bits consumed by current BFU */
233 
234  /* check for bitstream overflow */
235  if (bits_used > AT1_SU_MAX_BITS)
236  return AVERROR_INVALIDDATA;
237 
238  /* get the position of the 1st spec according to the block size mode */
239  pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];
240 
241  if (word_len) {
242  float max_quant = 1.0 / (float)((1 << (word_len - 1)) - 1);
243 
244  for (i = 0; i < num_specs; i++) {
245  /* read in a quantized spec and convert it to
246  * signed int and then inverse quantization
247  */
248  spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;
249  }
250  } else { /* word_len = 0 -> empty BFU, zero all specs in the empty BFU */
251  memset(&spec[pos], 0, num_specs * sizeof(float));
252  }
253  }
254  }
255 
256  return 0;
257 }
258 
259 
260 static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx* su, float *pOut)
261 {
262  float temp[256];
263  float iqmf_temp[512 + 46];
264 
265  /* combine low and middle bands */
266  ff_atrac_iqmf(q->bands[0], q->bands[1], 128, temp, su->fst_qmf_delay, iqmf_temp);
267 
268  /* delay the signal of the high band by 39 samples */
269  memcpy( su->last_qmf_delay, &su->last_qmf_delay[256], sizeof(float) * 39);
270  memcpy(&su->last_qmf_delay[39], q->bands[2], sizeof(float) * 256);
271 
272  /* combine (low + middle) and high bands */
273  ff_atrac_iqmf(temp, su->last_qmf_delay, 256, pOut, su->snd_qmf_delay, iqmf_temp);
274 }
275 
276 
278  int *got_frame_ptr, AVPacket *avpkt)
279 {
280  const uint8_t *buf = avpkt->data;
281  int buf_size = avpkt->size;
282  AT1Ctx *q = avctx->priv_data;
283  int channels = avctx->ch_layout.nb_channels;
284  int ch, ret;
285  GetBitContext gb;
286 
287 
288  if (buf_size < 212 * channels) {
289  av_log(avctx, AV_LOG_ERROR, "Not enough data to decode!\n");
290  return AVERROR_INVALIDDATA;
291  }
292 
293  /* get output buffer */
294  frame->nb_samples = AT1_SU_SAMPLES;
295  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
296  return ret;
297 
298  for (ch = 0; ch < channels; ch++) {
299  AT1SUCtx* su = &q->SUs[ch];
300 
301  init_get_bits(&gb, &buf[212 * ch], 212 * 8);
302 
303  /* parse block_size_mode, 1st byte */
304  ret = at1_parse_bsm(&gb, su->log2_block_count);
305  if (ret < 0)
306  return ret;
307 
308  ret = at1_unpack_dequant(&gb, su, q->spec);
309  if (ret < 0)
310  return ret;
311 
312  ret = at1_imdct_block(su, q);
313  if (ret < 0)
314  return ret;
315  at1_subband_synthesis(q, su, (float *)frame->extended_data[ch]);
316  }
317 
318  *got_frame_ptr = 1;
319 
320  return avctx->block_align;
321 }
322 
323 
325 {
326  AT1Ctx *q = avctx->priv_data;
327 
328  av_tx_uninit(&q->mdct_ctx[0]);
329  av_tx_uninit(&q->mdct_ctx[1]);
330  av_tx_uninit(&q->mdct_ctx[2]);
331 
332  return 0;
333 }
334 
335 
337 {
338  AT1Ctx *q = avctx->priv_data;
339  AVFloatDSPContext *fdsp;
340  int channels = avctx->ch_layout.nb_channels;
341  float scale = -1.0 / (1 << 15);
342  int ret;
343 
345 
347  av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",
348  channels);
349  return AVERROR(EINVAL);
350  }
351 
352  if (avctx->block_align <= 0) {
353  av_log(avctx, AV_LOG_ERROR, "Unsupported block align.");
354  return AVERROR_PATCHWELCOME;
355  }
356 
357  /* Init the mdct transforms */
358  if ((ret = av_tx_init(&q->mdct_ctx[0], &q->mdct_fn[0], AV_TX_FLOAT_MDCT,
359  1, 32, &scale, 0) < 0))
360  return ret;
361  if ((ret = av_tx_init(&q->mdct_ctx[1], &q->mdct_fn[1], AV_TX_FLOAT_MDCT,
362  1, 128, &scale, 0) < 0))
363  return ret;
364  if ((ret = av_tx_init(&q->mdct_ctx[2], &q->mdct_fn[2], AV_TX_FLOAT_MDCT,
365  1, 256, &scale, 0) < 0))
366  return ret;
367 
369 
371 
373  if (!fdsp)
374  return AVERROR(ENOMEM);
376  av_free(fdsp);
377 
378  q->bands[0] = q->low;
379  q->bands[1] = q->mid;
380  q->bands[2] = q->high;
381 
382  /* Prepare the mdct overlap buffers */
383  q->SUs[0].spectrum[0] = q->SUs[0].spec1;
384  q->SUs[0].spectrum[1] = q->SUs[0].spec2;
385  q->SUs[1].spectrum[0] = q->SUs[1].spec1;
386  q->SUs[1].spectrum[1] = q->SUs[1].spec2;
387 
388  return 0;
389 }
390 
391 
393  .p.name = "atrac1",
394  CODEC_LONG_NAME("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
395  .p.type = AVMEDIA_TYPE_AUDIO,
396  .p.id = AV_CODEC_ID_ATRAC1,
397  .priv_data_size = sizeof(AT1Ctx),
399  .close = atrac1_decode_end,
401  .p.capabilities = AV_CODEC_CAP_DR1,
402  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
404  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
405 };
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:42
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:55
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:54
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AT1Ctx::spec
float spec[AT1_SU_SAMPLES]
the mdct spectrum buffer
Definition: atrac1.c:78
AVPacket::data
uint8_t * data
Definition: packet.h:524
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:95
FFCodec
Definition: codec_internal.h:126
AT1Ctx
The atrac1 context, holds all needed parameters for decoding.
Definition: atrac1.c:76
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:903
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:120
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:67
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:62
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
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:111
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:392
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:86
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
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:286
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:320
AT1Ctx::mdct_fn
av_tx_fn mdct_fn[3]
Definition: atrac1.c:85
channels
channels
Definition: aptx.h:31
decode.h
get_bits.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
at1_unpack_dequant
static int at1_unpack_dequant(GetBitContext *gb, AT1SUCtx *su, float spec[AT1_SU_SAMPLES])
Definition: atrac1.c:195
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
AT1Ctx::mdct_ctx
AVTXContext * mdct_ctx[3]
Definition: atrac1.c:84
AT1_MAX_CHANNELS
#define AT1_MAX_CHANNELS
Definition: atrac1.c:52
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:1557
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:525
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
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:172
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:66
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: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
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:295
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AT1SUCtx::snd_qmf_delay
float snd_qmf_delay[46]
delay line for the 2nd stacked QMF filter
Definition: atrac1.c:69
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:336
avcodec.h
atrac1_decode_end
static av_cold int atrac1_decode_end(AVCodecContext *avctx)
Definition: atrac1.c:324
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
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:414
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
mem.h
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
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:260
atrac1_decode_frame
static int atrac1_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac1.c:277
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
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:91