git.sesse.net Git - ffmpeg/blob - libavcodec/sbrdsp.c

   1 /*
   2  * AAC Spectral Band Replication decoding functions
   3  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
   4  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
   5  *
   6  * This file is part of Libav.
   7  *
   8  * Libav is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * Libav is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with Libav; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "config.h"
  24 #include "libavutil/attributes.h"
  25 #include "sbrdsp.h"
  26
  27 static void sbr_sum64x5_c(float *z)
  28 {
  29     int k;
  30     for (k = 0; k < 64; k++) {
  31         float f = z[k] + z[k + 64] + z[k + 128] + z[k + 192] + z[k + 256];
  32         z[k] = f;
  33     }
  34 }
  35
  36 static float sbr_sum_square_c(float (*x)[2], int n)
  37 {
  38     float sum = 0.0f;
  39     int i;
  40
  41     for (i = 0; i < n; i++)
  42         sum += x[i][0] * x[i][0] + x[i][1] * x[i][1];
  43
  44     return sum;
  45 }
  46
  47 static void sbr_neg_odd_64_c(float *x)
  48 {
  49     int i;
  50     for (i = 1; i < 64; i += 2)
  51         x[i] = -x[i];
  52 }
  53
  54 static void sbr_qmf_pre_shuffle_c(float *z)
  55 {
  56     int k;
  57     z[64] = z[0];
  58     z[65] = z[1];
  59     for (k = 1; k < 32; k++) {
  60         z[64+2*k  ] = -z[64 - k];
  61         z[64+2*k+1] =  z[ k + 1];
  62     }
  63 }
  64
  65 static void sbr_qmf_post_shuffle_c(float W[32][2], const float *z)
  66 {
  67     int k;
  68     for (k = 0; k < 32; k++) {
  69         W[k][0] = -z[63-k];
  70         W[k][1] = z[k];
  71     }
  72 }
  73
  74 static void sbr_qmf_deint_neg_c(float *v, const float *src)
  75 {
  76     int i;
  77     for (i = 0; i < 32; i++) {
  78         v[     i] =  src[63 - 2*i    ];
  79         v[63 - i] = -src[63 - 2*i - 1];
  80     }
  81 }
  82
  83 static void sbr_qmf_deint_bfly_c(float *v, const float *src0, const float *src1)
  84 {
  85     int i;
  86     for (i = 0; i < 64; i++) {
  87         v[      i] = src0[i] - src1[63 - i];
  88         v[127 - i] = src0[i] + src1[63 - i];
  89     }
  90 }
  91
  92 static av_always_inline void autocorrelate(const float x[40][2],
  93                                            float phi[3][2][2], int lag)
  94 {
  95     int i;
  96     float real_sum = 0.0f;
  97     float imag_sum = 0.0f;
  98     if (lag) {
  99         for (i = 1; i < 38; i++) {
 100             real_sum += x[i][0] * x[i+lag][0] + x[i][1] * x[i+lag][1];
 101             imag_sum += x[i][0] * x[i+lag][1] - x[i][1] * x[i+lag][0];
 102         }
 103         phi[2-lag][1][0] = real_sum + x[ 0][0] * x[lag][0] + x[ 0][1] * x[lag][1];
 104         phi[2-lag][1][1] = imag_sum + x[ 0][0] * x[lag][1] - x[ 0][1] * x[lag][0];
 105         if (lag == 1) {
 106             phi[0][0][0] = real_sum + x[38][0] * x[39][0] + x[38][1] * x[39][1];
 107             phi[0][0][1] = imag_sum + x[38][0] * x[39][1] - x[38][1] * x[39][0];
 108         }
 109     } else {
 110         for (i = 1; i < 38; i++) {
 111             real_sum += x[i][0] * x[i][0] + x[i][1] * x[i][1];
 112         }
 113         phi[2][1][0] = real_sum + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
 114         phi[1][0][0] = real_sum + x[38][0] * x[38][0] + x[38][1] * x[38][1];
 115     }
 116 }
 117
 118 static void sbr_autocorrelate_c(const float x[40][2], float phi[3][2][2])
 119 {
 120     autocorrelate(x, phi, 0);
 121     autocorrelate(x, phi, 1);
 122     autocorrelate(x, phi, 2);
 123 }
 124
 125 static void sbr_hf_gen_c(float (*X_high)[2], const float (*X_low)[2],
 126                          const float alpha0[2], const float alpha1[2],
 127                          float bw, int start, int end)
 128 {
 129     float alpha[4];
 130     int i;
 131
 132     alpha[0] = alpha1[0] * bw * bw;
 133     alpha[1] = alpha1[1] * bw * bw;
 134     alpha[2] = alpha0[0] * bw;
 135     alpha[3] = alpha0[1] * bw;
 136
 137     for (i = start; i < end; i++) {
 138         X_high[i][0] =
 139             X_low[i - 2][0] * alpha[0] -
 140             X_low[i - 2][1] * alpha[1] +
 141             X_low[i - 1][0] * alpha[2] -
 142             X_low[i - 1][1] * alpha[3] +
 143             X_low[i][0];
 144         X_high[i][1] =
 145             X_low[i - 2][1] * alpha[0] +
 146             X_low[i - 2][0] * alpha[1] +
 147             X_low[i - 1][1] * alpha[2] +
 148             X_low[i - 1][0] * alpha[3] +
 149             X_low[i][1];
 150     }
 151 }
 152
 153 static void sbr_hf_g_filt_c(float (*Y)[2], const float (*X_high)[40][2],
 154                             const float *g_filt, int m_max, intptr_t ixh)
 155 {
 156     int m;
 157
 158     for (m = 0; m < m_max; m++) {
 159         Y[m][0] = X_high[m][ixh][0] * g_filt[m];
 160         Y[m][1] = X_high[m][ixh][1] * g_filt[m];
 161     }
 162 }
 163
 164 static av_always_inline void sbr_hf_apply_noise(float (*Y)[2],
 165                                                 const float *s_m,
 166                                                 const float *q_filt,
 167                                                 int noise,
 168                                                 float phi_sign0,
 169                                                 float phi_sign1,
 170                                                 int m_max)
 171 {
 172     int m;
 173
 174     for (m = 0; m < m_max; m++) {
 175         float y0 = Y[m][0];
 176         float y1 = Y[m][1];
 177         noise = (noise + 1) & 0x1ff;
 178         if (s_m[m]) {
 179             y0 += s_m[m] * phi_sign0;
 180             y1 += s_m[m] * phi_sign1;
 181         } else {
 182             y0 += q_filt[m] * ff_sbr_noise_table[noise][0];
 183             y1 += q_filt[m] * ff_sbr_noise_table[noise][1];
 184         }
 185         Y[m][0] = y0;
 186         Y[m][1] = y1;
 187         phi_sign1 = -phi_sign1;
 188     }
 189 }
 190
 191 static void sbr_hf_apply_noise_0(float (*Y)[2], const float *s_m,
 192                                  const float *q_filt, int noise,
 193                                  int kx, int m_max)
 194 {
 195     sbr_hf_apply_noise(Y, s_m, q_filt, noise, 1.0, 0.0, m_max);
 196 }
 197
 198 static void sbr_hf_apply_noise_1(float (*Y)[2], const float *s_m,
 199                                  const float *q_filt, int noise,
 200                                  int kx, int m_max)
 201 {
 202     float phi_sign = 1 - 2 * (kx & 1);
 203     sbr_hf_apply_noise(Y, s_m, q_filt, noise, 0.0, phi_sign, m_max);
 204 }
 205
 206 static void sbr_hf_apply_noise_2(float (*Y)[2], const float *s_m,
 207                                  const float *q_filt, int noise,
 208                                  int kx, int m_max)
 209 {
 210     sbr_hf_apply_noise(Y, s_m, q_filt, noise, -1.0, 0.0, m_max);
 211 }
 212
 213 static void sbr_hf_apply_noise_3(float (*Y)[2], const float *s_m,
 214                                  const float *q_filt, int noise,
 215                                  int kx, int m_max)
 216 {
 217     float phi_sign = 1 - 2 * (kx & 1);
 218     sbr_hf_apply_noise(Y, s_m, q_filt, noise, 0.0, -phi_sign, m_max);
 219 }
 220
 221 av_cold void ff_sbrdsp_init(SBRDSPContext *s)
 222 {
 223     s->sum64x5 = sbr_sum64x5_c;
 224     s->sum_square = sbr_sum_square_c;
 225     s->neg_odd_64 = sbr_neg_odd_64_c;
 226     s->qmf_pre_shuffle = sbr_qmf_pre_shuffle_c;
 227     s->qmf_post_shuffle = sbr_qmf_post_shuffle_c;
 228     s->qmf_deint_neg = sbr_qmf_deint_neg_c;
 229     s->qmf_deint_bfly = sbr_qmf_deint_bfly_c;
 230     s->autocorrelate = sbr_autocorrelate_c;
 231     s->hf_gen = sbr_hf_gen_c;
 232     s->hf_g_filt = sbr_hf_g_filt_c;
 233
 234     s->hf_apply_noise[0] = sbr_hf_apply_noise_0;
 235     s->hf_apply_noise[1] = sbr_hf_apply_noise_1;
 236     s->hf_apply_noise[2] = sbr_hf_apply_noise_2;
 237     s->hf_apply_noise[3] = sbr_hf_apply_noise_3;
 238
 239     if (ARCH_ARM)
 240         ff_sbrdsp_init_arm(s);
 241     if (HAVE_MMX)
 242         ff_sbrdsp_init_x86(s);
 243 }