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];
83  void (*vector_fmul_window)(float *dst, const float *src0,
84  const float *src1, const float *win, int len);
85 } AT1Ctx;
86 
87 /** size of the transform in samples in the long mode for each QMF band */
88 static const uint16_t samples_per_band[3] = {128, 128, 256};
89 static const uint8_t mdct_long_nbits[3] = {7, 7, 8};
90 
91 
92 static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits,
93  int rev_spec)
94 {
95  FFTContext* mdct_context = &q->mdct_ctx[nbits - 5 - (nbits > 6)];
96  int transf_size = 1 << nbits;
97 
98  if (rev_spec) {
99  int i;
100  for (i = 0; i < transf_size / 2; i++)
101  FFSWAP(float, spec[i], spec[transf_size - 1 - i]);
102  }
103  mdct_context->imdct_half(mdct_context, out, spec);
104 }
105 
106 
108 {
109  int band_num, band_samples, log2_block_count, nbits, num_blocks, block_size;
110  unsigned int start_pos, ref_pos = 0, pos = 0;
111 
112  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
113  float *prev_buf;
114  int j;
115 
116  band_samples = samples_per_band[band_num];
117  log2_block_count = su->log2_block_count[band_num];
118 
119  /* number of mdct blocks in the current QMF band: 1 - for long mode */
120  /* 4 for short mode(low/middle bands) and 8 for short mode(high band)*/
121  num_blocks = 1 << log2_block_count;
122 
123  if (num_blocks == 1) {
124  /* mdct block size in samples: 128 (long mode, low & mid bands), */
125  /* 256 (long mode, high band) and 32 (short mode, all bands) */
126  block_size = band_samples >> log2_block_count;
127 
128  /* calc transform size in bits according to the block_size_mode */
129  nbits = mdct_long_nbits[band_num] - log2_block_count;
130 
131  if (nbits != 5 && nbits != 7 && nbits != 8)
132  return AVERROR_INVALIDDATA;
133  } else {
134  block_size = 32;
135  nbits = 5;
136  }
137 
138  start_pos = 0;
139  prev_buf = &su->spectrum[1][ref_pos + band_samples - 16];
140  for (j=0; j < num_blocks; j++) {
141  at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);
142 
143  /* overlap and window */
144  q->vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
145  &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
146 
147  prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];
148  start_pos += block_size;
149  pos += block_size;
150  }
151 
152  if (num_blocks == 1)
153  memcpy(q->bands[band_num] + 32, &su->spectrum[0][ref_pos + 16], 240 * sizeof(float));
154 
155  ref_pos += band_samples;
156  }
157 
158  /* Swap buffers so the mdct overlap works */
159  FFSWAP(float*, su->spectrum[0], su->spectrum[1]);
160 
161  return 0;
162 }
163 
164 /**
165  * Parse the block size mode byte
166  */
167 
168 static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])
169 {
170  int log2_block_count_tmp, i;
171 
172  for (i = 0; i < 2; i++) {
173  /* low and mid band */
174  log2_block_count_tmp = get_bits(gb, 2);
175  if (log2_block_count_tmp & 1)
176  return AVERROR_INVALIDDATA;
177  log2_block_cnt[i] = 2 - log2_block_count_tmp;
178  }
179 
180  /* high band */
181  log2_block_count_tmp = get_bits(gb, 2);
182  if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)
183  return AVERROR_INVALIDDATA;
184  log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;
185 
186  skip_bits(gb, 2);
187  return 0;
188 }
189 
190 
192  float spec[AT1_SU_SAMPLES])
193 {
194  int bits_used, band_num, bfu_num, i;
195  uint8_t idwls[AT1_MAX_BFU]; ///< the word length indexes for each BFU
196  uint8_t idsfs[AT1_MAX_BFU]; ///< the scalefactor indexes for each BFU
197 
198  /* parse the info byte (2nd byte) telling how much BFUs were coded */
199  su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];
200 
201  /* calc number of consumed bits:
202  num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)
203  + info_byte_copy(8bits) + log2_block_count_copy(8bits) */
204  bits_used = su->num_bfus * 10 + 32 +
205  bfu_amount_tab2[get_bits(gb, 2)] +
206  (bfu_amount_tab3[get_bits(gb, 3)] << 1);
207 
208  /* get word length index (idwl) for each BFU */
209  for (i = 0; i < su->num_bfus; i++)
210  idwls[i] = get_bits(gb, 4);
211 
212  /* get scalefactor index (idsf) for each BFU */
213  for (i = 0; i < su->num_bfus; i++)
214  idsfs[i] = get_bits(gb, 6);
215 
216  /* zero idwl/idsf for empty BFUs */
217  for (i = su->num_bfus; i < AT1_MAX_BFU; i++)
218  idwls[i] = idsfs[i] = 0;
219 
220  /* read in the spectral data and reconstruct MDCT spectrum of this channel */
221  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
222  for (bfu_num = bfu_bands_t[band_num]; bfu_num < bfu_bands_t[band_num+1]; bfu_num++) {
223  int pos;
224 
225  int num_specs = specs_per_bfu[bfu_num];
226  int word_len = !!idwls[bfu_num] + idwls[bfu_num];
227  float scale_factor = ff_atrac_sf_table[idsfs[bfu_num]];
228  bits_used += word_len * num_specs; /* add number of bits consumed by current BFU */
229 
230  /* check for bitstream overflow */
231  if (bits_used > AT1_SU_MAX_BITS)
232  return AVERROR_INVALIDDATA;
233 
234  /* get the position of the 1st spec according to the block size mode */
235  pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];
236 
237  if (word_len) {
238  float max_quant = 1.0 / (float)((1 << (word_len - 1)) - 1);
239 
240  for (i = 0; i < num_specs; i++) {
241  /* read in a quantized spec and convert it to
242  * signed int and then inverse quantization
243  */
244  spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;
245  }
246  } else { /* word_len = 0 -> empty BFU, zero all specs in the empty BFU */
247  memset(&spec[pos], 0, num_specs * sizeof(float));
248  }
249  }
250  }
251 
252  return 0;
253 }
254 
255 
256 static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx* su, float *pOut)
257 {
258  float temp[256];
259  float iqmf_temp[512 + 46];
260 
261  /* combine low and middle bands */
262  ff_atrac_iqmf(q->bands[0], q->bands[1], 128, temp, su->fst_qmf_delay, iqmf_temp);
263 
264  /* delay the signal of the high band by 39 samples */
265  memcpy( su->last_qmf_delay, &su->last_qmf_delay[256], sizeof(float) * 39);
266  memcpy(&su->last_qmf_delay[39], q->bands[2], sizeof(float) * 256);
267 
268  /* combine (low + middle) and high bands */
269  ff_atrac_iqmf(temp, su->last_qmf_delay, 256, pOut, su->snd_qmf_delay, iqmf_temp);
270 }
271 
272 
273 static int atrac1_decode_frame(AVCodecContext *avctx, void *data,
274  int *got_frame_ptr, AVPacket *avpkt)
275 {
276  AVFrame *frame = data;
277  const uint8_t *buf = avpkt->data;
278  int buf_size = avpkt->size;
279  AT1Ctx *q = avctx->priv_data;
280  int ch, ret;
281  GetBitContext gb;
282 
283 
284  if (buf_size < 212 * avctx->channels) {
285  av_log(avctx, AV_LOG_ERROR, "Not enough data to decode!\n");
286  return AVERROR_INVALIDDATA;
287  }
288 
289  /* get output buffer */
290  frame->nb_samples = AT1_SU_SAMPLES;
291  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
292  return ret;
293 
294  for (ch = 0; ch < avctx->channels; ch++) {
295  AT1SUCtx* su = &q->SUs[ch];
296 
297  init_get_bits(&gb, &buf[212 * ch], 212 * 8);
298 
299  /* parse block_size_mode, 1st byte */
300  ret = at1_parse_bsm(&gb, su->log2_block_count);
301  if (ret < 0)
302  return ret;
303 
304  ret = at1_unpack_dequant(&gb, su, q->spec);
305  if (ret < 0)
306  return ret;
307 
308  ret = at1_imdct_block(su, q);
309  if (ret < 0)
310  return ret;
311  at1_subband_synthesis(q, su, (float *)frame->extended_data[ch]);
312  }
313 
314  *got_frame_ptr = 1;
315 
316  return avctx->block_align;
317 }
318 
319 
321 {
322  AT1Ctx *q = avctx->priv_data;
323 
324  ff_mdct_end(&q->mdct_ctx[0]);
325  ff_mdct_end(&q->mdct_ctx[1]);
326  ff_mdct_end(&q->mdct_ctx[2]);
327 
328  return 0;
329 }
330 
331 
333 {
334  AT1Ctx *q = avctx->priv_data;
335  AVFloatDSPContext *fdsp;
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  return ret;
357  }
358 
360 
362 
364  if (!fdsp)
365  return AVERROR(ENOMEM);
367  av_free(fdsp);
368 
369  q->bands[0] = q->low;
370  q->bands[1] = q->mid;
371  q->bands[2] = q->high;
372 
373  /* Prepare the mdct overlap buffers */
374  q->SUs[0].spectrum[0] = q->SUs[0].spec1;
375  q->SUs[0].spectrum[1] = q->SUs[0].spec2;
376  q->SUs[1].spectrum[0] = q->SUs[1].spec1;
377  q->SUs[1].spectrum[1] = q->SUs[1].spec2;
378 
379  return 0;
380 }
381 
382 
384  .name = "atrac1",
385  .long_name = NULL_IF_CONFIG_SMALL("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
386  .type = AVMEDIA_TYPE_AUDIO,
387  .id = AV_CODEC_ID_ATRAC1,
388  .priv_data_size = sizeof(AT1Ctx),
390  .close = atrac1_decode_end,
392  .capabilities = AV_CODEC_CAP_DR1,
393  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
395  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
396 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
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:308
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
AVCodec ff_atrac1_decoder
Definition: atrac1.c:383
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:191
else temp
Definition: vf_mcdeint.c:256
static float win(SuperEqualizerContext *s, float n, int N)
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:332
static av_cold int atrac1_decode_end(AVCodecContext *avctx)
Definition: atrac1.c:320
int size
Definition: packet.h:364
static const uint8_t bfu_amount_tab2[4]
Definition: atrac1data.h:34
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: codec.h:190
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:1223
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:71
static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx *su, float *pOut)
Definition: atrac1.c:256
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:1194
uint8_t
#define av_cold
Definition: attributes.h:88
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:88
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: packet.h:363
#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:168
channels
Definition: aptx.h:33
#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
float mid[256]
Definition: atrac1.c:79
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:92
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:153
unsigned int pos
Definition: spdifenc.c:410
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
const char * name
Name of the codec implementation.
Definition: codec.h:197
#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:553
#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:333
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
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
#define src1
Definition: h264pred.c:139
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:526
static const float bands[]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1872
static int atrac1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac1.c:273
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
#define src0
Definition: h264pred.c:138
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:108
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/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_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 *(UINT64_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 *(UINT64_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
static const uint8_t mdct_long_nbits[3]
Definition: atrac1.c:89
#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:553
#define av_free(p)
float last_qmf_delay[256+39]
delay line for the last stacked QMF filter
Definition: atrac1.c:68
int len
int channels
number of audio channels
Definition: avcodec.h:1187
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Definition: atrac1.c:83
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:836
FILE * out
Definition: movenc.c:54
#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:355
This structure stores compressed data.
Definition: packet.h:340
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:374
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int num_bfus
number of Block Floating Units
Definition: atrac1.c:62
int i
Definition: input.c:407
static int at1_imdct_block(AT1SUCtx *su, AT1Ctx *q)
Definition: atrac1.c:107
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