FFmpeg: libavcodec/wmadec.c Source File

FFmpeg

[フレーム]

libavcodec

wmadec.c

Go to the documentation of this file.

1 /*

2 * WMA compatible 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 /**

23 * @file

24 * WMA compatible decoder.

25 * This decoder handles Microsoft Windows Media Audio data, versions 1 & 2.

26 * WMA v1 is identified by audio format 0x160 in Microsoft media files

27 * (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161.

28 *

29 * To use this decoder, a calling application must supply the extra data

30 * bytes provided with the WMA data. These are the extra, codec-specific

31 * bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes

32 * to the decoder using the extradata[_size] fields in AVCodecContext. There

33 * should be 4 extra bytes for v1 data and 6 extra bytes for v2 data.

34 */

36 #include "config_components.h"

38 #include "libavutil/attributes.h"

39 #include "libavutil/ffmath.h"

41 #include "avcodec.h"

42 #include "codec_internal.h"

43 #include "decode.h"

44 #include "internal.h"

45 #include "wma.h"

47 #define EXPVLCBITS 8

48 #define EXPMAX ((19 + EXPVLCBITS - 1) / EXPVLCBITS)

50 #define HGAINVLCBITS 9

51 #define HGAINMAX ((13 + HGAINVLCBITS - 1) / HGAINVLCBITS)

53 static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len);

55 #ifdef TRACE

56 static void dump_floats(WMACodecContext *s, const char *name,

57 int prec, const float *tab, int n)

58 {

59 int i;

61 ff_tlog(s->avctx, "%s[%d]:\n", name, n);

62 for (i = 0; i < n; i++) {

63 if ((i & 7) == 0)

64 ff_tlog(s->avctx, "%4d: ", i);

65 ff_tlog(s->avctx, " %8.*f", prec, tab[i]);

66 if ((i & 7) == 7)

67 ff_tlog(s->avctx, "\n");

68 }

69 if ((i & 7) != 0)

70 ff_tlog(s->avctx, "\n");

71 }

72 #endif /* TRACE */

74 static av_cold int wma_decode_init(AVCodecContext *avctx)

75 {

76 WMACodecContext *s = avctx->priv_data;

77 int i, flags2, ret;

78 uint8_t *extradata;

80 if (!avctx->block_align) {

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

82 return AVERROR(EINVAL);

83 }

85 s->avctx = avctx;

87 /* extract flag info */

88 flags2 = 0;

89 extradata = avctx->extradata;

90 if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4)

91 flags2 = AV_RL16(extradata + 2);

92 else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6)

93 flags2 = AV_RL16(extradata + 4);

95 s->use_exp_vlc = flags2 & 0x0001;

96 s->use_bit_reservoir = flags2 & 0x0002;

97 s->use_variable_block_len = flags2 & 0x0004;

99 if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 8){

100 if (AV_RL16(extradata+4)==0xd && s->use_variable_block_len){

101 av_log(avctx, AV_LOG_WARNING, "Disabling use_variable_block_len, if this fails contact the ffmpeg developers and send us the file\n");

102 s->use_variable_block_len= 0; // this fixes issue1503

103 }

104 }

105

106 for (i=0; i<MAX_CHANNELS; i++)

107 s->max_exponent[i] = 1.0;

108

109 if ((ret = ff_wma_init(avctx, flags2)) < 0)

110 return ret;

111

112 /* init MDCT */

113 for (i = 0; i < s->nb_block_sizes; i++) {

114 float scale = 1.0 / 32768.0;

115 ret = av_tx_init(&s->mdct_ctx[i], &s->mdct_fn[i], AV_TX_FLOAT_MDCT,

116 1, 1 << (s->frame_len_bits - i), &scale, AV_TX_FULL_IMDCT);

117 if (ret < 0)

118 return ret;

119 }

120

121 if (s->use_noise_coding) {

122 ret = ff_vlc_init_from_lengths(&s->hgain_vlc, HGAINVLCBITS,

123 FF_ARRAY_ELEMS(ff_wma_hgain_hufftab),

124 &ff_wma_hgain_hufftab[0][1], 2,

125 &ff_wma_hgain_hufftab[0][0], 2, 1,

126 -18, 0, avctx);

127 if (ret < 0)

128 return ret;

129 }

130

131 if (s->use_exp_vlc) {

132 // FIXME move out of context

133 ret = vlc_init(&s->exp_vlc, EXPVLCBITS, sizeof(ff_aac_scalefactor_bits),

134 ff_aac_scalefactor_bits, 1, 1,

135 ff_aac_scalefactor_code, 4, 4, 0);

136 if (ret < 0)

137 return ret;

138 } else

139 wma_lsp_to_curve_init(s, s->frame_len);

140

141 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

142

143 avctx->internal->skip_samples = s->frame_len * 2;

144

145 return 0;

146 }

147

148 /**

149 * compute x^-0.25 with an exponent and mantissa table. We use linear

150 * interpolation to reduce the mantissa table size at a small speed

151 * expense (linear interpolation approximately doubles the number of

152 * bits of precision).

153 */

154 static inline float pow_m1_4(WMACodecContext *s, float x)

155 {

156 union {

157 float f;

158 unsigned int v;

159 } u, t;

160 unsigned int e, m;

161 float a, b;

162

163 u.f = x;

164 e = u.v >> 23;

165 m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);

166 /* build interpolation scale: 1 <= t < 2. */

167 t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);

168 a = s->lsp_pow_m_table1[m];

169 b = s->lsp_pow_m_table2[m];

170 return s->lsp_pow_e_table[e] * (a + b * t.f);

171 }

172

173 static av_cold void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)

174 {

175 float wdel, a, b;

176 int i, e, m;

177

178 wdel = M_PI / frame_len;

179 for (i = 0; i < frame_len; i++)

180 s->lsp_cos_table[i] = 2.0f * cos(wdel * i);

181

182 /* tables for x^-0.25 computation */

183 for (i = 0; i < 256; i++) {

184 e = i - 126;

185 s->lsp_pow_e_table[i] = exp2f(e * -0.25);

186 }

187

188 /* NOTE: these two tables are needed to avoid two operations in

189 * pow_m1_4 */

190 b = 1.0;

191 for (i = (1 << LSP_POW_BITS) - 1; i >= 0; i--) {

192 m = (1 << LSP_POW_BITS) + i;

193 a = (float) m * (0.5 / (1 << LSP_POW_BITS));

194 a = 1/sqrt(sqrt(a));

195 s->lsp_pow_m_table1[i] = 2 * a - b;

196 s->lsp_pow_m_table2[i] = b - a;

197 b = a;

198 }

199 }

200

201 /**

202 * NOTE: We use the same code as Vorbis here

203 * @todo optimize it further with SSE/3Dnow

204 */

205 static void wma_lsp_to_curve(WMACodecContext *s, float *out, float *val_max_ptr,

206 int n, float *lsp)

207 {

208 int i, j;

209 float p, q, w, v, val_max;

210

211 val_max = 0;

212 for (i = 0; i < n; i++) {

213 p = 0.5f;

214 q = 0.5f;

215 w = s->lsp_cos_table[i];

216 for (j = 1; j < NB_LSP_COEFS; j += 2) {

217 q *= w - lsp[j - 1];

218 p *= w - lsp[j];

219 }

220 p *= p * (2.0f - w);

221 q *= q * (2.0f + w);

222 v = p + q;

223 v = pow_m1_4(s, v);

224 if (v > val_max)

225 val_max = v;

226 out[i] = v;

227 }

228 *val_max_ptr = val_max;

229 }

230

231 /**

232 * decode exponents coded with LSP coefficients (same idea as Vorbis)

233 */

234 static void decode_exp_lsp(WMACodecContext *s, int ch)

235 {

236 float lsp_coefs[NB_LSP_COEFS];

237 int val, i;

238

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

240 if (i == 0 || i >= 8)

241 val = get_bits(&s->gb, 3);

242 else

243 val = get_bits(&s->gb, 4);

244 lsp_coefs[i] = ff_wma_lsp_codebook[i][val];

245 }

246

247 wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch],

248 s->block_len, lsp_coefs);

249 }

250

251 /** pow(10, i / 16.0) for i in -60..95 */

252 static const float pow_tab[] = {

253 1.7782794100389e-04, 2.0535250264571e-04,

254 2.3713737056617e-04, 2.7384196342644e-04,

255 3.1622776601684e-04, 3.6517412725484e-04,

256 4.2169650342858e-04, 4.8696752516586e-04,

257 5.6234132519035e-04, 6.4938163157621e-04,

258 7.4989420933246e-04, 8.6596432336006e-04,

259 1.0000000000000e-03, 1.1547819846895e-03,

260 1.3335214321633e-03, 1.5399265260595e-03,

261 1.7782794100389e-03, 2.0535250264571e-03,

262 2.3713737056617e-03, 2.7384196342644e-03,

263 3.1622776601684e-03, 3.6517412725484e-03,

264 4.2169650342858e-03, 4.8696752516586e-03,

265 5.6234132519035e-03, 6.4938163157621e-03,

266 7.4989420933246e-03, 8.6596432336006e-03,

267 1.0000000000000e-02, 1.1547819846895e-02,

268 1.3335214321633e-02, 1.5399265260595e-02,

269 1.7782794100389e-02, 2.0535250264571e-02,

270 2.3713737056617e-02, 2.7384196342644e-02,

271 3.1622776601684e-02, 3.6517412725484e-02,

272 4.2169650342858e-02, 4.8696752516586e-02,

273 5.6234132519035e-02, 6.4938163157621e-02,

274 7.4989420933246e-02, 8.6596432336007e-02,

275 1.0000000000000e-01, 1.1547819846895e-01,

276 1.3335214321633e-01, 1.5399265260595e-01,

277 1.7782794100389e-01, 2.0535250264571e-01,

278 2.3713737056617e-01, 2.7384196342644e-01,

279 3.1622776601684e-01, 3.6517412725484e-01,

280 4.2169650342858e-01, 4.8696752516586e-01,

281 5.6234132519035e-01, 6.4938163157621e-01,

282 7.4989420933246e-01, 8.6596432336007e-01,

283 1.0000000000000e+00, 1.1547819846895e+00,

284 1.3335214321633e+00, 1.5399265260595e+00,

285 1.7782794100389e+00, 2.0535250264571e+00,

286 2.3713737056617e+00, 2.7384196342644e+00,

287 3.1622776601684e+00, 3.6517412725484e+00,

288 4.2169650342858e+00, 4.8696752516586e+00,

289 5.6234132519035e+00, 6.4938163157621e+00,

290 7.4989420933246e+00, 8.6596432336007e+00,

291 1.0000000000000e+01, 1.1547819846895e+01,

292 1.3335214321633e+01, 1.5399265260595e+01,

293 1.7782794100389e+01, 2.0535250264571e+01,

294 2.3713737056617e+01, 2.7384196342644e+01,

295 3.1622776601684e+01, 3.6517412725484e+01,

296 4.2169650342858e+01, 4.8696752516586e+01,

297 5.6234132519035e+01, 6.4938163157621e+01,

298 7.4989420933246e+01, 8.6596432336007e+01,

299 1.0000000000000e+02, 1.1547819846895e+02,

300 1.3335214321633e+02, 1.5399265260595e+02,

301 1.7782794100389e+02, 2.0535250264571e+02,

302 2.3713737056617e+02, 2.7384196342644e+02,

303 3.1622776601684e+02, 3.6517412725484e+02,

304 4.2169650342858e+02, 4.8696752516586e+02,

305 5.6234132519035e+02, 6.4938163157621e+02,

306 7.4989420933246e+02, 8.6596432336007e+02,

307 1.0000000000000e+03, 1.1547819846895e+03,

308 1.3335214321633e+03, 1.5399265260595e+03,

309 1.7782794100389e+03, 2.0535250264571e+03,

310 2.3713737056617e+03, 2.7384196342644e+03,

311 3.1622776601684e+03, 3.6517412725484e+03,

312 4.2169650342858e+03, 4.8696752516586e+03,

313 5.6234132519035e+03, 6.4938163157621e+03,

314 7.4989420933246e+03, 8.6596432336007e+03,

315 1.0000000000000e+04, 1.1547819846895e+04,

316 1.3335214321633e+04, 1.5399265260595e+04,

317 1.7782794100389e+04, 2.0535250264571e+04,

318 2.3713737056617e+04, 2.7384196342644e+04,

319 3.1622776601684e+04, 3.6517412725484e+04,

320 4.2169650342858e+04, 4.8696752516586e+04,

321 5.6234132519035e+04, 6.4938163157621e+04,

322 7.4989420933246e+04, 8.6596432336007e+04,

323 1.0000000000000e+05, 1.1547819846895e+05,

324 1.3335214321633e+05, 1.5399265260595e+05,

325 1.7782794100389e+05, 2.0535250264571e+05,

326 2.3713737056617e+05, 2.7384196342644e+05,

327 3.1622776601684e+05, 3.6517412725484e+05,

328 4.2169650342858e+05, 4.8696752516586e+05,

329 5.6234132519035e+05, 6.4938163157621e+05,

330 7.4989420933246e+05, 8.6596432336007e+05,

331 };

332

333 /**

334 * decode exponents coded with VLC codes

335 */

336 static int decode_exp_vlc(WMACodecContext *s, int ch)

337 {

338 int last_exp, n, code;

339 const uint16_t *ptr;

340 float v, max_scale;

341 uint32_t *q, *q_end, iv;

342 const float *ptab = pow_tab + 60;

343 const uint32_t *iptab = (const uint32_t *) ptab;

344

345 ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];

346 q = (uint32_t *) s->exponents[ch];

347 q_end = q + s->block_len;

348 max_scale = 0;

349 if (s->version == 1) {

350 last_exp = get_bits(&s->gb, 5) + 10;

351 v = ptab[last_exp];

352 iv = iptab[last_exp];

353 max_scale = v;

354 n = *ptr++;

355 switch (n & 3) do {

356 case 0: *q++ = iv;

357 case 3: *q++ = iv;

358 case 2: *q++ = iv;

359 case 1: *q++ = iv;

360 } while ((n -= 4) > 0);

361 } else

362 last_exp = 36;

363

364 while (q < q_end) {

365 code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);

366 /* NOTE: this offset is the same as MPEG-4 AAC! */

367 last_exp += code - 60;

368 if ((unsigned) last_exp + 60 >= FF_ARRAY_ELEMS(pow_tab)) {

369 av_log(s->avctx, AV_LOG_ERROR, "Exponent out of range: %d\n",

370 last_exp);

371 return AVERROR_INVALIDDATA;

372 }

373 v = ptab[last_exp];

374 iv = iptab[last_exp];

375 if (v > max_scale)

376 max_scale = v;

377 n = *ptr++;

378 switch (n & 3) do {

379 case 0: *q++ = iv;

380 case 3: *q++ = iv;

381 case 2: *q++ = iv;

382 case 1: *q++ = iv;

383 } while ((n -= 4) > 0);

384 }

385 s->max_exponent[ch] = max_scale;

386 return 0;

387 }

388

389 /**

390 * Apply MDCT window and add into output.

391 *

392 * We ensure that when the windows overlap their squared sum

393 * is always 1 (MDCT reconstruction rule).

394 */

395 static void wma_window(WMACodecContext *s, float *out)

396 {

397 float *in = s->output;

398 int block_len, bsize, n;

399

400 /* left part */

401 if (s->block_len_bits <= s->prev_block_len_bits) {

402 block_len = s->block_len;

403 bsize = s->frame_len_bits - s->block_len_bits;

404

405 s->fdsp->vector_fmul_add(out, in, s->windows[bsize],

406 out, block_len);

407 } else {

408 block_len = 1 << s->prev_block_len_bits;

409 n = (s->block_len - block_len) / 2;

410 bsize = s->frame_len_bits - s->prev_block_len_bits;

411

412 s->fdsp->vector_fmul_add(out + n, in + n, s->windows[bsize],

413 out + n, block_len);

414

415 memcpy(out + n + block_len, in + n + block_len, n * sizeof(float));

416 }

417

418 out += s->block_len;

419 in += s->block_len;

420

421 /* right part */

422 if (s->block_len_bits <= s->next_block_len_bits) {

423 block_len = s->block_len;

424 bsize = s->frame_len_bits - s->block_len_bits;

425

426 s->fdsp->vector_fmul_reverse(out, in, s->windows[bsize], block_len);

427 } else {

428 block_len = 1 << s->next_block_len_bits;

429 n = (s->block_len - block_len) / 2;

430 bsize = s->frame_len_bits - s->next_block_len_bits;

431

432 memcpy(out, in, n * sizeof(float));

433

434 s->fdsp->vector_fmul_reverse(out + n, in + n, s->windows[bsize],

435 block_len);

436

437 memset(out + n + block_len, 0, n * sizeof(float));

438 }

439 }

440

441 /**

442 * @return

443 * 0 if OK.

444 * 1 if last block of frame.

445 * AVERROR if unrecoverable error.

446 */

447 static int wma_decode_block(WMACodecContext *s)

448 {

449 int channels = s->avctx->ch_layout.nb_channels;

450 int n, v, a, ch, bsize;

451 int coef_nb_bits, total_gain;

452 int nb_coefs[MAX_CHANNELS];

453 float mdct_norm;

454 AVTXContext *mdct;

455 av_tx_fn mdct_fn;

456

457 #ifdef TRACE

458 ff_tlog(s->avctx, "***decode_block: %d:%d\n",

459 s->frame_count - 1, s->block_num);

460 #endif /* TRACE */

461

462 /* compute current block length */

463 if (s->use_variable_block_len) {

464 n = av_log2(s->nb_block_sizes - 1) + 1;

465

466 if (s->reset_block_lengths) {

467 s->reset_block_lengths = 0;

468 v = get_bits(&s->gb, n);

469 if (v >= s->nb_block_sizes) {

470 av_log(s->avctx, AV_LOG_ERROR,

471 "prev_block_len_bits %d out of range\n",

472 s->frame_len_bits - v);

473 return AVERROR_INVALIDDATA;

474 }

475 s->prev_block_len_bits = s->frame_len_bits - v;

476 v = get_bits(&s->gb, n);

477 if (v >= s->nb_block_sizes) {

478 av_log(s->avctx, AV_LOG_ERROR,

479 "block_len_bits %d out of range\n",

480 s->frame_len_bits - v);

481 return AVERROR_INVALIDDATA;

482 }

483 s->block_len_bits = s->frame_len_bits - v;

484 } else {

485 /* update block lengths */

486 s->prev_block_len_bits = s->block_len_bits;

487 s->block_len_bits = s->next_block_len_bits;

488 }

489 v = get_bits(&s->gb, n);

490 if (v >= s->nb_block_sizes) {

491 av_log(s->avctx, AV_LOG_ERROR,

492 "next_block_len_bits %d out of range\n",

493 s->frame_len_bits - v);

494 return AVERROR_INVALIDDATA;

495 }

496 s->next_block_len_bits = s->frame_len_bits - v;

497 } else {

498 /* fixed block len */

499 s->next_block_len_bits = s->frame_len_bits;

500 s->prev_block_len_bits = s->frame_len_bits;

501 s->block_len_bits = s->frame_len_bits;

502 }

503

504 if (s->frame_len_bits - s->block_len_bits >= s->nb_block_sizes){

505 av_log(s->avctx, AV_LOG_ERROR, "block_len_bits not initialized to a valid value\n");

506 return AVERROR_INVALIDDATA;

507 }

508

509 /* now check if the block length is coherent with the frame length */

510 s->block_len = 1 << s->block_len_bits;

511 if ((s->block_pos + s->block_len) > s->frame_len) {

512 av_log(s->avctx, AV_LOG_ERROR, "frame_len overflow\n");

513 return AVERROR_INVALIDDATA;

514 }

515

516 if (channels == 2)

517 s->ms_stereo = get_bits1(&s->gb);

518 v = 0;

519 for (ch = 0; ch < channels; ch++) {

520 a = get_bits1(&s->gb);

521 s->channel_coded[ch] = a;

522 v |= a;

523 }

524

525 bsize = s->frame_len_bits - s->block_len_bits;

526

527 /* if no channel coded, no need to go further */

528 /* XXX: fix potential framing problems */

529 if (!v)

530 goto next;

531

532 /* read total gain and extract corresponding number of bits for

533 * coef escape coding */

534 total_gain = 1;

535 for (;;) {

536 if (get_bits_left(&s->gb) < 7) {

537 av_log(s->avctx, AV_LOG_ERROR, "total_gain overread\n");

538 return AVERROR_INVALIDDATA;

539 }

540 a = get_bits(&s->gb, 7);

541 total_gain += a;

542 if (a != 127)

543 break;

544 }

545

546 coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);

547

548 /* compute number of coefficients */

549 n = s->coefs_end[bsize] - s->coefs_start;

550 for (ch = 0; ch < channels; ch++)

551 nb_coefs[ch] = n;

552

553 /* complex coding */

554 if (s->use_noise_coding) {

555 for (ch = 0; ch < channels; ch++) {

556 if (s->channel_coded[ch]) {

557 int i, n, a;

558 n = s->exponent_high_sizes[bsize];

559 for (i = 0; i < n; i++) {

560 a = get_bits1(&s->gb);

561 s->high_band_coded[ch][i] = a;

562 /* if noise coding, the coefficients are not transmitted */

563 if (a)

564 nb_coefs[ch] -= s->exponent_high_bands[bsize][i];

565 }

566 }

567 }

568 for (ch = 0; ch < channels; ch++) {

569 if (s->channel_coded[ch]) {

570 int i, n, val;

571

572 n = s->exponent_high_sizes[bsize];

573 val = (int) 0x80000000;

574 for (i = 0; i < n; i++) {

575 if (s->high_band_coded[ch][i]) {

576 if (val == (int) 0x80000000) {

577 val = get_bits(&s->gb, 7) - 19;

578 } else {

579 val += get_vlc2(&s->gb, s->hgain_vlc.table,

580 HGAINVLCBITS, HGAINMAX);

581 }

582 s->high_band_values[ch][i] = val;

583 }

584 }

585 }

586 }

587 }

588

589 /* exponents can be reused in short blocks. */

590 if ((s->block_len_bits == s->frame_len_bits) || get_bits1(&s->gb)) {

591 for (ch = 0; ch < channels; ch++) {

592 if (s->channel_coded[ch]) {

593 if (s->use_exp_vlc) {

594 if (decode_exp_vlc(s, ch) < 0)

595 return AVERROR_INVALIDDATA;

596 } else {

597 decode_exp_lsp(s, ch);

598 }

599 s->exponents_bsize[ch] = bsize;

600 s->exponents_initialized[ch] = 1;

601 }

602 }

603 }

604

605 for (ch = 0; ch < channels; ch++) {

606 if (s->channel_coded[ch] && !s->exponents_initialized[ch])

607 return AVERROR_INVALIDDATA;

608 }

609

610 /* parse spectral coefficients : just RLE encoding */

611 for (ch = 0; ch < channels; ch++) {

612 if (s->channel_coded[ch]) {

613 int tindex;

614 WMACoef *ptr = &s->coefs1[ch][0];

615 int ret;

616

617 /* special VLC tables are used for ms stereo because

618 * there is potentially less energy there */

619 tindex = (ch == 1 && s->ms_stereo);

620 memset(ptr, 0, s->block_len * sizeof(WMACoef));

621 ret = ff_wma_run_level_decode(s->avctx, &s->gb, s->coef_vlc[tindex].table,

622 s->level_table[tindex], s->run_table[tindex],

623 0, ptr, 0, nb_coefs[ch],

624 s->block_len, s->frame_len_bits, coef_nb_bits);

625 if (ret < 0)

626 return ret;

627 }

628 if (s->version == 1 && channels >= 2)

629 align_get_bits(&s->gb);

630 }

631

632 /* normalize */

633 {

634 int n4 = s->block_len / 2;

635 mdct_norm = 1.0 / (float) n4;

636 if (s->version == 1)

637 mdct_norm *= sqrt(n4);

638 }

639

640 /* finally compute the MDCT coefficients */

641 for (ch = 0; ch < channels; ch++) {

642 if (s->channel_coded[ch]) {

643 WMACoef *coefs1;

644 float *coefs, *exponents, mult, mult1, noise;

645 int i, j, n, n1, last_high_band, esize;

646 float exp_power[HIGH_BAND_MAX_SIZE];

647

648 coefs1 = s->coefs1[ch];

649 exponents = s->exponents[ch];

650 esize = s->exponents_bsize[ch];

651 mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];

652 mult *= mdct_norm;

653 coefs = s->coefs[ch];

654 if (s->use_noise_coding) {

655 mult1 = mult;

656 /* very low freqs : noise */

657 for (i = 0; i < s->coefs_start; i++) {

658 *coefs++ = s->noise_table[s->noise_index] *

659 exponents[i << bsize >> esize] * mult1;

660 s->noise_index = (s->noise_index + 1) &

661 (NOISE_TAB_SIZE - 1);

662 }

663

664 n1 = s->exponent_high_sizes[bsize];

665

666 /* compute power of high bands */

667 exponents = s->exponents[ch] +

668 (s->high_band_start[bsize] << bsize >> esize);

669 last_high_band = 0; /* avoid warning */

670 for (j = 0; j < n1; j++) {

671 n = s->exponent_high_bands[s->frame_len_bits -

672 s->block_len_bits][j];

673 if (s->high_band_coded[ch][j]) {

674 float e2, v;

675 e2 = 0;

676 for (i = 0; i < n; i++) {

677 v = exponents[i << bsize >> esize];

678 e2 += v * v;

679 }

680 exp_power[j] = e2 / n;

681 last_high_band = j;

682 ff_tlog(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);

683 }

684 exponents += n << bsize >> esize;

685 }

686

687 /* main freqs and high freqs */

688 exponents = s->exponents[ch] + (s->coefs_start << bsize >> esize);

689 for (j = -1; j < n1; j++) {

690 if (j < 0)

691 n = s->high_band_start[bsize] - s->coefs_start;

692 else

693 n = s->exponent_high_bands[s->frame_len_bits -

694 s->block_len_bits][j];

695 if (j >= 0 && s->high_band_coded[ch][j]) {

696 /* use noise with specified power */

697 mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);

698 /* XXX: use a table */

699 mult1 = mult1 * ff_exp10(s->high_band_values[ch][j] * 0.05);

700 mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);

701 mult1 *= mdct_norm;

702 for (i = 0; i < n; i++) {

703 noise = s->noise_table[s->noise_index];

704 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);

705 *coefs++ = noise * exponents[i << bsize >> esize] * mult1;

706 }

707 exponents += n << bsize >> esize;

708 } else {

709 /* coded values + small noise */

710 for (i = 0; i < n; i++) {

711 noise = s->noise_table[s->noise_index];

712 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);

713 *coefs++ = ((*coefs1++) + noise) *

714 exponents[i << bsize >> esize] * mult;

715 }

716 exponents += n << bsize >> esize;

717 }

718 }

719

720 /* very high freqs : noise */

721 n = s->block_len - s->coefs_end[bsize];

722 mult1 = mult * exponents[(-(1 << bsize)) >> esize];

723 for (i = 0; i < n; i++) {

724 *coefs++ = s->noise_table[s->noise_index] * mult1;

725 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);

726 }

727 } else {

728 /* XXX: optimize more */

729 for (i = 0; i < s->coefs_start; i++)

730 *coefs++ = 0.0;

731 n = nb_coefs[ch];

732 for (i = 0; i < n; i++)

733 *coefs++ = coefs1[i] * exponents[i << bsize >> esize] * mult;

734 n = s->block_len - s->coefs_end[bsize];

735 for (i = 0; i < n; i++)

736 *coefs++ = 0.0;

737 }

738 }

739 }

740

741 #ifdef TRACE

742 for (ch = 0; ch < channels; ch++) {

743 if (s->channel_coded[ch]) {

744 dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len);

745 dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);

746 }

747 }

748 #endif /* TRACE */

749

750 if (s->ms_stereo && s->channel_coded[1]) {

751 /* nominal case for ms stereo: we do it before mdct */

752 /* no need to optimize this case because it should almost

753 * never happen */

754 if (!s->channel_coded[0]) {

755 ff_tlog(s->avctx, "rare ms-stereo case happened\n");

756 memset(s->coefs[0], 0, sizeof(float) * s->block_len);

757 s->channel_coded[0] = 1;

758 }

759

760 s->fdsp->butterflies_float(s->coefs[0], s->coefs[1], s->block_len);

761 }

762

763 next:

764 mdct = s->mdct_ctx[bsize];

765 mdct_fn = s->mdct_fn[bsize];

766

767 for (ch = 0; ch < channels; ch++) {

768 int n4, index;

769

770 n4 = s->block_len / 2;

771 if (s->channel_coded[ch])

772 mdct_fn(mdct, s->output, s->coefs[ch], sizeof(float));

773 else if (!(s->ms_stereo && ch == 1))

774 memset(s->output, 0, sizeof(s->output));

775

776 /* multiply by the window and add in the frame */

777 index = (s->frame_len / 2) + s->block_pos - n4;

778 wma_window(s, &s->frame_out[ch][index]);

779 }

780

781 /* update block number */

782 s->block_num++;

783 s->block_pos += s->block_len;

784 if (s->block_pos >= s->frame_len)

785 return 1;

786 else

787 return 0;

788 }

789

790 /* decode a frame of frame_len samples */

791 static int wma_decode_frame(WMACodecContext *s, float **samples,

792 int samples_offset)

793 {

794 int ret, ch;

795

796 #ifdef TRACE

797 ff_tlog(s->avctx, "***decode_frame: %d size=%d\n",

798 s->frame_count++, s->frame_len);

799 #endif /* TRACE */

800

801 /* read each block */

802 s->block_num = 0;

803 s->block_pos = 0;

804 for (;;) {

805 ret = wma_decode_block(s);

806 if (ret < 0)

807 return ret;

808 if (ret)

809 break;

810 }

811

812 for (ch = 0; ch < s->avctx->ch_layout.nb_channels; ch++) {

813 /* copy current block to output */

814 memcpy(samples[ch] + samples_offset, s->frame_out[ch],

815 s->frame_len * sizeof(*s->frame_out[ch]));

816 /* prepare for next block */

817 memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],

818 s->frame_len * sizeof(*s->frame_out[ch]));

819

820 #ifdef TRACE

821 dump_floats(s, "samples", 6, samples[ch] + samples_offset,

822 s->frame_len);

823 #endif /* TRACE */

824 }

825

826 return 0;

827 }

828

829 static int wma_decode_superframe(AVCodecContext *avctx, AVFrame *frame,

830 int *got_frame_ptr, AVPacket *avpkt)

831 {

832 const uint8_t *buf = avpkt->data;

833 int buf_size = avpkt->size;

834 WMACodecContext *s = avctx->priv_data;

835 int nb_frames, bit_offset, i, pos, len, ret;

836 uint8_t *q;

837 float **samples;

838 int samples_offset;

839

840 ff_tlog(avctx, "***decode_superframe:\n");

841

842 if (buf_size == 0) {

843 if (s->eof_done)

844 return 0;

845

846 frame->nb_samples = s->frame_len;

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

848 return ret;

849

850 frame->pts = AV_NOPTS_VALUE;

851 for (i = 0; i < s->avctx->ch_layout.nb_channels; i++)

852 memcpy(frame->extended_data[i], &s->frame_out[i][0],

853 frame->nb_samples * sizeof(s->frame_out[i][0]));

854

855 s->last_superframe_len = 0;

856 s->eof_done = 1;

857 *got_frame_ptr = 1;

858 return 0;

859 }

860 if (buf_size < avctx->block_align) {

861 av_log(avctx, AV_LOG_ERROR,

862 "Input packet size too small (%d < %d)\n",

863 buf_size, avctx->block_align);

864 return AVERROR_INVALIDDATA;

865 }

866 if (avctx->block_align)

867 buf_size = avctx->block_align;

868

869 init_get_bits(&s->gb, buf, buf_size * 8);

870

871 if (s->use_bit_reservoir) {

872 /* read super frame header */

873 skip_bits(&s->gb, 4); /* super frame index */

874 nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);

875 if (nb_frames <= 0) {

876 int is_error = nb_frames < 0 || get_bits_left(&s->gb) <= 8;

877 av_log(avctx, is_error ? AV_LOG_ERROR : AV_LOG_WARNING,

878 "nb_frames is %d bits left %d\n",

879 nb_frames, get_bits_left(&s->gb));

880 if (is_error)

881 return AVERROR_INVALIDDATA;

882

883 if ((s->last_superframe_len + buf_size - 1) >

884 MAX_CODED_SUPERFRAME_SIZE) {

885 ret = AVERROR_INVALIDDATA;

886 goto fail;

887 }

888

889 q = s->last_superframe + s->last_superframe_len;

890 len = buf_size - 1;

891 while (len > 0) {

892 *q++ = get_bits (&s->gb, 8);

893 len --;

894 }

895 memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);

896

897 s->last_superframe_len += 8*buf_size - 8;

898 // s->reset_block_lengths = 1; //XXX is this needed ?

899 *got_frame_ptr = 0;

900 return buf_size;

901 }

902 } else

903 nb_frames = 1;

904

905 /* get output buffer */

906 frame->nb_samples = nb_frames * s->frame_len;

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

908 return ret;

909 samples = (float **) frame->extended_data;

910 samples_offset = 0;

911

912 if (s->use_bit_reservoir) {

913 bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);

914 if (bit_offset > get_bits_left(&s->gb)) {

915 av_log(avctx, AV_LOG_ERROR,

916 "Invalid last frame bit offset %d > buf size %d (%d)\n",

917 bit_offset, get_bits_left(&s->gb), buf_size);

918 ret = AVERROR_INVALIDDATA;

919 goto fail;

920 }

921

922 if (s->last_superframe_len > 0) {

923 /* add bit_offset bits to last frame */

924 if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >

925 MAX_CODED_SUPERFRAME_SIZE) {

926 ret = AVERROR_INVALIDDATA;

927 goto fail;

928 }

929 q = s->last_superframe + s->last_superframe_len;

930 len = bit_offset;

931 while (len > 7) {

932 *q++ = get_bits(&s->gb, 8);

933 len -= 8;

934 }

935 if (len > 0)

936 *q++ = get_bits(&s->gb, len) << (8 - len);

937 memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);

938

939 /* XXX: bit_offset bits into last frame */

940 init_get_bits(&s->gb, s->last_superframe,

941 s->last_superframe_len * 8 + bit_offset);

942 /* skip unused bits */

943 if (s->last_bitoffset > 0)

944 skip_bits(&s->gb, s->last_bitoffset);

945 /* this frame is stored in the last superframe and in the

946 * current one */

947 if ((ret = wma_decode_frame(s, samples, samples_offset)) < 0)

948 goto fail;

949 samples_offset += s->frame_len;

950 nb_frames--;

951 }

952

953 /* read each frame starting from bit_offset */

954 pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;

955 if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8)

956 return AVERROR_INVALIDDATA;

957 init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3)) * 8);

958 len = pos & 7;

959 if (len > 0)

960 skip_bits(&s->gb, len);

961

962 s->reset_block_lengths = 1;

963 for (i = 0; i < nb_frames; i++) {

964 if ((ret = wma_decode_frame(s, samples, samples_offset)) < 0)

965 goto fail;

966 samples_offset += s->frame_len;

967 }

968

969 /* we copy the end of the frame in the last frame buffer */

970 pos = get_bits_count(&s->gb) +

971 ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);

972 s->last_bitoffset = pos & 7;

973 pos >>= 3;

974 len = buf_size - pos;

975 if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {

976 av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len);

977 ret = AVERROR_INVALIDDATA;

978 goto fail;

979 }

980 s->last_superframe_len = len;

981 memcpy(s->last_superframe, buf + pos, len);

982 } else {

983 /* single frame decode */

984 if ((ret = wma_decode_frame(s, samples, samples_offset)) < 0)

985 goto fail;

986 samples_offset += s->frame_len;

987 }

988

989 ff_dlog(s->avctx, "%d %d %d %d eaten:%d\n",

990 s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,

991 avctx->block_align);

992

993 *got_frame_ptr = 1;

994

995 return buf_size;

996

997 fail:

998 /* when error, we reset the bit reservoir */

999 s->last_superframe_len = 0;

1000 return ret;

1001 }

1002

1003 static av_cold void flush(AVCodecContext *avctx)

1004 {

1005 WMACodecContext *s = avctx->priv_data;

1006

1007 s->last_bitoffset =

1008 s->last_superframe_len = 0;

1009

1010 s->eof_done = 0;

1011 avctx->internal->skip_samples = s->frame_len * 2;

1012 }

1013

1014 #if CONFIG_WMAV1_DECODER

1015 const FFCodec ff_wmav1_decoder = {

1016 .p.name = "wmav1",

1017 CODEC_LONG_NAME("Windows Media Audio 1"),

1018 .p.type = AVMEDIA_TYPE_AUDIO,

1019 .p.id = AV_CODEC_ID_WMAV1,

1020 .priv_data_size = sizeof(WMACodecContext),

1021 .init = wma_decode_init,

1022 .close = ff_wma_end,

1023 FF_CODEC_DECODE_CB(wma_decode_superframe),

1024 .flush = flush,

1025 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,

1026 CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),

1027 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

1028 };

1029 #endif

1030 #if CONFIG_WMAV2_DECODER

1031 const FFCodec ff_wmav2_decoder = {

1032 .p.name = "wmav2",

1033 CODEC_LONG_NAME("Windows Media Audio 2"),

1034 .p.type = AVMEDIA_TYPE_AUDIO,

1035 .p.id = AV_CODEC_ID_WMAV2,

1036 .priv_data_size = sizeof(WMACodecContext),

1037 .init = wma_decode_init,

1038 .close = ff_wma_end,

1039 FF_CODEC_DECODE_CB(wma_decode_superframe),

1040 .flush = flush,

1041 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,

1042 CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),

1043 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

1044 };

1045 #endif

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

nb_coefs

static int nb_coefs(int length, int level, uint64_t sn)

Definition: af_afwtdn.c:515

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

name

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 default minimum maximum flags name is the option name

Definition: writing_filters.txt:88

ff_vlc_init_from_lengths

int ff_vlc_init_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:306

ff_exp10

static av_always_inline double ff_exp10(double x)

Compute 10^x for floating point values.

Definition: ffmath.h:42

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

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

Definition: codec_internal.h:42

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:689

AVERROR

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

out

FILE * out

Definition: movenc.c:55

flush

static av_cold void flush(AVCodecContext *avctx)

Definition: wmadec.c:1003

AVTXContext

Definition: tx_priv.h:235

AVCodecInternal::skip_samples

int skip_samples

Number of audio samples to skip at the start of the next decoded frame.

Definition: internal.h:125

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:250

AVFrame

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

Definition: frame.h:427

uint8_t w

Definition: llviddspenc.c:38

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

Definition: cbs_apv.c:68

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:558

wma_lsp_to_curve_init

static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)

Definition: wmadec.c:173

#define b

Definition: input.c:42

FFCodec

Definition: codec_internal.h:127

ff_wma_run_level_decode

int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, const VLCElem *vlc, const float *level_table, const uint16_t *run_table, int version, WMACoef *ptr, int offset, int num_coefs, int block_len, int frame_len_bits, int coef_nb_bits)

Decode run level compressed coefficients.

Definition: wma.c:427

AV_CODEC_ID_WMAV2

@ AV_CODEC_ID_WMAV2

Definition: codec_id.h:467

ff_wmav2_decoder

const FFCodec ff_wmav2_decoder

wma_decode_frame

static int wma_decode_frame(WMACodecContext *s, float **samples, int samples_offset)

Definition: wmadec.c:791

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:512

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

ff_wma_hgain_hufftab

const uint8_t ff_wma_hgain_hufftab[37][2]

Definition: wmadata.h:54

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:379

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:135

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:333

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

HIGH_BAND_MAX_SIZE

#define HIGH_BAND_MAX_SIZE

Definition: wma.h:41

decode_exp_lsp

static void decode_exp_lsp(WMACodecContext *s, int ch)

decode exponents coded with LSP coefficients (same idea as Vorbis)

Definition: wmadec.c:234

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:440

WMACoef

float WMACoef

type for decoded coefficients, int16_t would be enough for wma 1/2

Definition: wma.h:58

fail

#define fail()

Definition: checkasm.h:206

tab

static const struct twinvq_data tab

Definition: twinvq_data.h:10345

noise

static int noise(AVBSFContext *ctx, AVPacket *pkt)

Definition: noise.c:124

val

static double val(void *priv, double ch)

Definition: aeval.c:77

WMACodecContext

Definition: wma.h:68

mult

static int16_t mult(Float11 *f1, Float11 *f2)

Definition: g726.c:60

AV_CODEC_ID_WMAV1

@ AV_CODEC_ID_WMAV1

Definition: codec_id.h:466

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

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

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

EXPVLCBITS

#define EXPVLCBITS

Definition: wmadec.c:47

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

#define s(width, name)

Definition: cbs_vp9.c:198

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

vlc_init

#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)

Definition: vlc.h:70

exp2f

#define exp2f(x)

Definition: libm.h:295

channels

Definition: aptx.h:31

decode.h

AV_RL16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16

Definition: bytestream.h:94

wma.h

ff_wma_total_gain_to_bits

int ff_wma_total_gain_to_bits(int total_gain)

Definition: wma.c:353

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

if(ret)

Definition: filter_design.txt:179

AV_TX_FULL_IMDCT

@ AV_TX_FULL_IMDCT

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

Definition: tx.h:175

HGAINMAX

#define HGAINMAX

Definition: wmadec.c:51

AVCodecContext::internal

struct AVCodecInternal * internal

Private context used for internal data.

Definition: avcodec.h:466

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:386

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

index

int index

Definition: gxfenc.c:90

ff_wma_end

av_cold int ff_wma_end(AVCodecContext *avctx)

Definition: wma.c:367

MAX_CODED_SUPERFRAME_SIZE

#define MAX_CODED_SUPERFRAME_SIZE

Definition: wma.h:46

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

ff_aac_scalefactor_bits

const uint8_t ff_aac_scalefactor_bits[121]

Definition: aactab.c:200

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

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

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

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:559

ff_wmav1_decoder

const FFCodec ff_wmav1_decoder

codec_internal.h

wma_lsp_to_curve

static void wma_lsp_to_curve(WMACodecContext *s, float *out, float *val_max_ptr, int n, float *lsp)

NOTE: We use the same code as Vorbis here.

Definition: wmadec.c:205

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1031

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:247

ff_wma_init

av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)

Definition: wma.c:79

NOISE_TAB_SIZE

#define NOISE_TAB_SIZE

Definition: wma.h:50

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

attributes.h

CODEC_SAMPLEFMTS

#define CODEC_SAMPLEFMTS(...)

Definition: codec_internal.h:385

MAX_CHANNELS

#define MAX_CHANNELS

Definition: aac.h:33

wma_decode_block

static int wma_decode_block(WMACodecContext *s)

Definition: wmadec.c:447

M_PI

#define M_PI

Definition: mathematics.h:67

pow_tab

static const float pow_tab[]

pow(10, i / 16.0) for i in -60..95

Definition: wmadec.c:252

AVCodec::id

enum AVCodecID id

Definition: codec.h:186

LSP_POW_BITS

#define LSP_POW_BITS

Definition: wma.h:52

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

Definition: cbs_h2645.c:256

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

AVCodecContext::extradata

uint8_t * extradata

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

Definition: avcodec.h:514

wma_window

static void wma_window(WMACodecContext *s, float *out)

Apply MDCT window and add into output.

Definition: wmadec.c:395

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

len

int len

Definition: vorbis_enc_data.h:426

avcodec.h

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

wma_decode_superframe

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

Definition: wmadec.c:829

HGAINVLCBITS

#define HGAINVLCBITS

Definition: wmadec.c:50

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:555

pos

unsigned int pos