FFmpeg: libavcodec/atrac3plusdec.c Source File

FFmpeg

[フレーム]

libavcodec

atrac3plusdec.c

Go to the documentation of this file.

1 /*

2 * ATRAC3+ compatible decoder

3 *

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 */

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 */

37 #include <stdint.h>

38 #include <string.h>

40 #include "libavutil/channel_layout.h"

41 #include "libavutil/float_dsp.h"

42 #include "libavutil/mem.h"

43 #include "libavutil/mem_internal.h"

44 #include "libavutil/thread.h"

45 #include "avcodec.h"

46 #include "codec_internal.h"

47 #include "decode.h"

48 #include "get_bits.h"

49 #include "atrac.h"

50 #include "atrac3plus.h"

52 static const uint8_t channel_map[8][8] = {

53 { 0, },

54 { 0, 1, },

55 { 0, 1, 2, },

56 { 0, 1, 2, 3, },

57 { 0, },

58 { 0, 1, 2, 4, 5, 3, },

59 { 0, 1, 2, 4, 5, 6, 3, },

60 { 0, 1, 2, 4, 5, 6, 7, 3, },

61 };

63 typedef struct ATRAC3PContext {

64 GetBitContext gb;

65 AVFloatDSPContext *fdsp;

67 DECLARE_ALIGNED(32, float, samples)[2][ATRAC3P_FRAME_SAMPLES]; ///< quantized MDCT spectrum

68 DECLARE_ALIGNED(32, float, mdct_buf)[2][ATRAC3P_FRAME_SAMPLES]; ///< output of the IMDCT

69 DECLARE_ALIGNED(32, float, time_buf)[2][ATRAC3P_FRAME_SAMPLES]; ///< output of the gain compensation

70 DECLARE_ALIGNED(32, float, outp_buf)[2][ATRAC3P_FRAME_SAMPLES];

72 AtracGCContext gainc_ctx; ///< gain compensation context

73 AVTXContext *mdct_ctx;

74 av_tx_fn mdct_fn;

75 AVTXContext *ipqf_dct_ctx; ///< IDCT context used by IPQF

76 av_tx_fn ipqf_dct_fn;

78 Atrac3pChanUnitCtx *ch_units; ///< global channel units

80 int num_channel_blocks; ///< number of channel blocks

81 uint8_t channel_blocks[5]; ///< channel configuration descriptor

82 const uint8_t *channel_map; ///< channel layout map

83 } ATRAC3PContext;

85 static av_cold int atrac3p_decode_close(AVCodecContext *avctx)

86 {

87 ATRAC3PContext *ctx = avctx->priv_data;

89 av_freep(&ctx->ch_units);

90 av_freep(&ctx->fdsp);

92 av_tx_uninit(&ctx->mdct_ctx);

93 av_tx_uninit(&ctx->ipqf_dct_ctx);

95 return 0;

96 }

98 static av_cold int set_channel_params(ATRAC3PContext *ctx,

99 AVCodecContext *avctx)

100 {

101 int channels = avctx->ch_layout.nb_channels;

102 memset(ctx->channel_blocks, 0, sizeof(ctx->channel_blocks));

103

104 av_channel_layout_uninit(&avctx->ch_layout);

105 switch (channels) {

106 case 1:

107 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

108 ctx->num_channel_blocks = 1;

109 ctx->channel_blocks[0] = CH_UNIT_MONO;

110 break;

111 case 2:

112 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;

113 ctx->num_channel_blocks = 1;

114 ctx->channel_blocks[0] = CH_UNIT_STEREO;

115 break;

116 case 3:

117 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_SURROUND;

118 ctx->num_channel_blocks = 2;

119 ctx->channel_blocks[0] = CH_UNIT_STEREO;

120 ctx->channel_blocks[1] = CH_UNIT_MONO;

121 break;

122 case 4:

123 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_4POINT0;

124 ctx->num_channel_blocks = 3;

125 ctx->channel_blocks[0] = CH_UNIT_STEREO;

126 ctx->channel_blocks[1] = CH_UNIT_MONO;

127 ctx->channel_blocks[2] = CH_UNIT_MONO;

128 break;

129 case 6:

130 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1_BACK;

131 ctx->num_channel_blocks = 4;

132 ctx->channel_blocks[0] = CH_UNIT_STEREO;

133 ctx->channel_blocks[1] = CH_UNIT_MONO;

134 ctx->channel_blocks[2] = CH_UNIT_STEREO;

135 ctx->channel_blocks[3] = CH_UNIT_MONO;

136 break;

137 case 7:

138 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_6POINT1_BACK;

139 ctx->num_channel_blocks = 5;

140 ctx->channel_blocks[0] = CH_UNIT_STEREO;

141 ctx->channel_blocks[1] = CH_UNIT_MONO;

142 ctx->channel_blocks[2] = CH_UNIT_STEREO;

143 ctx->channel_blocks[3] = CH_UNIT_MONO;

144 ctx->channel_blocks[4] = CH_UNIT_MONO;

145 break;

146 case 8:

147 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_7POINT1;

148 ctx->num_channel_blocks = 5;

149 ctx->channel_blocks[0] = CH_UNIT_STEREO;

150 ctx->channel_blocks[1] = CH_UNIT_MONO;

151 ctx->channel_blocks[2] = CH_UNIT_STEREO;

152 ctx->channel_blocks[3] = CH_UNIT_STEREO;

153 ctx->channel_blocks[4] = CH_UNIT_MONO;

154 break;

155 default:

156 av_log(avctx, AV_LOG_ERROR,

157 "Unsupported channel count: %d!\n", channels);

158 return AVERROR_INVALIDDATA;

159 }

160

161 ctx->channel_map = channel_map[channels - 1];

162

163 return 0;

164 }

165

166 static av_cold void atrac3p_init_static(void)

167 {

168 ff_atrac3p_init_vlcs();

169 ff_atrac3p_init_dsp_static();

170 }

171

172 static av_cold int atrac3p_decode_init(AVCodecContext *avctx)

173 {

174 static AVOnce init_static_once = AV_ONCE_INIT;

175 ATRAC3PContext *ctx = avctx->priv_data;

176 float scale;

177 int i, ch, ret;

178

179 if (!avctx->block_align) {

180 av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");

181 return AVERROR(EINVAL);

182 }

183

184 /* initialize IPQF */

185 scale = 32.0 / 32768.0;

186 ret = av_tx_init(&ctx->ipqf_dct_ctx, &ctx->ipqf_dct_fn, AV_TX_FLOAT_MDCT,

187 1, 16, &scale, 0);

188 if (ret < 0)

189 return ret;

190

191 scale = -1.0f;

192 ret = av_tx_init(&ctx->mdct_ctx, &ctx->mdct_fn, AV_TX_FLOAT_MDCT,

193 1, 128, &scale, AV_TX_FULL_IMDCT);

194 if (ret < 0)

195 return ret;

196

197 ff_atrac_init_gain_compensation(&ctx->gainc_ctx, 6, 2);

198

199 if ((ret = set_channel_params(ctx, avctx)) < 0)

200 return ret;

201

202 ctx->ch_units = av_calloc(ctx->num_channel_blocks, sizeof(*ctx->ch_units));

203 ctx->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);

204

205 if (!ctx->ch_units || !ctx->fdsp) {

206 return AVERROR(ENOMEM);

207 }

208

209 for (i = 0; i < ctx->num_channel_blocks; i++) {

210 for (ch = 0; ch < 2; ch++) {

211 ctx->ch_units[i].channels[ch].ch_num = ch;

212 ctx->ch_units[i].channels[ch].wnd_shape = &ctx->ch_units[i].channels[ch].wnd_shape_hist[0][0];

213 ctx->ch_units[i].channels[ch].wnd_shape_prev = &ctx->ch_units[i].channels[ch].wnd_shape_hist[1][0];

214 ctx->ch_units[i].channels[ch].gain_data = &ctx->ch_units[i].channels[ch].gain_data_hist[0][0];

215 ctx->ch_units[i].channels[ch].gain_data_prev = &ctx->ch_units[i].channels[ch].gain_data_hist[1][0];

216 ctx->ch_units[i].channels[ch].tones_info = &ctx->ch_units[i].channels[ch].tones_info_hist[0][0];

217 ctx->ch_units[i].channels[ch].tones_info_prev = &ctx->ch_units[i].channels[ch].tones_info_hist[1][0];

218 }

219

220 ctx->ch_units[i].waves_info = &ctx->ch_units[i].wave_synth_hist[0];

221 ctx->ch_units[i].waves_info_prev = &ctx->ch_units[i].wave_synth_hist[1];

222 }

223

224 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

225

226 ff_thread_once(&init_static_once, atrac3p_init_static);

227

228 return 0;

229 }

230

231 static void decode_residual_spectrum(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit,

232 float out[2][ATRAC3P_FRAME_SAMPLES],

233 int num_channels,

234 AVCodecContext *avctx)

235 {

236 int i, sb, ch, qu, nspeclines, RNG_index;

237 float *dst, q;

238 int16_t *src;

239 /* calculate RNG table index for each subband */

240 int sb_RNG_index[ATRAC3P_SUBBANDS] = { 0 };

241

242 if (ch_unit->mute_flag) {

243 for (ch = 0; ch < num_channels; ch++)

244 memset(out[ch], 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out[ch]));

245 return;

246 }

247

248 for (qu = 0, RNG_index = 0; qu < ch_unit->used_quant_units; qu++)

249 RNG_index += ch_unit->channels[0].qu_sf_idx[qu] +

250 ch_unit->channels[1].qu_sf_idx[qu];

251

252 for (sb = 0; sb < ch_unit->num_coded_subbands; sb++, RNG_index += 128)

253 sb_RNG_index[sb] = RNG_index & 0x3FC;

254

255 /* inverse quant and power compensation */

256 for (ch = 0; ch < num_channels; ch++) {

257 /* clear channel's residual spectrum */

258 memset(out[ch], 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out[ch]));

259

260 for (qu = 0; qu < ch_unit->used_quant_units; qu++) {

261 src = &ch_unit->channels[ch].spectrum[ff_atrac3p_qu_to_spec_pos[qu]];

262 dst = &out[ch][ff_atrac3p_qu_to_spec_pos[qu]];

263 nspeclines = ff_atrac3p_qu_to_spec_pos[qu + 1] -

264 ff_atrac3p_qu_to_spec_pos[qu];

265

266 if (ch_unit->channels[ch].qu_wordlen[qu] > 0) {

267 q = ff_atrac3p_sf_tab[ch_unit->channels[ch].qu_sf_idx[qu]] *

268 ff_atrac3p_mant_tab[ch_unit->channels[ch].qu_wordlen[qu]];

269 for (i = 0; i < nspeclines; i++)

270 dst[i] = src[i] * q;

271 }

272 }

273

274 for (sb = 0; sb < ch_unit->num_coded_subbands; sb++)

275 ff_atrac3p_power_compensation(ch_unit, ctx->fdsp, ch, &out[ch][0],

276 sb_RNG_index[sb], sb);

277 }

278

279 if (ch_unit->unit_type == CH_UNIT_STEREO) {

280 for (sb = 0; sb < ch_unit->num_coded_subbands; sb++) {

281 if (ch_unit->swap_channels[sb]) {

282 for (i = 0; i < ATRAC3P_SUBBAND_SAMPLES; i++)

283 FFSWAP(float, out[0][sb * ATRAC3P_SUBBAND_SAMPLES + i],

284 out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i]);

285 }

286

287 /* flip coefficients' sign if requested */

288 if (ch_unit->negate_coeffs[sb])

289 for (i = 0; i < ATRAC3P_SUBBAND_SAMPLES; i++)

290 out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i] = -(out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i]);

291 }

292 }

293 }

294

295 static void reconstruct_frame(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit,

296 int num_channels, AVCodecContext *avctx)

297 {

298 int ch, sb;

299

300 for (ch = 0; ch < num_channels; ch++) {

301 for (sb = 0; sb < ch_unit->num_subbands; sb++) {

302 /* inverse transform and windowing */

303 ff_atrac3p_imdct(ctx->fdsp, ctx->mdct_ctx, ctx->mdct_fn,

304 &ctx->samples[ch][sb * ATRAC3P_SUBBAND_SAMPLES],

305 &ctx->mdct_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],

306 (ch_unit->channels[ch].wnd_shape_prev[sb] << 1) +

307 ch_unit->channels[ch].wnd_shape[sb], sb);

308

309 /* gain compensation and overlapping */

310 ff_atrac_gain_compensation(&ctx->gainc_ctx,

311 &ctx->mdct_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],

312 &ch_unit->prev_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],

313 &ch_unit->channels[ch].gain_data_prev[sb],

314 &ch_unit->channels[ch].gain_data[sb],

315 ATRAC3P_SUBBAND_SAMPLES,

316 &ctx->time_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES]);

317 }

318

319 /* zero unused subbands in both output and overlapping buffers */

320 memset(&ch_unit->prev_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES],

321 0,

322 (ATRAC3P_SUBBANDS - ch_unit->num_subbands) *

323 ATRAC3P_SUBBAND_SAMPLES *

324 sizeof(ch_unit->prev_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES]));

325 memset(&ctx->time_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES],

326 0,

327 (ATRAC3P_SUBBANDS - ch_unit->num_subbands) *

328 ATRAC3P_SUBBAND_SAMPLES *

329 sizeof(ctx->time_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES]));

330

331 /* resynthesize and add tonal signal */

332 if (ch_unit->waves_info->tones_present ||

333 ch_unit->waves_info_prev->tones_present) {

334 for (sb = 0; sb < ch_unit->num_subbands; sb++)

335 if (ch_unit->channels[ch].tones_info[sb].num_wavs ||

336 ch_unit->channels[ch].tones_info_prev[sb].num_wavs) {

337 ff_atrac3p_generate_tones(ch_unit, ctx->fdsp, ch, sb,

338 &ctx->time_buf[ch][sb * 128]);

339 }

340 }

341

342 /* subband synthesis and acoustic signal output */

343 ff_atrac3p_ipqf(ctx->ipqf_dct_ctx, ctx->ipqf_dct_fn,

344 &ch_unit->ipqf_ctx[ch], &ctx->time_buf[ch][0],

345 &ctx->outp_buf[ch][0]);

346 }

347

348 /* swap window shape and gain control buffers. */

349 for (ch = 0; ch < num_channels; ch++) {

350 FFSWAP(uint8_t *, ch_unit->channels[ch].wnd_shape,

351 ch_unit->channels[ch].wnd_shape_prev);

352 FFSWAP(AtracGainInfo *, ch_unit->channels[ch].gain_data,

353 ch_unit->channels[ch].gain_data_prev);

354 FFSWAP(Atrac3pWavesData *, ch_unit->channels[ch].tones_info,

355 ch_unit->channels[ch].tones_info_prev);

356 }

357

358 FFSWAP(Atrac3pWaveSynthParams *, ch_unit->waves_info, ch_unit->waves_info_prev);

359 }

360

361 static int atrac3p_decode_frame(AVCodecContext *avctx, AVFrame *frame,

362 int *got_frame_ptr, AVPacket *avpkt)

363 {

364 ATRAC3PContext *ctx = avctx->priv_data;

365 int i, ret, ch_unit_id, ch_block = 0, out_ch_index = 0, channels_to_process;

366 float **samples_p = (float **)frame->extended_data;

367

368 frame->nb_samples = ATRAC3P_FRAME_SAMPLES;

369 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

370 return ret;

371

372 if ((ret = init_get_bits8(&ctx->gb, avpkt->data, avpkt->size)) < 0)

373 return ret;

374

375 if (get_bits1(&ctx->gb)) {

376 av_log(avctx, AV_LOG_ERROR, "Invalid start bit!\n");

377 return AVERROR_INVALIDDATA;

378 }

379

380 while (get_bits_left(&ctx->gb) >= 2 &&

381 (ch_unit_id = get_bits(&ctx->gb, 2)) != CH_UNIT_TERMINATOR) {

382 if (ch_unit_id == CH_UNIT_EXTENSION) {

383 avpriv_report_missing_feature(avctx, "Channel unit extension");

384 return AVERROR_PATCHWELCOME;

385 }

386 if (ch_block >= ctx->num_channel_blocks ||

387 ctx->channel_blocks[ch_block] != ch_unit_id) {

388 av_log(avctx, AV_LOG_ERROR,

389 "Frame data doesn't match channel configuration!\n");

390 return AVERROR_INVALIDDATA;

391 }

392

393 ctx->ch_units[ch_block].unit_type = ch_unit_id;

394 channels_to_process = ch_unit_id + 1;

395

396 if ((ret = ff_atrac3p_decode_channel_unit(&ctx->gb,

397 &ctx->ch_units[ch_block],

398 channels_to_process,

399 avctx)) < 0)

400 return ret;

401

402 decode_residual_spectrum(ctx, &ctx->ch_units[ch_block], ctx->samples,

403 channels_to_process, avctx);

404 reconstruct_frame(ctx, &ctx->ch_units[ch_block],

405 channels_to_process, avctx);

406

407 for (i = 0; i < channels_to_process; i++)

408 memcpy(samples_p[ctx->channel_map[out_ch_index + i]], ctx->outp_buf[i],

409 ATRAC3P_FRAME_SAMPLES * sizeof(**samples_p));

410

411 ch_block++;

412 out_ch_index += channels_to_process;

413 }

414

415 *got_frame_ptr = 1;

416

417 return avctx->codec_id == AV_CODEC_ID_ATRAC3P ? FFMIN(avctx->block_align, avpkt->size) : avpkt->size;

418 }

419

420 const FFCodec ff_atrac3p_decoder = {

421 .p.name = "atrac3plus",

422 CODEC_LONG_NAME("ATRAC3+ (Adaptive TRansform Acoustic Coding 3+)"),

423 .p.type = AVMEDIA_TYPE_AUDIO,

424 .p.id = AV_CODEC_ID_ATRAC3P,

425 .p.capabilities = AV_CODEC_CAP_DR1,

426 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

427 .priv_data_size = sizeof(ATRAC3PContext),

428 .init = atrac3p_decode_init,

429 .close = atrac3p_decode_close,

430 FF_CODEC_DECODE_CB(atrac3p_decode_frame),

431 };

432

433 const FFCodec ff_atrac3pal_decoder = {

434 .p.name = "atrac3plusal",

435 CODEC_LONG_NAME("ATRAC3+ AL (Adaptive TRansform Acoustic Coding 3+ Advanced Lossless)"),

436 .p.type = AVMEDIA_TYPE_AUDIO,

437 .p.id = AV_CODEC_ID_ATRAC3PAL,

438 .p.capabilities = AV_CODEC_CAP_DR1,

439 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

440 .priv_data_size = sizeof(ATRAC3PContext),

441 .init = atrac3p_decode_init,

442 .close = atrac3p_decode_close,

443 FF_CODEC_DECODE_CB(atrac3p_decode_frame),

444 };

Atrac3pChanUnitCtx::waves_info

Atrac3pWaveSynthParams * waves_info

Definition: atrac3plus.h:151

ATRAC3PContext::channel_map

const uint8_t * channel_map

channel layout map

Definition: atrac3plusdec.c:82

ff_atrac3p_init_dsp_static

void ff_atrac3p_init_dsp_static(void)

Initialize sine waves synthesizer and ff_sine_* tables.

Definition: atrac3plusdsp.c:88

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:42

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:689

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

Atrac3pChanParams::tones_info_prev

Atrac3pWavesData * tones_info_prev

Definition: atrac3plus.h:117

mem_internal.h

out

FILE * out

Definition: movenc.c:55

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:395

thread.h

Atrac3pWavesData::num_wavs

int num_wavs

number of sine waves in the group

Definition: atrac3plus.h:78

AVTXContext

Definition: tx_priv.h:235

ATRAC3PContext::gainc_ctx

AtracGCContext gainc_ctx

gain compensation context

Definition: atrac3plusdec.c:72

atrac3p_decode_close

static av_cold int atrac3p_decode_close(AVCodecContext *avctx)

Definition: atrac3plusdec.c:85

reconstruct_frame

static void reconstruct_frame(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit, int num_channels, AVCodecContext *avctx)

Definition: atrac3plusdec.c:295

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

AVPacket::data

uint8_t * data

Definition: packet.h:558

Atrac3pChanUnitCtx::ipqf_ctx

Atrac3pIPQFChannelCtx ipqf_ctx[2]

Definition: atrac3plus.h:154

ff_atrac3p_generate_tones

void ff_atrac3p_generate_tones(Atrac3pChanUnitCtx *ch_unit, AVFloatDSPContext *fdsp, int ch_num, int sb, float *out)

Synthesize sine waves for a particular subband.

Definition: atrac3plusdsp.c:178

ATRAC3PContext::ch_units

Atrac3pChanUnitCtx * ch_units

global channel units

Definition: atrac3plusdec.c:78

atrac3p_init_static

static av_cold void atrac3p_init_static(void)

Definition: atrac3plusdec.c:166

FFCodec

Definition: codec_internal.h:127

ff_atrac3p_power_compensation

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.

Definition: atrac3plusdsp.c:412

ATRAC3PContext

Definition: atrac3plusdec.c:63

AV_CODEC_ID_ATRAC3PAL

@ AV_CODEC_ID_ATRAC3PAL

Definition: codec_id.h:542

Atrac3pChanUnitCtx::negate_coeffs

uint8_t negate_coeffs[ATRAC3P_SUBBANDS]

1 - subband-wise IMDCT coefficients negation

Definition: atrac3plus.h:146

ATRAC3PContext::mdct_buf

float mdct_buf[2][ATRAC3P_FRAME_SAMPLES]

output of the IMDCT

Definition: atrac3plusdec.c:68

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

atrac3p_decode_frame

static int atrac3p_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)

Definition: atrac3plusdec.c:361

av_tx_init

av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)

Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...

Definition: tx.c:903

ATRAC3P_FRAME_SAMPLES

#define ATRAC3P_FRAME_SAMPLES

Definition: atrac3plus.h:44

CH_UNIT_EXTENSION

@ CH_UNIT_EXTENSION

unit containing extension information

Definition: atrac3plus.h:55

Atrac3pChanParams::wnd_shape

uint8_t * wnd_shape

IMDCT window shape for current frame.

Definition: atrac3plus.h:105

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:135

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:333

ATRAC3PContext::gb

GetBitContext gb

Definition: atrac3plusdec.c:64

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

decode_residual_spectrum

static void decode_residual_spectrum(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit, float out[2][ATRAC3P_FRAME_SAMPLES], int num_channels, AVCodecContext *avctx)

Definition: atrac3plusdec.c:231

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

GetBitContext

Definition: get_bits.h:109

set_channel_params

static av_cold int set_channel_params(ATRAC3PContext *ctx, AVCodecContext *avctx)

Definition: atrac3plusdec.c:98

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:488

ff_atrac_init_gain_compensation

av_cold void ff_atrac_init_gain_compensation(AtracGCContext *gctx, int id2exp_offset, int loc_scale)

Initialize gain compensation context.

Definition: atrac.c:67

Atrac3pWaveSynthParams

Definition: atrac3plus.h:121

AV_CHANNEL_LAYOUT_SURROUND

#define AV_CHANNEL_LAYOUT_SURROUND

Definition: channel_layout.h:398

atrac3p_decode_init

static av_cold int atrac3p_decode_init(AVCodecContext *avctx)

Definition: atrac3plusdec.c:172

ff_atrac3p_sf_tab

const float ff_atrac3p_sf_tab[64]

Definition: atrac3plusdsp.c:52

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

AV_CODEC_ID_ATRAC3P

@ AV_CODEC_ID_ATRAC3P

Definition: codec_id.h:498

av_cold

#define av_cold

Definition: attributes.h:106

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:539

av_tx_fn

void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)

Function pointer to a function to perform the transform.

Definition: tx.h:151

ATRAC3PContext::outp_buf

float outp_buf[2][ATRAC3P_FRAME_SAMPLES]

Definition: atrac3plusdec.c:70

Atrac3pChanUnitCtx::used_quant_units

int used_quant_units

number of quant units with coded spectrum

Definition: atrac3plus.h:138

AV_CHANNEL_LAYOUT_4POINT0

#define AV_CHANNEL_LAYOUT_4POINT0

Definition: channel_layout.h:400

AV_TX_FLOAT_MDCT

@ AV_TX_FLOAT_MDCT

Standard MDCT with a sample data type of float, double or int32_t, respectively.

Definition: tx.h:68

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

AV_CHANNEL_LAYOUT_7POINT1

#define AV_CHANNEL_LAYOUT_7POINT1

Definition: channel_layout.h:417

CH_UNIT_MONO

@ CH_UNIT_MONO

unit containing one coded channel

Definition: atrac3plus.h:53

Atrac3pChanUnitCtx::num_coded_subbands

int num_coded_subbands

number of subbands with coded spectrum

Definition: atrac3plus.h:139

atrac.h

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

ctx

AVFormatContext * ctx

Definition: movenc.c:49

AtracGCContext

Gain compensation context structure.

Definition: atrac.h:44

channels

Definition: aptx.h:31

decode.h

get_bits.h

channel_map

static const uint8_t channel_map[8][8]

Definition: atrac3plusdec.c:52

ff_atrac3p_qu_to_spec_pos

const uint16_t ff_atrac3p_qu_to_spec_pos[33]

Map quant unit number to its position in the spectrum.

Definition: atrac3plusdsp.c:42

Atrac3pChanUnitCtx::waves_info_prev

Atrac3pWaveSynthParams * waves_info_prev

Definition: atrac3plus.h:152

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:441

ff_atrac3p_mant_tab

const float ff_atrac3p_mant_tab[8]

Definition: atrac3plusdsp.c:67

if(ret)

Definition: filter_design.txt:179

AV_TX_FULL_IMDCT

@ AV_TX_FULL_IMDCT

Performs a full inverse MDCT rather than leaving out samples that can be derived through symmetry.

Definition: tx.h:175

CH_UNIT_TERMINATOR

@ CH_UNIT_TERMINATOR

unit sequence terminator

Definition: atrac3plus.h:56

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

ff_atrac3p_ipqf

void ff_atrac3p_ipqf(AVTXContext *dct_ctx, av_tx_fn dct_fn, Atrac3pIPQFChannelCtx *hist, const float *in, float *out)

Subband synthesis filter based on the polyphase quadrature (pseudo-QMF) filter bank.

Definition: atrac3plusdsp.c:600

ATRAC3PContext::num_channel_blocks

int num_channel_blocks

number of channel blocks

Definition: atrac3plusdec.c:80

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:386

Atrac3pChanParams::gain_data_prev

AtracGainInfo * gain_data_prev

gain control data for previous frame

Definition: atrac3plus.h:111

Atrac3pChanParams::spectrum

int16_t spectrum[2048]

decoded IMDCT spectrum

Definition: atrac3plus.h:100

ATRAC3PContext::channel_blocks

uint8_t channel_blocks[5]

channel configuration descriptor

Definition: atrac3plusdec.c:81

AtracGainInfo

Gain control parameters for one subband.

Definition: atrac.h:35

Atrac3pChanParams::tones_info

Atrac3pWavesData * tones_info

Definition: atrac3plus.h:116

atrac3plus.h

ATRAC3PContext::fdsp

AVFloatDSPContext * fdsp

Definition: atrac3plusdec.c:65

AVOnce

#define AVOnce

Definition: thread.h:202

float_dsp.h

ATRAC3PContext::ipqf_dct_fn

av_tx_fn ipqf_dct_fn

Definition: atrac3plusdec.c:76

Atrac3pChanUnitCtx::channels

Atrac3pChanParams channels[2]

Definition: atrac3plus.h:147

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1720

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

ATRAC3PContext::ipqf_dct_ctx

AVTXContext * ipqf_dct_ctx

IDCT context used by IPQF.

Definition: atrac3plusdec.c:75

AVPacket::size

int size

Definition: packet.h:559

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:319

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:104

ff_atrac3pal_decoder

const FFCodec ff_atrac3pal_decoder

Definition: atrac3plusdec.c:433

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

ff_atrac3p_init_vlcs

av_cold void ff_atrac3p_init_vlcs(void)

Initialize VLC tables for bitstream parsing.

Definition: atrac3plus.c:76

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1031

Atrac3pChanParams::qu_sf_idx

int qu_sf_idx[32]

array of scale factor indexes for each quant unit

Definition: atrac3plus.h:98

CH_UNIT_STEREO

@ CH_UNIT_STEREO

unit containing two jointly-coded channels

Definition: atrac3plus.h:54

avpriv_report_missing_feature

void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

AVFloatDSPContext

Definition: float_dsp.h:24

ATRAC3PContext::time_buf

float time_buf[2][ATRAC3P_FRAME_SAMPLES]

output of the gain compensation

Definition: atrac3plusdec.c:69

ff_atrac3p_decode_channel_unit

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

av_tx_uninit

av_cold void av_tx_uninit(AVTXContext **ctx)

Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.

Definition: tx.c:295

AV_CHANNEL_LAYOUT_6POINT1_BACK

#define AV_CHANNEL_LAYOUT_6POINT1_BACK

Definition: channel_layout.h:413

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

ATRAC3PContext::mdct_fn

av_tx_fn mdct_fn

Definition: atrac3plusdec.c:74

Atrac3pChanUnitCtx::unit_type

int unit_type

unit type (mono/stereo)

Definition: atrac3plus.h:135

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

ff_atrac3p_imdct

void ff_atrac3p_imdct(AVFloatDSPContext *fdsp, AVTXContext *mdct_ctx, av_tx_fn mdct_fn, float *pIn, float *pOut, int wind_id, int sb)

Regular IMDCT and windowing without overlapping, with spectrum reversal in the odd subbands.

Definition: atrac3plusdsp.c:458

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

avcodec.h

ret

Definition: filter_design.txt:187

Atrac3pChanUnitCtx

Channel unit parameters.

Definition: atrac3plus.h:133

AVCodecContext::block_align

int block_align

number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.

Definition: avcodec.h:1057

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:265

Atrac3pChanUnitCtx::prev_buf

float prev_buf[2][ATRAC3P_FRAME_SAMPLES]

overlapping buffer

Definition: atrac3plus.h:155

Atrac3pChanUnitCtx::mute_flag

int mute_flag

mute flag

Definition: atrac3plus.h:140

Atrac3pWaveSynthParams::tones_present

int tones_present

1 - tones info present

Definition: atrac3plus.h:122

Atrac3pChanUnitCtx::swap_channels

uint8_t swap_channels[ATRAC3P_SUBBANDS]

1 - perform subband-wise channel swapping

Definition: atrac3plus.h:145

AVCodecContext

main external API structure.

Definition: avcodec.h:431

ff_atrac_gain_compensation

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:85

channel_layout.h

Atrac3pWavesData

Parameters of a group of sine waves.

Definition: atrac3plus.h:75

Atrac3pChanUnitCtx::num_subbands

int num_subbands

Definition: atrac3plus.h:137

av_channel_layout_uninit

void av_channel_layout_uninit(AVChannelLayout *channel_layout)

Free any allocated data in the channel layout and reset the channel count to 0.