e85bf8c5cad18fbb38a3150db7f62144c4af45c2
[ffmpeg.git] / libavcodec / mips / aaccoder_mips.c
1 /*
2  * Copyright (c) 2012
3  *      MIPS Technologies, Inc., California.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
14  *    contributors may be used to endorse or promote products derived from
15  *    this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * Author:  Stanislav Ocovaj (socovaj@mips.com)
30  *          Szabolcs Pal     (sabolc@mips.com)
31  *
32  * AAC coefficients encoder optimized for MIPS floating-point architecture
33  *
34  * This file is part of FFmpeg.
35  *
36  * FFmpeg is free software; you can redistribute it and/or
37  * modify it under the terms of the GNU Lesser General Public
38  * License as published by the Free Software Foundation; either
39  * version 2.1 of the License, or (at your option) any later version.
40  *
41  * FFmpeg is distributed in the hope that it will be useful,
42  * but WITHOUT ANY WARRANTY; without even the implied warranty of
43  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
44  * Lesser General Public License for more details.
45  *
46  * You should have received a copy of the GNU Lesser General Public
47  * License along with FFmpeg; if not, write to the Free Software
48  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
49  */
50
51 /**
52  * @file
53  * Reference: libavcodec/aaccoder.c
54  */
55
56 #include "libavutil/libm.h"
57
58 #include <float.h>
59 #include "libavutil/mathematics.h"
60 #include "libavcodec/avcodec.h"
61 #include "libavcodec/put_bits.h"
62 #include "libavcodec/aac.h"
63 #include "libavcodec/aacenc.h"
64 #include "libavcodec/aactab.h"
65 #include "libavcodec/aacenctab.h"
66
67 #if HAVE_INLINE_ASM
68 typedef struct BandCodingPath {
69     int prev_idx;
70     float cost;
71     int run;
72 } BandCodingPath;
73
74 static const uint8_t uquad_sign_bits[81] = {
75     0, 1, 1, 1, 2, 2, 1, 2, 2,
76     1, 2, 2, 2, 3, 3, 2, 3, 3,
77     1, 2, 2, 2, 3, 3, 2, 3, 3,
78     1, 2, 2, 2, 3, 3, 2, 3, 3,
79     2, 3, 3, 3, 4, 4, 3, 4, 4,
80     2, 3, 3, 3, 4, 4, 3, 4, 4,
81     1, 2, 2, 2, 3, 3, 2, 3, 3,
82     2, 3, 3, 3, 4, 4, 3, 4, 4,
83     2, 3, 3, 3, 4, 4, 3, 4, 4
84 };
85
86 static const uint8_t upair7_sign_bits[64] = {
87     0, 1, 1, 1, 1, 1, 1, 1,
88     1, 2, 2, 2, 2, 2, 2, 2,
89     1, 2, 2, 2, 2, 2, 2, 2,
90     1, 2, 2, 2, 2, 2, 2, 2,
91     1, 2, 2, 2, 2, 2, 2, 2,
92     1, 2, 2, 2, 2, 2, 2, 2,
93     1, 2, 2, 2, 2, 2, 2, 2,
94     1, 2, 2, 2, 2, 2, 2, 2,
95 };
96
97 static const uint8_t upair12_sign_bits[169] = {
98     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
99     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
105     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
109     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
110     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
111 };
112
113 static const uint8_t esc_sign_bits[289] = {
114     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
116     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
117     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
118     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
119     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
120     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
121     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
122     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
123     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
124     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
125     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
126     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
127     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
128     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
129     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
130     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
131 };
132
133 #define ROUND_STANDARD 0.4054f
134 #define ROUND_TO_ZERO 0.1054f
135
136 static void abs_pow34_v(float *out, const float *in, const int size) {
137 #ifndef USE_REALLY_FULL_SEARCH
138     int i;
139     float a, b, c, d;
140     float ax, bx, cx, dx;
141
142     for (i = 0; i < size; i += 4) {
143         a = fabsf(in[i  ]);
144         b = fabsf(in[i+1]);
145         c = fabsf(in[i+2]);
146         d = fabsf(in[i+3]);
147
148         ax = sqrtf(a);
149         bx = sqrtf(b);
150         cx = sqrtf(c);
151         dx = sqrtf(d);
152
153         a = a * ax;
154         b = b * bx;
155         c = c * cx;
156         d = d * dx;
157
158         out[i  ] = sqrtf(a);
159         out[i+1] = sqrtf(b);
160         out[i+2] = sqrtf(c);
161         out[i+3] = sqrtf(d);
162     }
163 #endif /* USE_REALLY_FULL_SEARCH */
164 }
165
166 static float find_max_val(int group_len, int swb_size, const float *scaled) {
167     float maxval = 0.0f;
168     int w2, i;
169     for (w2 = 0; w2 < group_len; w2++) {
170         for (i = 0; i < swb_size; i++) {
171             maxval = FFMAX(maxval, scaled[w2*128+i]);
172         }
173     }
174     return maxval;
175 }
176
177 static int find_min_book(float maxval, int sf) {
178     float Q = ff_aac_pow2sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512];
179     float Q34 = sqrtf(Q * sqrtf(Q));
180     int qmaxval, cb;
181     qmaxval = maxval * Q34 + 0.4054f;
182     if (qmaxval >= (FF_ARRAY_ELEMS(aac_maxval_cb)))
183         cb = 11;
184     else
185         cb = aac_maxval_cb[qmaxval];
186     return cb;
187 }
188
189 /**
190  * Functions developed from template function and optimized for quantizing and encoding band
191  */
192 static void quantize_and_encode_band_cost_SQUAD_mips(struct AACEncContext *s,
193                                                      PutBitContext *pb, const float *in, float *out,
194                                                      const float *scaled, int size, int scale_idx,
195                                                      int cb, const float lambda, const float uplim,
196                                                      int *bits, float *energy, const float ROUNDING)
197 {
198     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
199     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
200     int i;
201     int qc1, qc2, qc3, qc4;
202     float qenergy = 0.0f;
203
204     uint8_t  *p_bits  = (uint8_t  *)ff_aac_spectral_bits[cb-1];
205     uint16_t *p_codes = (uint16_t *)ff_aac_spectral_codes[cb-1];
206     float    *p_vec   = (float    *)ff_aac_codebook_vectors[cb-1];
207
208     abs_pow34_v(s->scoefs, in, size);
209     scaled = s->scoefs;
210     for (i = 0; i < size; i += 4) {
211         int curidx;
212         int *in_int = (int *)&in[i];
213         int t0, t1, t2, t3, t4, t5, t6, t7;
214         const float *vec;
215
216         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
217         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
218         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
219         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
220
221         __asm__ volatile (
222             ".set push                      \n\t"
223             ".set noreorder                 \n\t"
224
225             "slt    %[qc1], $zero,  %[qc1]  \n\t"
226             "slt    %[qc2], $zero,  %[qc2]  \n\t"
227             "slt    %[qc3], $zero,  %[qc3]  \n\t"
228             "slt    %[qc4], $zero,  %[qc4]  \n\t"
229             "lw     %[t0],  0(%[in_int])    \n\t"
230             "lw     %[t1],  4(%[in_int])    \n\t"
231             "lw     %[t2],  8(%[in_int])    \n\t"
232             "lw     %[t3],  12(%[in_int])   \n\t"
233             "srl    %[t0],  %[t0],  31      \n\t"
234             "srl    %[t1],  %[t1],  31      \n\t"
235             "srl    %[t2],  %[t2],  31      \n\t"
236             "srl    %[t3],  %[t3],  31      \n\t"
237             "subu   %[t4],  $zero,  %[qc1]  \n\t"
238             "subu   %[t5],  $zero,  %[qc2]  \n\t"
239             "subu   %[t6],  $zero,  %[qc3]  \n\t"
240             "subu   %[t7],  $zero,  %[qc4]  \n\t"
241             "movn   %[qc1], %[t4],  %[t0]   \n\t"
242             "movn   %[qc2], %[t5],  %[t1]   \n\t"
243             "movn   %[qc3], %[t6],  %[t2]   \n\t"
244             "movn   %[qc4], %[t7],  %[t3]   \n\t"
245
246             ".set pop                       \n\t"
247
248             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
249               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
250               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
251               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)
252             : [in_int]"r"(in_int)
253             : "memory"
254         );
255
256         curidx = qc1;
257         curidx *= 3;
258         curidx += qc2;
259         curidx *= 3;
260         curidx += qc3;
261         curidx *= 3;
262         curidx += qc4;
263         curidx += 40;
264
265         put_bits(pb, p_bits[curidx], p_codes[curidx]);
266
267         if (out || energy) {
268             float e1,e2,e3,e4;
269             vec = &p_vec[curidx*4];
270             e1 = vec[0] * IQ;
271             e2 = vec[1] * IQ;
272             e3 = vec[2] * IQ;
273             e4 = vec[3] * IQ;
274             if (out) {
275                 out[i+0] = e1;
276                 out[i+1] = e2;
277                 out[i+2] = e3;
278                 out[i+3] = e4;
279             }
280             if (energy)
281                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);
282         }
283     }
284     if (energy)
285         *energy = qenergy;
286 }
287
288 static void quantize_and_encode_band_cost_UQUAD_mips(struct AACEncContext *s,
289                                                      PutBitContext *pb, const float *in, float *out,
290                                                      const float *scaled, int size, int scale_idx,
291                                                      int cb, const float lambda, const float uplim,
292                                                      int *bits, float *energy, const float ROUNDING)
293 {
294     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
295     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
296     int i;
297     int qc1, qc2, qc3, qc4;
298     float qenergy = 0.0f;
299
300     uint8_t  *p_bits  = (uint8_t  *)ff_aac_spectral_bits[cb-1];
301     uint16_t *p_codes = (uint16_t *)ff_aac_spectral_codes[cb-1];
302     float    *p_vec   = (float    *)ff_aac_codebook_vectors[cb-1];
303
304     abs_pow34_v(s->scoefs, in, size);
305     scaled = s->scoefs;
306     for (i = 0; i < size; i += 4) {
307         int curidx, sign, count;
308         int *in_int = (int *)&in[i];
309         uint8_t v_bits;
310         unsigned int v_codes;
311         int t0, t1, t2, t3, t4;
312         const float *vec;
313
314         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
315         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
316         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
317         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
318
319         __asm__ volatile (
320             ".set push                              \n\t"
321             ".set noreorder                         \n\t"
322
323             "ori    %[t4],      $zero,      2       \n\t"
324             "ori    %[sign],    $zero,      0       \n\t"
325             "slt    %[t0],      %[t4],      %[qc1]  \n\t"
326             "slt    %[t1],      %[t4],      %[qc2]  \n\t"
327             "slt    %[t2],      %[t4],      %[qc3]  \n\t"
328             "slt    %[t3],      %[t4],      %[qc4]  \n\t"
329             "movn   %[qc1],     %[t4],      %[t0]   \n\t"
330             "movn   %[qc2],     %[t4],      %[t1]   \n\t"
331             "movn   %[qc3],     %[t4],      %[t2]   \n\t"
332             "movn   %[qc4],     %[t4],      %[t3]   \n\t"
333             "lw     %[t0],      0(%[in_int])        \n\t"
334             "lw     %[t1],      4(%[in_int])        \n\t"
335             "lw     %[t2],      8(%[in_int])        \n\t"
336             "lw     %[t3],      12(%[in_int])       \n\t"
337             "slt    %[t0],      %[t0],      $zero   \n\t"
338             "movn   %[sign],    %[t0],      %[qc1]  \n\t"
339             "slt    %[t1],      %[t1],      $zero   \n\t"
340             "slt    %[t2],      %[t2],      $zero   \n\t"
341             "slt    %[t3],      %[t3],      $zero   \n\t"
342             "sll    %[t0],      %[sign],    1       \n\t"
343             "or     %[t0],      %[t0],      %[t1]   \n\t"
344             "movn   %[sign],    %[t0],      %[qc2]  \n\t"
345             "slt    %[t4],      $zero,      %[qc1]  \n\t"
346             "slt    %[t1],      $zero,      %[qc2]  \n\t"
347             "slt    %[count],   $zero,      %[qc3]  \n\t"
348             "sll    %[t0],      %[sign],    1       \n\t"
349             "or     %[t0],      %[t0],      %[t2]   \n\t"
350             "movn   %[sign],    %[t0],      %[qc3]  \n\t"
351             "slt    %[t2],      $zero,      %[qc4]  \n\t"
352             "addu   %[count],   %[count],   %[t4]   \n\t"
353             "addu   %[count],   %[count],   %[t1]   \n\t"
354             "sll    %[t0],      %[sign],    1       \n\t"
355             "or     %[t0],      %[t0],      %[t3]   \n\t"
356             "movn   %[sign],    %[t0],      %[qc4]  \n\t"
357             "addu   %[count],   %[count],   %[t2]   \n\t"
358
359             ".set pop                               \n\t"
360
361             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
362               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
363               [sign]"=&r"(sign), [count]"=&r"(count),
364               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
365               [t4]"=&r"(t4)
366             : [in_int]"r"(in_int)
367             : "memory"
368         );
369
370         curidx = qc1;
371         curidx *= 3;
372         curidx += qc2;
373         curidx *= 3;
374         curidx += qc3;
375         curidx *= 3;
376         curidx += qc4;
377
378         v_codes = (p_codes[curidx] << count) | (sign & ((1 << count) - 1));
379         v_bits  = p_bits[curidx] + count;
380         put_bits(pb, v_bits, v_codes);
381
382         if (out || energy) {
383             float e1,e2,e3,e4;
384             vec = &p_vec[curidx*4];
385             e1 = copysignf(vec[0] * IQ, in[i+0]);
386             e2 = copysignf(vec[1] * IQ, in[i+1]);
387             e3 = copysignf(vec[2] * IQ, in[i+2]);
388             e4 = copysignf(vec[3] * IQ, in[i+3]);
389             if (out) {
390                 out[i+0] = e1;
391                 out[i+1] = e2;
392                 out[i+2] = e3;
393                 out[i+3] = e4;
394             }
395             if (energy)
396                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);
397         }
398     }
399     if (energy)
400         *energy = qenergy;
401 }
402
403 static void quantize_and_encode_band_cost_SPAIR_mips(struct AACEncContext *s,
404                                                      PutBitContext *pb, const float *in, float *out,
405                                                      const float *scaled, int size, int scale_idx,
406                                                      int cb, const float lambda, const float uplim,
407                                                      int *bits, float *energy, const float ROUNDING)
408 {
409     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
410     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
411     int i;
412     int qc1, qc2, qc3, qc4;
413     float qenergy = 0.0f;
414
415     uint8_t  *p_bits  = (uint8_t  *)ff_aac_spectral_bits[cb-1];
416     uint16_t *p_codes = (uint16_t *)ff_aac_spectral_codes[cb-1];
417     float    *p_vec   = (float    *)ff_aac_codebook_vectors[cb-1];
418
419     abs_pow34_v(s->scoefs, in, size);
420     scaled = s->scoefs;
421     for (i = 0; i < size; i += 4) {
422         int curidx, curidx2;
423         int *in_int = (int *)&in[i];
424         uint8_t v_bits;
425         unsigned int v_codes;
426         int t0, t1, t2, t3, t4, t5, t6, t7;
427         const float *vec1, *vec2;
428
429         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
430         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
431         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
432         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
433
434         __asm__ volatile (
435             ".set push                      \n\t"
436             ".set noreorder                 \n\t"
437
438             "ori    %[t4],  $zero,  4       \n\t"
439             "slt    %[t0],  %[t4],  %[qc1]  \n\t"
440             "slt    %[t1],  %[t4],  %[qc2]  \n\t"
441             "slt    %[t2],  %[t4],  %[qc3]  \n\t"
442             "slt    %[t3],  %[t4],  %[qc4]  \n\t"
443             "movn   %[qc1], %[t4],  %[t0]   \n\t"
444             "movn   %[qc2], %[t4],  %[t1]   \n\t"
445             "movn   %[qc3], %[t4],  %[t2]   \n\t"
446             "movn   %[qc4], %[t4],  %[t3]   \n\t"
447             "lw     %[t0],  0(%[in_int])    \n\t"
448             "lw     %[t1],  4(%[in_int])    \n\t"
449             "lw     %[t2],  8(%[in_int])    \n\t"
450             "lw     %[t3],  12(%[in_int])   \n\t"
451             "srl    %[t0],  %[t0],  31      \n\t"
452             "srl    %[t1],  %[t1],  31      \n\t"
453             "srl    %[t2],  %[t2],  31      \n\t"
454             "srl    %[t3],  %[t3],  31      \n\t"
455             "subu   %[t4],  $zero,  %[qc1]  \n\t"
456             "subu   %[t5],  $zero,  %[qc2]  \n\t"
457             "subu   %[t6],  $zero,  %[qc3]  \n\t"
458             "subu   %[t7],  $zero,  %[qc4]  \n\t"
459             "movn   %[qc1], %[t4],  %[t0]   \n\t"
460             "movn   %[qc2], %[t5],  %[t1]   \n\t"
461             "movn   %[qc3], %[t6],  %[t2]   \n\t"
462             "movn   %[qc4], %[t7],  %[t3]   \n\t"
463
464             ".set pop                       \n\t"
465
466             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
467               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
468               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
469               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)
470             : [in_int]"r"(in_int)
471             : "memory"
472         );
473
474         curidx = 9 * qc1;
475         curidx += qc2 + 40;
476
477         curidx2 = 9 * qc3;
478         curidx2 += qc4 + 40;
479
480         v_codes = (p_codes[curidx] << p_bits[curidx2]) | (p_codes[curidx2]);
481         v_bits  = p_bits[curidx] + p_bits[curidx2];
482         put_bits(pb, v_bits, v_codes);
483
484         if (out || energy) {
485             float e1,e2,e3,e4;
486             vec1 = &p_vec[curidx*2 ];
487             vec2 = &p_vec[curidx2*2];
488             e1 = vec1[0] * IQ;
489             e2 = vec1[1] * IQ;
490             e3 = vec2[0] * IQ;
491             e4 = vec2[1] * IQ;
492             if (out) {
493                 out[i+0] = e1;
494                 out[i+1] = e2;
495                 out[i+2] = e3;
496                 out[i+3] = e4;
497             }
498             if (energy)
499                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);
500         }
501     }
502     if (energy)
503         *energy = qenergy;
504 }
505
506 static void quantize_and_encode_band_cost_UPAIR7_mips(struct AACEncContext *s,
507                                                       PutBitContext *pb, const float *in, float *out,
508                                                       const float *scaled, int size, int scale_idx,
509                                                       int cb, const float lambda, const float uplim,
510                                                       int *bits, float *energy, const float ROUNDING)
511 {
512     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
513     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
514     int i;
515     int qc1, qc2, qc3, qc4;
516     float qenergy = 0.0f;
517
518     uint8_t  *p_bits  = (uint8_t*) ff_aac_spectral_bits[cb-1];
519     uint16_t *p_codes = (uint16_t*)ff_aac_spectral_codes[cb-1];
520     float    *p_vec   = (float    *)ff_aac_codebook_vectors[cb-1];
521
522     abs_pow34_v(s->scoefs, in, size);
523     scaled = s->scoefs;
524     for (i = 0; i < size; i += 4) {
525         int curidx1, curidx2, sign1, count1, sign2, count2;
526         int *in_int = (int *)&in[i];
527         uint8_t v_bits;
528         unsigned int v_codes;
529         int t0, t1, t2, t3, t4;
530         const float *vec1, *vec2;
531
532         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
533         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
534         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
535         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
536
537         __asm__ volatile (
538             ".set push                              \n\t"
539             ".set noreorder                         \n\t"
540
541             "ori    %[t4],      $zero,      7       \n\t"
542             "ori    %[sign1],   $zero,      0       \n\t"
543             "ori    %[sign2],   $zero,      0       \n\t"
544             "slt    %[t0],      %[t4],      %[qc1]  \n\t"
545             "slt    %[t1],      %[t4],      %[qc2]  \n\t"
546             "slt    %[t2],      %[t4],      %[qc3]  \n\t"
547             "slt    %[t3],      %[t4],      %[qc4]  \n\t"
548             "movn   %[qc1],     %[t4],      %[t0]   \n\t"
549             "movn   %[qc2],     %[t4],      %[t1]   \n\t"
550             "movn   %[qc3],     %[t4],      %[t2]   \n\t"
551             "movn   %[qc4],     %[t4],      %[t3]   \n\t"
552             "lw     %[t0],      0(%[in_int])        \n\t"
553             "lw     %[t1],      4(%[in_int])        \n\t"
554             "lw     %[t2],      8(%[in_int])        \n\t"
555             "lw     %[t3],      12(%[in_int])       \n\t"
556             "slt    %[t0],      %[t0],      $zero   \n\t"
557             "movn   %[sign1],   %[t0],      %[qc1]  \n\t"
558             "slt    %[t2],      %[t2],      $zero   \n\t"
559             "movn   %[sign2],   %[t2],      %[qc3]  \n\t"
560             "slt    %[t1],      %[t1],      $zero   \n\t"
561             "sll    %[t0],      %[sign1],   1       \n\t"
562             "or     %[t0],      %[t0],      %[t1]   \n\t"
563             "movn   %[sign1],   %[t0],      %[qc2]  \n\t"
564             "slt    %[t3],      %[t3],      $zero   \n\t"
565             "sll    %[t0],      %[sign2],   1       \n\t"
566             "or     %[t0],      %[t0],      %[t3]   \n\t"
567             "movn   %[sign2],   %[t0],      %[qc4]  \n\t"
568             "slt    %[count1],  $zero,      %[qc1]  \n\t"
569             "slt    %[t1],      $zero,      %[qc2]  \n\t"
570             "slt    %[count2],  $zero,      %[qc3]  \n\t"
571             "slt    %[t2],      $zero,      %[qc4]  \n\t"
572             "addu   %[count1],  %[count1],  %[t1]   \n\t"
573             "addu   %[count2],  %[count2],  %[t2]   \n\t"
574
575             ".set pop                               \n\t"
576
577             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
578               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
579               [sign1]"=&r"(sign1), [count1]"=&r"(count1),
580               [sign2]"=&r"(sign2), [count2]"=&r"(count2),
581               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
582               [t4]"=&r"(t4)
583             : [in_int]"r"(in_int)
584             : "t0", "t1", "t2", "t3", "t4",
585               "memory"
586         );
587
588         curidx1  = 8 * qc1;
589         curidx1 += qc2;
590
591         v_codes = (p_codes[curidx1] << count1) | sign1;
592         v_bits  = p_bits[curidx1] + count1;
593         put_bits(pb, v_bits, v_codes);
594
595         curidx2  = 8 * qc3;
596         curidx2 += qc4;
597
598         v_codes = (p_codes[curidx2] << count2) | sign2;
599         v_bits  = p_bits[curidx2] + count2;
600         put_bits(pb, v_bits, v_codes);
601
602         if (out || energy) {
603             float e1,e2,e3,e4;
604             vec1 = &p_vec[curidx1*2];
605             vec2 = &p_vec[curidx2*2];
606             e1 = copysignf(vec1[0] * IQ, in[i+0]);
607             e2 = copysignf(vec1[1] * IQ, in[i+1]);
608             e3 = copysignf(vec2[0] * IQ, in[i+2]);
609             e4 = copysignf(vec2[1] * IQ, in[i+3]);
610             if (out) {
611                 out[i+0] = e1;
612                 out[i+1] = e2;
613                 out[i+2] = e3;
614                 out[i+3] = e4;
615             }
616             if (energy)
617                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);
618         }
619     }
620     if (energy)
621         *energy = qenergy;
622 }
623
624 static void quantize_and_encode_band_cost_UPAIR12_mips(struct AACEncContext *s,
625                                                        PutBitContext *pb, const float *in, float *out,
626                                                        const float *scaled, int size, int scale_idx,
627                                                        int cb, const float lambda, const float uplim,
628                                                        int *bits, float *energy, const float ROUNDING)
629 {
630     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
631     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
632     int i;
633     int qc1, qc2, qc3, qc4;
634     float qenergy = 0.0f;
635
636     uint8_t  *p_bits  = (uint8_t*) ff_aac_spectral_bits[cb-1];
637     uint16_t *p_codes = (uint16_t*)ff_aac_spectral_codes[cb-1];
638     float    *p_vec   = (float   *)ff_aac_codebook_vectors[cb-1];
639
640     abs_pow34_v(s->scoefs, in, size);
641     scaled = s->scoefs;
642     for (i = 0; i < size; i += 4) {
643         int curidx1, curidx2, sign1, count1, sign2, count2;
644         int *in_int = (int *)&in[i];
645         uint8_t v_bits;
646         unsigned int v_codes;
647         int t0, t1, t2, t3, t4;
648         const float *vec1, *vec2;
649
650         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
651         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
652         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
653         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
654
655         __asm__ volatile (
656             ".set push                              \n\t"
657             ".set noreorder                         \n\t"
658
659             "ori    %[t4],      $zero,      12      \n\t"
660             "ori    %[sign1],   $zero,      0       \n\t"
661             "ori    %[sign2],   $zero,      0       \n\t"
662             "slt    %[t0],      %[t4],      %[qc1]  \n\t"
663             "slt    %[t1],      %[t4],      %[qc2]  \n\t"
664             "slt    %[t2],      %[t4],      %[qc3]  \n\t"
665             "slt    %[t3],      %[t4],      %[qc4]  \n\t"
666             "movn   %[qc1],     %[t4],      %[t0]   \n\t"
667             "movn   %[qc2],     %[t4],      %[t1]   \n\t"
668             "movn   %[qc3],     %[t4],      %[t2]   \n\t"
669             "movn   %[qc4],     %[t4],      %[t3]   \n\t"
670             "lw     %[t0],      0(%[in_int])        \n\t"
671             "lw     %[t1],      4(%[in_int])        \n\t"
672             "lw     %[t2],      8(%[in_int])        \n\t"
673             "lw     %[t3],      12(%[in_int])       \n\t"
674             "slt    %[t0],      %[t0],      $zero   \n\t"
675             "movn   %[sign1],   %[t0],      %[qc1]  \n\t"
676             "slt    %[t2],      %[t2],      $zero   \n\t"
677             "movn   %[sign2],   %[t2],      %[qc3]  \n\t"
678             "slt    %[t1],      %[t1],      $zero   \n\t"
679             "sll    %[t0],      %[sign1],   1       \n\t"
680             "or     %[t0],      %[t0],      %[t1]   \n\t"
681             "movn   %[sign1],   %[t0],      %[qc2]  \n\t"
682             "slt    %[t3],      %[t3],      $zero   \n\t"
683             "sll    %[t0],      %[sign2],   1       \n\t"
684             "or     %[t0],      %[t0],      %[t3]   \n\t"
685             "movn   %[sign2],   %[t0],      %[qc4]  \n\t"
686             "slt    %[count1],  $zero,      %[qc1]  \n\t"
687             "slt    %[t1],      $zero,      %[qc2]  \n\t"
688             "slt    %[count2],  $zero,      %[qc3]  \n\t"
689             "slt    %[t2],      $zero,      %[qc4]  \n\t"
690             "addu   %[count1],  %[count1],  %[t1]   \n\t"
691             "addu   %[count2],  %[count2],  %[t2]   \n\t"
692
693             ".set pop                               \n\t"
694
695             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
696               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
697               [sign1]"=&r"(sign1), [count1]"=&r"(count1),
698               [sign2]"=&r"(sign2), [count2]"=&r"(count2),
699               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
700               [t4]"=&r"(t4)
701             : [in_int]"r"(in_int)
702             : "memory"
703         );
704
705         curidx1  = 13 * qc1;
706         curidx1 += qc2;
707
708         v_codes = (p_codes[curidx1] << count1) | sign1;
709         v_bits  = p_bits[curidx1] + count1;
710         put_bits(pb, v_bits, v_codes);
711
712         curidx2  = 13 * qc3;
713         curidx2 += qc4;
714
715         v_codes = (p_codes[curidx2] << count2) | sign2;
716         v_bits  = p_bits[curidx2] + count2;
717         put_bits(pb, v_bits, v_codes);
718
719         if (out || energy) {
720             float e1,e2,e3,e4;
721             vec1 = &p_vec[curidx1*2];
722             vec2 = &p_vec[curidx2*2];
723             e1 = copysignf(vec1[0] * IQ, in[i+0]);
724             e2 = copysignf(vec1[1] * IQ, in[i+1]);
725             e3 = copysignf(vec2[0] * IQ, in[i+2]);
726             e4 = copysignf(vec2[1] * IQ, in[i+3]);
727             if (out) {
728                 out[i+0] = e1;
729                 out[i+1] = e2;
730                 out[i+2] = e3;
731                 out[i+3] = e4;
732             }
733             if (energy)
734                 qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);
735         }
736     }
737     if (energy)
738         *energy = qenergy;
739 }
740
741 static void quantize_and_encode_band_cost_ESC_mips(struct AACEncContext *s,
742                                                    PutBitContext *pb, const float *in, float *out,
743                                                    const float *scaled, int size, int scale_idx,
744                                                    int cb, const float lambda, const float uplim,
745                                                    int *bits, float *energy, const float ROUNDING)
746 {
747     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
748     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
749     int i;
750     int qc1, qc2, qc3, qc4;
751     float qenergy = 0.0f;
752
753     uint8_t  *p_bits    = (uint8_t* )ff_aac_spectral_bits[cb-1];
754     uint16_t *p_codes   = (uint16_t*)ff_aac_spectral_codes[cb-1];
755     float    *p_vectors = (float*   )ff_aac_codebook_vectors[cb-1];
756
757     abs_pow34_v(s->scoefs, in, size);
758     scaled = s->scoefs;
759
760     if (cb < 11) {
761         for (i = 0; i < size; i += 4) {
762             int curidx, curidx2, sign1, count1, sign2, count2;
763             int *in_int = (int *)&in[i];
764             uint8_t v_bits;
765             unsigned int v_codes;
766             int t0, t1, t2, t3, t4;
767             const float *vec1, *vec2;
768
769             qc1 = scaled[i  ] * Q34 + ROUNDING;
770             qc2 = scaled[i+1] * Q34 + ROUNDING;
771             qc3 = scaled[i+2] * Q34 + ROUNDING;
772             qc4 = scaled[i+3] * Q34 + ROUNDING;
773
774             __asm__ volatile (
775                 ".set push                                  \n\t"
776                 ".set noreorder                             \n\t"
777
778                 "ori        %[t4],      $zero,      16      \n\t"
779                 "ori        %[sign1],   $zero,      0       \n\t"
780                 "ori        %[sign2],   $zero,      0       \n\t"
781                 "slt        %[t0],      %[t4],      %[qc1]  \n\t"
782                 "slt        %[t1],      %[t4],      %[qc2]  \n\t"
783                 "slt        %[t2],      %[t4],      %[qc3]  \n\t"
784                 "slt        %[t3],      %[t4],      %[qc4]  \n\t"
785                 "movn       %[qc1],     %[t4],      %[t0]   \n\t"
786                 "movn       %[qc2],     %[t4],      %[t1]   \n\t"
787                 "movn       %[qc3],     %[t4],      %[t2]   \n\t"
788                 "movn       %[qc4],     %[t4],      %[t3]   \n\t"
789                 "lw         %[t0],      0(%[in_int])        \n\t"
790                 "lw         %[t1],      4(%[in_int])        \n\t"
791                 "lw         %[t2],      8(%[in_int])        \n\t"
792                 "lw         %[t3],      12(%[in_int])       \n\t"
793                 "slt        %[t0],      %[t0],      $zero   \n\t"
794                 "movn       %[sign1],   %[t0],      %[qc1]  \n\t"
795                 "slt        %[t2],      %[t2],      $zero   \n\t"
796                 "movn       %[sign2],   %[t2],      %[qc3]  \n\t"
797                 "slt        %[t1],      %[t1],      $zero   \n\t"
798                 "sll        %[t0],      %[sign1],   1       \n\t"
799                 "or         %[t0],      %[t0],      %[t1]   \n\t"
800                 "movn       %[sign1],   %[t0],      %[qc2]  \n\t"
801                 "slt        %[t3],      %[t3],      $zero   \n\t"
802                 "sll        %[t0],      %[sign2],   1       \n\t"
803                 "or         %[t0],      %[t0],      %[t3]   \n\t"
804                 "movn       %[sign2],   %[t0],      %[qc4]  \n\t"
805                 "slt        %[count1],  $zero,      %[qc1]  \n\t"
806                 "slt        %[t1],      $zero,      %[qc2]  \n\t"
807                 "slt        %[count2],  $zero,      %[qc3]  \n\t"
808                 "slt        %[t2],      $zero,      %[qc4]  \n\t"
809                 "addu       %[count1],  %[count1],  %[t1]   \n\t"
810                 "addu       %[count2],  %[count2],  %[t2]   \n\t"
811
812                 ".set pop                                   \n\t"
813
814                 : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
815                   [qc3]"+r"(qc3), [qc4]"+r"(qc4),
816                   [sign1]"=&r"(sign1), [count1]"=&r"(count1),
817                   [sign2]"=&r"(sign2), [count2]"=&r"(count2),
818                   [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
819                   [t4]"=&r"(t4)
820                 : [in_int]"r"(in_int)
821                 : "memory"
822             );
823
824             curidx = 17 * qc1;
825             curidx += qc2;
826             curidx2 = 17 * qc3;
827             curidx2 += qc4;
828
829             v_codes = (p_codes[curidx] << count1) | sign1;
830             v_bits  = p_bits[curidx] + count1;
831             put_bits(pb, v_bits, v_codes);
832
833             v_codes = (p_codes[curidx2] << count2) | sign2;
834             v_bits  = p_bits[curidx2] + count2;
835             put_bits(pb, v_bits, v_codes);
836
837             if (out || energy) {
838                 float e1,e2,e3,e4;
839                 vec1 = &p_vectors[curidx*2 ];
840                 vec2 = &p_vectors[curidx2*2];
841                 e1 = copysignf(vec1[0] * IQ, in[i+0]);
842                 e2 = copysignf(vec1[1] * IQ, in[i+1]);
843                 e3 = copysignf(vec2[0] * IQ, in[i+2]);
844                 e4 = copysignf(vec2[1] * IQ, in[i+3]);
845                 if (out) {
846                     out[i+0] = e1;
847                     out[i+1] = e2;
848                     out[i+2] = e3;
849                     out[i+3] = e4;
850                 }
851                 if (energy)
852                     qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);
853             }
854         }
855     } else {
856         for (i = 0; i < size; i += 4) {
857             int curidx, curidx2, sign1, count1, sign2, count2;
858             int *in_int = (int *)&in[i];
859             uint8_t v_bits;
860             unsigned int v_codes;
861             int c1, c2, c3, c4;
862             int t0, t1, t2, t3, t4;
863             const float *vec1, *vec2;
864
865             qc1 = scaled[i  ] * Q34 + ROUNDING;
866             qc2 = scaled[i+1] * Q34 + ROUNDING;
867             qc3 = scaled[i+2] * Q34 + ROUNDING;
868             qc4 = scaled[i+3] * Q34 + ROUNDING;
869
870             __asm__ volatile (
871                 ".set push                                  \n\t"
872                 ".set noreorder                             \n\t"
873
874                 "ori        %[t4],      $zero,      16      \n\t"
875                 "ori        %[sign1],   $zero,      0       \n\t"
876                 "ori        %[sign2],   $zero,      0       \n\t"
877                 "shll_s.w   %[c1],      %[qc1],     18      \n\t"
878                 "shll_s.w   %[c2],      %[qc2],     18      \n\t"
879                 "shll_s.w   %[c3],      %[qc3],     18      \n\t"
880                 "shll_s.w   %[c4],      %[qc4],     18      \n\t"
881                 "srl        %[c1],      %[c1],      18      \n\t"
882                 "srl        %[c2],      %[c2],      18      \n\t"
883                 "srl        %[c3],      %[c3],      18      \n\t"
884                 "srl        %[c4],      %[c4],      18      \n\t"
885                 "slt        %[t0],      %[t4],      %[qc1]  \n\t"
886                 "slt        %[t1],      %[t4],      %[qc2]  \n\t"
887                 "slt        %[t2],      %[t4],      %[qc3]  \n\t"
888                 "slt        %[t3],      %[t4],      %[qc4]  \n\t"
889                 "movn       %[qc1],     %[t4],      %[t0]   \n\t"
890                 "movn       %[qc2],     %[t4],      %[t1]   \n\t"
891                 "movn       %[qc3],     %[t4],      %[t2]   \n\t"
892                 "movn       %[qc4],     %[t4],      %[t3]   \n\t"
893                 "lw         %[t0],      0(%[in_int])        \n\t"
894                 "lw         %[t1],      4(%[in_int])        \n\t"
895                 "lw         %[t2],      8(%[in_int])        \n\t"
896                 "lw         %[t3],      12(%[in_int])       \n\t"
897                 "slt        %[t0],      %[t0],      $zero   \n\t"
898                 "movn       %[sign1],   %[t0],      %[qc1]  \n\t"
899                 "slt        %[t2],      %[t2],      $zero   \n\t"
900                 "movn       %[sign2],   %[t2],      %[qc3]  \n\t"
901                 "slt        %[t1],      %[t1],      $zero   \n\t"
902                 "sll        %[t0],      %[sign1],   1       \n\t"
903                 "or         %[t0],      %[t0],      %[t1]   \n\t"
904                 "movn       %[sign1],   %[t0],      %[qc2]  \n\t"
905                 "slt        %[t3],      %[t3],      $zero   \n\t"
906                 "sll        %[t0],      %[sign2],   1       \n\t"
907                 "or         %[t0],      %[t0],      %[t3]   \n\t"
908                 "movn       %[sign2],   %[t0],      %[qc4]  \n\t"
909                 "slt        %[count1],  $zero,      %[qc1]  \n\t"
910                 "slt        %[t1],      $zero,      %[qc2]  \n\t"
911                 "slt        %[count2],  $zero,      %[qc3]  \n\t"
912                 "slt        %[t2],      $zero,      %[qc4]  \n\t"
913                 "addu       %[count1],  %[count1],  %[t1]   \n\t"
914                 "addu       %[count2],  %[count2],  %[t2]   \n\t"
915
916                 ".set pop                                   \n\t"
917
918                 : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
919                   [qc3]"+r"(qc3), [qc4]"+r"(qc4),
920                   [sign1]"=&r"(sign1), [count1]"=&r"(count1),
921                   [sign2]"=&r"(sign2), [count2]"=&r"(count2),
922                   [c1]"=&r"(c1), [c2]"=&r"(c2),
923                   [c3]"=&r"(c3), [c4]"=&r"(c4),
924                   [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
925                   [t4]"=&r"(t4)
926                 : [in_int]"r"(in_int)
927                 : "memory"
928             );
929
930             curidx = 17 * qc1;
931             curidx += qc2;
932
933             curidx2 = 17 * qc3;
934             curidx2 += qc4;
935
936             v_codes = (p_codes[curidx] << count1) | sign1;
937             v_bits  = p_bits[curidx] + count1;
938             put_bits(pb, v_bits, v_codes);
939
940             if (p_vectors[curidx*2  ] == 64.0f) {
941                 int len = av_log2(c1);
942                 v_codes = (((1 << (len - 3)) - 2) << len) | (c1 & ((1 << len) - 1));
943                 put_bits(pb, len * 2 - 3, v_codes);
944             }
945             if (p_vectors[curidx*2+1] == 64.0f) {
946                 int len = av_log2(c2);
947                 v_codes = (((1 << (len - 3)) - 2) << len) | (c2 & ((1 << len) - 1));
948                 put_bits(pb, len*2-3, v_codes);
949             }
950
951             v_codes = (p_codes[curidx2] << count2) | sign2;
952             v_bits  = p_bits[curidx2] + count2;
953             put_bits(pb, v_bits, v_codes);
954
955             if (p_vectors[curidx2*2  ] == 64.0f) {
956                 int len = av_log2(c3);
957                 v_codes = (((1 << (len - 3)) - 2) << len) | (c3 & ((1 << len) - 1));
958                 put_bits(pb, len* 2 - 3, v_codes);
959             }
960             if (p_vectors[curidx2*2+1] == 64.0f) {
961                 int len = av_log2(c4);
962                 v_codes = (((1 << (len - 3)) - 2) << len) | (c4 & ((1 << len) - 1));
963                 put_bits(pb, len * 2 - 3, v_codes);
964             }
965
966             if (out || energy) {
967                 float e1, e2, e3, e4;
968                 vec1 = &p_vectors[curidx*2];
969                 vec2 = &p_vectors[curidx2*2];
970                 e1 = copysignf(c1 * cbrtf(c1) * IQ, in[i+0]);
971                 e2 = copysignf(c2 * cbrtf(c2) * IQ, in[i+1]);
972                 e3 = copysignf(c3 * cbrtf(c3) * IQ, in[i+2]);
973                 e4 = copysignf(c4 * cbrtf(c4) * IQ, in[i+3]);
974                 if (out) {
975                     out[i+0] = e1;
976                     out[i+1] = e2;
977                     out[i+2] = e3;
978                     out[i+3] = e4;
979                 }
980                 if (energy)
981                     qenergy += (e1*e1 + e2*e2) + (e3*e3 + e4*e4);
982             }
983         }
984     }
985     if (energy)
986         *energy = qenergy;
987 }
988
989 static void quantize_and_encode_band_cost_NONE_mips(struct AACEncContext *s,
990                                                          PutBitContext *pb, const float *in, float *out,
991                                                          const float *scaled, int size, int scale_idx,
992                                                          int cb, const float lambda, const float uplim,
993                                                          int *bits, float *energy, const float ROUNDING) {
994     av_assert0(0);
995 }
996
997 static void quantize_and_encode_band_cost_ZERO_mips(struct AACEncContext *s,
998                                                          PutBitContext *pb, const float *in, float *out,
999                                                          const float *scaled, int size, int scale_idx,
1000                                                          int cb, const float lambda, const float uplim,
1001                                                          int *bits, float *energy, const float ROUNDING) {
1002     int i;
1003     if (bits)
1004         *bits = 0;
1005     if (out) {
1006         for (i = 0; i < size; i += 4) {
1007            out[i  ] = 0.0f;
1008            out[i+1] = 0.0f;
1009            out[i+2] = 0.0f;
1010            out[i+3] = 0.0f;
1011         }
1012     }
1013     if (energy)
1014         *energy = 0.0f;
1015 }
1016
1017 static void (*const quantize_and_encode_band_cost_arr[])(struct AACEncContext *s,
1018                                                          PutBitContext *pb, const float *in, float *out,
1019                                                          const float *scaled, int size, int scale_idx,
1020                                                          int cb, const float lambda, const float uplim,
1021                                                          int *bits, float *energy, const float ROUNDING) = {
1022     quantize_and_encode_band_cost_ZERO_mips,
1023     quantize_and_encode_band_cost_SQUAD_mips,
1024     quantize_and_encode_band_cost_SQUAD_mips,
1025     quantize_and_encode_band_cost_UQUAD_mips,
1026     quantize_and_encode_band_cost_UQUAD_mips,
1027     quantize_and_encode_band_cost_SPAIR_mips,
1028     quantize_and_encode_band_cost_SPAIR_mips,
1029     quantize_and_encode_band_cost_UPAIR7_mips,
1030     quantize_and_encode_band_cost_UPAIR7_mips,
1031     quantize_and_encode_band_cost_UPAIR12_mips,
1032     quantize_and_encode_band_cost_UPAIR12_mips,
1033     quantize_and_encode_band_cost_ESC_mips,
1034     quantize_and_encode_band_cost_NONE_mips, /* cb 12 doesn't exist */
1035     quantize_and_encode_band_cost_ZERO_mips,
1036     quantize_and_encode_band_cost_ZERO_mips,
1037     quantize_and_encode_band_cost_ZERO_mips,
1038 };
1039
1040 #define quantize_and_encode_band_cost(                                       \
1041                                 s, pb, in, out, scaled, size, scale_idx, cb, \
1042                                 lambda, uplim, bits, energy, ROUNDING)       \
1043     quantize_and_encode_band_cost_arr[cb](                                   \
1044                                 s, pb, in, out, scaled, size, scale_idx, cb, \
1045                                 lambda, uplim, bits, energy, ROUNDING)
1046
1047 static void quantize_and_encode_band_mips(struct AACEncContext *s, PutBitContext *pb,
1048                                           const float *in, float *out, int size, int scale_idx,
1049                                           int cb, const float lambda, int rtz)
1050 {
1051     quantize_and_encode_band_cost(s, pb, in, out, NULL, size, scale_idx, cb, lambda,
1052                                   INFINITY, NULL, NULL, (rtz) ? ROUND_TO_ZERO : ROUND_STANDARD);
1053 }
1054
1055 /**
1056  * Functions developed from template function and optimized for getting the number of bits
1057  */
1058 static float get_band_numbits_ZERO_mips(struct AACEncContext *s,
1059                                         PutBitContext *pb, const float *in,
1060                                         const float *scaled, int size, int scale_idx,
1061                                         int cb, const float lambda, const float uplim,
1062                                         int *bits)
1063 {
1064     return 0;
1065 }
1066
1067 static float get_band_numbits_NONE_mips(struct AACEncContext *s,
1068                                         PutBitContext *pb, const float *in,
1069                                         const float *scaled, int size, int scale_idx,
1070                                         int cb, const float lambda, const float uplim,
1071                                         int *bits)
1072 {
1073     av_assert0(0);
1074     return 0;
1075 }
1076
1077 static float get_band_numbits_SQUAD_mips(struct AACEncContext *s,
1078                                          PutBitContext *pb, const float *in,
1079                                          const float *scaled, int size, int scale_idx,
1080                                          int cb, const float lambda, const float uplim,
1081                                          int *bits)
1082 {
1083     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1084     int i;
1085     int qc1, qc2, qc3, qc4;
1086     int curbits = 0;
1087
1088     uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[cb-1];
1089
1090     for (i = 0; i < size; i += 4) {
1091         int curidx;
1092         int *in_int = (int *)&in[i];
1093         int t0, t1, t2, t3, t4, t5, t6, t7;
1094
1095         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1096         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1097         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1098         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1099
1100         __asm__ volatile (
1101             ".set push                      \n\t"
1102             ".set noreorder                 \n\t"
1103
1104             "slt    %[qc1], $zero,  %[qc1]  \n\t"
1105             "slt    %[qc2], $zero,  %[qc2]  \n\t"
1106             "slt    %[qc3], $zero,  %[qc3]  \n\t"
1107             "slt    %[qc4], $zero,  %[qc4]  \n\t"
1108             "lw     %[t0],  0(%[in_int])    \n\t"
1109             "lw     %[t1],  4(%[in_int])    \n\t"
1110             "lw     %[t2],  8(%[in_int])    \n\t"
1111             "lw     %[t3],  12(%[in_int])   \n\t"
1112             "srl    %[t0],  %[t0],  31      \n\t"
1113             "srl    %[t1],  %[t1],  31      \n\t"
1114             "srl    %[t2],  %[t2],  31      \n\t"
1115             "srl    %[t3],  %[t3],  31      \n\t"
1116             "subu   %[t4],  $zero,  %[qc1]  \n\t"
1117             "subu   %[t5],  $zero,  %[qc2]  \n\t"
1118             "subu   %[t6],  $zero,  %[qc3]  \n\t"
1119             "subu   %[t7],  $zero,  %[qc4]  \n\t"
1120             "movn   %[qc1], %[t4],  %[t0]   \n\t"
1121             "movn   %[qc2], %[t5],  %[t1]   \n\t"
1122             "movn   %[qc3], %[t6],  %[t2]   \n\t"
1123             "movn   %[qc4], %[t7],  %[t3]   \n\t"
1124
1125             ".set pop                       \n\t"
1126
1127             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1128               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1129               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1130               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)
1131             : [in_int]"r"(in_int)
1132             : "memory"
1133         );
1134
1135         curidx = qc1;
1136         curidx *= 3;
1137         curidx += qc2;
1138         curidx *= 3;
1139         curidx += qc3;
1140         curidx *= 3;
1141         curidx += qc4;
1142         curidx += 40;
1143
1144         curbits += p_bits[curidx];
1145     }
1146     return curbits;
1147 }
1148
1149 static float get_band_numbits_UQUAD_mips(struct AACEncContext *s,
1150                                          PutBitContext *pb, const float *in,
1151                                          const float *scaled, int size, int scale_idx,
1152                                          int cb, const float lambda, const float uplim,
1153                                          int *bits)
1154 {
1155     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1156     int i;
1157     int curbits = 0;
1158     int qc1, qc2, qc3, qc4;
1159
1160     uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[cb-1];
1161
1162     for (i = 0; i < size; i += 4) {
1163         int curidx;
1164         int t0, t1, t2, t3, t4;
1165
1166         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1167         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1168         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1169         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1170
1171         __asm__ volatile (
1172             ".set push                      \n\t"
1173             ".set noreorder                 \n\t"
1174
1175             "ori    %[t4],  $zero,  2       \n\t"
1176             "slt    %[t0],  %[t4],  %[qc1]  \n\t"
1177             "slt    %[t1],  %[t4],  %[qc2]  \n\t"
1178             "slt    %[t2],  %[t4],  %[qc3]  \n\t"
1179             "slt    %[t3],  %[t4],  %[qc4]  \n\t"
1180             "movn   %[qc1], %[t4],  %[t0]   \n\t"
1181             "movn   %[qc2], %[t4],  %[t1]   \n\t"
1182             "movn   %[qc3], %[t4],  %[t2]   \n\t"
1183             "movn   %[qc4], %[t4],  %[t3]   \n\t"
1184
1185             ".set pop                       \n\t"
1186
1187             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1188               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1189               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1190               [t4]"=&r"(t4)
1191         );
1192
1193         curidx = qc1;
1194         curidx *= 3;
1195         curidx += qc2;
1196         curidx *= 3;
1197         curidx += qc3;
1198         curidx *= 3;
1199         curidx += qc4;
1200
1201         curbits += p_bits[curidx];
1202         curbits += uquad_sign_bits[curidx];
1203     }
1204     return curbits;
1205 }
1206
1207 static float get_band_numbits_SPAIR_mips(struct AACEncContext *s,
1208                                          PutBitContext *pb, const float *in,
1209                                          const float *scaled, int size, int scale_idx,
1210                                          int cb, const float lambda, const float uplim,
1211                                          int *bits)
1212 {
1213     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1214     int i;
1215     int qc1, qc2, qc3, qc4;
1216     int curbits = 0;
1217
1218     uint8_t *p_bits = (uint8_t*)ff_aac_spectral_bits[cb-1];
1219
1220     for (i = 0; i < size; i += 4) {
1221         int curidx, curidx2;
1222         int *in_int = (int *)&in[i];
1223         int t0, t1, t2, t3, t4, t5, t6, t7;
1224
1225         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1226         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1227         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1228         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1229
1230         __asm__ volatile (
1231             ".set push                      \n\t"
1232             ".set noreorder                 \n\t"
1233
1234             "ori    %[t4],  $zero,  4       \n\t"
1235             "slt    %[t0],  %[t4],  %[qc1]  \n\t"
1236             "slt    %[t1],  %[t4],  %[qc2]  \n\t"
1237             "slt    %[t2],  %[t4],  %[qc3]  \n\t"
1238             "slt    %[t3],  %[t4],  %[qc4]  \n\t"
1239             "movn   %[qc1], %[t4],  %[t0]   \n\t"
1240             "movn   %[qc2], %[t4],  %[t1]   \n\t"
1241             "movn   %[qc3], %[t4],  %[t2]   \n\t"
1242             "movn   %[qc4], %[t4],  %[t3]   \n\t"
1243             "lw     %[t0],  0(%[in_int])    \n\t"
1244             "lw     %[t1],  4(%[in_int])    \n\t"
1245             "lw     %[t2],  8(%[in_int])    \n\t"
1246             "lw     %[t3],  12(%[in_int])   \n\t"
1247             "srl    %[t0],  %[t0],  31      \n\t"
1248             "srl    %[t1],  %[t1],  31      \n\t"
1249             "srl    %[t2],  %[t2],  31      \n\t"
1250             "srl    %[t3],  %[t3],  31      \n\t"
1251             "subu   %[t4],  $zero,  %[qc1]  \n\t"
1252             "subu   %[t5],  $zero,  %[qc2]  \n\t"
1253             "subu   %[t6],  $zero,  %[qc3]  \n\t"
1254             "subu   %[t7],  $zero,  %[qc4]  \n\t"
1255             "movn   %[qc1], %[t4],  %[t0]   \n\t"
1256             "movn   %[qc2], %[t5],  %[t1]   \n\t"
1257             "movn   %[qc3], %[t6],  %[t2]   \n\t"
1258             "movn   %[qc4], %[t7],  %[t3]   \n\t"
1259
1260             ".set pop                       \n\t"
1261
1262             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1263               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1264               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1265               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)
1266             : [in_int]"r"(in_int)
1267             : "memory"
1268         );
1269
1270         curidx  = 9 * qc1;
1271         curidx += qc2 + 40;
1272
1273         curidx2  = 9 * qc3;
1274         curidx2 += qc4 + 40;
1275
1276         curbits += p_bits[curidx] + p_bits[curidx2];
1277     }
1278     return curbits;
1279 }
1280
1281 static float get_band_numbits_UPAIR7_mips(struct AACEncContext *s,
1282                                           PutBitContext *pb, const float *in,
1283                                           const float *scaled, int size, int scale_idx,
1284                                           int cb, const float lambda, const float uplim,
1285                                           int *bits)
1286 {
1287     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1288     int i;
1289     int qc1, qc2, qc3, qc4;
1290     int curbits = 0;
1291
1292     uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[cb-1];
1293
1294     for (i = 0; i < size; i += 4) {
1295         int curidx, curidx2;
1296         int t0, t1, t2, t3, t4;
1297
1298         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1299         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1300         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1301         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1302
1303         __asm__ volatile (
1304             ".set push                      \n\t"
1305             ".set noreorder                 \n\t"
1306
1307             "ori    %[t4],  $zero,  7       \n\t"
1308             "slt    %[t0],  %[t4],  %[qc1]  \n\t"
1309             "slt    %[t1],  %[t4],  %[qc2]  \n\t"
1310             "slt    %[t2],  %[t4],  %[qc3]  \n\t"
1311             "slt    %[t3],  %[t4],  %[qc4]  \n\t"
1312             "movn   %[qc1], %[t4],  %[t0]   \n\t"
1313             "movn   %[qc2], %[t4],  %[t1]   \n\t"
1314             "movn   %[qc3], %[t4],  %[t2]   \n\t"
1315             "movn   %[qc4], %[t4],  %[t3]   \n\t"
1316
1317             ".set pop                       \n\t"
1318
1319             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1320               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1321               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1322               [t4]"=&r"(t4)
1323         );
1324
1325         curidx  = 8 * qc1;
1326         curidx += qc2;
1327
1328         curidx2  = 8 * qc3;
1329         curidx2 += qc4;
1330
1331         curbits += p_bits[curidx] +
1332                    upair7_sign_bits[curidx] +
1333                    p_bits[curidx2] +
1334                    upair7_sign_bits[curidx2];
1335     }
1336     return curbits;
1337 }
1338
1339 static float get_band_numbits_UPAIR12_mips(struct AACEncContext *s,
1340                                            PutBitContext *pb, const float *in,
1341                                            const float *scaled, int size, int scale_idx,
1342                                            int cb, const float lambda, const float uplim,
1343                                            int *bits)
1344 {
1345     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1346     int i;
1347     int qc1, qc2, qc3, qc4;
1348     int curbits = 0;
1349
1350     uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[cb-1];
1351
1352     for (i = 0; i < size; i += 4) {
1353         int curidx, curidx2;
1354         int t0, t1, t2, t3, t4;
1355
1356         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1357         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1358         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1359         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1360
1361         __asm__ volatile (
1362             ".set push                      \n\t"
1363             ".set noreorder                 \n\t"
1364
1365             "ori    %[t4],  $zero,  12      \n\t"
1366             "slt    %[t0],  %[t4],  %[qc1]  \n\t"
1367             "slt    %[t1],  %[t4],  %[qc2]  \n\t"
1368             "slt    %[t2],  %[t4],  %[qc3]  \n\t"
1369             "slt    %[t3],  %[t4],  %[qc4]  \n\t"
1370             "movn   %[qc1], %[t4],  %[t0]   \n\t"
1371             "movn   %[qc2], %[t4],  %[t1]   \n\t"
1372             "movn   %[qc3], %[t4],  %[t2]   \n\t"
1373             "movn   %[qc4], %[t4],  %[t3]   \n\t"
1374
1375             ".set pop                       \n\t"
1376
1377             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1378               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1379               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1380               [t4]"=&r"(t4)
1381         );
1382
1383         curidx  = 13 * qc1;
1384         curidx += qc2;
1385
1386         curidx2  = 13 * qc3;
1387         curidx2 += qc4;
1388
1389         curbits += p_bits[curidx] +
1390                    p_bits[curidx2] +
1391                    upair12_sign_bits[curidx] +
1392                    upair12_sign_bits[curidx2];
1393     }
1394     return curbits;
1395 }
1396
1397 static float get_band_numbits_ESC_mips(struct AACEncContext *s,
1398                                        PutBitContext *pb, const float *in,
1399                                        const float *scaled, int size, int scale_idx,
1400                                        int cb, const float lambda, const float uplim,
1401                                        int *bits)
1402 {
1403     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1404     int i;
1405     int qc1, qc2, qc3, qc4;
1406     int curbits = 0;
1407
1408     uint8_t *p_bits = (uint8_t*)ff_aac_spectral_bits[cb-1];
1409
1410     for (i = 0; i < size; i += 4) {
1411         int curidx, curidx2;
1412         int cond0, cond1, cond2, cond3;
1413         int c1, c2, c3, c4;
1414         int t4, t5;
1415
1416         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1417         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1418         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1419         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1420
1421         __asm__ volatile (
1422             ".set push                                  \n\t"
1423             ".set noreorder                             \n\t"
1424
1425             "ori        %[t4],      $zero,  15          \n\t"
1426             "ori        %[t5],      $zero,  16          \n\t"
1427             "shll_s.w   %[c1],      %[qc1], 18          \n\t"
1428             "shll_s.w   %[c2],      %[qc2], 18          \n\t"
1429             "shll_s.w   %[c3],      %[qc3], 18          \n\t"
1430             "shll_s.w   %[c4],      %[qc4], 18          \n\t"
1431             "srl        %[c1],      %[c1],  18          \n\t"
1432             "srl        %[c2],      %[c2],  18          \n\t"
1433             "srl        %[c3],      %[c3],  18          \n\t"
1434             "srl        %[c4],      %[c4],  18          \n\t"
1435             "slt        %[cond0],   %[t4],  %[qc1]      \n\t"
1436             "slt        %[cond1],   %[t4],  %[qc2]      \n\t"
1437             "slt        %[cond2],   %[t4],  %[qc3]      \n\t"
1438             "slt        %[cond3],   %[t4],  %[qc4]      \n\t"
1439             "movn       %[qc1],     %[t5],  %[cond0]    \n\t"
1440             "movn       %[qc2],     %[t5],  %[cond1]    \n\t"
1441             "movn       %[qc3],     %[t5],  %[cond2]    \n\t"
1442             "movn       %[qc4],     %[t5],  %[cond3]    \n\t"
1443             "ori        %[t5],      $zero,  31          \n\t"
1444             "clz        %[c1],      %[c1]               \n\t"
1445             "clz        %[c2],      %[c2]               \n\t"
1446             "clz        %[c3],      %[c3]               \n\t"
1447             "clz        %[c4],      %[c4]               \n\t"
1448             "subu       %[c1],      %[t5],  %[c1]       \n\t"
1449             "subu       %[c2],      %[t5],  %[c2]       \n\t"
1450             "subu       %[c3],      %[t5],  %[c3]       \n\t"
1451             "subu       %[c4],      %[t5],  %[c4]       \n\t"
1452             "sll        %[c1],      %[c1],  1           \n\t"
1453             "sll        %[c2],      %[c2],  1           \n\t"
1454             "sll        %[c3],      %[c3],  1           \n\t"
1455             "sll        %[c4],      %[c4],  1           \n\t"
1456             "addiu      %[c1],      %[c1],  -3          \n\t"
1457             "addiu      %[c2],      %[c2],  -3          \n\t"
1458             "addiu      %[c3],      %[c3],  -3          \n\t"
1459             "addiu      %[c4],      %[c4],  -3          \n\t"
1460             "subu       %[cond0],   $zero,  %[cond0]    \n\t"
1461             "subu       %[cond1],   $zero,  %[cond1]    \n\t"
1462             "subu       %[cond2],   $zero,  %[cond2]    \n\t"
1463             "subu       %[cond3],   $zero,  %[cond3]    \n\t"
1464             "and        %[c1],      %[c1],  %[cond0]    \n\t"
1465             "and        %[c2],      %[c2],  %[cond1]    \n\t"
1466             "and        %[c3],      %[c3],  %[cond2]    \n\t"
1467             "and        %[c4],      %[c4],  %[cond3]    \n\t"
1468
1469             ".set pop                                   \n\t"
1470
1471             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1472               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1473               [cond0]"=&r"(cond0), [cond1]"=&r"(cond1),
1474               [cond2]"=&r"(cond2), [cond3]"=&r"(cond3),
1475               [c1]"=&r"(c1), [c2]"=&r"(c2),
1476               [c3]"=&r"(c3), [c4]"=&r"(c4),
1477               [t4]"=&r"(t4), [t5]"=&r"(t5)
1478         );
1479
1480         curidx = 17 * qc1;
1481         curidx += qc2;
1482
1483         curidx2 = 17 * qc3;
1484         curidx2 += qc4;
1485
1486         curbits += p_bits[curidx];
1487         curbits += esc_sign_bits[curidx];
1488         curbits += p_bits[curidx2];
1489         curbits += esc_sign_bits[curidx2];
1490
1491         curbits += c1;
1492         curbits += c2;
1493         curbits += c3;
1494         curbits += c4;
1495     }
1496     return curbits;
1497 }
1498
1499 static float (*const get_band_numbits_arr[])(struct AACEncContext *s,
1500                                              PutBitContext *pb, const float *in,
1501                                              const float *scaled, int size, int scale_idx,
1502                                              int cb, const float lambda, const float uplim,
1503                                              int *bits) = {
1504     get_band_numbits_ZERO_mips,
1505     get_band_numbits_SQUAD_mips,
1506     get_band_numbits_SQUAD_mips,
1507     get_band_numbits_UQUAD_mips,
1508     get_band_numbits_UQUAD_mips,
1509     get_band_numbits_SPAIR_mips,
1510     get_band_numbits_SPAIR_mips,
1511     get_band_numbits_UPAIR7_mips,
1512     get_band_numbits_UPAIR7_mips,
1513     get_band_numbits_UPAIR12_mips,
1514     get_band_numbits_UPAIR12_mips,
1515     get_band_numbits_ESC_mips,
1516     get_band_numbits_NONE_mips, /* cb 12 doesn't exist */
1517     get_band_numbits_ZERO_mips,
1518     get_band_numbits_ZERO_mips,
1519     get_band_numbits_ZERO_mips,
1520 };
1521
1522 #define get_band_numbits(                                  \
1523                                 s, pb, in, scaled, size, scale_idx, cb, \
1524                                 lambda, uplim, bits)                    \
1525     get_band_numbits_arr[cb](                              \
1526                                 s, pb, in, scaled, size, scale_idx, cb, \
1527                                 lambda, uplim, bits)
1528
1529 static float quantize_band_cost_bits(struct AACEncContext *s, const float *in,
1530                                      const float *scaled, int size, int scale_idx,
1531                                      int cb, const float lambda, const float uplim,
1532                                      int *bits, float *energy, int rtz)
1533 {
1534     return get_band_numbits(s, NULL, in, scaled, size, scale_idx, cb, lambda, uplim, bits);
1535 }
1536
1537 /**
1538  * Functions developed from template function and optimized for getting the band cost
1539  */
1540 #if HAVE_MIPSFPU
1541 static float get_band_cost_ZERO_mips(struct AACEncContext *s,
1542                                      PutBitContext *pb, const float *in,
1543                                      const float *scaled, int size, int scale_idx,
1544                                      int cb, const float lambda, const float uplim,
1545                                      int *bits, float *energy)
1546 {
1547     int i;
1548     float cost = 0;
1549
1550     for (i = 0; i < size; i += 4) {
1551         cost += in[i  ] * in[i  ];
1552         cost += in[i+1] * in[i+1];
1553         cost += in[i+2] * in[i+2];
1554         cost += in[i+3] * in[i+3];
1555     }
1556     if (bits)
1557         *bits = 0;
1558     if (energy)
1559         *energy = 0.0f;
1560     return cost * lambda;
1561 }
1562
1563 static float get_band_cost_NONE_mips(struct AACEncContext *s,
1564                                      PutBitContext *pb, const float *in,
1565                                      const float *scaled, int size, int scale_idx,
1566                                      int cb, const float lambda, const float uplim,
1567                                      int *bits, float *energy)
1568 {
1569     av_assert0(0);
1570     return 0;
1571 }
1572
1573 static float get_band_cost_SQUAD_mips(struct AACEncContext *s,
1574                                       PutBitContext *pb, const float *in,
1575                                       const float *scaled, int size, int scale_idx,
1576                                       int cb, const float lambda, const float uplim,
1577                                       int *bits, float *energy)
1578 {
1579     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1580     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
1581     int i;
1582     float cost = 0;
1583     float qenergy = 0.0f;
1584     int qc1, qc2, qc3, qc4;
1585     int curbits = 0;
1586
1587     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];
1588     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];
1589
1590     for (i = 0; i < size; i += 4) {
1591         const float *vec;
1592         int curidx;
1593         int   *in_int = (int   *)&in[i];
1594         float *in_pos = (float *)&in[i];
1595         float di0, di1, di2, di3;
1596         int t0, t1, t2, t3, t4, t5, t6, t7;
1597
1598         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1599         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1600         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1601         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1602
1603         __asm__ volatile (
1604             ".set push                                  \n\t"
1605             ".set noreorder                             \n\t"
1606
1607             "slt        %[qc1], $zero,  %[qc1]          \n\t"
1608             "slt        %[qc2], $zero,  %[qc2]          \n\t"
1609             "slt        %[qc3], $zero,  %[qc3]          \n\t"
1610             "slt        %[qc4], $zero,  %[qc4]          \n\t"
1611             "lw         %[t0],  0(%[in_int])            \n\t"
1612             "lw         %[t1],  4(%[in_int])            \n\t"
1613             "lw         %[t2],  8(%[in_int])            \n\t"
1614             "lw         %[t3],  12(%[in_int])           \n\t"
1615             "srl        %[t0],  %[t0],  31              \n\t"
1616             "srl        %[t1],  %[t1],  31              \n\t"
1617             "srl        %[t2],  %[t2],  31              \n\t"
1618             "srl        %[t3],  %[t3],  31              \n\t"
1619             "subu       %[t4],  $zero,  %[qc1]          \n\t"
1620             "subu       %[t5],  $zero,  %[qc2]          \n\t"
1621             "subu       %[t6],  $zero,  %[qc3]          \n\t"
1622             "subu       %[t7],  $zero,  %[qc4]          \n\t"
1623             "movn       %[qc1], %[t4],  %[t0]           \n\t"
1624             "movn       %[qc2], %[t5],  %[t1]           \n\t"
1625             "movn       %[qc3], %[t6],  %[t2]           \n\t"
1626             "movn       %[qc4], %[t7],  %[t3]           \n\t"
1627
1628             ".set pop                                   \n\t"
1629
1630             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1631               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1632               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1633               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)
1634             : [in_int]"r"(in_int)
1635             : "memory"
1636         );
1637
1638         curidx = qc1;
1639         curidx *= 3;
1640         curidx += qc2;
1641         curidx *= 3;
1642         curidx += qc3;
1643         curidx *= 3;
1644         curidx += qc4;
1645         curidx += 40;
1646
1647         curbits += p_bits[curidx];
1648         vec     = &p_codes[curidx*4];
1649
1650         qenergy += vec[0]*vec[0] + vec[1]*vec[1]
1651                 +  vec[2]*vec[2] + vec[3]*vec[3];
1652
1653         __asm__ volatile (
1654             ".set push                                  \n\t"
1655             ".set noreorder                             \n\t"
1656
1657             "lwc1       $f0,    0(%[in_pos])            \n\t"
1658             "lwc1       $f1,    0(%[vec])               \n\t"
1659             "lwc1       $f2,    4(%[in_pos])            \n\t"
1660             "lwc1       $f3,    4(%[vec])               \n\t"
1661             "lwc1       $f4,    8(%[in_pos])            \n\t"
1662             "lwc1       $f5,    8(%[vec])               \n\t"
1663             "lwc1       $f6,    12(%[in_pos])           \n\t"
1664             "lwc1       $f7,    12(%[vec])              \n\t"
1665             "nmsub.s    %[di0], $f0,    $f1,    %[IQ]   \n\t"
1666             "nmsub.s    %[di1], $f2,    $f3,    %[IQ]   \n\t"
1667             "nmsub.s    %[di2], $f4,    $f5,    %[IQ]   \n\t"
1668             "nmsub.s    %[di3], $f6,    $f7,    %[IQ]   \n\t"
1669
1670             ".set pop                                   \n\t"
1671
1672             : [di0]"=&f"(di0), [di1]"=&f"(di1),
1673               [di2]"=&f"(di2), [di3]"=&f"(di3)
1674             : [in_pos]"r"(in_pos), [vec]"r"(vec),
1675               [IQ]"f"(IQ)
1676             : "$f0", "$f1", "$f2", "$f3",
1677               "$f4", "$f5", "$f6", "$f7",
1678               "memory"
1679         );
1680
1681         cost += di0 * di0 + di1 * di1
1682                 + di2 * di2 + di3 * di3;
1683     }
1684
1685     if (bits)
1686         *bits = curbits;
1687     if (energy)
1688         *energy = qenergy * (IQ*IQ);
1689     return cost * lambda + curbits;
1690 }
1691
1692 static float get_band_cost_UQUAD_mips(struct AACEncContext *s,
1693                                       PutBitContext *pb, const float *in,
1694                                       const float *scaled, int size, int scale_idx,
1695                                       int cb, const float lambda, const float uplim,
1696                                       int *bits, float *energy)
1697 {
1698     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1699     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
1700     int i;
1701     float cost = 0;
1702     float qenergy = 0.0f;
1703     int curbits = 0;
1704     int qc1, qc2, qc3, qc4;
1705
1706     uint8_t *p_bits  = (uint8_t*)ff_aac_spectral_bits[cb-1];
1707     float   *p_codes = (float  *)ff_aac_codebook_vectors[cb-1];
1708
1709     for (i = 0; i < size; i += 4) {
1710         const float *vec;
1711         int curidx;
1712         float *in_pos = (float *)&in[i];
1713         float di0, di1, di2, di3;
1714         int t0, t1, t2, t3, t4;
1715
1716         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1717         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1718         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1719         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1720
1721         __asm__ volatile (
1722             ".set push                                  \n\t"
1723             ".set noreorder                             \n\t"
1724
1725             "ori        %[t4],  $zero,  2               \n\t"
1726             "slt        %[t0],  %[t4],  %[qc1]          \n\t"
1727             "slt        %[t1],  %[t4],  %[qc2]          \n\t"
1728             "slt        %[t2],  %[t4],  %[qc3]          \n\t"
1729             "slt        %[t3],  %[t4],  %[qc4]          \n\t"
1730             "movn       %[qc1], %[t4],  %[t0]           \n\t"
1731             "movn       %[qc2], %[t4],  %[t1]           \n\t"
1732             "movn       %[qc3], %[t4],  %[t2]           \n\t"
1733             "movn       %[qc4], %[t4],  %[t3]           \n\t"
1734
1735             ".set pop                                   \n\t"
1736
1737             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1738               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1739               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1740               [t4]"=&r"(t4)
1741         );
1742
1743         curidx = qc1;
1744         curidx *= 3;
1745         curidx += qc2;
1746         curidx *= 3;
1747         curidx += qc3;
1748         curidx *= 3;
1749         curidx += qc4;
1750
1751         curbits += p_bits[curidx];
1752         curbits += uquad_sign_bits[curidx];
1753         vec     = &p_codes[curidx*4];
1754
1755         qenergy += vec[0]*vec[0] + vec[1]*vec[1]
1756                 +  vec[2]*vec[2] + vec[3]*vec[3];
1757
1758         __asm__ volatile (
1759             ".set push                                  \n\t"
1760             ".set noreorder                             \n\t"
1761
1762             "lwc1       %[di0], 0(%[in_pos])            \n\t"
1763             "lwc1       %[di1], 4(%[in_pos])            \n\t"
1764             "lwc1       %[di2], 8(%[in_pos])            \n\t"
1765             "lwc1       %[di3], 12(%[in_pos])           \n\t"
1766             "abs.s      %[di0], %[di0]                  \n\t"
1767             "abs.s      %[di1], %[di1]                  \n\t"
1768             "abs.s      %[di2], %[di2]                  \n\t"
1769             "abs.s      %[di3], %[di3]                  \n\t"
1770             "lwc1       $f0,    0(%[vec])               \n\t"
1771             "lwc1       $f1,    4(%[vec])               \n\t"
1772             "lwc1       $f2,    8(%[vec])               \n\t"
1773             "lwc1       $f3,    12(%[vec])              \n\t"
1774             "nmsub.s    %[di0], %[di0], $f0,    %[IQ]   \n\t"
1775             "nmsub.s    %[di1], %[di1], $f1,    %[IQ]   \n\t"
1776             "nmsub.s    %[di2], %[di2], $f2,    %[IQ]   \n\t"
1777             "nmsub.s    %[di3], %[di3], $f3,    %[IQ]   \n\t"
1778
1779             ".set pop                                   \n\t"
1780
1781             : [di0]"=&f"(di0), [di1]"=&f"(di1),
1782               [di2]"=&f"(di2), [di3]"=&f"(di3)
1783             : [in_pos]"r"(in_pos), [vec]"r"(vec),
1784               [IQ]"f"(IQ)
1785             : "$f0", "$f1", "$f2", "$f3",
1786               "memory"
1787         );
1788
1789         cost += di0 * di0 + di1 * di1
1790                 + di2 * di2 + di3 * di3;
1791     }
1792
1793     if (bits)
1794         *bits = curbits;
1795     if (energy)
1796         *energy = qenergy * (IQ*IQ);
1797     return cost * lambda + curbits;
1798 }
1799
1800 static float get_band_cost_SPAIR_mips(struct AACEncContext *s,
1801                                       PutBitContext *pb, const float *in,
1802                                       const float *scaled, int size, int scale_idx,
1803                                       int cb, const float lambda, const float uplim,
1804                                       int *bits, float *energy)
1805 {
1806     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1807     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
1808     int i;
1809     float cost = 0;
1810     float qenergy = 0.0f;
1811     int qc1, qc2, qc3, qc4;
1812     int curbits = 0;
1813
1814     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];
1815     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];
1816
1817     for (i = 0; i < size; i += 4) {
1818         const float *vec, *vec2;
1819         int curidx, curidx2;
1820         int   *in_int = (int   *)&in[i];
1821         float *in_pos = (float *)&in[i];
1822         float di0, di1, di2, di3;
1823         int t0, t1, t2, t3, t4, t5, t6, t7;
1824
1825         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1826         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1827         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1828         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1829
1830         __asm__ volatile (
1831             ".set push                                  \n\t"
1832             ".set noreorder                             \n\t"
1833
1834             "ori        %[t4],  $zero,  4               \n\t"
1835             "slt        %[t0],  %[t4],  %[qc1]          \n\t"
1836             "slt        %[t1],  %[t4],  %[qc2]          \n\t"
1837             "slt        %[t2],  %[t4],  %[qc3]          \n\t"
1838             "slt        %[t3],  %[t4],  %[qc4]          \n\t"
1839             "movn       %[qc1], %[t4],  %[t0]           \n\t"
1840             "movn       %[qc2], %[t4],  %[t1]           \n\t"
1841             "movn       %[qc3], %[t4],  %[t2]           \n\t"
1842             "movn       %[qc4], %[t4],  %[t3]           \n\t"
1843             "lw         %[t0],  0(%[in_int])            \n\t"
1844             "lw         %[t1],  4(%[in_int])            \n\t"
1845             "lw         %[t2],  8(%[in_int])            \n\t"
1846             "lw         %[t3],  12(%[in_int])           \n\t"
1847             "srl        %[t0],  %[t0],  31              \n\t"
1848             "srl        %[t1],  %[t1],  31              \n\t"
1849             "srl        %[t2],  %[t2],  31              \n\t"
1850             "srl        %[t3],  %[t3],  31              \n\t"
1851             "subu       %[t4],  $zero,  %[qc1]          \n\t"
1852             "subu       %[t5],  $zero,  %[qc2]          \n\t"
1853             "subu       %[t6],  $zero,  %[qc3]          \n\t"
1854             "subu       %[t7],  $zero,  %[qc4]          \n\t"
1855             "movn       %[qc1], %[t4],  %[t0]           \n\t"
1856             "movn       %[qc2], %[t5],  %[t1]           \n\t"
1857             "movn       %[qc3], %[t6],  %[t2]           \n\t"
1858             "movn       %[qc4], %[t7],  %[t3]           \n\t"
1859
1860             ".set pop                                   \n\t"
1861
1862             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1863               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1864               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1865               [t4]"=&r"(t4), [t5]"=&r"(t5), [t6]"=&r"(t6), [t7]"=&r"(t7)
1866             : [in_int]"r"(in_int)
1867             : "memory"
1868         );
1869
1870         curidx = 9 * qc1;
1871         curidx += qc2 + 40;
1872
1873         curidx2 = 9 * qc3;
1874         curidx2 += qc4 + 40;
1875
1876         curbits += p_bits[curidx];
1877         curbits += p_bits[curidx2];
1878
1879         vec     = &p_codes[curidx*2];
1880         vec2    = &p_codes[curidx2*2];
1881
1882         qenergy += vec[0]*vec[0] + vec[1]*vec[1]
1883                 +  vec2[0]*vec2[0] + vec2[1]*vec2[1];
1884
1885         __asm__ volatile (
1886             ".set push                                  \n\t"
1887             ".set noreorder                             \n\t"
1888
1889             "lwc1       $f0,    0(%[in_pos])            \n\t"
1890             "lwc1       $f1,    0(%[vec])               \n\t"
1891             "lwc1       $f2,    4(%[in_pos])            \n\t"
1892             "lwc1       $f3,    4(%[vec])               \n\t"
1893             "lwc1       $f4,    8(%[in_pos])            \n\t"
1894             "lwc1       $f5,    0(%[vec2])              \n\t"
1895             "lwc1       $f6,    12(%[in_pos])           \n\t"
1896             "lwc1       $f7,    4(%[vec2])              \n\t"
1897             "nmsub.s    %[di0], $f0,    $f1,    %[IQ]   \n\t"
1898             "nmsub.s    %[di1], $f2,    $f3,    %[IQ]   \n\t"
1899             "nmsub.s    %[di2], $f4,    $f5,    %[IQ]   \n\t"
1900             "nmsub.s    %[di3], $f6,    $f7,    %[IQ]   \n\t"
1901
1902             ".set pop                                   \n\t"
1903
1904             : [di0]"=&f"(di0), [di1]"=&f"(di1),
1905               [di2]"=&f"(di2), [di3]"=&f"(di3)
1906             : [in_pos]"r"(in_pos), [vec]"r"(vec),
1907               [vec2]"r"(vec2), [IQ]"f"(IQ)
1908             : "$f0", "$f1", "$f2", "$f3",
1909               "$f4", "$f5", "$f6", "$f7",
1910               "memory"
1911         );
1912
1913         cost += di0 * di0 + di1 * di1
1914                 + di2 * di2 + di3 * di3;
1915     }
1916
1917     if (bits)
1918         *bits = curbits;
1919     if (energy)
1920         *energy = qenergy * (IQ*IQ);
1921     return cost * lambda + curbits;
1922 }
1923
1924 static float get_band_cost_UPAIR7_mips(struct AACEncContext *s,
1925                                        PutBitContext *pb, const float *in,
1926                                        const float *scaled, int size, int scale_idx,
1927                                        int cb, const float lambda, const float uplim,
1928                                        int *bits, float *energy)
1929 {
1930     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
1931     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
1932     int i;
1933     float cost = 0;
1934     float qenergy = 0.0f;
1935     int qc1, qc2, qc3, qc4;
1936     int curbits = 0;
1937
1938     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];
1939     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];
1940
1941     for (i = 0; i < size; i += 4) {
1942         const float *vec, *vec2;
1943         int curidx, curidx2, sign1, count1, sign2, count2;
1944         int   *in_int = (int   *)&in[i];
1945         float *in_pos = (float *)&in[i];
1946         float di0, di1, di2, di3;
1947         int t0, t1, t2, t3, t4;
1948
1949         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
1950         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
1951         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
1952         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
1953
1954         __asm__ volatile (
1955             ".set push                                          \n\t"
1956             ".set noreorder                                     \n\t"
1957
1958             "ori        %[t4],      $zero,      7               \n\t"
1959             "ori        %[sign1],   $zero,      0               \n\t"
1960             "ori        %[sign2],   $zero,      0               \n\t"
1961             "slt        %[t0],      %[t4],      %[qc1]          \n\t"
1962             "slt        %[t1],      %[t4],      %[qc2]          \n\t"
1963             "slt        %[t2],      %[t4],      %[qc3]          \n\t"
1964             "slt        %[t3],      %[t4],      %[qc4]          \n\t"
1965             "movn       %[qc1],     %[t4],      %[t0]           \n\t"
1966             "movn       %[qc2],     %[t4],      %[t1]           \n\t"
1967             "movn       %[qc3],     %[t4],      %[t2]           \n\t"
1968             "movn       %[qc4],     %[t4],      %[t3]           \n\t"
1969             "lw         %[t0],      0(%[in_int])                \n\t"
1970             "lw         %[t1],      4(%[in_int])                \n\t"
1971             "lw         %[t2],      8(%[in_int])                \n\t"
1972             "lw         %[t3],      12(%[in_int])               \n\t"
1973             "slt        %[t0],      %[t0],      $zero           \n\t"
1974             "movn       %[sign1],   %[t0],      %[qc1]          \n\t"
1975             "slt        %[t2],      %[t2],      $zero           \n\t"
1976             "movn       %[sign2],   %[t2],      %[qc3]          \n\t"
1977             "slt        %[t1],      %[t1],      $zero           \n\t"
1978             "sll        %[t0],      %[sign1],   1               \n\t"
1979             "or         %[t0],      %[t0],      %[t1]           \n\t"
1980             "movn       %[sign1],   %[t0],      %[qc2]          \n\t"
1981             "slt        %[t3],      %[t3],      $zero           \n\t"
1982             "sll        %[t0],      %[sign2],   1               \n\t"
1983             "or         %[t0],      %[t0],      %[t3]           \n\t"
1984             "movn       %[sign2],   %[t0],      %[qc4]          \n\t"
1985             "slt        %[count1],  $zero,      %[qc1]          \n\t"
1986             "slt        %[t1],      $zero,      %[qc2]          \n\t"
1987             "slt        %[count2],  $zero,      %[qc3]          \n\t"
1988             "slt        %[t2],      $zero,      %[qc4]          \n\t"
1989             "addu       %[count1],  %[count1],  %[t1]           \n\t"
1990             "addu       %[count2],  %[count2],  %[t2]           \n\t"
1991
1992             ".set pop                                           \n\t"
1993
1994             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
1995               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
1996               [sign1]"=&r"(sign1), [count1]"=&r"(count1),
1997               [sign2]"=&r"(sign2), [count2]"=&r"(count2),
1998               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
1999               [t4]"=&r"(t4)
2000             : [in_int]"r"(in_int)
2001             : "memory"
2002         );
2003
2004         curidx = 8 * qc1;
2005         curidx += qc2;
2006
2007         curidx2 = 8 * qc3;
2008         curidx2 += qc4;
2009
2010         curbits += p_bits[curidx];
2011         curbits += upair7_sign_bits[curidx];
2012         vec     = &p_codes[curidx*2];
2013
2014         curbits += p_bits[curidx2];
2015         curbits += upair7_sign_bits[curidx2];
2016         vec2    = &p_codes[curidx2*2];
2017
2018         qenergy += vec[0]*vec[0] + vec[1]*vec[1]
2019                 +  vec2[0]*vec2[0] + vec2[1]*vec2[1];
2020
2021         __asm__ volatile (
2022             ".set push                                          \n\t"
2023             ".set noreorder                                     \n\t"
2024
2025             "lwc1       %[di0],     0(%[in_pos])                \n\t"
2026             "lwc1       %[di1],     4(%[in_pos])                \n\t"
2027             "lwc1       %[di2],     8(%[in_pos])                \n\t"
2028             "lwc1       %[di3],     12(%[in_pos])               \n\t"
2029             "abs.s      %[di0],     %[di0]                      \n\t"
2030             "abs.s      %[di1],     %[di1]                      \n\t"
2031             "abs.s      %[di2],     %[di2]                      \n\t"
2032             "abs.s      %[di3],     %[di3]                      \n\t"
2033             "lwc1       $f0,        0(%[vec])                   \n\t"
2034             "lwc1       $f1,        4(%[vec])                   \n\t"
2035             "lwc1       $f2,        0(%[vec2])                  \n\t"
2036             "lwc1       $f3,        4(%[vec2])                  \n\t"
2037             "nmsub.s    %[di0],     %[di0],     $f0,    %[IQ]   \n\t"
2038             "nmsub.s    %[di1],     %[di1],     $f1,    %[IQ]   \n\t"
2039             "nmsub.s    %[di2],     %[di2],     $f2,    %[IQ]   \n\t"
2040             "nmsub.s    %[di3],     %[di3],     $f3,    %[IQ]   \n\t"
2041
2042             ".set pop                                           \n\t"
2043
2044             : [di0]"=&f"(di0), [di1]"=&f"(di1),
2045               [di2]"=&f"(di2), [di3]"=&f"(di3)
2046             : [in_pos]"r"(in_pos), [vec]"r"(vec),
2047               [vec2]"r"(vec2), [IQ]"f"(IQ)
2048             : "$f0", "$f1", "$f2", "$f3",
2049               "memory"
2050         );
2051
2052         cost += di0 * di0 + di1 * di1
2053                 + di2 * di2 + di3 * di3;
2054     }
2055
2056     if (bits)
2057         *bits = curbits;
2058     if (energy)
2059         *energy = qenergy * (IQ*IQ);
2060     return cost * lambda + curbits;
2061 }
2062
2063 static float get_band_cost_UPAIR12_mips(struct AACEncContext *s,
2064                                         PutBitContext *pb, const float *in,
2065                                         const float *scaled, int size, int scale_idx,
2066                                         int cb, const float lambda, const float uplim,
2067                                         int *bits, float *energy)
2068 {
2069     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
2070     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
2071     int i;
2072     float cost = 0;
2073     float qenergy = 0.0f;
2074     int qc1, qc2, qc3, qc4;
2075     int curbits = 0;
2076
2077     uint8_t *p_bits  = (uint8_t *)ff_aac_spectral_bits[cb-1];
2078     float   *p_codes = (float   *)ff_aac_codebook_vectors[cb-1];
2079
2080     for (i = 0; i < size; i += 4) {
2081         const float *vec, *vec2;
2082         int curidx, curidx2;
2083         int sign1, count1, sign2, count2;
2084         int   *in_int = (int   *)&in[i];
2085         float *in_pos = (float *)&in[i];
2086         float di0, di1, di2, di3;
2087         int t0, t1, t2, t3, t4;
2088
2089         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
2090         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
2091         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
2092         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
2093
2094         __asm__ volatile (
2095             ".set push                                          \n\t"
2096             ".set noreorder                                     \n\t"
2097
2098             "ori        %[t4],      $zero,      12              \n\t"
2099             "ori        %[sign1],   $zero,      0               \n\t"
2100             "ori        %[sign2],   $zero,      0               \n\t"
2101             "slt        %[t0],      %[t4],      %[qc1]          \n\t"
2102             "slt        %[t1],      %[t4],      %[qc2]          \n\t"
2103             "slt        %[t2],      %[t4],      %[qc3]          \n\t"
2104             "slt        %[t3],      %[t4],      %[qc4]          \n\t"
2105             "movn       %[qc1],     %[t4],      %[t0]           \n\t"
2106             "movn       %[qc2],     %[t4],      %[t1]           \n\t"
2107             "movn       %[qc3],     %[t4],      %[t2]           \n\t"
2108             "movn       %[qc4],     %[t4],      %[t3]           \n\t"
2109             "lw         %[t0],      0(%[in_int])                \n\t"
2110             "lw         %[t1],      4(%[in_int])                \n\t"
2111             "lw         %[t2],      8(%[in_int])                \n\t"
2112             "lw         %[t3],      12(%[in_int])               \n\t"
2113             "slt        %[t0],      %[t0],      $zero           \n\t"
2114             "movn       %[sign1],   %[t0],      %[qc1]          \n\t"
2115             "slt        %[t2],      %[t2],      $zero           \n\t"
2116             "movn       %[sign2],   %[t2],      %[qc3]          \n\t"
2117             "slt        %[t1],      %[t1],      $zero           \n\t"
2118             "sll        %[t0],      %[sign1],   1               \n\t"
2119             "or         %[t0],      %[t0],      %[t1]           \n\t"
2120             "movn       %[sign1],   %[t0],      %[qc2]          \n\t"
2121             "slt        %[t3],      %[t3],      $zero           \n\t"
2122             "sll        %[t0],      %[sign2],   1               \n\t"
2123             "or         %[t0],      %[t0],      %[t3]           \n\t"
2124             "movn       %[sign2],   %[t0],      %[qc4]          \n\t"
2125             "slt        %[count1],  $zero,      %[qc1]          \n\t"
2126             "slt        %[t1],      $zero,      %[qc2]          \n\t"
2127             "slt        %[count2],  $zero,      %[qc3]          \n\t"
2128             "slt        %[t2],      $zero,      %[qc4]          \n\t"
2129             "addu       %[count1],  %[count1],  %[t1]           \n\t"
2130             "addu       %[count2],  %[count2],  %[t2]           \n\t"
2131
2132             ".set pop                                           \n\t"
2133
2134             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
2135               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
2136               [sign1]"=&r"(sign1), [count1]"=&r"(count1),
2137               [sign2]"=&r"(sign2), [count2]"=&r"(count2),
2138               [t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
2139               [t4]"=&r"(t4)
2140             : [in_int]"r"(in_int)
2141             : "memory"
2142         );
2143
2144         curidx = 13 * qc1;
2145         curidx += qc2;
2146
2147         curidx2 = 13 * qc3;
2148         curidx2 += qc4;
2149
2150         curbits += p_bits[curidx];
2151         curbits += p_bits[curidx2];
2152         curbits += upair12_sign_bits[curidx];
2153         curbits += upair12_sign_bits[curidx2];
2154         vec     = &p_codes[curidx*2];
2155         vec2    = &p_codes[curidx2*2];
2156
2157         qenergy += vec[0]*vec[0] + vec[1]*vec[1]
2158                 +  vec2[0]*vec2[0] + vec2[1]*vec2[1];
2159
2160         __asm__ volatile (
2161             ".set push                                          \n\t"
2162             ".set noreorder                                     \n\t"
2163
2164             "lwc1       %[di0],     0(%[in_pos])                \n\t"
2165             "lwc1       %[di1],     4(%[in_pos])                \n\t"
2166             "lwc1       %[di2],     8(%[in_pos])                \n\t"
2167             "lwc1       %[di3],     12(%[in_pos])               \n\t"
2168             "abs.s      %[di0],     %[di0]                      \n\t"
2169             "abs.s      %[di1],     %[di1]                      \n\t"
2170             "abs.s      %[di2],     %[di2]                      \n\t"
2171             "abs.s      %[di3],     %[di3]                      \n\t"
2172             "lwc1       $f0,        0(%[vec])                   \n\t"
2173             "lwc1       $f1,        4(%[vec])                   \n\t"
2174             "lwc1       $f2,        0(%[vec2])                  \n\t"
2175             "lwc1       $f3,        4(%[vec2])                  \n\t"
2176             "nmsub.s    %[di0],     %[di0],     $f0,    %[IQ]   \n\t"
2177             "nmsub.s    %[di1],     %[di1],     $f1,    %[IQ]   \n\t"
2178             "nmsub.s    %[di2],     %[di2],     $f2,    %[IQ]   \n\t"
2179             "nmsub.s    %[di3],     %[di3],     $f3,    %[IQ]   \n\t"
2180
2181             ".set pop                                           \n\t"
2182
2183             : [di0]"=&f"(di0), [di1]"=&f"(di1),
2184               [di2]"=&f"(di2), [di3]"=&f"(di3)
2185             : [in_pos]"r"(in_pos), [vec]"r"(vec),
2186               [vec2]"r"(vec2), [IQ]"f"(IQ)
2187             : "$f0", "$f1", "$f2", "$f3",
2188               "memory"
2189         );
2190
2191         cost += di0 * di0 + di1 * di1
2192                 + di2 * di2 + di3 * di3;
2193     }
2194
2195     if (bits)
2196         *bits = curbits;
2197     if (energy)
2198         *energy = qenergy * (IQ*IQ);
2199     return cost * lambda + curbits;
2200 }
2201
2202 static float get_band_cost_ESC_mips(struct AACEncContext *s,
2203                                     PutBitContext *pb, const float *in,
2204                                     const float *scaled, int size, int scale_idx,
2205                                     int cb, const float lambda, const float uplim,
2206                                     int *bits, float *energy)
2207 {
2208     const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
2209     const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
2210     const float CLIPPED_ESCAPE = 165140.0f * IQ;
2211     int i;
2212     float cost = 0;
2213     float qenergy = 0.0f;
2214     int qc1, qc2, qc3, qc4;
2215     int curbits = 0;
2216
2217     uint8_t *p_bits  = (uint8_t*)ff_aac_spectral_bits[cb-1];
2218     float   *p_codes = (float*  )ff_aac_codebook_vectors[cb-1];
2219
2220     for (i = 0; i < size; i += 4) {
2221         const float *vec, *vec2;
2222         int curidx, curidx2;
2223         float t1, t2, t3, t4, V;
2224         float di1, di2, di3, di4;
2225         int cond0, cond1, cond2, cond3;
2226         int c1, c2, c3, c4;
2227         int t6, t7;
2228
2229         qc1 = scaled[i  ] * Q34 + ROUND_STANDARD;
2230         qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
2231         qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
2232         qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
2233
2234         __asm__ volatile (
2235             ".set push                                  \n\t"
2236             ".set noreorder                             \n\t"
2237
2238             "ori        %[t6],      $zero,  15          \n\t"
2239             "ori        %[t7],      $zero,  16          \n\t"
2240             "shll_s.w   %[c1],      %[qc1], 18          \n\t"
2241             "shll_s.w   %[c2],      %[qc2], 18          \n\t"
2242             "shll_s.w   %[c3],      %[qc3], 18          \n\t"
2243             "shll_s.w   %[c4],      %[qc4], 18          \n\t"
2244             "srl        %[c1],      %[c1],  18          \n\t"
2245             "srl        %[c2],      %[c2],  18          \n\t"
2246             "srl        %[c3],      %[c3],  18          \n\t"
2247             "srl        %[c4],      %[c4],  18          \n\t"
2248             "slt        %[cond0],   %[t6],  %[qc1]      \n\t"
2249             "slt        %[cond1],   %[t6],  %[qc2]      \n\t"
2250             "slt        %[cond2],   %[t6],  %[qc3]      \n\t"
2251             "slt        %[cond3],   %[t6],  %[qc4]      \n\t"
2252             "movn       %[qc1],     %[t7],  %[cond0]    \n\t"
2253             "movn       %[qc2],     %[t7],  %[cond1]    \n\t"
2254             "movn       %[qc3],     %[t7],  %[cond2]    \n\t"
2255             "movn       %[qc4],     %[t7],  %[cond3]    \n\t"
2256
2257             ".set pop                                   \n\t"
2258
2259             : [qc1]"+r"(qc1), [qc2]"+r"(qc2),
2260               [qc3]"+r"(qc3), [qc4]"+r"(qc4),
2261               [cond0]"=&r"(cond0), [cond1]"=&r"(cond1),
2262               [cond2]"=&r"(cond2), [cond3]"=&r"(cond3),
2263               [c1]"=&r"(c1), [c2]"=&r"(c2),
2264               [c3]"=&r"(c3), [c4]"=&r"(c4),
2265               [t6]"=&r"(t6), [t7]"=&r"(t7)
2266         );
2267
2268         curidx = 17 * qc1;
2269         curidx += qc2;
2270
2271         curidx2 = 17 * qc3;
2272         curidx2 += qc4;
2273
2274         curbits += p_bits[curidx];
2275         curbits += esc_sign_bits[curidx];
2276         vec     = &p_codes[curidx*2];
2277
2278         curbits += p_bits[curidx2];
2279         curbits += esc_sign_bits[curidx2];
2280         vec2     = &p_codes[curidx2*2];
2281
2282         curbits += (av_log2(c1) * 2 - 3) & (-cond0);
2283         curbits += (av_log2(c2) * 2 - 3) & (-cond1);
2284         curbits += (av_log2(c3) * 2 - 3) & (-cond2);
2285         curbits += (av_log2(c4) * 2 - 3) & (-cond3);
2286
2287         t1 = fabsf(in[i  ]);
2288         t2 = fabsf(in[i+1]);
2289         t3 = fabsf(in[i+2]);
2290         t4 = fabsf(in[i+3]);
2291
2292         if (cond0) {
2293             if (t1 >= CLIPPED_ESCAPE) {
2294                 di1 = t1 - CLIPPED_ESCAPE;
2295                 qenergy += CLIPPED_ESCAPE*CLIPPED_ESCAPE;
2296             } else {
2297                 di1 = t1 - (V = c1 * cbrtf(c1) * IQ);
2298                 qenergy += V*V;
2299             }
2300         } else {
2301             di1 = t1 - (V = vec[0] * IQ);
2302             qenergy += V*V;
2303         }
2304
2305         if (cond1) {
2306             if (t2 >= CLIPPED_ESCAPE) {
2307                 di2 = t2 - CLIPPED_ESCAPE;
2308                 qenergy += CLIPPED_ESCAPE*CLIPPED_ESCAPE;
2309             } else {
2310                 di2 = t2 - (V = c2 * cbrtf(c2) * IQ);
2311                 qenergy += V*V;
2312             }
2313         } else {
2314             di2 = t2 - (V = vec[1] * IQ);
2315             qenergy += V*V;
2316         }
2317
2318         if (cond2) {
2319             if (t3 >= CLIPPED_ESCAPE) {
2320                 di3 = t3 - CLIPPED_ESCAPE;
2321                 qenergy += CLIPPED_ESCAPE*CLIPPED_ESCAPE;
2322             } else {
2323                 di3 = t3 - (V = c3 * cbrtf(c3) * IQ);
2324                 qenergy += V*V;
2325             }
2326         } else {
2327             di3 = t3 - (V = vec2[0] * IQ);
2328             qenergy += V*V;
2329         }
2330
2331         if (cond3) {
2332             if (t4 >= CLIPPED_ESCAPE) {
2333                 di4 = t4 - CLIPPED_ESCAPE;
2334                 qenergy += CLIPPED_ESCAPE*CLIPPED_ESCAPE;
2335             } else {
2336                 di4 = t4 - (V = c4 * cbrtf(c4) * IQ);
2337                 qenergy += V*V;
2338             }
2339         } else {
2340             di4 = t4 - (V = vec2[1]*IQ);
2341             qenergy += V*V;
2342         }
2343
2344         cost += di1 * di1 + di2 * di2
2345                 + di3 * di3 + di4 * di4;
2346     }
2347
2348     if (bits)
2349         *bits = curbits;
2350     return cost * lambda + curbits;
2351 }
2352
2353 static float (*const get_band_cost_arr[])(struct AACEncContext *s,
2354                                           PutBitContext *pb, const float *in,
2355                                           const float *scaled, int size, int scale_idx,
2356                                           int cb, const float lambda, const float uplim,
2357                                           int *bits, float *energy) = {
2358     get_band_cost_ZERO_mips,
2359     get_band_cost_SQUAD_mips,
2360     get_band_cost_SQUAD_mips,
2361     get_band_cost_UQUAD_mips,
2362     get_band_cost_UQUAD_mips,
2363     get_band_cost_SPAIR_mips,
2364     get_band_cost_SPAIR_mips,
2365     get_band_cost_UPAIR7_mips,
2366     get_band_cost_UPAIR7_mips,
2367     get_band_cost_UPAIR12_mips,
2368     get_band_cost_UPAIR12_mips,
2369     get_band_cost_ESC_mips,
2370     get_band_cost_NONE_mips, /* cb 12 doesn't exist */
2371     get_band_cost_ZERO_mips,
2372     get_band_cost_ZERO_mips,
2373     get_band_cost_ZERO_mips,
2374 };
2375
2376 #define get_band_cost(                                  \
2377                                 s, pb, in, scaled, size, scale_idx, cb, \
2378                                 lambda, uplim, bits, energy)            \
2379     get_band_cost_arr[cb](                              \
2380                                 s, pb, in, scaled, size, scale_idx, cb, \
2381                                 lambda, uplim, bits, energy)
2382
2383 static float quantize_band_cost(struct AACEncContext *s, const float *in,
2384                                 const float *scaled, int size, int scale_idx,
2385                                 int cb, const float lambda, const float uplim,
2386                                 int *bits, float *energy, int rtz)
2387 {
2388     return get_band_cost(s, NULL, in, scaled, size, scale_idx, cb, lambda, uplim, bits, energy);
2389 }
2390
2391 static float find_form_factor(int group_len, int swb_size, float thresh, const float *scaled, float nzslope) {
2392     const float iswb_size = 1.0f / swb_size;
2393     const float iswb_sizem1 = 1.0f / (swb_size - 1);
2394     const float ethresh = thresh, iethresh = 1.0f / ethresh;
2395     float form = 0.0f, weight = 0.0f;
2396     int w2, i;
2397     for (w2 = 0; w2 < group_len; w2++) {
2398         float e = 0.0f, e2 = 0.0f, var = 0.0f, maxval = 0.0f;
2399         float nzl = 0;
2400         for (i = 0; i < swb_size; i+=4) {
2401             float s1 = fabsf(scaled[w2*128+i  ]);
2402             float s2 = fabsf(scaled[w2*128+i+1]);
2403             float s3 = fabsf(scaled[w2*128+i+2]);
2404             float s4 = fabsf(scaled[w2*128+i+3]);
2405             maxval = FFMAX(maxval, FFMAX(FFMAX(s1, s2), FFMAX(s3, s4)));
2406             e += (s1+s2)+(s3+s4);
2407             s1 *= s1;
2408             s2 *= s2;
2409             s3 *= s3;
2410             s4 *= s4;
2411             e2 += (s1+s2)+(s3+s4);
2412             /* We really don't want a hard non-zero-line count, since
2413              * even below-threshold lines do add up towards band spectral power.
2414              * So, fall steeply towards zero, but smoothly
2415              */
2416             if (s1 >= ethresh) {
2417                 nzl += 1.0f;
2418             } else {
2419                 nzl += powf(s1 * iethresh, nzslope);
2420             }
2421             if (s2 >= ethresh) {
2422                 nzl += 1.0f;
2423             } else {
2424                 nzl += powf(s2 * iethresh, nzslope);
2425             }
2426             if (s3 >= ethresh) {
2427                 nzl += 1.0f;
2428             } else {
2429                 nzl += powf(s3 * iethresh, nzslope);
2430             }
2431             if (s4 >= ethresh) {
2432                 nzl += 1.0f;
2433             } else {
2434                 nzl += powf(s4 * iethresh, nzslope);
2435             }
2436         }
2437         if (e2 > thresh) {
2438             float frm;
2439             e *= iswb_size;
2440
2441             /** compute variance */
2442             for (i = 0; i < swb_size; i++) {
2443                 float d = fabsf(scaled[w2*128+i]) - e;
2444                 var += d*d;
2445             }
2446             var = sqrtf(var * iswb_sizem1);
2447
2448             e2 *= iswb_size;
2449             frm = e / FFMIN(e+4*var,maxval);
2450             form += e2 * sqrtf(frm) / FFMAX(0.5f,nzl);
2451             weight += e2;
2452         }
2453     }
2454     if (weight > 0) {
2455         return form / weight;
2456     } else {
2457         return 1.0f;
2458     }
2459 }
2460
2461 #include "libavcodec/aaccoder_twoloop.h"
2462
2463 static void search_for_ms_mips(AACEncContext *s, ChannelElement *cpe)
2464 {
2465     int start = 0, i, w, w2, g;
2466     float M[128], S[128];
2467     float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;
2468     const float lambda = s->lambda;
2469     SingleChannelElement *sce0 = &cpe->ch[0];
2470     SingleChannelElement *sce1 = &cpe->ch[1];
2471     if (!cpe->common_window)
2472         return;
2473     for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
2474         start = 0;
2475         for (g = 0;  g < sce0->ics.num_swb; g++) {
2476             if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {
2477                 float dist1 = 0.0f, dist2 = 0.0f;
2478                 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
2479                     FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];
2480                     FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];
2481                     float minthr = FFMIN(band0->threshold, band1->threshold);
2482                     float maxthr = FFMAX(band0->threshold, band1->threshold);
2483                     for (i = 0; i < sce0->ics.swb_sizes[g]; i+=4) {
2484                         M[i  ] = (sce0->coeffs[start+w2*128+i  ]
2485                                 + sce1->coeffs[start+w2*128+i  ]) * 0.5;
2486                         M[i+1] = (sce0->coeffs[start+w2*128+i+1]
2487                                 + sce1->coeffs[start+w2*128+i+1]) * 0.5;
2488                         M[i+2] = (sce0->coeffs[start+w2*128+i+2]
2489                                 + sce1->coeffs[start+w2*128+i+2]) * 0.5;
2490                         M[i+3] = (sce0->coeffs[start+w2*128+i+3]
2491                                 + sce1->coeffs[start+w2*128+i+3]) * 0.5;
2492
2493                         S[i  ] =  M[i  ]
2494                                 - sce1->coeffs[start+w2*128+i  ];
2495                         S[i+1] =  M[i+1]
2496                                 - sce1->coeffs[start+w2*128+i+1];
2497                         S[i+2] =  M[i+2]
2498                                 - sce1->coeffs[start+w2*128+i+2];
2499                         S[i+3] =  M[i+3]
2500                                 - sce1->coeffs[start+w2*128+i+3];
2501                    }
2502                     abs_pow34_v(L34, sce0->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);
2503                     abs_pow34_v(R34, sce1->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);
2504                     abs_pow34_v(M34, M,                         sce0->ics.swb_sizes[g]);
2505                     abs_pow34_v(S34, S,                         sce0->ics.swb_sizes[g]);
2506                     dist1 += quantize_band_cost(s, &sce0->coeffs[start + (w+w2)*128],
2507                                                 L34,
2508                                                 sce0->ics.swb_sizes[g],
2509                                                 sce0->sf_idx[(w+w2)*16+g],
2510                                                 sce0->band_type[(w+w2)*16+g],
2511                                                 lambda / band0->threshold, INFINITY, NULL, NULL, 0);
2512                     dist1 += quantize_band_cost(s, &sce1->coeffs[start + (w+w2)*128],
2513                                                 R34,
2514                                                 sce1->ics.swb_sizes[g],
2515                                                 sce1->sf_idx[(w+w2)*16+g],
2516                                                 sce1->band_type[(w+w2)*16+g],
2517                                                 lambda / band1->threshold, INFINITY, NULL, NULL, 0);
2518                     dist2 += quantize_band_cost(s, M,
2519                                                 M34,
2520                                                 sce0->ics.swb_sizes[g],
2521                                                 sce0->sf_idx[(w+w2)*16+g],
2522                                                 sce0->band_type[(w+w2)*16+g],
2523                                                 lambda / maxthr, INFINITY, NULL, NULL, 0);
2524                     dist2 += quantize_band_cost(s, S,
2525                                                 S34,
2526                                                 sce1->ics.swb_sizes[g],
2527                                                 sce1->sf_idx[(w+w2)*16+g],
2528                                                 sce1->band_type[(w+w2)*16+g],
2529                                                 lambda / minthr, INFINITY, NULL, NULL, 0);
2530                 }
2531                 cpe->ms_mask[w*16+g] = dist2 < dist1;
2532             }
2533             start += sce0->ics.swb_sizes[g];
2534         }
2535     }
2536 }
2537 #endif /*HAVE_MIPSFPU */
2538
2539 #include "libavcodec/aaccoder_trellis.h"
2540
2541 #endif /* HAVE_INLINE_ASM */
2542
2543 void ff_aac_coder_init_mips(AACEncContext *c) {
2544 #if HAVE_INLINE_ASM
2545     AACCoefficientsEncoder *e = c->coder;
2546     int option = c->options.aac_coder;
2547
2548     if (option == 2) {
2549         e->quantize_and_encode_band = quantize_and_encode_band_mips;
2550         e->encode_window_bands_info = codebook_trellis_rate;
2551 #if HAVE_MIPSFPU
2552         e->search_for_quantizers    = search_for_quantizers_twoloop;
2553 #endif /* HAVE_MIPSFPU */
2554     }
2555 #if HAVE_MIPSFPU
2556     e->search_for_ms            = search_for_ms_mips;
2557 #endif /* HAVE_MIPSFPU */
2558 #endif /* HAVE_INLINE_ASM */
2559 }