FFmpeg
atrac3plusdec.c
Go to the documentation of this file.
1 /*
2  * ATRAC3+ compatible decoder
3  *
4  * Copyright (c) 2010-2013 Maxim Poliakovski
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  * Sony ATRAC3+ compatible decoder.
26  *
27  * Container formats used to store its data:
28  * RIFF WAV (.at3) and Sony OpenMG (.oma, .aa3).
29  *
30  * Technical description of this codec can be found here:
31  * http://wiki.multimedia.cx/index.php?title=ATRAC3plus
32  *
33  * Kudos to Benjamin Larsson and Michael Karcher
34  * for their precious technical help!
35  */
36 
37 #include <stdint.h>
38 #include <string.h>
39 
41 #include "libavutil/float_dsp.h"
42 #include "libavutil/mem_internal.h"
43 #include "libavutil/thread.h"
44 #include "avcodec.h"
45 #include "get_bits.h"
46 #include "internal.h"
47 #include "atrac.h"
48 #include "atrac3plus.h"
49 
50 typedef struct ATRAC3PContext {
53 
54  DECLARE_ALIGNED(32, float, samples)[2][ATRAC3P_FRAME_SAMPLES]; ///< quantized MDCT spectrum
55  DECLARE_ALIGNED(32, float, mdct_buf)[2][ATRAC3P_FRAME_SAMPLES]; ///< output of the IMDCT
56  DECLARE_ALIGNED(32, float, time_buf)[2][ATRAC3P_FRAME_SAMPLES]; ///< output of the gain compensation
58 
59  AtracGCContext gainc_ctx; ///< gain compensation context
61  FFTContext ipqf_dct_ctx; ///< IDCT context used by IPQF
62 
63  Atrac3pChanUnitCtx *ch_units; ///< global channel units
64 
65  int num_channel_blocks; ///< number of channel blocks
66  uint8_t channel_blocks[5]; ///< channel configuration descriptor
67  uint64_t my_channel_layout; ///< current channel layout
69 
71 {
72  ATRAC3PContext *ctx = avctx->priv_data;
73 
74  av_freep(&ctx->ch_units);
75  av_freep(&ctx->fdsp);
76 
77  ff_mdct_end(&ctx->mdct_ctx);
79 
80  return 0;
81 }
82 
84  AVCodecContext *avctx)
85 {
86  memset(ctx->channel_blocks, 0, sizeof(ctx->channel_blocks));
87 
88  switch (avctx->channels) {
89  case 1:
90  if (avctx->channel_layout != AV_CH_FRONT_LEFT)
92 
93  ctx->num_channel_blocks = 1;
94  ctx->channel_blocks[0] = CH_UNIT_MONO;
95  break;
96  case 2:
98  ctx->num_channel_blocks = 1;
100  break;
101  case 3:
103  ctx->num_channel_blocks = 2;
104  ctx->channel_blocks[0] = CH_UNIT_STEREO;
105  ctx->channel_blocks[1] = CH_UNIT_MONO;
106  break;
107  case 4:
109  ctx->num_channel_blocks = 3;
110  ctx->channel_blocks[0] = CH_UNIT_STEREO;
111  ctx->channel_blocks[1] = CH_UNIT_MONO;
112  ctx->channel_blocks[2] = CH_UNIT_MONO;
113  break;
114  case 6:
116  ctx->num_channel_blocks = 4;
117  ctx->channel_blocks[0] = CH_UNIT_STEREO;
118  ctx->channel_blocks[1] = CH_UNIT_MONO;
119  ctx->channel_blocks[2] = CH_UNIT_STEREO;
120  ctx->channel_blocks[3] = CH_UNIT_MONO;
121  break;
122  case 7:
124  ctx->num_channel_blocks = 5;
125  ctx->channel_blocks[0] = CH_UNIT_STEREO;
126  ctx->channel_blocks[1] = CH_UNIT_MONO;
127  ctx->channel_blocks[2] = CH_UNIT_STEREO;
128  ctx->channel_blocks[3] = CH_UNIT_MONO;
129  ctx->channel_blocks[4] = CH_UNIT_MONO;
130  break;
131  case 8:
133  ctx->num_channel_blocks = 5;
134  ctx->channel_blocks[0] = CH_UNIT_STEREO;
135  ctx->channel_blocks[1] = CH_UNIT_MONO;
136  ctx->channel_blocks[2] = CH_UNIT_STEREO;
137  ctx->channel_blocks[3] = CH_UNIT_STEREO;
138  ctx->channel_blocks[4] = CH_UNIT_MONO;
139  break;
140  default:
141  av_log(avctx, AV_LOG_ERROR,
142  "Unsupported channel count: %d!\n", avctx->channels);
143  return AVERROR_INVALIDDATA;
144  }
145 
146  return 0;
147 }
148 
149 static av_cold void atrac3p_init_static(void)
150 {
153 }
154 
156 {
157  static AVOnce init_static_once = AV_ONCE_INIT;
158  ATRAC3PContext *ctx = avctx->priv_data;
159  int i, ch, ret;
160 
161  if (!avctx->block_align) {
162  av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
163  return AVERROR(EINVAL);
164  }
165 
166  /* initialize IPQF */
167  ff_mdct_init(&ctx->ipqf_dct_ctx, 5, 1, 32.0 / 32768.0);
168 
169  ff_atrac3p_init_imdct(avctx, &ctx->mdct_ctx);
170 
172 
173  if ((ret = set_channel_params(ctx, avctx)) < 0)
174  return ret;
175 
176  ctx->my_channel_layout = avctx->channel_layout;
177 
178  ctx->ch_units = av_mallocz_array(ctx->num_channel_blocks, sizeof(*ctx->ch_units));
180 
181  if (!ctx->ch_units || !ctx->fdsp) {
182  return AVERROR(ENOMEM);
183  }
184 
185  for (i = 0; i < ctx->num_channel_blocks; i++) {
186  for (ch = 0; ch < 2; ch++) {
187  ctx->ch_units[i].channels[ch].ch_num = ch;
188  ctx->ch_units[i].channels[ch].wnd_shape = &ctx->ch_units[i].channels[ch].wnd_shape_hist[0][0];
189  ctx->ch_units[i].channels[ch].wnd_shape_prev = &ctx->ch_units[i].channels[ch].wnd_shape_hist[1][0];
190  ctx->ch_units[i].channels[ch].gain_data = &ctx->ch_units[i].channels[ch].gain_data_hist[0][0];
191  ctx->ch_units[i].channels[ch].gain_data_prev = &ctx->ch_units[i].channels[ch].gain_data_hist[1][0];
192  ctx->ch_units[i].channels[ch].tones_info = &ctx->ch_units[i].channels[ch].tones_info_hist[0][0];
193  ctx->ch_units[i].channels[ch].tones_info_prev = &ctx->ch_units[i].channels[ch].tones_info_hist[1][0];
194  }
195 
196  ctx->ch_units[i].waves_info = &ctx->ch_units[i].wave_synth_hist[0];
198  }
199 
201 
202  ff_thread_once(&init_static_once, atrac3p_init_static);
203 
204  return 0;
205 }
206 
208  float out[2][ATRAC3P_FRAME_SAMPLES],
209  int num_channels,
210  AVCodecContext *avctx)
211 {
212  int i, sb, ch, qu, nspeclines, RNG_index;
213  float *dst, q;
214  int16_t *src;
215  /* calculate RNG table index for each subband */
216  int sb_RNG_index[ATRAC3P_SUBBANDS] = { 0 };
217 
218  if (ch_unit->mute_flag) {
219  for (ch = 0; ch < num_channels; ch++)
220  memset(out[ch], 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out[ch]));
221  return;
222  }
223 
224  for (qu = 0, RNG_index = 0; qu < ch_unit->used_quant_units; qu++)
225  RNG_index += ch_unit->channels[0].qu_sf_idx[qu] +
226  ch_unit->channels[1].qu_sf_idx[qu];
227 
228  for (sb = 0; sb < ch_unit->num_coded_subbands; sb++, RNG_index += 128)
229  sb_RNG_index[sb] = RNG_index & 0x3FC;
230 
231  /* inverse quant and power compensation */
232  for (ch = 0; ch < num_channels; ch++) {
233  /* clear channel's residual spectrum */
234  memset(out[ch], 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out[ch]));
235 
236  for (qu = 0; qu < ch_unit->used_quant_units; qu++) {
237  src = &ch_unit->channels[ch].spectrum[ff_atrac3p_qu_to_spec_pos[qu]];
238  dst = &out[ch][ff_atrac3p_qu_to_spec_pos[qu]];
239  nspeclines = ff_atrac3p_qu_to_spec_pos[qu + 1] -
240  ff_atrac3p_qu_to_spec_pos[qu];
241 
242  if (ch_unit->channels[ch].qu_wordlen[qu] > 0) {
243  q = ff_atrac3p_sf_tab[ch_unit->channels[ch].qu_sf_idx[qu]] *
244  ff_atrac3p_mant_tab[ch_unit->channels[ch].qu_wordlen[qu]];
245  for (i = 0; i < nspeclines; i++)
246  dst[i] = src[i] * q;
247  }
248  }
249 
250  for (sb = 0; sb < ch_unit->num_coded_subbands; sb++)
251  ff_atrac3p_power_compensation(ch_unit, ctx->fdsp, ch, &out[ch][0],
252  sb_RNG_index[sb], sb);
253  }
254 
255  if (ch_unit->unit_type == CH_UNIT_STEREO) {
256  for (sb = 0; sb < ch_unit->num_coded_subbands; sb++) {
257  if (ch_unit->swap_channels[sb]) {
258  for (i = 0; i < ATRAC3P_SUBBAND_SAMPLES; i++)
259  FFSWAP(float, out[0][sb * ATRAC3P_SUBBAND_SAMPLES + i],
260  out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i]);
261  }
262 
263  /* flip coefficients' sign if requested */
264  if (ch_unit->negate_coeffs[sb])
265  for (i = 0; i < ATRAC3P_SUBBAND_SAMPLES; i++)
266  out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i] = -(out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i]);
267  }
268  }
269 }
270 
272  int num_channels, AVCodecContext *avctx)
273 {
274  int ch, sb;
275 
276  for (ch = 0; ch < num_channels; ch++) {
277  for (sb = 0; sb < ch_unit->num_subbands; sb++) {
278  /* inverse transform and windowing */
279  ff_atrac3p_imdct(ctx->fdsp, &ctx->mdct_ctx,
280  &ctx->samples[ch][sb * ATRAC3P_SUBBAND_SAMPLES],
281  &ctx->mdct_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],
282  (ch_unit->channels[ch].wnd_shape_prev[sb] << 1) +
283  ch_unit->channels[ch].wnd_shape[sb], sb);
284 
285  /* gain compensation and overlapping */
287  &ctx->mdct_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],
288  &ch_unit->prev_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],
289  &ch_unit->channels[ch].gain_data_prev[sb],
290  &ch_unit->channels[ch].gain_data[sb],
291  ATRAC3P_SUBBAND_SAMPLES,
292  &ctx->time_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES]);
293  }
294 
295  /* zero unused subbands in both output and overlapping buffers */
296  memset(&ch_unit->prev_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES],
297  0,
298  (ATRAC3P_SUBBANDS - ch_unit->num_subbands) *
299  ATRAC3P_SUBBAND_SAMPLES *
300  sizeof(ch_unit->prev_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES]));
301  memset(&ctx->time_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES],
302  0,
303  (ATRAC3P_SUBBANDS - ch_unit->num_subbands) *
304  ATRAC3P_SUBBAND_SAMPLES *
305  sizeof(ctx->time_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES]));
306 
307  /* resynthesize and add tonal signal */
308  if (ch_unit->waves_info->tones_present ||
309  ch_unit->waves_info_prev->tones_present) {
310  for (sb = 0; sb < ch_unit->num_subbands; sb++)
311  if (ch_unit->channels[ch].tones_info[sb].num_wavs ||
312  ch_unit->channels[ch].tones_info_prev[sb].num_wavs) {
313  ff_atrac3p_generate_tones(ch_unit, ctx->fdsp, ch, sb,
314  &ctx->time_buf[ch][sb * 128]);
315  }
316  }
317 
318  /* subband synthesis and acoustic signal output */
319  ff_atrac3p_ipqf(&ctx->ipqf_dct_ctx, &ch_unit->ipqf_ctx[ch],
320  &ctx->time_buf[ch][0], &ctx->outp_buf[ch][0]);
321  }
322 
323  /* swap window shape and gain control buffers. */
324  for (ch = 0; ch < num_channels; ch++) {
325  FFSWAP(uint8_t *, ch_unit->channels[ch].wnd_shape,
326  ch_unit->channels[ch].wnd_shape_prev);
327  FFSWAP(AtracGainInfo *, ch_unit->channels[ch].gain_data,
328  ch_unit->channels[ch].gain_data_prev);
329  FFSWAP(Atrac3pWavesData *, ch_unit->channels[ch].tones_info,
330  ch_unit->channels[ch].tones_info_prev);
331  }
332 
334 }
335 
336 static int atrac3p_decode_frame(AVCodecContext *avctx, void *data,
337  int *got_frame_ptr, AVPacket *avpkt)
338 {
339  ATRAC3PContext *ctx = avctx->priv_data;
340  AVFrame *frame = data;
341  int i, ret, ch_unit_id, ch_block = 0, out_ch_index = 0, channels_to_process;
342  float **samples_p = (float **)frame->extended_data;
343 
345  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
346  return ret;
347 
348  if ((ret = init_get_bits8(&ctx->gb, avpkt->data, avpkt->size)) < 0)
349  return ret;
350 
351  if (get_bits1(&ctx->gb)) {
352  av_log(avctx, AV_LOG_ERROR, "Invalid start bit!\n");
353  return AVERROR_INVALIDDATA;
354  }
355 
356  while (get_bits_left(&ctx->gb) >= 2 &&
357  (ch_unit_id = get_bits(&ctx->gb, 2)) != CH_UNIT_TERMINATOR) {
358  if (ch_unit_id == CH_UNIT_EXTENSION) {
359  avpriv_report_missing_feature(avctx, "Channel unit extension");
360  return AVERROR_PATCHWELCOME;
361  }
362  if (ch_block >= ctx->num_channel_blocks ||
363  ctx->channel_blocks[ch_block] != ch_unit_id) {
364  av_log(avctx, AV_LOG_ERROR,
365  "Frame data doesn't match channel configuration!\n");
366  return AVERROR_INVALIDDATA;
367  }
368 
369  ctx->ch_units[ch_block].unit_type = ch_unit_id;
370  channels_to_process = ch_unit_id + 1;
371 
372  if ((ret = ff_atrac3p_decode_channel_unit(&ctx->gb,
373  &ctx->ch_units[ch_block],
374  channels_to_process,
375  avctx)) < 0)
376  return ret;
377 
378  decode_residual_spectrum(ctx, &ctx->ch_units[ch_block], ctx->samples,
379  channels_to_process, avctx);
380  reconstruct_frame(ctx, &ctx->ch_units[ch_block],
381  channels_to_process, avctx);
382 
383  for (i = 0; i < channels_to_process; i++)
384  memcpy(samples_p[out_ch_index + i], ctx->outp_buf[i],
385  ATRAC3P_FRAME_SAMPLES * sizeof(**samples_p));
386 
387  ch_block++;
388  out_ch_index += channels_to_process;
389  }
390 
391  *got_frame_ptr = 1;
392 
393  return avctx->codec_id == AV_CODEC_ID_ATRAC3P ? FFMIN(avctx->block_align, avpkt->size) : avpkt->size;
394 }
395 
397  .name = "atrac3plus",
398  .long_name = NULL_IF_CONFIG_SMALL("ATRAC3+ (Adaptive TRansform Acoustic Coding 3+)"),
399  .type = AVMEDIA_TYPE_AUDIO,
400  .id = AV_CODEC_ID_ATRAC3P,
401  .capabilities = AV_CODEC_CAP_DR1,
403  .priv_data_size = sizeof(ATRAC3PContext),
405  .close = atrac3p_decode_close,
407 };
408 
410  .name = "atrac3plusal",
411  .long_name = NULL_IF_CONFIG_SMALL("ATRAC3+ AL (Adaptive TRansform Acoustic Coding 3+ Advanced Lossless)"),
412  .type = AVMEDIA_TYPE_AUDIO,
413  .id = AV_CODEC_ID_ATRAC3PAL,
414  .capabilities = AV_CODEC_CAP_DR1,
416  .priv_data_size = sizeof(ATRAC3PContext),
418  .close = atrac3p_decode_close,
420 };
#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 prev_buf[2][ATRAC3P_FRAME_SAMPLES]
overlapping buffer
Definition: atrac3plus.h:155
float, planar
Definition: samplefmt.h:69
const float ff_atrac3p_sf_tab[64]
Definition: atrac3plusdsp.c:54
#define AV_CH_LAYOUT_7POINT1
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
Atrac3pWaveSynthParams wave_synth_hist[2]
waves synth history for two frames
Definition: atrac3plus.h:150
const uint16_t ff_atrac3p_qu_to_spec_pos[33]
Map quant unit number to its position in the spectrum.
Definition: atrac3plusdsp.c:44
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
Atrac3pChanUnitCtx * ch_units
global channel units
Definition: atrac3plusdec.c:63
#define AV_CH_LAYOUT_SURROUND
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static av_cold void atrac3p_init_static(void)
GetBitContext gb
Definition: atrac3plusdec.c:51
Atrac3pWavesData * tones_info_prev
Definition: atrac3plus.h:117
int num_coded_subbands
number of subbands with coded spectrum
Definition: atrac3plus.h:139
int size
Definition: packet.h:364
#define AV_CH_LAYOUT_4POINT0
static av_cold int atrac3p_decode_close(AVCodecContext *avctx)
Definition: atrac3plusdec.c:70
int num_wavs
number of sine waves in the group
Definition: atrac3plus.h:78
#define AV_CH_LAYOUT_STEREO
AVCodec.
Definition: codec.h:190
int used_quant_units
number of quant units with coded spectrum
Definition: atrac3plus.h:138
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 void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static void decode_residual_spectrum(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit, float out[2][ATRAC3P_FRAME_SAMPLES], int num_channels, AVCodecContext *avctx)
uint8_t negate_coeffs[ATRAC3P_SUBBANDS]
1 - subband-wise IMDCT coefficients negation
Definition: atrac3plus.h:146
#define ATRAC3P_SUBBANDS
Global unit sizes.
Definition: atrac3plus.h:42
AtracGCContext gainc_ctx
gain compensation context
Definition: atrac3plusdec.c:59
AtracGainInfo * gain_data_prev
gain control data for previous frame
Definition: atrac3plus.h:111
#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
int16_t spectrum[2048]
decoded IMDCT spectrum
Definition: atrac3plus.h:100
float mdct_buf[2][ATRAC3P_FRAME_SAMPLES]
output of the IMDCT
Definition: atrac3plusdec.c:55
static void reconstruct_frame(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit, int num_channels, AVCodecContext *avctx)
#define ATRAC3P_FRAME_SAMPLES
Definition: atrac3plus.h:44
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels, AVCodecContext *avctx)
Decode bitstream data of a channel unit.
Definition: atrac3plus.c:1662
uint8_t * data
Definition: packet.h:363
ATRAC common header.
int qu_sf_idx[32]
array of scale factor indexes for each quant unit
Definition: atrac3plus.h:98
bitstream reader API header.
#define AVOnce
Definition: thread.h:172
uint8_t * wnd_shape
IMDCT window shape for current frame.
Definition: atrac3plus.h:105
#define av_log(a,...)
void ff_atrac3p_imdct(AVFloatDSPContext *fdsp, FFTContext *mdct_ctx, float *pIn, float *pOut, int wind_id, int sb)
Regular IMDCT and windowing without overlapping, with spectrum reversal in the odd subbands...
#define src
Definition: vp8dsp.c:255
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int num_channel_blocks
number of channel blocks
Definition: atrac3plusdec.c:65
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
uint8_t * wnd_shape_prev
IMDCT window shape for previous frame.
Definition: atrac3plus.h:106
void ff_atrac3p_ipqf(FFTContext *dct_ctx, Atrac3pIPQFChannelCtx *hist, const float *in, float *out)
Subband synthesis filter based on the polyphase quadrature (pseudo-QMF) filter bank.
Parameters of a group of sine waves.
Definition: atrac3plus.h:75
static av_cold int set_channel_params(ATRAC3PContext *ctx, AVCodecContext *avctx)
Definition: atrac3plusdec.c:83
void ff_atrac3p_init_dsp_static(void)
Initialize sine waves synthesizer and ff_sine_* tables.
Definition: atrac3plusdsp.c:96
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
static const float qu[2]
Definition: sipr16kdata.h:28
AVFloatDSPContext * fdsp
Definition: atrac3plusdec.c:52
static av_cold int atrac3p_decode_init(AVCodecContext *avctx)
Gain compensation context structure.
Definition: atrac.h:44
int qu_wordlen[32]
array of word lengths for each quant unit
Definition: atrac3plus.h:97
av_cold void ff_atrac_init_gain_compensation(AtracGCContext *gctx, int id2exp_offset, int loc_scale)
Initialize gain compensation context.
Definition: atrac.c:69
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
#define ATRAC3P_SUBBAND_SAMPLES
number of samples per subband
Definition: atrac3plus.h:43
float samples[2][ATRAC3P_FRAME_SAMPLES]
quantized MDCT spectrum
Definition: atrac3plusdec.c:54
Definition: fft.h:83
unit containing one coded channel
Definition: atrac3plus.h:53
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
#define FFMIN(a, b)
Definition: common.h:105
float time_buf[2][ATRAC3P_FRAME_SAMPLES]
output of the gain compensation
Definition: atrac3plusdec.c:56
Atrac3pWavesData * tones_info
Definition: atrac3plus.h:116
AVFormatContext * ctx
Definition: movenc.c:48
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
int unit_type
unit type (mono/stereo)
Definition: atrac3plus.h:135
uint8_t swap_channels[ATRAC3P_SUBBANDS]
1 - perform subband-wise channel swapping
Definition: atrac3plus.h:145
void ff_atrac3p_power_compensation(Atrac3pChanUnitCtx *ctx, AVFloatDSPContext *fdsp, int ch_index, float *sp, int rng_index, int sb_num)
Perform power compensation aka noise dithering.
av_cold void ff_atrac3p_init_vlcs(void)
Initialize VLC tables for bitstream parsing.
Definition: atrac3plus.c:76
#define AV_CH_LAYOUT_5POINT1_BACK
#define AV_CH_LAYOUT_6POINT1_BACK
if(ret)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
uint8_t channel_blocks[5]
channel configuration descriptor
Definition: atrac3plusdec.c:66
void ff_atrac3p_init_imdct(AVCodecContext *avctx, FFTContext *mdct_ctx)
Initialize IMDCT transform.
Definition: atrac3plusdsp.c:82
#define AV_ONCE_INIT
Definition: thread.h:173
Gain control parameters for one subband.
Definition: atrac.h:35
Libavcodec external API header.
void ff_atrac3p_generate_tones(Atrac3pChanUnitCtx *ch_unit, AVFloatDSPContext *fdsp, int ch_num, int sb, float *out)
Synthesize sine waves for a particular subband.
enum AVCodecID codec_id
Definition: avcodec.h:541
float outp_buf[2][ATRAC3P_FRAME_SAMPLES]
Definition: atrac3plusdec.c:57
AVCodec ff_atrac3p_decoder
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static int atrac3p_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
main external API structure.
Definition: avcodec.h:531
#define AV_CH_FRONT_LEFT
Atrac3pIPQFChannelCtx ipqf_ctx[2]
Definition: atrac3plus.h:154
Channel unit parameters.
Definition: atrac3plus.h:133
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
unit sequence terminator
Definition: atrac3plus.h:56
AVCodec ff_atrac3pal_decoder
const float ff_atrac3p_mant_tab[8]
Definition: atrac3plusdsp.c:69
Atrac3pWaveSynthParams * waves_info_prev
Definition: atrac3plus.h:152
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t wnd_shape_hist[2][ATRAC3P_SUBBANDS]
IMDCT window shape, 0=sine/1=steep.
Definition: atrac3plus.h:104
common internal api header.
AtracGainInfo * gain_data
gain control data for next frame
Definition: atrac3plus.h:110
#define ff_mdct_end
Definition: fft.h:162
FFTContext mdct_ctx
Definition: atrac3plusdec.c:60
unit containing two jointly-coded channels
Definition: atrac3plus.h:54
Atrac3pWaveSynthParams * waves_info
Definition: atrac3plus.h:151
void * priv_data
Definition: avcodec.h:558
int channels
number of audio channels
Definition: avcodec.h:1192
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
Atrac3pChanParams channels[2]
Definition: atrac3plus.h:147
void ff_atrac_gain_compensation(AtracGCContext *gctx, float *in, float *prev, AtracGainInfo *gc_now, AtracGainInfo *gc_next, int num_samples, float *out)
Apply gain compensation and perform the MDCT overlapping part.
Definition: atrac.c:87
uint64_t my_channel_layout
current channel layout
Definition: atrac3plusdec.c:67
FILE * out
Definition: movenc.c:54
#define av_freep(p)
int mute_flag
mute flag
Definition: atrac3plus.h:140
#define FFSWAP(type, a, b)
Definition: common.h:108
int tones_present
1 - tones info present
Definition: atrac3plus.h:122
FFTContext ipqf_dct_ctx
IDCT context used by IPQF.
Definition: atrac3plusdec.c:61
unit containing extension information
Definition: atrac3plus.h:55
Atrac3pWavesData tones_info_hist[2][ATRAC3P_SUBBANDS]
Definition: atrac3plus.h:115
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
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: packet.h:340
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
Global structures, constants and data for ATRAC3+ decoder.
for(j=16;j >0;--j)
int i
Definition: input.c:407
AtracGainInfo gain_data_hist[2][ATRAC3P_SUBBANDS]
gain control data for all subbands
Definition: atrac3plus.h:109
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190