FFmpeg
atrac1.c
Go to the documentation of this file.
1 /*
2  * ATRAC1 compatible decoder
3  * Copyright (c) 2009 Maxim Poliakovski
4  * Copyright (c) 2009 Benjamin Larsson
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * ATRAC1 compatible decoder.
26  * This decoder handles raw ATRAC1 data and probably SDDS data.
27  */
28 
29 /* Many thanks to Tim Craig for all the help! */
30 
31 #include <math.h>
32 #include <stddef.h>
33 #include <stdio.h>
34 
35 #include "libavutil/float_dsp.h"
36 #include "libavutil/mem_internal.h"
37 
38 #include "avcodec.h"
39 #include "get_bits.h"
40 #include "fft.h"
41 #include "internal.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];
84  FFTContext mdct_ctx[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  FFTContext* mdct_context = &q->mdct_ctx[nbits - 5 - (nbits > 6)];
98  int transf_size = 1 << nbits;
99 
100  if (rev_spec) {
101  int i;
102  for (i = 0; i < transf_size / 2; i++)
103  FFSWAP(float, spec[i], spec[transf_size - 1 - i]);
104  }
105  mdct_context->imdct_half(mdct_context, out, spec);
106 }
107 
108 
110 {
111  int band_num, band_samples, log2_block_count, nbits, num_blocks, block_size;
112  unsigned int start_pos, ref_pos = 0, pos = 0;
113 
114  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
115  float *prev_buf;
116  int j;
117 
118  band_samples = samples_per_band[band_num];
119  log2_block_count = su->log2_block_count[band_num];
120 
121  /* number of mdct blocks in the current QMF band: 1 - for long mode */
122  /* 4 for short mode(low/middle bands) and 8 for short mode(high band)*/
123  num_blocks = 1 << log2_block_count;
124 
125  if (num_blocks == 1) {
126  /* mdct block size in samples: 128 (long mode, low & mid bands), */
127  /* 256 (long mode, high band) and 32 (short mode, all bands) */
128  block_size = band_samples >> log2_block_count;
129 
130  /* calc transform size in bits according to the block_size_mode */
131  nbits = mdct_long_nbits[band_num] - log2_block_count;
132 
133  if (nbits != 5 && nbits != 7 && nbits != 8)
134  return AVERROR_INVALIDDATA;
135  } else {
136  block_size = 32;
137  nbits = 5;
138  }
139 
140  start_pos = 0;
141  prev_buf = &su->spectrum[1][ref_pos + band_samples - 16];
142  for (j=0; j < num_blocks; j++) {
143  at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);
144 
145  /* overlap and window */
146  q->vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
147  &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
148 
149  prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];
150  start_pos += block_size;
151  pos += block_size;
152  }
153 
154  if (num_blocks == 1)
155  memcpy(q->bands[band_num] + 32, &su->spectrum[0][ref_pos + 16], 240 * sizeof(float));
156 
157  ref_pos += band_samples;
158  }
159 
160  /* Swap buffers so the mdct overlap works */
161  FFSWAP(float*, su->spectrum[0], su->spectrum[1]);
162 
163  return 0;
164 }
165 
166 /**
167  * Parse the block size mode byte
168  */
169 
170 static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])
171 {
172  int log2_block_count_tmp, i;
173 
174  for (i = 0; i < 2; i++) {
175  /* low and mid band */
176  log2_block_count_tmp = get_bits(gb, 2);
177  if (log2_block_count_tmp & 1)
178  return AVERROR_INVALIDDATA;
179  log2_block_cnt[i] = 2 - log2_block_count_tmp;
180  }
181 
182  /* high band */
183  log2_block_count_tmp = get_bits(gb, 2);
184  if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)
185  return AVERROR_INVALIDDATA;
186  log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;
187 
188  skip_bits(gb, 2);
189  return 0;
190 }
191 
192 
194  float spec[AT1_SU_SAMPLES])
195 {
196  int bits_used, band_num, bfu_num, i;
197  uint8_t idwls[AT1_MAX_BFU]; ///< the word length indexes for each BFU
198  uint8_t idsfs[AT1_MAX_BFU]; ///< the scalefactor indexes for each BFU
199 
200  /* parse the info byte (2nd byte) telling how much BFUs were coded */
201  su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];
202 
203  /* calc number of consumed bits:
204  num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)
205  + info_byte_copy(8bits) + log2_block_count_copy(8bits) */
206  bits_used = su->num_bfus * 10 + 32 +
207  bfu_amount_tab2[get_bits(gb, 2)] +
208  (bfu_amount_tab3[get_bits(gb, 3)] << 1);
209 
210  /* get word length index (idwl) for each BFU */
211  for (i = 0; i < su->num_bfus; i++)
212  idwls[i] = get_bits(gb, 4);
213 
214  /* get scalefactor index (idsf) for each BFU */
215  for (i = 0; i < su->num_bfus; i++)
216  idsfs[i] = get_bits(gb, 6);
217 
218  /* zero idwl/idsf for empty BFUs */
219  for (i = su->num_bfus; i < AT1_MAX_BFU; i++)
220  idwls[i] = idsfs[i] = 0;
221 
222  /* read in the spectral data and reconstruct MDCT spectrum of this channel */
223  for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
224  for (bfu_num = bfu_bands_t[band_num]; bfu_num < bfu_bands_t[band_num+1]; bfu_num++) {
225  int pos;
226 
227  int num_specs = specs_per_bfu[bfu_num];
228  int word_len = !!idwls[bfu_num] + idwls[bfu_num];
229  float scale_factor = ff_atrac_sf_table[idsfs[bfu_num]];
230  bits_used += word_len * num_specs; /* add number of bits consumed by current BFU */
231 
232  /* check for bitstream overflow */
233  if (bits_used > AT1_SU_MAX_BITS)
234  return AVERROR_INVALIDDATA;
235 
236  /* get the position of the 1st spec according to the block size mode */
237  pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];
238 
239  if (word_len) {
240  float max_quant = 1.0 / (float)((1 << (word_len - 1)) - 1);
241 
242  for (i = 0; i < num_specs; i++) {
243  /* read in a quantized spec and convert it to
244  * signed int and then inverse quantization
245  */
246  spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;
247  }
248  } else { /* word_len = 0 -> empty BFU, zero all specs in the empty BFU */
249  memset(&spec[pos], 0, num_specs * sizeof(float));
250  }
251  }
252  }
253 
254  return 0;
255 }
256 
257 
258 static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx* su, float *pOut)
259 {
260  float temp[256];
261  float iqmf_temp[512 + 46];
262 
263  /* combine low and middle bands */
264  ff_atrac_iqmf(q->bands[0], q->bands[1], 128, temp, su->fst_qmf_delay, iqmf_temp);
265 
266  /* delay the signal of the high band by 39 samples */
267  memcpy( su->last_qmf_delay, &su->last_qmf_delay[256], sizeof(float) * 39);
268  memcpy(&su->last_qmf_delay[39], q->bands[2], sizeof(float) * 256);
269 
270  /* combine (low + middle) and high bands */
271  ff_atrac_iqmf(temp, su->last_qmf_delay, 256, pOut, su->snd_qmf_delay, iqmf_temp);
272 }
273 
274 
275 static int atrac1_decode_frame(AVCodecContext *avctx, void *data,
276  int *got_frame_ptr, AVPacket *avpkt)
277 {
278  AVFrame *frame = data;
279  const uint8_t *buf = avpkt->data;
280  int buf_size = avpkt->size;
281  AT1Ctx *q = avctx->priv_data;
282  int ch, ret;
283  GetBitContext gb;
284 
285 
286  if (buf_size < 212 * avctx->channels) {
287  av_log(avctx, AV_LOG_ERROR, "Not enough data to decode!\n");
288  return AVERROR_INVALIDDATA;
289  }
290 
291  /* get output buffer */
292  frame->nb_samples = AT1_SU_SAMPLES;
293  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
294  return ret;
295 
296  for (ch = 0; ch < avctx->channels; ch++) {
297  AT1SUCtx* su = &q->SUs[ch];
298 
299  init_get_bits(&gb, &buf[212 * ch], 212 * 8);
300 
301  /* parse block_size_mode, 1st byte */
302  ret = at1_parse_bsm(&gb, su->log2_block_count);
303  if (ret < 0)
304  return ret;
305 
306  ret = at1_unpack_dequant(&gb, su, q->spec);
307  if (ret < 0)
308  return ret;
309 
310  ret = at1_imdct_block(su, q);
311  if (ret < 0)
312  return ret;
313  at1_subband_synthesis(q, su, (float *)frame->extended_data[ch]);
314  }
315 
316  *got_frame_ptr = 1;
317 
318  return avctx->block_align;
319 }
320 
321 
323 {
324  AT1Ctx *q = avctx->priv_data;
325 
326  ff_mdct_end(&q->mdct_ctx[0]);
327  ff_mdct_end(&q->mdct_ctx[1]);
328  ff_mdct_end(&q->mdct_ctx[2]);
329 
330  return 0;
331 }
332 
333 
335 {
336  AT1Ctx *q = avctx->priv_data;
337  AVFloatDSPContext *fdsp;
338  int ret;
339 
341 
342  if (avctx->channels < 1 || avctx->channels > AT1_MAX_CHANNELS) {
343  av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",
344  avctx->channels);
345  return AVERROR(EINVAL);
346  }
347 
348  if (avctx->block_align <= 0) {
349  av_log(avctx, AV_LOG_ERROR, "Unsupported block align.");
350  return AVERROR_PATCHWELCOME;
351  }
352 
353  /* Init the mdct transforms */
354  if ((ret = ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15))) ||
355  (ret = ff_mdct_init(&q->mdct_ctx[1], 8, 1, -1.0/ (1 << 15))) ||
356  (ret = ff_mdct_init(&q->mdct_ctx[2], 9, 1, -1.0/ (1 << 15)))) {
357  av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
358  return ret;
359  }
360 
362 
364 
366  if (!fdsp)
367  return AVERROR(ENOMEM);
369  av_free(fdsp);
370 
371  q->bands[0] = q->low;
372  q->bands[1] = q->mid;
373  q->bands[2] = q->high;
374 
375  /* Prepare the mdct overlap buffers */
376  q->SUs[0].spectrum[0] = q->SUs[0].spec1;
377  q->SUs[0].spectrum[1] = q->SUs[0].spec2;
378  q->SUs[1].spectrum[0] = q->SUs[1].spec1;
379  q->SUs[1].spectrum[1] = q->SUs[1].spec2;
380 
381  return 0;
382 }
383 
384 
386  .name = "atrac1",
387  .long_name = NULL_IF_CONFIG_SMALL("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
388  .type = AVMEDIA_TYPE_AUDIO,
389  .id = AV_CODEC_ID_ATRAC1,
390  .priv_data_size = sizeof(AT1Ctx),
392  .close = atrac1_decode_end,
394  .capabilities = AV_CODEC_CAP_DR1,
395  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
398 };
#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:49
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:69
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
AVCodec ff_atrac1_decoder
Definition: atrac1.c:385
Sound unit struct, one unit is used per channel.
Definition: atrac1.c:62
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:193
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:77
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static av_cold int atrac1_decode_init(AVCodecContext *avctx)
Definition: atrac1.c:334
static av_cold int atrac1_decode_end(AVCodecContext *avctx)
Definition: atrac1.c:322
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:130
#define AT1_MAX_CHANNELS
Definition: atrac1.c:52
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:1228
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:258
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:38
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
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:90
The atrac1 context, holds all needed parameters for decoding.
Definition: atrac1.c:76
float spec2[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:67
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
uint8_t * data
Definition: packet.h:363
#define AT1_SU_SAMPLES
number of samples in a sound unit
Definition: atrac1.c:49
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:170
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:81
#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:94
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:115
unsigned int pos
Definition: spdifenc.c:412
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
const char * name
Name of the codec implementation.
Definition: codec.h:197
#define ff_mdct_init
Definition: fft.h:161
float spec1[AT1_SU_SAMPLES]
mdct buffer
Definition: atrac1.c:66
#define su(width, name)
Definition: cbs_av1.c:554
#define AT1_QMF_BANDS
Definition: atrac1.c:54
int log2_block_count[AT1_QMF_BANDS]
log2 number of blocks in a band
Definition: atrac1.c:63
Definition: fft.h:83
#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:57
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define src1
Definition: h264pred.c:140
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
#define AT1_SU_MAX_BITS
Definition: atrac1.c:51
float fst_qmf_delay[46]
delay line for the 1st stacked QMF filter
Definition: atrac1.c:68
main external API structure.
Definition: avcodec.h:531
static const float bands[]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1902
static int atrac1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac1.c:275
float high[512]
Definition: atrac1.c:82
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
FFTContext mdct_ctx[3]
Definition: atrac1.c:84
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:65
#define src0
Definition: h264pred.c:139
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:103
static const uint8_t mdct_long_nbits[3]
Definition: atrac1.c:91
#define AT1_MAX_BFU
max number of block floating units in a sound unit
Definition: atrac1.c:47
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:78
common internal api header.
#define ff_mdct_end
Definition: fft.h:162
float * bands[3]
Definition: atrac1.c:83
ATRAC1 compatible decoder data.
void * priv_data
Definition: avcodec.h:558
#define av_free(p)
float last_qmf_delay[256+39]
delay line for the last stacked QMF filter
Definition: atrac1.c:70
int len
int channels
number of audio channels
Definition: avcodec.h:1192
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Definition: atrac1.c:85
float low[256]
Definition: atrac1.c:80
av_cold void ff_atrac_generate_tables(void)
Generate common tables.
Definition: atrac.c:63
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:940
FILE * out
Definition: movenc.c:54
#define FFSWAP(type, a, b)
Definition: common.h:108
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:361
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:380
#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:64
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
int i
Definition: input.c:407
static int at1_imdct_block(AT1SUCtx *su, AT1Ctx *q)
Definition: atrac1.c:109
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