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/mem.h"

24 #include "libavutil/thread.h"

26 #include "codec_internal.h"

27 #include "decode.h"

28 #include "get_bits.h"

29 #include "atrac9tab.h"

30 #include "libavutil/tx.h"

31 #include "libavutil/lfg.h"

32 #include "libavutil/float_dsp.h"

33 #include "libavutil/mem_internal.h"

35 #define ATRAC9_SF_VLC_BITS 8

36 #define ATRAC9_COEFF_VLC_BITS 9

38 typedef struct ATRAC9ChannelData {

39 int band_ext;

40 int q_unit_cnt;

41 int band_ext_data[4];

42 int32_t scalefactors[31];

43 int32_t scalefactors_prev[31];

45 int precision_coarse[30];

46 int precision_fine[30];

47 int precision_mask[30];

49 int codebookset[30];

51 int32_t q_coeffs_coarse[256];

52 int32_t q_coeffs_fine[256];

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

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

56 } ATRAC9ChannelData;

58 typedef struct ATRAC9BlockData {

59 ATRAC9ChannelData channel[2];

61 /* Base */

62 int band_count;

63 int q_unit_cnt;

64 int q_unit_cnt_prev;

66 /* Stereo block only */

67 int stereo_q_unit;

69 /* Band extension only */

70 int has_band_ext;

71 int has_band_ext_data;

72 int band_ext_q_unit;

74 /* Gradient */

75 int grad_mode;

76 int grad_boundary;

77 int gradient[31];

79 /* Stereo */

80 int cpe_base_channel;

81 int is_signs[30];

83 int reusable;

85 } ATRAC9BlockData;

87 typedef struct ATRAC9Context {

88 AVCodecContext *avctx;

89 AVFloatDSPContext *fdsp;

90 AVTXContext *tx;

91 av_tx_fn tx_fn;

92 ATRAC9BlockData block[5];

93 AVLFG lfg;

95 /* Set on init */

96 int frame_log2;

97 int avg_frame_size;

98 int frame_count;

99 int samplerate_idx;

100 const ATRAC9BlockConfig *block_config;

101

102 /* Generated on init */

103 uint8_t alloc_curve[48][48];

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

105

106 DECLARE_ALIGNED(32, float, temp)[2048];

107 } ATRAC9Context;

108

109 static const VLCElem *sf_vlc[2][8]; /* Signed/unsigned, length */

110 static const VLCElem *coeff_vlc[2][8][4]; /* Cookbook, precision, cookbook index */

111

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

113 GetBitContext *gb)

114 {

115 int grad_range[2];

116 int grad_value[2];

117 int values, sign, base;

118 uint8_t *curve;

119 float scale;

120

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

122 if (b->grad_mode) {

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

124 grad_range[1] = 31;

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

126 grad_value[1] = 31;

127 } else {

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

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

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

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

132 }

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

134

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

136 return AVERROR_INVALIDDATA;

137

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

139 return AVERROR_INVALIDDATA;

140

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

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

143 base = grad_value[0] + sign;

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

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

146

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

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

149

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

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

152

153 return 0;

154 }

155

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

157 ATRAC9ChannelData *c)

158 {

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

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

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

162 if (delta > 0) {

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

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

165 }

166 }

167

168 if (b->grad_mode) {

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

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

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

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

173 continue;

174 switch (b->grad_mode) {

175 case 1:

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

177 break;

178 case 2:

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

180 break;

181 case 3:

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

183 break;

184 }

185 }

186 } else {

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

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

189 }

190

191

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

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

194

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

196 c->precision_coarse[i]++;

197

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

199 c->precision_fine[i] = 0;

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

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

202 c->precision_coarse[i] = 15;

203 }

204 }

205 }

206

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

208 GetBitContext *gb, int stereo)

209 {

210 int ext_band = 0;

211

212 if (b->has_band_ext) {

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

214 return AVERROR_INVALIDDATA;

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

216 if (stereo) {

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

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

219 } else {

220 skip_bits1(gb);

221 }

222 }

223

224 b->has_band_ext_data = get_bits1(gb);

225 if (!b->has_band_ext_data)

226 return 0;

227

228 if (!b->has_band_ext) {

229 skip_bits(gb, 2);

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

231 return 0;

232 }

233

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

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

236

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

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

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

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

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

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

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

244 }

245 }

246

247 return 0;

248 }

249

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

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

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

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

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

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

256 }

257 }

258

259 return 0;

260 }

261

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

263 ATRAC9ChannelData *c, GetBitContext *gb,

264 int channel_idx, int first_in_pkt)

265 {

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

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

268

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

270

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

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

273 return AVERROR_INVALIDDATA;

274 }

275

276 switch (mode) {

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

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

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

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

281 const VLCElem *tab = sf_vlc[0][len];

282

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

284

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

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

287 ATRAC9_SF_VLC_BITS, 1);

288 c->scalefactors[i] = av_zero_extend(val, len);

289 }

290

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

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

293

294 break;

295 }

296 case 1: { /* CLC offset */

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

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

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

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

301 break;

302 }

303 case 2:

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

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

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

307 c->scalefactors_prev;

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

309 channel_idx ? b->band_ext_q_unit :

310 b->q_unit_cnt_prev;

311

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

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

314 const VLCElem *tab = sf_vlc[1][len];

315

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

317 int dist = get_vlc2(gb, tab, ATRAC9_SF_VLC_BITS, 1);

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

319 }

320

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

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

323

324 break;

325 }

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

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

328 c->scalefactors_prev;

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

330 b->q_unit_cnt_prev;

331

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

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

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

335 const VLCElem *tab = sf_vlc[0][len];

336

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

338

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

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

341 ATRAC9_SF_VLC_BITS, 1);

342 c->scalefactors[i] = av_zero_extend(val, len);

343 }

344

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

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

347

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

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

350 break;

351 }

352 }

353

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

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

356 return AVERROR_INVALIDDATA;

357

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

359

360 return 0;

361 }

362

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

364 ATRAC9ChannelData *c)

365 {

366 int avg = 0;

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

368

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

370

371 if (c->q_unit_cnt <= 1)

372 return;

373 if (s->samplerate_idx > 7)

374 return;

375

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

377

378 if (c->q_unit_cnt > 12) {

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

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

381 avg = (avg + 6) / 12;

382 }

383

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

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

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

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

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

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

390 c->codebookset[i] = 1;

391 }

392

393

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

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

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

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

398 if (c->codebookset[i])

399 continue;

400

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

402 }

403

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

405 }

406

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

408 ATRAC9ChannelData *c, GetBitContext *gb)

409 {

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

411

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

413

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

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

416 const int bands = at9_q_unit_to_coeff_cnt[i];

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

418

419 if (prec <= max_prec) {

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

421 const int cbi = at9_q_unit_to_codebookidx[i];

422 const VLCElem *tab = coeff_vlc[cb][prec][cbi];

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

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

425

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

427 uint16_t val = get_vlc2(gb, tab, ATRAC9_COEFF_VLC_BITS, 2);

428

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

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

431 val >>= huff->value_bits;

432 }

433

434 coeffs += huff->value_cnt;

435 }

436 } else {

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

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

439 }

440 }

441 }

442

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

444 ATRAC9ChannelData *c, GetBitContext *gb)

445 {

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

447

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

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

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

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

452

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

454 continue;

455

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

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

458 }

459 }

460

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

462 ATRAC9ChannelData *c)

463 {

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

465

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

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

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

469

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

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

472

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

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

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

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

477 }

478 }

479 }

480

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

482 const int stereo)

483 {

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

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

486

487 if (!stereo)

488 return;

489

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

491 return;

492

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

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

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

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

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

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

499 }

500 }

501

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

503 const int stereo)

504 {

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

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

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

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

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

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

511 const float scale = at9_scalefactor_c[scalefactor];

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

513 coeffs[k] *= scale;

514 }

515 }

516 }

517

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

519 int start, int count)

520 {

521 float maxval = 0.0f;

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

523 double tmp[2];

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

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

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

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

528 }

529 /* Normalize */

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

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

532 }

533

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

535 const int s_unit, const int e_unit)

536 {

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

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

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

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

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

542 }

543 }

544

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

546 const int stereo)

547 {

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

549 b->q_unit_cnt,

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

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

552 FFMAX(g_units[2], 22),

553 };

554

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

556 at9_q_unit_to_coeff_idx[g_units[0]],

557 at9_q_unit_to_coeff_idx[g_units[1]],

558 at9_q_unit_to_coeff_idx[g_units[2]],

559 at9_q_unit_to_coeff_idx[g_units[3]],

560 };

561

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

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

564

565 /* Mirror the spectrum */

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

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

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

569

570 switch (c->band_ext) {

571 case 0: {

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

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

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

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

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

577 case 3:

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

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

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

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

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

583 break;

584 case 4:

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

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

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

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

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

590 break;

591 case 5:

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

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

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

595 break;

596 }

597

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

599

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

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

602 break;

603 }

604 case 1: {

605 float sf[6];

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

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

608

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

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

611 break;

612 }

613 case 2: {

614 const float g_sf[2] = {

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

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

617 };

618

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

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

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

622 break;

623 }

624 case 3: {

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

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

627 rate = pow(2, rate);

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

629 scale *= rate;

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

631 }

632 break;

633 }

634 case 4: {

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

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

637

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

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

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

641 break;

642 }

643 }

644 }

645 }

646

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

648 ATRAC9BlockData *b, AVFrame *frame,

649 int frame_idx, int block_idx)

650 {

651 const int first_in_pkt = !get_bits1(gb);

652 const int reuse_params = get_bits1(gb);

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

654

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

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

657 const int precision = reuse_params ? 8 : 4;

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

659

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

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

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

663

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

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

666 c->precision_coarse[i] = precision;

667 c->precision_fine[i] = 0;

668 }

669

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

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

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

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

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

675 }

676

677 dequantize (s, b, c);

678 apply_scalefactors(s, b, 0);

679

680 goto imdct;

681 }

682

683 if (first_in_pkt && reuse_params) {

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

685 return AVERROR_INVALIDDATA;

686 }

687

688 /* Band parameters */

689 if (!reuse_params) {

690 int stereo_band, ext_band;

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

692 b->reusable = 0;

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

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

695

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

697

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

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

700 b->band_count);

701 return AVERROR_INVALIDDATA;

702 }

703

704 if (stereo) {

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

706 if (stereo_band > b->band_count) {

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

708 stereo_band);

709 return AVERROR_INVALIDDATA;

710 }

711 b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];

712 }

713

714 b->has_band_ext = get_bits1(gb);

715 if (b->has_band_ext) {

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

717 if (ext_band < b->band_count) {

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

719 ext_band);

720 return AVERROR_INVALIDDATA;

721 }

722 b->band_ext_q_unit = at9_tab_band_q_unit_map[ext_band];

723 }

724 b->reusable = 1;

725 }

726 if (!b->reusable) {

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

728 return AVERROR_INVALIDDATA;

729 }

730

731 /* Calculate bit alloc gradient */

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

733 return AVERROR_INVALIDDATA;

734

735 /* IS data */

736 b->cpe_base_channel = 0;

737 if (stereo) {

738 b->cpe_base_channel = get_bits1(gb);

739 if (get_bits1(gb)) {

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

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

742 } else {

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

744 b->is_signs[i] = 1;

745 }

746 }

747

748 /* Band extension */

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

750 return AVERROR_INVALIDDATA;

751

752 /* Scalefactors */

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

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

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

756 b->stereo_q_unit;

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

758 return AVERROR_INVALIDDATA;

759

760 calc_precision (s, b, c);

761 calc_codebook_idx (s, b, c);

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

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

764 dequantize (s, b, c);

765 }

766

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

768

769 apply_intensity_stereo(s, b, stereo);

770 apply_scalefactors (s, b, stereo);

771

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

773 apply_band_extension (s, b, stereo);

774

775 imdct:

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

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

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

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

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

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

782

783 s->tx_fn(s->tx, s->temp, c->coeffs, sizeof(float));

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

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

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

787 }

788

789 return 0;

790 }

791

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

793 int *got_frame_ptr, AVPacket *avpkt)

794 {

795 int ret;

796 GetBitContext gb;

797 ATRAC9Context *s = avctx->priv_data;

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

799

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

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

802 if (ret < 0)

803 return ret;

804

805 ret = init_get_bits8(&gb, avpkt->data, avpkt->size);

806 if (ret < 0)

807 return ret;

808

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

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

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

812 if (ret)

813 return ret;

814 align_get_bits(&gb);

815 }

816 }

817

818 *got_frame_ptr = 1;

819

820 return avctx->block_align;

821 }

822

823 static av_cold void atrac9_decode_flush(AVCodecContext *avctx)

824 {

825 ATRAC9Context *s = avctx->priv_data;

826

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

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

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

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

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

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

833 }

834 }

835 }

836

837 static av_cold int atrac9_decode_close(AVCodecContext *avctx)

838 {

839 ATRAC9Context *s = avctx->priv_data;

840

841 av_tx_uninit(&s->tx);

842 av_freep(&s->fdsp);

843

844 return 0;

845 }

846

847 static av_cold const VLCElem *atrac9_init_vlc(VLCInitState *state,

848 int nb_bits, int nb_codes,

849 const uint8_t (**tab)[2], int offset)

850 {

851 const uint8_t (*table)[2] = *tab;

852

853 *tab += nb_codes;

854 return ff_vlc_init_tables_from_lengths(state, nb_bits, nb_codes,

855 &table[0][1], 2, &table[0][0], 2, 1,

856 offset, 0);

857 }

858

859 static av_cold void atrac9_init_static(void)

860 {

861 static VLCElem vlc_buf[24812];

862 VLCInitState state = VLC_INIT_STATE(vlc_buf);

863 const uint8_t (*tab)[2];

864

865 /* Unsigned scalefactor VLCs */

866 tab = at9_sfb_a_tab;

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

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

869

870 sf_vlc[0][i] = atrac9_init_vlc(&state, ATRAC9_SF_VLC_BITS,

871 hf->size, &tab, 0);

872 }

873

874 /* Signed scalefactor VLCs */

875 tab = at9_sfb_b_tab;

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

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

878

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

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

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

882 sf_vlc[1][i] = atrac9_init_vlc(&state, ATRAC9_SF_VLC_BITS,

883 hf->size, &tab, -16);

884 }

885

886 /* Coefficient VLCs */

887 tab = at9_coeffs_tab;

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

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

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

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

892 coeff_vlc[i][j][k] = atrac9_init_vlc(&state, ATRAC9_COEFF_VLC_BITS,

893 hf->size, &tab, 0);

894 }

895 }

896 }

897 }

898

899 static av_cold int atrac9_decode_init(AVCodecContext *avctx)

900 {

901 float scale;

902 static AVOnce static_table_init = AV_ONCE_INIT;

903 GetBitContext gb;

904 ATRAC9Context *s = avctx->priv_data;

905 int err, version, block_config_idx, superframe_idx, alloc_c_len;

906

907 s->avctx = avctx;

908

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

910

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

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

913 return AVERROR_INVALIDDATA;

914 }

915

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

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

918 return AVERROR_INVALIDDATA;

919 }

920

921 version = AV_RL32(avctx->extradata);

922 if (version > 2) {

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

924 return AVERROR_INVALIDDATA;

925 }

926

927 err = init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);

928 if (err < 0)

929 return err;

930

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

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

933 return AVERROR_INVALIDDATA;

934 }

935

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

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

938

939 block_config_idx = get_bits(&gb, 3);

940 if (block_config_idx > 5) {

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

942 return AVERROR_INVALIDDATA;

943 }

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

945

946 av_channel_layout_uninit(&avctx->ch_layout);

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

948 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

949

950 if (get_bits1(&gb)) {

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

952 return AVERROR_INVALIDDATA;

953 }

954

955 /* Average frame size in bytes */

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

957

958 superframe_idx = get_bits(&gb, 2);

959 if (superframe_idx & 1) {

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

961 return AVERROR_INVALIDDATA;

962 }

963

964 s->frame_count = 1 << superframe_idx;

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

966

967 scale = 1.0f / 32768.0;

968 err = av_tx_init(&s->tx, &s->tx_fn, AV_TX_FLOAT_MDCT, 1,

969 1 << s->frame_log2, &scale, 0);

970 if (err < 0)

971 return err;

972

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

974 if (!s->fdsp)

975 return AVERROR(ENOMEM);

976

977 /* iMDCT window */

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

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

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

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

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

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

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

985 }

986

987 /* Allocation curve */

988 alloc_c_len = FF_ARRAY_ELEMS(at9_tab_b_dist);

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

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

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

992

993 ff_thread_once(&static_table_init, atrac9_init_static);

994

995 return 0;

996 }

997

998 const FFCodec ff_atrac9_decoder = {

999 .p.name = "atrac9",

1000 CODEC_LONG_NAME("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),

1001 .p.type = AVMEDIA_TYPE_AUDIO,

1002 .p.id = AV_CODEC_ID_ATRAC9,

1003 .priv_data_size = sizeof(ATRAC9Context),

1004 .init = atrac9_decode_init,

1005 .close = atrac9_decode_close,

1006 FF_CODEC_DECODE_CB(atrac9_decode_frame),

1007 .flush = atrac9_decode_flush,

1008 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

1009 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,

1010 };

atrac9_decode_close

static av_cold int atrac9_decode_close(AVCodecContext *avctx)

Definition: atrac9dec.c:837

ATRAC9ChannelData::q_coeffs_coarse

int32_t q_coeffs_coarse[256]

Definition: atrac9dec.c:51

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

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

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

ATRAC9BlockData::is_signs

int is_signs[30]

Definition: atrac9dec.c:81

mem_internal.h

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1024

av_lfg_init

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

Definition: lfg.c:32

ATRAC9Context::temp

float temp[2048]

Definition: atrac9dec.c:106

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

Definition: vf_geq.c:247

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

AVTXContext

Definition: tx_priv.h:235

mode

Definition: swscale.c:56

AVFrame

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

Definition: frame.h:427

atrac9_init_vlc

static const av_cold VLCElem * atrac9_init_vlc(VLCInitState *state, int nb_bits, int nb_codes, const uint8_t(**tab)[2], int offset)

Definition: atrac9dec.c:847

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

AVPacket::data

uint8_t * data

Definition: packet.h:588

M_PI_2

#define M_PI_2

Definition: mathematics.h:73

ATRAC9BlockData::has_band_ext

int has_band_ext

Definition: atrac9dec.c:70

calc_codebook_idx

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

Definition: atrac9dec.c:363

#define b

Definition: input.c:42

ATRAC9ChannelData

Definition: atrac9dec.c:38

table

static const uint16_t table[]

Definition: prosumer.c:203

ATRAC9_COEFF_VLC_BITS

#define ATRAC9_COEFF_VLC_BITS

Definition: atrac9dec.c:36

at9_block_layout

static const ATRAC9BlockConfig at9_block_layout[]

Definition: atrac9tab.h:42

FFCodec

Definition: codec_internal.h:127

base

uint8_t base

Definition: vp3data.h:128

ATRAC9ChannelData::precision_fine

int precision_fine[30]

Definition: atrac9dec.c:46

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

ATRAC9Context::avctx

AVCodecContext * avctx

Definition: atrac9dec.c:88

ATRAC9Context::lfg

AVLFG lfg

Definition: atrac9dec.c:93

ATRAC9ChannelData::precision_mask

int precision_mask[30]

Definition: atrac9dec.c:47

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

read_coeffs_fine

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

Definition: atrac9dec.c:443

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:383

ATRAC9Context

Definition: atrac9dec.c:87

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:136

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:337

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

calc_precision

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

Definition: atrac9dec.c:156

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

frames

if it could not because there are no more frames

Definition: filter_design.txt:267

GetBitContext

Definition: get_bits.h:109

ATRAC9Context::block

ATRAC9BlockData block[5]

Definition: atrac9dec.c:92

tab

static const struct twinvq_data tab

Definition: twinvq_data.h:10345

ATRAC9BlockData::grad_mode

int grad_mode

Definition: atrac9dec.c:75

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:488

val

static double val(void *priv, double ch)

Definition: aeval.c:77

ATRAC9Context::alloc_curve

uint8_t alloc_curve[48][48]

Definition: atrac9dec.c:103

HuffmanCodebook::value_cnt_pow

const int value_cnt_pow

Definition: atrac9tab.h:427

state

static struct @542 state

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

ff_thread_once

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

Definition: thread.h:205

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

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:106

parse_band_ext

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

Definition: atrac9dec.c:207

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:544

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

VLCInitState

For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.

Definition: vlc.h:220

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

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

atrac9_decode_flush

static av_cold void atrac9_decode_flush(AVCodecContext *avctx)

Definition: atrac9dec.c:823

#define s(width, name)

Definition: cbs_vp9.c:198

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

lfg.h

fill_with_noise

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

Definition: atrac9dec.c:518

ATRAC9BlockConfig

Definition: atrac9tab.h:35

AV_CODEC_ID_ATRAC9

@ AV_CODEC_ID_ATRAC9

Definition: codec_id.h:547

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

decode.h

get_bits.h

ATRAC9BlockData::band_ext_q_unit

int band_ext_q_unit

Definition: atrac9dec.c:72

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

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:332

at9_sfb_a_tab

static const uint8_t at9_sfb_a_tab[][2]

Definition: atrac9tab.h:376

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

FFABS

#define FFABS(a)

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

Definition: common.h:74

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

ATRAC9_SF_VLC_BITS

#define ATRAC9_SF_VLC_BITS

Definition: atrac9dec.c:35

HuffmanCodebook

Definition: atrac9tab.h:424

ATRAC9Context::tx_fn

av_tx_fn tx_fn

Definition: atrac9dec.c:91

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

ATRAC9Context::frame_log2

int frame_log2

Definition: atrac9dec.c:96

atrac9_decode_init

static av_cold int atrac9_decode_init(AVCodecContext *avctx)

Definition: atrac9dec.c:899

ATRAC9ChannelData::q_coeffs_fine

int32_t q_coeffs_fine[256]

Definition: atrac9dec.c:52

parse_gradient

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

Definition: atrac9dec.c:112

ATRAC9BlockData::q_unit_cnt_prev

int q_unit_cnt_prev

Definition: atrac9dec.c:64

sinf

#define sinf(x)

Definition: libm.h:421

sf_vlc

static const VLCElem * sf_vlc[2][8]

Definition: atrac9dec.c:109

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

AVOnce

#define AVOnce

Definition: thread.h:202

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

float_dsp.h

atrac9_init_static

static av_cold void atrac9_init_static(void)

Definition: atrac9dec.c:859

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

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

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:550

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

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:104

dst

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

Definition: dsp.h:87

apply_band_extension

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

Definition: atrac9dec.c:545

for

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

Definition: h264pred_template.c:424

ATRAC9ChannelData::band_ext

int band_ext

Definition: atrac9dec.c:39

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1031

ATRAC9Context::fdsp

AVFloatDSPContext * fdsp

Definition: atrac9dec.c:89

VLCElem

Definition: vlc.h:32

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

dequantize

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

Definition: atrac9dec.c:461

ATRAC9BlockData::grad_boundary

int grad_boundary

Definition: atrac9dec.c:76

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

version

Definition: libkvazaar.c:313

av_zero_extend

#define av_zero_extend

Definition: common.h:151

ATRAC9ChannelData::scalefactors

int32_t scalefactors[31]

Definition: atrac9dec.c:42

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

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

at9_quant_step_coarse

static const float at9_quant_step_coarse[]

Definition: atrac9tab.h:306

ATRAC9BlockData::stereo_q_unit

int stereo_q_unit

Definition: atrac9dec.c:67

ATRAC9ChannelData::scalefactors_prev

int32_t scalefactors_prev[31]

Definition: atrac9dec.c:43

ATRAC9BlockData::cpe_base_channel

int cpe_base_channel

Definition: atrac9dec.c:80

ATRAC9Context::block_config

const ATRAC9BlockConfig * block_config

Definition: atrac9dec.c:100

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

Definition: cbs_h2645.c:256

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

AVCodecContext::extradata

uint8_t * extradata

Out-of-band global headers that may be used by some codecs.

Definition: avcodec.h:514

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

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

uint8_t ptrdiff_t const uint8_t ptrdiff_t int const int8_t * hf

Definition: dsp.h:258

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

len

int len

Definition: vorbis_enc_data.h:426

ATRAC9ChannelData::precision_coarse

int precision_coarse[30]

Definition: atrac9dec.c:45

ATRAC9ChannelData::codebookset

int codebookset[30]

Definition: atrac9dec.c:49

ret

Definition: filter_design.txt:187

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

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

ATRAC9BlockData::reusable

int reusable

Definition: atrac9dec.c:83

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:560

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

coeff_vlc

static const VLCElem * coeff_vlc[2][8][4]

Definition: atrac9dec.c:110

ATRAC9BlockData

Definition: atrac9dec.c:58

AVCodecContext

main external API structure.

Definition: avcodec.h:431

ATRAC9BlockData::has_band_ext_data

int has_band_ext_data

Definition: atrac9dec.c:71

atrac9tab.h

channel_layout.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:442

at9_quant_step_fine

static const float at9_quant_step_fine[]

Definition: atrac9tab.h:315

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:132

apply_scalefactors

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

Definition: atrac9dec.c:502

values

Definition: filter_design.txt:264

atrac9_decode_frame

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

Definition: atrac9dec.c:792

ATRAC9Context::samplerate_idx

int samplerate_idx

Definition: atrac9dec.c:99

read_coeffs_coarse

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

Definition: atrac9dec.c:407

at9_tab_sf_weights

static const uint8_t at9_tab_sf_weights[][32]

Definition: atrac9tab.h:335

ATRAC9ChannelData::q_unit_cnt

int q_unit_cnt

Definition: atrac9dec.c:40

ff_vlc_init_tables_from_lengths

const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, 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)

Definition: vlc.c:366

ATRAC9Context::tx

AVTXContext * tx

Definition: atrac9dec.c:90

mem.h

at9_tab_band_ext_group

static const uint8_t at9_tab_band_ext_group[][3]

Definition: atrac9tab.h:130

AV_CODEC_FLAG_BITEXACT

#define AV_CODEC_FLAG_BITEXACT

Use only bitexact stuff (except (I)DCT).

Definition: avcodec.h:322