libavcodec/mips/aacdec_mips.c

   1 /*
   2  * Copyright (c) 2012
   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  * Authors:  Darko Laus      (darko@mips.com)
  30  *           Djordje Pesut   (djordje@mips.com)
  31  *           Mirjana Vulin   (mvulin@mips.com)
  32  *
  33  * This file is part of FFmpeg.
  34  *
  35  * FFmpeg is free software; you can redistribute it and/or
  36  * modify it under the terms of the GNU Lesser General Public
  37  * License as published by the Free Software Foundation; either
  38  * version 2.1 of the License, or (at your option) any later version.
  39  *
  40  * FFmpeg is distributed in the hope that it will be useful,
  41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  43  * Lesser General Public License for more details.
  44  *
  45  * You should have received a copy of the GNU Lesser General Public
  46  * License along with FFmpeg; if not, write to the Free Software
  47  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  48  */
  49
  50 /**
  51  * @file
  52  * Reference: libavcodec/aacdec.c
  53  */
  54
  55 #include "libavutil/attributes.h"
  56 #include "libavcodec/aac.h"
  57 #include "aacdec_mips.h"
  58 #include "libavcodec/aactab.h"
  59 #include "libavcodec/sinewin.h"
  60 #include "libavutil/mips/asmdefs.h"
  61
  62 #if HAVE_INLINE_ASM
  63 #if HAVE_MIPSFPU
  64 static av_always_inline void float_copy(float *dst, const float *src, int count)
  65 {
  66     // Copy 'count' floats from src to dst
  67     const float *loop_end = src + count;
  68     int temp[8];
  69
  70     // count must be a multiple of 8
  71     av_assert2(count % 8 == 0);
  72
  73     // loop unrolled 8 times
  74     __asm__ volatile (
  75         ".set push                               \n\t"
  76         ".set noreorder                          \n\t"
  77     "1:                                          \n\t"
  78         "lw      %[temp0],    0(%[src])          \n\t"
  79         "lw      %[temp1],    4(%[src])          \n\t"
  80         "lw      %[temp2],    8(%[src])          \n\t"
  81         "lw      %[temp3],    12(%[src])         \n\t"
  82         "lw      %[temp4],    16(%[src])         \n\t"
  83         "lw      %[temp5],    20(%[src])         \n\t"
  84         "lw      %[temp6],    24(%[src])         \n\t"
  85         "lw      %[temp7],    28(%[src])         \n\t"
  86         PTR_ADDIU "%[src],    %[src],      32    \n\t"
  87         "sw      %[temp0],    0(%[dst])          \n\t"
  88         "sw      %[temp1],    4(%[dst])          \n\t"
  89         "sw      %[temp2],    8(%[dst])          \n\t"
  90         "sw      %[temp3],    12(%[dst])         \n\t"
  91         "sw      %[temp4],    16(%[dst])         \n\t"
  92         "sw      %[temp5],    20(%[dst])         \n\t"
  93         "sw      %[temp6],    24(%[dst])         \n\t"
  94         "sw      %[temp7],    28(%[dst])         \n\t"
  95         "bne     %[src],      %[loop_end], 1b    \n\t"
  96         PTR_ADDIU "%[dst],    %[dst],      32    \n\t"
  97         ".set pop                                \n\t"
  98
  99         : [temp0]"=&r"(temp[0]), [temp1]"=&r"(temp[1]),
 100           [temp2]"=&r"(temp[2]), [temp3]"=&r"(temp[3]),
 101           [temp4]"=&r"(temp[4]), [temp5]"=&r"(temp[5]),
 102           [temp6]"=&r"(temp[6]), [temp7]"=&r"(temp[7]),
 103           [src]"+r"(src), [dst]"+r"(dst)
 104         : [loop_end]"r"(loop_end)
 105         : "memory"
 106     );
 107 }
 108
 109 static av_always_inline int lcg_random(unsigned previous_val)
 110 {
 111     union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
 112     return v.s;
 113 }
 114
 115 static void imdct_and_windowing_mips(AACContext *ac, SingleChannelElement *sce)
 116 {
 117     IndividualChannelStream *ics = &sce->ics;
 118     float *in    = sce->coeffs;
 119     float *out   = sce->ret;
 120     float *saved = sce->saved;
 121     const float *swindow      = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
 122     const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
 123     const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
 124     float *buf  = ac->buf_mdct;
 125     int i;
 126
 127     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 128         for (i = 0; i < 1024; i += 128)
 129             ac->mdct128_fn(ac->mdct128, buf + i, in + i, sizeof(float));
 130     } else
 131         ac->mdct1024_fn(ac->mdct1024, buf, in, sizeof(float));
 132
 133     /* window overlapping
 134      * NOTE: To simplify the overlapping code, all 'meaningless' short to long
 135      * and long to short transitions are considered to be short to short
 136      * transitions. This leaves just two cases (long to long and short to short)
 137      * with a little special sauce for EIGHT_SHORT_SEQUENCE.
 138      */
 139     if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
 140             (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
 141         ac->fdsp->vector_fmul_window(    out,               saved,            buf,         lwindow_prev, 512);
 142     } else {
 143         float_copy(out, saved, 448);
 144
 145         if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 146             {
 147                 float wi;
 148                 float wj;
 149                 int i;
 150                 float temp0, temp1, temp2, temp3;
 151                 float *dst0 = out + 448 + 0*128;
 152                 float *dst1 = dst0 + 64 + 63;
 153                 float *dst2 = saved + 63;
 154                 float *win0 = (float*)swindow;
 155                 float *win1 = win0 + 64 + 63;
 156                 float *win0_prev = (float*)swindow_prev;
 157                 float *win1_prev = win0_prev + 64 + 63;
 158                 float *src0_prev = saved + 448;
 159                 float *src1_prev = buf + 0*128 + 63;
 160                 float *src0 = buf + 0*128 + 64;
 161                 float *src1 = buf + 1*128 + 63;
 162
 163                 for(i = 0; i < 64; i++)
 164                 {
 165                     temp0 = src0_prev[0];
 166                     temp1 = src1_prev[0];
 167                     wi = *win0_prev;
 168                     wj = *win1_prev;
 169                     temp2 = src0[0];
 170                     temp3 = src1[0];
 171                     dst0[0] = temp0 * wj - temp1 * wi;
 172                     dst1[0] = temp0 * wi + temp1 * wj;
 173
 174                     wi = *win0;
 175                     wj = *win1;
 176
 177                     temp0 = src0[128];
 178                     temp1 = src1[128];
 179                     dst0[128] = temp2 * wj - temp3 * wi;
 180                     dst1[128] = temp2 * wi + temp3 * wj;
 181
 182                     temp2 = src0[256];
 183                     temp3 = src1[256];
 184                     dst0[256] = temp0 * wj - temp1 * wi;
 185                     dst1[256] = temp0 * wi + temp1 * wj;
 186                     dst0[384] = temp2 * wj - temp3 * wi;
 187                     dst1[384] = temp2 * wi + temp3 * wj;
 188
 189                     temp0 = src0[384];
 190                     temp1 = src1[384];
 191                     dst0[512] = temp0 * wj - temp1 * wi;
 192                     dst2[0] = temp0 * wi + temp1 * wj;
 193
 194                     src0++;
 195                     src1--;
 196                     src0_prev++;
 197                     src1_prev--;
 198                     win0++;
 199                     win1--;
 200                     win0_prev++;
 201                     win1_prev--;
 202                     dst0++;
 203                     dst1--;
 204                     dst2--;
 205                 }
 206             }
 207         } else {
 208             ac->fdsp->vector_fmul_window(out + 448,         saved + 448,      buf,         swindow_prev, 64);
 209             float_copy(out + 576, buf + 64, 448);
 210         }
 211     }
 212
 213     // buffer update
 214     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 215         ac->fdsp->vector_fmul_window(saved + 64,  buf + 4*128 + 64, buf + 5*128, swindow, 64);
 216         ac->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
 217         ac->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
 218         float_copy(saved + 448, buf + 7*128 + 64, 64);
 219     } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
 220         float_copy(saved, buf + 512, 448);
 221         float_copy(saved + 448, buf + 7*128 + 64, 64);
 222     } else { // LONG_STOP or ONLY_LONG
 223         float_copy(saved, buf + 512, 512);
 224     }
 225 }
 226
 227 static void apply_ltp_mips(AACContext *ac, SingleChannelElement *sce)
 228 {
 229     const LongTermPrediction *ltp = &sce->ics.ltp;
 230     const uint16_t *offsets = sce->ics.swb_offset;
 231     int i, sfb;
 232     int j, k;
 233
 234     if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
 235         float *predTime = sce->ret;
 236         float *predFreq = ac->buf_mdct;
 237         float *p_predTime;
 238         int16_t num_samples = 2048;
 239
 240         if (ltp->lag < 1024)
 241             num_samples = ltp->lag + 1024;
 242         j = (2048 - num_samples) >> 2;
 243         k = (2048 - num_samples) & 3;
 244         p_predTime = &predTime[num_samples];
 245
 246         for (i = 0; i < num_samples; i++)
 247             predTime[i] = sce->ltp_state[i + 2048 - ltp->lag] * ltp->coef;
 248         for (i = 0; i < j; i++) {
 249
 250             /* loop unrolled 4 times */
 251             __asm__ volatile (
 252                 "sw      $0,              0(%[p_predTime])        \n\t"
 253                 "sw      $0,              4(%[p_predTime])        \n\t"
 254                 "sw      $0,              8(%[p_predTime])        \n\t"
 255                 "sw      $0,              12(%[p_predTime])       \n\t"
 256                 PTR_ADDIU "%[p_predTime], %[p_predTime],     16   \n\t"
 257
 258                 : [p_predTime]"+r"(p_predTime)
 259                 :
 260                 : "memory"
 261             );
 262         }
 263         for (i = 0; i < k; i++) {
 264
 265             __asm__ volatile (
 266                 "sw      $0,              0(%[p_predTime])        \n\t"
 267                 PTR_ADDIU "%[p_predTime], %[p_predTime],     4    \n\t"
 268
 269                 : [p_predTime]"+r"(p_predTime)
 270                 :
 271                 : "memory"
 272             );
 273         }
 274
 275         ac->windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
 276
 277         if (sce->tns.present)
 278             ac->apply_tns(predFreq, &sce->tns, &sce->ics, 0);
 279
 280         for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
 281             if (ltp->used[sfb])
 282                 for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
 283                     sce->coeffs[i] += predFreq[i];
 284     }
 285 }
 286
 287 static av_always_inline void fmul_and_reverse(float *dst, const float *src0, const float *src1, int count)
 288 {
 289     /* Multiply 'count' floats in src0 by src1 and store the results in dst in reverse */
 290     /* This should be equivalent to a normal fmul, followed by reversing dst */
 291
 292     // count must be a multiple of 4
 293     av_assert2(count % 4 == 0);
 294
 295     // move src0 and src1 to the last element of their arrays
 296     src0 += count - 1;
 297     src1 += count - 1;
 298
 299     for (; count > 0; count -= 4){
 300         float temp[12];
 301
 302         /* loop unrolled 4 times */
 303         __asm__ volatile (
 304             "lwc1    %[temp0],    0(%[ptr2])                \n\t"
 305             "lwc1    %[temp1],    -4(%[ptr2])               \n\t"
 306             "lwc1    %[temp2],    -8(%[ptr2])               \n\t"
 307             "lwc1    %[temp3],    -12(%[ptr2])              \n\t"
 308             "lwc1    %[temp4],    0(%[ptr3])                \n\t"
 309             "lwc1    %[temp5],    -4(%[ptr3])               \n\t"
 310             "lwc1    %[temp6],    -8(%[ptr3])               \n\t"
 311             "lwc1    %[temp7],    -12(%[ptr3])              \n\t"
 312             "mul.s   %[temp8],    %[temp0],     %[temp4]    \n\t"
 313             "mul.s   %[temp9],    %[temp1],     %[temp5]    \n\t"
 314             "mul.s   %[temp10],   %[temp2],     %[temp6]    \n\t"
 315             "mul.s   %[temp11],   %[temp3],     %[temp7]    \n\t"
 316             "swc1    %[temp8],    0(%[ptr1])                \n\t"
 317             "swc1    %[temp9],    4(%[ptr1])                \n\t"
 318             "swc1    %[temp10],   8(%[ptr1])                \n\t"
 319             "swc1    %[temp11],   12(%[ptr1])               \n\t"
 320             PTR_ADDIU "%[ptr1],   %[ptr1],      16          \n\t"
 321             PTR_ADDIU "%[ptr2],   %[ptr2],      -16         \n\t"
 322             PTR_ADDIU "%[ptr3],   %[ptr3],      -16         \n\t"
 323
 324             : [temp0]"=&f"(temp[0]), [temp1]"=&f"(temp[1]),
 325               [temp2]"=&f"(temp[2]), [temp3]"=&f"(temp[3]),
 326               [temp4]"=&f"(temp[4]), [temp5]"=&f"(temp[5]),
 327               [temp6]"=&f"(temp[6]), [temp7]"=&f"(temp[7]),
 328               [temp8]"=&f"(temp[8]), [temp9]"=&f"(temp[9]),
 329               [temp10]"=&f"(temp[10]), [temp11]"=&f"(temp[11]),
 330               [ptr1]"+r"(dst), [ptr2]"+r"(src0), [ptr3]"+r"(src1)
 331             :
 332             : "memory"
 333         );
 334     }
 335 }
 336
 337 static void update_ltp_mips(AACContext *ac, SingleChannelElement *sce)
 338 {
 339     IndividualChannelStream *ics = &sce->ics;
 340     float *saved     = sce->saved;
 341     float *saved_ltp = sce->coeffs;
 342     const float *lwindow = ics->use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
 343     const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
 344     uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
 345
 346     if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
 347         float *p_saved_ltp = saved_ltp + 576;
 348         float *loop_end1 = p_saved_ltp + 448;
 349
 350         float_copy(saved_ltp, saved, 512);
 351
 352         /* loop unrolled 8 times */
 353         __asm__ volatile (
 354         "1:                                                   \n\t"
 355             "sw     $0,              0(%[p_saved_ltp])        \n\t"
 356             "sw     $0,              4(%[p_saved_ltp])        \n\t"
 357             "sw     $0,              8(%[p_saved_ltp])        \n\t"
 358             "sw     $0,              12(%[p_saved_ltp])       \n\t"
 359             "sw     $0,              16(%[p_saved_ltp])       \n\t"
 360             "sw     $0,              20(%[p_saved_ltp])       \n\t"
 361             "sw     $0,              24(%[p_saved_ltp])       \n\t"
 362             "sw     $0,              28(%[p_saved_ltp])       \n\t"
 363             PTR_ADDIU "%[p_saved_ltp],%[p_saved_ltp],    32   \n\t"
 364             "bne    %[p_saved_ltp],  %[loop_end1],       1b   \n\t"
 365
 366             : [p_saved_ltp]"+r"(p_saved_ltp)
 367             : [loop_end1]"r"(loop_end1)
 368             : "memory"
 369         );
 370
 371         ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
 372         fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 960, swindow, 64);
 373     } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
 374         float *buff0 = saved;
 375         float *buff1 = saved_ltp;
 376         float *loop_end = saved + 448;
 377
 378         /* loop unrolled 8 times */
 379         __asm__ volatile (
 380             ".set push                                  \n\t"
 381             ".set noreorder                             \n\t"
 382         "1:                                             \n\t"
 383             "lw      %[temp0],    0(%[src])             \n\t"
 384             "lw      %[temp1],    4(%[src])             \n\t"
 385             "lw      %[temp2],    8(%[src])             \n\t"
 386             "lw      %[temp3],    12(%[src])            \n\t"
 387             "lw      %[temp4],    16(%[src])            \n\t"
 388             "lw      %[temp5],    20(%[src])            \n\t"
 389             "lw      %[temp6],    24(%[src])            \n\t"
 390             "lw      %[temp7],    28(%[src])            \n\t"
 391             PTR_ADDIU "%[src],    %[src],         32    \n\t"
 392             "sw      %[temp0],    0(%[dst])             \n\t"
 393             "sw      %[temp1],    4(%[dst])             \n\t"
 394             "sw      %[temp2],    8(%[dst])             \n\t"
 395             "sw      %[temp3],    12(%[dst])            \n\t"
 396             "sw      %[temp4],    16(%[dst])            \n\t"
 397             "sw      %[temp5],    20(%[dst])            \n\t"
 398             "sw      %[temp6],    24(%[dst])            \n\t"
 399             "sw      %[temp7],    28(%[dst])            \n\t"
 400             "sw      $0,          2304(%[dst])          \n\t"
 401             "sw      $0,          2308(%[dst])          \n\t"
 402             "sw      $0,          2312(%[dst])          \n\t"
 403             "sw      $0,          2316(%[dst])          \n\t"
 404             "sw      $0,          2320(%[dst])          \n\t"
 405             "sw      $0,          2324(%[dst])          \n\t"
 406             "sw      $0,          2328(%[dst])          \n\t"
 407             "sw      $0,          2332(%[dst])          \n\t"
 408             "bne     %[src],      %[loop_end],    1b    \n\t"
 409             PTR_ADDIU "%[dst],    %[dst],         32    \n\t"
 410             ".set pop                                   \n\t"
 411
 412             : [temp0]"=&r"(temp0), [temp1]"=&r"(temp1),
 413               [temp2]"=&r"(temp2), [temp3]"=&r"(temp3),
 414               [temp4]"=&r"(temp4), [temp5]"=&r"(temp5),
 415               [temp6]"=&r"(temp6), [temp7]"=&r"(temp7),
 416               [src]"+r"(buff0), [dst]"+r"(buff1)
 417             : [loop_end]"r"(loop_end)
 418             : "memory"
 419         );
 420         ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
 421         fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 960, swindow, 64);
 422     } else { // LONG_STOP or ONLY_LONG
 423         ac->fdsp->vector_fmul_reverse(saved_ltp,       ac->buf_mdct + 512,     &lwindow[512],     512);
 424         fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 512, lwindow, 512);
 425     }
 426
 427     float_copy(sce->ltp_state, sce->ltp_state + 1024, 1024);
 428     float_copy(sce->ltp_state + 1024, sce->ret, 1024);
 429     float_copy(sce->ltp_state + 2048, saved_ltp, 1024);
 430 }
 431 #endif /* HAVE_MIPSFPU */
 432 #endif /* HAVE_INLINE_ASM */
 433
 434 void ff_aacdec_init_mips(AACContext *c)
 435 {
 436 #if HAVE_INLINE_ASM
 437 #if HAVE_MIPSFPU
 438     c->imdct_and_windowing         = imdct_and_windowing_mips;
 439     c->apply_ltp                   = apply_ltp_mips;
 440     c->update_ltp                  = update_ltp_mips;
 441 #endif /* HAVE_MIPSFPU */
 442 #endif /* HAVE_INLINE_ASM */
 443 }