libavcodec/x86/mpegaudiodec_mmx.c

   1 /*
   2  * MMX optimized MP3 decoding functions
   3  * Copyright (c) 2010 Vitor Sessak
   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 #include "libavutil/cpu.h"
  23 #include "libavutil/x86_cpu.h"
  24 #include "libavcodec/dsputil.h"
  25 #include "libavcodec/mpegaudiodsp.h"
  26
  27 #define MACS(rt, ra, rb) rt+=(ra)*(rb)
  28 #define MLSS(rt, ra, rb) rt-=(ra)*(rb)
  29
  30 #define SUM8(op, sum, w, p)               \
  31 {                                         \
  32     op(sum, (w)[0 * 64], (p)[0 * 64]);    \
  33     op(sum, (w)[1 * 64], (p)[1 * 64]);    \
  34     op(sum, (w)[2 * 64], (p)[2 * 64]);    \
  35     op(sum, (w)[3 * 64], (p)[3 * 64]);    \
  36     op(sum, (w)[4 * 64], (p)[4 * 64]);    \
  37     op(sum, (w)[5 * 64], (p)[5 * 64]);    \
  38     op(sum, (w)[6 * 64], (p)[6 * 64]);    \
  39     op(sum, (w)[7 * 64], (p)[7 * 64]);    \
  40 }
  41
  42 static void apply_window(const float *buf, const float *win1,
  43                          const float *win2, float *sum1, float *sum2, int len)
  44 {
  45     x86_reg count = - 4*len;
  46     const float *win1a = win1+len;
  47     const float *win2a = win2+len;
  48     const float *bufa  = buf+len;
  49     float *sum1a = sum1+len;
  50     float *sum2a = sum2+len;
  51
  52
  53 #define MULT(a, b)                                 \
  54     "movaps " #a "(%1,%0), %%xmm1           \n\t"  \
  55     "movaps " #a "(%3,%0), %%xmm2           \n\t"  \
  56     "mulps         %%xmm2, %%xmm1           \n\t"  \
  57     "subps         %%xmm1, %%xmm0           \n\t"  \
  58     "mulps  " #b "(%2,%0), %%xmm2           \n\t"  \
  59     "subps         %%xmm2, %%xmm4           \n\t"  \
  60
  61     __asm__ volatile(
  62             "1:                                   \n\t"
  63             "xorps       %%xmm0, %%xmm0           \n\t"
  64             "xorps       %%xmm4, %%xmm4           \n\t"
  65
  66             MULT(   0,   0)
  67             MULT( 256,  64)
  68             MULT( 512, 128)
  69             MULT( 768, 192)
  70             MULT(1024, 256)
  71             MULT(1280, 320)
  72             MULT(1536, 384)
  73             MULT(1792, 448)
  74
  75             "movaps      %%xmm0, (%4,%0)          \n\t"
  76             "movaps      %%xmm4, (%5,%0)          \n\t"
  77             "add            $16,  %0              \n\t"
  78             "jl              1b                   \n\t"
  79             :"+&r"(count)
  80             :"r"(win1a), "r"(win2a), "r"(bufa), "r"(sum1a), "r"(sum2a)
  81             );
  82
  83 #undef MULT
  84 }
  85
  86 static void apply_window_mp3(float *in, float *win, int *unused, float *out,
  87                              int incr)
  88 {
  89     LOCAL_ALIGNED_16(float, suma, [17]);
  90     LOCAL_ALIGNED_16(float, sumb, [17]);
  91     LOCAL_ALIGNED_16(float, sumc, [17]);
  92     LOCAL_ALIGNED_16(float, sumd, [17]);
  93
  94     float sum;
  95
  96     /* copy to avoid wrap */
  97     memcpy(in + 512, in, 32 * sizeof(*in));
  98
  99     apply_window(in + 16, win     , win + 512, suma, sumc, 16);
 100     apply_window(in + 32, win + 48, win + 640, sumb, sumd, 16);
 101
 102     SUM8(MACS, suma[0], win + 32, in + 48);
 103
 104     sumc[ 0] = 0;
 105     sumb[16] = 0;
 106     sumd[16] = 0;
 107
 108 #define SUMS(suma, sumb, sumc, sumd, out1, out2)               \
 109             "movups " #sumd "(%4),       %%xmm0          \n\t" \
 110             "shufps         $0x1b,       %%xmm0, %%xmm0  \n\t" \
 111             "subps  " #suma "(%1),       %%xmm0          \n\t" \
 112             "movaps        %%xmm0," #out1 "(%0)          \n\t" \
 113 \
 114             "movups " #sumc "(%3),       %%xmm0          \n\t" \
 115             "shufps         $0x1b,       %%xmm0, %%xmm0  \n\t" \
 116             "addps  " #sumb "(%2),       %%xmm0          \n\t" \
 117             "movaps        %%xmm0," #out2 "(%0)          \n\t"
 118
 119     if (incr == 1) {
 120         __asm__ volatile(
 121             SUMS( 0, 48,  4, 52,  0, 112)
 122             SUMS(16, 32, 20, 36, 16,  96)
 123             SUMS(32, 16, 36, 20, 32,  80)
 124             SUMS(48,  0, 52,  4, 48,  64)
 125
 126             :"+&r"(out)
 127             :"r"(&suma[0]), "r"(&sumb[0]), "r"(&sumc[0]), "r"(&sumd[0])
 128             :"memory"
 129             );
 130         out += 16*incr;
 131     } else {
 132         int j;
 133         float *out2 = out + 32 * incr;
 134         out[0  ]  = -suma[   0];
 135         out += incr;
 136         out2 -= incr;
 137         for(j=1;j<16;j++) {
 138             *out  = -suma[   j] + sumd[16-j];
 139             *out2 =  sumb[16-j] + sumc[   j];
 140             out  += incr;
 141             out2 -= incr;
 142         }
 143     }
 144
 145     sum = 0;
 146     SUM8(MLSS, sum, win + 16 + 32, in + 32);
 147     *out = sum;
 148 }
 149
 150 void ff_mpadsp_init_mmx(MPADSPContext *s)
 151 {
 152     int mm_flags = av_get_cpu_flags();
 153
 154     if (mm_flags & AV_CPU_FLAG_SSE2) {
 155         s->apply_window_float = apply_window_mp3;
 156     }
 157 }