falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
75941 Commits
32 Branches
290MB
Tree: 97437bd17a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '97437bd17a'
${ noResults }
FFmpeg/libavcodec/mips/aaccoder_mips.c

2562 lines
104KB
Raw Blame History 

  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.  * Author:  Stanislav Ocovaj (socovaj@mips.com)

  30.  *          Szabolcs Pal     (sabolc@mips.com)

  31.  *

  32.  * AAC coefficients encoder optimized for MIPS floating-point architecture

  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.  * Reference: libavcodec/aaccoder.c

  54.  */

  55. 

  56. #include "libavutil/libm.h"

  57. 

  58. #include <float.h>

  59. #include "libavutil/mathematics.h"

  60. #include "libavcodec/avcodec.h"

  61. #include "libavcodec/put_bits.h"

  62. #include "libavcodec/aac.h"

  63. #include "libavcodec/aacenc.h"

  64. #include "libavcodec/aactab.h"

  65. #include "libavcodec/aacenctab.h"

  66. 

  67. #if HAVE_INLINE_ASM

  68. typedef struct BandCodingPath {

  69.     int prev_idx;

  70.     float cost;

  71.     int run;

  72. } BandCodingPath;

  73. 

  74. static const uint8_t uquad_sign_bits[81] = {

  75.     0, 1, 1, 1, 2, 2, 1, 2, 2,

  76.     1, 2, 2, 2, 3, 3, 2, 3, 3,

  77.     1, 2, 2, 2, 3, 3, 2, 3, 3,

  78.     1, 2, 2, 2, 3, 3, 2, 3, 3,

  79.     2, 3, 3, 3, 4, 4, 3, 4, 4,

  80.     2, 3, 3, 3, 4, 4, 3, 4, 4,

  81.     1, 2, 2, 2, 3, 3, 2, 3, 3,

  82.     2, 3, 3, 3, 4, 4, 3, 4, 4,

  83.     2, 3, 3, 3, 4, 4, 3, 4, 4

  84. };

  85. 

  86. static const uint8_t upair7_sign_bits[64] = {

  87.     0, 1, 1, 1, 1, 1, 1, 1,

  88.     1, 2, 2, 2, 2, 2, 2, 2,

  89.     1, 2, 2, 2, 2, 2, 2, 2,

  90.     1, 2, 2, 2, 2, 2, 2, 2,

  91.     1, 2, 2, 2, 2, 2, 2, 2,

  92.     1, 2, 2, 2, 2, 2, 2, 2,

  93.     1, 2, 2, 2, 2, 2, 2, 2,

  94.     1, 2, 2, 2, 2, 2, 2, 2,

  95. };

  96. 

  97. static const uint8_t upair12_sign_bits[169] = {

  98.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  99.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  100.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  101.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  102.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  103.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  104.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  105.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  106.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  107.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  108.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  109.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  110.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2

  111. };

  112. 

  113. static const uint8_t esc_sign_bits[289] = {

  114.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  115.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  116.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  117.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  118.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  119.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  120.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  121.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  122.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  123.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  124.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  125.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  126.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  127.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  128.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  129.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  130.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2

  131. };

  132. 

  133. #define ROUND_STANDARD 0.4054f

  134. #define ROUND_TO_ZERO 0.1054f

  135. 

  136. static void abs_pow34_v(float *out, const float *in, const int size) {

  137. #ifndef USE_REALLY_FULL_SEARCH

  138.     int i;

  139.     float a, b, c, d;

  140.     float ax, bx, cx, dx;

  141. 

  142.     for (i = 0; i < size; i += 4) {

  143.         a = fabsf(in[i  ]);

  144.         b = fabsf(in[i+1]);

  145.         c = fabsf(in[i+2]);

  146.         d = fabsf(in[i+3]);

  147. 

  148.         ax = sqrtf(a);

  149.         bx = sqrtf(b);

  150.         cx = sqrtf(c);

  151.         dx = sqrtf(d);

  152. 

  153.         a = a * ax;

  154.         b = b * bx;

  155.         c = c * cx;

  156.         d = d * dx;

  157. 

  158.         out[i  ] = sqrtf(a);

  159.         out[i+1] = sqrtf(b);

  160.         out[i+2] = sqrtf(c);

  161.         out[i+3] = sqrtf(d);

  162.     }

  163. #endif /* USE_REALLY_FULL_SEARCH */

  164. }

  165. 

  166. static float find_max_val(int group_len, int swb_size, const float *scaled) {

  167.     float maxval = 0.0f;

  168.     int w2, i;

  169.     for (w2 = 0; w2 < group_len; w2++) {

  170.         for (i = 0; i < swb_size; i++) {

  171.             maxval = FFMAX(maxval, scaled[w2*128+i]);

  172.         }

  173.     }

  174.     return maxval;

  175. }

  176. 

  177. static int find_min_book(float maxval, int sf) {

  178.     float Q = ff_aac_pow2sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512];

  179.     float Q34 = sqrtf(Q * sqrtf(Q));

  180.     int qmaxval, cb;

  181.     qmaxval = maxval * Q34 + 0.4054f;

  182.     if (qmaxval >= (FF_ARRAY_ELEMS(aac_maxval_cb)))

  183.         cb = 11;

  184.     else

  185.         cb = aac_maxval_cb[qmaxval];

  186.     return cb;

  187. }

  188. 

  189. /**

  190.  * Functions developed from template function and optimized for quantizing and encoding band

  191.  */

  192. static void quantize_and_encode_band_cost_SQUAD_mips(struct AACEncContext *s,

  193.                                                      PutBitContext *pb, const float *in, float *out,

  194.                                                      const float *scaled, int size, int scale_idx,

  195.                                                      int cb, const float lambda, const float uplim,

  196.                                                      int *bits, float *energy, const float ROUNDING)

  197. {

  198.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  199.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  200.     int i;

  201.     int qc1, qc2, qc3, qc4;

  202.     float qenergy = 0.0f;

  203. 

  204.     uint8_t  *p_bits  = (uint8_t  *)ff_aac_spectral_bits[cb-1];

  205.     uint16_t *p_codes = (uint16_t *)ff_aac_spectral_codes[cb-1];

  206.     float    *p_vec   = (float    *)ff_aac_codebook_vectors[cb-1];

  207. 

  208.     abs_pow34_v(s->scoefs, in, size);

  209.     scaled = s->scoefs;

  210.     for (i = 0; i < size; i += 4) {

  211.         int curidx;

  212.         int *in_int = (int *)&in[i];

  213.         int t0, t1, t2, t3, t4, t5, t6, t7;

  214.         const float *vec;

  215. 

  216.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  217.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  218.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  219.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  220. 

  221.         __asm__ volatile (

  222.             ".set push                      \n\t"

  223.             ".set noreorder                 \n\t"

  224. 

  225.             "slt    %[qc1], $zero,  %[qc1]  \n\t"

  226.             "slt    %[qc2], $zero,  %[qc2]  \n\t"

  227.             "slt    %[qc3], $zero,  %[qc3]  \n\t"

  228.             "slt    %[qc4], $zero,  %[qc4]  \n\t"

  229.             "lw     %[t0],  0(%[in_int])    \n\t"

  230.             "lw     %[t1],  4(%[in_int])    \n\t"

  231.             "lw     %[t2],  8(%[in_int])    \n\t"

  232.             "lw     %[t3],  12(%[in_int])   \n\t"

  233.             "srl    %[t0],  %[t0],  31      \n\t"

  234.             "srl    %[t1],  %[t1],  31      \n\t"

  235.             "srl    %[t2],  %[t2],  31      \n\t"

  236.             "srl    %[t3],  %[t3],  31      \n\t"

  237.             "subu   %[t4],  $zero,  %[qc1]  \n\t"

  238.             "subu   %[t5],  $zero,  %[qc2]  \n\t"

  239.             "subu   %[t6],  $zero,  %[qc3]  \n\t"

  240.             "subu   %[t7],  $zero,  %[qc4]  \n\t"

  241.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  242.             "movn   %[qc2], %[t5],  %[t1]   \n\t"

  243.             "movn   %[qc3], %[t6],  %[t2]   \n\t"

  244.             "movn   %[qc4], %[t7],  %[t3]   \n\t"

  245. 

  246.             ".set pop                       \n\t"

  247. 

  248.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  249.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  250.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  251.               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)

  252.             : [in_int]"r"(in_int)

  253.             : "memory"

  254.         );

  255. 

  256.         curidx = qc1;

  257.         curidx *= 3;

  258.         curidx += qc2;

  259.         curidx *= 3;

  260.         curidx += qc3;

  261.         curidx *= 3;

  262.         curidx += qc4;

  263.         curidx += 40;

  264. 

  265.         put_bits(pb, p_bits[curidx], p_codes[curidx]);

  266. 

  267.         if (out || energy) {

  268.             float e1,e2,e3,e4;

  269.             vec = &p_vec[curidx*4];

  270.             e1 = vec[0] * IQ;

  271.             e2 = vec[1] * IQ;

  272.             e3 = vec[2] * IQ;

  273.             e4 = vec[3] * IQ;

  274.             if (out) {

  275.                 out[i+0] = e1;

  276.                 out[i+1] = e2;

  277.                 out[i+2] = e3;

  278.                 out[i+3] = e4;

  279.             }

  280.             if (energy)

  281.                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);

  282.         }

  283.     }

  284.     if (energy)

  285.         *energy = qenergy;

  286. }

  287. 

  288. static void quantize_and_encode_band_cost_UQUAD_mips(struct AACEncContext *s,

  289.                                                      PutBitContext *pb, const float *in, float *out,

  290.                                                      const float *scaled, int size, int scale_idx,

  291.                                                      int cb, const float lambda, const float uplim,

  292.                                                      int *bits, float *energy, const float ROUNDING)

  293. {

  294.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  295.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  296.     int i;

  297.     int qc1, qc2, qc3, qc4;

  298.     float qenergy = 0.0f;

  299. 

  300.     uint8_t  *p_bits  = (uint8_t  *)ff_aac_spectral_bits[cb-1];

  301.     uint16_t *p_codes = (uint16_t *)ff_aac_spectral_codes[cb-1];

  302.     float    *p_vec   = (float    *)ff_aac_codebook_vectors[cb-1];

  303. 

  304.     abs_pow34_v(s->scoefs, in, size);

  305.     scaled = s->scoefs;

  306.     for (i = 0; i < size; i += 4) {

  307.         int curidx, sign, count;

  308.         int *in_int = (int *)&in[i];

  309.         uint8_t v_bits;

  310.         unsigned int v_codes;

  311.         int t0, t1, t2, t3, t4;

  312.         const float *vec;

  313. 

  314.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  315.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  316.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  317.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  318. 

  319.         __asm__ volatile (

  320.             ".set push                              \n\t"

  321.             ".set noreorder                         \n\t"

  322. 

  323.             "ori    %[t4],      $zero,      2       \n\t"

  324.             "ori    %[sign],    $zero,      0       \n\t"

  325.             "slt    %[t0],      %[t4],      %[qc1]  \n\t"

  326.             "slt    %[t1],      %[t4],      %[qc2]  \n\t"

  327.             "slt    %[t2],      %[t4],      %[qc3]  \n\t"

  328.             "slt    %[t3],      %[t4],      %[qc4]  \n\t"

  329.             "movn   %[qc1],     %[t4],      %[t0]   \n\t"

  330.             "movn   %[qc2],     %[t4],      %[t1]   \n\t"

  331.             "movn   %[qc3],     %[t4],      %[t2]   \n\t"

  332.             "movn   %[qc4],     %[t4],      %[t3]   \n\t"

  333.             "lw     %[t0],      0(%[in_int])        \n\t"

  334.             "lw     %[t1],      4(%[in_int])        \n\t"

  335.             "lw     %[t2],      8(%[in_int])        \n\t"

  336.             "lw     %[t3],      12(%[in_int])       \n\t"

  337.             "slt    %[t0],      %[t0],      $zero   \n\t"

  338.             "movn   %[sign],    %[t0],      %[qc1]  \n\t"

  339.             "slt    %[t1],      %[t1],      $zero   \n\t"

  340.             "slt    %[t2],      %[t2],      $zero   \n\t"

  341.             "slt    %[t3],      %[t3],      $zero   \n\t"

  342.             "sll    %[t0],      %[sign],    1       \n\t"

  343.             "or     %[t0],      %[t0],      %[t1]   \n\t"

  344.             "movn   %[sign],    %[t0],      %[qc2]  \n\t"

  345.             "slt    %[t4],      $zero,      %[qc1]  \n\t"

  346.             "slt    %[t1],      $zero,      %[qc2]  \n\t"

  347.             "slt    %[count],   $zero,      %[qc3]  \n\t"

  348.             "sll    %[t0],      %[sign],    1       \n\t"

  349.             "or     %[t0],      %[t0],      %[t2]   \n\t"

  350.             "movn   %[sign],    %[t0],      %[qc3]  \n\t"

  351.             "slt    %[t2],      $zero,      %[qc4]  \n\t"

  352.             "addu   %[count],   %[count],   %[t4]   \n\t"

  353.             "addu   %[count],   %[count],   %[t1]   \n\t"

  354.             "sll    %[t0],      %[sign],    1       \n\t"

  355.             "or     %[t0],      %[t0],      %[t3]   \n\t"

  356.             "movn   %[sign],    %[t0],      %[qc4]  \n\t"

  357.             "addu   %[count],   %[count],   %[t2]   \n\t"

  358. 

  359.             ".set pop                               \n\t"

  360. 

  361.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  362.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  363.               [sign]"=&r"(sign), [count]"=&r"(count),

  364.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  365.               [t4]"=&r"(t4)

  366.             : [in_int]"r"(in_int)

  367.             : "memory"

  368.         );

  369. 

  370.         curidx = qc1;

  371.         curidx *= 3;

  372.         curidx += qc2;

  373.         curidx *= 3;

  374.         curidx += qc3;

  375.         curidx *= 3;

  376.         curidx += qc4;

  377. 

  378.         v_codes = (p_codes[curidx] << count) | (sign & ((1 << count) - 1));

  379.         v_bits  = p_bits[curidx] + count;

  380.         put_bits(pb, v_bits, v_codes);

  381. 

  382.         if (out || energy) {

  383.             float e1,e2,e3,e4;

  384.             vec = &p_vec[curidx*4];

  385.             e1 = copysignf(vec[0] * IQ, in[i+0]);

  386.             e2 = copysignf(vec[1] * IQ, in[i+1]);

  387.             e3 = copysignf(vec[2] * IQ, in[i+2]);

  388.             e4 = copysignf(vec[3] * IQ, in[i+3]);

  389.             if (out) {

  390.                 out[i+0] = e1;

  391.                 out[i+1] = e2;

  392.                 out[i+2] = e3;

  393.                 out[i+3] = e4;

  394.             }

  395.             if (energy)

  396.                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);

  397.         }

  398.     }

  399.     if (energy)

  400.         *energy = qenergy;

  401. }

  402. 

  403. static void quantize_and_encode_band_cost_SPAIR_mips(struct AACEncContext *s,

  404.                                                      PutBitContext *pb, const float *in, float *out,

  405.                                                      const float *scaled, int size, int scale_idx,

  406.                                                      int cb, const float lambda, const float uplim,

  407.                                                      int *bits, float *energy, const float ROUNDING)

  408. {

  409.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  410.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  411.     int i;

  412.     int qc1, qc2, qc3, qc4;

  413.     float qenergy = 0.0f;

  414. 

  415.     uint8_t  *p_bits  = (uint8_t  *)ff_aac_spectral_bits[cb-1];

  416.     uint16_t *p_codes = (uint16_t *)ff_aac_spectral_codes[cb-1];

  417.     float    *p_vec   = (float    *)ff_aac_codebook_vectors[cb-1];

  418. 

  419.     abs_pow34_v(s->scoefs, in, size);

  420.     scaled = s->scoefs;

  421.     for (i = 0; i < size; i += 4) {

  422.         int curidx, curidx2;

  423.         int *in_int = (int *)&in[i];

  424.         uint8_t v_bits;

  425.         unsigned int v_codes;

  426.         int t0, t1, t2, t3, t4, t5, t6, t7;

  427.         const float *vec1, *vec2;

  428. 

  429.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  430.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  431.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  432.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  433. 

  434.         __asm__ volatile (

  435.             ".set push                      \n\t"

  436.             ".set noreorder                 \n\t"

  437. 

  438.             "ori    %[t4],  $zero,  4       \n\t"

  439.             "slt    %[t0],  %[t4],  %[qc1]  \n\t"

  440.             "slt    %[t1],  %[t4],  %[qc2]  \n\t"

  441.             "slt    %[t2],  %[t4],  %[qc3]  \n\t"

  442.             "slt    %[t3],  %[t4],  %[qc4]  \n\t"

  443.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  444.             "movn   %[qc2], %[t4],  %[t1]   \n\t"

  445.             "movn   %[qc3], %[t4],  %[t2]   \n\t"

  446.             "movn   %[qc4], %[t4],  %[t3]   \n\t"

  447.             "lw     %[t0],  0(%[in_int])    \n\t"

  448.             "lw     %[t1],  4(%[in_int])    \n\t"

  449.             "lw     %[t2],  8(%[in_int])    \n\t"

  450.             "lw     %[t3],  12(%[in_int])   \n\t"

  451.             "srl    %[t0],  %[t0],  31      \n\t"

  452.             "srl    %[t1],  %[t1],  31      \n\t"

  453.             "srl    %[t2],  %[t2],  31      \n\t"

  454.             "srl    %[t3],  %[t3],  31      \n\t"

  455.             "subu   %[t4],  $zero,  %[qc1]  \n\t"

  456.             "subu   %[t5],  $zero,  %[qc2]  \n\t"

  457.             "subu   %[t6],  $zero,  %[qc3]  \n\t"

  458.             "subu   %[t7],  $zero,  %[qc4]  \n\t"

  459.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  460.             "movn   %[qc2], %[t5],  %[t1]   \n\t"

  461.             "movn   %[qc3], %[t6],  %[t2]   \n\t"

  462.             "movn   %[qc4], %[t7],  %[t3]   \n\t"

  463. 

  464.             ".set pop                       \n\t"

  465. 

  466.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  467.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  468.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  469.               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)

  470.             : [in_int]"r"(in_int)

  471.             : "memory"

  472.         );

  473. 

  474.         curidx = 9 * qc1;

  475.         curidx += qc2 + 40;

  476. 

  477.         curidx2 = 9 * qc3;

  478.         curidx2 += qc4 + 40;

  479. 

  480.         v_codes = (p_codes[curidx] << p_bits[curidx2]) | (p_codes[curidx2]);

  481.         v_bits  = p_bits[curidx] + p_bits[curidx2];

  482.         put_bits(pb, v_bits, v_codes);

  483. 

  484.         if (out || energy) {

  485.             float e1,e2,e3,e4;

  486.             vec1 = &p_vec[curidx*2 ];

  487.             vec2 = &p_vec[curidx2*2];

  488.             e1 = vec1[0] * IQ;

  489.             e2 = vec1[1] * IQ;

  490.             e3 = vec2[0] * IQ;

  491.             e4 = vec2[1] * IQ;

  492.             if (out) {

  493.                 out[i+0] = e1;

  494.                 out[i+1] = e2;

  495.                 out[i+2] = e3;

  496.                 out[i+3] = e4;

  497.             }

  498.             if (energy)

  499.                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);

  500.         }

  501.     }

  502.     if (energy)

  503.         *energy = qenergy;

  504. }

  505. 

  506. static void quantize_and_encode_band_cost_UPAIR7_mips(struct AACEncContext *s,

  507.                                                       PutBitContext *pb, const float *in, float *out,

  508.                                                       const float *scaled, int size, int scale_idx,

  509.                                                       int cb, const float lambda, const float uplim,

  510.                                                       int *bits, float *energy, const float ROUNDING)

  511. {

  512.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  513.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  514.     int i;

  515.     int qc1, qc2, qc3, qc4;

  516.     float qenergy = 0.0f;

  517. 

  518.     uint8_t  *p_bits  = (uint8_t*) ff_aac_spectral_bits[cb-1];

  519.     uint16_t *p_codes = (uint16_t*)ff_aac_spectral_codes[cb-1];

  520.     float    *p_vec   = (float    *)ff_aac_codebook_vectors[cb-1];

  521. 

  522.     abs_pow34_v(s->scoefs, in, size);

  523.     scaled = s->scoefs;

  524.     for (i = 0; i < size; i += 4) {

  525.         int curidx1, curidx2, sign1, count1, sign2, count2;

  526.         int *in_int = (int *)&in[i];

  527.         uint8_t v_bits;

  528.         unsigned int v_codes;

  529.         int t0, t1, t2, t3, t4;

  530.         const float *vec1, *vec2;

  531. 

  532.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  533.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  534.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  535.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  536. 

  537.         __asm__ volatile (

  538.             ".set push                              \n\t"

  539.             ".set noreorder                         \n\t"

  540. 

  541.             "ori    %[t4],      $zero,      7       \n\t"

  542.             "ori    %[sign1],   $zero,      0       \n\t"

  543.             "ori    %[sign2],   $zero,      0       \n\t"

  544.             "slt    %[t0],      %[t4],      %[qc1]  \n\t"

  545.             "slt    %[t1],      %[t4],      %[qc2]  \n\t"

  546.             "slt    %[t2],      %[t4],      %[qc3]  \n\t"

  547.             "slt    %[t3],      %[t4],      %[qc4]  \n\t"

  548.             "movn   %[qc1],     %[t4],      %[t0]   \n\t"

  549.             "movn   %[qc2],     %[t4],      %[t1]   \n\t"

  550.             "movn   %[qc3],     %[t4],      %[t2]   \n\t"

  551.             "movn   %[qc4],     %[t4],      %[t3]   \n\t"

  552.             "lw     %[t0],      0(%[in_int])        \n\t"

  553.             "lw     %[t1],      4(%[in_int])        \n\t"

  554.             "lw     %[t2],      8(%[in_int])        \n\t"

  555.             "lw     %[t3],      12(%[in_int])       \n\t"

  556.             "slt    %[t0],      %[t0],      $zero   \n\t"

  557.             "movn   %[sign1],   %[t0],      %[qc1]  \n\t"

  558.             "slt    %[t2],      %[t2],      $zero   \n\t"

  559.             "movn   %[sign2],   %[t2],      %[qc3]  \n\t"

  560.             "slt    %[t1],      %[t1],      $zero   \n\t"

  561.             "sll    %[t0],      %[sign1],   1       \n\t"

  562.             "or     %[t0],      %[t0],      %[t1]   \n\t"

  563.             "movn   %[sign1],   %[t0],      %[qc2]  \n\t"

  564.             "slt    %[t3],      %[t3],      $zero   \n\t"

  565.             "sll    %[t0],      %[sign2],   1       \n\t"

  566.             "or     %[t0],      %[t0],      %[t3]   \n\t"

  567.             "movn   %[sign2],   %[t0],      %[qc4]  \n\t"

  568.             "slt    %[count1],  $zero,      %[qc1]  \n\t"

  569.             "slt    %[t1],      $zero,      %[qc2]  \n\t"

  570.             "slt    %[count2],  $zero,      %[qc3]  \n\t"

  571.             "slt    %[t2],      $zero,      %[qc4]  \n\t"

  572.             "addu   %[count1],  %[count1],  %[t1]   \n\t"

  573.             "addu   %[count2],  %[count2],  %[t2]   \n\t"

  574. 

  575.             ".set pop                               \n\t"

  576. 

  577.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  578.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  579.               [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  580.               [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  581.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  582.               [t4]"=&r"(t4)

  583.             : [in_int]"r"(in_int)

  584.             : "t0", "t1", "t2", "t3", "t4",

  585.               "memory"

  586.         );

  587. 

  588.         curidx1  = 8 * qc1;

  589.         curidx1 += qc2;

  590. 

  591.         v_codes = (p_codes[curidx1] << count1) | sign1;

  592.         v_bits  = p_bits[curidx1] + count1;

  593.         put_bits(pb, v_bits, v_codes);

  594. 

  595.         curidx2  = 8 * qc3;

  596.         curidx2 += qc4;

  597. 

  598.         v_codes = (p_codes[curidx2] << count2) | sign2;

  599.         v_bits  = p_bits[curidx2] + count2;

  600.         put_bits(pb, v_bits, v_codes);

  601. 

  602.         if (out || energy) {

  603.             float e1,e2,e3,e4;

  604.             vec1 = &p_vec[curidx1*2];

  605.             vec2 = &p_vec[curidx2*2];

  606.             e1 = copysignf(vec1[0] * IQ, in[i+0]);

  607.             e2 = copysignf(vec1[1] * IQ, in[i+1]);

  608.             e3 = copysignf(vec2[0] * IQ, in[i+2]);

  609.             e4 = copysignf(vec2[1] * IQ, in[i+3]);

  610.             if (out) {

  611.                 out[i+0] = e1;

  612.                 out[i+1] = e2;

  613.                 out[i+2] = e3;

  614.                 out[i+3] = e4;

  615.             }

  616.             if (energy)

  617.                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);

  618.         }

  619.     }

  620.     if (energy)

  621.         *energy = qenergy;

  622. }

  623. 

  624. static void quantize_and_encode_band_cost_UPAIR12_mips(struct AACEncContext *s,

  625.                                                        PutBitContext *pb, const float *in, float *out,

  626.                                                        const float *scaled, int size, int scale_idx,

  627.                                                        int cb, const float lambda, const float uplim,

  628.                                                        int *bits, float *energy, const float ROUNDING)

  629. {

  630.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  631.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  632.     int i;

  633.     int qc1, qc2, qc3, qc4;

  634.     float qenergy = 0.0f;

  635. 

  636.     uint8_t  *p_bits  = (uint8_t*) ff_aac_spectral_bits[cb-1];

  637.     uint16_t *p_codes = (uint16_t*)ff_aac_spectral_codes[cb-1];

  638.     float    *p_vec   = (float   *)ff_aac_codebook_vectors[cb-1];

  639. 

  640.     abs_pow34_v(s->scoefs, in, size);

  641.     scaled = s->scoefs;

  642.     for (i = 0; i < size; i += 4) {

  643.         int curidx1, curidx2, sign1, count1, sign2, count2;

  644.         int *in_int = (int *)&in[i];

  645.         uint8_t v_bits;

  646.         unsigned int v_codes;

  647.         int t0, t1, t2, t3, t4;

  648.         const float *vec1, *vec2;

  649. 

  650.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  651.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  652.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  653.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  654. 

  655.         __asm__ volatile (

  656.             ".set push                              \n\t"

  657.             ".set noreorder                         \n\t"

  658. 

  659.             "ori    %[t4],      $zero,      12      \n\t"

  660.             "ori    %[sign1],   $zero,      0       \n\t"

  661.             "ori    %[sign2],   $zero,      0       \n\t"

  662.             "slt    %[t0],      %[t4],      %[qc1]  \n\t"

  663.             "slt    %[t1],      %[t4],      %[qc2]  \n\t"

  664.             "slt    %[t2],      %[t4],      %[qc3]  \n\t"

  665.             "slt    %[t3],      %[t4],      %[qc4]  \n\t"

  666.             "movn   %[qc1],     %[t4],      %[t0]   \n\t"

  667.             "movn   %[qc2],     %[t4],      %[t1]   \n\t"

  668.             "movn   %[qc3],     %[t4],      %[t2]   \n\t"

  669.             "movn   %[qc4],     %[t4],      %[t3]   \n\t"

  670.             "lw     %[t0],      0(%[in_int])        \n\t"

  671.             "lw     %[t1],      4(%[in_int])        \n\t"

  672.             "lw     %[t2],      8(%[in_int])        \n\t"

  673.             "lw     %[t3],      12(%[in_int])       \n\t"

  674.             "slt    %[t0],      %[t0],      $zero   \n\t"

  675.             "movn   %[sign1],   %[t0],      %[qc1]  \n\t"

  676.             "slt    %[t2],      %[t2],      $zero   \n\t"

  677.             "movn   %[sign2],   %[t2],      %[qc3]  \n\t"

  678.             "slt    %[t1],      %[t1],      $zero   \n\t"

  679.             "sll    %[t0],      %[sign1],   1       \n\t"

  680.             "or     %[t0],      %[t0],      %[t1]   \n\t"

  681.             "movn   %[sign1],   %[t0],      %[qc2]  \n\t"

  682.             "slt    %[t3],      %[t3],      $zero   \n\t"

  683.             "sll    %[t0],      %[sign2],   1       \n\t"

  684.             "or     %[t0],      %[t0],      %[t3]   \n\t"

  685.             "movn   %[sign2],   %[t0],      %[qc4]  \n\t"

  686.             "slt    %[count1],  $zero,      %[qc1]  \n\t"

  687.             "slt    %[t1],      $zero,      %[qc2]  \n\t"

  688.             "slt    %[count2],  $zero,      %[qc3]  \n\t"

  689.             "slt    %[t2],      $zero,      %[qc4]  \n\t"

  690.             "addu   %[count1],  %[count1],  %[t1]   \n\t"

  691.             "addu   %[count2],  %[count2],  %[t2]   \n\t"

  692. 

  693.             ".set pop                               \n\t"

  694. 

  695.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  696.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  697.               [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  698.               [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  699.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  700.               [t4]"=&r"(t4)

  701.             : [in_int]"r"(in_int)

  702.             : "memory"

  703.         );

  704. 

  705.         curidx1  = 13 * qc1;

  706.         curidx1 += qc2;

  707. 

  708.         v_codes = (p_codes[curidx1] << count1) | sign1;

  709.         v_bits  = p_bits[curidx1] + count1;

  710.         put_bits(pb, v_bits, v_codes);

  711. 

  712.         curidx2  = 13 * qc3;

  713.         curidx2 += qc4;

  714. 

  715.         v_codes = (p_codes[curidx2] << count2) | sign2;

  716.         v_bits  = p_bits[curidx2] + count2;

  717.         put_bits(pb, v_bits, v_codes);

  718. 

  719.         if (out || energy) {

  720.             float e1,e2,e3,e4;

  721.             vec1 = &p_vec[curidx1*2];

  722.             vec2 = &p_vec[curidx2*2];

  723.             e1 = copysignf(vec1[0] * IQ, in[i+0]);

  724.             e2 = copysignf(vec1[1] * IQ, in[i+1]);

  725.             e3 = copysignf(vec2[0] * IQ, in[i+2]);

  726.             e4 = copysignf(vec2[1] * IQ, in[i+3]);

  727.             if (out) {

  728.                 out[i+0] = e1;

  729.                 out[i+1] = e2;

  730.                 out[i+2] = e3;

  731.                 out[i+3] = e4;

  732.             }

  733.             if (energy)

  734.                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);

  735.         }

  736.     }

  737.     if (energy)

  738.         *energy = qenergy;

  739. }

  740. 

  741. static void quantize_and_encode_band_cost_ESC_mips(struct AACEncContext *s,

  742.                                                    PutBitContext *pb, const float *in, float *out,

  743.                                                    const float *scaled, int size, int scale_idx,

  744.                                                    int cb, const float lambda, const float uplim,

  745.                                                    int *bits, float *energy, const float ROUNDING)

  746. {

  747.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  748.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  749.     int i;

  750.     int qc1, qc2, qc3, qc4;

  751.     float qenergy = 0.0f;

  752. 

  753.     uint8_t  *p_bits    = (uint8_t* )ff_aac_spectral_bits[cb-1];

  754.     uint16_t *p_codes   = (uint16_t*)ff_aac_spectral_codes[cb-1];

  755.     float    *p_vectors = (float*   )ff_aac_codebook_vectors[cb-1];

  756. 

  757.     abs_pow34_v(s->scoefs, in, size);

  758.     scaled = s->scoefs;

  759. 

  760.     if (cb < 11) {

  761.         for (i = 0; i < size; i += 4) {

  762.             int curidx, curidx2, sign1, count1, sign2, count2;

  763.             int *in_int = (int *)&in[i];

  764.             uint8_t v_bits;

  765.             unsigned int v_codes;

  766.             int t0, t1, t2, t3, t4;

  767.             const float *vec1, *vec2;

  768. 

  769.             qc1 = scaled[i  ] * Q34 + ROUNDING;

  770.             qc2 = scaled[i+1] * Q34 + ROUNDING;

  771.             qc3 = scaled[i+2] * Q34 + ROUNDING;

  772.             qc4 = scaled[i+3] * Q34 + ROUNDING;

  773. 

  774.             __asm__ volatile (

  775.                 ".set push                                  \n\t"

  776.                 ".set noreorder                             \n\t"

  777. 

  778.                 "ori        %[t4],      $zero,      16      \n\t"

  779.                 "ori        %[sign1],   $zero,      0       \n\t"

  780.                 "ori        %[sign2],   $zero,      0       \n\t"

  781.                 "slt        %[t0],      %[t4],      %[qc1]  \n\t"

  782.                 "slt        %[t1],      %[t4],      %[qc2]  \n\t"

  783.                 "slt        %[t2],      %[t4],      %[qc3]  \n\t"

  784.                 "slt        %[t3],      %[t4],      %[qc4]  \n\t"

  785.                 "movn       %[qc1],     %[t4],      %[t0]   \n\t"

  786.                 "movn       %[qc2],     %[t4],      %[t1]   \n\t"

  787.                 "movn       %[qc3],     %[t4],      %[t2]   \n\t"

  788.                 "movn       %[qc4],     %[t4],      %[t3]   \n\t"

  789.                 "lw         %[t0],      0(%[in_int])        \n\t"

  790.                 "lw         %[t1],      4(%[in_int])        \n\t"

  791.                 "lw         %[t2],      8(%[in_int])        \n\t"

  792.                 "lw         %[t3],      12(%[in_int])       \n\t"

  793.                 "slt        %[t0],      %[t0],      $zero   \n\t"

  794.                 "movn       %[sign1],   %[t0],      %[qc1]  \n\t"

  795.                 "slt        %[t2],      %[t2],      $zero   \n\t"

  796.                 "movn       %[sign2],   %[t2],      %[qc3]  \n\t"

  797.                 "slt        %[t1],      %[t1],      $zero   \n\t"

  798.                 "sll        %[t0],      %[sign1],   1       \n\t"

  799.                 "or         %[t0],      %[t0],      %[t1]   \n\t"

  800.                 "movn       %[sign1],   %[t0],      %[qc2]  \n\t"

  801.                 "slt        %[t3],      %[t3],      $zero   \n\t"

  802.                 "sll        %[t0],      %[sign2],   1       \n\t"

  803.                 "or         %[t0],      %[t0],      %[t3]   \n\t"

  804.                 "movn       %[sign2],   %[t0],      %[qc4]  \n\t"

  805.                 "slt        %[count1],  $zero,      %[qc1]  \n\t"

  806.                 "slt        %[t1],      $zero,      %[qc2]  \n\t"

  807.                 "slt        %[count2],  $zero,      %[qc3]  \n\t"

  808.                 "slt        %[t2],      $zero,      %[qc4]  \n\t"

  809.                 "addu       %[count1],  %[count1],  %[t1]   \n\t"

  810.                 "addu       %[count2],  %[count2],  %[t2]   \n\t"

  811. 

  812.                 ".set pop                                   \n\t"

  813. 

  814.                 : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  815.                   [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  816.                   [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  817.                   [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  818.                   [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  819.                   [t4]"=&r"(t4)

  820.                 : [in_int]"r"(in_int)

  821.                 : "memory"

  822.             );

  823. 

  824.             curidx = 17 * qc1;

  825.             curidx += qc2;

  826.             curidx2 = 17 * qc3;

  827.             curidx2 += qc4;

  828. 

  829.             v_codes = (p_codes[curidx] << count1) | sign1;

  830.             v_bits  = p_bits[curidx] + count1;

  831.             put_bits(pb, v_bits, v_codes);

  832. 

  833.             v_codes = (p_codes[curidx2] << count2) | sign2;

  834.             v_bits  = p_bits[curidx2] + count2;

  835.             put_bits(pb, v_bits, v_codes);

  836. 

  837.             if (out || energy) {

  838.                 float e1,e2,e3,e4;

  839.                 vec1 = &p_vectors[curidx*2 ];

  840.                 vec2 = &p_vectors[curidx2*2];

  841.                 e1 = copysignf(vec1[0] * IQ, in[i+0]);

  842.                 e2 = copysignf(vec1[1] * IQ, in[i+1]);

  843.                 e3 = copysignf(vec2[0] * IQ, in[i+2]);

  844.                 e4 = copysignf(vec2[1] * IQ, in[i+3]);

  845.                 if (out) {

  846.                     out[i+0] = e1;

  847.                     out[i+1] = e2;

  848.                     out[i+2] = e3;

  849.                     out[i+3] = e4;

  850.                 }

  851.                 if (energy)

  852.                     qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);

  853.             }

  854.         }

  855.     } else {

  856.         for (i = 0; i < size; i += 4) {

  857.             int curidx, curidx2, sign1, count1, sign2, count2;

  858.             int *in_int = (int *)&in[i];

  859.             uint8_t v_bits;

  860.             unsigned int v_codes;

  861.             int c1, c2, c3, c4;

  862.             int t0, t1, t2, t3, t4;

  863.             const float *vec1, *vec2;

  864. 

  865.             qc1 = scaled[i  ] * Q34 + ROUNDING;

  866.             qc2 = scaled[i+1] * Q34 + ROUNDING;

  867.             qc3 = scaled[i+2] * Q34 + ROUNDING;

  868.             qc4 = scaled[i+3] * Q34 + ROUNDING;

  869. 

  870.             __asm__ volatile (

  871.                 ".set push                                  \n\t"

  872.                 ".set noreorder                             \n\t"

  873. 

  874.                 "ori        %[t4],      $zero,      16      \n\t"

  875.                 "ori        %[sign1],   $zero,      0       \n\t"

  876.                 "ori        %[sign2],   $zero,      0       \n\t"

  877.                 "shll_s.w   %[c1],      %[qc1],     18      \n\t"

  878.                 "shll_s.w   %[c2],      %[qc2],     18      \n\t"

  879.                 "shll_s.w   %[c3],      %[qc3],     18      \n\t"

  880.                 "shll_s.w   %[c4],      %[qc4],     18      \n\t"

  881.                 "srl        %[c1],      %[c1],      18      \n\t"

  882.                 "srl        %[c2],      %[c2],      18      \n\t"

  883.                 "srl        %[c3],      %[c3],      18      \n\t"

  884.                 "srl        %[c4],      %[c4],      18      \n\t"

  885.                 "slt        %[t0],      %[t4],      %[qc1]  \n\t"

  886.                 "slt        %[t1],      %[t4],      %[qc2]  \n\t"

  887.                 "slt        %[t2],      %[t4],      %[qc3]  \n\t"

  888.                 "slt        %[t3],      %[t4],      %[qc4]  \n\t"

  889.                 "movn       %[qc1],     %[t4],      %[t0]   \n\t"

  890.                 "movn       %[qc2],     %[t4],      %[t1]   \n\t"

  891.                 "movn       %[qc3],     %[t4],      %[t2]   \n\t"

  892.                 "movn       %[qc4],     %[t4],      %[t3]   \n\t"

  893.                 "lw         %[t0],      0(%[in_int])        \n\t"

  894.                 "lw         %[t1],      4(%[in_int])        \n\t"

  895.                 "lw         %[t2],      8(%[in_int])        \n\t"

  896.                 "lw         %[t3],      12(%[in_int])       \n\t"

  897.                 "slt        %[t0],      %[t0],      $zero   \n\t"

  898.                 "movn       %[sign1],   %[t0],      %[qc1]  \n\t"

  899.                 "slt        %[t2],      %[t2],      $zero   \n\t"

  900.                 "movn       %[sign2],   %[t2],      %[qc3]  \n\t"

  901.                 "slt        %[t1],      %[t1],      $zero   \n\t"

  902.                 "sll        %[t0],      %[sign1],   1       \n\t"

  903.                 "or         %[t0],      %[t0],      %[t1]   \n\t"

  904.                 "movn       %[sign1],   %[t0],      %[qc2]  \n\t"

  905.                 "slt        %[t3],      %[t3],      $zero   \n\t"

  906.                 "sll        %[t0],      %[sign2],   1       \n\t"

  907.                 "or         %[t0],      %[t0],      %[t3]   \n\t"

  908.                 "movn       %[sign2],   %[t0],      %[qc4]  \n\t"

  909.                 "slt        %[count1],  $zero,      %[qc1]  \n\t"

  910.                 "slt        %[t1],      $zero,      %[qc2]  \n\t"

  911.                 "slt        %[count2],  $zero,      %[qc3]  \n\t"

  912.                 "slt        %[t2],      $zero,      %[qc4]  \n\t"

  913.                 "addu       %[count1],  %[count1],  %[t1]   \n\t"

  914.                 "addu       %[count2],  %[count2],  %[t2]   \n\t"

  915. 

  916.                 ".set pop                                   \n\t"

  917. 

  918.                 : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  919.                   [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  920.                   [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  921.                   [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  922.                   [c1]"=&r"(c1), [c2]"=&r"(c2),

  923.                   [c3]"=&r"(c3), [c4]"=&r"(c4),

  924.                   [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  925.                   [t4]"=&r"(t4)

  926.                 : [in_int]"r"(in_int)

  927.                 : "memory"

  928.             );

  929. 

  930.             curidx = 17 * qc1;

  931.             curidx += qc2;

  932. 

  933.             curidx2 = 17 * qc3;

  934.             curidx2 += qc4;

  935. 

  936.             v_codes = (p_codes[curidx] << count1) | sign1;

  937.             v_bits  = p_bits[curidx] + count1;

  938.             put_bits(pb, v_bits, v_codes);

  939. 

  940.             if (p_vectors[curidx*2  ] == 64.0f) {

  941.                 int len = av_log2(c1);

  942.                 v_codes = (((1 << (len - 3)) - 2) << len) | (c1 & ((1 << len) - 1));

  943.                 put_bits(pb, len * 2 - 3, v_codes);

  944.             }

  945.             if (p_vectors[curidx*2+1] == 64.0f) {

  946.                 int len = av_log2(c2);

  947.                 v_codes = (((1 << (len - 3)) - 2) << len) | (c2 & ((1 << len) - 1));

  948.                 put_bits(pb, len*2-3, v_codes);

  949.             }

  950. 

  951.             v_codes = (p_codes[curidx2] << count2) | sign2;

  952.             v_bits  = p_bits[curidx2] + count2;

  953.             put_bits(pb, v_bits, v_codes);

  954. 

  955.             if (p_vectors[curidx2*2  ] == 64.0f) {

  956.                 int len = av_log2(c3);

  957.                 v_codes = (((1 << (len - 3)) - 2) << len) | (c3 & ((1 << len) - 1));

  958.                 put_bits(pb, len* 2 - 3, v_codes);

  959.             }

  960.             if (p_vectors[curidx2*2+1] == 64.0f) {

  961.                 int len = av_log2(c4);

  962.                 v_codes = (((1 << (len - 3)) - 2) << len) | (c4 & ((1 << len) - 1));

  963.                 put_bits(pb, len * 2 - 3, v_codes);

  964.             }

  965. 

  966.             if (out || energy) {

  967.                 float e1, e2, e3, e4;

  968.                 vec1 = &p_vectors[curidx*2];

  969.                 vec2 = &p_vectors[curidx2*2];

  970.                 e1 = copysignf(c1 * cbrtf(c1) * IQ, in[i+0]);

  971.                 e2 = copysignf(c2 * cbrtf(c2) * IQ, in[i+1]);

  972.                 e3 = copysignf(c3 * cbrtf(c3) * IQ, in[i+2]);

  973.                 e4 = copysignf(c4 * cbrtf(c4) * IQ, in[i+3]);

  974.                 if (out) {

  975.                     out[i+0] = e1;

  976.                     out[i+1] = e2;

  977.                     out[i+2] = e3;

  978.                     out[i+3] = e4;

  979.                 }

  980.                 if (energy)

  981.                     qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);

  982.             }

  983.         }

  984.     }

  985.     if (energy)

  986.         *energy = qenergy;

  987. }

  988. 

  989. static void quantize_and_encode_band_cost_NONE_mips(struct AACEncContext *s,

  990.                                                          PutBitContext *pb, const float *in, float *out,

  991.                                                          const float *scaled, int size, int scale_idx,

  992.                                                          int cb, const float lambda, const float uplim,

  993.                                                          int *bits, float *energy, const float ROUNDING) {

  994.     av_assert0(0);

  995. }

  996. 

  997. static void quantize_and_encode_band_cost_ZERO_mips(struct AACEncContext *s,

  998.                                                          PutBitContext *pb, const float *in, float *out,

  999.                                                          const float *scaled, int size, int scale_idx,

  1000.                                                          int cb, const float lambda, const float uplim,

  1001.                                                          int *bits, float *energy, const float ROUNDING) {

  1002.     int i;

  1003.     if (bits)

  1004.         *bits = 0;

  1005.     if (out) {

  1006.         for (i = 0; i < size; i += 4) {

  1007.            out[i  ] = 0.0f;

  1008.            out[i+1] = 0.0f;

  1009.            out[i+2] = 0.0f;

  1010.            out[i+3] = 0.0f;

  1011.         }

  1012.     }

  1013.     if (energy)

  1014.         *energy = 0.0f;

  1015. }

  1016. 

  1017. static void (*const quantize_and_encode_band_cost_arr[])(struct AACEncContext *s,

  1018.                                                          PutBitContext *pb, const float *in, float *out,

  1019.                                                          const float *scaled, int size, int scale_idx,

  1020.                                                          int cb, const float lambda, const float uplim,

  1021.                                                          int *bits, float *energy, const float ROUNDING) = {

  1022.     quantize_and_encode_band_cost_ZERO_mips,

  1023.     quantize_and_encode_band_cost_SQUAD_mips,

  1024.     quantize_and_encode_band_cost_SQUAD_mips,

  1025.     quantize_and_encode_band_cost_UQUAD_mips,

  1026.     quantize_and_encode_band_cost_UQUAD_mips,

  1027.     quantize_and_encode_band_cost_SPAIR_mips,

  1028.     quantize_and_encode_band_cost_SPAIR_mips,

  1029.     quantize_and_encode_band_cost_UPAIR7_mips,

  1030.     quantize_and_encode_band_cost_UPAIR7_mips,

  1031.     quantize_and_encode_band_cost_UPAIR12_mips,

  1032.     quantize_and_encode_band_cost_UPAIR12_mips,

  1033.     quantize_and_encode_band_cost_ESC_mips,

  1034.     quantize_and_encode_band_cost_NONE_mips, /* cb 12 doesn't exist */

  1035.     quantize_and_encode_band_cost_ZERO_mips,

  1036.     quantize_and_encode_band_cost_ZERO_mips,

  1037.     quantize_and_encode_band_cost_ZERO_mips,

  1038. };

  1039. 

  1040. #define quantize_and_encode_band_cost(                                       \

  1041.                                 s, pb, in, out, scaled, size, scale_idx, cb, \

  1042.                                 lambda, uplim, bits, energy, ROUNDING)       \

  1043.     quantize_and_encode_band_cost_arr[cb](                                   \

  1044.                                 s, pb, in, out, scaled, size, scale_idx, cb, \

  1045.                                 lambda, uplim, bits, energy, ROUNDING)

  1046. 

  1047. static void quantize_and_encode_band_mips(struct AACEncContext *s, PutBitContext *pb,

  1048.                                           const float *in, float *out, int size, int scale_idx,

  1049.                                           int cb, const float lambda, int rtz)

  1050. {

  1051.     quantize_and_encode_band_cost(s, pb, in, out, NULL, size, scale_idx, cb, lambda,

  1052.                                   INFINITY, NULL, NULL, (rtz) ? ROUND_TO_ZERO : ROUND_STANDARD);

  1053. }

  1054. 

  1055. /**

  1056.  * Functions developed from template function and optimized for getting the number of bits

  1057.  */

  1058. static float get_band_numbits_ZERO_mips(struct AACEncContext *s,

  1059.                                         PutBitContext *pb, const float *in,

  1060.                                         const float *scaled, int size, int scale_idx,

  1061.                                         int cb, const float lambda, const float uplim,

  1062.                                         int *bits)

  1063. {

  1064.     return 0;

  1065. }

  1066. 

  1067. static float get_band_numbits_NONE_mips(struct AACEncContext *s,

  1068.                                         PutBitContext *pb, const float *in,

  1069.                                         const float *scaled, int size, int scale_idx,

  1070.                                         int cb, const float lambda, const float uplim,

  1071.                                         int *bits)

  1072. {

  1073.     av_assert0(0);

  1074.     return 0;

  1075. }

  1076. 

  1077. static float get_band_numbits_SQUAD_mips(struct AACEncContext *s,

  1078.                                          PutBitContext *pb, const float *in,

  1079.                                          const float *scaled, int size, int scale_idx,

  1080.                                          int cb, const float lambda, const float uplim,

  1081.                                          int *bits)

  1082. {

  1083.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1084.     int i;

  1085.     int qc1, qc2, qc3, qc4;

  1086.     int curbits = 0;

  1087. 

  1088.     uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1089. 

  1090.     for (i = 0; i < size; i += 4) {

  1091.         int curidx;

  1092.         int *in_int = (int *)&in[i];

  1093.         int t0, t1, t2, t3, t4, t5, t6, t7;

  1094. 

  1095.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1096.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1097.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1098.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1099. 

  1100.         __asm__ volatile (

  1101.             ".set push                      \n\t"

  1102.             ".set noreorder                 \n\t"

  1103. 

  1104.             "slt    %[qc1], $zero,  %[qc1]  \n\t"

  1105.             "slt    %[qc2], $zero,  %[qc2]  \n\t"

  1106.             "slt    %[qc3], $zero,  %[qc3]  \n\t"

  1107.             "slt    %[qc4], $zero,  %[qc4]  \n\t"

  1108.             "lw     %[t0],  0(%[in_int])    \n\t"

  1109.             "lw     %[t1],  4(%[in_int])    \n\t"

  1110.             "lw     %[t2],  8(%[in_int])    \n\t"

  1111.             "lw     %[t3],  12(%[in_int])   \n\t"

  1112.             "srl    %[t0],  %[t0],  31      \n\t"

  1113.             "srl    %[t1],  %[t1],  31      \n\t"

  1114.             "srl    %[t2],  %[t2],  31      \n\t"

  1115.             "srl    %[t3],  %[t3],  31      \n\t"

  1116.             "subu   %[t4],  $zero,  %[qc1]  \n\t"

  1117.             "subu   %[t5],  $zero,  %[qc2]  \n\t"

  1118.             "subu   %[t6],  $zero,  %[qc3]  \n\t"

  1119.             "subu   %[t7],  $zero,  %[qc4]  \n\t"

  1120.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  1121.             "movn   %[qc2], %[t5],  %[t1]   \n\t"

  1122.             "movn   %[qc3], %[t6],  %[t2]   \n\t"

  1123.             "movn   %[qc4], %[t7],  %[t3]   \n\t"

  1124. 

  1125.             ".set pop                       \n\t"

  1126. 

  1127.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1128.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1129.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1130.               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)

  1131.             : [in_int]"r"(in_int)

  1132.             : "memory"

  1133.         );

  1134. 

  1135.         curidx = qc1;

  1136.         curidx *= 3;

  1137.         curidx += qc2;

  1138.         curidx *= 3;

  1139.         curidx += qc3;

  1140.         curidx *= 3;

  1141.         curidx += qc4;

  1142.         curidx += 40;

  1143. 

  1144.         curbits += p_bits[curidx];

  1145.     }

  1146.     return curbits;

  1147. }

  1148. 

  1149. static float get_band_numbits_UQUAD_mips(struct AACEncContext *s,

  1150.                                          PutBitContext *pb, const float *in,

  1151.                                          const float *scaled, int size, int scale_idx,

  1152.                                          int cb, const float lambda, const float uplim,

  1153.                                          int *bits)

  1154. {

  1155.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1156.     int i;

  1157.     int curbits = 0;

  1158.     int qc1, qc2, qc3, qc4;

  1159. 

  1160.     uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1161. 

  1162.     for (i = 0; i < size; i += 4) {

  1163.         int curidx;

  1164.         int t0, t1, t2, t3, t4;

  1165. 

  1166.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1167.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1168.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1169.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1170. 

  1171.         __asm__ volatile (

  1172.             ".set push                      \n\t"

  1173.             ".set noreorder                 \n\t"

  1174. 

  1175.             "ori    %[t4],  $zero,  2       \n\t"

  1176.             "slt    %[t0],  %[t4],  %[qc1]  \n\t"

  1177.             "slt    %[t1],  %[t4],  %[qc2]  \n\t"

  1178.             "slt    %[t2],  %[t4],  %[qc3]  \n\t"

  1179.             "slt    %[t3],  %[t4],  %[qc4]  \n\t"

  1180.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  1181.             "movn   %[qc2], %[t4],  %[t1]   \n\t"

  1182.             "movn   %[qc3], %[t4],  %[t2]   \n\t"

  1183.             "movn   %[qc4], %[t4],  %[t3]   \n\t"

  1184. 

  1185.             ".set pop                       \n\t"

  1186. 

  1187.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1188.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1189.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1190.               [t4]"=&r"(t4)

  1191.         );

  1192. 

  1193.         curidx = qc1;

  1194.         curidx *= 3;

  1195.         curidx += qc2;

  1196.         curidx *= 3;

  1197.         curidx += qc3;

  1198.         curidx *= 3;

  1199.         curidx += qc4;

  1200. 

  1201.         curbits += p_bits[curidx];

  1202.         curbits += uquad_sign_bits[curidx];

  1203.     }

  1204.     return curbits;

  1205. }

  1206. 

  1207. static float get_band_numbits_SPAIR_mips(struct AACEncContext *s,

  1208.                                          PutBitContext *pb, const float *in,

  1209.                                          const float *scaled, int size, int scale_idx,

  1210.                                          int cb, const float lambda, const float uplim,

  1211.                                          int *bits)

  1212. {

  1213.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1214.     int i;

  1215.     int qc1, qc2, qc3, qc4;

  1216.     int curbits = 0;

  1217. 

  1218.     uint8_t *p_bits = (uint8_t*)ff_aac_spectral_bits[cb-1];

  1219. 

  1220.     for (i = 0; i < size; i += 4) {

  1221.         int curidx, curidx2;

  1222.         int *in_int = (int *)&in[i];

  1223.         int t0, t1, t2, t3, t4, t5, t6, t7;

  1224. 

  1225.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1226.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1227.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1228.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1229. 

  1230.         __asm__ volatile (

  1231.             ".set push                      \n\t"

  1232.             ".set noreorder                 \n\t"

  1233. 

  1234.             "ori    %[t4],  $zero,  4       \n\t"

  1235.             "slt    %[t0],  %[t4],  %[qc1]  \n\t"

  1236.             "slt    %[t1],  %[t4],  %[qc2]  \n\t"

  1237.             "slt    %[t2],  %[t4],  %[qc3]  \n\t"

  1238.             "slt    %[t3],  %[t4],  %[qc4]  \n\t"

  1239.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  1240.             "movn   %[qc2], %[t4],  %[t1]   \n\t"

  1241.             "movn   %[qc3], %[t4],  %[t2]   \n\t"

  1242.             "movn   %[qc4], %[t4],  %[t3]   \n\t"

  1243.             "lw     %[t0],  0(%[in_int])    \n\t"

  1244.             "lw     %[t1],  4(%[in_int])    \n\t"

  1245.             "lw     %[t2],  8(%[in_int])    \n\t"

  1246.             "lw     %[t3],  12(%[in_int])   \n\t"

  1247.             "srl    %[t0],  %[t0],  31      \n\t"

  1248.             "srl    %[t1],  %[t1],  31      \n\t"

  1249.             "srl    %[t2],  %[t2],  31      \n\t"

  1250.             "srl    %[t3],  %[t3],  31      \n\t"

  1251.             "subu   %[t4],  $zero,  %[qc1]  \n\t"

  1252.             "subu   %[t5],  $zero,  %[qc2]  \n\t"

  1253.             "subu   %[t6],  $zero,  %[qc3]  \n\t"

  1254.             "subu   %[t7],  $zero,  %[qc4]  \n\t"

  1255.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  1256.             "movn   %[qc2], %[t5],  %[t1]   \n\t"

  1257.             "movn   %[qc3], %[t6],  %[t2]   \n\t"

  1258.             "movn   %[qc4], %[t7],  %[t3]   \n\t"

  1259. 

  1260.             ".set pop                       \n\t"

  1261. 

  1262.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1263.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1264.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1265.               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)

  1266.             : [in_int]"r"(in_int)

  1267.             : "memory"

  1268.         );

  1269. 

  1270.         curidx  = 9 * qc1;

  1271.         curidx += qc2 + 40;

  1272. 

  1273.         curidx2  = 9 * qc3;

  1274.         curidx2 += qc4 + 40;

  1275. 

  1276.         curbits += p_bits[curidx] + p_bits[curidx2];

  1277.     }

  1278.     return curbits;

  1279. }

  1280. 

  1281. static float get_band_numbits_UPAIR7_mips(struct AACEncContext *s,

  1282.                                           PutBitContext *pb, const float *in,

  1283.                                           const float *scaled, int size, int scale_idx,

  1284.                                           int cb, const float lambda, const float uplim,

  1285.                                           int *bits)

  1286. {

  1287.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1288.     int i;

  1289.     int qc1, qc2, qc3, qc4;

  1290.     int curbits = 0;

  1291. 

  1292.     uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1293. 

  1294.     for (i = 0; i < size; i += 4) {

  1295.         int curidx, curidx2;

  1296.         int t0, t1, t2, t3, t4;

  1297. 

  1298.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1299.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1300.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1301.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1302. 

  1303.         __asm__ volatile (

  1304.             ".set push                      \n\t"

  1305.             ".set noreorder                 \n\t"

  1306. 

  1307.             "ori    %[t4],  $zero,  7       \n\t"

  1308.             "slt    %[t0],  %[t4],  %[qc1]  \n\t"

  1309.             "slt    %[t1],  %[t4],  %[qc2]  \n\t"

  1310.             "slt    %[t2],  %[t4],  %[qc3]  \n\t"

  1311.             "slt    %[t3],  %[t4],  %[qc4]  \n\t"

  1312.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  1313.             "movn   %[qc2], %[t4],  %[t1]   \n\t"

  1314.             "movn   %[qc3], %[t4],  %[t2]   \n\t"

  1315.             "movn   %[qc4], %[t4],  %[t3]   \n\t"

  1316. 

  1317.             ".set pop                       \n\t"

  1318. 

  1319.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1320.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1321.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1322.               [t4]"=&r"(t4)

  1323.         );

  1324. 

  1325.         curidx  = 8 * qc1;

  1326.         curidx += qc2;

  1327. 

  1328.         curidx2  = 8 * qc3;

  1329.         curidx2 += qc4;

  1330. 

  1331.         curbits += p_bits[curidx] +

  1332.                    upair7_sign_bits[curidx] +

  1333.                    p_bits[curidx2] +

  1334.                    upair7_sign_bits[curidx2];

  1335.     }

  1336.     return curbits;

  1337. }

  1338. 

  1339. static float get_band_numbits_UPAIR12_mips(struct AACEncContext *s,

  1340.                                            PutBitContext *pb, const float *in,

  1341.                                            const float *scaled, int size, int scale_idx,

  1342.                                            int cb, const float lambda, const float uplim,

  1343.                                            int *bits)

  1344. {

  1345.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1346.     int i;

  1347.     int qc1, qc2, qc3, qc4;

  1348.     int curbits = 0;

  1349. 

  1350.     uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1351. 

  1352.     for (i = 0; i < size; i += 4) {

  1353.         int curidx, curidx2;

  1354.         int t0, t1, t2, t3, t4;

  1355. 

  1356.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1357.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1358.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1359.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1360. 

  1361.         __asm__ volatile (

  1362.             ".set push                      \n\t"

  1363.             ".set noreorder                 \n\t"

  1364. 

  1365.             "ori    %[t4],  $zero,  12      \n\t"

  1366.             "slt    %[t0],  %[t4],  %[qc1]  \n\t"

  1367.             "slt    %[t1],  %[t4],  %[qc2]  \n\t"

  1368.             "slt    %[t2],  %[t4],  %[qc3]  \n\t"

  1369.             "slt    %[t3],  %[t4],  %[qc4]  \n\t"

  1370.             "movn   %[qc1], %[t4],  %[t0]   \n\t"

  1371.             "movn   %[qc2], %[t4],  %[t1]   \n\t"

  1372.             "movn   %[qc3], %[t4],  %[t2]   \n\t"

  1373.             "movn   %[qc4], %[t4],  %[t3]   \n\t"

  1374. 

  1375.             ".set pop                       \n\t"

  1376. 

  1377.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1378.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1379.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1380.               [t4]"=&r"(t4)

  1381.         );

  1382. 

  1383.         curidx  = 13 * qc1;

  1384.         curidx += qc2;

  1385. 

  1386.         curidx2  = 13 * qc3;

  1387.         curidx2 += qc4;

  1388. 

  1389.         curbits += p_bits[curidx] +

  1390.                    p_bits[curidx2] +

  1391.                    upair12_sign_bits[curidx] +

  1392.                    upair12_sign_bits[curidx2];

  1393.     }

  1394.     return curbits;

  1395. }

  1396. 

  1397. static float get_band_numbits_ESC_mips(struct AACEncContext *s,

  1398.                                        PutBitContext *pb, const float *in,

  1399.                                        const float *scaled, int size, int scale_idx,

  1400.                                        int cb, const float lambda, const float uplim,

  1401.                                        int *bits)

  1402. {

  1403.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1404.     int i;

  1405.     int qc1, qc2, qc3, qc4;

  1406.     int curbits = 0;

  1407. 

  1408.     uint8_t *p_bits = (uint8_t*)ff_aac_spectral_bits[cb-1];

  1409. 

  1410.     for (i = 0; i < size; i += 4) {

  1411.         int curidx, curidx2;

  1412.         int cond0, cond1, cond2, cond3;

  1413.         int c1, c2, c3, c4;

  1414.         int t4, t5;

  1415. 

  1416.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1417.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1418.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1419.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1420. 

  1421.         __asm__ volatile (

  1422.             ".set push                                  \n\t"

  1423.             ".set noreorder                             \n\t"

  1424. 

  1425.             "ori        %[t4],      $zero,  15          \n\t"

  1426.             "ori        %[t5],      $zero,  16          \n\t"

  1427.             "shll_s.w   %[c1],      %[qc1], 18          \n\t"

  1428.             "shll_s.w   %[c2],      %[qc2], 18          \n\t"

  1429.             "shll_s.w   %[c3],      %[qc3], 18          \n\t"

  1430.             "shll_s.w   %[c4],      %[qc4], 18          \n\t"

  1431.             "srl        %[c1],      %[c1],  18          \n\t"

  1432.             "srl        %[c2],      %[c2],  18          \n\t"

  1433.             "srl        %[c3],      %[c3],  18          \n\t"

  1434.             "srl        %[c4],      %[c4],  18          \n\t"

  1435.             "slt        %[cond0],   %[t4],  %[qc1]      \n\t"

  1436.             "slt        %[cond1],   %[t4],  %[qc2]      \n\t"

  1437.             "slt        %[cond2],   %[t4],  %[qc3]      \n\t"

  1438.             "slt        %[cond3],   %[t4],  %[qc4]      \n\t"

  1439.             "movn       %[qc1],     %[t5],  %[cond0]    \n\t"

  1440.             "movn       %[qc2],     %[t5],  %[cond1]    \n\t"

  1441.             "movn       %[qc3],     %[t5],  %[cond2]    \n\t"

  1442.             "movn       %[qc4],     %[t5],  %[cond3]    \n\t"

  1443.             "ori        %[t5],      $zero,  31          \n\t"

  1444.             "clz        %[c1],      %[c1]               \n\t"

  1445.             "clz        %[c2],      %[c2]               \n\t"

  1446.             "clz        %[c3],      %[c3]               \n\t"

  1447.             "clz        %[c4],      %[c4]               \n\t"

  1448.             "subu       %[c1],      %[t5],  %[c1]       \n\t"

  1449.             "subu       %[c2],      %[t5],  %[c2]       \n\t"

  1450.             "subu       %[c3],      %[t5],  %[c3]       \n\t"

  1451.             "subu       %[c4],      %[t5],  %[c4]       \n\t"

  1452.             "sll        %[c1],      %[c1],  1           \n\t"

  1453.             "sll        %[c2],      %[c2],  1           \n\t"

  1454.             "sll        %[c3],      %[c3],  1           \n\t"

  1455.             "sll        %[c4],      %[c4],  1           \n\t"

  1456.             "addiu      %[c1],      %[c1],  -3          \n\t"

  1457.             "addiu      %[c2],      %[c2],  -3          \n\t"

  1458.             "addiu      %[c3],      %[c3],  -3          \n\t"

  1459.             "addiu      %[c4],      %[c4],  -3          \n\t"

  1460.             "subu       %[cond0],   $zero,  %[cond0]    \n\t"

  1461.             "subu       %[cond1],   $zero,  %[cond1]    \n\t"

  1462.             "subu       %[cond2],   $zero,  %[cond2]    \n\t"

  1463.             "subu       %[cond3],   $zero,  %[cond3]    \n\t"

  1464.             "and        %[c1],      %[c1],  %[cond0]    \n\t"

  1465.             "and        %[c2],      %[c2],  %[cond1]    \n\t"

  1466.             "and        %[c3],      %[c3],  %[cond2]    \n\t"

  1467.             "and        %[c4],      %[c4],  %[cond3]    \n\t"

  1468. 

  1469.             ".set pop                                   \n\t"

  1470. 

  1471.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1472.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1473.               [cond0]"=&r"(cond0), [cond1]"=&r"(cond1),

  1474.               [cond2]"=&r"(cond2), [cond3]"=&r"(cond3),

  1475.               [c1]"=&r"(c1), [c2]"=&r"(c2),

  1476.               [c3]"=&r"(c3), [c4]"=&r"(c4),

  1477.               [t4]"=&r"(t4), [t5]"=&r"(t5)

  1478.         );

  1479. 

  1480.         curidx = 17 * qc1;

  1481.         curidx += qc2;

  1482. 

  1483.         curidx2 = 17 * qc3;

  1484.         curidx2 += qc4;

  1485. 

  1486.         curbits += p_bits[curidx];

  1487.         curbits += esc_sign_bits[curidx];

  1488.         curbits += p_bits[curidx2];

  1489.         curbits += esc_sign_bits[curidx2];

  1490. 

  1491.         curbits += c1;

  1492.         curbits += c2;

  1493.         curbits += c3;

  1494.         curbits += c4;

  1495.     }

  1496.     return curbits;

  1497. }

  1498. 

  1499. static float (*const get_band_numbits_arr[])(struct AACEncContext *s,

  1500.                                              PutBitContext *pb, const float *in,

  1501.                                              const float *scaled, int size, int scale_idx,

  1502.                                              int cb, const float lambda, const float uplim,

  1503.                                              int *bits) = {

  1504.     get_band_numbits_ZERO_mips,

  1505.     get_band_numbits_SQUAD_mips,

  1506.     get_band_numbits_SQUAD_mips,

  1507.     get_band_numbits_UQUAD_mips,

  1508.     get_band_numbits_UQUAD_mips,

  1509.     get_band_numbits_SPAIR_mips,

  1510.     get_band_numbits_SPAIR_mips,

  1511.     get_band_numbits_UPAIR7_mips,

  1512.     get_band_numbits_UPAIR7_mips,

  1513.     get_band_numbits_UPAIR12_mips,

  1514.     get_band_numbits_UPAIR12_mips,

  1515.     get_band_numbits_ESC_mips,

  1516.     get_band_numbits_NONE_mips, /* cb 12 doesn't exist */

  1517.     get_band_numbits_ZERO_mips,

  1518.     get_band_numbits_ZERO_mips,

  1519.     get_band_numbits_ZERO_mips,

  1520. };

  1521. 

  1522. #define get_band_numbits(                                  \

  1523.                                 s, pb, in, scaled, size, scale_idx, cb, \

  1524.                                 lambda, uplim, bits)                    \

  1525.     get_band_numbits_arr[cb](                              \

  1526.                                 s, pb, in, scaled, size, scale_idx, cb, \

  1527.                                 lambda, uplim, bits)

  1528. 

  1529. static float quantize_band_cost_bits(struct AACEncContext *s, const float *in,

  1530.                                      const float *scaled, int size, int scale_idx,

  1531.                                      int cb, const float lambda, const float uplim,

  1532.                                      int *bits, float *energy, int rtz)

  1533. {

  1534.     return get_band_numbits(s, NULL, in, scaled, size, scale_idx, cb, lambda, uplim, bits);

  1535. }

  1536. 

  1537. /**

  1538.  * Functions developed from template function and optimized for getting the band cost

  1539.  */

  1540. #if HAVE_MIPSFPU

  1541. static float get_band_cost_ZERO_mips(struct AACEncContext *s,

  1542.                                      PutBitContext *pb, const float *in,

  1543.                                      const float *scaled, int size, int scale_idx,

  1544.                                      int cb, const float lambda, const float uplim,

  1545.                                      int *bits, float *energy)

  1546. {

  1547.     int i;

  1548.     float cost = 0;

  1549. 

  1550.     for (i = 0; i < size; i += 4) {

  1551.         cost += in[i  ] * in[i  ];

  1552.         cost += in[i+1] * in[i+1];

  1553.         cost += in[i+2] * in[i+2];

  1554.         cost += in[i+3] * in[i+3];

  1555.     }

  1556.     if (bits)

  1557.         *bits = 0;

  1558.     if (energy)

  1559.         *energy = 0.0f;

  1560.     return cost * lambda;

  1561. }

  1562. 

  1563. static float get_band_cost_NONE_mips(struct AACEncContext *s,

  1564.                                      PutBitContext *pb, const float *in,

  1565.                                      const float *scaled, int size, int scale_idx,

  1566.                                      int cb, const float lambda, const float uplim,

  1567.                                      int *bits, float *energy)

  1568. {

  1569.     av_assert0(0);

  1570.     return 0;

  1571. }

  1572. 

  1573. static float get_band_cost_SQUAD_mips(struct AACEncContext *s,

  1574.                                       PutBitContext *pb, const float *in,

  1575.                                       const float *scaled, int size, int scale_idx,

  1576.                                       int cb, const float lambda, const float uplim,

  1577.                                       int *bits, float *energy)

  1578. {

  1579.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1580.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  1581.     int i;

  1582.     float cost = 0;

  1583.     float qenergy = 0.0f;

  1584.     int qc1, qc2, qc3, qc4;

  1585.     int curbits = 0;

  1586. 

  1587.     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1588.     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];

  1589. 

  1590.     for (i = 0; i < size; i += 4) {

  1591.         const float *vec;

  1592.         int curidx;

  1593.         int   *in_int = (int   *)&in[i];

  1594.         float *in_pos = (float *)&in[i];

  1595.         float di0, di1, di2, di3;

  1596.         int t0, t1, t2, t3, t4, t5, t6, t7;

  1597. 

  1598.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1599.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1600.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1601.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1602. 

  1603.         __asm__ volatile (

  1604.             ".set push                                  \n\t"

  1605.             ".set noreorder                             \n\t"

  1606. 

  1607.             "slt        %[qc1], $zero,  %[qc1]          \n\t"

  1608.             "slt        %[qc2], $zero,  %[qc2]          \n\t"

  1609.             "slt        %[qc3], $zero,  %[qc3]          \n\t"

  1610.             "slt        %[qc4], $zero,  %[qc4]          \n\t"

  1611.             "lw         %[t0],  0(%[in_int])            \n\t"

  1612.             "lw         %[t1],  4(%[in_int])            \n\t"

  1613.             "lw         %[t2],  8(%[in_int])            \n\t"

  1614.             "lw         %[t3],  12(%[in_int])           \n\t"

  1615.             "srl        %[t0],  %[t0],  31              \n\t"

  1616.             "srl        %[t1],  %[t1],  31              \n\t"

  1617.             "srl        %[t2],  %[t2],  31              \n\t"

  1618.             "srl        %[t3],  %[t3],  31              \n\t"

  1619.             "subu       %[t4],  $zero,  %[qc1]          \n\t"

  1620.             "subu       %[t5],  $zero,  %[qc2]          \n\t"

  1621.             "subu       %[t6],  $zero,  %[qc3]          \n\t"

  1622.             "subu       %[t7],  $zero,  %[qc4]          \n\t"

  1623.             "movn       %[qc1], %[t4],  %[t0]           \n\t"

  1624.             "movn       %[qc2], %[t5],  %[t1]           \n\t"

  1625.             "movn       %[qc3], %[t6],  %[t2]           \n\t"

  1626.             "movn       %[qc4], %[t7],  %[t3]           \n\t"

  1627. 

  1628.             ".set pop                                   \n\t"

  1629. 

  1630.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1631.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1632.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1633.               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)

  1634.             : [in_int]"r"(in_int)

  1635.             : "memory"

  1636.         );

  1637. 

  1638.         curidx = qc1;

  1639.         curidx *= 3;

  1640.         curidx += qc2;

  1641.         curidx *= 3;

  1642.         curidx += qc3;

  1643.         curidx *= 3;

  1644.         curidx += qc4;

  1645.         curidx += 40;

  1646. 

  1647.         curbits += p_bits[curidx];

  1648.         vec     = &p_codes[curidx*4];

  1649. 

  1650.         qenergy += vec[0]*vec[0] + vec[1]*vec[1]

  1651.                 +  vec[2]*vec[2] + vec[3]*vec[3];

  1652. 

  1653.         __asm__ volatile (

  1654.             ".set push                                  \n\t"

  1655.             ".set noreorder                             \n\t"

  1656. 

  1657.             "lwc1       $f0,    0(%[in_pos])            \n\t"

  1658.             "lwc1       $f1,    0(%[vec])               \n\t"

  1659.             "lwc1       $f2,    4(%[in_pos])            \n\t"

  1660.             "lwc1       $f3,    4(%[vec])               \n\t"

  1661.             "lwc1       $f4,    8(%[in_pos])            \n\t"

  1662.             "lwc1       $f5,    8(%[vec])               \n\t"

  1663.             "lwc1       $f6,    12(%[in_pos])           \n\t"

  1664.             "lwc1       $f7,    12(%[vec])              \n\t"

  1665.             "nmsub.s    %[di0], $f0,    $f1,    %[IQ]   \n\t"

  1666.             "nmsub.s    %[di1], $f2,    $f3,    %[IQ]   \n\t"

  1667.             "nmsub.s    %[di2], $f4,    $f5,    %[IQ]   \n\t"

  1668.             "nmsub.s    %[di3], $f6,    $f7,    %[IQ]   \n\t"

  1669. 

  1670.             ".set pop                                   \n\t"

  1671. 

  1672.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  1673.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  1674.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  1675.               [IQ]"f"(IQ)

  1676.             : "$f0", "$f1", "$f2", "$f3",

  1677.               "$f4", "$f5", "$f6", "$f7",

  1678.               "memory"

  1679.         );

  1680. 

  1681.         cost += di0 * di0 + di1 * di1

  1682.                 + di2 * di2 + di3 * di3;

  1683.     }

  1684. 

  1685.     if (bits)

  1686.         *bits = curbits;

  1687.     if (energy)

  1688.         *energy = qenergy * (IQ*IQ);

  1689.     return cost * lambda + curbits;

  1690. }

  1691. 

  1692. static float get_band_cost_UQUAD_mips(struct AACEncContext *s,

  1693.                                       PutBitContext *pb, const float *in,

  1694.                                       const float *scaled, int size, int scale_idx,

  1695.                                       int cb, const float lambda, const float uplim,

  1696.                                       int *bits, float *energy)

  1697. {

  1698.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1699.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  1700.     int i;

  1701.     float cost = 0;

  1702.     float qenergy = 0.0f;

  1703.     int curbits = 0;

  1704.     int qc1, qc2, qc3, qc4;

  1705. 

  1706.     uint8_t *p_bits  = (uint8_t*)ff_aac_spectral_bits[cb-1];

  1707.     float   *p_codes = (float  *)ff_aac_codebook_vectors[cb-1];

  1708. 

  1709.     for (i = 0; i < size; i += 4) {

  1710.         const float *vec;

  1711.         int curidx;

  1712.         float *in_pos = (float *)&in[i];

  1713.         float di0, di1, di2, di3;

  1714.         int t0, t1, t2, t3, t4;

  1715. 

  1716.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1717.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1718.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1719.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1720. 

  1721.         __asm__ volatile (

  1722.             ".set push                                  \n\t"

  1723.             ".set noreorder                             \n\t"

  1724. 

  1725.             "ori        %[t4],  $zero,  2               \n\t"

  1726.             "slt        %[t0],  %[t4],  %[qc1]          \n\t"

  1727.             "slt        %[t1],  %[t4],  %[qc2]          \n\t"

  1728.             "slt        %[t2],  %[t4],  %[qc3]          \n\t"

  1729.             "slt        %[t3],  %[t4],  %[qc4]          \n\t"

  1730.             "movn       %[qc1], %[t4],  %[t0]           \n\t"

  1731.             "movn       %[qc2], %[t4],  %[t1]           \n\t"

  1732.             "movn       %[qc3], %[t4],  %[t2]           \n\t"

  1733.             "movn       %[qc4], %[t4],  %[t3]           \n\t"

  1734. 

  1735.             ".set pop                                   \n\t"

  1736. 

  1737.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1738.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1739.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1740.               [t4]"=&r"(t4)

  1741.         );

  1742. 

  1743.         curidx = qc1;

  1744.         curidx *= 3;

  1745.         curidx += qc2;

  1746.         curidx *= 3;

  1747.         curidx += qc3;

  1748.         curidx *= 3;

  1749.         curidx += qc4;

  1750. 

  1751.         curbits += p_bits[curidx];

  1752.         curbits += uquad_sign_bits[curidx];

  1753.         vec     = &p_codes[curidx*4];

  1754. 

  1755.         qenergy += vec[0]*vec[0] + vec[1]*vec[1]

  1756.                 +  vec[2]*vec[2] + vec[3]*vec[3];

  1757. 

  1758.         __asm__ volatile (

  1759.             ".set push                                  \n\t"

  1760.             ".set noreorder                             \n\t"

  1761. 

  1762.             "lwc1       %[di0], 0(%[in_pos])            \n\t"

  1763.             "lwc1       %[di1], 4(%[in_pos])            \n\t"

  1764.             "lwc1       %[di2], 8(%[in_pos])            \n\t"

  1765.             "lwc1       %[di3], 12(%[in_pos])           \n\t"

  1766.             "abs.s      %[di0], %[di0]                  \n\t"

  1767.             "abs.s      %[di1], %[di1]                  \n\t"

  1768.             "abs.s      %[di2], %[di2]                  \n\t"

  1769.             "abs.s      %[di3], %[di3]                  \n\t"

  1770.             "lwc1       $f0,    0(%[vec])               \n\t"

  1771.             "lwc1       $f1,    4(%[vec])               \n\t"

  1772.             "lwc1       $f2,    8(%[vec])               \n\t"

  1773.             "lwc1       $f3,    12(%[vec])              \n\t"

  1774.             "nmsub.s    %[di0], %[di0], $f0,    %[IQ]   \n\t"

  1775.             "nmsub.s    %[di1], %[di1], $f1,    %[IQ]   \n\t"

  1776.             "nmsub.s    %[di2], %[di2], $f2,    %[IQ]   \n\t"

  1777.             "nmsub.s    %[di3], %[di3], $f3,    %[IQ]   \n\t"

  1778. 

  1779.             ".set pop                                   \n\t"

  1780. 

  1781.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  1782.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  1783.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  1784.               [IQ]"f"(IQ)

  1785.             : "$f0", "$f1", "$f2", "$f3",

  1786.               "memory"

  1787.         );

  1788. 

  1789.         cost += di0 * di0 + di1 * di1

  1790.                 + di2 * di2 + di3 * di3;

  1791.     }

  1792. 

  1793.     if (bits)

  1794.         *bits = curbits;

  1795.     if (energy)

  1796.         *energy = qenergy * (IQ*IQ);

  1797.     return cost * lambda + curbits;

  1798. }

  1799. 

  1800. static float get_band_cost_SPAIR_mips(struct AACEncContext *s,

  1801.                                       PutBitContext *pb, const float *in,

  1802.                                       const float *scaled, int size, int scale_idx,

  1803.                                       int cb, const float lambda, const float uplim,

  1804.                                       int *bits, float *energy)

  1805. {

  1806.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1807.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  1808.     int i;

  1809.     float cost = 0;

  1810.     float qenergy = 0.0f;

  1811.     int qc1, qc2, qc3, qc4;

  1812.     int curbits = 0;

  1813. 

  1814.     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1815.     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];

  1816. 

  1817.     for (i = 0; i < size; i += 4) {

  1818.         const float *vec, *vec2;

  1819.         int curidx, curidx2;

  1820.         int   *in_int = (int   *)&in[i];

  1821.         float *in_pos = (float *)&in[i];

  1822.         float di0, di1, di2, di3;

  1823.         int t0, t1, t2, t3, t4, t5, t6, t7;

  1824. 

  1825.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1826.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1827.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1828.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1829. 

  1830.         __asm__ volatile (

  1831.             ".set push                                  \n\t"

  1832.             ".set noreorder                             \n\t"

  1833. 

  1834.             "ori        %[t4],  $zero,  4               \n\t"

  1835.             "slt        %[t0],  %[t4],  %[qc1]          \n\t"

  1836.             "slt        %[t1],  %[t4],  %[qc2]          \n\t"

  1837.             "slt        %[t2],  %[t4],  %[qc3]          \n\t"

  1838.             "slt        %[t3],  %[t4],  %[qc4]          \n\t"

  1839.             "movn       %[qc1], %[t4],  %[t0]           \n\t"

  1840.             "movn       %[qc2], %[t4],  %[t1]           \n\t"

  1841.             "movn       %[qc3], %[t4],  %[t2]           \n\t"

  1842.             "movn       %[qc4], %[t4],  %[t3]           \n\t"

  1843.             "lw         %[t0],  0(%[in_int])            \n\t"

  1844.             "lw         %[t1],  4(%[in_int])            \n\t"

  1845.             "lw         %[t2],  8(%[in_int])            \n\t"

  1846.             "lw         %[t3],  12(%[in_int])           \n\t"

  1847.             "srl        %[t0],  %[t0],  31              \n\t"

  1848.             "srl        %[t1],  %[t1],  31              \n\t"

  1849.             "srl        %[t2],  %[t2],  31              \n\t"

  1850.             "srl        %[t3],  %[t3],  31              \n\t"

  1851.             "subu       %[t4],  $zero,  %[qc1]          \n\t"

  1852.             "subu       %[t5],  $zero,  %[qc2]          \n\t"

  1853.             "subu       %[t6],  $zero,  %[qc3]          \n\t"

  1854.             "subu       %[t7],  $zero,  %[qc4]          \n\t"

  1855.             "movn       %[qc1], %[t4],  %[t0]           \n\t"

  1856.             "movn       %[qc2], %[t5],  %[t1]           \n\t"

  1857.             "movn       %[qc3], %[t6],  %[t2]           \n\t"

  1858.             "movn       %[qc4], %[t7],  %[t3]           \n\t"

  1859. 

  1860.             ".set pop                                   \n\t"

  1861. 

  1862.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1863.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1864.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1865.               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)

  1866.             : [in_int]"r"(in_int)

  1867.             : "memory"

  1868.         );

  1869. 

  1870.         curidx = 9 * qc1;

  1871.         curidx += qc2 + 40;

  1872. 

  1873.         curidx2 = 9 * qc3;

  1874.         curidx2 += qc4 + 40;

  1875. 

  1876.         curbits += p_bits[curidx];

  1877.         curbits += p_bits[curidx2];

  1878. 

  1879.         vec     = &p_codes[curidx*2];

  1880.         vec2    = &p_codes[curidx2*2];

  1881. 

  1882.         qenergy += vec[0]*vec[0] + vec[1]*vec[1]

  1883.                 +  vec2[0]*vec2[0] + vec2[1]*vec2[1];

  1884. 

  1885.         __asm__ volatile (

  1886.             ".set push                                  \n\t"

  1887.             ".set noreorder                             \n\t"

  1888. 

  1889.             "lwc1       $f0,    0(%[in_pos])            \n\t"

  1890.             "lwc1       $f1,    0(%[vec])               \n\t"

  1891.             "lwc1       $f2,    4(%[in_pos])            \n\t"

  1892.             "lwc1       $f3,    4(%[vec])               \n\t"

  1893.             "lwc1       $f4,    8(%[in_pos])            \n\t"

  1894.             "lwc1       $f5,    0(%[vec2])              \n\t"

  1895.             "lwc1       $f6,    12(%[in_pos])           \n\t"

  1896.             "lwc1       $f7,    4(%[vec2])              \n\t"

  1897.             "nmsub.s    %[di0], $f0,    $f1,    %[IQ]   \n\t"

  1898.             "nmsub.s    %[di1], $f2,    $f3,    %[IQ]   \n\t"

  1899.             "nmsub.s    %[di2], $f4,    $f5,    %[IQ]   \n\t"

  1900.             "nmsub.s    %[di3], $f6,    $f7,    %[IQ]   \n\t"

  1901. 

  1902.             ".set pop                                   \n\t"

  1903. 

  1904.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  1905.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  1906.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  1907.               [vec2]"r"(vec2), [IQ]"f"(IQ)

  1908.             : "$f0", "$f1", "$f2", "$f3",

  1909.               "$f4", "$f5", "$f6", "$f7",

  1910.               "memory"

  1911.         );

  1912. 

  1913.         cost += di0 * di0 + di1 * di1

  1914.                 + di2 * di2 + di3 * di3;

  1915.     }

  1916. 

  1917.     if (bits)

  1918.         *bits = curbits;

  1919.     if (energy)

  1920.         *energy = qenergy * (IQ*IQ);

  1921.     return cost * lambda + curbits;

  1922. }

  1923. 

  1924. static float get_band_cost_UPAIR7_mips(struct AACEncContext *s,

  1925.                                        PutBitContext *pb, const float *in,

  1926.                                        const float *scaled, int size, int scale_idx,

  1927.                                        int cb, const float lambda, const float uplim,

  1928.                                        int *bits, float *energy)

  1929. {

  1930.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1931.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  1932.     int i;

  1933.     float cost = 0;

  1934.     float qenergy = 0.0f;

  1935.     int qc1, qc2, qc3, qc4;

  1936.     int curbits = 0;

  1937. 

  1938.     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1939.     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];

  1940. 

  1941.     for (i = 0; i < size; i += 4) {

  1942.         const float *vec, *vec2;

  1943.         int curidx, curidx2, sign1, count1, sign2, count2;

  1944.         int   *in_int = (int   *)&in[i];

  1945.         float *in_pos = (float *)&in[i];

  1946.         float di0, di1, di2, di3;

  1947.         int t0, t1, t2, t3, t4;

  1948. 

  1949.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1950.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1951.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1952.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1953. 

  1954.         __asm__ volatile (

  1955.             ".set push                                          \n\t"

  1956.             ".set noreorder                                     \n\t"

  1957. 

  1958.             "ori        %[t4],      $zero,      7               \n\t"

  1959.             "ori        %[sign1],   $zero,      0               \n\t"

  1960.             "ori        %[sign2],   $zero,      0               \n\t"

  1961.             "slt        %[t0],      %[t4],      %[qc1]          \n\t"

  1962.             "slt        %[t1],      %[t4],      %[qc2]          \n\t"

  1963.             "slt        %[t2],      %[t4],      %[qc3]          \n\t"

  1964.             "slt        %[t3],      %[t4],      %[qc4]          \n\t"

  1965.             "movn       %[qc1],     %[t4],      %[t0]           \n\t"

  1966.             "movn       %[qc2],     %[t4],      %[t1]           \n\t"

  1967.             "movn       %[qc3],     %[t4],      %[t2]           \n\t"

  1968.             "movn       %[qc4],     %[t4],      %[t3]           \n\t"

  1969.             "lw         %[t0],      0(%[in_int])                \n\t"

  1970.             "lw         %[t1],      4(%[in_int])                \n\t"

  1971.             "lw         %[t2],      8(%[in_int])                \n\t"

  1972.             "lw         %[t3],      12(%[in_int])               \n\t"

  1973.             "slt        %[t0],      %[t0],      $zero           \n\t"

  1974.             "movn       %[sign1],   %[t0],      %[qc1]          \n\t"

  1975.             "slt        %[t2],      %[t2],      $zero           \n\t"

  1976.             "movn       %[sign2],   %[t2],      %[qc3]          \n\t"

  1977.             "slt        %[t1],      %[t1],      $zero           \n\t"

  1978.             "sll        %[t0],      %[sign1],   1               \n\t"

  1979.             "or         %[t0],      %[t0],      %[t1]           \n\t"

  1980.             "movn       %[sign1],   %[t0],      %[qc2]          \n\t"

  1981.             "slt        %[t3],      %[t3],      $zero           \n\t"

  1982.             "sll        %[t0],      %[sign2],   1               \n\t"

  1983.             "or         %[t0],      %[t0],      %[t3]           \n\t"

  1984.             "movn       %[sign2],   %[t0],      %[qc4]          \n\t"

  1985.             "slt        %[count1],  $zero,      %[qc1]          \n\t"

  1986.             "slt        %[t1],      $zero,      %[qc2]          \n\t"

  1987.             "slt        %[count2],  $zero,      %[qc3]          \n\t"

  1988.             "slt        %[t2],      $zero,      %[qc4]          \n\t"

  1989.             "addu       %[count1],  %[count1],  %[t1]           \n\t"

  1990.             "addu       %[count2],  %[count2],  %[t2]           \n\t"

  1991. 

  1992.             ".set pop                                           \n\t"

  1993. 

  1994.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1995.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1996.               [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  1997.               [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  1998.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1999.               [t4]"=&r"(t4)

  2000.             : [in_int]"r"(in_int)

  2001.             : "memory"

  2002.         );

  2003. 

  2004.         curidx = 8 * qc1;

  2005.         curidx += qc2;

  2006. 

  2007.         curidx2 = 8 * qc3;

  2008.         curidx2 += qc4;

  2009. 

  2010.         curbits += p_bits[curidx];

  2011.         curbits += upair7_sign_bits[curidx];

  2012.         vec     = &p_codes[curidx*2];

  2013. 

  2014.         curbits += p_bits[curidx2];

  2015.         curbits += upair7_sign_bits[curidx2];

  2016.         vec2    = &p_codes[curidx2*2];

  2017. 

  2018.         qenergy += vec[0]*vec[0] + vec[1]*vec[1]

  2019.                 +  vec2[0]*vec2[0] + vec2[1]*vec2[1];

  2020. 

  2021.         __asm__ volatile (

  2022.             ".set push                                          \n\t"

  2023.             ".set noreorder                                     \n\t"

  2024. 

  2025.             "lwc1       %[di0],     0(%[in_pos])                \n\t"

  2026.             "lwc1       %[di1],     4(%[in_pos])                \n\t"

  2027.             "lwc1       %[di2],     8(%[in_pos])                \n\t"

  2028.             "lwc1       %[di3],     12(%[in_pos])               \n\t"

  2029.             "abs.s      %[di0],     %[di0]                      \n\t"

  2030.             "abs.s      %[di1],     %[di1]                      \n\t"

  2031.             "abs.s      %[di2],     %[di2]                      \n\t"

  2032.             "abs.s      %[di3],     %[di3]                      \n\t"

  2033.             "lwc1       $f0,        0(%[vec])                   \n\t"

  2034.             "lwc1       $f1,        4(%[vec])                   \n\t"

  2035.             "lwc1       $f2,        0(%[vec2])                  \n\t"

  2036.             "lwc1       $f3,        4(%[vec2])                  \n\t"

  2037.             "nmsub.s    %[di0],     %[di0],     $f0,    %[IQ]   \n\t"

  2038.             "nmsub.s    %[di1],     %[di1],     $f1,    %[IQ]   \n\t"

  2039.             "nmsub.s    %[di2],     %[di2],     $f2,    %[IQ]   \n\t"

  2040.             "nmsub.s    %[di3],     %[di3],     $f3,    %[IQ]   \n\t"

  2041. 

  2042.             ".set pop                                           \n\t"

  2043. 

  2044.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  2045.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  2046.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  2047.               [vec2]"r"(vec2), [IQ]"f"(IQ)

  2048.             : "$f0", "$f1", "$f2", "$f3",

  2049.               "memory"

  2050.         );

  2051. 

  2052.         cost += di0 * di0 + di1 * di1

  2053.                 + di2 * di2 + di3 * di3;

  2054.     }

  2055. 

  2056.     if (bits)

  2057.         *bits = curbits;

  2058.     if (energy)

  2059.         *energy = qenergy * (IQ*IQ);

  2060.     return cost * lambda + curbits;

  2061. }

  2062. 

  2063. static float get_band_cost_UPAIR12_mips(struct AACEncContext *s,

  2064.                                         PutBitContext *pb, const float *in,

  2065.                                         const float *scaled, int size, int scale_idx,

  2066.                                         int cb, const float lambda, const float uplim,

  2067.                                         int *bits, float *energy)

  2068. {

  2069.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  2070.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  2071.     int i;

  2072.     float cost = 0;

  2073.     float qenergy = 0.0f;

  2074.     int qc1, qc2, qc3, qc4;

  2075.     int curbits = 0;

  2076. 

  2077.     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];

  2078.     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];

  2079. 

  2080.     for (i = 0; i < size; i += 4) {

  2081.         const float *vec, *vec2;

  2082.         int curidx, curidx2;

  2083.         int sign1, count1, sign2, count2;

  2084.         int   *in_int = (int   *)&in[i];

  2085.         float *in_pos = (float *)&in[i];

  2086.         float di0, di1, di2, di3;

  2087.         int t0, t1, t2, t3, t4;

  2088. 

  2089.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  2090.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  2091.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  2092.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  2093. 

  2094.         __asm__ volatile (

  2095.             ".set push                                          \n\t"

  2096.             ".set noreorder                                     \n\t"

  2097. 

  2098.             "ori        %[t4],      $zero,      12              \n\t"

  2099.             "ori        %[sign1],   $zero,      0               \n\t"

  2100.             "ori        %[sign2],   $zero,      0               \n\t"

  2101.             "slt        %[t0],      %[t4],      %[qc1]          \n\t"

  2102.             "slt        %[t1],      %[t4],      %[qc2]          \n\t"

  2103.             "slt        %[t2],      %[t4],      %[qc3]          \n\t"

  2104.             "slt        %[t3],      %[t4],      %[qc4]          \n\t"

  2105.             "movn       %[qc1],     %[t4],      %[t0]           \n\t"

  2106.             "movn       %[qc2],     %[t4],      %[t1]           \n\t"

  2107.             "movn       %[qc3],     %[t4],      %[t2]           \n\t"

  2108.             "movn       %[qc4],     %[t4],      %[t3]           \n\t"

  2109.             "lw         %[t0],      0(%[in_int])                \n\t"

  2110.             "lw         %[t1],      4(%[in_int])                \n\t"

  2111.             "lw         %[t2],      8(%[in_int])                \n\t"

  2112.             "lw         %[t3],      12(%[in_int])               \n\t"

  2113.             "slt        %[t0],      %[t0],      $zero           \n\t"

  2114.             "movn       %[sign1],   %[t0],      %[qc1]          \n\t"

  2115.             "slt        %[t2],      %[t2],      $zero           \n\t"

  2116.             "movn       %[sign2],   %[t2],      %[qc3]          \n\t"

  2117.             "slt        %[t1],      %[t1],      $zero           \n\t"

  2118.             "sll        %[t0],      %[sign1],   1               \n\t"

  2119.             "or         %[t0],      %[t0],      %[t1]           \n\t"

  2120.             "movn       %[sign1],   %[t0],      %[qc2]          \n\t"

  2121.             "slt        %[t3],      %[t3],      $zero           \n\t"

  2122.             "sll        %[t0],      %[sign2],   1               \n\t"

  2123.             "or         %[t0],      %[t0],      %[t3]           \n\t"

  2124.             "movn       %[sign2],   %[t0],      %[qc4]          \n\t"

  2125.             "slt        %[count1],  $zero,      %[qc1]          \n\t"

  2126.             "slt        %[t1],      $zero,      %[qc2]          \n\t"

  2127.             "slt        %[count2],  $zero,      %[qc3]          \n\t"

  2128.             "slt        %[t2],      $zero,      %[qc4]          \n\t"

  2129.             "addu       %[count1],  %[count1],  %[t1]           \n\t"

  2130.             "addu       %[count2],  %[count2],  %[t2]           \n\t"

  2131. 

  2132.             ".set pop                                           \n\t"

  2133. 

  2134.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  2135.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  2136.               [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  2137.               [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  2138.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  2139.               [t4]"=&r"(t4)

  2140.             : [in_int]"r"(in_int)

  2141.             : "memory"

  2142.         );

  2143. 

  2144.         curidx = 13 * qc1;

  2145.         curidx += qc2;

  2146. 

  2147.         curidx2 = 13 * qc3;

  2148.         curidx2 += qc4;

  2149. 

  2150.         curbits += p_bits[curidx];

  2151.         curbits += p_bits[curidx2];

  2152.         curbits += upair12_sign_bits[curidx];

  2153.         curbits += upair12_sign_bits[curidx2];

  2154.         vec     = &p_codes[curidx*2];

  2155.         vec2    = &p_codes[curidx2*2];

  2156. 

  2157.         qenergy += vec[0]*vec[0] + vec[1]*vec[1]

  2158.                 +  vec2[0]*vec2[0] + vec2[1]*vec2[1];

  2159. 

  2160.         __asm__ volatile (

  2161.             ".set push                                          \n\t"

  2162.             ".set noreorder                                     \n\t"

  2163. 

  2164.             "lwc1       %[di0],     0(%[in_pos])                \n\t"

  2165.             "lwc1       %[di1],     4(%[in_pos])                \n\t"

  2166.             "lwc1       %[di2],     8(%[in_pos])                \n\t"

  2167.             "lwc1       %[di3],     12(%[in_pos])               \n\t"

  2168.             "abs.s      %[di0],     %[di0]                      \n\t"

  2169.             "abs.s      %[di1],     %[di1]                      \n\t"

  2170.             "abs.s      %[di2],     %[di2]                      \n\t"

  2171.             "abs.s      %[di3],     %[di3]                      \n\t"

  2172.             "lwc1       $f0,        0(%[vec])                   \n\t"

  2173.             "lwc1       $f1,        4(%[vec])                   \n\t"

  2174.             "lwc1       $f2,        0(%[vec2])                  \n\t"

  2175.             "lwc1       $f3,        4(%[vec2])                  \n\t"

  2176.             "nmsub.s    %[di0],     %[di0],     $f0,    %[IQ]   \n\t"

  2177.             "nmsub.s    %[di1],     %[di1],     $f1,    %[IQ]   \n\t"

  2178.             "nmsub.s    %[di2],     %[di2],     $f2,    %[IQ]   \n\t"

  2179.             "nmsub.s    %[di3],     %[di3],     $f3,    %[IQ]   \n\t"

  2180. 

  2181.             ".set pop                                           \n\t"

  2182. 

  2183.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  2184.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  2185.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  2186.               [vec2]"r"(vec2), [IQ]"f"(IQ)

  2187.             : "$f0", "$f1", "$f2", "$f3",

  2188.               "memory"

  2189.         );

  2190. 

  2191.         cost += di0 * di0 + di1 * di1

  2192.                 + di2 * di2 + di3 * di3;

  2193.     }

  2194. 

  2195.     if (bits)

  2196.         *bits = curbits;

  2197.     if (energy)

  2198.         *energy = qenergy * (IQ*IQ);

  2199.     return cost * lambda + curbits;

  2200. }

  2201. 

  2202. static float get_band_cost_ESC_mips(struct AACEncContext *s,

  2203.                                     PutBitContext *pb, const float *in,

  2204.                                     const float *scaled, int size, int scale_idx,

  2205.                                     int cb, const float lambda, const float uplim,

  2206.                                     int *bits, float *energy)

  2207. {

  2208.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  2209.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  2210.     const float CLIPPED_ESCAPE = 165140.0f * IQ;

  2211.     int i;

  2212.     float cost = 0;

  2213.     float qenergy = 0.0f;

  2214.     int qc1, qc2, qc3, qc4;

  2215.     int curbits = 0;

  2216. 

  2217.     uint8_t *p_bits  = (uint8_t*)ff_aac_spectral_bits[cb-1];

  2218.     float   *p_codes = (float*  )ff_aac_codebook_vectors[cb-1];

  2219. 

  2220.     for (i = 0; i < size; i += 4) {

  2221.         const float *vec, *vec2;

  2222.         int curidx, curidx2;

  2223.         float t1, t2, t3, t4, V;

  2224.         float di1, di2, di3, di4;

  2225.         int cond0, cond1, cond2, cond3;

  2226.         int c1, c2, c3, c4;

  2227.         int t6, t7;

  2228. 

  2229.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  2230.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  2231.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  2232.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  2233. 

  2234.         __asm__ volatile (

  2235.             ".set push                                  \n\t"

  2236.             ".set noreorder                             \n\t"

  2237. 

  2238.             "ori        %[t6],      $zero,  15          \n\t"

  2239.             "ori        %[t7],      $zero,  16          \n\t"

  2240.             "shll_s.w   %[c1],      %[qc1], 18          \n\t"

  2241.             "shll_s.w   %[c2],      %[qc2], 18          \n\t"

  2242.             "shll_s.w   %[c3],      %[qc3], 18          \n\t"

  2243.             "shll_s.w   %[c4],      %[qc4], 18          \n\t"

  2244.             "srl        %[c1],      %[c1],  18          \n\t"

  2245.             "srl        %[c2],      %[c2],  18          \n\t"

  2246.             "srl        %[c3],      %[c3],  18          \n\t"

  2247.             "srl        %[c4],      %[c4],  18          \n\t"

  2248.             "slt        %[cond0],   %[t6],  %[qc1]      \n\t"

  2249.             "slt        %[cond1],   %[t6],  %[qc2]      \n\t"

  2250.             "slt        %[cond2],   %[t6],  %[qc3]      \n\t"

  2251.             "slt        %[cond3],   %[t6],  %[qc4]      \n\t"

  2252.             "movn       %[qc1],     %[t7],  %[cond0]    \n\t"

  2253.             "movn       %[qc2],     %[t7],  %[cond1]    \n\t"

  2254.             "movn       %[qc3],     %[t7],  %[cond2]    \n\t"

  2255.             "movn       %[qc4],     %[t7],  %[cond3]    \n\t"

  2256. 

  2257.             ".set pop                                   \n\t"

  2258. 

  2259.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  2260.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  2261.               [cond0]"=&r"(cond0), [cond1]"=&r"(cond1),

  2262.               [cond2]"=&r"(cond2), [cond3]"=&r"(cond3),

  2263.               [c1]"=&r"(c1), [c2]"=&r"(c2),

  2264.               [c3]"=&r"(c3), [c4]"=&r"(c4),

  2265.               [t6]"=&r"(t6), [t7]"=&r"(t7)

  2266.         );

  2267. 

  2268.         curidx = 17 * qc1;

  2269.         curidx += qc2;

  2270. 

  2271.         curidx2 = 17 * qc3;

  2272.         curidx2 += qc4;

  2273. 

  2274.         curbits += p_bits[curidx];

  2275.         curbits += esc_sign_bits[curidx];

  2276.         vec     = &p_codes[curidx*2];

  2277. 

  2278.         curbits += p_bits[curidx2];

  2279.         curbits += esc_sign_bits[curidx2];

  2280.         vec2     = &p_codes[curidx2*2];

  2281. 

  2282.         curbits += (av_log2(c1) * 2 - 3) & (-cond0);

  2283.         curbits += (av_log2(c2) * 2 - 3) & (-cond1);

  2284.         curbits += (av_log2(c3) * 2 - 3) & (-cond2);

  2285.         curbits += (av_log2(c4) * 2 - 3) & (-cond3);

  2286. 

  2287.         t1 = fabsf(in[i  ]);

  2288.         t2 = fabsf(in[i+1]);

  2289.         t3 = fabsf(in[i+2]);

  2290.         t4 = fabsf(in[i+3]);

  2291. 

  2292.         if (cond0) {

  2293.             if (t1 >= CLIPPED_ESCAPE) {

  2294.                 di1 = t1 - CLIPPED_ESCAPE;

  2295.                 qenergy += CLIPPED_ESCAPE*CLIPPED_ESCAPE;

  2296.             } else {

  2297.                 di1 = t1 - (V = c1 * cbrtf(c1) * IQ);

  2298.                 qenergy += V*V;

  2299.             }

  2300.         } else {

  2301.             di1 = t1 - (V = vec[0] * IQ);

  2302.             qenergy += V*V;

  2303.         }

  2304. 

  2305.         if (cond1) {

  2306.             if (t2 >= CLIPPED_ESCAPE) {

  2307.                 di2 = t2 - CLIPPED_ESCAPE;

  2308.                 qenergy += CLIPPED_ESCAPE*CLIPPED_ESCAPE;

  2309.             } else {

  2310.                 di2 = t2 - (V = c2 * cbrtf(c2) * IQ);

  2311.                 qenergy += V*V;

  2312.             }

  2313.         } else {

  2314.             di2 = t2 - (V = vec[1] * IQ);

  2315.             qenergy += V*V;

  2316.         }

  2317. 

  2318.         if (cond2) {

  2319.             if (t3 >= CLIPPED_ESCAPE) {

  2320.                 di3 = t3 - CLIPPED_ESCAPE;

  2321.                 qenergy += CLIPPED_ESCAPE*CLIPPED_ESCAPE;

  2322.             } else {

  2323.                 di3 = t3 - (V = c3 * cbrtf(c3) * IQ);

  2324.                 qenergy += V*V;

  2325.             }

  2326.         } else {

  2327.             di3 = t3 - (V = vec2[0] * IQ);

  2328.             qenergy += V*V;

  2329.         }

  2330. 

  2331.         if (cond3) {

  2332.             if (t4 >= CLIPPED_ESCAPE) {

  2333.                 di4 = t4 - CLIPPED_ESCAPE;

  2334.                 qenergy += CLIPPED_ESCAPE*CLIPPED_ESCAPE;

  2335.             } else {

  2336.                 di4 = t4 - (V = c4 * cbrtf(c4) * IQ);

  2337.                 qenergy += V*V;

  2338.             }

  2339.         } else {

  2340.             di4 = t4 - (V = vec2[1]*IQ);

  2341.             qenergy += V*V;

  2342.         }

  2343. 

  2344.         cost += di1 * di1 + di2 * di2

  2345.                 + di3 * di3 + di4 * di4;

  2346.     }

  2347. 

  2348.     if (bits)

  2349.         *bits = curbits;

  2350.     return cost * lambda + curbits;

  2351. }

  2352. 

  2353. static float (*const get_band_cost_arr[])(struct AACEncContext *s,

  2354.                                           PutBitContext *pb, const float *in,

  2355.                                           const float *scaled, int size, int scale_idx,

  2356.                                           int cb, const float lambda, const float uplim,

  2357.                                           int *bits, float *energy) = {

  2358.     get_band_cost_ZERO_mips,

  2359.     get_band_cost_SQUAD_mips,

  2360.     get_band_cost_SQUAD_mips,

  2361.     get_band_cost_UQUAD_mips,

  2362.     get_band_cost_UQUAD_mips,

  2363.     get_band_cost_SPAIR_mips,

  2364.     get_band_cost_SPAIR_mips,

  2365.     get_band_cost_UPAIR7_mips,

  2366.     get_band_cost_UPAIR7_mips,

  2367.     get_band_cost_UPAIR12_mips,

  2368.     get_band_cost_UPAIR12_mips,

  2369.     get_band_cost_ESC_mips,

  2370.     get_band_cost_NONE_mips, /* cb 12 doesn't exist */

  2371.     get_band_cost_ZERO_mips,

  2372.     get_band_cost_ZERO_mips,

  2373.     get_band_cost_ZERO_mips,

  2374. };

  2375. 

  2376. #define get_band_cost(                                  \

  2377.                                 s, pb, in, scaled, size, scale_idx, cb, \

  2378.                                 lambda, uplim, bits, energy)            \

  2379.     get_band_cost_arr[cb](                              \

  2380.                                 s, pb, in, scaled, size, scale_idx, cb, \

  2381.                                 lambda, uplim, bits, energy)

  2382. 

  2383. static float quantize_band_cost(struct AACEncContext *s, const float *in,

  2384.                                 const float *scaled, int size, int scale_idx,

  2385.                                 int cb, const float lambda, const float uplim,

  2386.                                 int *bits, float *energy, int rtz)

  2387. {

  2388.     return get_band_cost(s, NULL, in, scaled, size, scale_idx, cb, lambda, uplim, bits, energy);

  2389. }

  2390. 

  2391. #include "libavcodec/aacenc_quantization_misc.h"

  2392. 

  2393. static float find_form_factor(int group_len, int swb_size, float thresh, const float *scaled, float nzslope) {

  2394.     const float iswb_size = 1.0f / swb_size;

  2395.     const float iswb_sizem1 = 1.0f / (swb_size - 1);

  2396.     const float ethresh = thresh, iethresh = 1.0f / ethresh;

  2397.     float form = 0.0f, weight = 0.0f;

  2398.     int w2, i;

  2399.     for (w2 = 0; w2 < group_len; w2++) {

  2400.         float e = 0.0f, e2 = 0.0f, var = 0.0f, maxval = 0.0f;

  2401.         float nzl = 0;

  2402.         for (i = 0; i < swb_size; i+=4) {

  2403.             float s1 = fabsf(scaled[w2*128+i  ]);

  2404.             float s2 = fabsf(scaled[w2*128+i+1]);

  2405.             float s3 = fabsf(scaled[w2*128+i+2]);

  2406.             float s4 = fabsf(scaled[w2*128+i+3]);

  2407.             maxval = FFMAX(maxval, FFMAX(FFMAX(s1, s2), FFMAX(s3, s4)));

  2408.             e += (s1+s2)+(s3+s4);

  2409.             s1 *= s1;

  2410.             s2 *= s2;

  2411.             s3 *= s3;

  2412.             s4 *= s4;

  2413.             e2 += (s1+s2)+(s3+s4);

  2414.             /* We really don't want a hard non-zero-line count, since

  2415.              * even below-threshold lines do add up towards band spectral power.

  2416.              * So, fall steeply towards zero, but smoothly

  2417.              */

  2418.             if (s1 >= ethresh) {

  2419.                 nzl += 1.0f;

  2420.             } else {

  2421.                 nzl += powf(s1 * iethresh, nzslope);

  2422.             }

  2423.             if (s2 >= ethresh) {

  2424.                 nzl += 1.0f;

  2425.             } else {

  2426.                 nzl += powf(s2 * iethresh, nzslope);

  2427.             }

  2428.             if (s3 >= ethresh) {

  2429.                 nzl += 1.0f;

  2430.             } else {

  2431.                 nzl += powf(s3 * iethresh, nzslope);

  2432.             }

  2433.             if (s4 >= ethresh) {

  2434.                 nzl += 1.0f;

  2435.             } else {

  2436.                 nzl += powf(s4 * iethresh, nzslope);

  2437.             }

  2438.         }

  2439.         if (e2 > thresh) {

  2440.             float frm;

  2441.             e *= iswb_size;

  2442. 

  2443.             /** compute variance */

  2444.             for (i = 0; i < swb_size; i++) {

  2445.                 float d = fabsf(scaled[w2*128+i]) - e;

  2446.                 var += d*d;

  2447.             }

  2448.             var = sqrtf(var * iswb_sizem1);

  2449. 

  2450.             e2 *= iswb_size;

  2451.             frm = e / FFMIN(e+4*var,maxval);

  2452.             form += e2 * sqrtf(frm) / FFMAX(0.5f,nzl);

  2453.             weight += e2;

  2454.         }

  2455.     }

  2456.     if (weight > 0) {

  2457.         return form / weight;

  2458.     } else {

  2459.         return 1.0f;

  2460.     }

  2461. }

  2462. 

  2463. #include "libavcodec/aaccoder_twoloop.h"

  2464. 

  2465. static void search_for_ms_mips(AACEncContext *s, ChannelElement *cpe)

  2466. {

  2467.     int start = 0, i, w, w2, g;

  2468.     float M[128], S[128];

  2469.     float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;

  2470.     const float lambda = s->lambda;

  2471.     SingleChannelElement *sce0 = &cpe->ch[0];

  2472.     SingleChannelElement *sce1 = &cpe->ch[1];

  2473.     if (!cpe->common_window)

  2474.         return;

  2475.     for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {

  2476.         start = 0;

  2477.         for (g = 0;  g < sce0->ics.num_swb; g++) {

  2478.             if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {

  2479.                 float dist1 = 0.0f, dist2 = 0.0f;

  2480.                 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {

  2481.                     FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];

  2482.                     FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];

  2483.                     float minthr = FFMIN(band0->threshold, band1->threshold);

  2484.                     float maxthr = FFMAX(band0->threshold, band1->threshold);

  2485.                     for (i = 0; i < sce0->ics.swb_sizes[g]; i+=4) {

  2486.                         M[i  ] = (sce0->coeffs[start+w2*128+i  ]

  2487.                                 + sce1->coeffs[start+w2*128+i  ]) * 0.5;

  2488.                         M[i+1] = (sce0->coeffs[start+w2*128+i+1]

  2489.                                 + sce1->coeffs[start+w2*128+i+1]) * 0.5;

  2490.                         M[i+2] = (sce0->coeffs[start+w2*128+i+2]

  2491.                                 + sce1->coeffs[start+w2*128+i+2]) * 0.5;

  2492.                         M[i+3] = (sce0->coeffs[start+w2*128+i+3]

  2493.                                 + sce1->coeffs[start+w2*128+i+3]) * 0.5;

  2494. 

  2495.                         S[i  ] =  M[i  ]

  2496.                                 - sce1->coeffs[start+w2*128+i  ];

  2497.                         S[i+1] =  M[i+1]

  2498.                                 - sce1->coeffs[start+w2*128+i+1];

  2499.                         S[i+2] =  M[i+2]

  2500.                                 - sce1->coeffs[start+w2*128+i+2];

  2501.                         S[i+3] =  M[i+3]

  2502.                                 - sce1->coeffs[start+w2*128+i+3];

  2503.                    }

  2504.                     abs_pow34_v(L34, sce0->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);

  2505.                     abs_pow34_v(R34, sce1->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);

  2506.                     abs_pow34_v(M34, M,                         sce0->ics.swb_sizes[g]);

  2507.                     abs_pow34_v(S34, S,                         sce0->ics.swb_sizes[g]);

  2508.                     dist1 += quantize_band_cost(s, &sce0->coeffs[start + (w+w2)*128],

  2509.                                                 L34,

  2510.                                                 sce0->ics.swb_sizes[g],

  2511.                                                 sce0->sf_idx[(w+w2)*16+g],

  2512.                                                 sce0->band_type[(w+w2)*16+g],

  2513.                                                 lambda / band0->threshold, INFINITY, NULL, NULL, 0);

  2514.                     dist1 += quantize_band_cost(s, &sce1->coeffs[start + (w+w2)*128],

  2515.                                                 R34,

  2516.                                                 sce1->ics.swb_sizes[g],

  2517.                                                 sce1->sf_idx[(w+w2)*16+g],

  2518.                                                 sce1->band_type[(w+w2)*16+g],

  2519.                                                 lambda / band1->threshold, INFINITY, NULL, NULL, 0);

  2520.                     dist2 += quantize_band_cost(s, M,

  2521.                                                 M34,

  2522.                                                 sce0->ics.swb_sizes[g],

  2523.                                                 sce0->sf_idx[(w+w2)*16+g],

  2524.                                                 sce0->band_type[(w+w2)*16+g],

  2525.                                                 lambda / maxthr, INFINITY, NULL, NULL, 0);

  2526.                     dist2 += quantize_band_cost(s, S,

  2527.                                                 S34,

  2528.                                                 sce1->ics.swb_sizes[g],

  2529.                                                 sce1->sf_idx[(w+w2)*16+g],

  2530.                                                 sce1->band_type[(w+w2)*16+g],

  2531.                                                 lambda / minthr, INFINITY, NULL, NULL, 0);

  2532.                 }

  2533.                 cpe->ms_mask[w*16+g] = dist2 < dist1;

  2534.             }

  2535.             start += sce0->ics.swb_sizes[g];

  2536.         }

  2537.     }

  2538. }

  2539. #endif /*HAVE_MIPSFPU */

  2540. 

  2541. #include "libavcodec/aaccoder_trellis.h"

  2542. 

  2543. #endif /* HAVE_INLINE_ASM */

  2544. 

  2545. void ff_aac_coder_init_mips(AACEncContext *c) {

  2546. #if 0 // HAVE_INLINE_ASM

  2547.     AACCoefficientsEncoder *e = c->coder;

  2548.     int option = c->options.aac_coder;

  2549. 

  2550.     if (option == 2) {

  2551.         e->quantize_and_encode_band = quantize_and_encode_band_mips;

  2552.         e->encode_window_bands_info = codebook_trellis_rate;

  2553. #if HAVE_MIPSFPU

  2554.         e->search_for_quantizers    = search_for_quantizers_twoloop;

  2555. #endif /* HAVE_MIPSFPU */

  2556.     }

  2557. #if HAVE_MIPSFPU

  2558.     e->search_for_ms            = search_for_ms_mips;

  2559. #endif /* HAVE_MIPSFPU */

  2560. #endif /* HAVE_INLINE_ASM */

  2561. }