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