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 "avcodec.h"
37 #include "get_bits.h"
38 #include "fft.h"
39 #include "internal.h"
40 #include "sinewin.h"
41 
42 #include "atrac.h"
43 #include "atrac1data.h"
44 
45 #define AT1_MAX_BFU 52 ///< max number of block floating units in a sound unit
46 #define AT1_SU_SIZE 212 ///< number of bytes in a sound unit
47 #define AT1_SU_SAMPLES 512 ///< number of samples in a sound unit
48 #define AT1_FRAME_SIZE AT1_SU_SIZE * 2
49 #define AT1_SU_MAX_BITS AT1_SU_SIZE * 8
50 #define AT1_MAX_CHANNELS 2
51 
52 #define AT1_QMF_BANDS 3
53 #define IDX_LOW_BAND 0
54 #define IDX_MID_BAND 1
55 #define IDX_HIGH_BAND 2
56 
57 /**
58  * Sound unit struct, one unit is used per channel
59  */
60 typedef struct AT1SUCtx {
61  int log2_block_count[AT1_QMF_BANDS]; ///< log2 number of blocks in a band
62  int num_bfus; ///< number of Block Floating Units
63  float* spectrum[2];
64  DECLARE_ALIGNED(32, float, spec1)[AT1_SU_SAMPLES]; ///< mdct buffer
65  DECLARE_ALIGNED(32, float, spec2)[AT1_SU_SAMPLES]; ///< mdct buffer
66  DECLARE_ALIGNED(32, float, fst_qmf_delay)[46]; ///< delay line for the 1st stacked QMF filter
67  DECLARE_ALIGNED(32, float, snd_qmf_delay)[46]; ///< delay line for the 2nd stacked QMF filter
68  DECLARE_ALIGNED(32, float, last_qmf_delay)[256+39]; ///< delay line for the last stacked QMF filter
69 } AT1SUCtx;
70 
71 /**
72  * The atrac1 context, holds all needed parameters for decoding
73  */
74 typedef struct AT1Ctx {
75  AT1SUCtx SUs[AT1_MAX_CHANNELS]; ///< channel sound unit
76  DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES]; ///< the mdct spectrum buffer
77 
78  DECLARE_ALIGNED(32, float, low)[256];
79  DECLARE_ALIGNED(32, float, mid)[256];
80  DECLARE_ALIGNED(32, float, high)[512];
81  float* bands[3];
82  FFTContext mdct_ctx[3];
84 } AT1Ctx;
85 
86 /** size of the transform in samples in the long mode for each QMF band */
87 static const uint16_t samples_per_band[3] = {128, 128, 256};
88 static const uint8_t mdct_long_nbits[3] = {7, 7, 8};
89 
90 
91 static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits,
92  int rev_spec)
93 {
94  FFTContext* mdct_context = &q->mdct_ctx[nbits - 5 - (nbits > 6)];
95  int transf_size = 1 << nbits;
96 
97  if (rev_spec) {
98  int i;
99  for (i = 0; i < transf_size / 2; i++)
100  FFSWAP(float, spec[i], spec[transf_size - 1 - i]);
101  }
102  mdct_context->imdct_half(mdct_context, out, spec);
103 }
104 
105 
107 {
108  int band_num, band_samples, log2_block_count, nbits, num_blocks, block_size;
109  unsigned int start_pos, ref_pos = 0, pos = 0;
110 
111  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
112  float *prev_buf;
113  int j;
114 
115  band_samples = samples_per_band[band_num];
116  log2_block_count = su->log2_block_count[band_num];
117 
118  /* number of mdct blocks in the current QMF band: 1 - for long mode */
119  /* 4 for short mode(low/middle bands) and 8 for short mode(high band)*/
120  num_blocks = 1 << log2_block_count;
121 
122  if (num_blocks == 1) {
123  /* mdct block size in samples: 128 (long mode, low & mid bands), */
124  /* 256 (long mode, high band) and 32 (short mode, all bands) */
125  block_size = band_samples >> log2_block_count;
126 
127  /* calc transform size in bits according to the block_size_mode */
128  nbits = mdct_long_nbits[band_num] - log2_block_count;
129 
130  if (nbits != 5 && nbits != 7 && nbits != 8)
131  return AVERROR_INVALIDDATA;
132  } else {
133  block_size = 32;
134  nbits = 5;
135  }
136 
137  start_pos = 0;
138  prev_buf = &su->spectrum[1][ref_pos + band_samples - 16];
139  for (j=0; j < num_blocks; j++) {
140  at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);
141 
142  /* overlap and window */
143  q->fdsp->vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
144  &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
145 
146  prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];
147  start_pos += block_size;
148  pos += block_size;
149  }
150 
151  if (num_blocks == 1)
152  memcpy(q->bands[band_num] + 32, &su->spectrum[0][ref_pos + 16], 240 * sizeof(float));
153 
154  ref_pos += band_samples;
155  }
156 
157  /* Swap buffers so the mdct overlap works */
158  FFSWAP(float*, su->spectrum[0], su->spectrum[1]);
159 
160  return 0;
161 }
162 
163 /**
164  * Parse the block size mode byte
165  */
166 
167 static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])
168 {
169  int log2_block_count_tmp, i;
170 
171  for (i = 0; i < 2; i++) {
172  /* low and mid band */
173  log2_block_count_tmp = get_bits(gb, 2);
174  if (log2_block_count_tmp & 1)
175  return AVERROR_INVALIDDATA;
176  log2_block_cnt[i] = 2 - log2_block_count_tmp;
177  }
178 
179  /* high band */
180  log2_block_count_tmp = get_bits(gb, 2);
181  if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)
182  return AVERROR_INVALIDDATA;
183  log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;
184 
185  skip_bits(gb, 2);
186  return 0;
187 }
188 
189 
191  float spec[AT1_SU_SAMPLES])
192 {
193  int bits_used, band_num, bfu_num, i;
194  uint8_t idwls[AT1_MAX_BFU]; ///< the word length indexes for each BFU
195  uint8_t idsfs[AT1_MAX_BFU]; ///< the scalefactor indexes for each BFU
196 
197  /* parse the info byte (2nd byte) telling how much BFUs were coded */
198  su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];
199 
200  /* calc number of consumed bits:
201  num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)
202  + info_byte_copy(8bits) + log2_block_count_copy(8bits) */
203  bits_used = su->num_bfus * 10 + 32 +
204  bfu_amount_tab2[get_bits(gb, 2)] +
205  (bfu_amount_tab3[get_bits(gb, 3)] << 1);
206 
207  /* get word length index (idwl) for each BFU */
208  for (i = 0; i < su->num_bfus; i++)
209  idwls[i] = get_bits(gb, 4);
210 
211  /* get scalefactor index (idsf) for each BFU */
212  for (i = 0; i < su->num_bfus; i++)
213  idsfs[i] = get_bits(gb, 6);
214 
215  /* zero idwl/idsf for empty BFUs */
216  for (i = su->num_bfus; i < AT1_MAX_BFU; i++)
217  idwls[i] = idsfs[i] = 0;
218 
219  /* read in the spectral data and reconstruct MDCT spectrum of this channel */
220  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
221  for (bfu_num = bfu_bands_t[band_num]; bfu_num < bfu_bands_t[band_num+1]; bfu_num++) {
222  int pos;
223 
224  int num_specs = specs_per_bfu[bfu_num];
225  int word_len = !!idwls[bfu_num] + idwls[bfu_num];
226  float scale_factor = ff_atrac_sf_table[idsfs[bfu_num]];
227  bits_used += word_len * num_specs; /* add number of bits consumed by current BFU */
228 
229  /* check for bitstream overflow */
230  if (bits_used > AT1_SU_MAX_BITS)
231  return AVERROR_INVALIDDATA;
232 
233  /* get the position of the 1st spec according to the block size mode */
234  pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];
235 
236  if (word_len) {
237  float max_quant = 1.0 / (float)((1 << (word_len - 1)) - 1);
238 
239  for (i = 0; i < num_specs; i++) {
240  /* read in a quantized spec and convert it to
241  * signed int and then inverse quantization
242  */
243  spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;
244  }
245  } else { /* word_len = 0 -> empty BFU, zero all specs in the empty BFU */
246  memset(&spec[pos], 0, num_specs * sizeof(float));
247  }
248  }
249  }
250 
251  return 0;
252 }
253 
254 
255 static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx* su, float *pOut)
256 {
257  float temp[256];
258  float iqmf_temp[512 + 46];
259 
260  /* combine low and middle bands */
261  ff_atrac_iqmf(q->bands[0], q->bands[1], 128, temp, su->fst_qmf_delay, iqmf_temp);
262 
263  /* delay the signal of the high band by 39 samples */
264  memcpy( su->last_qmf_delay, &su->last_qmf_delay[256], sizeof(float) * 39);
265  memcpy(&su->last_qmf_delay[39], q->bands[2], sizeof(float) * 256);
266 
267  /* combine (low + middle) and high bands */
268  ff_atrac_iqmf(temp, su->last_qmf_delay, 256, pOut, su->snd_qmf_delay, iqmf_temp);
269 }
270 
271 
272 static int atrac1_decode_frame(AVCodecContext *avctx, void *data,
273  int *got_frame_ptr, AVPacket *avpkt)
274 {
275  AVFrame *frame = data;
276  const uint8_t *buf = avpkt->data;
277  int buf_size = avpkt->size;
278  AT1Ctx *q = avctx->priv_data;
279  int ch, ret;
280  GetBitContext gb;
281 
282 
283  if (buf_size < 212 * avctx->channels) {
284  av_log(avctx, AV_LOG_ERROR, "Not enough data to decode!\n");
285  return AVERROR_INVALIDDATA;
286  }
287 
288  /* get output buffer */
289  frame->nb_samples = AT1_SU_SAMPLES;
290  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
291  return ret;
292 
293  for (ch = 0; ch < avctx->channels; ch++) {
294  AT1SUCtx* su = &q->SUs[ch];
295 
296  init_get_bits(&gb, &buf[212 * ch], 212 * 8);
297 
298  /* parse block_size_mode, 1st byte */
299  ret = at1_parse_bsm(&gb, su->log2_block_count);
300  if (ret < 0)
301  return ret;
302 
303  ret = at1_unpack_dequant(&gb, su, q->spec);
304  if (ret < 0)
305  return ret;
306 
307  ret = at1_imdct_block(su, q);
308  if (ret < 0)
309  return ret;
310  at1_subband_synthesis(q, su, (float *)frame->extended_data[ch]);
311  }
312 
313  *got_frame_ptr = 1;
314 
315  return avctx->block_align;
316 }
317 
318 
320 {
321  AT1Ctx *q = avctx->priv_data;
322 
323  ff_mdct_end(&q->mdct_ctx[0]);
324  ff_mdct_end(&q->mdct_ctx[1]);
325  ff_mdct_end(&q->mdct_ctx[2]);
326 
327  av_freep(&q->fdsp);
328 
329  return 0;
330 }
331 
332 
334 {
335  AT1Ctx *q = avctx->priv_data;
336  int ret;
337 
339 
340  if (avctx->channels < 1 || avctx->channels > AT1_MAX_CHANNELS) {
341  av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",
342  avctx->channels);
343  return AVERROR(EINVAL);
344  }
345 
346  if (avctx->block_align <= 0) {
347  av_log(avctx, AV_LOG_ERROR, "Unsupported block align.");
348  return AVERROR_PATCHWELCOME;
349  }
350 
351  /* Init the mdct transforms */
352  if ((ret = ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15))) ||
353  (ret = ff_mdct_init(&q->mdct_ctx[1], 8, 1, -1.0/ (1 << 15))) ||
354  (ret = ff_mdct_init(&q->mdct_ctx[2], 9, 1, -1.0/ (1 << 15)))) {
355  av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
356  atrac1_decode_end(avctx);
357  return ret;
358  }
359 
361 
363 
365 
366  q->bands[0] = q->low;
367  q->bands[1] = q->mid;
368  q->bands[2] = q->high;
369 
370  /* Prepare the mdct overlap buffers */
371  q->SUs[0].spectrum[0] = q->SUs[0].spec1;
372  q->SUs[0].spectrum[1] = q->SUs[0].spec2;
373  q->SUs[1].spectrum[0] = q->SUs[1].spec1;
374  q->SUs[1].spectrum[1] = q->SUs[1].spec2;
375 
376  return 0;
377 }
378 
379 
381  .name = "atrac1",
382  .long_name = NULL_IF_CONFIG_SMALL("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
383  .type = AVMEDIA_TYPE_AUDIO,
384  .id = AV_CODEC_ID_ATRAC1,
385  .priv_data_size = sizeof(AT1Ctx),
387  .close = atrac1_decode_end,
389  .capabilities = AV_CODEC_CAP_DR1,
390  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
392 };
float, planar
Definition: samplefmt.h:69
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
float snd_qmf_delay[46]
delay line for the 2nd stacked QMF filter
Definition: atrac1.c:67
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
AVCodec ff_atrac1_decoder
Definition: atrac1.c:380
Sound unit struct, one unit is used per channel.
Definition: atrac1.c:60
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static int at1_unpack_dequant(GetBitContext *gb, AT1SUCtx *su, float spec[AT1_SU_SAMPLES])
Definition: atrac1.c:190
else temp
Definition: vf_mcdeint.c:256
AT1SUCtx SUs[AT1_MAX_CHANNELS]
channel sound unit
Definition: atrac1.c:75
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static av_cold int atrac1_decode_init(AVCodecContext *avctx)
Definition: atrac1.c:333
channels
Definition: aptx.c:30
static av_cold int atrac1_decode_end(AVCodecContext *avctx)
Definition: atrac1.c:319
int size
Definition: avcodec.h:1478
static const uint8_t bfu_amount_tab2[4]
Definition: atrac1data.h:34
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
void ff_atrac_iqmf(float *inlo, float *inhi, unsigned int nIn, float *pOut, float *delayBuf, float *temp)
Quadrature mirror synthesis filter.
Definition: atrac.c:127
#define AT1_MAX_CHANNELS
Definition: atrac1.c:50
AVCodec.
Definition: avcodec.h:3477
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2258
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx *su, float *pOut)
Definition: atrac1.c:255
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
float ff_atrac_sf_table[64]
Definition: atrac.c:36
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2229
uint8_t
#define av_cold
Definition: attributes.h:82
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:87
The atrac1 context, holds all needed parameters for decoding.
Definition: atrac1.c:74
float spec2[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:65
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint8_t * data
Definition: avcodec.h:1477
#define AT1_SU_SAMPLES
number of samples in a sound unit
Definition: atrac1.c:47
ATRAC common header.
bitstream reader API header.
static int at1_parse_bsm(GetBitContext *gb, int log2_block_cnt[AT1_QMF_BANDS])
Parse the block size mode byte.
Definition: atrac1.c:167
#define av_log(a,...)
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
float mid[256]
Definition: atrac1.c:79
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits, int rev_spec)
Definition: atrac1.c:91
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
static const uint8_t bfu_amount_tab1[8]
Definition: atrac1data.h:33
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
#define ff_mdct_init
Definition: fft.h:169
float spec1[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:64
#define su(width, name)
Definition: cbs_av1.c:554
AVFloatDSPContext * fdsp
Definition: atrac1.c:83
#define AT1_QMF_BANDS
Definition: atrac1.c:52
int log2_block_count[AT1_QMF_BANDS]
log2 number of blocks in a band
Definition: atrac1.c:61
Definition: fft.h:88
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:908
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
#define IDX_HIGH_BAND
Definition: atrac1.c:55
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
#define AT1_SU_MAX_BITS
Definition: atrac1.c:49
float fst_qmf_delay[46]
delay line for the 1st stacked QMF filter
Definition: atrac1.c:66
main external API structure.
Definition: avcodec.h:1565
static const float bands[]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
void * buf
Definition: avisynth_c.h:766
static int atrac1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac1.c:272
float high[512]
Definition: atrac1.c:80
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
FFTContext mdct_ctx[3]
Definition: atrac1.c:82
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
float * spectrum[2]
Definition: atrac1.c:63
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:108
static const uint8_t mdct_long_nbits[3]
Definition: atrac1.c:88
#define AT1_MAX_BFU
max number of block floating units in a sound unit
Definition: atrac1.c:45
static const uint8_t bfu_bands_t[4]
number of BFUs in each QMF band
Definition: atrac1data.h:38
float spec[AT1_SU_SAMPLES]
the mdct spectrum buffer
Definition: atrac1.c:76
common internal api header.
#define ff_mdct_end
Definition: fft.h:170
float * bands[3]
Definition: atrac1.c:81
ATRAC1 compatible decoder data.
void * priv_data
Definition: avcodec.h:1592
float last_qmf_delay[256+39]
delay line for the last stacked QMF filter
Definition: atrac1.c:68
int channels
number of audio channels
Definition: avcodec.h:2222
float low[256]
Definition: atrac1.c:78
av_cold void ff_atrac_generate_tables(void)
Generate common tables.
Definition: atrac.c:48
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
FILE * out
Definition: movenc.c:54
#define av_freep(p)
#define FFSWAP(type, a, b)
Definition: common.h:99
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
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:315
This structure stores compressed data.
Definition: avcodec.h:1454
static const uint8_t bfu_amount_tab3[8]
Definition: atrac1data.h:35
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:334
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
int num_bfus
number of Block Floating Units
Definition: atrac1.c:62
static int at1_imdct_block(AT1SUCtx *su, AT1Ctx *q)
Definition: atrac1.c:106
void AAC_RENAME() ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
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