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