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

2585 lines
106KB
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. 

  66. #if HAVE_INLINE_ASM

  67. typedef struct BandCodingPath {

  68.     int prev_idx;

  69.     float cost;

  70.     int run;

  71. } BandCodingPath;

  72. 

  73. static const uint8_t run_value_bits_long[64] = {

  74.      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,

  75.      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5, 10,

  76.     10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,

  77.     10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 15

  78. };

  79. 

  80. static const uint8_t run_value_bits_short[16] = {

  81.     3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 9

  82. };

  83. 

  84. static const uint8_t * const run_value_bits[2] = {

  85.     run_value_bits_long, run_value_bits_short

  86. };

  87. 

  88. static const uint8_t uquad_sign_bits[81] = {

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

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

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

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

  93.     2, 3, 3, 3, 4, 4, 3, 4, 4,

  94.     2, 3, 3, 3, 4, 4, 3, 4, 4,

  95.     1, 2, 2, 2, 3, 3, 2, 3, 3,

  96.     2, 3, 3, 3, 4, 4, 3, 4, 4,

  97.     2, 3, 3, 3, 4, 4, 3, 4, 4

  98. };

  99. 

  100. static const uint8_t upair7_sign_bits[64] = {

  101.     0, 1, 1, 1, 1, 1, 1, 1,

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

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

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

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

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

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

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

  109. };

  110. 

  111. static const uint8_t upair12_sign_bits[169] = {

  112.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  113.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  114.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  115.     1, 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,

  117.     1, 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,

  119.     1, 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,

  121.     1, 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,

  123.     1, 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

  125. };

  126. 

  127. static const uint8_t esc_sign_bits[289] = {

  128.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  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.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  132.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  133.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  134.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  135.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  136.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  137.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  138.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  139.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  140.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  141.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  142.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  143.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  144.     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2

  145. };

  146. 

  147. #define ROUND_STANDARD 0.4054f

  148. #define ROUND_TO_ZERO 0.1054f

  149. 

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

  151. #ifndef USE_REALLY_FULL_SEARCH

  152.     int i;

  153.     float a, b, c, d;

  154.     float ax, bx, cx, dx;

  155. 

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

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

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

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

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

  161. 

  162.         ax = sqrtf(a);

  163.         bx = sqrtf(b);

  164.         cx = sqrtf(c);

  165.         dx = sqrtf(d);

  166. 

  167.         a = a * ax;

  168.         b = b * bx;

  169.         c = c * cx;

  170.         d = d * dx;

  171. 

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

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

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

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

  176.     }

  177. #endif /* USE_REALLY_FULL_SEARCH */

  178. }

  179. 

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

  181.     float maxval = 0.0f;

  182.     int w2, i;

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

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

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

  186.         }

  187.     }

  188.     return maxval;

  189. }

  190. 

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

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

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

  194.     int qmaxval, cb;

  195.     qmaxval = maxval * Q34 + 0.4054f;

  196.     if      (qmaxval ==  0) cb = 0;

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

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

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

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

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

  202.     else                    cb = 11;

  203.     return cb;

  204. }

  205. 

  206. /**

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

  208.  */

  209. static void quantize_and_encode_band_cost_SQUAD_mips(struct AACEncContext *s,

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

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

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

  213.                                                      int *bits, const float ROUNDING)

  214. {

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

  216.     int i;

  217.     int qc1, qc2, qc3, qc4;

  218. 

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

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

  221. 

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

  223.     scaled = s->scoefs;

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

  225.         int curidx;

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

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

  228. 

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

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

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

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

  233. 

  234.         __asm__ volatile (

  235.             ".set push                      \n\t"

  236.             ".set noreorder                 \n\t"

  237. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  258. 

  259.             ".set pop                       \n\t"

  260. 

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

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

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

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

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

  266.             : "memory"

  267.         );

  268. 

  269.         curidx = qc1;

  270.         curidx *= 3;

  271.         curidx += qc2;

  272.         curidx *= 3;

  273.         curidx += qc3;

  274.         curidx *= 3;

  275.         curidx += qc4;

  276.         curidx += 40;

  277. 

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

  279.     }

  280. }

  281. 

  282. static void quantize_and_encode_band_cost_UQUAD_mips(struct AACEncContext *s,

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

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

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

  286.                                                      int *bits, const float ROUNDING)

  287. {

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

  289.     int i;

  290.     int qc1, qc2, qc3, qc4;

  291. 

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

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

  294. 

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

  296.     scaled = s->scoefs;

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

  298.         int curidx, sign, count;

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

  300.         uint8_t v_bits;

  301.         unsigned int v_codes;

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

  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. }

  373. 

  374. static void quantize_and_encode_band_cost_SPAIR_mips(struct AACEncContext *s,

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

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

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

  378.                                                      int *bits, const float ROUNDING)

  379. {

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

  381.     int i;

  382.     int qc1, qc2, qc3, qc4;

  383. 

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

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

  386. 

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

  388.     scaled = s->scoefs;

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

  390.         int curidx, curidx2;

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

  392.         uint8_t v_bits;

  393.         unsigned int v_codes;

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

  395. 

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

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

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

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

  400. 

  401.         __asm__ volatile (

  402.             ".set push                      \n\t"

  403.             ".set noreorder                 \n\t"

  404. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  430. 

  431.             ".set pop                       \n\t"

  432. 

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

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

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

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

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

  438.             : "memory"

  439.         );

  440. 

  441.         curidx = 9 * qc1;

  442.         curidx += qc2 + 40;

  443. 

  444.         curidx2 = 9 * qc3;

  445.         curidx2 += qc4 + 40;

  446. 

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

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

  449.         put_bits(pb, v_bits, v_codes);

  450.     }

  451. }

  452. 

  453. static void quantize_and_encode_band_cost_UPAIR7_mips(struct AACEncContext *s,

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

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

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

  457.                                                       int *bits, const float ROUNDING)

  458. {

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

  460.     int i;

  461.     int qc1, qc2, qc3, qc4;

  462. 

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

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

  465. 

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

  467.     scaled = s->scoefs;

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

  469.         int curidx, sign1, count1, sign2, count2;

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

  471.         uint8_t v_bits;

  472.         unsigned int v_codes;

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

  474. 

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

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

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

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

  479. 

  480.         __asm__ volatile (

  481.             ".set push                              \n\t"

  482.             ".set noreorder                         \n\t"

  483. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  517. 

  518.             ".set pop                               \n\t"

  519. 

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

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

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

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

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

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

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

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

  528.               "memory"

  529.         );

  530. 

  531.         curidx  = 8 * qc1;

  532.         curidx += qc2;

  533. 

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

  535.         v_bits  = p_bits[curidx] + count1;

  536.         put_bits(pb, v_bits, v_codes);

  537. 

  538.         curidx  = 8 * qc3;

  539.         curidx += qc4;

  540. 

  541.         v_codes = (p_codes[curidx] << count2) | sign2;

  542.         v_bits  = p_bits[curidx] + count2;

  543.         put_bits(pb, v_bits, v_codes);

  544.     }

  545. }

  546. 

  547. static void quantize_and_encode_band_cost_UPAIR12_mips(struct AACEncContext *s,

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

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

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

  551.                                                        int *bits, const float ROUNDING)

  552. {

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

  554.     int i;

  555.     int qc1, qc2, qc3, qc4;

  556. 

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

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

  559. 

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

  561.     scaled = s->scoefs;

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

  563.         int curidx, sign1, count1, sign2, count2;

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

  565.         uint8_t v_bits;

  566.         unsigned int v_codes;

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

  568. 

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

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

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

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

  573. 

  574.         __asm__ volatile (

  575.             ".set push                              \n\t"

  576.             ".set noreorder                         \n\t"

  577. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  611. 

  612.             ".set pop                               \n\t"

  613. 

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

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

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

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

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

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

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

  621.             : "memory"

  622.         );

  623. 

  624.         curidx  = 13 * qc1;

  625.         curidx += qc2;

  626. 

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

  628.         v_bits  = p_bits[curidx] + count1;

  629.         put_bits(pb, v_bits, v_codes);

  630. 

  631.         curidx  = 13 * qc3;

  632.         curidx += qc4;

  633. 

  634.         v_codes = (p_codes[curidx] << count2) | sign2;

  635.         v_bits  = p_bits[curidx] + count2;

  636.         put_bits(pb, v_bits, v_codes);

  637.     }

  638. }

  639. 

  640. static void quantize_and_encode_band_cost_ESC_mips(struct AACEncContext *s,

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

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

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

  644.                                                    int *bits, const float ROUNDING)

  645. {

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

  647.     int i;

  648.     int qc1, qc2, qc3, qc4;

  649. 

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

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

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

  653. 

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

  655.     scaled = s->scoefs;

  656. 

  657.     if (cb < 11) {

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

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

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

  661.             uint8_t v_bits;

  662.             unsigned int v_codes;

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

  664. 

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

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

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

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

  669. 

  670.             __asm__ volatile (

  671.                 ".set push                                  \n\t"

  672.                 ".set noreorder                             \n\t"

  673. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  707. 

  708.                 ".set pop                                   \n\t"

  709. 

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

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

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

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

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

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

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

  717.                 : "memory"

  718.             );

  719. 

  720.             curidx = 17 * qc1;

  721.             curidx += qc2;

  722.             curidx2 = 17 * qc3;

  723.             curidx2 += qc4;

  724. 

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

  726.             v_bits  = p_bits[curidx] + count1;

  727.             put_bits(pb, v_bits, v_codes);

  728. 

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

  730.             v_bits  = p_bits[curidx2] + count2;

  731.             put_bits(pb, v_bits, v_codes);

  732.         }

  733.     } else {

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

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

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

  737.             uint8_t v_bits;

  738.             unsigned int v_codes;

  739.             int c1, c2, c3, c4;

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

  741. 

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

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

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

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

  746. 

  747.             __asm__ volatile (

  748.                 ".set push                                  \n\t"

  749.                 ".set noreorder                             \n\t"

  750. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  792. 

  793.                 ".set pop                                   \n\t"

  794. 

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

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

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

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

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

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

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

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

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

  804.                 : "memory"

  805.             );

  806. 

  807.             curidx = 17 * qc1;

  808.             curidx += qc2;

  809. 

  810.             curidx2 = 17 * qc3;

  811.             curidx2 += qc4;

  812. 

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

  814.             v_bits  = p_bits[curidx] + count1;

  815.             put_bits(pb, v_bits, v_codes);

  816. 

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

  818.                 int len = av_log2(c1);

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

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

  821.             }

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

  823.                 int len = av_log2(c2);

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

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

  826.             }

  827. 

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

  829.             v_bits  = p_bits[curidx2] + count2;

  830.             put_bits(pb, v_bits, v_codes);

  831. 

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

  833.                 int len = av_log2(c3);

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

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

  836.             }

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

  838.                 int len = av_log2(c4);

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

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

  841.             }

  842.         }

  843.     }

  844. }

  845. 

  846. static void quantize_and_encode_band_cost_NONE_mips(struct AACEncContext *s,

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

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

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

  850.                                                          int *bits, const float ROUNDING) {

  851.     av_assert0(0);

  852. }

  853. 

  854. static void quantize_and_encode_band_cost_ZERO_mips(struct AACEncContext *s,

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

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

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

  858.                                                          int *bits, const float ROUNDING) {

  859.     int i;

  860.     if (bits)

  861.         *bits = 0;

  862.     if (out) {

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

  864.            out[i  ] = 0.0f;

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

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

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

  868.         }

  869.     }

  870. }

  871. 

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

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

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

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

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

  877.     quantize_and_encode_band_cost_ZERO_mips,

  878.     quantize_and_encode_band_cost_SQUAD_mips,

  879.     quantize_and_encode_band_cost_SQUAD_mips,

  880.     quantize_and_encode_band_cost_UQUAD_mips,

  881.     quantize_and_encode_band_cost_UQUAD_mips,

  882.     quantize_and_encode_band_cost_SPAIR_mips,

  883.     quantize_and_encode_band_cost_SPAIR_mips,

  884.     quantize_and_encode_band_cost_UPAIR7_mips,

  885.     quantize_and_encode_band_cost_UPAIR7_mips,

  886.     quantize_and_encode_band_cost_UPAIR12_mips,

  887.     quantize_and_encode_band_cost_UPAIR12_mips,

  888.     quantize_and_encode_band_cost_ESC_mips,

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

  890.     quantize_and_encode_band_cost_ZERO_mips,

  891.     quantize_and_encode_band_cost_ZERO_mips,

  892.     quantize_and_encode_band_cost_ZERO_mips,

  893. };

  894. 

  895. #define quantize_and_encode_band_cost(                                       \

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

  897.                                 lambda, uplim, bits, ROUNDING)               \

  898.     quantize_and_encode_band_cost_arr[cb](                                   \

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

  900.                                 lambda, uplim, bits, ROUNDING)

  901. 

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

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

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

  905. {

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

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

  908. }

  909. 

  910. /**

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

  912.  */

  913. static float get_band_numbits_ZERO_mips(struct AACEncContext *s,

  914.                                         PutBitContext *pb, const float *in,

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

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

  917.                                         int *bits)

  918. {

  919.     return 0;

  920. }

  921. 

  922. static float get_band_numbits_NONE_mips(struct AACEncContext *s,

  923.                                         PutBitContext *pb, const float *in,

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

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

  926.                                         int *bits)

  927. {

  928.     av_assert0(0);

  929.     return 0;

  930. }

  931. 

  932. static float get_band_numbits_SQUAD_mips(struct AACEncContext *s,

  933.                                          PutBitContext *pb, const float *in,

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

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

  936.                                          int *bits)

  937. {

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

  939.     int i;

  940.     int qc1, qc2, qc3, qc4;

  941.     int curbits = 0;

  942. 

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

  944. 

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

  946.         int curidx;

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

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

  949. 

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

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

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

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

  954. 

  955.         __asm__ volatile (

  956.             ".set push                      \n\t"

  957.             ".set noreorder                 \n\t"

  958. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  979. 

  980.             ".set pop                       \n\t"

  981. 

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

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

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

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

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

  987.             : "memory"

  988.         );

  989. 

  990.         curidx = qc1;

  991.         curidx *= 3;

  992.         curidx += qc2;

  993.         curidx *= 3;

  994.         curidx += qc3;

  995.         curidx *= 3;

  996.         curidx += qc4;

  997.         curidx += 40;

  998. 

  999.         curbits += p_bits[curidx];

  1000.     }

  1001.     return curbits;

  1002. }

  1003. 

  1004. static float get_band_numbits_UQUAD_mips(struct AACEncContext *s,

  1005.                                          PutBitContext *pb, const float *in,

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

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

  1008.                                          int *bits)

  1009. {

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

  1011.     int i;

  1012.     int curbits = 0;

  1013.     int qc1, qc2, qc3, qc4;

  1014. 

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

  1016. 

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

  1018.         int curidx;

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

  1020. 

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

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

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

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

  1025. 

  1026.         __asm__ volatile (

  1027.             ".set push                      \n\t"

  1028.             ".set noreorder                 \n\t"

  1029. 

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

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

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

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

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

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

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

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

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

  1039. 

  1040.             ".set pop                       \n\t"

  1041. 

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

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

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

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

  1046.         );

  1047. 

  1048.         curidx = qc1;

  1049.         curidx *= 3;

  1050.         curidx += qc2;

  1051.         curidx *= 3;

  1052.         curidx += qc3;

  1053.         curidx *= 3;

  1054.         curidx += qc4;

  1055. 

  1056.         curbits += p_bits[curidx];

  1057.         curbits += uquad_sign_bits[curidx];

  1058.     }

  1059.     return curbits;

  1060. }

  1061. 

  1062. static float get_band_numbits_SPAIR_mips(struct AACEncContext *s,

  1063.                                          PutBitContext *pb, const float *in,

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

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

  1066.                                          int *bits)

  1067. {

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

  1069.     int i;

  1070.     int qc1, qc2, qc3, qc4;

  1071.     int curbits = 0;

  1072. 

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

  1074. 

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

  1076.         int curidx, curidx2;

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

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

  1079. 

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

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

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

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

  1084. 

  1085.         __asm__ volatile (

  1086.             ".set push                      \n\t"

  1087.             ".set noreorder                 \n\t"

  1088. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1114. 

  1115.             ".set pop                       \n\t"

  1116. 

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

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

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

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

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

  1122.             : "memory"

  1123.         );

  1124. 

  1125.         curidx  = 9 * qc1;

  1126.         curidx += qc2 + 40;

  1127. 

  1128.         curidx2  = 9 * qc3;

  1129.         curidx2 += qc4 + 40;

  1130. 

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

  1132.     }

  1133.     return curbits;

  1134. }

  1135. 

  1136. static float get_band_numbits_UPAIR7_mips(struct AACEncContext *s,

  1137.                                           PutBitContext *pb, const float *in,

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

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

  1140.                                           int *bits)

  1141. {

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

  1143.     int i;

  1144.     int qc1, qc2, qc3, qc4;

  1145.     int curbits = 0;

  1146. 

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

  1148. 

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

  1150.         int curidx, curidx2;

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

  1152. 

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

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

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

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

  1157. 

  1158.         __asm__ volatile (

  1159.             ".set push                      \n\t"

  1160.             ".set noreorder                 \n\t"

  1161. 

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

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

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

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

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

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

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

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

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

  1171. 

  1172.             ".set pop                       \n\t"

  1173. 

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

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

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

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

  1178.         );

  1179. 

  1180.         curidx  = 8 * qc1;

  1181.         curidx += qc2;

  1182. 

  1183.         curidx2  = 8 * qc3;

  1184.         curidx2 += qc4;

  1185. 

  1186.         curbits += p_bits[curidx] +

  1187.                    upair7_sign_bits[curidx] +

  1188.                    p_bits[curidx2] +

  1189.                    upair7_sign_bits[curidx2];

  1190.     }

  1191.     return curbits;

  1192. }

  1193. 

  1194. static float get_band_numbits_UPAIR12_mips(struct AACEncContext *s,

  1195.                                            PutBitContext *pb, const float *in,

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

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

  1198.                                            int *bits)

  1199. {

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

  1201.     int i;

  1202.     int qc1, qc2, qc3, qc4;

  1203.     int curbits = 0;

  1204. 

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

  1206. 

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

  1208.         int curidx, curidx2;

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

  1210. 

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

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

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

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

  1215. 

  1216.         __asm__ volatile (

  1217.             ".set push                      \n\t"

  1218.             ".set noreorder                 \n\t"

  1219. 

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

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

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

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

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

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

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

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

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

  1229. 

  1230.             ".set pop                       \n\t"

  1231. 

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

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

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

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

  1236.         );

  1237. 

  1238.         curidx  = 13 * qc1;

  1239.         curidx += qc2;

  1240. 

  1241.         curidx2  = 13 * qc3;

  1242.         curidx2 += qc4;

  1243. 

  1244.         curbits += p_bits[curidx] +

  1245.                    p_bits[curidx2] +

  1246.                    upair12_sign_bits[curidx] +

  1247.                    upair12_sign_bits[curidx2];

  1248.     }

  1249.     return curbits;

  1250. }

  1251. 

  1252. static float get_band_numbits_ESC_mips(struct AACEncContext *s,

  1253.                                        PutBitContext *pb, const float *in,

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

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

  1256.                                        int *bits)

  1257. {

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

  1259.     int i;

  1260.     int qc1, qc2, qc3, qc4;

  1261.     int curbits = 0;

  1262. 

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

  1264. 

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

  1266.         int curidx, curidx2;

  1267.         int cond0, cond1, cond2, cond3;

  1268.         int c1, c2, c3, c4;

  1269.         int t4, t5;

  1270. 

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

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

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

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

  1275. 

  1276.         __asm__ volatile (

  1277.             ".set push                                  \n\t"

  1278.             ".set noreorder                             \n\t"

  1279. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1323. 

  1324.             ".set pop                                   \n\t"

  1325. 

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

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

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

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

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

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

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

  1333.         );

  1334. 

  1335.         curidx = 17 * qc1;

  1336.         curidx += qc2;

  1337. 

  1338.         curidx2 = 17 * qc3;

  1339.         curidx2 += qc4;

  1340. 

  1341.         curbits += p_bits[curidx];

  1342.         curbits += esc_sign_bits[curidx];

  1343.         curbits += p_bits[curidx2];

  1344.         curbits += esc_sign_bits[curidx2];

  1345. 

  1346.         curbits += c1;

  1347.         curbits += c2;

  1348.         curbits += c3;

  1349.         curbits += c4;

  1350.     }

  1351.     return curbits;

  1352. }

  1353. 

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

  1355.                                              PutBitContext *pb, const float *in,

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

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

  1358.                                              int *bits) = {

  1359.     get_band_numbits_ZERO_mips,

  1360.     get_band_numbits_SQUAD_mips,

  1361.     get_band_numbits_SQUAD_mips,

  1362.     get_band_numbits_UQUAD_mips,

  1363.     get_band_numbits_UQUAD_mips,

  1364.     get_band_numbits_SPAIR_mips,

  1365.     get_band_numbits_SPAIR_mips,

  1366.     get_band_numbits_UPAIR7_mips,

  1367.     get_band_numbits_UPAIR7_mips,

  1368.     get_band_numbits_UPAIR12_mips,

  1369.     get_band_numbits_UPAIR12_mips,

  1370.     get_band_numbits_ESC_mips,

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

  1372.     get_band_numbits_ZERO_mips,

  1373.     get_band_numbits_ZERO_mips,

  1374.     get_band_numbits_ZERO_mips,

  1375. };

  1376. 

  1377. #define get_band_numbits(                                  \

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

  1379.                                 lambda, uplim, bits)                    \

  1380.     get_band_numbits_arr[cb](                              \

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

  1382.                                 lambda, uplim, bits)

  1383. 

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

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

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

  1387.                                      int *bits)

  1388. {

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

  1390. }

  1391. 

  1392. /**

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

  1394.  */

  1395. #if HAVE_MIPSFPU

  1396. static float get_band_cost_ZERO_mips(struct AACEncContext *s,

  1397.                                      PutBitContext *pb, const float *in,

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

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

  1400.                                      int *bits)

  1401. {

  1402.     int i;

  1403.     float cost = 0;

  1404. 

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

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

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

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

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

  1410.     }

  1411.     if (bits)

  1412.         *bits = 0;

  1413.     return cost * lambda;

  1414. }

  1415. 

  1416. static float get_band_cost_NONE_mips(struct AACEncContext *s,

  1417.                                      PutBitContext *pb, const float *in,

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

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

  1420.                                      int *bits)

  1421. {

  1422.     av_assert0(0);

  1423.     return 0;

  1424. }

  1425. 

  1426. static float get_band_cost_SQUAD_mips(struct AACEncContext *s,

  1427.                                       PutBitContext *pb, const float *in,

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

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

  1430.                                       int *bits)

  1431. {

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

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

  1434.     int i;

  1435.     float cost = 0;

  1436.     int qc1, qc2, qc3, qc4;

  1437.     int curbits = 0;

  1438. 

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

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

  1441. 

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

  1443.         const float *vec;

  1444.         int curidx;

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

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

  1447.         float di0, di1, di2, di3;

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

  1449. 

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

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

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

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

  1454. 

  1455.         __asm__ volatile (

  1456.             ".set push                                  \n\t"

  1457.             ".set noreorder                             \n\t"

  1458. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1479. 

  1480.             ".set pop                                   \n\t"

  1481. 

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

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

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

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

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

  1487.             : "memory"

  1488.         );

  1489. 

  1490.         curidx = qc1;

  1491.         curidx *= 3;

  1492.         curidx += qc2;

  1493.         curidx *= 3;

  1494.         curidx += qc3;

  1495.         curidx *= 3;

  1496.         curidx += qc4;

  1497.         curidx += 40;

  1498. 

  1499.         curbits += p_bits[curidx];

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

  1501. 

  1502.         __asm__ volatile (

  1503.             ".set push                                  \n\t"

  1504.             ".set noreorder                             \n\t"

  1505. 

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

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

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

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

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

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

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

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

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

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

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

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

  1518. 

  1519.             ".set pop                                   \n\t"

  1520. 

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

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

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

  1524.               [IQ]"f"(IQ)

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

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

  1527.               "memory"

  1528.         );

  1529. 

  1530.         cost += di0 * di0 + di1 * di1

  1531.                 + di2 * di2 + di3 * di3;

  1532.     }

  1533. 

  1534.     if (bits)

  1535.         *bits = curbits;

  1536.     return cost * lambda + curbits;

  1537. }

  1538. 

  1539. static float get_band_cost_UQUAD_mips(struct AACEncContext *s,

  1540.                                       PutBitContext *pb, const float *in,

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

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

  1543.                                       int *bits)

  1544. {

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

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

  1547.     int i;

  1548.     float cost = 0;

  1549.     int curbits = 0;

  1550.     int qc1, qc2, qc3, qc4;

  1551. 

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

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

  1554. 

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

  1556.         const float *vec;

  1557.         int curidx;

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

  1559.         float di0, di1, di2, di3;

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

  1561. 

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

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

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

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

  1566. 

  1567.         __asm__ volatile (

  1568.             ".set push                                  \n\t"

  1569.             ".set noreorder                             \n\t"

  1570. 

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

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

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

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

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

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

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

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

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

  1580. 

  1581.             ".set pop                                   \n\t"

  1582. 

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

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

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

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

  1587.         );

  1588. 

  1589.         curidx = qc1;

  1590.         curidx *= 3;

  1591.         curidx += qc2;

  1592.         curidx *= 3;

  1593.         curidx += qc3;

  1594.         curidx *= 3;

  1595.         curidx += qc4;

  1596. 

  1597.         curbits += p_bits[curidx];

  1598.         curbits += uquad_sign_bits[curidx];

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

  1600. 

  1601.         __asm__ volatile (

  1602.             ".set push                                  \n\t"

  1603.             ".set noreorder                             \n\t"

  1604. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1620.             "nmsub.s    %[di3], %[di3], $f3,    %[IQ]   \n\t"

  1621. 

  1622.             ".set pop                                   \n\t"

  1623. 

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

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

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

  1627.               [IQ]"f"(IQ)

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

  1629.               "memory"

  1630.         );

  1631. 

  1632.         cost += di0 * di0 + di1 * di1

  1633.                 + di2 * di2 + di3 * di3;

  1634.     }

  1635. 

  1636.     if (bits)

  1637.         *bits = curbits;

  1638.     return cost * lambda + curbits;

  1639. }

  1640. 

  1641. static float get_band_cost_SPAIR_mips(struct AACEncContext *s,

  1642.                                       PutBitContext *pb, const float *in,

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

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

  1645.                                       int *bits)

  1646. {

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

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

  1649.     int i;

  1650.     float cost = 0;

  1651.     int qc1, qc2, qc3, qc4;

  1652.     int curbits = 0;

  1653. 

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

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

  1656. 

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

  1658.         const float *vec, *vec2;

  1659.         int curidx, curidx2;

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

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

  1662.         float di0, di1, di2, di3;

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

  1664. 

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

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

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

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

  1669. 

  1670.         __asm__ volatile (

  1671.             ".set push                                  \n\t"

  1672.             ".set noreorder                             \n\t"

  1673. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1699. 

  1700.             ".set pop                                   \n\t"

  1701. 

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

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

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

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

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

  1707.             : "memory"

  1708.         );

  1709. 

  1710.         curidx = 9 * qc1;

  1711.         curidx += qc2 + 40;

  1712. 

  1713.         curidx2 = 9 * qc3;

  1714.         curidx2 += qc4 + 40;

  1715. 

  1716.         curbits += p_bits[curidx];

  1717.         curbits += p_bits[curidx2];

  1718. 

  1719.         vec     = &p_codes[curidx*2];

  1720.         vec2    = &p_codes[curidx2*2];

  1721. 

  1722.         __asm__ volatile (

  1723.             ".set push                                  \n\t"

  1724.             ".set noreorder                             \n\t"

  1725. 

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

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

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

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

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

  1731.             "lwc1       $f5,    0(%[vec2])              \n\t"

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

  1733.             "lwc1       $f7,    4(%[vec2])              \n\t"

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

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

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

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

  1738. 

  1739.             ".set pop                                   \n\t"

  1740. 

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

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

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

  1744.               [vec2]"r"(vec2), [IQ]"f"(IQ)

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

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

  1747.               "memory"

  1748.         );

  1749. 

  1750.         cost += di0 * di0 + di1 * di1

  1751.                 + di2 * di2 + di3 * di3;

  1752.     }

  1753. 

  1754.     if (bits)

  1755.         *bits = curbits;

  1756.     return cost * lambda + curbits;

  1757. }

  1758. 

  1759. static float get_band_cost_UPAIR7_mips(struct AACEncContext *s,

  1760.                                        PutBitContext *pb, const float *in,

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

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

  1763.                                        int *bits)

  1764. {

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

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

  1767.     int i;

  1768.     float cost = 0;

  1769.     int qc1, qc2, qc3, qc4;

  1770.     int curbits = 0;

  1771. 

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

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

  1774. 

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

  1776.         const float *vec, *vec2;

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

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

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

  1780.         float di0, di1, di2, di3;

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

  1782. 

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

  1784.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1785.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1786.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1787. 

  1788.         __asm__ volatile (

  1789.             ".set push                                          \n\t"

  1790.             ".set noreorder                                     \n\t"

  1791. 

  1792.             "ori        %[t4],      $zero,      7               \n\t"

  1793.             "ori        %[sign1],   $zero,      0               \n\t"

  1794.             "ori        %[sign2],   $zero,      0               \n\t"

  1795.             "slt        %[t0],      %[t4],      %[qc1]          \n\t"

  1796.             "slt        %[t1],      %[t4],      %[qc2]          \n\t"

  1797.             "slt        %[t2],      %[t4],      %[qc3]          \n\t"

  1798.             "slt        %[t3],      %[t4],      %[qc4]          \n\t"

  1799.             "movn       %[qc1],     %[t4],      %[t0]           \n\t"

  1800.             "movn       %[qc2],     %[t4],      %[t1]           \n\t"

  1801.             "movn       %[qc3],     %[t4],      %[t2]           \n\t"

  1802.             "movn       %[qc4],     %[t4],      %[t3]           \n\t"

  1803.             "lw         %[t0],      0(%[in_int])                \n\t"

  1804.             "lw         %[t1],      4(%[in_int])                \n\t"

  1805.             "lw         %[t2],      8(%[in_int])                \n\t"

  1806.             "lw         %[t3],      12(%[in_int])               \n\t"

  1807.             "slt        %[t0],      %[t0],      $zero           \n\t"

  1808.             "movn       %[sign1],   %[t0],      %[qc1]          \n\t"

  1809.             "slt        %[t2],      %[t2],      $zero           \n\t"

  1810.             "movn       %[sign2],   %[t2],      %[qc3]          \n\t"

  1811.             "slt        %[t1],      %[t1],      $zero           \n\t"

  1812.             "sll        %[t0],      %[sign1],   1               \n\t"

  1813.             "or         %[t0],      %[t0],      %[t1]           \n\t"

  1814.             "movn       %[sign1],   %[t0],      %[qc2]          \n\t"

  1815.             "slt        %[t3],      %[t3],      $zero           \n\t"

  1816.             "sll        %[t0],      %[sign2],   1               \n\t"

  1817.             "or         %[t0],      %[t0],      %[t3]           \n\t"

  1818.             "movn       %[sign2],   %[t0],      %[qc4]          \n\t"

  1819.             "slt        %[count1],  $zero,      %[qc1]          \n\t"

  1820.             "slt        %[t1],      $zero,      %[qc2]          \n\t"

  1821.             "slt        %[count2],  $zero,      %[qc3]          \n\t"

  1822.             "slt        %[t2],      $zero,      %[qc4]          \n\t"

  1823.             "addu       %[count1],  %[count1],  %[t1]           \n\t"

  1824.             "addu       %[count2],  %[count2],  %[t2]           \n\t"

  1825. 

  1826.             ".set pop                                           \n\t"

  1827. 

  1828.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1829.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1830.               [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  1831.               [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  1832.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1833.               [t4]"=&r"(t4)

  1834.             : [in_int]"r"(in_int)

  1835.             : "memory"

  1836.         );

  1837. 

  1838.         curidx = 8 * qc1;

  1839.         curidx += qc2;

  1840. 

  1841.         curidx2 = 8 * qc3;

  1842.         curidx2 += qc4;

  1843. 

  1844.         curbits += p_bits[curidx];

  1845.         curbits += upair7_sign_bits[curidx];

  1846.         vec     = &p_codes[curidx*2];

  1847. 

  1848.         curbits += p_bits[curidx2];

  1849.         curbits += upair7_sign_bits[curidx2];

  1850.         vec2    = &p_codes[curidx2*2];

  1851. 

  1852.         __asm__ volatile (

  1853.             ".set push                                          \n\t"

  1854.             ".set noreorder                                     \n\t"

  1855. 

  1856.             "lwc1       %[di0],     0(%[in_pos])                \n\t"

  1857.             "lwc1       %[di1],     4(%[in_pos])                \n\t"

  1858.             "lwc1       %[di2],     8(%[in_pos])                \n\t"

  1859.             "lwc1       %[di3],     12(%[in_pos])               \n\t"

  1860.             "abs.s      %[di0],     %[di0]                      \n\t"

  1861.             "abs.s      %[di1],     %[di1]                      \n\t"

  1862.             "abs.s      %[di2],     %[di2]                      \n\t"

  1863.             "abs.s      %[di3],     %[di3]                      \n\t"

  1864.             "lwc1       $f0,        0(%[vec])                   \n\t"

  1865.             "lwc1       $f1,        4(%[vec])                   \n\t"

  1866.             "lwc1       $f2,        0(%[vec2])                  \n\t"

  1867.             "lwc1       $f3,        4(%[vec2])                  \n\t"

  1868.             "nmsub.s    %[di0],     %[di0],     $f0,    %[IQ]   \n\t"

  1869.             "nmsub.s    %[di1],     %[di1],     $f1,    %[IQ]   \n\t"

  1870.             "nmsub.s    %[di2],     %[di2],     $f2,    %[IQ]   \n\t"

  1871.             "nmsub.s    %[di3],     %[di3],     $f3,    %[IQ]   \n\t"

  1872. 

  1873.             ".set pop                                           \n\t"

  1874. 

  1875.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  1876.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  1877.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  1878.               [vec2]"r"(vec2), [IQ]"f"(IQ)

  1879.             : "$f0", "$f1", "$f2", "$f3",

  1880.               "memory"

  1881.         );

  1882. 

  1883.         cost += di0 * di0 + di1 * di1

  1884.                 + di2 * di2 + di3 * di3;

  1885.     }

  1886. 

  1887.     if (bits)

  1888.         *bits = curbits;

  1889.     return cost * lambda + curbits;

  1890. }

  1891. 

  1892. static float get_band_cost_UPAIR12_mips(struct AACEncContext *s,

  1893.                                         PutBitContext *pb, const float *in,

  1894.                                         const float *scaled, int size, int scale_idx,

  1895.                                         int cb, const float lambda, const float uplim,

  1896.                                         int *bits)

  1897. {

  1898.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  1899.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  1900.     int i;

  1901.     float cost = 0;

  1902.     int qc1, qc2, qc3, qc4;

  1903.     int curbits = 0;

  1904. 

  1905.     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];

  1906.     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];

  1907. 

  1908.     for (i = 0; i < size; i += 4) {

  1909.         const float *vec, *vec2;

  1910.         int curidx, curidx2;

  1911.         int sign1, count1, sign2, count2;

  1912.         int   *in_int = (int   *)&in[i];

  1913.         float *in_pos = (float *)&in[i];

  1914.         float di0, di1, di2, di3;

  1915.         int t0, t1, t2, t3, t4;

  1916. 

  1917.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  1918.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  1919.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  1920.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  1921. 

  1922.         __asm__ volatile (

  1923.             ".set push                                          \n\t"

  1924.             ".set noreorder                                     \n\t"

  1925. 

  1926.             "ori        %[t4],      $zero,      12              \n\t"

  1927.             "ori        %[sign1],   $zero,      0               \n\t"

  1928.             "ori        %[sign2],   $zero,      0               \n\t"

  1929.             "slt        %[t0],      %[t4],      %[qc1]          \n\t"

  1930.             "slt        %[t1],      %[t4],      %[qc2]          \n\t"

  1931.             "slt        %[t2],      %[t4],      %[qc3]          \n\t"

  1932.             "slt        %[t3],      %[t4],      %[qc4]          \n\t"

  1933.             "movn       %[qc1],     %[t4],      %[t0]           \n\t"

  1934.             "movn       %[qc2],     %[t4],      %[t1]           \n\t"

  1935.             "movn       %[qc3],     %[t4],      %[t2]           \n\t"

  1936.             "movn       %[qc4],     %[t4],      %[t3]           \n\t"

  1937.             "lw         %[t0],      0(%[in_int])                \n\t"

  1938.             "lw         %[t1],      4(%[in_int])                \n\t"

  1939.             "lw         %[t2],      8(%[in_int])                \n\t"

  1940.             "lw         %[t3],      12(%[in_int])               \n\t"

  1941.             "slt        %[t0],      %[t0],      $zero           \n\t"

  1942.             "movn       %[sign1],   %[t0],      %[qc1]          \n\t"

  1943.             "slt        %[t2],      %[t2],      $zero           \n\t"

  1944.             "movn       %[sign2],   %[t2],      %[qc3]          \n\t"

  1945.             "slt        %[t1],      %[t1],      $zero           \n\t"

  1946.             "sll        %[t0],      %[sign1],   1               \n\t"

  1947.             "or         %[t0],      %[t0],      %[t1]           \n\t"

  1948.             "movn       %[sign1],   %[t0],      %[qc2]          \n\t"

  1949.             "slt        %[t3],      %[t3],      $zero           \n\t"

  1950.             "sll        %[t0],      %[sign2],   1               \n\t"

  1951.             "or         %[t0],      %[t0],      %[t3]           \n\t"

  1952.             "movn       %[sign2],   %[t0],      %[qc4]          \n\t"

  1953.             "slt        %[count1],  $zero,      %[qc1]          \n\t"

  1954.             "slt        %[t1],      $zero,      %[qc2]          \n\t"

  1955.             "slt        %[count2],  $zero,      %[qc3]          \n\t"

  1956.             "slt        %[t2],      $zero,      %[qc4]          \n\t"

  1957.             "addu       %[count1],  %[count1],  %[t1]           \n\t"

  1958.             "addu       %[count2],  %[count2],  %[t2]           \n\t"

  1959. 

  1960.             ".set pop                                           \n\t"

  1961. 

  1962.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  1963.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  1964.               [sign1]"=&r"(sign1), [count1]"=&r"(count1),

  1965.               [sign2]"=&r"(sign2), [count2]"=&r"(count2),

  1966.               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),

  1967.               [t4]"=&r"(t4)

  1968.             : [in_int]"r"(in_int)

  1969.             : "memory"

  1970.         );

  1971. 

  1972.         curidx = 13 * qc1;

  1973.         curidx += qc2;

  1974. 

  1975.         curidx2 = 13 * qc3;

  1976.         curidx2 += qc4;

  1977. 

  1978.         curbits += p_bits[curidx];

  1979.         curbits += p_bits[curidx2];

  1980.         curbits += upair12_sign_bits[curidx];

  1981.         curbits += upair12_sign_bits[curidx2];

  1982.         vec     = &p_codes[curidx*2];

  1983.         vec2    = &p_codes[curidx2*2];

  1984. 

  1985.         __asm__ volatile (

  1986.             ".set push                                          \n\t"

  1987.             ".set noreorder                                     \n\t"

  1988. 

  1989.             "lwc1       %[di0],     0(%[in_pos])                \n\t"

  1990.             "lwc1       %[di1],     4(%[in_pos])                \n\t"

  1991.             "lwc1       %[di2],     8(%[in_pos])                \n\t"

  1992.             "lwc1       %[di3],     12(%[in_pos])               \n\t"

  1993.             "abs.s      %[di0],     %[di0]                      \n\t"

  1994.             "abs.s      %[di1],     %[di1]                      \n\t"

  1995.             "abs.s      %[di2],     %[di2]                      \n\t"

  1996.             "abs.s      %[di3],     %[di3]                      \n\t"

  1997.             "lwc1       $f0,        0(%[vec])                   \n\t"

  1998.             "lwc1       $f1,        4(%[vec])                   \n\t"

  1999.             "lwc1       $f2,        0(%[vec2])                  \n\t"

  2000.             "lwc1       $f3,        4(%[vec2])                  \n\t"

  2001.             "nmsub.s    %[di0],     %[di0],     $f0,    %[IQ]   \n\t"

  2002.             "nmsub.s    %[di1],     %[di1],     $f1,    %[IQ]   \n\t"

  2003.             "nmsub.s    %[di2],     %[di2],     $f2,    %[IQ]   \n\t"

  2004.             "nmsub.s    %[di3],     %[di3],     $f3,    %[IQ]   \n\t"

  2005. 

  2006.             ".set pop                                           \n\t"

  2007. 

  2008.             : [di0]"=&f"(di0), [di1]"=&f"(di1),

  2009.               [di2]"=&f"(di2), [di3]"=&f"(di3)

  2010.             : [in_pos]"r"(in_pos), [vec]"r"(vec),

  2011.               [vec2]"r"(vec2), [IQ]"f"(IQ)

  2012.             : "$f0", "$f1", "$f2", "$f3",

  2013.               "memory"

  2014.         );

  2015. 

  2016.         cost += di0 * di0 + di1 * di1

  2017.                 + di2 * di2 + di3 * di3;

  2018.     }

  2019. 

  2020.     if (bits)

  2021.         *bits = curbits;

  2022.     return cost * lambda + curbits;

  2023. }

  2024. 

  2025. static float get_band_cost_ESC_mips(struct AACEncContext *s,

  2026.                                     PutBitContext *pb, const float *in,

  2027.                                     const float *scaled, int size, int scale_idx,

  2028.                                     int cb, const float lambda, const float uplim,

  2029.                                     int *bits)

  2030. {

  2031.     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];

  2032.     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

  2033.     const float CLIPPED_ESCAPE = 165140.0f * IQ;

  2034.     int i;

  2035.     float cost = 0;

  2036.     int qc1, qc2, qc3, qc4;

  2037.     int curbits = 0;

  2038. 

  2039.     uint8_t *p_bits  = (uint8_t*)ff_aac_spectral_bits[cb-1];

  2040.     float   *p_codes = (float*  )ff_aac_codebook_vectors[cb-1];

  2041. 

  2042.     for (i = 0; i < size; i += 4) {

  2043.         const float *vec, *vec2;

  2044.         int curidx, curidx2;

  2045.         float t1, t2, t3, t4;

  2046.         float di1, di2, di3, di4;

  2047.         int cond0, cond1, cond2, cond3;

  2048.         int c1, c2, c3, c4;

  2049.         int t6, t7;

  2050. 

  2051.         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;

  2052.         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;

  2053.         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;

  2054.         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;

  2055. 

  2056.         __asm__ volatile (

  2057.             ".set push                                  \n\t"

  2058.             ".set noreorder                             \n\t"

  2059. 

  2060.             "ori        %[t6],      $zero,  15          \n\t"

  2061.             "ori        %[t7],      $zero,  16          \n\t"

  2062.             "shll_s.w   %[c1],      %[qc1], 18          \n\t"

  2063.             "shll_s.w   %[c2],      %[qc2], 18          \n\t"

  2064.             "shll_s.w   %[c3],      %[qc3], 18          \n\t"

  2065.             "shll_s.w   %[c4],      %[qc4], 18          \n\t"

  2066.             "srl        %[c1],      %[c1],  18          \n\t"

  2067.             "srl        %[c2],      %[c2],  18          \n\t"

  2068.             "srl        %[c3],      %[c3],  18          \n\t"

  2069.             "srl        %[c4],      %[c4],  18          \n\t"

  2070.             "slt        %[cond0],   %[t6],  %[qc1]      \n\t"

  2071.             "slt        %[cond1],   %[t6],  %[qc2]      \n\t"

  2072.             "slt        %[cond2],   %[t6],  %[qc3]      \n\t"

  2073.             "slt        %[cond3],   %[t6],  %[qc4]      \n\t"

  2074.             "movn       %[qc1],     %[t7],  %[cond0]    \n\t"

  2075.             "movn       %[qc2],     %[t7],  %[cond1]    \n\t"

  2076.             "movn       %[qc3],     %[t7],  %[cond2]    \n\t"

  2077.             "movn       %[qc4],     %[t7],  %[cond3]    \n\t"

  2078. 

  2079.             ".set pop                                   \n\t"

  2080. 

  2081.             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),

  2082.               [qc3]"+r"(qc3), [qc4]"+r"(qc4),

  2083.               [cond0]"=&r"(cond0), [cond1]"=&r"(cond1),

  2084.               [cond2]"=&r"(cond2), [cond3]"=&r"(cond3),

  2085.               [c1]"=&r"(c1), [c2]"=&r"(c2),

  2086.               [c3]"=&r"(c3), [c4]"=&r"(c4),

  2087.               [t6]"=&r"(t6), [t7]"=&r"(t7)

  2088.         );

  2089. 

  2090.         curidx = 17 * qc1;

  2091.         curidx += qc2;

  2092. 

  2093.         curidx2 = 17 * qc3;

  2094.         curidx2 += qc4;

  2095. 

  2096.         curbits += p_bits[curidx];

  2097.         curbits += esc_sign_bits[curidx];

  2098.         vec     = &p_codes[curidx*2];

  2099. 

  2100.         curbits += p_bits[curidx2];

  2101.         curbits += esc_sign_bits[curidx2];

  2102.         vec2     = &p_codes[curidx2*2];

  2103. 

  2104.         curbits += (av_log2(c1) * 2 - 3) & (-cond0);

  2105.         curbits += (av_log2(c2) * 2 - 3) & (-cond1);

  2106.         curbits += (av_log2(c3) * 2 - 3) & (-cond2);

  2107.         curbits += (av_log2(c4) * 2 - 3) & (-cond3);

  2108. 

  2109.         t1 = fabsf(in[i  ]);

  2110.         t2 = fabsf(in[i+1]);

  2111.         t3 = fabsf(in[i+2]);

  2112.         t4 = fabsf(in[i+3]);

  2113. 

  2114.         if (cond0) {

  2115.             if (t1 >= CLIPPED_ESCAPE) {

  2116.                 di1 = t1 - CLIPPED_ESCAPE;

  2117.             } else {

  2118.                 di1 = t1 - c1 * cbrtf(c1) * IQ;

  2119.             }

  2120.         } else

  2121.             di1 = t1 - vec[0] * IQ;

  2122. 

  2123.         if (cond1) {

  2124.             if (t2 >= CLIPPED_ESCAPE) {

  2125.                 di2 = t2 - CLIPPED_ESCAPE;

  2126.             } else {

  2127.                 di2 = t2 - c2 * cbrtf(c2) * IQ;

  2128.             }

  2129.         } else

  2130.             di2 = t2 - vec[1] * IQ;

  2131. 

  2132.         if (cond2) {

  2133.             if (t3 >= CLIPPED_ESCAPE) {

  2134.                 di3 = t3 - CLIPPED_ESCAPE;

  2135.             } else {

  2136.                 di3 = t3 - c3 * cbrtf(c3) * IQ;

  2137.             }

  2138.         } else

  2139.             di3 = t3 - vec2[0] * IQ;

  2140. 

  2141.         if (cond3) {

  2142.             if (t4 >= CLIPPED_ESCAPE) {

  2143.                 di4 = t4 - CLIPPED_ESCAPE;

  2144.             } else {

  2145.                 di4 = t4 - c4 * cbrtf(c4) * IQ;

  2146.             }

  2147.         } else

  2148.             di4 = t4 - vec2[1]*IQ;

  2149. 

  2150.         cost += di1 * di1 + di2 * di2

  2151.                 + di3 * di3 + di4 * di4;

  2152.     }

  2153. 

  2154.     if (bits)

  2155.         *bits = curbits;

  2156.     return cost * lambda + curbits;

  2157. }

  2158. 

  2159. static float (*const get_band_cost_arr[])(struct AACEncContext *s,

  2160.                                           PutBitContext *pb, const float *in,

  2161.                                           const float *scaled, int size, int scale_idx,

  2162.                                           int cb, const float lambda, const float uplim,

  2163.                                           int *bits) = {

  2164.     get_band_cost_ZERO_mips,

  2165.     get_band_cost_SQUAD_mips,

  2166.     get_band_cost_SQUAD_mips,

  2167.     get_band_cost_UQUAD_mips,

  2168.     get_band_cost_UQUAD_mips,

  2169.     get_band_cost_SPAIR_mips,

  2170.     get_band_cost_SPAIR_mips,

  2171.     get_band_cost_UPAIR7_mips,

  2172.     get_band_cost_UPAIR7_mips,

  2173.     get_band_cost_UPAIR12_mips,

  2174.     get_band_cost_UPAIR12_mips,

  2175.     get_band_cost_ESC_mips,

  2176.     get_band_cost_NONE_mips, /* cb 12 doesn't exist */

  2177.     get_band_cost_ZERO_mips,

  2178.     get_band_cost_ZERO_mips,

  2179.     get_band_cost_ZERO_mips,

  2180. };

  2181. 

  2182. #define get_band_cost(                                  \

  2183.                                 s, pb, in, scaled, size, scale_idx, cb, \

  2184.                                 lambda, uplim, bits)                    \

  2185.     get_band_cost_arr[cb](                              \

  2186.                                 s, pb, in, scaled, size, scale_idx, cb, \

  2187.                                 lambda, uplim, bits)

  2188. 

  2189. static float quantize_band_cost(struct AACEncContext *s, const float *in,

  2190.                                 const float *scaled, int size, int scale_idx,

  2191.                                 int cb, const float lambda, const float uplim,

  2192.                                 int *bits)

  2193. {

  2194.     return get_band_cost(s, NULL, in, scaled, size, scale_idx, cb, lambda, uplim, bits);

  2195. }

  2196. 

  2197. static void search_for_quantizers_twoloop_mips(AVCodecContext *avctx,

  2198.                                                AACEncContext *s,

  2199.                                                SingleChannelElement *sce,

  2200.                                                const float lambda)

  2201. {

  2202.     int start = 0, i, w, w2, g;

  2203.     int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels;

  2204.     float dists[128] = { 0 }, uplims[128];

  2205.     float maxvals[128];

  2206.     int fflag, minscaler;

  2207.     int its  = 0;

  2208.     int allz = 0;

  2209.     float minthr = INFINITY;

  2210. 

  2211.     destbits = FFMIN(destbits, 5800);

  2212.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  2213.         for (g = 0;  g < sce->ics.num_swb; g++) {

  2214.             int nz = 0;

  2215.             float uplim = 0.0f;

  2216.             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  2217.                 FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

  2218.                 uplim += band->threshold;

  2219.                 if (band->energy <= band->threshold || band->threshold == 0.0f) {

  2220.                     sce->zeroes[(w+w2)*16+g] = 1;

  2221.                     continue;

  2222.                 }

  2223.                 nz = 1;

  2224.             }

  2225.             uplims[w*16+g] = uplim *512;

  2226.             sce->zeroes[w*16+g] = !nz;

  2227.             if (nz)

  2228.                 minthr = FFMIN(minthr, uplim);

  2229.             allz |= nz;

  2230.         }

  2231.     }

  2232.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  2233.         for (g = 0;  g < sce->ics.num_swb; g++) {

  2234.             if (sce->zeroes[w*16+g]) {

  2235.                 sce->sf_idx[w*16+g] = SCALE_ONE_POS;

  2236.                 continue;

  2237.             }

  2238.             sce->sf_idx[w*16+g] = SCALE_ONE_POS + FFMIN(log2f(uplims[w*16+g]/minthr)*4,59);

  2239.         }

  2240.     }

  2241. 

  2242.     if (!allz)

  2243.         return;

  2244.     abs_pow34_v(s->scoefs, sce->coeffs, 1024);

  2245. 

  2246.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  2247.         start = w*128;

  2248.         for (g = 0;  g < sce->ics.num_swb; g++) {

  2249.             const float *scaled = s->scoefs + start;

  2250.             maxvals[w*16+g] = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], scaled);

  2251.             start += sce->ics.swb_sizes[g];

  2252.         }

  2253.     }

  2254. 

  2255.     do {

  2256.         int tbits, qstep;

  2257.         minscaler = sce->sf_idx[0];

  2258.         qstep = its ? 1 : 32;

  2259.         do {

  2260.             int prev = -1;

  2261.             tbits = 0;

  2262.             fflag = 0;

  2263. 

  2264.             if (qstep > 1) {

  2265.                 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  2266.                     start = w*128;

  2267.                     for (g = 0;  g < sce->ics.num_swb; g++) {

  2268.                         const float *coefs = sce->coeffs + start;

  2269.                         const float *scaled = s->scoefs + start;

  2270.                         int bits = 0;

  2271.                         int cb;

  2272. 

  2273.                         if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) {

  2274.                             start += sce->ics.swb_sizes[g];

  2275.                             continue;

  2276.                         }

  2277.                         minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);

  2278.                         cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);

  2279.                         for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  2280.                             int b;

  2281.                             bits += quantize_band_cost_bits(s, coefs + w2*128,

  2282.                                                             scaled + w2*128,

  2283.                                                             sce->ics.swb_sizes[g],

  2284.                                                             sce->sf_idx[w*16+g],

  2285.                                                             cb,

  2286.                                                             1.0f,

  2287.                                                             INFINITY,

  2288.                                                             &b);

  2289.                         }

  2290.                         if (prev != -1) {

  2291.                             bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];

  2292.                         }

  2293.                         tbits += bits;

  2294.                         start += sce->ics.swb_sizes[g];

  2295.                         prev = sce->sf_idx[w*16+g];

  2296.                     }

  2297.                 }

  2298.             }

  2299.             else {

  2300.                 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  2301.                     start = w*128;

  2302.                     for (g = 0;  g < sce->ics.num_swb; g++) {

  2303.                         const float *coefs = sce->coeffs + start;

  2304.                         const float *scaled = s->scoefs + start;

  2305.                         int bits = 0;

  2306.                         int cb;

  2307.                         float dist = 0.0f;

  2308. 

  2309.                         if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) {

  2310.                             start += sce->ics.swb_sizes[g];

  2311.                             continue;

  2312.                         }

  2313.                         minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);

  2314.                         cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);

  2315.                         for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  2316.                             int b;

  2317.                             dist += quantize_band_cost(s, coefs + w2*128,

  2318.                                                        scaled + w2*128,

  2319.                                                        sce->ics.swb_sizes[g],

  2320.                                                        sce->sf_idx[w*16+g],

  2321.                                                        cb,

  2322.                                                        1.0f,

  2323.                                                        INFINITY,

  2324.                                                        &b);

  2325.                             bits += b;

  2326.                         }

  2327.                         dists[w*16+g] = dist - bits;

  2328.                         if (prev != -1) {

  2329.                             bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];

  2330.                         }

  2331.                         tbits += bits;

  2332.                         start += sce->ics.swb_sizes[g];

  2333.                         prev = sce->sf_idx[w*16+g];

  2334.                     }

  2335.                 }

  2336.             }

  2337.             if (tbits > destbits) {

  2338.                 for (i = 0; i < 128; i++)

  2339.                     if (sce->sf_idx[i] < 218 - qstep)

  2340.                         sce->sf_idx[i] += qstep;

  2341.             } else {

  2342.                 for (i = 0; i < 128; i++)

  2343.                     if (sce->sf_idx[i] > 60 - qstep)

  2344.                         sce->sf_idx[i] -= qstep;

  2345.             }

  2346.             qstep >>= 1;

  2347.             if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217)

  2348.                 qstep = 1;

  2349.         } while (qstep);

  2350. 

  2351.         fflag = 0;

  2352.         minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);

  2353.         for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  2354.             for (g = 0; g < sce->ics.num_swb; g++) {

  2355.                 int prevsc = sce->sf_idx[w*16+g];

  2356.                 if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) {

  2357.                     if (find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]-1))

  2358.                         sce->sf_idx[w*16+g]--;

  2359.                     else

  2360.                         sce->sf_idx[w*16+g]-=2;

  2361.                 }

  2362.                 sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);

  2363.                 sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219);

  2364.                 if (sce->sf_idx[w*16+g] != prevsc)

  2365.                     fflag = 1;

  2366.                 sce->band_type[w*16+g] = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);

  2367.             }

  2368.         }

  2369.         its++;

  2370.     } while (fflag && its < 10);

  2371. }

  2372. 

  2373. static void search_for_ms_mips(AACEncContext *s, ChannelElement *cpe)

  2374. {

  2375.     int start = 0, i, w, w2, g;

  2376.     float M[128], S[128];

  2377.     float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;

  2378.     SingleChannelElement *sce0 = &cpe->ch[0];

  2379.     SingleChannelElement *sce1 = &cpe->ch[1];

  2380.     if (!cpe->common_window)

  2381.         return;

  2382.     for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {

  2383.         for (g = 0;  g < sce0->ics.num_swb; g++) {

  2384.             if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {

  2385.                 float dist1 = 0.0f, dist2 = 0.0f;

  2386.                 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {

  2387.                     FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];

  2388.                     FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];

  2389.                     float minthr = FFMIN(band0->threshold, band1->threshold);

  2390.                     float maxthr = FFMAX(band0->threshold, band1->threshold);

  2391.                     for (i = 0; i < sce0->ics.swb_sizes[g]; i+=4) {

  2392.                         M[i  ] = (sce0->coeffs[start+w2*128+i  ]

  2393.                                 + sce1->coeffs[start+w2*128+i  ]) * 0.5;

  2394.                         M[i+1] = (sce0->coeffs[start+w2*128+i+1]

  2395.                                 + sce1->coeffs[start+w2*128+i+1]) * 0.5;

  2396.                         M[i+2] = (sce0->coeffs[start+w2*128+i+2]

  2397.                                 + sce1->coeffs[start+w2*128+i+2]) * 0.5;

  2398.                         M[i+3] = (sce0->coeffs[start+w2*128+i+3]

  2399.                                 + sce1->coeffs[start+w2*128+i+3]) * 0.5;

  2400. 

  2401.                         S[i  ] =  M[i  ]

  2402.                                 - sce1->coeffs[start+w2*128+i  ];

  2403.                         S[i+1] =  M[i+1]

  2404.                                 - sce1->coeffs[start+w2*128+i+1];

  2405.                         S[i+2] =  M[i+2]

  2406.                                 - sce1->coeffs[start+w2*128+i+2];

  2407.                         S[i+3] =  M[i+3]

  2408.                                 - sce1->coeffs[start+w2*128+i+3];

  2409.                    }

  2410.                     abs_pow34_v(L34, sce0->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);

  2411.                     abs_pow34_v(R34, sce1->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);

  2412.                     abs_pow34_v(M34, M,                         sce0->ics.swb_sizes[g]);

  2413.                     abs_pow34_v(S34, S,                         sce0->ics.swb_sizes[g]);

  2414.                     dist1 += quantize_band_cost(s, sce0->coeffs + start + w2*128,

  2415.                                                 L34,

  2416.                                                 sce0->ics.swb_sizes[g],

  2417.                                                 sce0->sf_idx[(w+w2)*16+g],

  2418.                                                 sce0->band_type[(w+w2)*16+g],

  2419.                                                 s->lambda / band0->threshold, INFINITY, NULL);

  2420.                     dist1 += quantize_band_cost(s, sce1->coeffs + start + w2*128,

  2421.                                                 R34,

  2422.                                                 sce1->ics.swb_sizes[g],

  2423.                                                 sce1->sf_idx[(w+w2)*16+g],

  2424.                                                 sce1->band_type[(w+w2)*16+g],

  2425.                                                 s->lambda / band1->threshold, INFINITY, NULL);

  2426.                     dist2 += quantize_band_cost(s, M,

  2427.                                                 M34,

  2428.                                                 sce0->ics.swb_sizes[g],

  2429.                                                 sce0->sf_idx[(w+w2)*16+g],

  2430.                                                 sce0->band_type[(w+w2)*16+g],

  2431.                                                 s->lambda / maxthr, INFINITY, NULL);

  2432.                     dist2 += quantize_band_cost(s, S,

  2433.                                                 S34,

  2434.                                                 sce1->ics.swb_sizes[g],

  2435.                                                 sce1->sf_idx[(w+w2)*16+g],

  2436.                                                 sce1->band_type[(w+w2)*16+g],

  2437.                                                 s->lambda / minthr, INFINITY, NULL);

  2438.                 }

  2439.                 cpe->ms_mask[w*16+g] = dist2 < dist1;

  2440.             }

  2441.             start += sce0->ics.swb_sizes[g];

  2442.         }

  2443.     }

  2444. }

  2445. #endif /*HAVE_MIPSFPU */

  2446. 

  2447. static void codebook_trellis_rate_mips(AACEncContext *s, SingleChannelElement *sce,

  2448.                                        int win, int group_len, const float lambda)

  2449. {

  2450.     BandCodingPath path[120][12];

  2451.     int w, swb, cb, start, size;

  2452.     int i, j;

  2453.     const int max_sfb  = sce->ics.max_sfb;

  2454.     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;

  2455.     const int run_esc  = (1 << run_bits) - 1;

  2456.     int idx, ppos, count;

  2457.     int stackrun[120], stackcb[120], stack_len;

  2458.     float next_minbits = INFINITY;

  2459.     int next_mincb = 0;

  2460. 

  2461.     abs_pow34_v(s->scoefs, sce->coeffs, 1024);

  2462.     start = win*128;

  2463.     for (cb = 0; cb < 12; cb++) {

  2464.         path[0][cb].cost     = run_bits+4;

  2465.         path[0][cb].prev_idx = -1;

  2466.         path[0][cb].run      = 0;

  2467.     }

  2468.     for (swb = 0; swb < max_sfb; swb++) {

  2469.         size = sce->ics.swb_sizes[swb];

  2470.         if (sce->zeroes[win*16 + swb]) {

  2471.             float cost_stay_here = path[swb][0].cost;

  2472.             float cost_get_here  = next_minbits + run_bits + 4;

  2473.             if (   run_value_bits[sce->ics.num_windows == 8][path[swb][0].run]

  2474.                 != run_value_bits[sce->ics.num_windows == 8][path[swb][0].run+1])

  2475.                 cost_stay_here += run_bits;

  2476.             if (cost_get_here < cost_stay_here) {

  2477.                 path[swb+1][0].prev_idx = next_mincb;

  2478.                 path[swb+1][0].cost     = cost_get_here;

  2479.                 path[swb+1][0].run      = 1;

  2480.             } else {

  2481.                 path[swb+1][0].prev_idx = 0;

  2482.                 path[swb+1][0].cost     = cost_stay_here;

  2483.                 path[swb+1][0].run      = path[swb][0].run + 1;

  2484.             }

  2485.             next_minbits = path[swb+1][0].cost;

  2486.             next_mincb = 0;

  2487.             for (cb = 1; cb < 12; cb++) {

  2488.                 path[swb+1][cb].cost = 61450;

  2489.                 path[swb+1][cb].prev_idx = -1;

  2490.                 path[swb+1][cb].run = 0;

  2491.             }

  2492.         } else {

  2493.             float minbits = next_minbits;

  2494.             int mincb = next_mincb;

  2495.             int startcb = sce->band_type[win*16+swb];

  2496.             next_minbits = INFINITY;

  2497.             next_mincb = 0;

  2498.             for (cb = 0; cb < startcb; cb++) {

  2499.                 path[swb+1][cb].cost = 61450;

  2500.                 path[swb+1][cb].prev_idx = -1;

  2501.                 path[swb+1][cb].run = 0;

  2502.             }

  2503.             for (cb = startcb; cb < 12; cb++) {

  2504.                 float cost_stay_here, cost_get_here;

  2505.                 float bits = 0.0f;

  2506.                 for (w = 0; w < group_len; w++) {

  2507.                     bits += quantize_band_cost_bits(s, sce->coeffs + start + w*128,

  2508.                                                     s->scoefs + start + w*128, size,

  2509.                                                     sce->sf_idx[(win+w)*16+swb], cb,

  2510.                                                     0, INFINITY, NULL);

  2511.                 }

  2512.                 cost_stay_here = path[swb][cb].cost + bits;

  2513.                 cost_get_here  = minbits            + bits + run_bits + 4;

  2514.                 if (   run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]

  2515.                     != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])

  2516.                     cost_stay_here += run_bits;

  2517.                 if (cost_get_here < cost_stay_here) {

  2518.                     path[swb+1][cb].prev_idx = mincb;

  2519.                     path[swb+1][cb].cost     = cost_get_here;

  2520.                     path[swb+1][cb].run      = 1;

  2521.                 } else {

  2522.                     path[swb+1][cb].prev_idx = cb;

  2523.                     path[swb+1][cb].cost     = cost_stay_here;

  2524.                     path[swb+1][cb].run      = path[swb][cb].run + 1;

  2525.                 }

  2526.                 if (path[swb+1][cb].cost < next_minbits) {

  2527.                     next_minbits = path[swb+1][cb].cost;

  2528.                     next_mincb = cb;

  2529.                 }

  2530.             }

  2531.         }

  2532.         start += sce->ics.swb_sizes[swb];

  2533.     }

  2534. 

  2535.     stack_len = 0;

  2536.     idx       = 0;

  2537.     for (cb = 1; cb < 12; cb++)

  2538.         if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)

  2539.             idx = cb;

  2540.     ppos = max_sfb;

  2541.     while (ppos > 0) {

  2542.         av_assert1(idx >= 0);

  2543.         cb = idx;

  2544.         stackrun[stack_len] = path[ppos][cb].run;

  2545.         stackcb [stack_len] = cb;

  2546.         idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;

  2547.         ppos -= path[ppos][cb].run;

  2548.         stack_len++;

  2549.     }

  2550. 

  2551.     start = 0;

  2552.     for (i = stack_len - 1; i >= 0; i--) {

  2553.         put_bits(&s->pb, 4, stackcb[i]);

  2554.         count = stackrun[i];

  2555.         memset(sce->zeroes + win*16 + start, !stackcb[i], count);

  2556.         for (j = 0; j < count; j++) {

  2557.             sce->band_type[win*16 + start] =  stackcb[i];

  2558.             start++;

  2559.         }

  2560.         while (count >= run_esc) {

  2561.             put_bits(&s->pb, run_bits, run_esc);

  2562.             count -= run_esc;

  2563.         }

  2564.         put_bits(&s->pb, run_bits, count);

  2565.     }

  2566. }

  2567. #endif /* HAVE_INLINE_ASM */

  2568. 

  2569. void ff_aac_coder_init_mips(AACEncContext *c) {

  2570. #if HAVE_INLINE_ASM

  2571.     AACCoefficientsEncoder *e = c->coder;

  2572.     int option = c->options.aac_coder;

  2573. 

  2574.     if (option == 2) {

  2575. // Disabled due to failure with fate-aac-pns-encode

  2576. //         e->quantize_and_encode_band = quantize_and_encode_band_mips;

  2577. //         e->encode_window_bands_info = codebook_trellis_rate_mips;

  2578. #if HAVE_MIPSFPU

  2579.         e->search_for_quantizers    = search_for_quantizers_twoloop_mips;

  2580.         e->search_for_ms            = search_for_ms_mips;

  2581. #endif /* HAVE_MIPSFPU */

  2582.     }

  2583. #endif /* HAVE_INLINE_ASM */

  2584. }