Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 11 Nov 2013 21:21:38 +0000 (22:21 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 11 Nov 2013 21:21:38 +0000 (22:21 +0100)
* qatar/master:
  mpegaudioenc: Move some static tables to MpegAudioContext

Conflicts:
libavcodec/mpegaudioenc.c
libavcodec/mpegaudiotab.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/mpegaudioenc.c
libavcodec/mpegaudiotab.h

@@@ -2,20 -2,20 +2,20 @@@
   * The simplest mpeg audio layer 2 encoder
   * Copyright (c) 2000, 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -33,9 -33,6 +33,9 @@@
  #define FRAC_BITS   15   /* fractional bits for sb_samples and dct */
  #define WFRAC_BITS  14   /* fractional bits for window */
  
 +/* define it to use floats in quantization (I don't like floats !) */
 +#define USE_FLOATS
 +
  #include "mpegaudio.h"
  #include "mpegaudiodsp.h"
  #include "mpegaudiodata.h"
@@@ -64,6 -61,11 +64,16 @@@ typedef struct MpegAudioContext 
      unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
      int sblimit; /* number of used subbands */
      const unsigned char *alloc_table;
+     int16_t filter_bank[512];
+     int scale_factor_table[64];
+     unsigned char scale_diff_table[128];
++#ifdef USE_FLOATS
+     float scale_factor_inv_table[64];
++#else
++    int8_t scale_factor_shift[64];
++    unsigned short scale_factor_mult[64];
++#endif
+     unsigned short total_quant_bits[17]; /* total number of bits per allocation group */
  } MpegAudioContext;
  
  static av_cold int MPA_encode_init(AVCodecContext *avctx)
  #if WFRAC_BITS != 16
          v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
  #endif
-         filter_bank[i] = v;
+         s->filter_bank[i] = v;
          if ((i & 63) != 0)
              v = -v;
          if (i != 0)
-             filter_bank[512 - i] = v;
+             s->filter_bank[512 - i] = v;
      }
  
      for(i=0;i<64;i++) {
 -        v = (int)(pow(2.0, (3 - i) / 3.0) * (1 << 20));
 +        v = (int)(exp2((3 - i) / 3.0) * (1 << 20));
          if (v <= 0)
              v = 1;
-         scale_factor_table[i] = v;
+         s->scale_factor_table[i] = v;
 -        s->scale_factor_inv_table[i] = pow(2.0, -(3 - i) / 3.0) / (float)(1 << 20);
 +#ifdef USE_FLOATS
-         scale_factor_inv_table[i] = exp2(-(3 - i) / 3.0) / (float)(1 << 20);
++        s->scale_factor_inv_table[i] = exp2(-(3 - i) / 3.0) / (float)(1 << 20);
 +#else
 +#define P 15
-         scale_factor_shift[i] = 21 - P - (i / 3);
-         scale_factor_mult[i] = (1 << P) * exp2((i % 3) / 3.0);
++        s->scale_factor_shift[i] = 21 - P - (i / 3);
++        s->scale_factor_mult[i] = (1 << P) * exp2((i % 3) / 3.0);
 +#endif
      }
      for(i=0;i<128;i++) {
          v = i - 64;
              v = 3;
          else
              v = 4;
-         scale_diff_table[i] = v;
+         s->scale_diff_table[i] = v;
      }
  
      for(i=0;i<17;i++) {
              v = -v;
          else
              v = v * 3;
-         total_quant_bits[i] = 12 * v;
+         s->total_quant_bits[i] = 12 * v;
      }
  
      return 0;
@@@ -327,7 -323,7 +337,7 @@@ static void filter(MpegAudioContext *s
  
          /* filter */
          p = s->samples_buf[ch] + offset;
-         q = filter_bank;
+         q = s->filter_bank;
          /* maxsum = 23169 */
          for(i=0;i<64;i++) {
              sum = p[0*64] * q[0*64];
      s->samples_offset[ch] = offset;
  }
  
- static void compute_scale_factors(unsigned char scale_code[SBLIMIT],
+ 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)
                     use at most 2 compares to find the index */
                  index = (21 - n) * 3 - 3;
                  if (index >= 0) {
-                     while (vmax <= scale_factor_table[index+1])
+                     while (vmax <= s->scale_factor_table[index+1])
                          index++;
                  } else {
                      index = 0; /* very unlikely case of overflow */
              }
  
              av_dlog(NULL, "%2d:%d in=%x %x %d\n",
-                     j, i, vmax, scale_factor_table[index], index);
+                     j, i, vmax, s->scale_factor_table[index], index);
              /* store the scale factor */
 -            assert(index >=0 && index <= 63);
 +            av_assert2(index >=0 && index <= 63);
              sf[i] = index;
          }
  
          /* compute the transmission factor : look if the scale factors
             are close enough to each other */
-         d1 = scale_diff_table[sf[0] - sf[1] + 64];
-         d2 = scale_diff_table[sf[1] - sf[2] + 64];
+         d1 = s->scale_diff_table[sf[0] - sf[1] + 64];
+         d2 = s->scale_diff_table[sf[1] - sf[2] + 64];
  
          /* handle the 25 cases */
          switch(d1 * 5 + d2) {
              sf[1] = sf[2] = sf[0];
              break;
          default:
 -            assert(0); //cannot happen
 +            av_assert2(0); //cannot happen
              code = 0;           /* kill warning */
          }
  
@@@ -557,12 -554,12 +568,12 @@@ static void compute_bit_allocation(Mpeg
          if (subband_status[max_ch][max_sb] == SB_NOTALLOCATED) {
              /* nothing was coded for this band: add the necessary bits */
              incr = 2 + nb_scale_factors[s->scale_code[max_ch][max_sb]] * 6;
-             incr += total_quant_bits[alloc[1]];
+             incr += s->total_quant_bits[alloc[1]];
          } else {
              /* increments bit allocation */
              b = bit_alloc[max_ch][max_sb];
-             incr = total_quant_bits[alloc[b + 1]] -
-                 total_quant_bits[alloc[b]];
+             incr = s->total_quant_bits[alloc[b + 1]] -
+                 s->total_quant_bits[alloc[b]];
          }
  
          if (current_frame_size + incr <= max_frame_size) {
          }
      }
      *padding = max_frame_size - current_frame_size;
 -    assert(*padding >= 0);
 +    av_assert0(*padding >= 0);
  }
  
  /*
@@@ -671,33 -668,14 +682,33 @@@ static void encode_frame(MpegAudioConte
                          qindex = s->alloc_table[j+b];
                          steps = ff_mpa_quant_steps[qindex];
                          for(m=0;m<3;m++) {
 -                            float a;
                              sample = s->sb_samples[ch][k][l + m][i];
                              /* divide by scale factor */
 -                            a = (float)sample * s->scale_factor_inv_table[s->scale_factors[ch][i][k]];
 -                            q[m] = (int)((a + 1.0) * steps * 0.5);
 +#ifdef USE_FLOATS
 +                            {
 +                                float a;
-                                 a = (float)sample * scale_factor_inv_table[s->scale_factors[ch][i][k]];
++                                a = (float)sample * s->scale_factor_inv_table[s->scale_factors[ch][i][k]];
 +                                q[m] = (int)((a + 1.0) * steps * 0.5);
 +                            }
 +#else
 +                            {
 +                                int q1, e, shift, mult;
 +                                e = s->scale_factors[ch][i][k];
-                                 shift = scale_factor_shift[e];
-                                 mult = scale_factor_mult[e];
++                                shift = s->scale_factor_shift[e];
++                                mult = s->scale_factor_mult[e];
 +
 +                                /* normalize to P bits */
 +                                if (shift < 0)
 +                                    q1 = sample << (-shift);
 +                                else
 +                                    q1 = sample >> shift;
 +                                q1 = (q1 * mult) >> P;
 +                                q[m] = ((q1 + (1 << P)) * steps) >> (P + 1);
 +                            }
 +#endif
                              if (q[m] >= steps)
                                  q[m] = steps - 1;
 -                            assert(q[m] >= 0 && q[m] < steps);
 +                            av_assert2(q[m] >= 0 && q[m] < steps);
                          }
                          bits = ff_mpa_quant_bits[qindex];
                          if (bits < 0) {
@@@ -739,7 -717,7 +750,7 @@@ static int MPA_encode_frame(AVCodecCont
      }
  
      for(i=0;i<s->nb_channels;i++) {
-         compute_scale_factors(s->scale_code[i], s->scale_factors[i],
+         compute_scale_factors(s, s->scale_code[i], s->scale_factors[i],
                                s->sb_samples[i], s->sblimit);
      }
      for(i=0;i<s->nb_channels;i++) {
      }
      compute_bit_allocation(s, smr, bit_alloc, &padding);
  
 -    if ((ret = ff_alloc_packet(avpkt, MPA_MAX_CODED_FRAME_SIZE))) {
 -        av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, MPA_MAX_CODED_FRAME_SIZE)) < 0)
          return ret;
 -    }
  
      init_put_bits(&s->pb, avpkt->data, avpkt->size);
  
@@@ -4,20 -4,20 +4,20 @@@
   *
   * Copyright (c) 2000, 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -79,20 -79,6 +79,6 @@@ static const int bitinv32[32] = 
  };
  
  
- static int16_t filter_bank[512];
- static int scale_factor_table[64];
- #ifdef USE_FLOATS
- static float scale_factor_inv_table[64];
- #else
- static int8_t scale_factor_shift[64];
- static unsigned short scale_factor_mult[64];
- #endif
- static unsigned char scale_diff_table[128];
- /* total number of bits per allocation group */
- static unsigned short total_quant_bits[17];
  /* signal to noise ratio of each quantification step (could be
     computed from quant_steps[]). The values are dB multiplied by 10
  */