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 * Authors: Darko Laus (darko@mips.com)
30 * Djordje Pesut (djordje@mips.com)
31 * Mirjana Vulin (mvulin@mips.com)
32 *
33 * This file is part of FFmpeg.
34 *
35 * FFmpeg is free software; you can redistribute it and/or
36 * modify it under the terms of the GNU Lesser General Public
37 * License as published by the Free Software Foundation; either
38 * version 2.1 of the License, or (at your option) any later version.
39 *
40 * FFmpeg is distributed in the hope that it will be useful,
41 * but WITHOUT ANY WARRANTY; without even the implied warranty of
42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43 * Lesser General Public License for more details.
44 *
45 * You should have received a copy of the GNU Lesser General Public
46 * License along with FFmpeg; if not, write to the Free Software
47 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
48 */
49
50 /**
51 * @file
52 * Reference: libavcodec/aacdec.c
53 */
54
55 #include "libavcodec/aac.h"
56 #include "aacdec_mips.h"
57 #include "libavcodec/aactab.h"
58 #include "libavcodec/sinewin.h"
59 #include "libavutil/mips/asmdefs.h"
60
61 #if HAVE_INLINE_ASM
62 #if HAVE_MIPSFPU
float_copy(float * dst,const float * src,int count)63 static av_always_inline void float_copy(float *dst, const float *src, int count)
64 {
65 // Copy 'count' floats from src to dst
66 const float *loop_end = src + count;
67 int temp[8];
68
69 // count must be a multiple of 8
70 av_assert2(count % 8 == 0);
71
72 // loop unrolled 8 times
73 __asm__ volatile (
74 ".set push \n\t"
75 ".set noreorder \n\t"
76 "1: \n\t"
77 "lw %[temp0], 0(%[src]) \n\t"
78 "lw %[temp1], 4(%[src]) \n\t"
79 "lw %[temp2], 8(%[src]) \n\t"
80 "lw %[temp3], 12(%[src]) \n\t"
81 "lw %[temp4], 16(%[src]) \n\t"
82 "lw %[temp5], 20(%[src]) \n\t"
83 "lw %[temp6], 24(%[src]) \n\t"
84 "lw %[temp7], 28(%[src]) \n\t"
85 PTR_ADDIU "%[src], %[src], 32 \n\t"
86 "sw %[temp0], 0(%[dst]) \n\t"
87 "sw %[temp1], 4(%[dst]) \n\t"
88 "sw %[temp2], 8(%[dst]) \n\t"
89 "sw %[temp3], 12(%[dst]) \n\t"
90 "sw %[temp4], 16(%[dst]) \n\t"
91 "sw %[temp5], 20(%[dst]) \n\t"
92 "sw %[temp6], 24(%[dst]) \n\t"
93 "sw %[temp7], 28(%[dst]) \n\t"
94 "bne %[src], %[loop_end], 1b \n\t"
95 PTR_ADDIU "%[dst], %[dst], 32 \n\t"
96 ".set pop \n\t"
97
98 : [temp0]"=&r"(temp[0]), [temp1]"=&r"(temp[1]),
99 [temp2]"=&r"(temp[2]), [temp3]"=&r"(temp[3]),
100 [temp4]"=&r"(temp[4]), [temp5]"=&r"(temp[5]),
101 [temp6]"=&r"(temp[6]), [temp7]"=&r"(temp[7]),
102 [src]"+r"(src), [dst]"+r"(dst)
103 : [loop_end]"r"(loop_end)
104 : "memory"
105 );
106 }
107
lcg_random(unsigned previous_val)108 static av_always_inline int lcg_random(unsigned previous_val)
109 {
110 union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
111 return v.s;
112 }
113
imdct_and_windowing_mips(AACContext * ac,SingleChannelElement * sce)114 static void imdct_and_windowing_mips(AACContext *ac, SingleChannelElement *sce)
115 {
116 IndividualChannelStream *ics = &sce->ics;
117 float *in = sce->coeffs;
118 float *out = sce->ret;
119 float *saved = sce->saved;
120 const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
121 const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
122 const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
123 float *buf = ac->buf_mdct;
124 int i;
125
126 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
127 for (i = 0; i < 1024; i += 128)
128 ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
129 } else
130 ac->mdct.imdct_half(&ac->mdct, buf, in);
131
132 /* window overlapping
133 * NOTE: To simplify the overlapping code, all 'meaningless' short to long
134 * and long to short transitions are considered to be short to short
135 * transitions. This leaves just two cases (long to long and short to short)
136 * with a little special sauce for EIGHT_SHORT_SEQUENCE.
137 */
138 if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
139 (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
140 ac->fdsp->vector_fmul_window( out, saved, buf, lwindow_prev, 512);
141 } else {
142 float_copy(out, saved, 448);
143
144 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
145 {
146 float wi;
147 float wj;
148 int i;
149 float temp0, temp1, temp2, temp3;
150 float *dst0 = out + 448 + 0*128;
151 float *dst1 = dst0 + 64 + 63;
152 float *dst2 = saved + 63;
153 float *win0 = (float*)swindow;
154 float *win1 = win0 + 64 + 63;
155 float *win0_prev = (float*)swindow_prev;
156 float *win1_prev = win0_prev + 64 + 63;
157 float *src0_prev = saved + 448;
158 float *src1_prev = buf + 0*128 + 63;
159 float *src0 = buf + 0*128 + 64;
160 float *src1 = buf + 1*128 + 63;
161
162 for(i = 0; i < 64; i++)
163 {
164 temp0 = src0_prev[0];
165 temp1 = src1_prev[0];
166 wi = *win0_prev;
167 wj = *win1_prev;
168 temp2 = src0[0];
169 temp3 = src1[0];
170 dst0[0] = temp0 * wj - temp1 * wi;
171 dst1[0] = temp0 * wi + temp1 * wj;
172
173 wi = *win0;
174 wj = *win1;
175
176 temp0 = src0[128];
177 temp1 = src1[128];
178 dst0[128] = temp2 * wj - temp3 * wi;
179 dst1[128] = temp2 * wi + temp3 * wj;
180
181 temp2 = src0[256];
182 temp3 = src1[256];
183 dst0[256] = temp0 * wj - temp1 * wi;
184 dst1[256] = temp0 * wi + temp1 * wj;
185 dst0[384] = temp2 * wj - temp3 * wi;
186 dst1[384] = temp2 * wi + temp3 * wj;
187
188 temp0 = src0[384];
189 temp1 = src1[384];
190 dst0[512] = temp0 * wj - temp1 * wi;
191 dst2[0] = temp0 * wi + temp1 * wj;
192
193 src0++;
194 src1--;
195 src0_prev++;
196 src1_prev--;
197 win0++;
198 win1--;
199 win0_prev++;
200 win1_prev--;
201 dst0++;
202 dst1--;
203 dst2--;
204 }
205 }
206 } else {
207 ac->fdsp->vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, 64);
208 float_copy(out + 576, buf + 64, 448);
209 }
210 }
211
212 // buffer update
213 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
214 ac->fdsp->vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, swindow, 64);
215 ac->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
216 ac->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
217 float_copy(saved + 448, buf + 7*128 + 64, 64);
218 } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
219 float_copy(saved, buf + 512, 448);
220 float_copy(saved + 448, buf + 7*128 + 64, 64);
221 } else { // LONG_STOP or ONLY_LONG
222 float_copy(saved, buf + 512, 512);
223 }
224 }
225
apply_ltp_mips(AACContext * ac,SingleChannelElement * sce)226 static void apply_ltp_mips(AACContext *ac, SingleChannelElement *sce)
227 {
228 const LongTermPrediction *ltp = &sce->ics.ltp;
229 const uint16_t *offsets = sce->ics.swb_offset;
230 int i, sfb;
231 int j, k;
232
233 if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
234 float *predTime = sce->ret;
235 float *predFreq = ac->buf_mdct;
236 float *p_predTime;
237 int16_t num_samples = 2048;
238
239 if (ltp->lag < 1024)
240 num_samples = ltp->lag + 1024;
241 j = (2048 - num_samples) >> 2;
242 k = (2048 - num_samples) & 3;
243 p_predTime = &predTime[num_samples];
244
245 for (i = 0; i < num_samples; i++)
246 predTime[i] = sce->ltp_state[i + 2048 - ltp->lag] * ltp->coef;
247 for (i = 0; i < j; i++) {
248
249 /* loop unrolled 4 times */
250 __asm__ volatile (
251 "sw $0, 0(%[p_predTime]) \n\t"
252 "sw $0, 4(%[p_predTime]) \n\t"
253 "sw $0, 8(%[p_predTime]) \n\t"
254 "sw $0, 12(%[p_predTime]) \n\t"
255 PTR_ADDIU "%[p_predTime], %[p_predTime], 16 \n\t"
256
257 : [p_predTime]"+r"(p_predTime)
258 :
259 : "memory"
260 );
261 }
262 for (i = 0; i < k; i++) {
263
264 __asm__ volatile (
265 "sw $0, 0(%[p_predTime]) \n\t"
266 PTR_ADDIU "%[p_predTime], %[p_predTime], 4 \n\t"
267
268 : [p_predTime]"+r"(p_predTime)
269 :
270 : "memory"
271 );
272 }
273
274 ac->windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
275
276 if (sce->tns.present)
277 ac->apply_tns(predFreq, &sce->tns, &sce->ics, 0);
278
279 for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
280 if (ltp->used[sfb])
281 for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
282 sce->coeffs[i] += predFreq[i];
283 }
284 }
285
fmul_and_reverse(float * dst,const float * src0,const float * src1,int count)286 static av_always_inline void fmul_and_reverse(float *dst, const float *src0, const float *src1, int count)
287 {
288 /* Multiply 'count' floats in src0 by src1 and store the results in dst in reverse */
289 /* This should be equivalent to a normal fmul, followed by reversing dst */
290
291 // count must be a multiple of 4
292 av_assert2(count % 4 == 0);
293
294 // move src0 and src1 to the last element of their arrays
295 src0 += count - 1;
296 src1 += count - 1;
297
298 for (; count > 0; count -= 4){
299 float temp[12];
300
301 /* loop unrolled 4 times */
302 __asm__ volatile (
303 "lwc1 %[temp0], 0(%[ptr2]) \n\t"
304 "lwc1 %[temp1], -4(%[ptr2]) \n\t"
305 "lwc1 %[temp2], -8(%[ptr2]) \n\t"
306 "lwc1 %[temp3], -12(%[ptr2]) \n\t"
307 "lwc1 %[temp4], 0(%[ptr3]) \n\t"
308 "lwc1 %[temp5], -4(%[ptr3]) \n\t"
309 "lwc1 %[temp6], -8(%[ptr3]) \n\t"
310 "lwc1 %[temp7], -12(%[ptr3]) \n\t"
311 "mul.s %[temp8], %[temp0], %[temp4] \n\t"
312 "mul.s %[temp9], %[temp1], %[temp5] \n\t"
313 "mul.s %[temp10], %[temp2], %[temp6] \n\t"
314 "mul.s %[temp11], %[temp3], %[temp7] \n\t"
315 "swc1 %[temp8], 0(%[ptr1]) \n\t"
316 "swc1 %[temp9], 4(%[ptr1]) \n\t"
317 "swc1 %[temp10], 8(%[ptr1]) \n\t"
318 "swc1 %[temp11], 12(%[ptr1]) \n\t"
319 PTR_ADDIU "%[ptr1], %[ptr1], 16 \n\t"
320 PTR_ADDIU "%[ptr2], %[ptr2], -16 \n\t"
321 PTR_ADDIU "%[ptr3], %[ptr3], -16 \n\t"
322
323 : [temp0]"=&f"(temp[0]), [temp1]"=&f"(temp[1]),
324 [temp2]"=&f"(temp[2]), [temp3]"=&f"(temp[3]),
325 [temp4]"=&f"(temp[4]), [temp5]"=&f"(temp[5]),
326 [temp6]"=&f"(temp[6]), [temp7]"=&f"(temp[7]),
327 [temp8]"=&f"(temp[8]), [temp9]"=&f"(temp[9]),
328 [temp10]"=&f"(temp[10]), [temp11]"=&f"(temp[11]),
329 [ptr1]"+r"(dst), [ptr2]"+r"(src0), [ptr3]"+r"(src1)
330 :
331 : "memory"
332 );
333 }
334 }
335
update_ltp_mips(AACContext * ac,SingleChannelElement * sce)336 static void update_ltp_mips(AACContext *ac, SingleChannelElement *sce)
337 {
338 IndividualChannelStream *ics = &sce->ics;
339 float *saved = sce->saved;
340 float *saved_ltp = sce->coeffs;
341 const float *lwindow = ics->use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
342 const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
343 uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
344
345 if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
346 float *p_saved_ltp = saved_ltp + 576;
347 float *loop_end1 = p_saved_ltp + 448;
348
349 float_copy(saved_ltp, saved, 512);
350
351 /* loop unrolled 8 times */
352 __asm__ volatile (
353 "1: \n\t"
354 "sw $0, 0(%[p_saved_ltp]) \n\t"
355 "sw $0, 4(%[p_saved_ltp]) \n\t"
356 "sw $0, 8(%[p_saved_ltp]) \n\t"
357 "sw $0, 12(%[p_saved_ltp]) \n\t"
358 "sw $0, 16(%[p_saved_ltp]) \n\t"
359 "sw $0, 20(%[p_saved_ltp]) \n\t"
360 "sw $0, 24(%[p_saved_ltp]) \n\t"
361 "sw $0, 28(%[p_saved_ltp]) \n\t"
362 PTR_ADDIU "%[p_saved_ltp],%[p_saved_ltp], 32 \n\t"
363 "bne %[p_saved_ltp], %[loop_end1], 1b \n\t"
364
365 : [p_saved_ltp]"+r"(p_saved_ltp)
366 : [loop_end1]"r"(loop_end1)
367 : "memory"
368 );
369
370 ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
371 fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 960, swindow, 64);
372 } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
373 float *buff0 = saved;
374 float *buff1 = saved_ltp;
375 float *loop_end = saved + 448;
376
377 /* loop unrolled 8 times */
378 __asm__ volatile (
379 ".set push \n\t"
380 ".set noreorder \n\t"
381 "1: \n\t"
382 "lw %[temp0], 0(%[src]) \n\t"
383 "lw %[temp1], 4(%[src]) \n\t"
384 "lw %[temp2], 8(%[src]) \n\t"
385 "lw %[temp3], 12(%[src]) \n\t"
386 "lw %[temp4], 16(%[src]) \n\t"
387 "lw %[temp5], 20(%[src]) \n\t"
388 "lw %[temp6], 24(%[src]) \n\t"
389 "lw %[temp7], 28(%[src]) \n\t"
390 PTR_ADDIU "%[src], %[src], 32 \n\t"
391 "sw %[temp0], 0(%[dst]) \n\t"
392 "sw %[temp1], 4(%[dst]) \n\t"
393 "sw %[temp2], 8(%[dst]) \n\t"
394 "sw %[temp3], 12(%[dst]) \n\t"
395 "sw %[temp4], 16(%[dst]) \n\t"
396 "sw %[temp5], 20(%[dst]) \n\t"
397 "sw %[temp6], 24(%[dst]) \n\t"
398 "sw %[temp7], 28(%[dst]) \n\t"
399 "sw $0, 2304(%[dst]) \n\t"
400 "sw $0, 2308(%[dst]) \n\t"
401 "sw $0, 2312(%[dst]) \n\t"
402 "sw $0, 2316(%[dst]) \n\t"
403 "sw $0, 2320(%[dst]) \n\t"
404 "sw $0, 2324(%[dst]) \n\t"
405 "sw $0, 2328(%[dst]) \n\t"
406 "sw $0, 2332(%[dst]) \n\t"
407 "bne %[src], %[loop_end], 1b \n\t"
408 PTR_ADDIU "%[dst], %[dst], 32 \n\t"
409 ".set pop \n\t"
410
411 : [temp0]"=&r"(temp0), [temp1]"=&r"(temp1),
412 [temp2]"=&r"(temp2), [temp3]"=&r"(temp3),
413 [temp4]"=&r"(temp4), [temp5]"=&r"(temp5),
414 [temp6]"=&r"(temp6), [temp7]"=&r"(temp7),
415 [src]"+r"(buff0), [dst]"+r"(buff1)
416 : [loop_end]"r"(loop_end)
417 : "memory"
418 );
419 ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
420 fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 960, swindow, 64);
421 } else { // LONG_STOP or ONLY_LONG
422 ac->fdsp->vector_fmul_reverse(saved_ltp, ac->buf_mdct + 512, &lwindow[512], 512);
423 fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 512, lwindow, 512);
424 }
425
426 float_copy(sce->ltp_state, sce->ltp_state + 1024, 1024);
427 float_copy(sce->ltp_state + 1024, sce->ret, 1024);
428 float_copy(sce->ltp_state + 2048, saved_ltp, 1024);
429 }
430 #endif /* HAVE_MIPSFPU */
431 #endif /* HAVE_INLINE_ASM */
432
ff_aacdec_init_mips(AACContext * c)433 void ff_aacdec_init_mips(AACContext *c)
434 {
435 #if HAVE_INLINE_ASM
436 #if HAVE_MIPSFPU
437 c->imdct_and_windowing = imdct_and_windowing_mips;
438 c->apply_ltp = apply_ltp_mips;
439 c->update_ltp = update_ltp_mips;
440 #endif /* HAVE_MIPSFPU */
441 #endif /* HAVE_INLINE_ASM */
442 }
443