FFmpeg: libavcodec/atrac1.c Source File

FFmpeg

[フレーム]

libavcodec

atrac1.c

Go to the documentation of this file.

1 /*

2 * Atrac 1 compatible decoder

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 * Atrac 1 compatible decoder.

26 * This decoder handles raw ATRAC1 data and probably SDDS data.

27 */

29 /* Many thanks to Tim Craig for all the help! */

31 #include <math.h>

32 #include <stddef.h>

33 #include <stdio.h>

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"

42 #include "atrac.h"

43 #include "atrac1data.h"

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

52 #define AT1_QMF_BANDS 3

53 #define IDX_LOW_BAND 0

54 #define IDX_MID_BAND 1

55 #define IDX_HIGH_BAND 2

57 /**

58 * Sound unit struct, one unit is used per channel

59 */

60 typedef struct {

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+23]; ///< delay line for the last stacked QMF filter

69 } AT1SUCtx;

71 /**

72 * The atrac1 context, holds all needed parameters for decoding

73 */

74 typedef struct {

75 AT1SUCtx SUs[AT1_MAX_CHANNELS]; ///< channel sound unit

76 DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES]; ///< the mdct spectrum buffer

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 AVFloatDSPContext fdsp;

84 } AT1Ctx;

86 /** size of the transform in samples in the long mode for each QMF band */

87 static const uint16_t samples_per_band[3] = {128, 128, 256};

88 static const uint8_t mdct_long_nbits[3] = {7, 7, 8};

91 static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits,

92 int rev_spec)

93 {

94 FFTContext* mdct_context = &q->mdct_ctx[nbits - 5 - (nbits > 6)];

95 int transf_size = 1 << nbits;

97 if (rev_spec) {

98 int i;

99 for (i = 0; i < transf_size / 2; i++)

100 FFSWAP(float, spec[i], spec[transf_size - 1 - i]);

101 }

102 mdct_context->imdct_half(mdct_context, out, spec);

103 }

104

105

106 static int at1_imdct_block(AT1SUCtx* su, AT1Ctx *q)

107 {

108 int band_num, band_samples, log2_block_count, nbits, num_blocks, block_size;

109 unsigned int start_pos, ref_pos = 0, pos = 0;

110

111 for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {

112 float *prev_buf;

113 int j;

114

115 band_samples = samples_per_band[band_num];

116 log2_block_count = su->log2_block_count[band_num];

117

118 /* number of mdct blocks in the current QMF band: 1 - for long mode */

119 /* 4 for short mode(low/middle bands) and 8 for short mode(high band)*/

120 num_blocks = 1 << log2_block_count;

121

122 if (num_blocks == 1) {

123 /* mdct block size in samples: 128 (long mode, low & mid bands), */

124 /* 256 (long mode, high band) and 32 (short mode, all bands) */

125 block_size = band_samples >> log2_block_count;

126

127 /* calc transform size in bits according to the block_size_mode */

128 nbits = mdct_long_nbits[band_num] - log2_block_count;

129

130 if (nbits != 5 && nbits != 7 && nbits != 8)

131 return AVERROR_INVALIDDATA;

132 } else {

133 block_size = 32;

134 nbits = 5;

135 }

136

137 start_pos = 0;

138 prev_buf = &su->spectrum[1][ref_pos + band_samples - 16];

139 for (j=0; j < num_blocks; j++) {

140 at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);

141

142 /* overlap and window */

143 q->fdsp.vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,

144 &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);

145

146 prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];

147 start_pos += block_size;

148 pos += block_size;

149 }

150

151 if (num_blocks == 1)

152 memcpy(q->bands[band_num] + 32, &su->spectrum[0][ref_pos + 16], 240 * sizeof(float));

153

154 ref_pos += band_samples;

155 }

156

157 /* Swap buffers so the mdct overlap works */

158 FFSWAP(float*, su->spectrum[0], su->spectrum[1]);

159

160 return 0;

161 }

162

163 /**

164 * Parse the block size mode byte

165 */

166

167 static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])

168 {

169 int log2_block_count_tmp, i;

170

171 for (i = 0; i < 2; i++) {

172 /* low and mid band */

173 log2_block_count_tmp = get_bits(gb, 2);

174 if (log2_block_count_tmp & 1)

175 return AVERROR_INVALIDDATA;

176 log2_block_cnt[i] = 2 - log2_block_count_tmp;

177 }

178

179 /* high band */

180 log2_block_count_tmp = get_bits(gb, 2);

181 if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)

182 return AVERROR_INVALIDDATA;

183 log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;

184

185 skip_bits(gb, 2);

186 return 0;

187 }

188

189

190 static int at1_unpack_dequant(GetBitContext* gb, AT1SUCtx* su,

191 float spec[AT1_SU_SAMPLES])

192 {

193 int bits_used, band_num, bfu_num, i;

194 uint8_t idwls[AT1_MAX_BFU]; ///< the word length indexes for each BFU

195 uint8_t idsfs[AT1_MAX_BFU]; ///< the scalefactor indexes for each BFU

196

197 /* parse the info byte (2nd byte) telling how much BFUs were coded */

198 su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];

199

200 /* calc number of consumed bits:

201 num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)

202 + info_byte_copy(8bits) + log2_block_count_copy(8bits) */

203 bits_used = su->num_bfus * 10 + 32 +

204 bfu_amount_tab2[get_bits(gb, 2)] +

205 (bfu_amount_tab3[get_bits(gb, 3)] << 1);

206

207 /* get word length index (idwl) for each BFU */

208 for (i = 0; i < su->num_bfus; i++)

209 idwls[i] = get_bits(gb, 4);

210

211 /* get scalefactor index (idsf) for each BFU */

212 for (i = 0; i < su->num_bfus; i++)

213 idsfs[i] = get_bits(gb, 6);

214

215 /* zero idwl/idsf for empty BFUs */

216 for (i = su->num_bfus; i < AT1_MAX_BFU; i++)

217 idwls[i] = idsfs[i] = 0;

218

219 /* read in the spectral data and reconstruct MDCT spectrum of this channel */

220 for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {

221 for (bfu_num = bfu_bands_t[band_num]; bfu_num < bfu_bands_t[band_num+1]; bfu_num++) {

222 int pos;

223

224 int num_specs = specs_per_bfu[bfu_num];

225 int word_len = !!idwls[bfu_num] + idwls[bfu_num];

226 float scale_factor = ff_atrac_sf_table[idsfs[bfu_num]];

227 bits_used += word_len * num_specs; /* add number of bits consumed by current BFU */

228

229 /* check for bitstream overflow */

230 if (bits_used > AT1_SU_MAX_BITS)

231 return AVERROR_INVALIDDATA;

232

233 /* get the position of the 1st spec according to the block size mode */

234 pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];

235

236 if (word_len) {

237 float max_quant = 1.0 / (float)((1 << (word_len - 1)) - 1);

238

239 for (i = 0; i < num_specs; i++) {

240 /* read in a quantized spec and convert it to

241 * signed int and then inverse quantization

242 */

243 spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;

244 }

245 } else { /* word_len = 0 -> empty BFU, zero all specs in the empty BFU */

246 memset(&spec[pos], 0, num_specs * sizeof(float));

247 }

248 }

249 }

250

251 return 0;

252 }

253

254

255 static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx* su, float *pOut)

256 {

257 float temp[256];

258 float iqmf_temp[512 + 46];

259

260 /* combine low and middle bands */

261 ff_atrac_iqmf(q->bands[0], q->bands[1], 128, temp, su->fst_qmf_delay, iqmf_temp);

262

263 /* delay the signal of the high band by 23 samples */

264 memcpy( su->last_qmf_delay, &su->last_qmf_delay[256], sizeof(float) * 23);

265 memcpy(&su->last_qmf_delay[23], q->bands[2], sizeof(float) * 256);

266

267 /* combine (low + middle) and high bands */

268 ff_atrac_iqmf(temp, su->last_qmf_delay, 256, pOut, su->snd_qmf_delay, iqmf_temp);

269 }

270

271

272 static int atrac1_decode_frame(AVCodecContext *avctx, void *data,

273 int *got_frame_ptr, AVPacket *avpkt)

274 {

275 AVFrame *frame = data;

276 const uint8_t *buf = avpkt->data;

277 int buf_size = avpkt->size;

278 AT1Ctx *q = avctx->priv_data;

279 int ch, ret;

280 GetBitContext gb;

281

282

283 if (buf_size < 212 * avctx->channels) {

284 av_log(avctx, AV_LOG_ERROR, "Not enough data to decode!\n");

285 return AVERROR_INVALIDDATA;

286 }

287

288 /* get output buffer */

289 frame->nb_samples = AT1_SU_SAMPLES;

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

291 return ret;

292

293 for (ch = 0; ch < avctx->channels; ch++) {

294 AT1SUCtx* su = &q->SUs[ch];

295

296 init_get_bits(&gb, &buf[212 * ch], 212 * 8);

297

298 /* parse block_size_mode, 1st byte */

299 ret = at1_parse_bsm(&gb, su->log2_block_count);

300 if (ret < 0)

301 return ret;

302

303 ret = at1_unpack_dequant(&gb, su, q->spec);

304 if (ret < 0)

305 return ret;

306

307 ret = at1_imdct_block(su, q);

308 if (ret < 0)

309 return ret;

310 at1_subband_synthesis(q, su, (float *)frame->extended_data[ch]);

311 }

312

313 *got_frame_ptr = 1;

314

315 return avctx->block_align;

316 }

317

318

319 static av_cold int atrac1_decode_end(AVCodecContext * avctx)

320 {

321 AT1Ctx *q = avctx->priv_data;

322

323 ff_mdct_end(&q->mdct_ctx[0]);

324 ff_mdct_end(&q->mdct_ctx[1]);

325 ff_mdct_end(&q->mdct_ctx[2]);

326

327 return 0;

328 }

329

330

331 static av_cold int atrac1_decode_init(AVCodecContext *avctx)

332 {

333 AT1Ctx *q = avctx->priv_data;

334 int ret;

335

336 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

337

338 if (avctx->channels < 1 || avctx->channels > AT1_MAX_CHANNELS) {

339 av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",

340 avctx->channels);

341 return AVERROR(EINVAL);

342 }

343

344 if (avctx->block_align <= 0) {

345 av_log(avctx, AV_LOG_ERROR, "Unsupported block align.");

346 return AVERROR_PATCHWELCOME;

347 }

348

349 /* Init the mdct transforms */

350 if ((ret = ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15))) ||

351 (ret = ff_mdct_init(&q->mdct_ctx[1], 8, 1, -1.0/ (1 << 15))) ||

352 (ret = ff_mdct_init(&q->mdct_ctx[2], 9, 1, -1.0/ (1 << 15)))) {

353 av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");

354 atrac1_decode_end(avctx);

355 return ret;

356 }

357

358 ff_init_ff_sine_windows(5);

359

360 ff_atrac_generate_tables();

361

362 avpriv_float_dsp_init(&q->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);

363

364 q->bands[0] = q->low;

365 q->bands[1] = q->mid;

366 q->bands[2] = q->high;

367

368 /* Prepare the mdct overlap buffers */

369 q->SUs[0].spectrum[0] = q->SUs[0].spec1;

370 q->SUs[0].spectrum[1] = q->SUs[0].spec2;

371 q->SUs[1].spectrum[0] = q->SUs[1].spec1;

372 q->SUs[1].spectrum[1] = q->SUs[1].spec2;

373

374 return 0;

375 }

376

377

378 AVCodec ff_atrac1_decoder = {

379 .name = "atrac1",

380 .type = AVMEDIA_TYPE_AUDIO,

381 .id = AV_CODEC_ID_ATRAC1,

382 .priv_data_size = sizeof(AT1Ctx),

383 .init = atrac1_decode_init,

384 .close = atrac1_decode_end,

385 .decode = atrac1_decode_frame,

386 .capabilities = CODEC_CAP_DR1,

387 .long_name = NULL_IF_CONFIG_SMALL("Atrac 1 (Adaptive TRansform Acoustic Coding)"),

388 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,

389 AV_SAMPLE_FMT_NONE },

390 };

Generated on Wed Jul 10 2013 23:47:55 for FFmpeg by doxygen 1.8.2