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.
75401 Commits
32 Branches
1012MB
Tree: e1ac0ecbba
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e1ac0ecbba'
${ noResults }
FFmpeg/libavcodec/mips/aaccoder_mips.c

2361 lines
97KB
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 ==  0) cb = 0;

  183.     else if (qmaxval ==  1) cb = 1;

  184.     else if (qmaxval ==  2) cb = 3;

  185.     else if (qmaxval <=  4) cb = 5;

  186.     else if (qmaxval <=  7) cb = 7;

  187.     else if (qmaxval <= 12) cb = 9;

  188.     else                    cb = 11;

  189.     return cb;

  190. }

  191. 

  192. /**

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

  194.  */

  195. static void quantize_and_encode_band_cost_SQUAD_mips(struct AACEncContext *s,

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

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

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

  199.                                                      int *bits, const float ROUNDING)

  200. {

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

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

  203.     int i;

  204.     int qc1, qc2, qc3, qc4;

  205. 

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

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

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

  209. 

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

  211.     scaled = s->scoefs;

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

  213.         int curidx;

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

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

  216.         const float *vec;

  217. 

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

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

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

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

  222. 

  223.         __asm__ volatile (

  224.             ".set push                      \n\t"

  225.             ".set noreorder                 \n\t"

  226. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  247. 

  248.             ".set pop                       \n\t"

  249. 

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

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

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

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

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

  255.             : "memory"

  256.         );

  257. 

  258.         curidx = qc1;

  259.         curidx *= 3;

  260.         curidx += qc2;

  261.         curidx *= 3;

  262.         curidx += qc3;

  263.         curidx *= 3;

  264.         curidx += qc4;

  265.         curidx += 40;

  266. 

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

  268. 

  269.         if (out) {

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

  271.            out[i+0] = vec[0] * IQ;

  272.            out[i+1] = vec[1] * IQ;

  273.            out[i+2] = vec[2] * IQ;

  274.            out[i+3] = vec[3] * IQ;

  275.         }

  276.     }

  277. }

  278. 

  279. static void quantize_and_encode_band_cost_UQUAD_mips(struct AACEncContext *s,

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

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

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

  283.                                                      int *bits, const float ROUNDING)

  284. {

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

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

  287.     int i;

  288.     int qc1, qc2, qc3, qc4;

  289. 

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

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

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

  293. 

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

  295.     scaled = s->scoefs;

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

  297.         int curidx, sign, count;

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

  299.         uint8_t v_bits;

  300.         unsigned int v_codes;

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

  302.         const float *vec;

  303. 

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

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

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

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

  308. 

  309.         __asm__ volatile (

  310.             ".set push                              \n\t"

  311.             ".set noreorder                         \n\t"

  312. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  348. 

  349.             ".set pop                               \n\t"

  350. 

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

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

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

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

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

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

  357.             : "memory"

  358.         );

  359. 

  360.         curidx = qc1;

  361.         curidx *= 3;

  362.         curidx += qc2;

  363.         curidx *= 3;

  364.         curidx += qc3;

  365.         curidx *= 3;

  366.         curidx += qc4;

  367. 

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

  369.         v_bits  = p_bits[curidx] + count;

  370.         put_bits(pb, v_bits, v_codes);

  371. 

  372.         if (out) {

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

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

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

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

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

  378.         }

  379.     }

  380. }

  381. 

  382. static void quantize_and_encode_band_cost_SPAIR_mips(struct AACEncContext *s,

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

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

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

  386.                                                      int *bits, const float ROUNDING)

  387. {

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

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

  390.     int i;

  391.     int qc1, qc2, qc3, qc4;

  392. 

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

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

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

  396. 

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

  398.     scaled = s->scoefs;

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

  400.         int curidx, curidx2;

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

  402.         uint8_t v_bits;

  403.         unsigned int v_codes;

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

  405.         const float *vec1, *vec2;

  406. 

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

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

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

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

  411. 

  412.         __asm__ volatile (

  413.             ".set push                      \n\t"

  414.             ".set noreorder                 \n\t"

  415. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  441. 

  442.             ".set pop                       \n\t"

  443. 

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

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

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

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

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

  449.             : "memory"

  450.         );

  451. 

  452.         curidx = 9 * qc1;

  453.         curidx += qc2 + 40;

  454. 

  455.         curidx2 = 9 * qc3;

  456.         curidx2 += qc4 + 40;

  457. 

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

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

  460.         put_bits(pb, v_bits, v_codes);

  461. 

  462.         if (out) {

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

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

  465.            out[i+0] = vec1[0] * IQ;

  466.            out[i+1] = vec1[1] * IQ;

  467.            out[i+2] = vec2[0] * IQ;

  468.            out[i+3] = vec2[1] * IQ;

  469.         }

  470.     }

  471. }

  472. 

  473. static void quantize_and_encode_band_cost_UPAIR7_mips(struct AACEncContext *s,

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

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

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

  477.                                                       int *bits, const float ROUNDING)

  478. {

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

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

  481.     int i;

  482.     int qc1, qc2, qc3, qc4;

  483. 

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

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

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

  487. 

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

  489.     scaled = s->scoefs;

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

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

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

  493.         uint8_t v_bits;

  494.         unsigned int v_codes;

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

  496.         const float *vec1, *vec2;

  497. 

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

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

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

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

  502. 

  503.         __asm__ volatile (

  504.             ".set push                              \n\t"

  505.             ".set noreorder                         \n\t"

  506. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  540. 

  541.             ".set pop                               \n\t"

  542. 

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

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

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

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

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

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

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

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

  551.               "memory"

  552.         );

  553. 

  554.         curidx1  = 8 * qc1;

  555.         curidx1 += qc2;

  556. 

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

  558.         v_bits  = p_bits[curidx1] + count1;

  559.         put_bits(pb, v_bits, v_codes);

  560. 

  561.         curidx2  = 8 * qc3;

  562.         curidx2 += qc4;

  563. 

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

  565.         v_bits  = p_bits[curidx2] + count2;

  566.         put_bits(pb, v_bits, v_codes);

  567. 

  568.         if (out) {

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

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

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

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

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

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

  575.         }

  576.     }

  577. }

  578. 

  579. static void quantize_and_encode_band_cost_UPAIR12_mips(struct AACEncContext *s,

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

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

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

  583.                                                        int *bits, const float ROUNDING)

  584. {

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

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

  587.     int i;

  588.     int qc1, qc2, qc3, qc4;

  589. 

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

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

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

  593. 

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

  595.     scaled = s->scoefs;

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

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

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

  599.         uint8_t v_bits;

  600.         unsigned int v_codes;

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

  602.         const float *vec1, *vec2;

  603. 

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

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

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

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

  608. 

  609.         __asm__ volatile (

  610.             ".set push                              \n\t"

  611.             ".set noreorder                         \n\t"

  612. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  646. 

  647.             ".set pop                               \n\t"

  648. 

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

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

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

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

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

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

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

  656.             : "memory"

  657.         );

  658. 

  659.         curidx1  = 13 * qc1;

  660.         curidx1 += qc2;

  661. 

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

  663.         v_bits  = p_bits[curidx1] + count1;

  664.         put_bits(pb, v_bits, v_codes);

  665. 

  666.         curidx2  = 13 * qc3;

  667.         curidx2 += qc4;

  668. 

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

  670.         v_bits  = p_bits[curidx2] + count2;

  671.         put_bits(pb, v_bits, v_codes);

  672. 

  673.         if (out) {

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

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

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

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

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

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

  680.         }

  681.     }

  682. }

  683. 

  684. static void quantize_and_encode_band_cost_ESC_mips(struct AACEncContext *s,

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

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

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

  688.                                                    int *bits, const float ROUNDING)

  689. {

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

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

  692.     int i;

  693.     int qc1, qc2, qc3, qc4;

  694. 

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

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

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

  698. 

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

  700.     scaled = s->scoefs;

  701. 

  702.     if (cb < 11) {

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

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

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

  706.             uint8_t v_bits;

  707.             unsigned int v_codes;

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

  709.             const float *vec1, *vec2;

  710. 

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

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

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

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

  715. 

  716.             __asm__ volatile (

  717.                 ".set push                                  \n\t"

  718.                 ".set noreorder                             \n\t"

  719. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  753. 

  754.                 ".set pop                                   \n\t"

  755. 

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

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

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

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

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

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

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

  763.                 : "memory"

  764.             );

  765. 

  766.             curidx = 17 * qc1;

  767.             curidx += qc2;

  768.             curidx2 = 17 * qc3;

  769.             curidx2 += qc4;

  770. 

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

  772.             v_bits  = p_bits[curidx] + count1;

  773.             put_bits(pb, v_bits, v_codes);

  774. 

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

  776.             v_bits  = p_bits[curidx2] + count2;

  777.             put_bits(pb, v_bits, v_codes);

  778. 

  779.             if (out) {

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

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

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

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

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

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

  786.             }

  787.         }

  788.     } else {

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

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

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

  792.             uint8_t v_bits;

  793.             unsigned int v_codes;

  794.             int c1, c2, c3, c4;

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

  796.             const float *vec1, *vec2;

  797. 

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

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

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

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

  802. 

  803.             __asm__ volatile (

  804.                 ".set push                                  \n\t"

  805.                 ".set noreorder                             \n\t"

  806. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  848. 

  849.                 ".set pop                                   \n\t"

  850. 

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

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

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

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

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

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

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

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

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

  860.                 : "memory"

  861.             );

  862. 

  863.             curidx = 17 * qc1;

  864.             curidx += qc2;

  865. 

  866.             curidx2 = 17 * qc3;

  867.             curidx2 += qc4;

  868. 

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

  870.             v_bits  = p_bits[curidx] + count1;

  871.             put_bits(pb, v_bits, v_codes);

  872. 

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

  874.                 int len = av_log2(c1);

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

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

  877.             }

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

  879.                 int len = av_log2(c2);

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

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

  882.             }

  883. 

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

  885.             v_bits  = p_bits[curidx2] + count2;

  886.             put_bits(pb, v_bits, v_codes);

  887. 

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

  889.                 int len = av_log2(c3);

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

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

  892.             }

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

  894.                 int len = av_log2(c4);

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

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

  897.             }

  898. 

  899.             if (out) {

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

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

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

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

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

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

  906.             }

  907.         }

  908.     }

  909. }

  910. 

  911. static void quantize_and_encode_band_cost_NONE_mips(struct AACEncContext *s,

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

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

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

  915.                                                          int *bits, const float ROUNDING) {

  916.     av_assert0(0);

  917. }

  918. 

  919. static void quantize_and_encode_band_cost_ZERO_mips(struct AACEncContext *s,

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

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

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

  923.                                                          int *bits, const float ROUNDING) {

  924.     int i;

  925.     if (bits)

  926.         *bits = 0;

  927.     if (out) {

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

  929.            out[i  ] = 0.0f;

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

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

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

  933.         }

  934.     }

  935. }

  936. 

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

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

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

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

  941.                                                          int *bits, const float ROUNDING) = {

  942.     quantize_and_encode_band_cost_ZERO_mips,

  943.     quantize_and_encode_band_cost_SQUAD_mips,

  944.     quantize_and_encode_band_cost_SQUAD_mips,

  945.     quantize_and_encode_band_cost_UQUAD_mips,

  946.     quantize_and_encode_band_cost_UQUAD_mips,

  947.     quantize_and_encode_band_cost_SPAIR_mips,

  948.     quantize_and_encode_band_cost_SPAIR_mips,

  949.     quantize_and_encode_band_cost_UPAIR7_mips,

  950.     quantize_and_encode_band_cost_UPAIR7_mips,

  951.     quantize_and_encode_band_cost_UPAIR12_mips,

  952.     quantize_and_encode_band_cost_UPAIR12_mips,

  953.     quantize_and_encode_band_cost_ESC_mips,

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

  955.     quantize_and_encode_band_cost_ZERO_mips,

  956.     quantize_and_encode_band_cost_ZERO_mips,

  957.     quantize_and_encode_band_cost_ZERO_mips,

  958. };

  959. 

  960. #define quantize_and_encode_band_cost(                                       \

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

  962.                                 lambda, uplim, bits, ROUNDING)               \

  963.     quantize_and_encode_band_cost_arr[cb](                                   \

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

  965.                                 lambda, uplim, bits, ROUNDING)

  966. 

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

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

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

  970. {

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

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

  973. }

  974. 

  975. /**

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

  977.  */

  978. static float get_band_numbits_ZERO_mips(struct AACEncContext *s,

  979.                                         PutBitContext *pb, const float *in,

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

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

  982.                                         int *bits)

  983. {

  984.     return 0;

  985. }

  986. 

  987. static float get_band_numbits_NONE_mips(struct AACEncContext *s,

  988.                                         PutBitContext *pb, const float *in,

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

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

  991.                                         int *bits)

  992. {

  993.     av_assert0(0);

  994.     return 0;

  995. }

  996. 

  997. static float get_band_numbits_SQUAD_mips(struct AACEncContext *s,

  998.                                          PutBitContext *pb, const float *in,

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

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

  1001.                                          int *bits)

  1002. {

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

  1004.     int i;

  1005.     int qc1, qc2, qc3, qc4;

  1006.     int curbits = 0;

  1007. 

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

  1009. 

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

  1011.         int curidx;

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

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

  1014. 

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

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

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

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

  1019. 

  1020.         __asm__ volatile (

  1021.             ".set push                      \n\t"

  1022.             ".set noreorder                 \n\t"

  1023. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1044. 

  1045.             ".set pop                       \n\t"

  1046. 

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

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

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

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

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

  1052.             : "memory"

  1053.         );

  1054. 

  1055.         curidx = qc1;

  1056.         curidx *= 3;

  1057.         curidx += qc2;

  1058.         curidx *= 3;

  1059.         curidx += qc3;

  1060.         curidx *= 3;

  1061.         curidx += qc4;

  1062.         curidx += 40;

  1063. 

  1064.         curbits += p_bits[curidx];

  1065.     }

  1066.     return curbits;

  1067. }

  1068. 

  1069. static float get_band_numbits_UQUAD_mips(struct AACEncContext *s,

  1070.                                          PutBitContext *pb, const float *in,

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

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

  1073.                                          int *bits)

  1074. {

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

  1076.     int i;

  1077.     int curbits = 0;

  1078.     int qc1, qc2, qc3, qc4;

  1079. 

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

  1081. 

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

  1083.         int curidx;

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

  1085. 

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

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

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

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

  1090. 

  1091.         __asm__ volatile (

  1092.             ".set push                      \n\t"

  1093.             ".set noreorder                 \n\t"

  1094. 

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

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

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

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

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

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

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

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

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

  1104. 

  1105.             ".set pop                       \n\t"

  1106. 

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

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

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

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

  1111.         );

  1112. 

  1113.         curidx = qc1;

  1114.         curidx *= 3;

  1115.         curidx += qc2;

  1116.         curidx *= 3;

  1117.         curidx += qc3;

  1118.         curidx *= 3;

  1119.         curidx += qc4;

  1120. 

  1121.         curbits += p_bits[curidx];

  1122.         curbits += uquad_sign_bits[curidx];

  1123.     }

  1124.     return curbits;

  1125. }

  1126. 

  1127. static float get_band_numbits_SPAIR_mips(struct AACEncContext *s,

  1128.                                          PutBitContext *pb, const float *in,

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

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

  1131.                                          int *bits)

  1132. {

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

  1134.     int i;

  1135.     int qc1, qc2, qc3, qc4;

  1136.     int curbits = 0;

  1137. 

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

  1139. 

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

  1141.         int curidx, curidx2;

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

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

  1144. 

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

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

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

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

  1149. 

  1150.         __asm__ volatile (

  1151.             ".set push                      \n\t"

  1152.             ".set noreorder                 \n\t"

  1153. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1179. 

  1180.             ".set pop                       \n\t"

  1181. 

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

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

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

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

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

  1187.             : "memory"

  1188.         );

  1189. 

  1190.         curidx  = 9 * qc1;

  1191.         curidx += qc2 + 40;

  1192. 

  1193.         curidx2  = 9 * qc3;

  1194.         curidx2 += qc4 + 40;

  1195. 

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

  1197.     }

  1198.     return curbits;

  1199. }

  1200. 

  1201. static float get_band_numbits_UPAIR7_mips(struct AACEncContext *s,

  1202.                                           PutBitContext *pb, const float *in,

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

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

  1205.                                           int *bits)

  1206. {

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

  1208.     int i;

  1209.     int qc1, qc2, qc3, qc4;

  1210.     int curbits = 0;

  1211. 

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

  1213. 

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

  1215.         int curidx, curidx2;

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

  1217. 

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

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

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

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

  1222. 

  1223.         __asm__ volatile (

  1224.             ".set push                      \n\t"

  1225.             ".set noreorder                 \n\t"

  1226. 

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

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

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

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

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

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

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

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

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

  1236. 

  1237.             ".set pop                       \n\t"

  1238. 

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

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

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

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

  1243.         );

  1244. 

  1245.         curidx  = 8 * qc1;

  1246.         curidx += qc2;

  1247. 

  1248.         curidx2  = 8 * qc3;

  1249.         curidx2 += qc4;

  1250. 

  1251.         curbits += p_bits[curidx] +

  1252.                    upair7_sign_bits[curidx] +

  1253.                    p_bits[curidx2] +

  1254.                    upair7_sign_bits[curidx2];

  1255.     }

  1256.     return curbits;

  1257. }

  1258. 

  1259. static float get_band_numbits_UPAIR12_mips(struct AACEncContext *s,

  1260.                                            PutBitContext *pb, const float *in,

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

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

  1263.                                            int *bits)

  1264. {

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

  1266.     int i;

  1267.     int qc1, qc2, qc3, qc4;

  1268.     int curbits = 0;

  1269. 

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

  1271. 

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

  1273.         int curidx, curidx2;

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

  1275. 

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

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

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

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

  1280. 

  1281.         __asm__ volatile (

  1282.             ".set push                      \n\t"

  1283.             ".set noreorder                 \n\t"

  1284. 

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

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

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

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

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

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

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

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

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

  1294. 

  1295.             ".set pop                       \n\t"

  1296. 

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

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

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

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

  1301.         );

  1302. 

  1303.         curidx  = 13 * qc1;

  1304.         curidx += qc2;

  1305. 

  1306.         curidx2  = 13 * qc3;

  1307.         curidx2 += qc4;

  1308. 

  1309.         curbits += p_bits[curidx] +

  1310.                    p_bits[curidx2] +

  1311.                    upair12_sign_bits[curidx] +

  1312.                    upair12_sign_bits[curidx2];

  1313.     }

  1314.     return curbits;

  1315. }

  1316. 

  1317. static float get_band_numbits_ESC_mips(struct AACEncContext *s,

  1318.                                        PutBitContext *pb, const float *in,

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

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

  1321.                                        int *bits)

  1322. {

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

  1324.     int i;

  1325.     int qc1, qc2, qc3, qc4;

  1326.     int curbits = 0;

  1327. 

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

  1329. 

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

  1331.         int curidx, curidx2;

  1332.         int cond0, cond1, cond2, cond3;

  1333.         int c1, c2, c3, c4;

  1334.         int t4, t5;

  1335. 

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

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

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

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

  1340. 

  1341.         __asm__ volatile (

  1342.             ".set push                                  \n\t"

  1343.             ".set noreorder                             \n\t"

  1344. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1388. 

  1389.             ".set pop                                   \n\t"

  1390. 

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

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

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

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

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

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

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

  1398.         );

  1399. 

  1400.         curidx = 17 * qc1;

  1401.         curidx += qc2;

  1402. 

  1403.         curidx2 = 17 * qc3;

  1404.         curidx2 += qc4;

  1405. 

  1406.         curbits += p_bits[curidx];

  1407.         curbits += esc_sign_bits[curidx];

  1408.         curbits += p_bits[curidx2];

  1409.         curbits += esc_sign_bits[curidx2];

  1410. 

  1411.         curbits += c1;

  1412.         curbits += c2;

  1413.         curbits += c3;

  1414.         curbits += c4;

  1415.     }

  1416.     return curbits;

  1417. }

  1418. 

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

  1420.                                              PutBitContext *pb, const float *in,

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

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

  1423.                                              int *bits) = {

  1424.     get_band_numbits_ZERO_mips,

  1425.     get_band_numbits_SQUAD_mips,

  1426.     get_band_numbits_SQUAD_mips,

  1427.     get_band_numbits_UQUAD_mips,

  1428.     get_band_numbits_UQUAD_mips,

  1429.     get_band_numbits_SPAIR_mips,

  1430.     get_band_numbits_SPAIR_mips,

  1431.     get_band_numbits_UPAIR7_mips,

  1432.     get_band_numbits_UPAIR7_mips,

  1433.     get_band_numbits_UPAIR12_mips,

  1434.     get_band_numbits_UPAIR12_mips,

  1435.     get_band_numbits_ESC_mips,

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

  1437.     get_band_numbits_ZERO_mips,

  1438.     get_band_numbits_ZERO_mips,

  1439.     get_band_numbits_ZERO_mips,

  1440. };

  1441. 

  1442. #define get_band_numbits(                                  \

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

  1444.                                 lambda, uplim, bits)                    \

  1445.     get_band_numbits_arr[cb](                              \

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

  1447.                                 lambda, uplim, bits)

  1448. 

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

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

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

  1452.                                      int *bits, int rtz)

  1453. {

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

  1455. }

  1456. 

  1457. /**

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

  1459.  */

  1460. #if HAVE_MIPSFPU

  1461. static float get_band_cost_ZERO_mips(struct AACEncContext *s,

  1462.                                      PutBitContext *pb, const float *in,

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

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

  1465.                                      int *bits)

  1466. {

  1467.     int i;

  1468.     float cost = 0;

  1469. 

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

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

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

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

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

  1475.     }

  1476.     if (bits)

  1477.         *bits = 0;

  1478.     return cost * lambda;

  1479. }

  1480. 

  1481. static float get_band_cost_NONE_mips(struct AACEncContext *s,

  1482.                                      PutBitContext *pb, const float *in,

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

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

  1485.                                      int *bits)

  1486. {

  1487.     av_assert0(0);

  1488.     return 0;

  1489. }

  1490. 

  1491. static float get_band_cost_SQUAD_mips(struct AACEncContext *s,

  1492.                                       PutBitContext *pb, const float *in,

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

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

  1495.                                       int *bits)

  1496. {

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

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

  1499.     int i;

  1500.     float cost = 0;

  1501.     int qc1, qc2, qc3, qc4;

  1502.     int curbits = 0;

  1503. 

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

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

  1506. 

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

  1508.         const float *vec;

  1509.         int curidx;

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

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

  1512.         float di0, di1, di2, di3;

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

  1514. 

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

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

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

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

  1519. 

  1520.         __asm__ volatile (

  1521.             ".set push                                  \n\t"

  1522.             ".set noreorder                             \n\t"

  1523. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1544. 

  1545.             ".set pop                                   \n\t"

  1546. 

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

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

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

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

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

  1552.             : "memory"

  1553.         );

  1554. 

  1555.         curidx = qc1;

  1556.         curidx *= 3;

  1557.         curidx += qc2;

  1558.         curidx *= 3;

  1559.         curidx += qc3;

  1560.         curidx *= 3;

  1561.         curidx += qc4;

  1562.         curidx += 40;

  1563. 

  1564.         curbits += p_bits[curidx];

  1565.         vec     = &p_codes[curidx*4];

  1566. 

  1567.         __asm__ volatile (

  1568.             ".set push                                  \n\t"

  1569.             ".set noreorder                             \n\t"

  1570. 

  1571.             "lwc1       $f0,    0(%[in_pos])            \n\t"

  1572.             "lwc1       $f1,    0(%[vec])               \n\t"

  1573.             "lwc1       $f2,    4(%[in_pos])            \n\t"

  1574.             "lwc1       $f3,    4(%[vec])               \n\t"

  1575.             "lwc1       $f4,    8(%[in_pos])            \n\t"

  1576.             "lwc1       $f5,    8(%[vec])               \n\t"

  1577.             "lwc1       $f6,    12(%[in_pos])           \n\t"

  1578.             "lwc1       $f7,    12(%[vec])              \n\t"

  1579.             "nmsub.s    %[di0], $f0,    $f1,    %[IQ]   \n\t"

  1580.             "nmsub.s    %[di1], $f2,    $f3,    %[IQ]   \n\t"

  1581.             "nmsub.s    %[di2], $f4,    $f5,    %[IQ]   \n\t"

  1582.             "nmsub.s    %[di3], $f6,    $f7,    %[IQ]   \n\t"

  1583. 

  1584.             ".set pop                                   \n\t"

  1585. 

  1586.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  1587.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  1588.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  1589.               [IQ]"f"(IQ)

  1590.             : "$f0", "$f1", "$f2", "$f3",

  1591.               "$f4", "$f5", "$f6", "$f7",

  1592.               "memory"

  1593.         );

  1594. 

  1595.         cost += di0 * di0 + di1 * di1

  1596.                 + di2 * di2 + di3 * di3;

  1597.     }

  1598. 

  1599.     if (bits)

  1600.         *bits = curbits;

  1601.     return cost * lambda + curbits;

  1602. }

  1603. 

  1604. static float get_band_cost_UQUAD_mips(struct AACEncContext *s,

  1605.                                       PutBitContext *pb, const float *in,

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

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

  1608.                                       int *bits)

  1609. {

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

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

  1612.     int i;

  1613.     float cost = 0;

  1614.     int curbits = 0;

  1615.     int qc1, qc2, qc3, qc4;

  1616. 

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

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

  1619. 

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

  1621.         const float *vec;

  1622.         int curidx;

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

  1624.         float di0, di1, di2, di3;

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

  1626. 

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

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

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

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

  1631. 

  1632.         __asm__ volatile (

  1633.             ".set push                                  \n\t"

  1634.             ".set noreorder                             \n\t"

  1635. 

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

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

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

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

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

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

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

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

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

  1645. 

  1646.             ".set pop                                   \n\t"

  1647. 

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

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

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

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

  1652.         );

  1653. 

  1654.         curidx = qc1;

  1655.         curidx *= 3;

  1656.         curidx += qc2;

  1657.         curidx *= 3;

  1658.         curidx += qc3;

  1659.         curidx *= 3;

  1660.         curidx += qc4;

  1661. 

  1662.         curbits += p_bits[curidx];

  1663.         curbits += uquad_sign_bits[curidx];

  1664.         vec     = &p_codes[curidx*4];

  1665. 

  1666.         __asm__ volatile (

  1667.             ".set push                                  \n\t"

  1668.             ".set noreorder                             \n\t"

  1669. 

  1670.             "lwc1       %[di0], 0(%[in_pos])            \n\t"

  1671.             "lwc1       %[di1], 4(%[in_pos])            \n\t"

  1672.             "lwc1       %[di2], 8(%[in_pos])            \n\t"

  1673.             "lwc1       %[di3], 12(%[in_pos])           \n\t"

  1674.             "abs.s      %[di0], %[di0]                  \n\t"

  1675.             "abs.s      %[di1], %[di1]                  \n\t"

  1676.             "abs.s      %[di2], %[di2]                  \n\t"

  1677.             "abs.s      %[di3], %[di3]                  \n\t"

  1678.             "lwc1       $f0,    0(%[vec])               \n\t"

  1679.             "lwc1       $f1,    4(%[vec])               \n\t"

  1680.             "lwc1       $f2,    8(%[vec])               \n\t"

  1681.             "lwc1       $f3,    12(%[vec])              \n\t"

  1682.             "nmsub.s    %[di0], %[di0], $f0,    %[IQ]   \n\t"

  1683.             "nmsub.s    %[di1], %[di1], $f1,    %[IQ]   \n\t"

  1684.             "nmsub.s    %[di2], %[di2], $f2,    %[IQ]   \n\t"

  1685.             "nmsub.s    %[di3], %[di3], $f3,    %[IQ]   \n\t"

  1686. 

  1687.             ".set pop                                   \n\t"

  1688. 

  1689.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  1690.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  1691.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  1692.               [IQ]"f"(IQ)

  1693.             : "$f0", "$f1", "$f2", "$f3",

  1694.               "memory"

  1695.         );

  1696. 

  1697.         cost += di0 * di0 + di1 * di1

  1698.                 + di2 * di2 + di3 * di3;

  1699.     }

  1700. 

  1701.     if (bits)

  1702.         *bits = curbits;

  1703.     return cost * lambda + curbits;

  1704. }

  1705. 

  1706. static float get_band_cost_SPAIR_mips(struct AACEncContext *s,

  1707.                                       PutBitContext *pb, const float *in,

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

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

  1710.                                       int *bits)

  1711. {

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

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

  1714.     int i;

  1715.     float cost = 0;

  1716.     int qc1, qc2, qc3, qc4;

  1717.     int curbits = 0;

  1718. 

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

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

  1721. 

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

  1723.         const float *vec, *vec2;

  1724.         int curidx, curidx2;

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

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

  1727.         float di0, di1, di2, di3;

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

  1729. 

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

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

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

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

  1734. 

  1735.         __asm__ volatile (

  1736.             ".set push                                  \n\t"

  1737.             ".set noreorder                             \n\t"

  1738. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1764. 

  1765.             ".set pop                                   \n\t"

  1766. 

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

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

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

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

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

  1772.             : "memory"

  1773.         );

  1774. 

  1775.         curidx = 9 * qc1;

  1776.         curidx += qc2 + 40;

  1777. 

  1778.         curidx2 = 9 * qc3;

  1779.         curidx2 += qc4 + 40;

  1780. 

  1781.         curbits += p_bits[curidx];

  1782.         curbits += p_bits[curidx2];

  1783. 

  1784.         vec     = &p_codes[curidx*2];

  1785.         vec2    = &p_codes[curidx2*2];

  1786. 

  1787.         __asm__ volatile (

  1788.             ".set push                                  \n\t"

  1789.             ".set noreorder                             \n\t"

  1790. 

  1791.             "lwc1       $f0,    0(%[in_pos])            \n\t"

  1792.             "lwc1       $f1,    0(%[vec])               \n\t"

  1793.             "lwc1       $f2,    4(%[in_pos])            \n\t"

  1794.             "lwc1       $f3,    4(%[vec])               \n\t"

  1795.             "lwc1       $f4,    8(%[in_pos])            \n\t"

  1796.             "lwc1       $f5,    0(%[vec2])              \n\t"

  1797.             "lwc1       $f6,    12(%[in_pos])           \n\t"

  1798.             "lwc1       $f7,    4(%[vec2])              \n\t"

  1799.             "nmsub.s    %[di0], $f0,    $f1,    %[IQ]   \n\t"

  1800.             "nmsub.s    %[di1], $f2,    $f3,    %[IQ]   \n\t"

  1801.             "nmsub.s    %[di2], $f4,    $f5,    %[IQ]   \n\t"

  1802.             "nmsub.s    %[di3], $f6,    $f7,    %[IQ]   \n\t"

  1803. 

  1804.             ".set pop                                   \n\t"

  1805. 

  1806.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  1807.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  1808.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  1809.               [vec2]"r"(vec2), [IQ]"f"(IQ)

  1810.             : "$f0", "$f1", "$f2", "$f3",

  1811.               "$f4", "$f5", "$f6", "$f7",

  1812.               "memory"

  1813.         );

  1814. 

  1815.         cost += di0 * di0 + di1 * di1

  1816.                 + di2 * di2 + di3 * di3;

  1817.     }

  1818. 

  1819.     if (bits)

  1820.         *bits = curbits;

  1821.     return cost * lambda + curbits;

  1822. }

  1823. 

  1824. static float get_band_cost_UPAIR7_mips(struct AACEncContext *s,

  1825.                                        PutBitContext *pb, const float *in,

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

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

  1828.                                        int *bits)

  1829. {

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

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

  1832.     int i;

  1833.     float cost = 0;

  1834.     int qc1, qc2, qc3, qc4;

  1835.     int curbits = 0;

  1836. 

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

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

  1839. 

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

  1841.         const float *vec, *vec2;

  1842.         int curidx, curidx2, sign1, count1, sign2, count2;

  1843.         int   *in_int = (int   *)&in[i];

  1844.         float *in_pos = (float *)&in[i];

  1845.         float di0, di1, di2, di3;

  1846.         int t0, t1, t2, t3, t4;

  1847. 

  1848.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1849.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1850.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1851.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1852. 

  1853.         __asm__ volatile (

  1854.             ".set push                                          \n\t"

  1855.             ".set noreorder                                     \n\t"

  1856. 

  1857.             "ori        %[t4],      $zero,      7               \n\t"

  1858.             "ori        %[sign1],   $zero,      0               \n\t"

  1859.             "ori        %[sign2],   $zero,      0               \n\t"

  1860.             "slt        %[t0],      %[t4],      %[qc1]          \n\t"

  1861.             "slt        %[t1],      %[t4],      %[qc2]          \n\t"

  1862.             "slt        %[t2],      %[t4],      %[qc3]          \n\t"

  1863.             "slt        %[t3],      %[t4],      %[qc4]          \n\t"

  1864.             "movn       %[qc1],     %[t4],      %[t0]           \n\t"

  1865.             "movn       %[qc2],     %[t4],      %[t1]           \n\t"

  1866.             "movn       %[qc3],     %[t4],      %[t2]           \n\t"

  1867.             "movn       %[qc4],     %[t4],      %[t3]           \n\t"

  1868.             "lw         %[t0],      0(%[in_int])                \n\t"

  1869.             "lw         %[t1],      4(%[in_int])                \n\t"

  1870.             "lw         %[t2],      8(%[in_int])                \n\t"

  1871.             "lw         %[t3],      12(%[in_int])               \n\t"

  1872.             "slt        %[t0],      %[t0],      $zero           \n\t"

  1873.             "movn       %[sign1],   %[t0],      %[qc1]          \n\t"

  1874.             "slt        %[t2],      %[t2],      $zero           \n\t"

  1875.             "movn       %[sign2],   %[t2],      %[qc3]          \n\t"

  1876.             "slt        %[t1],      %[t1],      $zero           \n\t"

  1877.             "sll        %[t0],      %[sign1],   1               \n\t"

  1878.             "or         %[t0],      %[t0],      %[t1]           \n\t"

  1879.             "movn       %[sign1],   %[t0],      %[qc2]          \n\t"

  1880.             "slt        %[t3],      %[t3],      $zero           \n\t"

  1881.             "sll        %[t0],      %[sign2],   1               \n\t"

  1882.             "or         %[t0],      %[t0],      %[t3]           \n\t"

  1883.             "movn       %[sign2],   %[t0],      %[qc4]          \n\t"

  1884.             "slt        %[count1],  $zero,      %[qc1]          \n\t"

  1885.             "slt        %[t1],      $zero,      %[qc2]          \n\t"

  1886.             "slt        %[count2],  $zero,      %[qc3]          \n\t"

  1887.             "slt        %[t2],      $zero,      %[qc4]          \n\t"

  1888.             "addu       %[count1],  %[count1],  %[t1]           \n\t"

  1889.             "addu       %[count2],  %[count2],  %[t2]           \n\t"

  1890. 

  1891.             ".set pop                                           \n\t"

  1892. 

  1893.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1894.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1895.               [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  1896.               [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  1897.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1898.               [t4]"=&r"(t4)

  1899.             : [in_int]"r"(in_int)

  1900.             : "memory"

  1901.         );

  1902. 

  1903.         curidx = 8 * qc1;

  1904.         curidx += qc2;

  1905. 

  1906.         curidx2 = 8 * qc3;

  1907.         curidx2 += qc4;

  1908. 

  1909.         curbits += p_bits[curidx];

  1910.         curbits += upair7_sign_bits[curidx];

  1911.         vec     = &p_codes[curidx*2];

  1912. 

  1913.         curbits += p_bits[curidx2];

  1914.         curbits += upair7_sign_bits[curidx2];

  1915.         vec2    = &p_codes[curidx2*2];

  1916. 

  1917.         __asm__ volatile (

  1918.             ".set push                                          \n\t"

  1919.             ".set noreorder                                     \n\t"

  1920. 

  1921.             "lwc1       %[di0],     0(%[in_pos])                \n\t"

  1922.             "lwc1       %[di1],     4(%[in_pos])                \n\t"

  1923.             "lwc1       %[di2],     8(%[in_pos])                \n\t"

  1924.             "lwc1       %[di3],     12(%[in_pos])               \n\t"

  1925.             "abs.s      %[di0],     %[di0]                      \n\t"

  1926.             "abs.s      %[di1],     %[di1]                      \n\t"

  1927.             "abs.s      %[di2],     %[di2]                      \n\t"

  1928.             "abs.s      %[di3],     %[di3]                      \n\t"

  1929.             "lwc1       $f0,        0(%[vec])                   \n\t"

  1930.             "lwc1       $f1,        4(%[vec])                   \n\t"

  1931.             "lwc1       $f2,        0(%[vec2])                  \n\t"

  1932.             "lwc1       $f3,        4(%[vec2])                  \n\t"

  1933.             "nmsub.s    %[di0],     %[di0],     $f0,    %[IQ]   \n\t"

  1934.             "nmsub.s    %[di1],     %[di1],     $f1,    %[IQ]   \n\t"

  1935.             "nmsub.s    %[di2],     %[di2],     $f2,    %[IQ]   \n\t"

  1936.             "nmsub.s    %[di3],     %[di3],     $f3,    %[IQ]   \n\t"

  1937. 

  1938.             ".set pop                                           \n\t"

  1939. 

  1940.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  1941.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  1942.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  1943.               [vec2]"r"(vec2), [IQ]"f"(IQ)

  1944.             : "$f0", "$f1", "$f2", "$f3",

  1945.               "memory"

  1946.         );

  1947. 

  1948.         cost += di0 * di0 + di1 * di1

  1949.                 + di2 * di2 + di3 * di3;

  1950.     }

  1951. 

  1952.     if (bits)

  1953.         *bits = curbits;

  1954.     return cost * lambda + curbits;

  1955. }

  1956. 

  1957. static float get_band_cost_UPAIR12_mips(struct AACEncContext *s,

  1958.                                         PutBitContext *pb, const float *in,

  1959.                                         const float *scaled, int size, int scale_idx,

  1960.                                         int cb, const float lambda, const float uplim,

  1961.                                         int *bits)

  1962. {

  1963.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1964.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  1965.     int i;

  1966.     float cost = 0;

  1967.     int qc1, qc2, qc3, qc4;

  1968.     int curbits = 0;

  1969. 

  1970.     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1971.     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];

  1972. 

  1973.     for (i = 0; i < size; i += 4) {

  1974.         const float *vec, *vec2;

  1975.         int curidx, curidx2;

  1976.         int sign1, count1, sign2, count2;

  1977.         int   *in_int = (int   *)&in[i];

  1978.         float *in_pos = (float *)&in[i];

  1979.         float di0, di1, di2, di3;

  1980.         int t0, t1, t2, t3, t4;

  1981. 

  1982.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1983.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1984.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1985.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1986. 

  1987.         __asm__ volatile (

  1988.             ".set push                                          \n\t"

  1989.             ".set noreorder                                     \n\t"

  1990. 

  1991.             "ori        %[t4],      $zero,      12              \n\t"

  1992.             "ori        %[sign1],   $zero,      0               \n\t"

  1993.             "ori        %[sign2],   $zero,      0               \n\t"

  1994.             "slt        %[t0],      %[t4],      %[qc1]          \n\t"

  1995.             "slt        %[t1],      %[t4],      %[qc2]          \n\t"

  1996.             "slt        %[t2],      %[t4],      %[qc3]          \n\t"

  1997.             "slt        %[t3],      %[t4],      %[qc4]          \n\t"

  1998.             "movn       %[qc1],     %[t4],      %[t0]           \n\t"

  1999.             "movn       %[qc2],     %[t4],      %[t1]           \n\t"

  2000.             "movn       %[qc3],     %[t4],      %[t2]           \n\t"

  2001.             "movn       %[qc4],     %[t4],      %[t3]           \n\t"

  2002.             "lw         %[t0],      0(%[in_int])                \n\t"

  2003.             "lw         %[t1],      4(%[in_int])                \n\t"

  2004.             "lw         %[t2],      8(%[in_int])                \n\t"

  2005.             "lw         %[t3],      12(%[in_int])               \n\t"

  2006.             "slt        %[t0],      %[t0],      $zero           \n\t"

  2007.             "movn       %[sign1],   %[t0],      %[qc1]          \n\t"

  2008.             "slt        %[t2],      %[t2],      $zero           \n\t"

  2009.             "movn       %[sign2],   %[t2],      %[qc3]          \n\t"

  2010.             "slt        %[t1],      %[t1],      $zero           \n\t"

  2011.             "sll        %[t0],      %[sign1],   1               \n\t"

  2012.             "or         %[t0],      %[t0],      %[t1]           \n\t"

  2013.             "movn       %[sign1],   %[t0],      %[qc2]          \n\t"

  2014.             "slt        %[t3],      %[t3],      $zero           \n\t"

  2015.             "sll        %[t0],      %[sign2],   1               \n\t"

  2016.             "or         %[t0],      %[t0],      %[t3]           \n\t"

  2017.             "movn       %[sign2],   %[t0],      %[qc4]          \n\t"

  2018.             "slt        %[count1],  $zero,      %[qc1]          \n\t"

  2019.             "slt        %[t1],      $zero,      %[qc2]          \n\t"

  2020.             "slt        %[count2],  $zero,      %[qc3]          \n\t"

  2021.             "slt        %[t2],      $zero,      %[qc4]          \n\t"

  2022.             "addu       %[count1],  %[count1],  %[t1]           \n\t"

  2023.             "addu       %[count2],  %[count2],  %[t2]           \n\t"

  2024. 

  2025.             ".set pop                                           \n\t"

  2026. 

  2027.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  2028.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  2029.               [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  2030.               [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  2031.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  2032.               [t4]"=&r"(t4)

  2033.             : [in_int]"r"(in_int)

  2034.             : "memory"

  2035.         );

  2036. 

  2037.         curidx = 13 * qc1;

  2038.         curidx += qc2;

  2039. 

  2040.         curidx2 = 13 * qc3;

  2041.         curidx2 += qc4;

  2042. 

  2043.         curbits += p_bits[curidx];

  2044.         curbits += p_bits[curidx2];

  2045.         curbits += upair12_sign_bits[curidx];

  2046.         curbits += upair12_sign_bits[curidx2];

  2047.         vec     = &p_codes[curidx*2];

  2048.         vec2    = &p_codes[curidx2*2];

  2049. 

  2050.         __asm__ volatile (

  2051.             ".set push                                          \n\t"

  2052.             ".set noreorder                                     \n\t"

  2053. 

  2054.             "lwc1       %[di0],     0(%[in_pos])                \n\t"

  2055.             "lwc1       %[di1],     4(%[in_pos])                \n\t"

  2056.             "lwc1       %[di2],     8(%[in_pos])                \n\t"

  2057.             "lwc1       %[di3],     12(%[in_pos])               \n\t"

  2058.             "abs.s      %[di0],     %[di0]                      \n\t"

  2059.             "abs.s      %[di1],     %[di1]                      \n\t"

  2060.             "abs.s      %[di2],     %[di2]                      \n\t"

  2061.             "abs.s      %[di3],     %[di3]                      \n\t"

  2062.             "lwc1       $f0,        0(%[vec])                   \n\t"

  2063.             "lwc1       $f1,        4(%[vec])                   \n\t"

  2064.             "lwc1       $f2,        0(%[vec2])                  \n\t"

  2065.             "lwc1       $f3,        4(%[vec2])                  \n\t"

  2066.             "nmsub.s    %[di0],     %[di0],     $f0,    %[IQ]   \n\t"

  2067.             "nmsub.s    %[di1],     %[di1],     $f1,    %[IQ]   \n\t"

  2068.             "nmsub.s    %[di2],     %[di2],     $f2,    %[IQ]   \n\t"

  2069.             "nmsub.s    %[di3],     %[di3],     $f3,    %[IQ]   \n\t"

  2070. 

  2071.             ".set pop                                           \n\t"

  2072. 

  2073.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  2074.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  2075.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  2076.               [vec2]"r"(vec2), [IQ]"f"(IQ)

  2077.             : "$f0", "$f1", "$f2", "$f3",

  2078.               "memory"

  2079.         );

  2080. 

  2081.         cost += di0 * di0 + di1 * di1

  2082.                 + di2 * di2 + di3 * di3;

  2083.     }

  2084. 

  2085.     if (bits)

  2086.         *bits = curbits;

  2087.     return cost * lambda + curbits;

  2088. }

  2089. 

  2090. static float get_band_cost_ESC_mips(struct AACEncContext *s,

  2091.                                     PutBitContext *pb, const float *in,

  2092.                                     const float *scaled, int size, int scale_idx,

  2093.                                     int cb, const float lambda, const float uplim,

  2094.                                     int *bits)

  2095. {

  2096.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  2097.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  2098.     const float CLIPPED_ESCAPE = 165140.0f * IQ;

  2099.     int i;

  2100.     float cost = 0;

  2101.     int qc1, qc2, qc3, qc4;

  2102.     int curbits = 0;

  2103. 

  2104.     uint8_t *p_bits  = (uint8_t*)ff_aac_spectral_bits[cb-1];

  2105.     float   *p_codes = (float*  )ff_aac_codebook_vectors[cb-1];

  2106. 

  2107.     for (i = 0; i < size; i += 4) {

  2108.         const float *vec, *vec2;

  2109.         int curidx, curidx2;

  2110.         float t1, t2, t3, t4;

  2111.         float di1, di2, di3, di4;

  2112.         int cond0, cond1, cond2, cond3;

  2113.         int c1, c2, c3, c4;

  2114.         int t6, t7;

  2115. 

  2116.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  2117.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  2118.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  2119.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  2120. 

  2121.         __asm__ volatile (

  2122.             ".set push                                  \n\t"

  2123.             ".set noreorder                             \n\t"

  2124. 

  2125.             "ori        %[t6],      $zero,  15          \n\t"

  2126.             "ori        %[t7],      $zero,  16          \n\t"

  2127.             "shll_s.w   %[c1],      %[qc1], 18          \n\t"

  2128.             "shll_s.w   %[c2],      %[qc2], 18          \n\t"

  2129.             "shll_s.w   %[c3],      %[qc3], 18          \n\t"

  2130.             "shll_s.w   %[c4],      %[qc4], 18          \n\t"

  2131.             "srl        %[c1],      %[c1],  18          \n\t"

  2132.             "srl        %[c2],      %[c2],  18          \n\t"

  2133.             "srl        %[c3],      %[c3],  18          \n\t"

  2134.             "srl        %[c4],      %[c4],  18          \n\t"

  2135.             "slt        %[cond0],   %[t6],  %[qc1]      \n\t"

  2136.             "slt        %[cond1],   %[t6],  %[qc2]      \n\t"

  2137.             "slt        %[cond2],   %[t6],  %[qc3]      \n\t"

  2138.             "slt        %[cond3],   %[t6],  %[qc4]      \n\t"

  2139.             "movn       %[qc1],     %[t7],  %[cond0]    \n\t"

  2140.             "movn       %[qc2],     %[t7],  %[cond1]    \n\t"

  2141.             "movn       %[qc3],     %[t7],  %[cond2]    \n\t"

  2142.             "movn       %[qc4],     %[t7],  %[cond3]    \n\t"

  2143. 

  2144.             ".set pop                                   \n\t"

  2145. 

  2146.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  2147.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  2148.               [cond0]"=&r"(cond0), [cond1]"=&r"(cond1),

  2149.               [cond2]"=&r"(cond2), [cond3]"=&r"(cond3),

  2150.               [c1]"=&r"(c1), [c2]"=&r"(c2),

  2151.               [c3]"=&r"(c3), [c4]"=&r"(c4),

  2152.               [t6]"=&r"(t6), [t7]"=&r"(t7)

  2153.         );

  2154. 

  2155.         curidx = 17 * qc1;

  2156.         curidx += qc2;

  2157. 

  2158.         curidx2 = 17 * qc3;

  2159.         curidx2 += qc4;

  2160. 

  2161.         curbits += p_bits[curidx];

  2162.         curbits += esc_sign_bits[curidx];

  2163.         vec     = &p_codes[curidx*2];

  2164. 

  2165.         curbits += p_bits[curidx2];

  2166.         curbits += esc_sign_bits[curidx2];

  2167.         vec2     = &p_codes[curidx2*2];

  2168. 

  2169.         curbits += (av_log2(c1) * 2 - 3) & (-cond0);

  2170.         curbits += (av_log2(c2) * 2 - 3) & (-cond1);

  2171.         curbits += (av_log2(c3) * 2 - 3) & (-cond2);

  2172.         curbits += (av_log2(c4) * 2 - 3) & (-cond3);

  2173. 

  2174.         t1 = fabsf(in[i  ]);

  2175.         t2 = fabsf(in[i+1]);

  2176.         t3 = fabsf(in[i+2]);

  2177.         t4 = fabsf(in[i+3]);

  2178. 

  2179.         if (cond0) {

  2180.             if (t1 >= CLIPPED_ESCAPE) {

  2181.                 di1 = t1 - CLIPPED_ESCAPE;

  2182.             } else {

  2183.                 di1 = t1 - c1 * cbrtf(c1) * IQ;

  2184.             }

  2185.         } else

  2186.             di1 = t1 - vec[0] * IQ;

  2187. 

  2188.         if (cond1) {

  2189.             if (t2 >= CLIPPED_ESCAPE) {

  2190.                 di2 = t2 - CLIPPED_ESCAPE;

  2191.             } else {

  2192.                 di2 = t2 - c2 * cbrtf(c2) * IQ;

  2193.             }

  2194.         } else

  2195.             di2 = t2 - vec[1] * IQ;

  2196. 

  2197.         if (cond2) {

  2198.             if (t3 >= CLIPPED_ESCAPE) {

  2199.                 di3 = t3 - CLIPPED_ESCAPE;

  2200.             } else {

  2201.                 di3 = t3 - c3 * cbrtf(c3) * IQ;

  2202.             }

  2203.         } else

  2204.             di3 = t3 - vec2[0] * IQ;

  2205. 

  2206.         if (cond3) {

  2207.             if (t4 >= CLIPPED_ESCAPE) {

  2208.                 di4 = t4 - CLIPPED_ESCAPE;

  2209.             } else {

  2210.                 di4 = t4 - c4 * cbrtf(c4) * IQ;

  2211.             }

  2212.         } else

  2213.             di4 = t4 - vec2[1]*IQ;

  2214. 

  2215.         cost += di1 * di1 + di2 * di2

  2216.                 + di3 * di3 + di4 * di4;

  2217.     }

  2218. 

  2219.     if (bits)

  2220.         *bits = curbits;

  2221.     return cost * lambda + curbits;

  2222. }

  2223. 

  2224. static float (*const get_band_cost_arr[])(struct AACEncContext *s,

  2225.                                           PutBitContext *pb, const float *in,

  2226.                                           const float *scaled, int size, int scale_idx,

  2227.                                           int cb, const float lambda, const float uplim,

  2228.                                           int *bits) = {

  2229.     get_band_cost_ZERO_mips,

  2230.     get_band_cost_SQUAD_mips,

  2231.     get_band_cost_SQUAD_mips,

  2232.     get_band_cost_UQUAD_mips,

  2233.     get_band_cost_UQUAD_mips,

  2234.     get_band_cost_SPAIR_mips,

  2235.     get_band_cost_SPAIR_mips,

  2236.     get_band_cost_UPAIR7_mips,

  2237.     get_band_cost_UPAIR7_mips,

  2238.     get_band_cost_UPAIR12_mips,

  2239.     get_band_cost_UPAIR12_mips,

  2240.     get_band_cost_ESC_mips,

  2241.     get_band_cost_NONE_mips, /* cb 12 doesn't exist */

  2242.     get_band_cost_ZERO_mips,

  2243.     get_band_cost_ZERO_mips,

  2244.     get_band_cost_ZERO_mips,

  2245. };

  2246. 

  2247. #define get_band_cost(                                  \

  2248.                                 s, pb, in, scaled, size, scale_idx, cb, \

  2249.                                 lambda, uplim, bits)                    \

  2250.     get_band_cost_arr[cb](                              \

  2251.                                 s, pb, in, scaled, size, scale_idx, cb, \

  2252.                                 lambda, uplim, bits)

  2253. 

  2254. static float quantize_band_cost(struct AACEncContext *s, const float *in,

  2255.                                 const float *scaled, int size, int scale_idx,

  2256.                                 int cb, const float lambda, const float uplim,

  2257.                                 int *bits, int rtz)

  2258. {

  2259.     return get_band_cost(s, NULL, in, scaled, size, scale_idx, cb, lambda, uplim, bits);

  2260. }

  2261. 

  2262. #include "libavcodec/aaccoder_twoloop.h"

  2263. 

  2264. static void search_for_ms_mips(AACEncContext *s, ChannelElement *cpe)

  2265. {

  2266.     int start = 0, i, w, w2, g;

  2267.     float M[128], S[128];

  2268.     float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;

  2269.     const float lambda = s->lambda;

  2270.     SingleChannelElement *sce0 = &cpe->ch[0];

  2271.     SingleChannelElement *sce1 = &cpe->ch[1];

  2272.     if (!cpe->common_window)

  2273.         return;

  2274.     for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {

  2275.         start = 0;

  2276.         for (g = 0;  g < sce0->ics.num_swb; g++) {

  2277.             if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {

  2278.                 float dist1 = 0.0f, dist2 = 0.0f;

  2279.                 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {

  2280.                     FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];

  2281.                     FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];

  2282.                     float minthr = FFMIN(band0->threshold, band1->threshold);

  2283.                     float maxthr = FFMAX(band0->threshold, band1->threshold);

  2284.                     for (i = 0; i < sce0->ics.swb_sizes[g]; i+=4) {

  2285.                         M[i  ] = (sce0->coeffs[start+w2*128+i  ]

  2286.                                 + sce1->coeffs[start+w2*128+i  ]) * 0.5;

  2287.                         M[i+1] = (sce0->coeffs[start+w2*128+i+1]

  2288.                                 + sce1->coeffs[start+w2*128+i+1]) * 0.5;

  2289.                         M[i+2] = (sce0->coeffs[start+w2*128+i+2]

  2290.                                 + sce1->coeffs[start+w2*128+i+2]) * 0.5;

  2291.                         M[i+3] = (sce0->coeffs[start+w2*128+i+3]

  2292.                                 + sce1->coeffs[start+w2*128+i+3]) * 0.5;

  2293. 

  2294.                         S[i  ] =  M[i  ]

  2295.                                 - sce1->coeffs[start+w2*128+i  ];

  2296.                         S[i+1] =  M[i+1]

  2297.                                 - sce1->coeffs[start+w2*128+i+1];

  2298.                         S[i+2] =  M[i+2]

  2299.                                 - sce1->coeffs[start+w2*128+i+2];

  2300.                         S[i+3] =  M[i+3]

  2301.                                 - sce1->coeffs[start+w2*128+i+3];

  2302.                    }

  2303.                     abs_pow34_v(L34, sce0->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);

  2304.                     abs_pow34_v(R34, sce1->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);

  2305.                     abs_pow34_v(M34, M,                         sce0->ics.swb_sizes[g]);

  2306.                     abs_pow34_v(S34, S,                         sce0->ics.swb_sizes[g]);

  2307.                     dist1 += quantize_band_cost(s, &sce0->coeffs[start + (w+w2)*128],

  2308.                                                 L34,

  2309.                                                 sce0->ics.swb_sizes[g],

  2310.                                                 sce0->sf_idx[(w+w2)*16+g],

  2311.                                                 sce0->band_type[(w+w2)*16+g],

  2312.                                                 lambda / band0->threshold, INFINITY, NULL, 0);

  2313.                     dist1 += quantize_band_cost(s, &sce1->coeffs[start + (w+w2)*128],

  2314.                                                 R34,

  2315.                                                 sce1->ics.swb_sizes[g],

  2316.                                                 sce1->sf_idx[(w+w2)*16+g],

  2317.                                                 sce1->band_type[(w+w2)*16+g],

  2318.                                                 lambda / band1->threshold, INFINITY, NULL, 0);

  2319.                     dist2 += quantize_band_cost(s, M,

  2320.                                                 M34,

  2321.                                                 sce0->ics.swb_sizes[g],

  2322.                                                 sce0->sf_idx[(w+w2)*16+g],

  2323.                                                 sce0->band_type[(w+w2)*16+g],

  2324.                                                 lambda / maxthr, INFINITY, NULL, 0);

  2325.                     dist2 += quantize_band_cost(s, S,

  2326.                                                 S34,

  2327.                                                 sce1->ics.swb_sizes[g],

  2328.                                                 sce1->sf_idx[(w+w2)*16+g],

  2329.                                                 sce1->band_type[(w+w2)*16+g],

  2330.                                                 lambda / minthr, INFINITY, NULL, 0);

  2331.                 }

  2332.                 cpe->ms_mask[w*16+g] = dist2 < dist1;

  2333.             }

  2334.             start += sce0->ics.swb_sizes[g];

  2335.         }

  2336.     }

  2337. }

  2338. #endif /*HAVE_MIPSFPU */

  2339. 

  2340. #include "libavcodec/aaccoder_trellis.h"

  2341. 

  2342. #endif /* HAVE_INLINE_ASM */

  2343. 

  2344. void ff_aac_coder_init_mips(AACEncContext *c) {

  2345. #if HAVE_INLINE_ASM

  2346.     AACCoefficientsEncoder *e = c->coder;

  2347.     int option = c->options.aac_coder;

  2348. 

  2349.     if (option == 2) {

  2350.         e->quantize_and_encode_band = quantize_and_encode_band_mips;

  2351.         e->encode_window_bands_info = codebook_trellis_rate;

  2352. #if HAVE_MIPSFPU

  2353.         e->search_for_quantizers    = search_for_quantizers_twoloop;

  2354. #endif /* HAVE_MIPSFPU */

  2355.     }

  2356. #if HAVE_MIPSFPU

  2357.     e->search_for_ms            = search_for_ms_mips;

  2358. #endif /* HAVE_MIPSFPU */

  2359. #endif /* HAVE_INLINE_ASM */

  2360. }