44 #define EXPMAX ((19 + EXPVLCBITS - 1) / EXPVLCBITS)
46 #define HGAINVLCBITS 9
47 #define HGAINMAX ((13 + HGAINVLCBITS - 1) / HGAINVLCBITS)
53 int prec,
const float *
tab,
int n)
58 for (
i = 0;
i < n;
i++) {
87 flags2 =
AV_RL16(extradata + 2);
89 flags2 =
AV_RL16(extradata + 4);
91 s->use_exp_vlc = flags2 & 0x0001;
92 s->use_bit_reservoir = flags2 & 0x0002;
93 s->use_variable_block_len = flags2 & 0x0004;
96 if (
AV_RL16(extradata+4)==0xd &&
s->use_variable_block_len){
97 av_log(avctx,
AV_LOG_WARNING,
"Disabling use_variable_block_len, if this fails contact the ffmpeg developers and send us the file\n");
98 s->use_variable_block_len= 0;
103 s->max_exponent[
i] = 1.0;
109 for (
i = 0;
i <
s->nb_block_sizes;
i++)
112 if (
s->use_noise_coding) {
149 t.v = ((
u.v <<
LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
150 a =
s->lsp_pow_m_table1[m];
151 b =
s->lsp_pow_m_table2[m];
152 return s->lsp_pow_e_table[e] * (
a +
b * t.f);
160 wdel =
M_PI / frame_len;
161 for (
i = 0;
i < frame_len;
i++)
162 s->lsp_cos_table[
i] = 2.0f * cos(wdel *
i);
165 for (
i = 0;
i < 256;
i++) {
167 s->lsp_pow_e_table[
i] =
exp2f(e * -0.25);
177 s->lsp_pow_m_table1[
i] = 2 *
a -
b;
178 s->lsp_pow_m_table2[
i] =
b -
a;
191 float p, q,
w, v, val_max;
194 for (
i = 0;
i < n;
i++) {
197 w =
s->lsp_cos_table[
i];
210 *val_max_ptr = val_max;
222 if (
i == 0 ||
i >= 8)
230 s->block_len, lsp_coefs);
235 1.7782794100389e-04, 2.0535250264571e-04,
236 2.3713737056617e-04, 2.7384196342644e-04,
237 3.1622776601684e-04, 3.6517412725484e-04,
238 4.2169650342858e-04, 4.8696752516586e-04,
239 5.6234132519035e-04, 6.4938163157621e-04,
240 7.4989420933246e-04, 8.6596432336006e-04,
241 1.0000000000000e-03, 1.1547819846895e-03,
242 1.3335214321633e-03, 1.5399265260595e-03,
243 1.7782794100389e-03, 2.0535250264571e-03,
244 2.3713737056617e-03, 2.7384196342644e-03,
245 3.1622776601684e-03, 3.6517412725484e-03,
246 4.2169650342858e-03, 4.8696752516586e-03,
247 5.6234132519035e-03, 6.4938163157621e-03,
248 7.4989420933246e-03, 8.6596432336006e-03,
249 1.0000000000000e-02, 1.1547819846895e-02,
250 1.3335214321633e-02, 1.5399265260595e-02,
251 1.7782794100389e-02, 2.0535250264571e-02,
252 2.3713737056617e-02, 2.7384196342644e-02,
253 3.1622776601684e-02, 3.6517412725484e-02,
254 4.2169650342858e-02, 4.8696752516586e-02,
255 5.6234132519035e-02, 6.4938163157621e-02,
256 7.4989420933246e-02, 8.6596432336007e-02,
257 1.0000000000000e-01, 1.1547819846895e-01,
258 1.3335214321633e-01, 1.5399265260595e-01,
259 1.7782794100389e-01, 2.0535250264571e-01,
260 2.3713737056617e-01, 2.7384196342644e-01,
261 3.1622776601684e-01, 3.6517412725484e-01,
262 4.2169650342858e-01, 4.8696752516586e-01,
263 5.6234132519035e-01, 6.4938163157621e-01,
264 7.4989420933246e-01, 8.6596432336007e-01,
265 1.0000000000000e+00, 1.1547819846895e+00,
266 1.3335214321633e+00, 1.5399265260595e+00,
267 1.7782794100389e+00, 2.0535250264571e+00,
268 2.3713737056617e+00, 2.7384196342644e+00,
269 3.1622776601684e+00, 3.6517412725484e+00,
270 4.2169650342858e+00, 4.8696752516586e+00,
271 5.6234132519035e+00, 6.4938163157621e+00,
272 7.4989420933246e+00, 8.6596432336007e+00,
273 1.0000000000000e+01, 1.1547819846895e+01,
274 1.3335214321633e+01, 1.5399265260595e+01,
275 1.7782794100389e+01, 2.0535250264571e+01,
276 2.3713737056617e+01, 2.7384196342644e+01,
277 3.1622776601684e+01, 3.6517412725484e+01,
278 4.2169650342858e+01, 4.8696752516586e+01,
279 5.6234132519035e+01, 6.4938163157621e+01,
280 7.4989420933246e+01, 8.6596432336007e+01,
281 1.0000000000000e+02, 1.1547819846895e+02,
282 1.3335214321633e+02, 1.5399265260595e+02,
283 1.7782794100389e+02, 2.0535250264571e+02,
284 2.3713737056617e+02, 2.7384196342644e+02,
285 3.1622776601684e+02, 3.6517412725484e+02,
286 4.2169650342858e+02, 4.8696752516586e+02,
287 5.6234132519035e+02, 6.4938163157621e+02,
288 7.4989420933246e+02, 8.6596432336007e+02,
289 1.0000000000000e+03, 1.1547819846895e+03,
290 1.3335214321633e+03, 1.5399265260595e+03,
291 1.7782794100389e+03, 2.0535250264571e+03,
292 2.3713737056617e+03, 2.7384196342644e+03,
293 3.1622776601684e+03, 3.6517412725484e+03,
294 4.2169650342858e+03, 4.8696752516586e+03,
295 5.6234132519035e+03, 6.4938163157621e+03,
296 7.4989420933246e+03, 8.6596432336007e+03,
297 1.0000000000000e+04, 1.1547819846895e+04,
298 1.3335214321633e+04, 1.5399265260595e+04,
299 1.7782794100389e+04, 2.0535250264571e+04,
300 2.3713737056617e+04, 2.7384196342644e+04,
301 3.1622776601684e+04, 3.6517412725484e+04,
302 4.2169650342858e+04, 4.8696752516586e+04,
303 5.6234132519035e+04, 6.4938163157621e+04,
304 7.4989420933246e+04, 8.6596432336007e+04,
305 1.0000000000000e+05, 1.1547819846895e+05,
306 1.3335214321633e+05, 1.5399265260595e+05,
307 1.7782794100389e+05, 2.0535250264571e+05,
308 2.3713737056617e+05, 2.7384196342644e+05,
309 3.1622776601684e+05, 3.6517412725484e+05,
310 4.2169650342858e+05, 4.8696752516586e+05,
311 5.6234132519035e+05, 6.4938163157621e+05,
312 7.4989420933246e+05, 8.6596432336007e+05,
320 int last_exp, n,
code;
323 uint32_t *q, *q_end, iv;
324 const float *ptab =
pow_tab + 60;
325 const uint32_t *iptab = (
const uint32_t *) ptab;
327 ptr =
s->exponent_bands[
s->frame_len_bits -
s->block_len_bits];
328 q = (uint32_t *)
s->exponents[ch];
329 q_end = q +
s->block_len;
331 if (
s->version == 1) {
334 iv = iptab[last_exp];
342 }
while ((n -= 4) > 0);
349 last_exp +=
code - 60;
356 iv = iptab[last_exp];
365 }
while ((n -= 4) > 0);
367 s->max_exponent[ch] = max_scale;
379 float *
in =
s->output;
380 int block_len, bsize, n;
383 if (
s->block_len_bits <=
s->prev_block_len_bits) {
384 block_len =
s->block_len;
385 bsize =
s->frame_len_bits -
s->block_len_bits;
387 s->fdsp->vector_fmul_add(
out,
in,
s->windows[bsize],
390 block_len = 1 <<
s->prev_block_len_bits;
391 n = (
s->block_len - block_len) / 2;
392 bsize =
s->frame_len_bits -
s->prev_block_len_bits;
394 s->fdsp->vector_fmul_add(
out + n,
in + n,
s->windows[bsize],
397 memcpy(
out + n + block_len,
in + n + block_len, n *
sizeof(
float));
404 if (
s->block_len_bits <=
s->next_block_len_bits) {
405 block_len =
s->block_len;
406 bsize =
s->frame_len_bits -
s->block_len_bits;
408 s->fdsp->vector_fmul_reverse(
out,
in,
s->windows[bsize], block_len);
410 block_len = 1 <<
s->next_block_len_bits;
411 n = (
s->block_len - block_len) / 2;
412 bsize =
s->frame_len_bits -
s->next_block_len_bits;
414 memcpy(
out,
in, n *
sizeof(
float));
416 s->fdsp->vector_fmul_reverse(
out + n,
in + n,
s->windows[bsize],
419 memset(
out + n + block_len, 0, n *
sizeof(
float));
429 int n, v,
a, ch, bsize;
430 int coef_nb_bits, total_gain;
436 ff_tlog(
s->avctx,
"***decode_block: %d:%d\n",
437 s->frame_count - 1,
s->block_num);
441 if (
s->use_variable_block_len) {
442 n =
av_log2(
s->nb_block_sizes - 1) + 1;
444 if (
s->reset_block_lengths) {
445 s->reset_block_lengths = 0;
447 if (v >=
s->nb_block_sizes) {
449 "prev_block_len_bits %d out of range\n",
450 s->frame_len_bits - v);
453 s->prev_block_len_bits =
s->frame_len_bits - v;
455 if (v >=
s->nb_block_sizes) {
457 "block_len_bits %d out of range\n",
458 s->frame_len_bits - v);
461 s->block_len_bits =
s->frame_len_bits - v;
464 s->prev_block_len_bits =
s->block_len_bits;
465 s->block_len_bits =
s->next_block_len_bits;
468 if (v >=
s->nb_block_sizes) {
470 "next_block_len_bits %d out of range\n",
471 s->frame_len_bits - v);
474 s->next_block_len_bits =
s->frame_len_bits - v;
477 s->next_block_len_bits =
s->frame_len_bits;
478 s->prev_block_len_bits =
s->frame_len_bits;
479 s->block_len_bits =
s->frame_len_bits;
482 if (
s->frame_len_bits -
s->block_len_bits >=
s->nb_block_sizes){
488 s->block_len = 1 <<
s->block_len_bits;
489 if ((
s->block_pos +
s->block_len) >
s->frame_len) {
494 if (
s->avctx->channels == 2)
497 for (ch = 0; ch <
s->avctx->channels; ch++) {
499 s->channel_coded[ch] =
a;
503 bsize =
s->frame_len_bits -
s->block_len_bits;
527 n =
s->coefs_end[bsize] -
s->coefs_start;
528 for (ch = 0; ch <
s->avctx->channels; ch++)
532 if (
s->use_noise_coding) {
533 for (ch = 0; ch <
s->avctx->channels; ch++) {
534 if (
s->channel_coded[ch]) {
536 n =
s->exponent_high_sizes[bsize];
537 for (
i = 0;
i < n;
i++) {
539 s->high_band_coded[ch][
i] =
a;
542 nb_coefs[ch] -=
s->exponent_high_bands[bsize][
i];
546 for (ch = 0; ch <
s->avctx->channels; ch++) {
547 if (
s->channel_coded[ch]) {
550 n =
s->exponent_high_sizes[bsize];
552 for (
i = 0;
i < n;
i++) {
553 if (
s->high_band_coded[ch][
i]) {
554 if (
val == (
int) 0x80000000) {
560 s->high_band_values[ch][
i] =
val;
568 if ((
s->block_len_bits ==
s->frame_len_bits) ||
get_bits1(&
s->gb)) {
569 for (ch = 0; ch <
s->avctx->channels; ch++) {
570 if (
s->channel_coded[ch]) {
571 if (
s->use_exp_vlc) {
577 s->exponents_bsize[ch] = bsize;
578 s->exponents_initialized[ch] = 1;
583 for (ch = 0; ch <
s->avctx->channels; ch++) {
584 if (
s->channel_coded[ch] && !
s->exponents_initialized[ch])
589 for (ch = 0; ch <
s->avctx->channels; ch++) {
590 if (
s->channel_coded[ch]) {
596 tindex = (ch == 1 &&
s->ms_stereo);
597 memset(ptr, 0,
s->block_len *
sizeof(
WMACoef));
599 s->level_table[tindex],
s->run_table[tindex],
600 0, ptr, 0, nb_coefs[ch],
601 s->block_len,
s->frame_len_bits, coef_nb_bits);
603 if (
s->version == 1 &&
s->avctx->channels >= 2)
609 int n4 =
s->block_len / 2;
610 mdct_norm = 1.0 / (float) n4;
612 mdct_norm *= sqrt(n4);
616 for (ch = 0; ch <
s->avctx->channels; ch++) {
617 if (
s->channel_coded[ch]) {
619 float *coefs, *exponents,
mult, mult1,
noise;
620 int i, j, n, n1, last_high_band, esize;
623 coefs1 =
s->coefs1[ch];
624 exponents =
s->exponents[ch];
625 esize =
s->exponents_bsize[ch];
628 coefs =
s->coefs[ch];
629 if (
s->use_noise_coding) {
632 for (
i = 0;
i <
s->coefs_start;
i++) {
633 *coefs++ =
s->noise_table[
s->noise_index] *
634 exponents[i << bsize >> esize] * mult1;
635 s->noise_index = (
s->noise_index + 1) &
639 n1 =
s->exponent_high_sizes[bsize];
642 exponents =
s->exponents[ch] +
643 (
s->high_band_start[bsize] << bsize >> esize);
645 for (j = 0; j < n1; j++) {
646 n =
s->exponent_high_bands[
s->frame_len_bits -
647 s->block_len_bits][j];
648 if (
s->high_band_coded[ch][j]) {
651 for (
i = 0;
i < n;
i++) {
652 v = exponents[i << bsize >> esize];
655 exp_power[j] = e2 / n;
657 ff_tlog(
s->avctx,
"%d: power=%f (%d)\n", j, exp_power[j], n);
659 exponents += n << bsize >> esize;
663 exponents =
s->exponents[ch] + (
s->coefs_start << bsize >> esize);
664 for (j = -1; j < n1; j++) {
666 n =
s->high_band_start[bsize] -
s->coefs_start;
668 n =
s->exponent_high_bands[
s->frame_len_bits -
669 s->block_len_bits][j];
670 if (j >= 0 &&
s->high_band_coded[ch][j]) {
672 mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
674 mult1 = mult1 *
ff_exp10(
s->high_band_values[ch][j] * 0.05);
675 mult1 = mult1 / (
s->max_exponent[ch] *
s->noise_mult);
677 for (
i = 0;
i < n;
i++) {
678 noise =
s->noise_table[
s->noise_index];
680 *coefs++ =
noise * exponents[i << bsize >> esize] * mult1;
682 exponents += n << bsize >> esize;
685 for (
i = 0;
i < n;
i++) {
686 noise =
s->noise_table[
s->noise_index];
688 *coefs++ = ((*coefs1++) +
noise) *
689 exponents[i << bsize >> esize] *
mult;
691 exponents += n << bsize >> esize;
696 n =
s->block_len -
s->coefs_end[bsize];
697 mult1 =
mult * exponents[(-(1 << bsize)) >> esize];
698 for (
i = 0;
i < n;
i++) {
699 *coefs++ =
s->noise_table[
s->noise_index] * mult1;
704 for (
i = 0;
i <
s->coefs_start;
i++)
707 for (
i = 0;
i < n;
i++)
708 *coefs++ = coefs1[
i] * exponents[
i << bsize >> esize] *
mult;
709 n =
s->block_len -
s->coefs_end[bsize];
710 for (
i = 0;
i < n;
i++)
717 for (ch = 0; ch <
s->avctx->channels; ch++) {
718 if (
s->channel_coded[ch]) {
719 dump_floats(
s,
"exponents", 3,
s->exponents[ch],
s->block_len);
720 dump_floats(
s,
"coefs", 1,
s->coefs[ch],
s->block_len);
725 if (
s->ms_stereo &&
s->channel_coded[1]) {
729 if (!
s->channel_coded[0]) {
730 ff_tlog(
s->avctx,
"rare ms-stereo case happened\n");
731 memset(
s->coefs[0], 0,
sizeof(
float) *
s->block_len);
732 s->channel_coded[0] = 1;
735 s->fdsp->butterflies_float(
s->coefs[0],
s->coefs[1],
s->block_len);
739 mdct = &
s->mdct_ctx[bsize];
741 for (ch = 0; ch <
s->avctx->channels; ch++) {
744 n4 =
s->block_len / 2;
745 if (
s->channel_coded[ch])
747 else if (!(
s->ms_stereo && ch == 1))
748 memset(
s->output, 0,
sizeof(
s->output));
751 index = (
s->frame_len / 2) +
s->block_pos - n4;
757 s->block_pos +=
s->block_len;
758 if (
s->block_pos >=
s->frame_len)
771 ff_tlog(
s->avctx,
"***decode_frame: %d size=%d\n",
772 s->frame_count++,
s->frame_len);
786 for (ch = 0; ch <
s->avctx->channels; ch++) {
788 memcpy(samples[ch] + samples_offset,
s->frame_out[ch],
789 s->frame_len *
sizeof(*
s->frame_out[ch]));
791 memmove(&
s->frame_out[ch][0], &
s->frame_out[ch][
s->frame_len],
792 s->frame_len *
sizeof(*
s->frame_out[ch]));
795 dump_floats(
s,
"samples", 6, samples[ch] + samples_offset,
804 int *got_frame_ptr,
AVPacket *avpkt)
808 int buf_size = avpkt->
size;
810 int nb_frames, bit_offset,
i,
pos,
len, ret;
815 ff_tlog(avctx,
"***decode_superframe:\n");
818 s->last_superframe_len = 0;
821 if (buf_size < avctx->block_align) {
823 "Input packet size too small (%d < %d)\n",
832 if (
s->use_bit_reservoir) {
835 nb_frames =
get_bits(&
s->gb, 4) - (
s->last_superframe_len <= 0);
836 if (nb_frames <= 0) {
839 "nb_frames is %d bits left %d\n",
844 if ((
s->last_superframe_len + buf_size - 1) >
848 q =
s->last_superframe +
s->last_superframe_len;
856 s->last_superframe_len += 8*buf_size - 8;
871 if (
s->use_bit_reservoir) {
872 bit_offset =
get_bits(&
s->gb,
s->byte_offset_bits + 3);
875 "Invalid last frame bit offset %d > buf size %d (%d)\n",
880 if (
s->last_superframe_len > 0) {
882 if ((
s->last_superframe_len + ((bit_offset + 7) >> 3)) >
885 q =
s->last_superframe +
s->last_superframe_len;
897 s->last_superframe_len * 8 + bit_offset);
899 if (
s->last_bitoffset > 0)
905 samples_offset +=
s->frame_len;
910 pos = bit_offset + 4 + 4 +
s->byte_offset_bits + 3;
918 s->reset_block_lengths = 1;
919 for (
i = 0;
i < nb_frames;
i++) {
922 samples_offset +=
s->frame_len;
927 ((bit_offset + 4 + 4 +
s->byte_offset_bits + 3) & ~7);
928 s->last_bitoffset =
pos & 7;
935 s->last_superframe_len =
len;
936 memcpy(
s->last_superframe, buf +
pos,
len);
941 samples_offset +=
s->frame_len;
945 s->frame_len_bits,
s->block_len_bits,
s->frame_len,
s->block_len,
954 s->last_superframe_len = 0;
963 s->last_superframe_len = 0;
966 #if CONFIG_WMAV1_DECODER
982 #if CONFIG_WMAV2_DECODER
const uint32_t ff_aac_scalefactor_code[121]
const uint8_t ff_aac_scalefactor_bits[121]
static enum AVSampleFormat sample_fmts[]
static double val(void *priv, double ch)
Macro definitions for various function/variable attributes.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
int ff_init_vlc_from_lengths(VLC *vlc_arg, 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()
#define u(width, name, range_min, range_max)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
internal math functions header
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static int get_bits_left(GetBitContext *gb)
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
static int get_bits_count(const GetBitContext *s)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static const uint8_t * align_get_bits(GetBitContext *s)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVSampleFormat
Audio sample formats.
@ AV_SAMPLE_FMT_FLTP
float, planar
static int16_t mult(Float11 *f1, Float11 *f2)
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define PTRDIFF_SPECIFIER
static int noise(AVBSFContext *ctx, AVPacket *pkt)
#define FF_ARRAY_ELEMS(a)
main external API structure.
enum AVSampleFormat sample_fmt
audio sample format
const struct AVCodec * codec
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
uint8_t ** extended_data
pointers to the data planes/channels.
This structure stores compressed data.
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
static const struct twinvq_data tab
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
int ff_wma_total_gain_to_bits(int total_gain)
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, VLC *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.
int ff_wma_end(AVCodecContext *avctx)
#define MAX_CODED_SUPERFRAME_SIZE
const uint8_t ff_wma_hgain_hufftab[37][2]
const float ff_wma_lsp_codebook[NB_LSP_COEFS][16]
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
#define HIGH_BAND_MAX_SIZE
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
static int wma_decode_frame(WMACodecContext *s, float **samples, int samples_offset)
static void wma_window(WMACodecContext *s, float *out)
Apply MDCT window and add into output.
static av_cold int wma_decode_init(AVCodecContext *avctx)
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.
static int decode_exp_vlc(WMACodecContext *s, int ch)
decode exponents coded with VLC codes
static int wma_decode_superframe(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
static void decode_exp_lsp(WMACodecContext *s, int ch)
decode exponents coded with LSP coefficients (same idea as Vorbis)
static av_cold void flush(AVCodecContext *avctx)
static float pow_m1_4(WMACodecContext *s, float x)
compute x^-0.25 with an exponent and mantissa table.
static const float pow_tab[]
pow(10, i / 16.0) for i in -60..95
static int wma_decode_block(WMACodecContext *s)