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