"Fossies" - the Fresh Open Source Software Archive

Member "ffmpeg-3.4.2/libavcodec/aacdec_fixed.c" (12 Feb 2018, 14174 Bytes) of package /linux/misc/ffmpeg-3.4.2.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "aacdec_fixed.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 3.4_vs_3.4.1.

    1 /*
    2  * Copyright (c) 2013
    3  *      MIPS Technologies, Inc., California.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
   14  *    contributors may be used to endorse or promote products derived from
   15  *    this software without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  * AAC decoder fixed-point implementation
   30  *
   31  * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
   32  * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
   33  *
   34  * This file is part of FFmpeg.
   35  *
   36  * FFmpeg is free software; you can redistribute it and/or
   37  * modify it under the terms of the GNU Lesser General Public
   38  * License as published by the Free Software Foundation; either
   39  * version 2.1 of the License, or (at your option) any later version.
   40  *
   41  * FFmpeg is distributed in the hope that it will be useful,
   42  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   43  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   44  * Lesser General Public License for more details.
   45  *
   46  * You should have received a copy of the GNU Lesser General Public
   47  * License along with FFmpeg; if not, write to the Free Software
   48  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   49  */
   50 
   51 /**
   52  * @file
   53  * AAC decoder
   54  * @author Oded Shimon  ( ods15 ods15 dyndns org )
   55  * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
   56  *
   57  * Fixed point implementation
   58  * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
   59  */
   60 
   61 #define FFT_FLOAT 0
   62 #define FFT_FIXED_32 1
   63 #define USE_FIXED 1
   64 
   65 #include "libavutil/fixed_dsp.h"
   66 #include "libavutil/opt.h"
   67 #include "avcodec.h"
   68 #include "internal.h"
   69 #include "get_bits.h"
   70 #include "fft.h"
   71 #include "lpc.h"
   72 #include "kbdwin.h"
   73 #include "sinewin.h"
   74 
   75 #include "aac.h"
   76 #include "aactab.h"
   77 #include "aacdectab.h"
   78 #include "cbrt_data.h"
   79 #include "sbr.h"
   80 #include "aacsbr.h"
   81 #include "mpeg4audio.h"
   82 #include "aacadtsdec.h"
   83 #include "profiles.h"
   84 #include "libavutil/intfloat.h"
   85 
   86 #include <math.h>
   87 #include <string.h>
   88 
   89 static av_always_inline void reset_predict_state(PredictorState *ps)
   90 {
   91     ps->r0.mant   = 0;
   92     ps->r0.exp   = 0;
   93     ps->r1.mant   = 0;
   94     ps->r1.exp   = 0;
   95     ps->cor0.mant = 0;
   96     ps->cor0.exp = 0;
   97     ps->cor1.mant = 0;
   98     ps->cor1.exp = 0;
   99     ps->var0.mant = 0x20000000;
  100     ps->var0.exp = 1;
  101     ps->var1.mant = 0x20000000;
  102     ps->var1.exp = 1;
  103 }
  104 
  105 static const int exp2tab[4] = { Q31(1.0000000000/2), Q31(1.1892071150/2), Q31(1.4142135624/2), Q31(1.6817928305/2) };  // 2^0, 2^0.25, 2^0.5, 2^0.75
  106 
  107 static inline int *DEC_SPAIR(int *dst, unsigned idx)
  108 {
  109     dst[0] = (idx & 15) - 4;
  110     dst[1] = (idx >> 4 & 15) - 4;
  111 
  112     return dst + 2;
  113 }
  114 
  115 static inline int *DEC_SQUAD(int *dst, unsigned idx)
  116 {
  117     dst[0] = (idx & 3) - 1;
  118     dst[1] = (idx >> 2 & 3) - 1;
  119     dst[2] = (idx >> 4 & 3) - 1;
  120     dst[3] = (idx >> 6 & 3) - 1;
  121 
  122     return dst + 4;
  123 }
  124 
  125 static inline int *DEC_UPAIR(int *dst, unsigned idx, unsigned sign)
  126 {
  127     dst[0] = (idx & 15) * (1 - (sign & 0xFFFFFFFE));
  128     dst[1] = (idx >> 4 & 15) * (1 - ((sign & 1) * 2));
  129 
  130     return dst + 2;
  131 }
  132 
  133 static inline int *DEC_UQUAD(int *dst, unsigned idx, unsigned sign)
  134 {
  135     unsigned nz = idx >> 12;
  136 
  137     dst[0] = (idx & 3) * (1 + (((int)sign >> 31) * 2));
  138     sign <<= nz & 1;
  139     nz >>= 1;
  140     dst[1] = (idx >> 2 & 3) * (1 + (((int)sign >> 31) * 2));
  141     sign <<= nz & 1;
  142     nz >>= 1;
  143     dst[2] = (idx >> 4 & 3) * (1 + (((int)sign >> 31) * 2));
  144     sign <<= nz & 1;
  145     nz >>= 1;
  146     dst[3] = (idx >> 6 & 3) * (1 + (((int)sign >> 31) * 2));
  147 
  148     return dst + 4;
  149 }
  150 
  151 static void vector_pow43(int *coefs, int len)
  152 {
  153     int i, coef;
  154 
  155     for (i=0; i<len; i++) {
  156         coef = coefs[i];
  157         if (coef < 0)
  158             coef = -(int)ff_cbrt_tab_fixed[-coef];
  159         else
  160             coef = (int)ff_cbrt_tab_fixed[coef];
  161         coefs[i] = coef;
  162     }
  163 }
  164 
  165 static void subband_scale(int *dst, int *src, int scale, int offset, int len)
  166 {
  167     int ssign = scale < 0 ? -1 : 1;
  168     int s = FFABS(scale);
  169     unsigned int round;
  170     int i, out, c = exp2tab[s & 3];
  171 
  172     s = offset - (s >> 2);
  173 
  174     if (s > 31) {
  175         for (i=0; i<len; i++) {
  176             dst[i] = 0;
  177         }
  178     } else if (s > 0) {
  179         round = 1 << (s-1);
  180         for (i=0; i<len; i++) {
  181             out = (int)(((int64_t)src[i] * c) >> 32);
  182             dst[i] = ((int)(out+round) >> s) * ssign;
  183         }
  184     } else if (s > -32) {
  185         s = s + 32;
  186         round = 1U << (s-1);
  187         for (i=0; i<len; i++) {
  188             out = (int)((int64_t)((int64_t)src[i] * c + round) >> s);
  189             dst[i] = out * (unsigned)ssign;
  190         }
  191     } else {
  192         av_log(NULL, AV_LOG_ERROR, "Overflow in subband_scale()\n");
  193     }
  194 }
  195 
  196 static void noise_scale(int *coefs, int scale, int band_energy, int len)
  197 {
  198     int ssign = scale < 0 ? -1 : 1;
  199     int s = FFABS(scale);
  200     unsigned int round;
  201     int i, out, c = exp2tab[s & 3];
  202     int nlz = 0;
  203 
  204     while (band_energy > 0x7fff) {
  205         band_energy >>= 1;
  206         nlz++;
  207     }
  208     c /= band_energy;
  209     s = 21 + nlz - (s >> 2);
  210 
  211     if (s > 31) {
  212         for (i=0; i<len; i++) {
  213             coefs[i] = 0;
  214         }
  215     } else if (s >= 0) {
  216         round = s ? 1 << (s-1) : 0;
  217         for (i=0; i<len; i++) {
  218             out = (int)(((int64_t)coefs[i] * c) >> 32);
  219             coefs[i] = ((int)(out+round) >> s) * ssign;
  220         }
  221     }
  222     else {
  223         s = s + 32;
  224         round = 1 << (s-1);
  225         for (i=0; i<len; i++) {
  226             out = (int)((int64_t)((int64_t)coefs[i] * c + round) >> s);
  227             coefs[i] = out * ssign;
  228         }
  229     }
  230 }
  231 
  232 static av_always_inline SoftFloat flt16_round(SoftFloat pf)
  233 {
  234     SoftFloat tmp;
  235     int s;
  236 
  237     tmp.exp = pf.exp;
  238     s = pf.mant >> 31;
  239     tmp.mant = (pf.mant ^ s) - s;
  240     tmp.mant = (tmp.mant + 0x00200000U) & 0xFFC00000U;
  241     tmp.mant = (tmp.mant ^ s) - s;
  242 
  243     return tmp;
  244 }
  245 
  246 static av_always_inline SoftFloat flt16_even(SoftFloat pf)
  247 {
  248     SoftFloat tmp;
  249     int s;
  250 
  251     tmp.exp = pf.exp;
  252     s = pf.mant >> 31;
  253     tmp.mant = (pf.mant ^ s) - s;
  254     tmp.mant = (tmp.mant + 0x001FFFFFU + (tmp.mant & 0x00400000U >> 16)) & 0xFFC00000U;
  255     tmp.mant = (tmp.mant ^ s) - s;
  256 
  257     return tmp;
  258 }
  259 
  260 static av_always_inline SoftFloat flt16_trunc(SoftFloat pf)
  261 {
  262     SoftFloat pun;
  263     int s;
  264 
  265     pun.exp = pf.exp;
  266     s = pf.mant >> 31;
  267     pun.mant = (pf.mant ^ s) - s;
  268     pun.mant = pun.mant & 0xFFC00000U;
  269     pun.mant = (pun.mant ^ s) - s;
  270 
  271     return pun;
  272 }
  273 
  274 static av_always_inline void predict(PredictorState *ps, int *coef,
  275                                      int output_enable)
  276 {
  277     const SoftFloat a     = { 1023410176, 0 };  // 61.0 / 64
  278     const SoftFloat alpha = {  973078528, 0 };  // 29.0 / 32
  279     SoftFloat e0, e1;
  280     SoftFloat pv;
  281     SoftFloat k1, k2;
  282     SoftFloat   r0 = ps->r0,     r1 = ps->r1;
  283     SoftFloat cor0 = ps->cor0, cor1 = ps->cor1;
  284     SoftFloat var0 = ps->var0, var1 = ps->var1;
  285     SoftFloat tmp;
  286 
  287     if (var0.exp > 1 || (var0.exp == 1 && var0.mant > 0x20000000)) {
  288         k1 = av_mul_sf(cor0, flt16_even(av_div_sf(a, var0)));
  289     }
  290     else {
  291         k1.mant = 0;
  292         k1.exp = 0;
  293     }
  294 
  295     if (var1.exp > 1 || (var1.exp == 1 && var1.mant > 0x20000000)) {
  296         k2 = av_mul_sf(cor1, flt16_even(av_div_sf(a, var1)));
  297     }
  298     else {
  299         k2.mant = 0;
  300         k2.exp = 0;
  301     }
  302 
  303     tmp = av_mul_sf(k1, r0);
  304     pv = flt16_round(av_add_sf(tmp, av_mul_sf(k2, r1)));
  305     if (output_enable) {
  306         int shift = 28 - pv.exp;
  307 
  308         if (shift < 31) {
  309             if (shift > 0) {
  310                 *coef += (unsigned)((pv.mant + (1 << (shift - 1))) >> shift);
  311             } else
  312                 *coef += (unsigned)pv.mant << -shift;
  313         }
  314     }
  315 
  316     e0 = av_int2sf(*coef, 2);
  317     e1 = av_sub_sf(e0, tmp);
  318 
  319     ps->cor1 = flt16_trunc(av_add_sf(av_mul_sf(alpha, cor1), av_mul_sf(r1, e1)));
  320     tmp = av_add_sf(av_mul_sf(r1, r1), av_mul_sf(e1, e1));
  321     tmp.exp--;
  322     ps->var1 = flt16_trunc(av_add_sf(av_mul_sf(alpha, var1), tmp));
  323     ps->cor0 = flt16_trunc(av_add_sf(av_mul_sf(alpha, cor0), av_mul_sf(r0, e0)));
  324     tmp = av_add_sf(av_mul_sf(r0, r0), av_mul_sf(e0, e0));
  325     tmp.exp--;
  326     ps->var0 = flt16_trunc(av_add_sf(av_mul_sf(alpha, var0), tmp));
  327 
  328     ps->r1 = flt16_trunc(av_mul_sf(a, av_sub_sf(r0, av_mul_sf(k1, e0))));
  329     ps->r0 = flt16_trunc(av_mul_sf(a, e0));
  330 }
  331 
  332 
  333 static const int cce_scale_fixed[8] = {
  334     Q30(1.0),          //2^(0/8)
  335     Q30(1.0905077327), //2^(1/8)
  336     Q30(1.1892071150), //2^(2/8)
  337     Q30(1.2968395547), //2^(3/8)
  338     Q30(1.4142135624), //2^(4/8)
  339     Q30(1.5422108254), //2^(5/8)
  340     Q30(1.6817928305), //2^(6/8)
  341     Q30(1.8340080864), //2^(7/8)
  342 };
  343 
  344 /**
  345  * Apply dependent channel coupling (applied before IMDCT).
  346  *
  347  * @param   index   index into coupling gain array
  348  */
  349 static void apply_dependent_coupling_fixed(AACContext *ac,
  350                                      SingleChannelElement *target,
  351                                      ChannelElement *cce, int index)
  352 {
  353     IndividualChannelStream *ics = &cce->ch[0].ics;
  354     const uint16_t *offsets = ics->swb_offset;
  355     int *dest = target->coeffs;
  356     const int *src = cce->ch[0].coeffs;
  357     int g, i, group, k, idx = 0;
  358     if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
  359         av_log(ac->avctx, AV_LOG_ERROR,
  360                "Dependent coupling is not supported together with LTP\n");
  361         return;
  362     }
  363     for (g = 0; g < ics->num_window_groups; g++) {
  364         for (i = 0; i < ics->max_sfb; i++, idx++) {
  365             if (cce->ch[0].band_type[idx] != ZERO_BT) {
  366                 const int gain = cce->coup.gain[index][idx];
  367                 int shift, round, c, tmp;
  368 
  369                 if (gain < 0) {
  370                     c = -cce_scale_fixed[-gain & 7];
  371                     shift = (-gain-1024) >> 3;
  372                 }
  373                 else {
  374                     c = cce_scale_fixed[gain & 7];
  375                     shift = (gain-1024) >> 3;
  376                 }
  377 
  378                 if (shift < -31) {
  379                     // Nothing to do
  380                 } else if (shift < 0) {
  381                     shift = -shift;
  382                     round = 1 << (shift - 1);
  383 
  384                     for (group = 0; group < ics->group_len[g]; group++) {
  385                         for (k = offsets[i]; k < offsets[i + 1]; k++) {
  386                             tmp = (int)(((int64_t)src[group * 128 + k] * c + \
  387                                        (int64_t)0x1000000000) >> 37);
  388                             dest[group * 128 + k] += (tmp + round) >> shift;
  389                         }
  390                     }
  391                 }
  392                 else {
  393                     for (group = 0; group < ics->group_len[g]; group++) {
  394                         for (k = offsets[i]; k < offsets[i + 1]; k++) {
  395                             tmp = (int)(((int64_t)src[group * 128 + k] * c + \
  396                                         (int64_t)0x1000000000) >> 37);
  397                             dest[group * 128 + k] += tmp * (1U << shift);
  398                         }
  399                     }
  400                 }
  401             }
  402         }
  403         dest += ics->group_len[g] * 128;
  404         src  += ics->group_len[g] * 128;
  405     }
  406 }
  407 
  408 /**
  409  * Apply independent channel coupling (applied after IMDCT).
  410  *
  411  * @param   index   index into coupling gain array
  412  */
  413 static void apply_independent_coupling_fixed(AACContext *ac,
  414                                        SingleChannelElement *target,
  415                                        ChannelElement *cce, int index)
  416 {
  417     int i, c, shift, round, tmp;
  418     const int gain = cce->coup.gain[index][0];
  419     const int *src = cce->ch[0].ret;
  420     int *dest = target->ret;
  421     const int len = 1024 << (ac->oc[1].m4ac.sbr == 1);
  422 
  423     c = cce_scale_fixed[gain & 7];
  424     shift = (gain-1024) >> 3;
  425     if (shift < -31) {
  426         return;
  427     } else if (shift < 0) {
  428         shift = -shift;
  429         round = 1 << (shift - 1);
  430 
  431         for (i = 0; i < len; i++) {
  432             tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
  433             dest[i] += (tmp + round) >> shift;
  434         }
  435     }
  436     else {
  437       for (i = 0; i < len; i++) {
  438           tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
  439           dest[i] += tmp * (1 << shift);
  440       }
  441     }
  442 }
  443 
  444 #include "aacdec_template.c"
  445 
  446 AVCodec ff_aac_fixed_decoder = {
  447     .name            = "aac_fixed",
  448     .long_name       = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
  449     .type            = AVMEDIA_TYPE_AUDIO,
  450     .id              = AV_CODEC_ID_AAC,
  451     .priv_data_size  = sizeof(AACContext),
  452     .init            = aac_decode_init,
  453     .close           = aac_decode_close,
  454     .decode          = aac_decode_frame,
  455     .sample_fmts     = (const enum AVSampleFormat[]) {
  456         AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE
  457     },
  458     .capabilities    = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
  459     .caps_internal   = FF_CODEC_CAP_INIT_THREADSAFE,
  460     .channel_layouts = aac_channel_layout,
  461     .profiles        = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
  462     .flush = flush,
  463 };