FFmpeg: libavcodec/atrac9dec.c Source File

FFmpeg

[フレーム]

libavcodec

atrac9dec.c

Go to the documentation of this file.

1 /*

2 * ATRAC9 decoder

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 #include "libavutil/channel_layout.h"

23 #include "libavutil/thread.h"

25 #include "codec_internal.h"

26 #include "internal.h"

27 #include "get_bits.h"

28 #include "fft.h"

29 #include "atrac9tab.h"

30 #include "libavutil/lfg.h"

31 #include "libavutil/float_dsp.h"

32 #include "libavutil/mem_internal.h"

34 #define ATRAC9_SF_VLC_BITS 8

35 #define ATRAC9_COEFF_VLC_BITS 9

37 typedef struct ATRAC9ChannelData {

38 int band_ext;

39 int q_unit_cnt;

40 int band_ext_data[4];

41 int32_t scalefactors[31];

42 int32_t scalefactors_prev[31];

44 int precision_coarse[30];

45 int precision_fine[30];

46 int precision_mask[30];

48 int codebookset[30];

50 int32_t q_coeffs_coarse[256];

51 int32_t q_coeffs_fine[256];

53 DECLARE_ALIGNED(32, float, coeffs )[256];

54 DECLARE_ALIGNED(32, float, prev_win)[128];

55 } ATRAC9ChannelData;

57 typedef struct ATRAC9BlockData {

58 ATRAC9ChannelData channel[2];

60 /* Base */

61 int band_count;

62 int q_unit_cnt;

63 int q_unit_cnt_prev;

65 /* Stereo block only */

66 int stereo_q_unit;

68 /* Band extension only */

69 int has_band_ext;

70 int has_band_ext_data;

71 int band_ext_q_unit;

73 /* Gradient */

74 int grad_mode;

75 int grad_boundary;

76 int gradient[31];

78 /* Stereo */

79 int cpe_base_channel;

80 int is_signs[30];

82 int reuseable;

84 } ATRAC9BlockData;

86 typedef struct ATRAC9Context {

87 AVCodecContext *avctx;

88 AVFloatDSPContext *fdsp;

89 FFTContext imdct;

90 ATRAC9BlockData block[5];

91 AVLFG lfg;

93 /* Set on init */

94 int frame_log2;

95 int avg_frame_size;

96 int frame_count;

97 int samplerate_idx;

98 const ATRAC9BlockConfig *block_config;

100 /* Generated on init */

101 uint8_t alloc_curve[48][48];

102 DECLARE_ALIGNED(32, float, imdct_win)[256];

103

104 DECLARE_ALIGNED(32, float, temp)[256];

105 } ATRAC9Context;

106

107 static VLC sf_vlc[2][8]; /* Signed/unsigned, length */

108 static VLC coeff_vlc[2][8][4]; /* Cookbook, precision, cookbook index */

109

110 static inline int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b,

111 GetBitContext *gb)

112 {

113 int grad_range[2];

114 int grad_value[2];

115 int values, sign, base;

116 uint8_t *curve;

117 float scale;

118

119 b->grad_mode = get_bits(gb, 2);

120 if (b->grad_mode) {

121 grad_range[0] = get_bits(gb, 5);

122 grad_range[1] = 31;

123 grad_value[0] = get_bits(gb, 5);

124 grad_value[1] = 31;

125 } else {

126 grad_range[0] = get_bits(gb, 6);

127 grad_range[1] = get_bits(gb, 6) + 1;

128 grad_value[0] = get_bits(gb, 5);

129 grad_value[1] = get_bits(gb, 5);

130 }

131 b->grad_boundary = get_bits(gb, 4);

132

133 if (grad_range[0] >= grad_range[1] || grad_range[1] > 31)

134 return AVERROR_INVALIDDATA;

135

136 if (b->grad_boundary > b->q_unit_cnt)

137 return AVERROR_INVALIDDATA;

138

139 values = grad_value[1] - grad_value[0];

140 sign = 1 - 2*(values < 0);

141 base = grad_value[0] + sign;

142 scale = (FFABS(values) - 1) / 31.0f;

143 curve = s->alloc_curve[grad_range[1] - grad_range[0] - 1];

144

145 for (int i = 0; i <= b->q_unit_cnt; i++)

146 b->gradient[i] = grad_value[i >= grad_range[0]];

147

148 for (int i = grad_range[0]; i < grad_range[1]; i++)

149 b->gradient[i] = base + sign*((int)(scale*curve[i - grad_range[0]]));

150

151 return 0;

152 }

153

154 static inline void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b,

155 ATRAC9ChannelData *c)

156 {

157 memset(c->precision_mask, 0, sizeof(c->precision_mask));

158 for (int i = 1; i < b->q_unit_cnt; i++) {

159 const int delta = FFABS(c->scalefactors[i] - c->scalefactors[i - 1]) - 1;

160 if (delta > 0) {

161 const int neg = c->scalefactors[i - 1] > c->scalefactors[i];

162 c->precision_mask[i - neg] += FFMIN(delta, 5);

163 }

164 }

165

166 if (b->grad_mode) {

167 for (int i = 0; i < b->q_unit_cnt; i++) {

168 c->precision_coarse[i] = c->scalefactors[i];

169 c->precision_coarse[i] += c->precision_mask[i] - b->gradient[i];

170 if (c->precision_coarse[i] < 0)

171 continue;

172 switch (b->grad_mode) {

173 case 1:

174 c->precision_coarse[i] >>= 1;

175 break;

176 case 2:

177 c->precision_coarse[i] = (3 * c->precision_coarse[i]) >> 3;

178 break;

179 case 3:

180 c->precision_coarse[i] >>= 2;

181 break;

182 }

183 }

184 } else {

185 for (int i = 0; i < b->q_unit_cnt; i++)

186 c->precision_coarse[i] = c->scalefactors[i] - b->gradient[i];

187 }

188

189

190 for (int i = 0; i < b->q_unit_cnt; i++)

191 c->precision_coarse[i] = FFMAX(c->precision_coarse[i], 1);

192

193 for (int i = 0; i < b->grad_boundary; i++)

194 c->precision_coarse[i]++;

195

196 for (int i = 0; i < b->q_unit_cnt; i++) {

197 c->precision_fine[i] = 0;

198 if (c->precision_coarse[i] > 15) {

199 c->precision_fine[i] = FFMIN(c->precision_coarse[i], 30) - 15;

200 c->precision_coarse[i] = 15;

201 }

202 }

203 }

204

205 static inline int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b,

206 GetBitContext *gb, int stereo)

207 {

208 int ext_band = 0;

209

210 if (b->has_band_ext) {

211 if (b->q_unit_cnt < 13 || b->q_unit_cnt > 20)

212 return AVERROR_INVALIDDATA;

213 ext_band = at9_tab_band_ext_group[b->q_unit_cnt - 13][2];

214 if (stereo) {

215 b->channel[1].band_ext = get_bits(gb, 2);

216 b->channel[1].band_ext = ext_band > 2 ? b->channel[1].band_ext : 4;

217 } else {

218 skip_bits1(gb);

219 }

220 }

221

222 b->has_band_ext_data = get_bits1(gb);

223 if (!b->has_band_ext_data)

224 return 0;

225

226 if (!b->has_band_ext) {

227 skip_bits(gb, 2);

228 skip_bits_long(gb, get_bits(gb, 5));

229 return 0;

230 }

231

232 b->channel[0].band_ext = get_bits(gb, 2);

233 b->channel[0].band_ext = ext_band > 2 ? b->channel[0].band_ext : 4;

234

235 if (!get_bits(gb, 5)) {

236 for (int i = 0; i <= stereo; i++) {

237 ATRAC9ChannelData *c = &b->channel[i];

238 const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];

239 for (int j = 0; j < count; j++) {

240 int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];

241 c->band_ext_data[j] = av_clip_uintp2_c(c->band_ext_data[j], len);

242 }

243 }

244

245 return 0;

246 }

247

248 for (int i = 0; i <= stereo; i++) {

249 ATRAC9ChannelData *c = &b->channel[i];

250 const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];

251 for (int j = 0; j < count; j++) {

252 int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];

253 c->band_ext_data[j] = get_bits(gb, len);

254 }

255 }

256

257 return 0;

258 }

259

260 static inline int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,

261 ATRAC9ChannelData *c, GetBitContext *gb,

262 int channel_idx, int first_in_pkt)

263 {

264 static const uint8_t mode_map[2][4] = { { 0, 1, 2, 3 }, { 0, 2, 3, 4 } };

265 const int mode = mode_map[channel_idx][get_bits(gb, 2)];

266

267 memset(c->scalefactors, 0, sizeof(c->scalefactors));

268

269 if (first_in_pkt && (mode == 4 || ((mode == 3) && !channel_idx))) {

270 av_log(s->avctx, AV_LOG_ERROR, "Invalid scalefactor coding mode!\n");

271 return AVERROR_INVALIDDATA;

272 }

273

274 switch (mode) {

275 case 0: { /* VLC delta offset */

276 const uint8_t *sf_weights = at9_tab_sf_weights[get_bits(gb, 3)];

277 const int base = get_bits(gb, 5);

278 const int len = get_bits(gb, 2) + 3;

279 const VLC *tab = &sf_vlc[0][len];

280

281 c->scalefactors[0] = get_bits(gb, len);

282

283 for (int i = 1; i < b->band_ext_q_unit; i++) {

284 int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table,

285 ATRAC9_SF_VLC_BITS, 1);

286 c->scalefactors[i] = val & ((1 << len) - 1);

287 }

288

289 for (int i = 0; i < b->band_ext_q_unit; i++)

290 c->scalefactors[i] += base - sf_weights[i];

291

292 break;

293 }

294 case 1: { /* CLC offset */

295 const int len = get_bits(gb, 2) + 2;

296 const int base = len < 5 ? get_bits(gb, 5) : 0;

297 for (int i = 0; i < b->band_ext_q_unit; i++)

298 c->scalefactors[i] = base + get_bits(gb, len);

299 break;

300 }

301 case 2:

302 case 4: { /* VLC dist to baseline */

303 const int *baseline = mode == 4 ? c->scalefactors_prev :

304 channel_idx ? b->channel[0].scalefactors :

305 c->scalefactors_prev;

306 const int baseline_len = mode == 4 ? b->q_unit_cnt_prev :

307 channel_idx ? b->band_ext_q_unit :

308 b->q_unit_cnt_prev;

309

310 const int len = get_bits(gb, 2) + 2;

311 const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);

312 const VLC *tab = &sf_vlc[1][len];

313

314 for (int i = 0; i < unit_cnt; i++) {

315 int dist = get_vlc2(gb, tab->table, ATRAC9_SF_VLC_BITS, 1);

316 c->scalefactors[i] = baseline[i] + dist;

317 }

318

319 for (int i = unit_cnt; i < b->band_ext_q_unit; i++)

320 c->scalefactors[i] = get_bits(gb, 5);

321

322 break;

323 }

324 case 3: { /* VLC offset with baseline */

325 const int *baseline = channel_idx ? b->channel[0].scalefactors :

326 c->scalefactors_prev;

327 const int baseline_len = channel_idx ? b->band_ext_q_unit :

328 b->q_unit_cnt_prev;

329

330 const int base = get_bits(gb, 5) - (1 << (5 - 1));

331 const int len = get_bits(gb, 2) + 1;

332 const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);

333 const VLC *tab = &sf_vlc[0][len];

334

335 c->scalefactors[0] = get_bits(gb, len);

336

337 for (int i = 1; i < unit_cnt; i++) {

338 int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table,

339 ATRAC9_SF_VLC_BITS, 1);

340 c->scalefactors[i] = val & ((1 << len) - 1);

341 }

342

343 for (int i = 0; i < unit_cnt; i++)

344 c->scalefactors[i] += base + baseline[i];

345

346 for (int i = unit_cnt; i < b->band_ext_q_unit; i++)

347 c->scalefactors[i] = get_bits(gb, 5);

348 break;

349 }

350 }

351

352 for (int i = 0; i < b->band_ext_q_unit; i++)

353 if (c->scalefactors[i] < 0 || c->scalefactors[i] > 31)

354 return AVERROR_INVALIDDATA;

355

356 memcpy(c->scalefactors_prev, c->scalefactors, sizeof(c->scalefactors));

357

358 return 0;

359 }

360

361 static inline void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b,

362 ATRAC9ChannelData *c)

363 {

364 int avg = 0;

365 const int last_sf = c->scalefactors[c->q_unit_cnt];

366

367 memset(c->codebookset, 0, sizeof(c->codebookset));

368

369 if (c->q_unit_cnt <= 1)

370 return;

371 if (s->samplerate_idx > 7)

372 return;

373

374 c->scalefactors[c->q_unit_cnt] = c->scalefactors[c->q_unit_cnt - 1];

375

376 if (c->q_unit_cnt > 12) {

377 for (int i = 0; i < 12; i++)

378 avg += c->scalefactors[i];

379 avg = (avg + 6) / 12;

380 }

381

382 for (int i = 8; i < c->q_unit_cnt; i++) {

383 const int prev = c->scalefactors[i - 1];

384 const int cur = c->scalefactors[i ];

385 const int next = c->scalefactors[i + 1];

386 const int min = FFMIN(prev, next);

387 if ((cur - min >= 3 || 2*cur - prev - next >= 3))

388 c->codebookset[i] = 1;

389 }

390

391

392 for (int i = 12; i < c->q_unit_cnt; i++) {

393 const int cur = c->scalefactors[i];

394 const int cnd = at9_q_unit_to_coeff_cnt[i] == 16;

395 const int min = FFMIN(c->scalefactors[i + 1], c->scalefactors[i - 1]);

396 if (c->codebookset[i])

397 continue;

398

399 c->codebookset[i] = (((cur - min) >= 2) && (cur >= (avg - cnd)));

400 }

401

402 c->scalefactors[c->q_unit_cnt] = last_sf;

403 }

404

405 static inline void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b,

406 ATRAC9ChannelData *c, GetBitContext *gb)

407 {

408 const int max_prec = s->samplerate_idx > 7 ? 1 : 7;

409

410 memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));

411

412 for (int i = 0; i < c->q_unit_cnt; i++) {

413 int *coeffs = &c->q_coeffs_coarse[at9_q_unit_to_coeff_idx[i]];

414 const int bands = at9_q_unit_to_coeff_cnt[i];

415 const int prec = c->precision_coarse[i] + 1;

416

417 if (prec <= max_prec) {

418 const int cb = c->codebookset[i];

419 const int cbi = at9_q_unit_to_codebookidx[i];

420 const VLC *tab = &coeff_vlc[cb][prec][cbi];

421 const HuffmanCodebook *huff = &at9_huffman_coeffs[cb][prec][cbi];

422 const int groups = bands >> huff->value_cnt_pow;

423

424 for (int j = 0; j < groups; j++) {

425 uint16_t val = get_vlc2(gb, tab->table, ATRAC9_COEFF_VLC_BITS, 2);

426

427 for (int k = 0; k < huff->value_cnt; k++) {

428 coeffs[k] = sign_extend(val, huff->value_bits);

429 val >>= huff->value_bits;

430 }

431

432 coeffs += huff->value_cnt;

433 }

434 } else {

435 for (int j = 0; j < bands; j++)

436 coeffs[j] = sign_extend(get_bits(gb, prec), prec);

437 }

438 }

439 }

440

441 static inline void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b,

442 ATRAC9ChannelData *c, GetBitContext *gb)

443 {

444 memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));

445

446 for (int i = 0; i < c->q_unit_cnt; i++) {

447 const int start = at9_q_unit_to_coeff_idx[i + 0];

448 const int end = at9_q_unit_to_coeff_idx[i + 1];

449 const int len = c->precision_fine[i] + 1;

450

451 if (c->precision_fine[i] <= 0)

452 continue;

453

454 for (int j = start; j < end; j++)

455 c->q_coeffs_fine[j] = sign_extend(get_bits(gb, len), len);

456 }

457 }

458

459 static inline void dequantize(ATRAC9Context *s, ATRAC9BlockData *b,

460 ATRAC9ChannelData *c)

461 {

462 memset(c->coeffs, 0, sizeof(c->coeffs));

463

464 for (int i = 0; i < c->q_unit_cnt; i++) {

465 const int start = at9_q_unit_to_coeff_idx[i + 0];

466 const int end = at9_q_unit_to_coeff_idx[i + 1];

467

468 const float coarse_c = at9_quant_step_coarse[c->precision_coarse[i]];

469 const float fine_c = at9_quant_step_fine[c->precision_fine[i]];

470

471 for (int j = start; j < end; j++) {

472 const float vc = c->q_coeffs_coarse[j] * coarse_c;

473 const float vf = c->q_coeffs_fine[j] * fine_c;

474 c->coeffs[j] = vc + vf;

475 }

476 }

477 }

478

479 static inline void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b,

480 const int stereo)

481 {

482 float *src = b->channel[ b->cpe_base_channel].coeffs;

483 float *dst = b->channel[!b->cpe_base_channel].coeffs;

484

485 if (!stereo)

486 return;

487

488 if (b->q_unit_cnt <= b->stereo_q_unit)

489 return;

490

491 for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++) {

492 const int sign = b->is_signs[i];

493 const int start = at9_q_unit_to_coeff_idx[i + 0];

494 const int end = at9_q_unit_to_coeff_idx[i + 1];

495 for (int j = start; j < end; j++)

496 dst[j] = sign*src[j];

497 }

498 }

499

500 static inline void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,

501 const int stereo)

502 {

503 for (int i = 0; i <= stereo; i++) {

504 float *coeffs = b->channel[i].coeffs;

505 for (int j = 0; j < b->q_unit_cnt; j++) {

506 const int start = at9_q_unit_to_coeff_idx[j + 0];

507 const int end = at9_q_unit_to_coeff_idx[j + 1];

508 const int scalefactor = b->channel[i].scalefactors[j];

509 const float scale = at9_scalefactor_c[scalefactor];

510 for (int k = start; k < end; k++)

511 coeffs[k] *= scale;

512 }

513 }

514 }

515

516 static inline void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c,

517 int start, int count)

518 {

519 float maxval = 0.0f;

520 for (int i = 0; i < count; i += 2) {

521 double tmp[2];

522 av_bmg_get(&s->lfg, tmp);

523 c->coeffs[start + i + 0] = tmp[0];

524 c->coeffs[start + i + 1] = tmp[1];

525 maxval = FFMAX(FFMAX(FFABS(tmp[0]), FFABS(tmp[1])), maxval);

526 }

527 /* Normalize */

528 for (int i = 0; i < count; i++)

529 c->coeffs[start + i] /= maxval;

530 }

531

532 static inline void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6],

533 const int s_unit, const int e_unit)

534 {

535 for (int i = s_unit; i < e_unit; i++) {

536 const int start = at9_q_unit_to_coeff_idx[i + 0];

537 const int end = at9_q_unit_to_coeff_idx[i + 1];

538 for (int j = start; j < end; j++)

539 c->coeffs[j] *= sf[i - s_unit];

540 }

541 }

542

543 static inline void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b,

544 const int stereo)

545 {

546 const int g_units[4] = { /* A, B, C, total units */

547 b->q_unit_cnt,

548 at9_tab_band_ext_group[b->q_unit_cnt - 13][0],

549 at9_tab_band_ext_group[b->q_unit_cnt - 13][1],

550 FFMAX(g_units[2], 22),

551 };

552

553 const int g_bins[4] = { /* A, B, C, total bins */

554 at9_q_unit_to_coeff_idx[g_units[0]],

555 at9_q_unit_to_coeff_idx[g_units[1]],

556 at9_q_unit_to_coeff_idx[g_units[2]],

557 at9_q_unit_to_coeff_idx[g_units[3]],

558 };

559

560 for (int ch = 0; ch <= stereo; ch++) {

561 ATRAC9ChannelData *c = &b->channel[ch];

562

563 /* Mirror the spectrum */

564 for (int i = 0; i < 3; i++)

565 for (int j = 0; j < (g_bins[i + 1] - g_bins[i + 0]); j++)

566 c->coeffs[g_bins[i] + j] = c->coeffs[g_bins[i] - j - 1];

567

568 switch (c->band_ext) {

569 case 0: {

570 float sf[6] = { 0.0f };

571 const int l = g_units[3] - g_units[0] - 1;

572 const int n_start = at9_q_unit_to_coeff_idx[g_units[3] - 1];

573 const int n_cnt = at9_q_unit_to_coeff_cnt[g_units[3] - 1];

574 switch (at9_tab_band_ext_group[b->q_unit_cnt - 13][2]) {

575 case 3:

576 sf[0] = at9_band_ext_scales_m0[0][0][c->band_ext_data[0]];

577 sf[1] = at9_band_ext_scales_m0[0][1][c->band_ext_data[0]];

578 sf[2] = at9_band_ext_scales_m0[0][2][c->band_ext_data[1]];

579 sf[3] = at9_band_ext_scales_m0[0][3][c->band_ext_data[2]];

580 sf[4] = at9_band_ext_scales_m0[0][4][c->band_ext_data[3]];

581 break;

582 case 4:

583 sf[0] = at9_band_ext_scales_m0[1][0][c->band_ext_data[0]];

584 sf[1] = at9_band_ext_scales_m0[1][1][c->band_ext_data[0]];

585 sf[2] = at9_band_ext_scales_m0[1][2][c->band_ext_data[1]];

586 sf[3] = at9_band_ext_scales_m0[1][3][c->band_ext_data[2]];

587 sf[4] = at9_band_ext_scales_m0[1][4][c->band_ext_data[3]];

588 break;

589 case 5:

590 sf[0] = at9_band_ext_scales_m0[2][0][c->band_ext_data[0]];

591 sf[1] = at9_band_ext_scales_m0[2][1][c->band_ext_data[1]];

592 sf[2] = at9_band_ext_scales_m0[2][2][c->band_ext_data[1]];

593 break;

594 }

595

596 sf[l] = at9_scalefactor_c[c->scalefactors[g_units[0]]];

597

598 fill_with_noise(s, c, n_start, n_cnt);

599 scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);

600 break;

601 }

602 case 1: {

603 float sf[6];

604 for (int i = g_units[0]; i < g_units[3]; i++)

605 sf[i - g_units[0]] = at9_scalefactor_c[c->scalefactors[i]];

606

607 fill_with_noise(s, c, g_bins[0], g_bins[3] - g_bins[0]);

608 scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);

609 break;

610 }

611 case 2: {

612 const float g_sf[2] = {

613 at9_band_ext_scales_m2[c->band_ext_data[0]],

614 at9_band_ext_scales_m2[c->band_ext_data[1]],

615 };

616

617 for (int i = 0; i < 2; i++)

618 for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)

619 c->coeffs[j] *= g_sf[i];

620 break;

621 }

622 case 3: {

623 float scale = at9_band_ext_scales_m3[c->band_ext_data[0]][0];

624 float rate = at9_band_ext_scales_m3[c->band_ext_data[1]][1];

625 rate = pow(2, rate);

626 for (int i = g_bins[0]; i < g_bins[3]; i++) {

627 scale *= rate;

628 c->coeffs[i] *= scale;

629 }

630 break;

631 }

632 case 4: {

633 const float m = at9_band_ext_scales_m4[c->band_ext_data[0]];

634 const float g_sf[3] = { 0.7079468f*m, 0.5011902f*m, 0.3548279f*m };

635

636 for (int i = 0; i < 3; i++)

637 for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)

638 c->coeffs[j] *= g_sf[i];

639 break;

640 }

641 }

642 }

643 }

644

645 static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb,

646 ATRAC9BlockData *b, AVFrame *frame,

647 int frame_idx, int block_idx)

648 {

649 const int first_in_pkt = !get_bits1(gb);

650 const int reuse_params = get_bits1(gb);

651 const int stereo = s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_CPE;

652

653 if (s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_LFE) {

654 ATRAC9ChannelData *c = &b->channel[0];

655 const int precision = reuse_params ? 8 : 4;

656 c->q_unit_cnt = b->q_unit_cnt = 2;

657

658 memset(c->scalefactors, 0, sizeof(c->scalefactors));

659 memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));

660 memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));

661

662 for (int i = 0; i < b->q_unit_cnt; i++) {

663 c->scalefactors[i] = get_bits(gb, 5);

664 c->precision_coarse[i] = precision;

665 c->precision_fine[i] = 0;

666 }

667

668 for (int i = 0; i < c->q_unit_cnt; i++) {

669 const int start = at9_q_unit_to_coeff_idx[i + 0];

670 const int end = at9_q_unit_to_coeff_idx[i + 1];

671 for (int j = start; j < end; j++)

672 c->q_coeffs_coarse[j] = get_bits(gb, c->precision_coarse[i] + 1);

673 }

674

675 dequantize (s, b, c);

676 apply_scalefactors(s, b, 0);

677

678 goto imdct;

679 }

680

681 if (first_in_pkt && reuse_params) {

682 av_log(s->avctx, AV_LOG_ERROR, "Invalid block flags!\n");

683 return AVERROR_INVALIDDATA;

684 }

685

686 /* Band parameters */

687 if (!reuse_params) {

688 int stereo_band, ext_band;

689 const int min_band_count = s->samplerate_idx > 7 ? 1 : 3;

690 b->reuseable = 0;

691 b->band_count = get_bits(gb, 4) + min_band_count;

692 b->q_unit_cnt = at9_tab_band_q_unit_map[b->band_count];

693

694 b->band_ext_q_unit = b->stereo_q_unit = b->q_unit_cnt;

695

696 if (b->band_count > at9_tab_sri_max_bands[s->samplerate_idx]) {

697 av_log(s->avctx, AV_LOG_ERROR, "Invalid band count %i!\n",

698 b->band_count);

699 return AVERROR_INVALIDDATA;

700 }

701

702 if (stereo) {

703 stereo_band = get_bits(gb, 4) + min_band_count;

704 if (stereo_band > b->band_count) {

705 av_log(s->avctx, AV_LOG_ERROR, "Invalid stereo band %i!\n",

706 stereo_band);

707 return AVERROR_INVALIDDATA;

708 }

709 b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];

710 }

711

712 b->has_band_ext = get_bits1(gb);

713 if (b->has_band_ext) {

714 ext_band = get_bits(gb, 4) + min_band_count;

715 if (ext_band < b->band_count) {

716 av_log(s->avctx, AV_LOG_ERROR, "Invalid extension band %i!\n",

717 ext_band);

718 return AVERROR_INVALIDDATA;

719 }

720 b->band_ext_q_unit = at9_tab_band_q_unit_map[ext_band];

721 }

722 b->reuseable = 1;

723 }

724 if (!b->reuseable) {

725 av_log(s->avctx, AV_LOG_ERROR, "invalid block reused!\n");

726 return AVERROR_INVALIDDATA;

727 }

728

729 /* Calculate bit alloc gradient */

730 if (parse_gradient(s, b, gb))

731 return AVERROR_INVALIDDATA;

732

733 /* IS data */

734 b->cpe_base_channel = 0;

735 if (stereo) {

736 b->cpe_base_channel = get_bits1(gb);

737 if (get_bits1(gb)) {

738 for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++)

739 b->is_signs[i] = 1 - 2*get_bits1(gb);

740 } else {

741 for (int i = 0; i < FF_ARRAY_ELEMS(b->is_signs); i++)

742 b->is_signs[i] = 1;

743 }

744 }

745

746 /* Band extension */

747 if (parse_band_ext(s, b, gb, stereo))

748 return AVERROR_INVALIDDATA;

749

750 /* Scalefactors */

751 for (int i = 0; i <= stereo; i++) {

752 ATRAC9ChannelData *c = &b->channel[i];

753 c->q_unit_cnt = i == b->cpe_base_channel ? b->q_unit_cnt :

754 b->stereo_q_unit;

755 if (read_scalefactors(s, b, c, gb, i, first_in_pkt))

756 return AVERROR_INVALIDDATA;

757

758 calc_precision (s, b, c);

759 calc_codebook_idx (s, b, c);

760 read_coeffs_coarse(s, b, c, gb);

761 read_coeffs_fine (s, b, c, gb);

762 dequantize (s, b, c);

763 }

764

765 b->q_unit_cnt_prev = b->has_band_ext ? b->band_ext_q_unit : b->q_unit_cnt;

766

767 apply_intensity_stereo(s, b, stereo);

768 apply_scalefactors (s, b, stereo);

769

770 if (b->has_band_ext && b->has_band_ext_data)

771 apply_band_extension (s, b, stereo);

772

773 imdct:

774 for (int i = 0; i <= stereo; i++) {

775 ATRAC9ChannelData *c = &b->channel[i];

776 const int dst_idx = s->block_config->plane_map[block_idx][i];

777 const int wsize = 1 << s->frame_log2;

778 const ptrdiff_t offset = wsize*frame_idx*sizeof(float);

779 float *dst = (float *)(frame->extended_data[dst_idx] + offset);

780

781 s->imdct.imdct_half(&s->imdct, s->temp, c->coeffs);

782 s->fdsp->vector_fmul_window(dst, c->prev_win, s->temp,

783 s->imdct_win, wsize >> 1);

784 memcpy(c->prev_win, s->temp + (wsize >> 1), sizeof(float)*wsize >> 1);

785 }

786

787 return 0;

788 }

789

790 static int atrac9_decode_frame(AVCodecContext *avctx, AVFrame *frame,

791 int *got_frame_ptr, AVPacket *avpkt)

792 {

793 int ret;

794 GetBitContext gb;

795 ATRAC9Context *s = avctx->priv_data;

796 const int frames = FFMIN(avpkt->size / s->avg_frame_size, s->frame_count);

797

798 frame->nb_samples = (1 << s->frame_log2) * frames;

799 ret = ff_get_buffer(avctx, frame, 0);

800 if (ret < 0)

801 return ret;

802

803 init_get_bits8(&gb, avpkt->data, avpkt->size);

804

805 for (int i = 0; i < frames; i++) {

806 for (int j = 0; j < s->block_config->count; j++) {

807 ret = atrac9_decode_block(s, &gb, &s->block[j], frame, i, j);

808 if (ret)

809 return ret;

810 align_get_bits(&gb);

811 }

812 }

813

814 *got_frame_ptr = 1;

815

816 return avctx->block_align;

817 }

818

819 static void atrac9_decode_flush(AVCodecContext *avctx)

820 {

821 ATRAC9Context *s = avctx->priv_data;

822

823 for (int j = 0; j < s->block_config->count; j++) {

824 ATRAC9BlockData *b = &s->block[j];

825 const int stereo = s->block_config->type[j] == ATRAC9_BLOCK_TYPE_CPE;

826 for (int i = 0; i <= stereo; i++) {

827 ATRAC9ChannelData *c = &b->channel[i];

828 memset(c->prev_win, 0, sizeof(c->prev_win));

829 }

830 }

831 }

832

833 static av_cold int atrac9_decode_close(AVCodecContext *avctx)

834 {

835 ATRAC9Context *s = avctx->priv_data;

836

837 ff_mdct_end(&s->imdct);

838 av_freep(&s->fdsp);

839

840 return 0;

841 }

842

843 static av_cold void atrac9_init_vlc(VLC *vlc, int nb_bits, int nb_codes,

844 const uint8_t (**tab)[2],

845 unsigned *buf_offset, int offset)

846 {

847 static VLCElem vlc_buf[24812];

848

849 vlc->table = &vlc_buf[*buf_offset];

850 vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *buf_offset;

851 ff_init_vlc_from_lengths(vlc, nb_bits, nb_codes,

852 &(*tab)[0][1], 2, &(*tab)[0][0], 2, 1,

853 offset, INIT_VLC_STATIC_OVERLONG, NULL);

854 *buf_offset += vlc->table_size;

855 *tab += nb_codes;

856 }

857

858 static av_cold void atrac9_init_static(void)

859 {

860 const uint8_t (*tab)[2];

861 unsigned offset = 0;

862

863 /* Unsigned scalefactor VLCs */

864 tab = at9_sfb_a_tab;

865 for (int i = 1; i < 7; i++) {

866 const HuffmanCodebook *hf = &at9_huffman_sf_unsigned[i];

867

868 atrac9_init_vlc(&sf_vlc[0][i], ATRAC9_SF_VLC_BITS,

869 hf->size, &tab, &offset, 0);

870 }

871

872 /* Signed scalefactor VLCs */

873 tab = at9_sfb_b_tab;

874 for (int i = 2; i < 6; i++) {

875 const HuffmanCodebook *hf = &at9_huffman_sf_signed[i];

876

877 /* The symbols are signed integers in the range -16..15;

878 * the values in the source table are offset by 16 to make

879 * them fit into an uint8_t; the -16 reverses this shift. */

880 atrac9_init_vlc(&sf_vlc[1][i], ATRAC9_SF_VLC_BITS,

881 hf->size, &tab, &offset, -16);

882 }

883

884 /* Coefficient VLCs */

885 tab = at9_coeffs_tab;

886 for (int i = 0; i < 2; i++) {

887 for (int j = 2; j < 8; j++) {

888 for (int k = i; k < 4; k++) {

889 const HuffmanCodebook *hf = &at9_huffman_coeffs[i][j][k];

890 atrac9_init_vlc(&coeff_vlc[i][j][k], ATRAC9_COEFF_VLC_BITS,

891 hf->size, &tab, &offset, 0);

892 }

893 }

894 }

895 }

896

897 static av_cold int atrac9_decode_init(AVCodecContext *avctx)

898 {

899 static AVOnce static_table_init = AV_ONCE_INIT;

900 GetBitContext gb;

901 ATRAC9Context *s = avctx->priv_data;

902 int version, block_config_idx, superframe_idx, alloc_c_len;

903

904 s->avctx = avctx;

905

906 av_lfg_init(&s->lfg, 0xFBADF00D);

907

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

909 av_log(avctx, AV_LOG_ERROR, "Invalid block align\n");

910 return AVERROR_INVALIDDATA;

911 }

912

913 if (avctx->extradata_size != 12) {

914 av_log(avctx, AV_LOG_ERROR, "Invalid extradata length!\n");

915 return AVERROR_INVALIDDATA;

916 }

917

918 version = AV_RL32(avctx->extradata);

919 if (version > 2) {

920 av_log(avctx, AV_LOG_ERROR, "Unsupported version (%i)!\n", version);

921 return AVERROR_INVALIDDATA;

922 }

923

924 init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);

925

926 if (get_bits(&gb, 8) != 0xFE) {

927 av_log(avctx, AV_LOG_ERROR, "Incorrect magic byte!\n");

928 return AVERROR_INVALIDDATA;

929 }

930

931 s->samplerate_idx = get_bits(&gb, 4);

932 avctx->sample_rate = at9_tab_samplerates[s->samplerate_idx];

933

934 block_config_idx = get_bits(&gb, 3);

935 if (block_config_idx > 5) {

936 av_log(avctx, AV_LOG_ERROR, "Incorrect block config!\n");

937 return AVERROR_INVALIDDATA;

938 }

939 s->block_config = &at9_block_layout[block_config_idx];

940

941 av_channel_layout_uninit(&avctx->ch_layout);

942 avctx->ch_layout = s->block_config->channel_layout;

943 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

944

945 if (get_bits1(&gb)) {

946 av_log(avctx, AV_LOG_ERROR, "Incorrect verification bit!\n");

947 return AVERROR_INVALIDDATA;

948 }

949

950 /* Average frame size in bytes */

951 s->avg_frame_size = get_bits(&gb, 11) + 1;

952

953 superframe_idx = get_bits(&gb, 2);

954 if (superframe_idx & 1) {

955 av_log(avctx, AV_LOG_ERROR, "Invalid superframe index!\n");

956 return AVERROR_INVALIDDATA;

957 }

958

959 s->frame_count = 1 << superframe_idx;

960 s->frame_log2 = at9_tab_sri_frame_log2[s->samplerate_idx];

961

962 if (ff_mdct_init(&s->imdct, s->frame_log2 + 1, 1, 1.0f / 32768.0f))

963 return AVERROR(ENOMEM);

964

965 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);

966 if (!s->fdsp)

967 return AVERROR(ENOMEM);

968

969 /* iMDCT window */

970 for (int i = 0; i < (1 << s->frame_log2); i++) {

971 const int len = 1 << s->frame_log2;

972 const float sidx = ( i + 0.5f) / len;

973 const float eidx = (len - i - 0.5f) / len;

974 const float s_c = sinf(sidx*M_PI - M_PI_2)*0.5f + 0.5f;

975 const float e_c = sinf(eidx*M_PI - M_PI_2)*0.5f + 0.5f;

976 s->imdct_win[i] = s_c / ((s_c * s_c) + (e_c * e_c));

977 }

978

979 /* Allocation curve */

980 alloc_c_len = FF_ARRAY_ELEMS(at9_tab_b_dist);

981 for (int i = 1; i <= alloc_c_len; i++)

982 for (int j = 0; j < i; j++)

983 s->alloc_curve[i - 1][j] = at9_tab_b_dist[(j * alloc_c_len) / i];

984

985 ff_thread_once(&static_table_init, atrac9_init_static);

986

987 return 0;

988 }

989

990 const FFCodec ff_atrac9_decoder = {

991 .p.name = "atrac9",

992 .p.long_name = NULL_IF_CONFIG_SMALL("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),

993 .p.type = AVMEDIA_TYPE_AUDIO,

994 .p.id = AV_CODEC_ID_ATRAC9,

995 .priv_data_size = sizeof(ATRAC9Context),

996 .init = atrac9_decode_init,

997 .close = atrac9_decode_close,

998 FF_CODEC_DECODE_CB(atrac9_decode_frame),

999 .flush = atrac9_decode_flush,

1000 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

1001 .p.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,

1002 };

atrac9_decode_close

static av_cold int atrac9_decode_close(AVCodecContext *avctx)

Definition: atrac9dec.c:833

ATRAC9ChannelData::q_coeffs_coarse

int32_t q_coeffs_coarse[256]

Definition: atrac9dec.c:50

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:291

coeff_vlc

static VLC coeff_vlc[2][8][4]

Definition: atrac9dec.c:108

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

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

ATRAC9ChannelData::coeffs

float coeffs[256]

Definition: atrac9dec.c:53

ATRAC9BlockData::is_signs

int is_signs[30]

Definition: atrac9dec.c:80

mem_internal.h

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:998

av_lfg_init

av_cold void av_lfg_init(AVLFG *c, unsigned int seed)

Definition: lfg.c:32

static double cb(void *priv, double x, double y)

Definition: vf_geq.c:239

HuffmanCodebook::size

const int size

Definition: atrac9tab.h:425

at9_band_ext_scales_m2

static const float at9_band_ext_scales_m2[]

Definition: atrac9tab.h:271

thread.h

read_scalefactors

static int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb, int channel_idx, int first_in_pkt)

Definition: atrac9dec.c:260

AVFrame

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

Definition: frame.h:325

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

at9_tab_samplerates

static const int at9_tab_samplerates[]

Definition: atrac9tab.h:116

av_clip_uintp2_c

static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)

Clip a signed integer to an unsigned power of two range.

Definition: common.h:275

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

M_PI_2

#define M_PI_2

Definition: mathematics.h:55

ATRAC9BlockData::has_band_ext

int has_band_ext

Definition: atrac9dec.c:69

calc_codebook_idx

static void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)

Definition: atrac9dec.c:361

#define b

Definition: input.c:34

ATRAC9ChannelData

Definition: atrac9dec.c:37

ATRAC9_COEFF_VLC_BITS

#define ATRAC9_COEFF_VLC_BITS

Definition: atrac9dec.c:35

at9_block_layout

static const ATRAC9BlockConfig at9_block_layout[]

Definition: atrac9tab.h:42

ff_mdct_init

#define ff_mdct_init

Definition: fft.h:153

FFCodec

Definition: codec_internal.h:112

base

uint8_t base

Definition: vp3data.h:141

ATRAC9ChannelData::precision_fine

int precision_fine[30]

Definition: atrac9dec.c:45

HuffmanCodebook::value_cnt

const int value_cnt

Definition: atrac9tab.h:426

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

ATRAC9Context::frame_count

int frame_count

Definition: atrac9dec.c:96

ATRAC9Context::avctx

AVCodecContext * avctx

Definition: atrac9dec.c:87

ATRAC9Context::lfg

AVLFG lfg

Definition: atrac9dec.c:91

ATRAC9ChannelData::precision_mask

int precision_mask[30]

Definition: atrac9dec.c:46

read_coeffs_fine

static void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)

Definition: atrac9dec.c:441

init

static int init

Definition: av_tx.c:47

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:467

ATRAC9Context

Definition: atrac9dec.c:86

ATRAC9Context::imdct

FFTContext imdct

Definition: atrac9dec.c:89

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:379

at9_tab_band_ext_cnt

static const uint8_t at9_tab_band_ext_cnt[][6]

Definition: atrac9tab.h:121

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

calc_precision

static void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)

Definition: atrac9dec.c:154

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:2056

frames

if it could not because there are no more frames

Definition: filter_design.txt:266

GetBitContext

Definition: get_bits.h:61

ATRAC9Context::block

ATRAC9BlockData block[5]

Definition: atrac9dec.c:90

tab

static const struct twinvq_data tab

Definition: twinvq_data.h:10345

ATRAC9BlockData::grad_mode

int grad_mode

Definition: atrac9dec.c:74

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:469

val

static double val(void *priv, double ch)

Definition: aeval.c:77

ATRAC9Context::alloc_curve

uint8_t alloc_curve[48][48]

Definition: atrac9dec.c:101

scale

static av_always_inline float scale(float x, float s)

Definition: vf_v360.c:1389

HuffmanCodebook::value_cnt_pow

const int value_cnt_pow

Definition: atrac9tab.h:427

scale_band_ext_coeffs

static void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6], const int s_unit, const int e_unit)

Definition: atrac9dec.c:532

ff_thread_once

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

Definition: thread.h:179

ATRAC9_BLOCK_TYPE_LFE

@ ATRAC9_BLOCK_TYPE_LFE

Definition: atrac9tab.h:32

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

parse_band_ext

static int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb, int stereo)

Definition: atrac9dec.c:205

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:667

at9_tab_sri_max_bands

static const uint8_t at9_tab_sri_max_bands[]

Definition: atrac9tab.h:112

float

Definition: af_crystalizer.c:122

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:491

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:254

#define s(width, name)

Definition: cbs_vp9.c:256

at9_q_unit_to_codebookidx

static const uint8_t at9_q_unit_to_codebookidx[]

Definition: atrac9tab.h:107

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

lfg.h

fill_with_noise

static void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c, int start, int count)

Definition: atrac9dec.c:516

vlc_buf

static VLCElem vlc_buf[16716]

Definition: clearvideo.c:87

ATRAC9BlockConfig

Definition: atrac9tab.h:35

AV_CODEC_ID_ATRAC9

@ AV_CODEC_ID_ATRAC9

Definition: codec_id.h:515

av_bmg_get

void av_bmg_get(AVLFG *lfg, double out[2])

Get the next two numbers generated by a Box-Muller Gaussian generator using the random numbers issued...

Definition: lfg.c:49

HuffmanCodebook::value_bits

const int value_bits

Definition: atrac9tab.h:428

ATRAC9Context::avg_frame_size

int avg_frame_size

Definition: atrac9dec.c:95

get_bits.h

ATRAC9BlockData::band_ext_q_unit

int band_ext_q_unit

Definition: atrac9dec.c:71

bands

static const float bands[]

Definition: af_superequalizer.c:56

at9_band_ext_scales_m0

static const float at9_band_ext_scales_m0[][5][32]

Definition: atrac9tab.h:184

at9_sfb_a_tab

static const uint8_t at9_sfb_a_tab[][2]

Definition: atrac9tab.h:376

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:64

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:177

ATRAC9_SF_VLC_BITS

#define ATRAC9_SF_VLC_BITS

Definition: atrac9dec.c:34

NULL

#define NULL

Definition: coverity.c:32

HuffmanCodebook

Definition: atrac9tab.h:424

at9_huffman_sf_unsigned

static const HuffmanCodebook at9_huffman_sf_unsigned[]

Definition: atrac9tab.h:431

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:498

ff_init_vlc_from_lengths

int ff_init_vlc_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)

Build VLC decoding tables suitable for use with get_vlc2()

Definition: vlc.c:328

ATRAC9Context::frame_log2

int frame_log2

Definition: atrac9dec.c:94

atrac9_decode_init

static av_cold int atrac9_decode_init(AVCodecContext *avctx)

Definition: atrac9dec.c:897

ATRAC9ChannelData::q_coeffs_fine

int32_t q_coeffs_fine[256]

Definition: atrac9dec.c:51

parse_gradient

static int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb)

Definition: atrac9dec.c:110

ATRAC9BlockData::q_unit_cnt_prev

int q_unit_cnt_prev

Definition: atrac9dec.c:63

sinf

#define sinf(x)

Definition: libm.h:419

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:787

AVOnce

#define AVOnce

Definition: thread.h:176

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

ATRAC9BlockData::gradient

int gradient[31]

Definition: atrac9dec.c:76

float_dsp.h

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.

Definition: channel_layout.c:630

atrac9_init_static

static av_cold void atrac9_init_static(void)

Definition: atrac9dec.c:858

AV_CODEC_CAP_CHANNEL_CONF

#define AV_CODEC_CAP_CHANNEL_CONF

Codec should fill in channel configuration and samplerate instead of container.

Definition: codec.h:109

VLC::table_allocated

int table_allocated

Definition: vlc.h:34

AVLFG

Context structure for the Lagged Fibonacci PRNG.

Definition: lfg.h:33

Definition: af_crystalizer.c:122

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1403

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

AVPacket::size

int size

Definition: packet.h:375

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

codec_internal.h

apply_band_extension

static void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)

Definition: atrac9dec.c:543

for

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

Definition: h264pred_template.c:425

ATRAC9ChannelData::band_ext

int band_ext

Definition: atrac9dec.c:38

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1014

ATRAC9Context::fdsp

AVFloatDSPContext * fdsp

Definition: atrac9dec.c:88

VLCElem

Definition: vlc.h:27

ff_mdct_end

#define ff_mdct_end

Definition: fft.h:154

ATRAC9_BLOCK_TYPE_CPE

@ ATRAC9_BLOCK_TYPE_CPE

Definition: atrac9tab.h:31

avg

#define avg(a, b, c, d)

Definition: colorspacedsp_template.c:28

AVFloatDSPContext

Definition: float_dsp.h:24

ATRAC9ChannelData::band_ext_data

int band_ext_data[4]

Definition: atrac9dec.c:40

dequantize

static void dequantize(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)

Definition: atrac9dec.c:459

ATRAC9BlockData::grad_boundary

int grad_boundary

Definition: atrac9dec.c:75

at9_tab_band_q_unit_map

static const uint8_t at9_tab_band_q_unit_map[]

Definition: atrac9tab.h:93

at9_huffman_sf_signed

static const HuffmanCodebook at9_huffman_sf_signed[]

Definition: atrac9tab.h:441

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:538

version

Definition: libkvazaar.c:313

ATRAC9ChannelData::scalefactors

int32_t scalefactors[31]

Definition: atrac9dec.c:41

at9_q_unit_to_coeff_idx

static const int at9_q_unit_to_coeff_idx[]

Definition: atrac9tab.h:102

M_PI

#define M_PI

Definition: mathematics.h:52

at9_quant_step_coarse

static const float at9_quant_step_coarse[]

Definition: atrac9tab.h:306

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem.h:116

ATRAC9BlockData::stereo_q_unit

int stereo_q_unit

Definition: atrac9dec.c:66

ATRAC9ChannelData::scalefactors_prev

int32_t scalefactors_prev[31]

Definition: atrac9dec.c:42

ATRAC9BlockData::cpe_base_channel

int cpe_base_channel

Definition: atrac9dec.c:79

ATRAC9Context::block_config

const ATRAC9BlockConfig * block_config

Definition: atrac9dec.c:98

FFTContext

Definition: fft.h:75

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

Definition: cbs_h2645.c:269

at9_tab_band_ext_lengths

static const uint8_t at9_tab_band_ext_lengths[][6][4]

Definition: atrac9tab.h:141

ATRAC9Context::imdct_win

float imdct_win[256]

Definition: atrac9dec.c:102

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:490

atrac9_decode_block

static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb, ATRAC9BlockData *b, AVFrame *frame, int frame_idx, int block_idx)

Definition: atrac9dec.c:645

ATRAC9Context::temp

float temp[256]

Definition: atrac9dec.c:104

delta

float delta

Definition: vorbis_enc_data.h:430

at9_band_ext_scales_m3

static const float at9_band_ext_scales_m3[][2]

Definition: atrac9tab.h:290

at9_scalefactor_c

static const float at9_scalefactor_c[]

Definition: atrac9tab.h:324

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

at9_band_ext_scales_m4

static const float at9_band_ext_scales_m4[]

Definition: atrac9tab.h:301

FF_CODEC_CAP_INIT_THREADSAFE

#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: codec_internal.h:31

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

len

int len

Definition: vorbis_enc_data.h:426

atrac9_init_vlc

static av_cold void atrac9_init_vlc(VLC *vlc, int nb_bits, int nb_codes, const uint8_t(**tab)[2], unsigned *buf_offset, int offset)

Definition: atrac9dec.c:843

ATRAC9BlockData::reuseable

int reuseable

Definition: atrac9dec.c:82

ATRAC9ChannelData::precision_coarse

int precision_coarse[30]

Definition: atrac9dec.c:44

ATRAC9ChannelData::codebookset

int codebookset[30]

Definition: atrac9dec.c:48

ret

Definition: filter_design.txt:187

INIT_VLC_STATIC_OVERLONG

#define INIT_VLC_STATIC_OVERLONG

Definition: vlc.h:101

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

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

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:683

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

at9_coeffs_tab

static const uint8_t at9_coeffs_tab[][2]

Definition: atrac9tab.h:450

ATRAC9BlockData

Definition: atrac9dec.c:57