LCOV - code coverage report
Current view: top level - libavcodec - mpegaudioenc_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 395 410 96.3 %
Date: 2017-12-18 06:23:41 Functions: 8 8 100.0 %

          Line data    Source code
       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             : 
      27             : #include "libavutil/channel_layout.h"
      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 {
      48             :     PutBitContext pb;
      49             :     int nb_channels;
      50             :     int lsf;           /* 1 if mpeg2 low bitrate selected */
      51             :     int bitrate_index; /* bit rate */
      52             :     int freq_index;
      53             :     int frame_size; /* frame size, in bits, without padding */
      54             :     /* padding computation */
      55             :     int frame_frac, frame_frac_incr, do_padding;
      56             :     short samples_buf[MPA_MAX_CHANNELS][SAMPLES_BUF_SIZE]; /* buffer for filter */
      57             :     int samples_offset[MPA_MAX_CHANNELS];       /* offset in samples_buf */
      58             :     int sb_samples[MPA_MAX_CHANNELS][3][12][SBLIMIT];
      59             :     unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3]; /* scale factors */
      60             :     /* code to group 3 scale factors */
      61             :     unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
      62             :     int sblimit; /* number of used subbands */
      63             :     const unsigned char *alloc_table;
      64             :     int16_t filter_bank[512];
      65             :     int scale_factor_table[64];
      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 */
      74             : } MpegAudioContext;
      75             : 
      76          16 : static av_cold int MPA_encode_init(AVCodecContext *avctx)
      77             : {
      78          16 :     MpegAudioContext *s = avctx->priv_data;
      79          16 :     int freq = avctx->sample_rate;
      80          16 :     int bitrate = avctx->bit_rate;
      81          16 :     int channels = avctx->channels;
      82             :     int i, v, table;
      83             :     float a;
      84             : 
      85          16 :     if (channels <= 0 || channels > 2){
      86           0 :         av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed in mp2\n", channels);
      87           0 :         return AVERROR(EINVAL);
      88             :     }
      89          16 :     bitrate = bitrate / 1000;
      90          16 :     s->nb_channels = channels;
      91          16 :     avctx->frame_size = MPA_FRAME_SIZE;
      92          16 :     avctx->initial_padding = 512 - 32 + 1;
      93             : 
      94             :     /* encoding freq */
      95          16 :     s->lsf = 0;
      96          16 :     for(i=0;i<3;i++) {
      97          16 :         if (avpriv_mpa_freq_tab[i] == freq)
      98          16 :             break;
      99           0 :         if ((avpriv_mpa_freq_tab[i] / 2) == freq) {
     100           0 :             s->lsf = 1;
     101           0 :             break;
     102             :         }
     103             :     }
     104          16 :     if (i == 3){
     105           0 :         av_log(avctx, AV_LOG_ERROR, "Sampling rate %d is not allowed in mp2\n", freq);
     106           0 :         return AVERROR(EINVAL);
     107             :     }
     108          16 :     s->freq_index = i;
     109             : 
     110             :     /* encoding bitrate & frequency */
     111         111 :     for(i=1;i<15;i++) {
     112         108 :         if (avpriv_mpa_bitrate_tab[s->lsf][1][i] == bitrate)
     113          13 :             break;
     114             :     }
     115          16 :     if (i == 15 && !avctx->bit_rate) {
     116           3 :         i = 14;
     117           3 :         bitrate = avpriv_mpa_bitrate_tab[s->lsf][1][i];
     118           3 :         avctx->bit_rate = bitrate * 1000;
     119             :     }
     120          16 :     if (i == 15){
     121           0 :         av_log(avctx, AV_LOG_ERROR, "bitrate %d is not allowed in mp2\n", bitrate);
     122           0 :         return AVERROR(EINVAL);
     123             :     }
     124          16 :     s->bitrate_index = i;
     125             : 
     126             :     /* compute total header size & pad bit */
     127             : 
     128          16 :     a = (float)(bitrate * 1000 * MPA_FRAME_SIZE) / (freq * 8.0);
     129          16 :     s->frame_size = ((int)a) * 8;
     130             : 
     131             :     /* frame fractional size to compute padding */
     132          16 :     s->frame_frac = 0;
     133          16 :     s->frame_frac_incr = (int)((a - floor(a)) * 65536.0);
     134             : 
     135             :     /* select the right allocation table */
     136          16 :     table = ff_mpa_l2_select_table(bitrate, s->nb_channels, freq, s->lsf);
     137             : 
     138             :     /* number of used subbands */
     139          16 :     s->sblimit = ff_mpa_sblimit_table[table];
     140          16 :     s->alloc_table = ff_mpa_alloc_tables[table];
     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          34 :     for(i=0;i<s->nb_channels;i++)
     146          18 :         s->samples_offset[i] = 0;
     147             : 
     148        4128 :     for(i=0;i<257;i++) {
     149             :         int v;
     150        4112 :         v = ff_mpa_enwindow[i];
     151             : #if WFRAC_BITS != 16
     152        4112 :         v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
     153             : #endif
     154        4112 :         s->filter_bank[i] = v;
     155        4112 :         if ((i & 63) != 0)
     156        4032 :             v = -v;
     157        4112 :         if (i != 0)
     158        4096 :             s->filter_bank[512 - i] = v;
     159             :     }
     160             : 
     161        1040 :     for(i=0;i<64;i++) {
     162        1024 :         v = (int)(exp2((3 - i) / 3.0) * (1 << 20));
     163        1024 :         if (v <= 0)
     164           0 :             v = 1;
     165        1024 :         s->scale_factor_table[i] = v;
     166             : #if USE_FLOATS
     167         768 :         s->scale_factor_inv_table[i] = exp2(-(3 - i) / 3.0) / (float)(1 << 20);
     168             : #else
     169             : #define P 15
     170         256 :         s->scale_factor_shift[i] = 21 - P - (i / 3);
     171         256 :         s->scale_factor_mult[i] = (1 << P) * exp2((i % 3) / 3.0);
     172             : #endif
     173             :     }
     174        2064 :     for(i=0;i<128;i++) {
     175        2048 :         v = i - 64;
     176        2048 :         if (v <= -3)
     177         992 :             v = 0;
     178        1056 :         else if (v < 0)
     179          32 :             v = 1;
     180        1024 :         else if (v == 0)
     181          16 :             v = 2;
     182        1008 :         else if (v < 3)
     183          32 :             v = 3;
     184             :         else
     185         976 :             v = 4;
     186        2048 :         s->scale_diff_table[i] = v;
     187             :     }
     188             : 
     189         288 :     for(i=0;i<17;i++) {
     190         272 :         v = ff_mpa_quant_bits[i];
     191         272 :         if (v < 0)
     192          48 :             v = -v;
     193             :         else
     194         224 :             v = v * 3;
     195         272 :         s->total_quant_bits[i] = 12 * v;
     196             :     }
     197             : 
     198          16 :     return 0;
     199             : }
     200             : 
     201             : /* 32 point floating point IDCT without 1/sqrt(2) coef zero scaling */
     202      131292 : static void idct32(int *out, int *tab)
     203             : {
     204             :     int i, j;
     205             :     int *t, *t1, xr;
     206      131292 :     const int *xp = costab32;
     207             : 
     208      131292 :     for(j=31;j>=3;j-=2) tab[j] += tab[j - 2];
     209             : 
     210      131292 :     t = tab + 30;
     211      131292 :     t1 = tab + 2;
     212             :     do {
     213      919044 :         t[0] += t[-4];
     214      919044 :         t[1] += t[1 - 4];
     215      919044 :         t -= 4;
     216      919044 :     } while (t != t1);
     217             : 
     218      131292 :     t = tab + 28;
     219      131292 :     t1 = tab + 4;
     220             :     do {
     221      393876 :         t[0] += t[-8];
     222      393876 :         t[1] += t[1-8];
     223      393876 :         t[2] += t[2-8];
     224      393876 :         t[3] += t[3-8];
     225      393876 :         t -= 8;
     226      393876 :     } while (t != t1);
     227             : 
     228      131292 :     t = tab;
     229      131292 :     t1 = tab + 32;
     230             :     do {
     231      262584 :         t[ 3] = -t[ 3];
     232      262584 :         t[ 6] = -t[ 6];
     233             : 
     234      262584 :         t[11] = -t[11];
     235      262584 :         t[12] = -t[12];
     236      262584 :         t[13] = -t[13];
     237      262584 :         t[15] = -t[15];
     238      262584 :         t += 16;
     239      262584 :     } while (t != t1);
     240             : 
     241             : 
     242      131292 :     t = tab;
     243      131292 :     t1 = tab + 8;
     244             :     do {
     245             :         int x1, x2, x3, x4;
     246             : 
     247     1050336 :         x3 = MUL(t[16], FIX(M_SQRT2*0.5));
     248     1050336 :         x4 = t[0] - x3;
     249     1050336 :         x3 = t[0] + x3;
     250             : 
     251     1050336 :         x2 = MUL(-(t[24] + t[8]), FIX(M_SQRT2*0.5));
     252     1050336 :         x1 = MUL((t[8] - x2), xp[0]);
     253     1050336 :         x2 = MUL((t[8] + x2), xp[1]);
     254             : 
     255     1050336 :         t[ 0] = x3 + x1;
     256     1050336 :         t[ 8] = x4 - x2;
     257     1050336 :         t[16] = x4 + x2;
     258     1050336 :         t[24] = x3 - x1;
     259     1050336 :         t++;
     260     1050336 :     } while (t != t1);
     261             : 
     262      131292 :     xp += 2;
     263      131292 :     t = tab;
     264      131292 :     t1 = tab + 4;
     265             :     do {
     266      525168 :         xr = MUL(t[28],xp[0]);
     267      525168 :         t[28] = (t[0] - xr);
     268      525168 :         t[0] = (t[0] + xr);
     269             : 
     270      525168 :         xr = MUL(t[4],xp[1]);
     271      525168 :         t[ 4] = (t[24] - xr);
     272      525168 :         t[24] = (t[24] + xr);
     273             : 
     274      525168 :         xr = MUL(t[20],xp[2]);
     275      525168 :         t[20] = (t[8] - xr);
     276      525168 :         t[ 8] = (t[8] + xr);
     277             : 
     278      525168 :         xr = MUL(t[12],xp[3]);
     279      525168 :         t[12] = (t[16] - xr);
     280      525168 :         t[16] = (t[16] + xr);
     281      525168 :         t++;
     282      525168 :     } while (t != t1);
     283      131292 :     xp += 4;
     284             : 
     285      656460 :     for (i = 0; i < 4; i++) {
     286      525168 :         xr = MUL(tab[30-i*4],xp[0]);
     287      525168 :         tab[30-i*4] = (tab[i*4] - xr);
     288      525168 :         tab[   i*4] = (tab[i*4] + xr);
     289             : 
     290      525168 :         xr = MUL(tab[ 2+i*4],xp[1]);
     291      525168 :         tab[ 2+i*4] = (tab[28-i*4] - xr);
     292      525168 :         tab[28-i*4] = (tab[28-i*4] + xr);
     293             : 
     294      525168 :         xr = MUL(tab[31-i*4],xp[0]);
     295      525168 :         tab[31-i*4] = (tab[1+i*4] - xr);
     296      525168 :         tab[ 1+i*4] = (tab[1+i*4] + xr);
     297             : 
     298      525168 :         xr = MUL(tab[ 3+i*4],xp[1]);
     299      525168 :         tab[ 3+i*4] = (tab[29-i*4] - xr);
     300      525168 :         tab[29-i*4] = (tab[29-i*4] + xr);
     301             : 
     302      525168 :         xp += 2;
     303             :     }
     304             : 
     305      131292 :     t = tab + 30;
     306      131292 :     t1 = tab + 1;
     307             :     do {
     308     2100672 :         xr = MUL(t1[0], *xp);
     309     2100672 :         t1[0] = (t[0] - xr);
     310     2100672 :         t[0] = (t[0] + xr);
     311     2100672 :         t -= 2;
     312     2100672 :         t1 += 2;
     313     2100672 :         xp++;
     314     2100672 :     } while (t >= tab);
     315             : 
     316     4332636 :     for(i=0;i<32;i++) {
     317     4201344 :         out[i] = tab[bitinv32[i]];
     318             :     }
     319      131292 : }
     320             : 
     321             : #define WSHIFT (WFRAC_BITS + 15 - FRAC_BITS)
     322             : 
     323        3647 : 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        3647 :     offset = s->samples_offset[ch];
     332        3647 :     out = &s->sb_samples[ch][0][0][0];
     333      134939 :     for(j=0;j<36;j++) {
     334             :         /* 32 samples at once */
     335     4332636 :         for(i=0;i<32;i++) {
     336     4201344 :             s->samples_buf[ch][offset + (31 - i)] = samples[0];
     337     4201344 :             samples += incr;
     338             :         }
     339             : 
     340             :         /* filter */
     341      131292 :         p = s->samples_buf[ch] + offset;
     342      131292 :         q = s->filter_bank;
     343             :         /* maxsum = 23169 */
     344     8533980 :         for(i=0;i<64;i++) {
     345     8402688 :             sum = p[0*64] * q[0*64];
     346     8402688 :             sum += p[1*64] * q[1*64];
     347     8402688 :             sum += p[2*64] * q[2*64];
     348     8402688 :             sum += p[3*64] * q[3*64];
     349     8402688 :             sum += p[4*64] * q[4*64];
     350     8402688 :             sum += p[5*64] * q[5*64];
     351     8402688 :             sum += p[6*64] * q[6*64];
     352     8402688 :             sum += p[7*64] * q[7*64];
     353     8402688 :             tmp[i] = sum;
     354     8402688 :             p++;
     355     8402688 :             q++;
     356             :         }
     357      131292 :         tmp1[0] = tmp[16] >> WSHIFT;
     358      131292 :         for( i=1; i<=16; i++ ) tmp1[i] = (tmp[i+16]+tmp[16-i]) >> WSHIFT;
     359      131292 :         for( i=17; i<=31; i++ ) tmp1[i] = (tmp[i+16]-tmp[80-i]) >> WSHIFT;
     360             : 
     361      131292 :         idct32(out, tmp1);
     362             : 
     363             :         /* advance of 32 samples */
     364      131292 :         offset -= 32;
     365      131292 :         out += 32;
     366             :         /* handle the wrap around */
     367      131292 :         if (offset < 0) {
     368        1174 :             memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32),
     369        1174 :                     s->samples_buf[ch], (512 - 32) * 2);
     370        1174 :             offset = SAMPLES_BUF_SIZE - 512;
     371             :         }
     372             :     }
     373        3647 :     s->samples_offset[ch] = offset;
     374        3647 : }
     375             : 
     376        3647 : static void compute_scale_factors(MpegAudioContext *s,
     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        3647 :     unsigned char *sf = &scale_factors[0][0];
     385             : 
     386      110390 :     for(j=0;j<sblimit;j++) {
     387      426972 :         for(i=0;i<3;i++) {
     388             :             /* find the max absolute value */
     389      320229 :             p = &sb_samples[i][0][j];
     390      320229 :             vmax = abs(*p);
     391     3842748 :             for(k=1;k<12;k++) {
     392     3522519 :                 p += SBLIMIT;
     393     3522519 :                 v = abs(*p);
     394     3522519 :                 if (v > vmax)
     395      590535 :                     vmax = v;
     396             :             }
     397             :             /* compute the scale factor index using log 2 computations */
     398      320229 :             if (vmax > 1) {
     399      320185 :                 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      320185 :                 index = (21 - n) * 3 - 3;
     403      320185 :                 if (index >= 0) {
     404     1043803 :                     while (vmax <= s->scale_factor_table[index+1])
     405      403433 :                         index++;
     406             :                 } else {
     407           0 :                     index = 0; /* very unlikely case of overflow */
     408             :                 }
     409             :             } else {
     410          44 :                 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      320229 :             sf[i] = index;
     418             :         }
     419             : 
     420             :         /* compute the transmission factor : look if the scale factors
     421             :            are close enough to each other */
     422      106743 :         d1 = s->scale_diff_table[sf[0] - sf[1] + 64];
     423      106743 :         d2 = s->scale_diff_table[sf[1] - sf[2] + 64];
     424             : 
     425             :         /* handle the 25 cases */
     426      106743 :         switch(d1 * 5 + d2) {
     427        2564 :         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        2564 :             code = 0;
     433        2564 :             break;
     434        2291 :         case 0*5+1:
     435             :         case 0*5+2:
     436             :         case 4*5+1:
     437             :         case 4*5+2:
     438        2291 :             code = 3;
     439        2291 :             sf[2] = sf[1];
     440        2291 :             break;
     441        1652 :         case 0*5+3:
     442             :         case 4*5+3:
     443        1652 :             code = 3;
     444        1652 :             sf[1] = sf[2];
     445        1652 :             break;
     446        2095 :         case 1*5+0:
     447             :         case 1*5+4:
     448             :         case 2*5+4:
     449        2095 :             code = 1;
     450        2095 :             sf[1] = sf[0];
     451        2095 :             break;
     452       47894 :         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       47894 :             code = 2;
     458       47894 :             sf[1] = sf[2] = sf[0];
     459       47894 :             break;
     460       14012 :         case 2*5+3:
     461             :         case 3*5+3:
     462       14012 :             code = 2;
     463       14012 :             sf[0] = sf[1] = sf[2];
     464       14012 :             break;
     465       23576 :         case 3*5+0:
     466             :         case 3*5+1:
     467             :         case 3*5+2:
     468       23576 :             code = 2;
     469       23576 :             sf[0] = sf[2] = sf[1];
     470       23576 :             break;
     471       12659 :         case 1*5+3:
     472       12659 :             code = 2;
     473       12659 :             if (sf[0] > sf[2])
     474        2198 :               sf[0] = sf[2];
     475       12659 :             sf[1] = sf[2] = sf[0];
     476       12659 :             break;
     477           0 :         default:
     478             :             av_assert2(0); //cannot happen
     479           0 :             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      106743 :         scale_code[j] = code;
     485      106743 :         sf += 3;
     486             :     }
     487        3647 : }
     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. */
     492        3647 : static void psycho_acoustic_model(MpegAudioContext *s, short smr[SBLIMIT])
     493             : {
     494             :     int i;
     495             : 
     496      110390 :     for(i=0;i<s->sblimit;i++) {
     497      106743 :         smr[i] = (int)(fixed_smr[i] * 10);
     498             :     }
     499        3647 : }
     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 :-) */
     509        3187 : static void compute_bit_allocation(MpegAudioContext *s,
     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        3187 :     memcpy(smr, smr1, s->nb_channels * sizeof(short) * SBLIMIT);
     521        3187 :     memset(subband_status, SB_NOTALLOCATED, s->nb_channels * SBLIMIT);
     522        3187 :     memset(bit_alloc, 0, s->nb_channels * SBLIMIT);
     523             : 
     524             :     /* compute frame size and padding */
     525        3187 :     max_frame_size = s->frame_size;
     526        3187 :     s->frame_frac += s->frame_frac_incr;
     527        3187 :     if (s->frame_frac >= 65536) {
     528        2855 :         s->frame_frac -= 65536;
     529        2855 :         s->do_padding = 1;
     530        2855 :         max_frame_size += 8;
     531             :     } else {
     532         332 :         s->do_padding = 0;
     533             :     }
     534             : 
     535             :     /* compute the header + bit alloc size */
     536        3187 :     current_frame_size = 32;
     537        3187 :     alloc = s->alloc_table;
     538       96820 :     for(i=0;i<s->sblimit;i++) {
     539       93633 :         incr = alloc[0];
     540       93633 :         current_frame_size += incr * s->nb_channels;
     541       93633 :         alloc += 1 << incr;
     542             :     }
     543             :     for(;;) {
     544             :         /* look for the subband with the largest signal to mask ratio */
     545     1276135 :         max_sb = -1;
     546      639661 :         max_ch = -1;
     547      639661 :         max_smr = INT_MIN;
     548     1372823 :         for(ch=0;ch<s->nb_channels;ch++) {
     549    22494100 :             for(i=0;i<s->sblimit;i++) {
     550    21760938 :                 if (smr[ch][i] > max_smr && subband_status[ch][i] != SB_NOMORE) {
     551     1701292 :                     max_smr = smr[ch][i];
     552     1701292 :                     max_sb = i;
     553     1701292 :                     max_ch = ch;
     554             :                 }
     555             :             }
     556             :         }
     557      639661 :         if (max_sb < 0)
     558        3187 :             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      636474 :         alloc = s->alloc_table;
     566     6376957 :         for(i=0;i<max_sb;i++) {
     567     5740483 :             alloc += 1 << alloc[0];
     568             :         }
     569             : 
     570      636474 :         if (subband_status[max_ch][max_sb] == SB_NOTALLOCATED) {
     571             :             /* nothing was coded for this band: add the necessary bits */
     572      106743 :             incr = 2 + nb_scale_factors[s->scale_code[max_ch][max_sb]] * 6;
     573      106743 :             incr += s->total_quant_bits[alloc[1]];
     574             :         } else {
     575             :             /* increments bit allocation */
     576      529731 :             b = bit_alloc[max_ch][max_sb];
     577     1059462 :             incr = s->total_quant_bits[alloc[b + 1]] -
     578      529731 :                 s->total_quant_bits[alloc[b]];
     579             :         }
     580             : 
     581      636474 :         if (current_frame_size + incr <= max_frame_size) {
     582             :             /* can increase size */
     583      549262 :             b = ++bit_alloc[max_ch][max_sb];
     584      549262 :             current_frame_size += incr;
     585             :             /* decrease smr by the resolution we added */
     586      549262 :             smr[max_ch][max_sb] = smr1[max_ch][max_sb] - quant_snr[alloc[b]];
     587             :             /* max allocation size reached ? */
     588      549262 :             if (b == ((1 << alloc[0]) - 1))
     589       19531 :                 subband_status[max_ch][max_sb] = SB_NOMORE;
     590             :             else
     591      529731 :                 subband_status[max_ch][max_sb] = SB_ALLOCATED;
     592             :         } else {
     593             :             /* cannot increase the size of this subband */
     594       87212 :             subband_status[max_ch][max_sb] = SB_NOMORE;
     595             :         }
     596             :     }
     597        3187 :     *padding = max_frame_size - current_frame_size;
     598        3187 :     av_assert0(*padding >= 0);
     599        3187 : }
     600             : 
     601             : /*
     602             :  * Output the MPEG audio layer 2 frame. Note how the code is small
     603             :  * compared to other encoders :-)
     604             :  */
     605        3187 : static void encode_frame(MpegAudioContext *s,
     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        3187 :     PutBitContext *p = &s->pb;
     613             : 
     614             :     /* header */
     615             : 
     616        3187 :     put_bits(p, 12, 0xfff);
     617        3187 :     put_bits(p, 1, 1 - s->lsf); /* 1 = MPEG-1 ID, 0 = MPEG-2 lsf ID */
     618        3187 :     put_bits(p, 2, 4-2);  /* layer 2 */
     619        3187 :     put_bits(p, 1, 1); /* no error protection */
     620        3187 :     put_bits(p, 4, s->bitrate_index);
     621        3187 :     put_bits(p, 2, s->freq_index);
     622        3187 :     put_bits(p, 1, s->do_padding); /* use padding */
     623        3187 :     put_bits(p, 1, 0);             /* private_bit */
     624        3187 :     put_bits(p, 2, s->nb_channels == 2 ? MPA_STEREO : MPA_MONO);
     625        3187 :     put_bits(p, 2, 0); /* mode_ext */
     626        3187 :     put_bits(p, 1, 0); /* no copyright */
     627        3187 :     put_bits(p, 1, 1); /* original */
     628        3187 :     put_bits(p, 2, 0); /* no emphasis */
     629             : 
     630             :     /* bit allocation */
     631        3187 :     j = 0;
     632       96820 :     for(i=0;i<s->sblimit;i++) {
     633       93633 :         bit_alloc_bits = s->alloc_table[j];
     634      200376 :         for(ch=0;ch<s->nb_channels;ch++) {
     635      106743 :             put_bits(p, bit_alloc_bits, bit_alloc[ch][i]);
     636             :         }
     637       93633 :         j += 1 << bit_alloc_bits;
     638             :     }
     639             : 
     640             :     /* scale codes */
     641       96820 :     for(i=0;i<s->sblimit;i++) {
     642      200376 :         for(ch=0;ch<s->nb_channels;ch++) {
     643      106743 :             if (bit_alloc[ch][i])
     644       73509 :                 put_bits(p, 2, s->scale_code[ch][i]);
     645             :         }
     646             :     }
     647             : 
     648             :     /* scale factors */
     649       96820 :     for(i=0;i<s->sblimit;i++) {
     650      200376 :         for(ch=0;ch<s->nb_channels;ch++) {
     651      106743 :             if (bit_alloc[ch][i]) {
     652       73509 :                 sf = &s->scale_factors[ch][i][0];
     653       73509 :                 switch(s->scale_code[ch][i]) {
     654        1570 :                 case 0:
     655        1570 :                     put_bits(p, 6, sf[0]);
     656        1570 :                     put_bits(p, 6, sf[1]);
     657        1570 :                     put_bits(p, 6, sf[2]);
     658        1570 :                     break;
     659        3730 :                 case 3:
     660             :                 case 1:
     661        3730 :                     put_bits(p, 6, sf[0]);
     662        3730 :                     put_bits(p, 6, sf[2]);
     663        3730 :                     break;
     664       68209 :                 case 2:
     665       68209 :                     put_bits(p, 6, sf[0]);
     666       68209 :                     break;
     667             :                 }
     668             :             }
     669             :         }
     670             :     }
     671             : 
     672             :     /* quantization & write sub band samples */
     673             : 
     674       12748 :     for(k=0;k<3;k++) {
     675       47805 :         for(l=0;l<12;l+=3) {
     676       38244 :             j = 0;
     677     1161840 :             for(i=0;i<s->sblimit;i++) {
     678     1123596 :                 bit_alloc_bits = s->alloc_table[j];
     679     2404512 :                 for(ch=0;ch<s->nb_channels;ch++) {
     680     1280916 :                     b = bit_alloc[ch][i];
     681     1280916 :                     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      882108 :                         qindex = s->alloc_table[j+b];
     685      882108 :                         steps = ff_mpa_quant_steps[qindex];
     686     3528432 :                         for(m=0;m<3;m++) {
     687     2646324 :                             sample = s->sb_samples[ch][k][l + m][i];
     688             :                             /* divide by scale factor */
     689             : #if USE_FLOATS
     690             :                             {
     691             :                                 float a;
     692      511668 :                                 a = (float)sample * s->scale_factor_inv_table[s->scale_factors[ch][i][k]];
     693      511668 :                                 q[m] = (int)((a + 1.0) * steps * 0.5);
     694             :                             }
     695             : #else
     696             :                             {
     697             :                                 int q1, e, shift, mult;
     698     2134656 :                                 e = s->scale_factors[ch][i][k];
     699     2134656 :                                 shift = s->scale_factor_shift[e];
     700     2134656 :                                 mult = s->scale_factor_mult[e];
     701             : 
     702             :                                 /* normalize to P bits */
     703     2134656 :                                 if (shift < 0)
     704     1916136 :                                     q1 = sample << (-shift);
     705             :                                 else
     706      218520 :                                     q1 = sample >> shift;
     707     2134656 :                                 q1 = (q1 * mult) >> P;
     708     2134656 :                                 q1 += 1 << P;
     709     2134656 :                                 if (q1 < 0)
     710           0 :                                     q1 = 0;
     711     2134656 :                                 q[m] = (q1 * (unsigned)steps) >> (P + 1);
     712             :                             }
     713             : #endif
     714     2646324 :                             if (q[m] >= steps)
     715        4530 :                                 q[m] = steps - 1;
     716             :                             av_assert2(q[m] >= 0 && q[m] < steps);
     717             :                         }
     718      882108 :                         bits = ff_mpa_quant_bits[qindex];
     719      882108 :                         if (bits < 0) {
     720             :                             /* group the 3 values to save bits */
     721      188232 :                             put_bits(p, -bits,
     722      188232 :                                      q[0] + steps * (q[1] + steps * q[2]));
     723             :                         } else {
     724      693876 :                             put_bits(p, bits, q[0]);
     725      693876 :                             put_bits(p, bits, q[1]);
     726      693876 :                             put_bits(p, bits, q[2]);
     727             :                         }
     728             :                     }
     729             :                 }
     730             :                 /* next subband in alloc table */
     731     1123596 :                 j += 1 << bit_alloc_bits;
     732             :             }
     733             :         }
     734             :     }
     735             : 
     736             :     /* padding */
     737       26811 :     for(i=0;i<padding;i++)
     738       23624 :         put_bits(p, 1, 0);
     739             : 
     740             :     /* flush */
     741        3187 :     flush_put_bits(p);
     742        3187 : }
     743             : 
     744        3187 : static int MPA_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     745             :                             const AVFrame *frame, int *got_packet_ptr)
     746             : {
     747        3187 :     MpegAudioContext *s = avctx->priv_data;
     748        3187 :     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        6834 :     for(i=0;i<s->nb_channels;i++) {
     754        3647 :         filter(s, i, samples + i, s->nb_channels);
     755             :     }
     756             : 
     757        6834 :     for(i=0;i<s->nb_channels;i++) {
     758        7294 :         compute_scale_factors(s, s->scale_code[i], s->scale_factors[i],
     759        3647 :                               s->sb_samples[i], s->sblimit);
     760             :     }
     761        6834 :     for(i=0;i<s->nb_channels;i++) {
     762        3647 :         psycho_acoustic_model(s, smr[i]);
     763             :     }
     764        3187 :     compute_bit_allocation(s, smr, bit_alloc, &padding);
     765             : 
     766        3187 :     if ((ret = ff_alloc_packet2(avctx, avpkt, MPA_MAX_CODED_FRAME_SIZE, 0)) < 0)
     767           0 :         return ret;
     768             : 
     769        3187 :     init_put_bits(&s->pb, avpkt->data, avpkt->size);
     770             : 
     771        3187 :     encode_frame(s, bit_alloc, padding);
     772             : 
     773        3187 :     if (frame->pts != AV_NOPTS_VALUE)
     774        3187 :         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
     775             : 
     776        3187 :     avpkt->size = put_bits_count(&s->pb) / 8;
     777        3187 :     *got_packet_ptr = 1;
     778        3187 :     return 0;
     779             : }
     780             : 
     781             : static const AVCodecDefault mp2_defaults[] = {
     782             :     { "b", "0" },
     783             :     { NULL },
     784             : };
     785             : 

Generated by: LCOV version 1.13