FFmpeg
mpegaudioenc_template.c
Go to the documentation of this file.
1 /*
2  * The simplest mpeg audio layer 2 encoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard
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  */
21 
22 /**
23  * @file
24  * The simplest mpeg audio layer 2 encoder.
25  */
26 
28 
29 #include "avcodec.h"
30 #include "internal.h"
31 #include "put_bits.h"
32 
33 #define FRAC_BITS 15 /* fractional bits for sb_samples and dct */
34 #define WFRAC_BITS 14 /* fractional bits for window */
35 
36 #include "mpegaudio.h"
37 #include "mpegaudiodsp.h"
38 #include "mpegaudiodata.h"
39 #include "mpegaudiotab.h"
40 
41 /* currently, cannot change these constants (need to modify
42  quantization stage) */
43 #define MUL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS)
44 
45 #define SAMPLES_BUF_SIZE 4096
46 
47 typedef struct MpegAudioContext {
50  int lsf; /* 1 if mpeg2 low bitrate selected */
51  int bitrate_index; /* bit rate */
53  int frame_size; /* frame size, in bits, without padding */
54  /* padding computation */
56  short samples_buf[MPA_MAX_CHANNELS][SAMPLES_BUF_SIZE]; /* buffer for filter */
57  int samples_offset[MPA_MAX_CHANNELS]; /* offset in samples_buf */
59  unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3]; /* scale factors */
60  /* code to group 3 scale factors */
62  int sblimit; /* number of used subbands */
63  const unsigned char *alloc_table;
64  int16_t filter_bank[512];
66  unsigned char scale_diff_table[128];
67 #if USE_FLOATS
68  float scale_factor_inv_table[64];
69 #else
70  int8_t scale_factor_shift[64];
71  unsigned short scale_factor_mult[64];
72 #endif
73  unsigned short total_quant_bits[17]; /* total number of bits per allocation group */
75 
77 {
78  MpegAudioContext *s = avctx->priv_data;
79  int freq = avctx->sample_rate;
80  int bitrate = avctx->bit_rate;
81  int channels = avctx->channels;
82  int i, v, table;
83  float a;
84 
86  av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed in mp2\n", channels);
87  return AVERROR(EINVAL);
88  }
89  bitrate = bitrate / 1000;
90  s->nb_channels = channels;
91  avctx->frame_size = MPA_FRAME_SIZE;
92  avctx->initial_padding = 512 - 32 + 1;
93 
94  /* encoding freq */
95  s->lsf = 0;
96  for(i=0;i<3;i++) {
97  if (avpriv_mpa_freq_tab[i] == freq)
98  break;
99  if ((avpriv_mpa_freq_tab[i] / 2) == freq) {
100  s->lsf = 1;
101  break;
102  }
103  }
104  if (i == 3){
105  av_log(avctx, AV_LOG_ERROR, "Sampling rate %d is not allowed in mp2\n", freq);
106  return AVERROR(EINVAL);
107  }
108  s->freq_index = i;
109 
110  /* encoding bitrate & frequency */
111  for(i=1;i<15;i++) {
112  if (avpriv_mpa_bitrate_tab[s->lsf][1][i] == bitrate)
113  break;
114  }
115  if (i == 15 && !avctx->bit_rate) {
116  i = 14;
117  bitrate = avpriv_mpa_bitrate_tab[s->lsf][1][i];
118  avctx->bit_rate = bitrate * 1000;
119  }
120  if (i == 15){
121  av_log(avctx, AV_LOG_ERROR, "bitrate %d is not allowed in mp2\n", bitrate);
122  return AVERROR(EINVAL);
123  }
124  s->bitrate_index = i;
125 
126  /* compute total header size & pad bit */
127 
128  a = (float)(bitrate * 1000 * MPA_FRAME_SIZE) / (freq * 8.0);
129  s->frame_size = ((int)a) * 8;
130 
131  /* frame fractional size to compute padding */
132  s->frame_frac = 0;
133  s->frame_frac_incr = (int)((a - floor(a)) * 65536.0);
134 
135  /* select the right allocation table */
136  table = ff_mpa_l2_select_table(bitrate, s->nb_channels, freq, s->lsf);
137 
138  /* number of used subbands */
141 
142  ff_dlog(avctx, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
143  bitrate, freq, s->frame_size, table, s->frame_frac_incr);
144 
145  for(i=0;i<s->nb_channels;i++)
146  s->samples_offset[i] = 0;
147 
148  for(i=0;i<257;i++) {
149  int v;
150  v = ff_mpa_enwindow[i];
151 #if WFRAC_BITS != 16
152  v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
153 #endif
154  s->filter_bank[i] = v;
155  if ((i & 63) != 0)
156  v = -v;
157  if (i != 0)
158  s->filter_bank[512 - i] = v;
159  }
160 
161  for(i=0;i<64;i++) {
162  v = (int)(exp2((3 - i) / 3.0) * (1 << 20));
163  if (v <= 0)
164  v = 1;
165  s->scale_factor_table[i] = v;
166 #if USE_FLOATS
167  s->scale_factor_inv_table[i] = exp2(-(3 - i) / 3.0) / (float)(1 << 20);
168 #else
169 #define P 15
170  s->scale_factor_shift[i] = 21 - P - (i / 3);
171  s->scale_factor_mult[i] = (1 << P) * exp2((i % 3) / 3.0);
172 #endif
173  }
174  for(i=0;i<128;i++) {
175  v = i - 64;
176  if (v <= -3)
177  v = 0;
178  else if (v < 0)
179  v = 1;
180  else if (v == 0)
181  v = 2;
182  else if (v < 3)
183  v = 3;
184  else
185  v = 4;
186  s->scale_diff_table[i] = v;
187  }
188 
189  for(i=0;i<17;i++) {
190  v = ff_mpa_quant_bits[i];
191  if (v < 0)
192  v = -v;
193  else
194  v = v * 3;
195  s->total_quant_bits[i] = 12 * v;
196  }
197 
198  return 0;
199 }
200 
201 /* 32 point floating point IDCT without 1/sqrt(2) coef zero scaling */
202 static void idct32(int *out, int *tab)
203 {
204  int i, j;
205  int *t, *t1, xr;
206  const int *xp = costab32;
207 
208  for(j=31;j>=3;j-=2) tab[j] += tab[j - 2];
209 
210  t = tab + 30;
211  t1 = tab + 2;
212  do {
213  t[0] += t[-4];
214  t[1] += t[1 - 4];
215  t -= 4;
216  } while (t != t1);
217 
218  t = tab + 28;
219  t1 = tab + 4;
220  do {
221  t[0] += t[-8];
222  t[1] += t[1-8];
223  t[2] += t[2-8];
224  t[3] += t[3-8];
225  t -= 8;
226  } while (t != t1);
227 
228  t = tab;
229  t1 = tab + 32;
230  do {
231  t[ 3] = -t[ 3];
232  t[ 6] = -t[ 6];
233 
234  t[11] = -t[11];
235  t[12] = -t[12];
236  t[13] = -t[13];
237  t[15] = -t[15];
238  t += 16;
239  } while (t != t1);
240 
241 
242  t = tab;
243  t1 = tab + 8;
244  do {
245  int x1, x2, x3, x4;
246 
247  x3 = MUL(t[16], FIX(M_SQRT2*0.5));
248  x4 = t[0] - x3;
249  x3 = t[0] + x3;
250 
251  x2 = MUL(-(t[24] + t[8]), FIX(M_SQRT2*0.5));
252  x1 = MUL((t[8] - x2), xp[0]);
253  x2 = MUL((t[8] + x2), xp[1]);
254 
255  t[ 0] = x3 + x1;
256  t[ 8] = x4 - x2;
257  t[16] = x4 + x2;
258  t[24] = x3 - x1;
259  t++;
260  } while (t != t1);
261 
262  xp += 2;
263  t = tab;
264  t1 = tab + 4;
265  do {
266  xr = MUL(t[28],xp[0]);
267  t[28] = (t[0] - xr);
268  t[0] = (t[0] + xr);
269 
270  xr = MUL(t[4],xp[1]);
271  t[ 4] = (t[24] - xr);
272  t[24] = (t[24] + xr);
273 
274  xr = MUL(t[20],xp[2]);
275  t[20] = (t[8] - xr);
276  t[ 8] = (t[8] + xr);
277 
278  xr = MUL(t[12],xp[3]);
279  t[12] = (t[16] - xr);
280  t[16] = (t[16] + xr);
281  t++;
282  } while (t != t1);
283  xp += 4;
284 
285  for (i = 0; i < 4; i++) {
286  xr = MUL(tab[30-i*4],xp[0]);
287  tab[30-i*4] = (tab[i*4] - xr);
288  tab[ i*4] = (tab[i*4] + xr);
289 
290  xr = MUL(tab[ 2+i*4],xp[1]);
291  tab[ 2+i*4] = (tab[28-i*4] - xr);
292  tab[28-i*4] = (tab[28-i*4] + xr);
293 
294  xr = MUL(tab[31-i*4],xp[0]);
295  tab[31-i*4] = (tab[1+i*4] - xr);
296  tab[ 1+i*4] = (tab[1+i*4] + xr);
297 
298  xr = MUL(tab[ 3+i*4],xp[1]);
299  tab[ 3+i*4] = (tab[29-i*4] - xr);
300  tab[29-i*4] = (tab[29-i*4] + xr);
301 
302  xp += 2;
303  }
304 
305  t = tab + 30;
306  t1 = tab + 1;
307  do {
308  xr = MUL(t1[0], *xp);
309  t1[0] = (t[0] - xr);
310  t[0] = (t[0] + xr);
311  t -= 2;
312  t1 += 2;
313  xp++;
314  } while (t >= tab);
315 
316  for(i=0;i<32;i++) {
317  out[i] = tab[bitinv32[i]];
318  }
319 }
320 
321 #define WSHIFT (WFRAC_BITS + 15 - FRAC_BITS)
322 
323 static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
324 {
325  short *p, *q;
326  int sum, offset, i, j;
327  int tmp[64];
328  int tmp1[32];
329  int *out;
330 
331  offset = s->samples_offset[ch];
332  out = &s->sb_samples[ch][0][0][0];
333  for(j=0;j<36;j++) {
334  /* 32 samples at once */
335  for(i=0;i<32;i++) {
336  s->samples_buf[ch][offset + (31 - i)] = samples[0];
337  samples += incr;
338  }
339 
340  /* filter */
341  p = s->samples_buf[ch] + offset;
342  q = s->filter_bank;
343  /* maxsum = 23169 */
344  for(i=0;i<64;i++) {
345  sum = p[0*64] * q[0*64];
346  sum += p[1*64] * q[1*64];
347  sum += p[2*64] * q[2*64];
348  sum += p[3*64] * q[3*64];
349  sum += p[4*64] * q[4*64];
350  sum += p[5*64] * q[5*64];
351  sum += p[6*64] * q[6*64];
352  sum += p[7*64] * q[7*64];
353  tmp[i] = sum;
354  p++;
355  q++;
356  }
357  tmp1[0] = tmp[16] >> WSHIFT;
358  for( i=1; i<=16; i++ ) tmp1[i] = (tmp[i+16]+tmp[16-i]) >> WSHIFT;
359  for( i=17; i<=31; i++ ) tmp1[i] = (tmp[i+16]-tmp[80-i]) >> WSHIFT;
360 
361  idct32(out, tmp1);
362 
363  /* advance of 32 samples */
364  offset -= 32;
365  out += 32;
366  /* handle the wrap around */
367  if (offset < 0) {
368  memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32),
369  s->samples_buf[ch], (512 - 32) * 2);
370  offset = SAMPLES_BUF_SIZE - 512;
371  }
372  }
373  s->samples_offset[ch] = offset;
374 }
375 
377  unsigned char scale_code[SBLIMIT],
378  unsigned char scale_factors[SBLIMIT][3],
379  int sb_samples[3][12][SBLIMIT],
380  int sblimit)
381 {
382  int *p, vmax, v, n, i, j, k, code;
383  int index, d1, d2;
384  unsigned char *sf = &scale_factors[0][0];
385 
386  for(j=0;j<sblimit;j++) {
387  for(i=0;i<3;i++) {
388  /* find the max absolute value */
389  p = &sb_samples[i][0][j];
390  vmax = abs(*p);
391  for(k=1;k<12;k++) {
392  p += SBLIMIT;
393  v = abs(*p);
394  if (v > vmax)
395  vmax = v;
396  }
397  /* compute the scale factor index using log 2 computations */
398  if (vmax > 1) {
399  n = av_log2(vmax);
400  /* n is the position of the MSB of vmax. now
401  use at most 2 compares to find the index */
402  index = (21 - n) * 3 - 3;
403  if (index >= 0) {
404  while (vmax <= s->scale_factor_table[index+1])
405  index++;
406  } else {
407  index = 0; /* very unlikely case of overflow */
408  }
409  } else {
410  index = 62; /* value 63 is not allowed */
411  }
412 
413  ff_dlog(NULL, "%2d:%d in=%x %x %d\n",
414  j, i, vmax, s->scale_factor_table[index], index);
415  /* store the scale factor */
416  av_assert2(index >=0 && index <= 63);
417  sf[i] = index;
418  }
419 
420  /* compute the transmission factor : look if the scale factors
421  are close enough to each other */
422  d1 = s->scale_diff_table[sf[0] - sf[1] + 64];
423  d2 = s->scale_diff_table[sf[1] - sf[2] + 64];
424 
425  /* handle the 25 cases */
426  switch(d1 * 5 + d2) {
427  case 0*5+0:
428  case 0*5+4:
429  case 3*5+4:
430  case 4*5+0:
431  case 4*5+4:
432  code = 0;
433  break;
434  case 0*5+1:
435  case 0*5+2:
436  case 4*5+1:
437  case 4*5+2:
438  code = 3;
439  sf[2] = sf[1];
440  break;
441  case 0*5+3:
442  case 4*5+3:
443  code = 3;
444  sf[1] = sf[2];
445  break;
446  case 1*5+0:
447  case 1*5+4:
448  case 2*5+4:
449  code = 1;
450  sf[1] = sf[0];
451  break;
452  case 1*5+1:
453  case 1*5+2:
454  case 2*5+0:
455  case 2*5+1:
456  case 2*5+2:
457  code = 2;
458  sf[1] = sf[2] = sf[0];
459  break;
460  case 2*5+3:
461  case 3*5+3:
462  code = 2;
463  sf[0] = sf[1] = sf[2];
464  break;
465  case 3*5+0:
466  case 3*5+1:
467  case 3*5+2:
468  code = 2;
469  sf[0] = sf[2] = sf[1];
470  break;
471  case 1*5+3:
472  code = 2;
473  if (sf[0] > sf[2])
474  sf[0] = sf[2];
475  sf[1] = sf[2] = sf[0];
476  break;
477  default:
478  av_assert2(0); //cannot happen
479  code = 0; /* kill warning */
480  }
481 
482  ff_dlog(NULL, "%d: %2d %2d %2d %d %d -> %d\n", j,
483  sf[0], sf[1], sf[2], d1, d2, code);
484  scale_code[j] = code;
485  sf += 3;
486  }
487 }
488 
489 /* The most important function : psycho acoustic module. In this
490  encoder there is basically none, so this is the worst you can do,
491  but also this is the simpler. */
493 {
494  int i;
495 
496  for(i=0;i<s->sblimit;i++) {
497  smr[i] = (int)(fixed_smr[i] * 10);
498  }
499 }
500 
501 
502 #define SB_NOTALLOCATED 0
503 #define SB_ALLOCATED 1
504 #define SB_NOMORE 2
505 
506 /* Try to maximize the smr while using a number of bits inferior to
507  the frame size. I tried to make the code simpler, faster and
508  smaller than other encoders :-) */
510  short smr1[MPA_MAX_CHANNELS][SBLIMIT],
511  unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
512  int *padding)
513 {
514  int i, ch, b, max_smr, max_ch, max_sb, current_frame_size, max_frame_size;
515  int incr;
516  short smr[MPA_MAX_CHANNELS][SBLIMIT];
517  unsigned char subband_status[MPA_MAX_CHANNELS][SBLIMIT];
518  const unsigned char *alloc;
519 
520  memcpy(smr, smr1, s->nb_channels * sizeof(short) * SBLIMIT);
521  memset(subband_status, SB_NOTALLOCATED, s->nb_channels * SBLIMIT);
522  memset(bit_alloc, 0, s->nb_channels * SBLIMIT);
523 
524  /* compute frame size and padding */
525  max_frame_size = s->frame_size;
526  s->frame_frac += s->frame_frac_incr;
527  if (s->frame_frac >= 65536) {
528  s->frame_frac -= 65536;
529  s->do_padding = 1;
530  max_frame_size += 8;
531  } else {
532  s->do_padding = 0;
533  }
534 
535  /* compute the header + bit alloc size */
536  current_frame_size = 32;
537  alloc = s->alloc_table;
538  for(i=0;i<s->sblimit;i++) {
539  incr = alloc[0];
540  current_frame_size += incr * s->nb_channels;
541  alloc += 1 << incr;
542  }
543  for(;;) {
544  /* look for the subband with the largest signal to mask ratio */
545  max_sb = -1;
546  max_ch = -1;
547  max_smr = INT_MIN;
548  for(ch=0;ch<s->nb_channels;ch++) {
549  for(i=0;i<s->sblimit;i++) {
550  if (smr[ch][i] > max_smr && subband_status[ch][i] != SB_NOMORE) {
551  max_smr = smr[ch][i];
552  max_sb = i;
553  max_ch = ch;
554  }
555  }
556  }
557  if (max_sb < 0)
558  break;
559  ff_dlog(NULL, "current=%d max=%d max_sb=%d max_ch=%d alloc=%d\n",
560  current_frame_size, max_frame_size, max_sb, max_ch,
561  bit_alloc[max_ch][max_sb]);
562 
563  /* find alloc table entry (XXX: not optimal, should use
564  pointer table) */
565  alloc = s->alloc_table;
566  for(i=0;i<max_sb;i++) {
567  alloc += 1 << alloc[0];
568  }
569 
570  if (subband_status[max_ch][max_sb] == SB_NOTALLOCATED) {
571  /* nothing was coded for this band: add the necessary bits */
572  incr = 2 + nb_scale_factors[s->scale_code[max_ch][max_sb]] * 6;
573  incr += s->total_quant_bits[alloc[1]];
574  } else {
575  /* increments bit allocation */
576  b = bit_alloc[max_ch][max_sb];
577  incr = s->total_quant_bits[alloc[b + 1]] -
578  s->total_quant_bits[alloc[b]];
579  }
580 
581  if (current_frame_size + incr <= max_frame_size) {
582  /* can increase size */
583  b = ++bit_alloc[max_ch][max_sb];
584  current_frame_size += incr;
585  /* decrease smr by the resolution we added */
586  smr[max_ch][max_sb] = smr1[max_ch][max_sb] - quant_snr[alloc[b]];
587  /* max allocation size reached ? */
588  if (b == ((1 << alloc[0]) - 1))
589  subband_status[max_ch][max_sb] = SB_NOMORE;
590  else
591  subband_status[max_ch][max_sb] = SB_ALLOCATED;
592  } else {
593  /* cannot increase the size of this subband */
594  subband_status[max_ch][max_sb] = SB_NOMORE;
595  }
596  }
597  *padding = max_frame_size - current_frame_size;
598  av_assert0(*padding >= 0);
599 }
600 
601 /*
602  * Output the MPEG audio layer 2 frame. Note how the code is small
603  * compared to other encoders :-)
604  */
606  unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
607  int padding)
608 {
609  int i, j, k, l, bit_alloc_bits, b, ch;
610  unsigned char *sf;
611  int q[3];
612  PutBitContext *p = &s->pb;
613 
614  /* header */
615 
616  put_bits(p, 12, 0xfff);
617  put_bits(p, 1, 1 - s->lsf); /* 1 = MPEG-1 ID, 0 = MPEG-2 lsf ID */
618  put_bits(p, 2, 4-2); /* layer 2 */
619  put_bits(p, 1, 1); /* no error protection */
620  put_bits(p, 4, s->bitrate_index);
621  put_bits(p, 2, s->freq_index);
622  put_bits(p, 1, s->do_padding); /* use padding */
623  put_bits(p, 1, 0); /* private_bit */
624  put_bits(p, 2, s->nb_channels == 2 ? MPA_STEREO : MPA_MONO);
625  put_bits(p, 2, 0); /* mode_ext */
626  put_bits(p, 1, 0); /* no copyright */
627  put_bits(p, 1, 1); /* original */
628  put_bits(p, 2, 0); /* no emphasis */
629 
630  /* bit allocation */
631  j = 0;
632  for(i=0;i<s->sblimit;i++) {
633  bit_alloc_bits = s->alloc_table[j];
634  for(ch=0;ch<s->nb_channels;ch++) {
635  put_bits(p, bit_alloc_bits, bit_alloc[ch][i]);
636  }
637  j += 1 << bit_alloc_bits;
638  }
639 
640  /* scale codes */
641  for(i=0;i<s->sblimit;i++) {
642  for(ch=0;ch<s->nb_channels;ch++) {
643  if (bit_alloc[ch][i])
644  put_bits(p, 2, s->scale_code[ch][i]);
645  }
646  }
647 
648  /* scale factors */
649  for(i=0;i<s->sblimit;i++) {
650  for(ch=0;ch<s->nb_channels;ch++) {
651  if (bit_alloc[ch][i]) {
652  sf = &s->scale_factors[ch][i][0];
653  switch(s->scale_code[ch][i]) {
654  case 0:
655  put_bits(p, 6, sf[0]);
656  put_bits(p, 6, sf[1]);
657  put_bits(p, 6, sf[2]);
658  break;
659  case 3:
660  case 1:
661  put_bits(p, 6, sf[0]);
662  put_bits(p, 6, sf[2]);
663  break;
664  case 2:
665  put_bits(p, 6, sf[0]);
666  break;
667  }
668  }
669  }
670  }
671 
672  /* quantization & write sub band samples */
673 
674  for(k=0;k<3;k++) {
675  for(l=0;l<12;l+=3) {
676  j = 0;
677  for(i=0;i<s->sblimit;i++) {
678  bit_alloc_bits = s->alloc_table[j];
679  for(ch=0;ch<s->nb_channels;ch++) {
680  b = bit_alloc[ch][i];
681  if (b) {
682  int qindex, steps, m, sample, bits;
683  /* we encode 3 sub band samples of the same sub band at a time */
684  qindex = s->alloc_table[j+b];
685  steps = ff_mpa_quant_steps[qindex];
686  for(m=0;m<3;m++) {
687  sample = s->sb_samples[ch][k][l + m][i];
688  /* divide by scale factor */
689 #if USE_FLOATS
690  {
691  float a;
692  a = (float)sample * s->scale_factor_inv_table[s->scale_factors[ch][i][k]];
693  q[m] = (int)((a + 1.0) * steps * 0.5);
694  }
695 #else
696  {
697  int q1, e, shift, mult;
698  e = s->scale_factors[ch][i][k];
699  shift = s->scale_factor_shift[e];
700  mult = s->scale_factor_mult[e];
701 
702  /* normalize to P bits */
703  if (shift < 0)
704  q1 = sample << (-shift);
705  else
706  q1 = sample >> shift;
707  q1 = (q1 * mult) >> P;
708  q1 += 1 << P;
709  if (q1 < 0)
710  q1 = 0;
711  q[m] = (q1 * (unsigned)steps) >> (P + 1);
712  }
713 #endif
714  if (q[m] >= steps)
715  q[m] = steps - 1;
716  av_assert2(q[m] >= 0 && q[m] < steps);
717  }
718  bits = ff_mpa_quant_bits[qindex];
719  if (bits < 0) {
720  /* group the 3 values to save bits */
721  put_bits(p, -bits,
722  q[0] + steps * (q[1] + steps * q[2]));
723  } else {
724  put_bits(p, bits, q[0]);
725  put_bits(p, bits, q[1]);
726  put_bits(p, bits, q[2]);
727  }
728  }
729  }
730  /* next subband in alloc table */
731  j += 1 << bit_alloc_bits;
732  }
733  }
734  }
735 
736  /* padding */
737  for(i=0;i<padding;i++)
738  put_bits(p, 1, 0);
739 
740  /* flush */
741  flush_put_bits(p);
742 }
743 
744 static int MPA_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
745  const AVFrame *frame, int *got_packet_ptr)
746 {
747  MpegAudioContext *s = avctx->priv_data;
748  const int16_t *samples = (const int16_t *)frame->data[0];
749  short smr[MPA_MAX_CHANNELS][SBLIMIT];
750  unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
751  int padding, i, ret;
752 
753  for(i=0;i<s->nb_channels;i++) {
754  filter(s, i, samples + i, s->nb_channels);
755  }
756 
757  for(i=0;i<s->nb_channels;i++) {
759  s->sb_samples[i], s->sblimit);
760  }
761  for(i=0;i<s->nb_channels;i++) {
762  psycho_acoustic_model(s, smr[i]);
763  }
764  compute_bit_allocation(s, smr, bit_alloc, &padding);
765 
766  if ((ret = ff_alloc_packet2(avctx, avpkt, MPA_MAX_CODED_FRAME_SIZE, 0)) < 0)
767  return ret;
768 
769  init_put_bits(&s->pb, avpkt->data, avpkt->size);
770 
771  encode_frame(s, bit_alloc, padding);
772 
773  if (frame->pts != AV_NOPTS_VALUE)
774  avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
775 
776  avpkt->size = put_bits_count(&s->pb) / 8;
777  *got_packet_ptr = 1;
778  return 0;
779 }
780 
781 static const AVCodecDefault mp2_defaults[] = {
782  { "b", "0" },
783  { NULL },
784 };
785 
#define MPA_STEREO
Definition: mpegaudio.h:46
#define MPA_MAX_CODED_FRAME_SIZE
Definition: mpegaudio.h:40
#define NULL
Definition: coverity.c:32
#define WFRAC_BITS
#define P
static int shift(int a, int b)
Definition: sonic.c:82
#define SBLIMIT
Definition: mpegaudio.h:44
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
unsigned char scale_diff_table[128]
static const unsigned char nb_scale_factors[4]
Definition: mpegaudiotab.h:100
unsigned short scale_factor_mult[64]
#define SB_NOMORE
channels
Definition: aptx.c:30
int size
Definition: avcodec.h:1481
unsigned short total_quant_bits[17]
int av_log2(unsigned v)
Definition: intmath.c:26
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:36
const int ff_mpa_quant_bits[17]
Definition: mpegaudiodata.c:55
static const uint8_t q1[256]
Definition: twofish.c:96
#define sample
mpeg audio layer common tables.
const int32_t ff_mpa_enwindow[257]
static int MPA_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
#define av_cold
Definition: attributes.h:82
static const AVCodecDefault mp2_defaults[]
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
static const int costab32[30]
Definition: mpegaudiotab.h:36
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
const int ff_mpa_quant_steps[17]
Definition: mpegaudiodata.c:47
const uint16_t avpriv_mpa_freq_tab[3]
Definition: mpegaudiodata.c:40
const unsigned char *const ff_mpa_alloc_tables[5]
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3]
mpeg audio layer 2 tables.
uint8_t * data
Definition: avcodec.h:1480
#define ff_dlog(a,...)
static void compute_bit_allocation(MpegAudioContext *s, short smr1[MPA_MAX_CHANNELS][SBLIMIT], unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT], int *padding)
#define FIX(x)
Definition: jrevdct.c:146
unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT]
static int bit_alloc(AC3EncodeContext *s, int snr_offset)
Run the bit allocation with a given SNR offset.
Definition: ac3enc.c:1064
static const unsigned short quant_snr[17]
Definition: mpegaudiotab.h:83
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
static av_cold int MPA_encode_init(AVCodecContext *avctx)
#define SB_NOTALLOCATED
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void compute_scale_factors(MpegAudioContext *s, unsigned char scale_code[SBLIMIT], unsigned char scale_factors[SBLIMIT][3], int sb_samples[3][12][SBLIMIT], int sblimit)
#define SB_ALLOCATED
int initial_padding
Audio only.
Definition: avcodec.h:3099
#define t1
Definition: regdef.h:29
static const int bitinv32[32]
Definition: mpegaudiotab.h:72
uint8_t bits
Definition: vp3data.h:202
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
const unsigned char * alloc_table
#define MPA_MAX_CHANNELS
Definition: mpegaudio.h:42
#define b
Definition: input.c:41
audio channel layout utility functions
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
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 s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:760
static void encode_frame(MpegAudioContext *s, unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT], int padding)
#define MUL(a, b)
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2248
Libavcodec external API header.
int samples_offset[MPA_MAX_CHANNELS]
int sample_rate
samples per second
Definition: avcodec.h:2228
#define abs(x)
Definition: cuda_runtime.h:35
static const float fixed_smr[SBLIMIT]
Definition: mpegaudiotab.h:93
main external API structure.
Definition: avcodec.h:1568
int index
Definition: gxfenc.c:89
#define WSHIFT
#define MPA_MONO
Definition: mpegaudio.h:49
short samples_buf[MPA_MAX_CHANNELS][SAMPLES_BUF_SIZE]
static void idct32(int *out, int *tab)
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
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 * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
#define M_SQRT2
Definition: mathematics.h:61
int64_t bitrate
Definition: h264_levels.c:131
int
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
#define exp2(x)
Definition: libm.h:288
mpeg audio declarations for both encoder and decoder.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
const int ff_mpa_sblimit_table[5]
Definition: mpegaudiodata.c:45
static void psycho_acoustic_model(MpegAudioContext *s, short smr[SBLIMIT])
void * priv_data
Definition: avcodec.h:1595
int ff_mpa_l2_select_table(int bitrate, int nb_channels, int freq, int lsf)
Definition: mpegaudio.c:31
int channels
number of audio channels
Definition: avcodec.h:2229
static const struct twinvq_data tab
FILE * out
Definition: movenc.c:54
Filter the word “frame” indicates either a video frame or a group of audio samples
const uint16_t avpriv_mpa_bitrate_tab[2][3][15]
Definition: mpegaudiodata.c:30
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: internal.h:288
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
int sb_samples[MPA_MAX_CHANNELS][3][12][SBLIMIT]
#define MPA_FRAME_SIZE
Definition: mpegaudio.h:37
This structure stores compressed data.
Definition: avcodec.h:1457
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define SAMPLES_BUF_SIZE
static uint8_t tmp[11]
Definition: aes_ctr.c:26
bitstream writer API