Go to the documentation of this file.
47 #define BACKSTEP_SIZE 512
49 #define LAST_BUF_SIZE 2 * BACKSTEP_SIZE + EXTRABYTES
102 0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
103 142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
106 0, 128, 128, 128, 130, 128, 154, 166,
107 142, 204, 190, 170, 542, 460, 662, 414
134 #define SCALE_GEN(v) \
135 { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
150 g->region_size[2] = 576 / 2;
151 for (
i = 0;
i < 3;
i++) {
152 k =
FFMIN(
g->region_size[
i],
g->big_values);
153 g->region_size[
i] = k - j;
160 if (
g->block_type == 2) {
161 if (
s->sample_rate_index != 8)
162 g->region_size[0] = (36 / 2);
164 g->region_size[0] = (72 / 2);
166 if (
s->sample_rate_index <= 2)
167 g->region_size[0] = (36 / 2);
168 else if (
s->sample_rate_index != 8)
169 g->region_size[0] = (54 / 2);
171 g->region_size[0] = (108 / 2);
173 g->region_size[1] = (576 / 2);
182 l =
FFMIN(ra1 + ra2 + 2, 22);
188 if (
g->block_type == 2) {
189 if (
g->switch_point) {
190 if(
s->sample_rate_index == 8)
195 if (
s->sample_rate_index <= 2)
213 static inline int l1_unscale(
int n,
int mant,
int scale_factor)
257 m = (m + ((1U << e)>>1)) >> e;
268 for (
i = 0;
i < 64;
i++) {
277 for (
i = 0;
i < 15;
i++) {
280 norm = ((INT64_C(1) << n) *
FRAC_ONE) / ((1 << n) - 1);
284 ff_dlog(
NULL,
"%d: norm=%x s=%"PRIx32
" %"PRIx32
" %"PRIx32
"\n",
i,
295 for (
i = 1;
i < 16;
i++) {
298 uint8_t tmp_bits [512] = { 0 };
299 uint16_t tmp_codes[512] = { 0 };
304 for (x = 0; x < xsize; x++) {
305 for (y = 0; y < xsize; y++) {
306 tmp_bits [(x << 5) | y | ((x&&y)<<4)]=
h->bits [j ];
307 tmp_codes[(x << 5) | y | ((x&&y)<<4)]=
h->codes[j++];
315 tmp_bits, 1, 1, tmp_codes, 2, 2,
322 for (
i = 0;
i < 2;
i++) {
332 for (
i = 0;
i < 9;
i++) {
334 for (j = 0; j < 22; j++) {
345 for (
i = 0;
i < 4;
i++) {
348 int val1, val2, val3, steps;
361 for (
i = 0;
i < 7;
i++) {
365 f = tan((
double)
i *
M_PI / 12.0);
374 for (
i = 7;
i < 16;
i++)
377 for (
i = 0;
i < 16;
i++) {
381 for (j = 0; j < 2; j++) {
382 e = -(j + 1) * ((
i + 1) >> 1);
393 for (
i = 0;
i < 8;
i++) {
396 cs = 1.0 / sqrt(1.0 + ci * ci);
424 static int initialized_tables = 0;
427 if (!initialized_tables) {
429 initialized_tables = 1;
455 #define C3 FIXHR(0.86602540378443864676/2)
456 #define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
457 #define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
458 #define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
467 in1 =
in[1*3] +
in[0*3];
468 in2 =
in[2*3] +
in[1*3];
469 in3 =
in[3*3] +
in[2*3];
470 in4 =
in[4*3] +
in[3*3];
471 in5 =
in[5*3] +
in[4*3];
506 int bound,
i, v, n, ch, j, mant;
511 bound = (
s->mode_ext + 1) * 4;
517 for (ch = 0; ch <
s->nb_channels; ch++) {
526 for (ch = 0; ch <
s->nb_channels; ch++) {
527 if (allocation[ch][
i])
532 if (allocation[0][
i]) {
539 for (j = 0; j < 12; j++) {
541 for (ch = 0; ch <
s->nb_channels; ch++) {
542 n = allocation[ch][
i];
549 s->sb_samples[ch][j][
i] = v;
553 n = allocation[0][
i];
557 s->sb_samples[0][j][
i] = v;
559 s->sb_samples[1][j][
i] = v;
561 s->sb_samples[0][j][
i] = 0;
562 s->sb_samples[1][j][
i] = 0;
577 int scale, qindex,
bits, steps, k, l, m,
b;
581 s->sample_rate,
s->lsf);
586 bound = (
s->mode_ext + 1) * 4;
600 for (ch = 0; ch <
s->nb_channels; ch++)
602 j += 1 << bit_alloc_bits;
609 j += 1 << bit_alloc_bits;
613 for (
i = 0;
i < sblimit;
i++) {
614 for (ch = 0; ch <
s->nb_channels; ch++) {
621 for (
i = 0;
i < sblimit;
i++) {
622 for (ch = 0; ch <
s->nb_channels; ch++) {
624 sf = scale_factors[ch][
i];
625 switch (scale_code[ch][
i]) {
653 for (k = 0; k < 3; k++) {
654 for (l = 0; l < 12; l += 3) {
658 for (ch = 0; ch <
s->nb_channels; ch++) {
661 scale = scale_factors[ch][
i][k];
671 s->sb_samples[ch][k * 12 + l + 0][
i] =
673 s->sb_samples[ch][k * 12 + l + 1][
i] =
675 s->sb_samples[ch][k * 12 + l + 2][
i] =
678 for (m = 0; m < 3; m++) {
681 s->sb_samples[ch][k * 12 + l + m][
i] = v;
685 s->sb_samples[ch][k * 12 + l + 0][
i] = 0;
686 s->sb_samples[ch][k * 12 + l + 1][
i] = 0;
687 s->sb_samples[ch][k * 12 + l + 2][
i] = 0;
691 j += 1 << bit_alloc_bits;
698 int mant, scale0, scale1;
699 scale0 = scale_factors[0][
i][k];
700 scale1 = scale_factors[1][
i][k];
709 s->sb_samples[0][k * 12 + l + 0][
i] =
711 s->sb_samples[1][k * 12 + l + 0][
i] =
715 s->sb_samples[0][k * 12 + l + 1][
i] =
717 s->sb_samples[1][k * 12 + l + 1][
i] =
719 s->sb_samples[0][k * 12 + l + 2][
i] =
721 s->sb_samples[1][k * 12 + l + 2][
i] =
724 for (m = 0; m < 3; m++) {
726 s->sb_samples[0][k * 12 + l + m][
i] =
728 s->sb_samples[1][k * 12 + l + m][
i] =
733 s->sb_samples[0][k * 12 + l + 0][
i] = 0;
734 s->sb_samples[0][k * 12 + l + 1][
i] = 0;
735 s->sb_samples[0][k * 12 + l + 2][
i] = 0;
736 s->sb_samples[1][k * 12 + l + 0][
i] = 0;
737 s->sb_samples[1][k * 12 + l + 1][
i] = 0;
738 s->sb_samples[1][k * 12 + l + 2][
i] = 0;
741 j += 1 << bit_alloc_bits;
745 for (ch = 0; ch <
s->nb_channels; ch++) {
746 s->sb_samples[ch][k * 12 + l + 0][
i] = 0;
747 s->sb_samples[ch][k * 12 + l + 1][
i] = 0;
748 s->sb_samples[ch][k * 12 + l + 2][
i] = 0;
756 #define SPLIT(dst,sf,n) \
758 int m = (sf * 171) >> 9; \
761 } else if (n == 4) { \
764 } else if (n == 5) { \
765 int m = (sf * 205) >> 10; \
768 } else if (n == 6) { \
769 int m = (sf * 171) >> 10; \
779 SPLIT(slen[3], sf, n3)
780 SPLIT(slen[2], sf, n2)
781 SPLIT(slen[1], sf, n1)
793 gain =
g->global_gain - 210;
794 shift =
g->scalefac_scale + 1;
798 for (
i = 0;
i <
g->long_end;
i++) {
799 v0 = gain - ((
g->scale_factors[
i] + pretab[
i]) <<
shift) + 400;
801 for (j =
len; j > 0; j--)
805 if (
g->short_start < 13) {
807 gains[0] = gain - (
g->subblock_gain[0] << 3);
808 gains[1] = gain - (
g->subblock_gain[1] << 3);
809 gains[2] = gain - (
g->subblock_gain[2] << 3);
811 for (
i =
g->short_start;
i < 13;
i++) {
813 for (l = 0; l < 3; l++) {
814 v0 = gains[l] - (
g->scale_factors[k++] <<
shift) + 400;
815 for (j =
len; j > 0; j--)
825 if (
s->in_gb.buffer && *
pos >=
s->gb.size_in_bits -
s->extrasize * 8) {
827 s->in_gb.buffer =
NULL;
844 #define READ_FLIP_SIGN(dst,src) \
845 v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31); \
848 #define READ_FLIP_SIGN(dst,src) \
849 v = -get_bits1(&s->gb); \
850 *(dst) = (*(src) ^ v) - v;
854 int16_t *exponents,
int end_pos2)
858 int last_pos, bits_left;
860 int end_pos =
FFMIN(end_pos2,
s->gb.size_in_bits -
s->extrasize * 8);
864 for (
i = 0;
i < 3;
i++) {
865 int j, k, l, linbits;
866 j =
g->region_size[
i];
870 k =
g->table_select[
i];
876 memset(&
g->sb_hybrid[s_index], 0,
sizeof(*
g->sb_hybrid) * 2 * j);
895 g->sb_hybrid[s_index ] =
896 g->sb_hybrid[s_index+1] = 0;
901 exponent= exponents[s_index];
903 ff_dlog(
s->avctx,
"region=%d n=%d y=%d exp=%d\n",
904 i,
g->region_size[
i] - j, y, exponent);
915 g->sb_hybrid[s_index] = v;
924 g->sb_hybrid[s_index+1] = v;
937 g->sb_hybrid[s_index+!!y] = v;
939 g->sb_hybrid[s_index + !y] = 0;
948 while (s_index <= 572) {
951 if (
pos >= end_pos) {
952 if (
pos > end_pos2 && last_pos) {
969 ff_dlog(
s->avctx,
"t=%d code=%d\n",
g->count1table_select,
code);
970 g->sb_hybrid[s_index+0] =
971 g->sb_hybrid[s_index+1] =
972 g->sb_hybrid[s_index+2] =
973 g->sb_hybrid[s_index+3] = 0;
975 static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
977 int pos = s_index + idxtab[
code];
992 memset(&
g->sb_hybrid[s_index], 0,
sizeof(*
g->sb_hybrid) * (576 - s_index));
1010 if (
g->block_type != 2)
1013 if (
g->switch_point) {
1014 if (
s->sample_rate_index != 8)
1015 ptr =
g->sb_hybrid + 36;
1017 ptr =
g->sb_hybrid + 72;
1022 for (
i =
g->short_start;
i < 13;
i++) {
1026 for (j =
len; j > 0; j--) {
1027 *dst++ = ptr[0*
len];
1028 *dst++ = ptr[1*
len];
1029 *dst++ = ptr[2*
len];
1033 memcpy(ptr1,
tmp,
len * 3 *
sizeof(*ptr1));
1037 #define ISQRT2 FIXR(0.70710678118654752440)
1042 int sf_max, sf,
len, non_zero_found;
1045 int non_zero_found_short[3];
1060 non_zero_found_short[0] = 0;
1061 non_zero_found_short[1] = 0;
1062 non_zero_found_short[2] = 0;
1069 for (l = 2; l >= 0; l--) {
1072 if (!non_zero_found_short[l]) {
1074 for (j = 0; j <
len; j++) {
1076 non_zero_found_short[l] = 1;
1086 for (j = 0; j <
len; j++) {
1096 for (j = 0; j <
len; j++) {
1107 non_zero_found = non_zero_found_short[0] |
1108 non_zero_found_short[1] |
1109 non_zero_found_short[2];
1116 if (!non_zero_found) {
1117 for (j = 0; j <
len; j++) {
1124 k = (
i == 21) ? 20 :
i;
1130 for (j = 0; j <
len; j++) {
1140 for (j = 0; j <
len; j++) {
1158 for (
i = 0;
i < 576;
i++) {
1161 tab0[
i] = tmp0 + tmp1;
1162 tab1[
i] = tmp0 - tmp1;
1178 #ifndef compute_antialias
1180 #define AA(j) do { \
1181 float tmp0 = ptr[-1-j]; \
1182 float tmp1 = ptr[ j]; \
1183 ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1]; \
1184 ptr[ j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0]; \
1187 #define AA(j) do { \
1188 SUINT tmp0 = ptr[-1-j]; \
1189 SUINT tmp1 = ptr[ j]; \
1190 SUINT tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]); \
1191 ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2])); \
1192 ptr[ j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3])); \
1202 if (
g->block_type == 2) {
1203 if (!
g->switch_point)
1211 ptr =
g->sb_hybrid + 18;
1212 for (
i = n;
i > 0;
i--) {
1232 int i, j, mdct_long_end, sblimit;
1235 ptr =
g->sb_hybrid + 576;
1236 ptr1 =
g->sb_hybrid + 2 * 18;
1237 while (ptr >= ptr1) {
1241 if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
1244 sblimit = ((ptr -
g->sb_hybrid) / 18) + 1;
1246 if (
g->block_type == 2) {
1248 if (
g->switch_point)
1253 mdct_long_end = sblimit;
1256 s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf,
g->sb_hybrid,
1257 mdct_long_end,
g->switch_point,
1260 buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
1261 ptr =
g->sb_hybrid + 18 * mdct_long_end;
1263 for (j = mdct_long_end; j < sblimit; j++) {
1265 win =
RENAME(ff_mdct_win)[2 + (4 & -(j & 1))];
1266 out_ptr = sb_samples + j;
1268 for (
i = 0;
i < 6;
i++) {
1269 *out_ptr = buf[4*
i];
1273 for (
i = 0;
i < 6;
i++) {
1274 *out_ptr =
MULH3(out2[
i ],
win[
i ], 1) + buf[4*(
i + 6*1)];
1275 buf[4*(
i + 6*2)] =
MULH3(out2[
i + 6],
win[
i + 6], 1);
1279 for (
i = 0;
i < 6;
i++) {
1280 *out_ptr =
MULH3(out2[
i ],
win[
i ], 1) + buf[4*(
i + 6*2)];
1281 buf[4*(
i + 6*0)] =
MULH3(out2[
i + 6],
win[
i + 6], 1);
1285 for (
i = 0;
i < 6;
i++) {
1286 buf[4*(
i + 6*0)] =
MULH3(out2[
i ],
win[
i ], 1) + buf[4*(
i + 6*0)];
1287 buf[4*(
i + 6*1)] =
MULH3(out2[
i + 6],
win[
i + 6], 1);
1288 buf[4*(
i + 6*2)] = 0;
1291 buf += (j&3) != 3 ? 1 : (4*18-3);
1294 for (j = sblimit; j <
SBLIMIT; j++) {
1296 out_ptr = sb_samples + j;
1297 for (
i = 0;
i < 18;
i++) {
1298 *out_ptr = buf[4*
i];
1302 buf += (j&3) != 3 ? 1 : (4*18-3);
1309 int nb_granules, main_data_begin;
1310 int gr, ch, blocksplit_flag,
i, j, k, n, bits_pos;
1312 int16_t exponents[576];
1321 if (
s->nb_channels == 2)
1326 for (ch = 0; ch <
s->nb_channels; ch++) {
1327 s->granules[ch][0].scfsi = 0;
1328 s->granules[ch][1].scfsi =
get_bits(&
s->gb, 4);
1332 for (gr = 0; gr < nb_granules; gr++) {
1333 for (ch = 0; ch <
s->nb_channels; ch++) {
1334 ff_dlog(
s->avctx,
"gr=%d ch=%d: side_info\n", gr, ch);
1335 g = &
s->granules[ch][gr];
1338 if (
g->big_values > 288) {
1348 g->global_gain -= 2;
1354 if (blocksplit_flag) {
1356 if (
g->block_type == 0) {
1361 for (
i = 0;
i < 2;
i++)
1363 for (
i = 0;
i < 3;
i++)
1367 int region_address1, region_address2;
1369 g->switch_point = 0;
1370 for (
i = 0;
i < 3;
i++)
1375 ff_dlog(
s->avctx,
"region1=%d region2=%d\n",
1376 region_address1, region_address2);
1387 ff_dlog(
s->avctx,
"block_type=%d switch_point=%d\n",
1388 g->block_type,
g->switch_point);
1399 ff_dlog(
s->avctx,
"seekback:%d, lastbuf:%d\n",
1400 main_data_begin,
s->last_buf_size);
1402 memcpy(
s->last_buf +
s->last_buf_size, ptr,
s->extrasize);
1405 s->last_buf_size <<= 3;
1406 for (gr = 0; gr < nb_granules && (
s->last_buf_size >> 3) < main_data_begin; gr++) {
1407 for (ch = 0; ch <
s->nb_channels; ch++) {
1408 g = &
s->granules[ch][gr];
1409 s->last_buf_size +=
g->part2_3_length;
1410 memset(
g->sb_hybrid, 0,
sizeof(
g->sb_hybrid));
1414 skip =
s->last_buf_size - 8 * main_data_begin;
1415 if (skip >=
s->gb.size_in_bits -
s->extrasize * 8 &&
s->in_gb.buffer) {
1418 s->in_gb.buffer =
NULL;
1428 for (; gr < nb_granules; gr++) {
1429 for (ch = 0; ch <
s->nb_channels; ch++) {
1430 g = &
s->granules[ch][gr];
1435 int slen, slen1, slen2;
1440 ff_dlog(
s->avctx,
"slen1=%d slen2=%d\n", slen1, slen2);
1441 if (
g->block_type == 2) {
1442 n =
g->switch_point ? 17 : 18;
1445 for (
i = 0;
i < n;
i++)
1446 g->scale_factors[j++] =
get_bits(&
s->gb, slen1);
1448 for (
i = 0;
i < n;
i++)
1449 g->scale_factors[j++] = 0;
1452 for (
i = 0;
i < 18;
i++)
1453 g->scale_factors[j++] =
get_bits(&
s->gb, slen2);
1454 for (
i = 0;
i < 3;
i++)
1455 g->scale_factors[j++] = 0;
1457 for (
i = 0;
i < 21;
i++)
1458 g->scale_factors[j++] = 0;
1461 sc =
s->granules[ch][0].scale_factors;
1463 for (k = 0; k < 4; k++) {
1465 if ((
g->scfsi & (0x8 >> k)) == 0) {
1466 slen = (k < 2) ? slen1 : slen2;
1468 for (
i = 0;
i < n;
i++)
1469 g->scale_factors[j++] =
get_bits(&
s->gb, slen);
1471 for (
i = 0;
i < n;
i++)
1472 g->scale_factors[j++] = 0;
1476 for (
i = 0;
i < n;
i++) {
1477 g->scale_factors[j] = sc[j];
1482 g->scale_factors[j++] = 0;
1485 int tindex, tindex2, slen[4], sl, sf;
1488 if (
g->block_type == 2)
1489 tindex =
g->switch_point ? 2 : 1;
1493 sf =
g->scalefac_compress;
1500 }
else if (sf < 244) {
1512 }
else if (sf < 500) {
1523 for (k = 0; k < 4; k++) {
1527 for (
i = 0;
i < n;
i++)
1528 g->scale_factors[j++] =
get_bits(&
s->gb, sl);
1530 for (
i = 0;
i < n;
i++)
1531 g->scale_factors[j++] = 0;
1536 g->scale_factors[j] = 0;
1548 for (ch = 0; ch <
s->nb_channels; ch++) {
1549 g = &
s->granules[ch][gr];
1558 return nb_granules * 18;
1562 const uint8_t *buf,
int buf_size)
1564 int i, nb_frames, ch,
ret;
1569 if (
s->error_protection) {
1572 const int sec_len =
s->lsf ? ((
s->nb_channels == 1) ? 9 : 17) :
1573 ((
s->nb_channels == 1) ? 17 : 32);
1575 uint32_t crc_cal =
av_crc(crc_tab, UINT16_MAX, &buf[2], 2);
1576 crc_cal =
av_crc(crc_tab, crc_cal, &buf[6], sec_len);
1588 s->avctx->frame_size = 384;
1592 s->avctx->frame_size = 1152;
1596 s->avctx->frame_size =
s->lsf ? 576 : 1152;
1601 if (
s->in_gb.buffer) {
1610 s->in_gb.buffer =
NULL;
1622 av_assert1(i <= buf_size - HEADER_SIZE && i >= 0);
1623 memcpy(
s->last_buf +
s->last_buf_size,
s->gb.buffer + buf_size -
HEADER_SIZE -
i,
i);
1624 s->last_buf_size +=
i;
1633 s->frame->nb_samples =
s->avctx->frame_size;
1640 for (ch = 0; ch <
s->nb_channels; ch++) {
1646 samples_ptr =
samples[0] + ch;
1647 sample_stride =
s->nb_channels;
1649 for (
i = 0;
i < nb_frames;
i++) {
1650 RENAME(ff_mpa_synth_filter)(&
s->mpadsp,
s->synth_buf[ch],
1651 &(
s->synth_buf_offset[ch]),
1652 RENAME(ff_mpa_synth_window),
1653 &
s->dither_state, samples_ptr,
1654 sample_stride,
s->sb_samples[ch][
i]);
1655 samples_ptr += 32 * sample_stride;
1659 return nb_frames * 32 *
sizeof(
OUT_INT) *
s->nb_channels;
1666 int buf_size = avpkt->
size;
1672 while(buf_size && !*buf){
1684 return buf_size + skipped;
1690 }
else if (
ret == 1) {
1701 if (
s->frame_size <= 0) {
1704 }
else if (
s->frame_size < buf_size) {
1706 buf_size=
s->frame_size;
1729 return buf_size + skipped;
1734 memset(
ctx->synth_buf, 0,
sizeof(
ctx->synth_buf));
1735 memset(
ctx->mdct_buf, 0,
sizeof(
ctx->mdct_buf));
1736 ctx->last_buf_size = 0;
1737 ctx->dither_state = 0;
1745 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
1747 int *got_frame_ptr,
AVPacket *avpkt)
1750 int buf_size = avpkt->
size;
1783 s->frame_size =
len;
1799 #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
1804 typedef struct MP3On4DecodeContext {
1809 } MP3On4DecodeContext;
1816 static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
1819 static const uint8_t chan_offset[8][5] = {
1831 static const int16_t chan_layout[8] = {
1847 if (
s->mp3decctx[0])
1850 for (
i = 0;
i <
s->frames;
i++)
1880 s->syncword = 0xffe00000;
1882 s->syncword = 0xfff00000;
1891 if (!
s->mp3decctx[0])
1899 decode_close_mp3on4(avctx);
1902 s->mp3decctx[0]->adu_mode = 1;
1907 for (
i = 1;
i <
s->frames;
i++) {
1909 if (!
s->mp3decctx[
i])
1911 s->mp3decctx[
i]->adu_mode = 1;
1912 s->mp3decctx[
i]->avctx = avctx;
1913 s->mp3decctx[
i]->mpadsp =
s->mp3decctx[0]->mpadsp;
1914 s->mp3decctx[
i]->fdsp =
s->mp3decctx[0]->fdsp;
1919 decode_close_mp3on4(avctx);
1929 for (
i = 0;
i <
s->frames;
i++)
1935 int *got_frame_ptr,
AVPacket *avpkt)
1939 int buf_size = avpkt->
size;
1961 for (fr = 0; fr <
s->frames; fr++) {
1964 m =
s->mp3decctx[fr];
1979 if (ch + m->nb_channels > avctx->
channels ||
1980 s->coff[fr] + m->nb_channels > avctx->
channels) {
1985 ch += m->nb_channels;
1987 outptr[0] = out_samples[
s->coff[fr]];
1988 if (m->nb_channels > 1)
1989 outptr[1] = out_samples[
s->coff[fr] + 1];
1994 if (m->nb_channels > 1)
int frame_size
Number of samples per channel in an audio frame.
uint8_t scale_factors[40]
MPA_DECODE_HEADER uint8_t last_buf[LAST_BUF_SIZE]
static void compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int l3_unscale(int value, int exponent)
static void init_short_region(MPADecodeContext *s, GranuleDef *g)
int ff_mpa_l2_select_table(int bitrate, int nb_channels, int freq, int lsf)
static const uint8_t mpa_quad_bits[2][16]
static int get_bits_left(GetBitContext *gb)
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
static VLC huff_quad_vlc[2]
uint64_t channel_layout
Audio channel layout.
int sample_rate
samples per second
GranuleDef granules[2][2]
static const uint8_t lsf_nsf_table[6][3][4]
static int l1_unscale(int n, int mant, int scale_factor)
static INTFLOAT is_table[2][16]
#define AV_CH_LAYOUT_MONO
static void mp_flush(MPADecodeContext *ctx)
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
static int get_bits_count(const GetBitContext *s)
av_cold void ff_mpadsp_init(MPADSPContext *s)
This structure describes decoded (raw) audio or video data.
int adu_mode
0 for standard mp3, 1 for adu formatted mp3
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
static const uint16_t table[]
static const uint8_t mpa_quad_codes[2][16]
static const int huff_vlc_tables_sizes[16]
static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples, const uint8_t *buf, int buf_size)
static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
static int8_t table_4_3_exp[TABLE_4_3_SIZE]
static INTFLOAT is_table_lsf[2][2][16]
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
const int ff_mpa_quant_bits[17]
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
#define AV_EF_BUFFER
detect improper bitstream length
static int16_t *const division_tabs[4]
static VLC_TYPE huff_vlc_tables[0+128+128+128+130+128+154+166+142+204+190+170+542+460+662+414][2]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static float win(SuperEqualizerContext *s, float n, int N)
static av_cold void mpegaudio_tableinit(void)
const uint8_t ff_mpeg4audio_channels[8]
static void skip_bits(GetBitContext *s, int n)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g, int16_t *exponents)
static void reorder_block(MPADecodeContext *s, GranuleDef *g)
static int mp_decode_layer3(MPADecodeContext *s)
if it could not because there are no more frames
int flags
AV_CODEC_FLAG_*.
static double val(void *priv, double ch)
#define AV_CH_LAYOUT_STEREO
static int bit_alloc(AC3EncodeContext *s, int snr_offset)
Run the bit allocation with a given SNR offset.
#define AV_EF_BITSTREAM
detect bitstream specification deviations
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const int ff_mpa_quant_steps[17]
static void compute_imdct(MPADecodeContext *s, GranuleDef *g, INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
static void imdct12(INTFLOAT *out, SUINTFLOAT *in)
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
#define MODE_EXT_MS_STEREO
int avpriv_mpeg4audio_get_config2(MPEG4AudioConfig *c, const uint8_t *buf, int size, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration.
static const uint8_t slen_table[2][16]
static int16_t division_tab3[1<< 6]
static const uint8_t band_size_long[9][22]
static const float ci_table[8]
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static const uint8_t band_size_short[9][13]
static int64_t fsize(FILE *f)
static av_cold int decode_close(AVCodecContext *avctx)
const unsigned char *const ff_mpa_alloc_tables[5]
#define SPLIT(dst, sf, n)
static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
static const int huff_quad_vlc_tables_sizes[2]
static int huffman_decode(MPADecodeContext *s, GranuleDef *g, int16_t *exponents, int end_pos2)
Used to store optimal huffman encoding results.
int64_t bit_rate
the average bitrate
int sb_hybrid[SBLIMIT *18]
static unsigned int get_bits1(GetBitContext *s)
static int mp_decode_layer1(MPADecodeContext *s)
#define AV_CH_LAYOUT_5POINT1
#define INIT_VLC_USE_NEW_STATIC
#define AV_EF_EXPLODE
abort decoding on minor error detection
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2, int n3)
enum AVSampleFormat sample_fmt
audio sample format
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
#define READ_FLIP_SIGN(dst, src)
static const uint8_t header[24]
uint32_t free_format_next_header
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
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
enum AVSampleFormat request_sample_fmt
desired sample format
static av_cold void decode_init_static(void)
static int16_t division_tab9[1<< 11]
#define AV_LOG_INFO
Standard information.
static int32_t scale_factor_mult[15][3]
int channels
number of audio channels
static const uint8_t mpa_huff_data[32][2]
#define DECLARE_ALIGNED(n, t, v)
#define AV_CH_LAYOUT_5POINT0
static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos, int *end_pos2)
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
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define i(width, name, range_min, range_max)
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
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
const int ff_mpa_sblimit_table[5]
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define AV_CH_LAYOUT_7POINT1
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 value
MPA_INT synth_buf[MPA_MAX_CHANNELS][512 *2]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static int mod(int a, int b)
Modulo operation with only positive remainders.
static const uint8_t mpa_pretab[2][22]
static int alloc_table(VLC *vlc, int size, int use_static)
static double bound(const double threshold, const double val)
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
#define AV_CH_LAYOUT_SURROUND
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
static const uint8_t * align_get_bits(GetBitContext *s)
#define FF_ARRAY_ELEMS(a)
main external API structure.
int synth_buf_offset[MPA_MAX_CHANNELS]
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
static VLC_TYPE huff_quad_vlc_tables[128+16][2]
static void region_offset2size(GranuleDef *g)
Convert region offsets to region sizes and truncate size to big_values.
static void init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)
#define MODE_EXT_I_STEREO
static INTFLOAT csa_table[8][4]
static void flush(AVCodecContext *avctx)
Filter the word “frame” indicates either a video frame or a group of audio samples
static int l2_unscale_group(int steps, int mant, int scale_factor)
static uint16_t scale_factor_modshift[64]
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
static int shift(int a, int b)
int sb_samples[MPA_MAX_CHANNELS][36][SBLIMIT]
uint8_t count1table_select
static uint16_t band_index_long[9][23]
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define avpriv_request_sample(...)
This structure stores compressed data.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
static av_cold int decode_init(AVCodecContext *avctx)
#define AV_CH_LAYOUT_4POINT0
static const int32_t scale_factor_mult2[3][3]
static const HuffTable mpa_huff_tables[16]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT *18]
#define MPA_MAX_CODED_FRAME_SIZE
VLC_TYPE(* table)[2]
code, bits
static int16_t division_tab5[1<< 8]
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
static uint32_t table_4_3_value[TABLE_4_3_SIZE]
static int mp_decode_layer2(MPADecodeContext *s)