cast ssize_t to long
[kugel-rb.git] / apps / dsp_arm.S
blob2150ff0631d90d73e515de640ffdf31aa16a17dc
1 /***************************************************************************
2  *             __________               __   ___.
3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
7  *                     \/            \/     \/    \/            \/
8  * $Id$
9  *
10  * Copyright (C) 2006-2007 Thom Johansen
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  *
17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18  * KIND, either express or implied.
19  *
20  ****************************************************************************/
21  #include "config.h"
23 /****************************************************************************
24  *  void channels_process_sound_chan_mono(int count, int32_t *buf[])
25  */
26     .section .icode, "ax", %progbits
27     .align  2
28     .global channels_process_sound_chan_mono
29     .type   channels_process_sound_chan_mono, %function
30 channels_process_sound_chan_mono:
31     @ input: r0 = count, r1 = buf
32     stmfd   sp!, { r4, lr }            @
33                                        @
34     ldmia   r1, { r1, r2 }             @ r1 = buf[0], r2 = buf[1]
35     subs    r0, r0, #1                 @ odd: end at 0; even: end at -1
36     beq     .mono_singlesample         @ Zero? Only one sample!
37                                        @
38 .monoloop:                             @
39     ldmia   r1, { r3, r4 }             @ r3, r4 = Li0, Li1
40     ldmia   r2, { r12, r14 }           @ r12, r14 = Ri0, Ri1
41     mov     r3, r3, asr #1             @ Mo0 = Li0 / 2 + Ri0 / 2
42     mov     r4, r4, asr #1             @ Mo1 = Li1 / 2 + Ri1 / 2
43     add     r12, r3, r12, asr #1       @
44     add     r14, r4, r14, asr #1       @
45     subs    r0, r0, #2                 @
46     stmia   r1!, { r12, r14 }          @ store Mo0, Mo1
47     stmia   r2!, { r12, r14 }          @ store Mo0, Mo1
48     bgt     .monoloop                  @
49                                        @
50     ldmltfd sp!, { r4, pc }            @ if count was even, we're done
51                                        @
52 .mono_singlesample:                    @
53     ldr     r3, [r1]                   @ r3 = Ls
54     ldr     r12, [r2]                  @ r12 = Rs
55     mov     r3, r3, asr #1             @ Mo = Ls / 2 + Rs / 2
56     add     r12, r3, r12, asr #1       @
57     str     r12, [r1]                  @ store Mo
58     str     r12, [r2]                  @ store Mo
59                                        @
60     ldmfd   sp!, { r4, pc }            @
61     .size   channels_process_sound_chan_mono, \
62                 .-channels_process_sound_chan_mono
64 /****************************************************************************
65  * void channels_process_sound_chan_custom(int count, int32_t *buf[])
66  */
67     .section .icode, "ax", %progbits
68     .align  2
69     .global channels_process_sound_chan_custom
70     .type   channels_process_sound_chan_custom, %function
71 channels_process_sound_chan_custom:
72     stmfd   sp!, { r4-r10, lr }
73     
74     ldr     r3, =dsp_sw_gain
75     ldr     r4, =dsp_sw_cross
77     ldmia   r1, { r1, r2 }             @ r1 = buf[0], r2 = buf[1]
78     ldr     r3, [r3]                   @ r3 = dsp_sw_gain
79     ldr     r4, [r4]                   @ r4 = dsp_sw_cross
80     
81     subs    r0, r0, #1
82     beq     .custom_single_sample      @ Zero? Only one sample!
83     
84 .custom_loop:
85     ldmia   r1, { r5, r6 }             @ r5 = Li0, r6 = Li1
86     ldmia   r2, { r7, r8 }             @ r7 = Ri0, r8 = Ri1
88     subs    r0, r0, #2
90     smull   r9, r10, r5, r3            @ Lc0 = Li0*gain
91     smull   r12, r14, r7, r3           @ Rc0 = Ri0*gain
92     smlal   r9, r10, r7, r4            @ Lc0 += Ri0*cross
93     smlal   r12, r14, r5, r4           @ Rc0 += Li0*cross
94     
95     mov     r9, r9, lsr #31            @ Convert to s0.31
96     mov     r12, r12, lsr #31
97     orr     r5, r9, r10, asl #1
98     orr     r7, r12, r14, asl #1
99     
100     smull   r9, r10, r6, r3            @ Lc1 = Li1*gain
101     smull   r12, r14, r8, r3           @ Rc1 = Ri1*gain
102     smlal   r9, r10, r8, r4            @ Lc1 += Ri1*cross
103     smlal   r12, r14, r6, r4           @ Rc1 += Li1*cross
104     
105     mov     r9, r9, lsr #31            @ Convert to s0.31
106     mov     r12, r12, lsr #31
107     orr     r6, r9, r10, asl #1
108     orr     r8, r12, r14, asl #1
109     
110     stmia   r1!, { r5, r6 }            @ Store Lc0, Lc1
111     stmia   r2!, { r7, r8 }            @ Store Rc0, Rc1
113     bgt     .custom_loop
114     
115     ldmltfd sp!, { r4-r10, pc }        @ < 0? even count
116     
117 .custom_single_sample:
118     ldr     r5, [r1]                   @ handle odd sample
119     ldr     r7, [r2]
121     smull   r9, r10, r5, r3            @ Lc0 = Li0*gain
122     smull   r12, r14, r7, r3           @ Rc0 = Ri0*gain
123     smlal   r9, r10, r7, r4            @ Lc0 += Ri0*cross
124     smlal   r12, r14, r5, r4           @ Rc0 += Li0*cross
126     mov     r9, r9, lsr #31            @ Convert to s0.31
127     mov     r12, r12, lsr #31
128     orr     r5, r9, r10, asl #1
129     orr     r7, r12, r14, asl #1
131     str     r5, [r1]                   @ Store Lc0
132     str     r7, [r2]                   @ Store Rc0
134     ldmfd   sp!, { r4-r10, pc }
135     .size   channels_process_sound_chan_custom, \
136                 .-channels_process_sound_chan_custom
138 /****************************************************************************
139  *  void channels_process_sound_chan_karaoke(int count, int32_t *buf[])
140  */
141     .section .icode, "ax", %progbits
142     .align  2
143     .global channels_process_sound_chan_karaoke
144     .type   channels_process_sound_chan_karaoke, %function
145 channels_process_sound_chan_karaoke:
146     @ input: r0 = count, r1 = buf
147     stmfd   sp!, { r4, lr }            @
148                                        @
149     ldmia   r1, { r1, r2 }             @ r1 = buf[0], r2 = buf[1]
150     subs    r0, r0, #1                 @ odd: end at 0; even: end at -1
151     beq     .karaoke_singlesample      @ Zero? Only one sample!
152                                        @
153 .karaokeloop:                          @
154     ldmia   r1, { r3, r4 }             @ r3, r4  = Li0, Li1
155     ldmia   r2, { r12, r14 }           @ r12, r14 = Ri0, Ri1
156     mov     r3, r3, asr #1             @ Lo0 = Li0 / 2 - Ri0 / 2
157     mov     r4, r4, asr #1             @ Lo1 = Li1 / 2 - Ri1 / 2
158     sub     r3, r3, r12, asr #1        @
159     sub     r4, r4, r14, asr #1        @
160     rsb     r12, r3, #0                @ Ro0 = -Lk0 = Rs0 / 2 - Ls0 / 2
161     rsb     r14, r4, #0                @ Ro1 = -Lk1 = Ri1 / 2 - Li1 / 2
162     subs    r0, r0, #2                 @
163     stmia   r1!, { r3, r4 }            @ store Lo0, Lo1
164     stmia   r2!, { r12, r14 }          @ store Ro0, Ro1
165     bgt     .karaokeloop               @
166                                        @
167     ldmltfd sp!, { r4, pc }            @ if count was even, we're done
168                                        @
169 .karaoke_singlesample:                 @
170     ldr     r3, [r1]                   @ r3 = Li
171     ldr     r12, [r2]                  @ r12 = Ri
172     mov     r3, r3, asr #1             @ Lk = Li / 2 - Ri /2
173     sub     r3, r3, r12, asr #1        @
174     rsb     r12, r3, #0                @ Rk = -Lo = Ri / 2 - Li / 2
175     str     r3, [r1]                   @ store Lo
176     str     r12, [r2]                  @ store Ro
177                                        @
178     ldmfd   sp!, { r4, pc }            @
179     .size   channels_process_sound_chan_karaoke, \
180                 .-channels_process_sound_chan_karaoke
182 #if ARM_ARCH < 6
183 /****************************************************************************
184  *  void sample_output_mono(int count, struct dsp_data *data,
185  *                          const int32_t *src[], int16_t *dst)
186  */
187     .section .icode, "ax", %progbits
188     .align  2
189     .global sample_output_mono
190     .type   sample_output_mono, %function
191 sample_output_mono:
192     @ input: r0 = count, r1 = data, r2 = src, r3 = dst
193     stmfd   sp!, { r4-r6, lr }
195     ldr     r1, [r1]                   @ lr = data->output_scale
196     ldr     r2, [r2]                   @ r2 = src[0]
198     mov     r4, #1
199     mov     r4, r4, lsl r1             @ r4 = 1 << (scale-1)
200     mov     r4, r4, lsr #1
201     mvn     r14, #0x8000               @ r14 = 0xffff7fff, needed for
202                                        @ clipping and masking
203     subs    r0, r0, #1                 @
204     beq     .som_singlesample          @ Zero? Only one sample!
206 .somloop:
207     ldmia   r2!, { r5, r6 }
208     add     r5, r5, r4                 @ r6 = (r6 + 1<<(scale-1)) >> scale
209     mov     r5, r5, asr r1
210     mov     r12, r5, asr #15
211     teq     r12, r12, asr #31
212     eorne   r5, r14, r5, asr #31       @ Clip (-32768...+32767)
213     add     r6, r6, r4
214     mov     r6, r6, asr r1             @ r7 = (r7 + 1<<(scale-1)) >> scale
215     mov     r12, r6, asr #15
216     teq     r12, r12, asr #31
217     eorne   r6, r14, r6, asr #31       @ Clip (-32768...+32767)
218     
219     and     r5, r5, r14, lsr #16
220     and     r6, r6, r14, lsr #16
221     orr     r5, r5, r5, lsl #16        @ pack first 2 halfwords into 1 word
222     orr     r6, r6, r6, lsl #16        @ pack last 2 halfwords into 1 word
223     stmia   r3!, { r5, r6 }
224     
225     subs    r0, r0, #2
226     bgt     .somloop     
227        
228     ldmltfd sp!, { r4-r6, pc }         @ even 'count'? return
230 .som_singlesample:
231     ldr     r5, [r2]                   @ do odd sample
232     add     r5, r5, r4
233     mov     r5, r5, asr r1
234     mov     r12, r5, asr #15
235     teq     r12, r12, asr #31
236     eorne   r5, r14, r5, asr #31
238     and     r5, r5, r14, lsr #16       @ pack 2 halfwords into 1 word
239     orr     r5, r5, r5, lsl #16
240     str     r5, [r3]
242     ldmfd   sp!, { r4-r6, pc }
243     .size   sample_output_mono, .-sample_output_mono
244     
245 /****************************************************************************
246  * void sample_output_stereo(int count, struct dsp_data *data,
247  *                           const int32_t *src[], int16_t *dst)
248  */
249     .section .icode, "ax", %progbits
250     .align  2
251     .global sample_output_stereo
252     .type   sample_output_stereo, %function
253 sample_output_stereo:
254     @ input: r0 = count, r1 = data, r2 = src, r3 = dst
255     stmfd   sp!, { r4-r9, lr }
257     ldr     r1, [r1]                   @ r1 = data->output_scale
258     ldmia   r2, { r2, r5 }             @ r2 = src[0], r5 = src[1]
260     mov     r4, #1
261     mov     r4, r4, lsl r1             @ r4 = 1 << (scale-1)
262     mov     r4, r4, lsr #1             @
263     
264     mvn     r14, #0x8000               @ r14 = 0xffff7fff, needed for
265                                        @ clipping and masking
266     subs    r0, r0, #1                 @
267     beq     .sos_singlesample          @ Zero? Only one sample!
269 .sosloop:
270     ldmia   r2!, { r6, r7 }            @ 2 left
271     ldmia   r5!, { r8, r9 }            @ 2 right
273     add     r6, r6, r4                 @ r6 = (r6 + 1<<(scale-1)) >> scale
274     mov     r6, r6, asr r1
275     mov     r12, r6, asr #15
276     teq     r12, r12, asr #31
277     eorne   r6, r14, r6, asr #31       @ Clip (-32768...+32767)
278     add     r7, r7, r4
279     mov     r7, r7, asr r1             @ r7 = (r7 + 1<<(scale-1)) >> scale
280     mov     r12, r7, asr #15
281     teq     r12, r12, asr #31
282     eorne   r7, r14, r7, asr #31       @ Clip (-32768...+32767)
283     
284     add     r8, r8, r4                 @ r8 = (r8 + 1<<(scale-1)) >> scale
285     mov     r8, r8, asr r1
286     mov     r12, r8, asr #15
287     teq     r12, r12, asr #31
288     eorne   r8, r14, r8, asr #31       @ Clip (-32768...+32767)
289     add     r9, r9, r4                 @ r9 = (r9 + 1<<(scale-1)) >> scale
290     mov     r9, r9, asr r1
291     mov     r12, r9, asr #15
292     teq     r12, r12, asr #31
293     eorne   r9, r14, r9, asr #31       @ Clip (-32768...+32767)
294     
295     and     r6, r6, r14, lsr #16       @ pack first 2 halfwords into 1 word
296     orr     r8, r6, r8, asl #16
297     and     r7, r7, r14, lsr #16       @ pack last 2 halfwords into 1 word
298     orr     r9, r7, r9, asl #16
300     stmia   r3!, { r8, r9 }
302     subs    r0, r0, #2
303     bgt     .sosloop
305     ldmltfd sp!, { r4-r9, pc }         @ even 'count'? return
307 .sos_singlesample:    
308     ldr     r6, [r2]                   @ left odd sample
309     ldr     r8, [r5]                   @ right odd sample
311     add     r6, r6, r4                 @ r6 = (r7 + 1<<(scale-1)) >> scale
312     mov     r6, r6, asr r1
313     mov     r12, r6, asr #15
314     teq     r12, r12, asr #31
315     eorne   r6, r14, r6, asr #31       @ Clip (-32768...+32767)
316     add     r8, r8, r4                 @ r8 = (r8 + 1<<(scale-1)) >> scale
317     mov     r8, r8, asr r1
318     mov     r12, r8, asr #15
319     teq     r12, r12, asr #31
320     eorne   r8, r14, r8, asr #31       @ Clip (-32768...+32767)
321     
322     and     r6, r6, r14, lsr #16       @ pack 2 halfwords into 1 word
323     orr     r8, r6, r8, asl #16
325     str     r8, [r3]
327     ldmfd   sp!, { r4-r9, pc }
328     .size   sample_output_stereo, .-sample_output_stereo
329 #endif /* ARM_ARCH < 6 */    
331 /****************************************************************************
332  * void apply_crossfeed(int count, int32_t* src[])
333  */
334     .section .text
335     .global apply_crossfeed 
336 apply_crossfeed:
337     @ unfortunately, we ended up in a bit of a register squeeze here, and need
338     @ to keep the count on the stack :/
339     stmdb   sp!, { r4-r11, lr }        @ stack modified regs
340     ldmia   r1, { r2-r3 }              @ r2 = src[0], r3 = src[1]
341     
342     ldr     r1, =crossfeed_data
343     ldmia   r1!, { r4-r11 }            @ load direct gain and filter data
344     mov     r12, r0                    @ better to ldm delay + count later
345     add     r0, r1, #13*4*2            @ calculate end of delay
346     stmdb   sp!, { r0, r12 }           @ stack end of delay adr and count
347     ldr     r0, [r1, #13*4*2]          @ fetch current delay line address
349     /* Register usage in loop:
350      * r0 = &delay[index][0], r1 = accumulator high, r2 = src[0], r3 = src[1],
351      * r4 = direct gain, r5-r7 = b0, b1, a1 (filter coefs),
352      * r8-r11 = filter history, r12 = temp, r14 = accumulator low
353      */
354 .cfloop:
355     smull   r14, r1, r6, r8            @ acc = b1*dr[n - 1]
356     smlal   r14, r1, r7, r9            @ acc += a1*y_l[n - 1]
357     ldr     r8, [r0, #4]               @ r8 = dr[n]
358     smlal   r14, r1, r5, r8            @ acc += b0*dr[n]
359     mov     r9, r1, lsl #1             @ fix format for filter history
360     ldr     r12, [r2]                  @ load left input
361     smlal   r14, r1, r4, r12           @ acc += gain*x_l[n] 
362     mov     r1, r1, lsl #1             @ fix format
363     str     r1, [r2], #4               @ save result
365     smull   r14, r1, r6, r10           @ acc = b1*dl[n - 1]
366     smlal   r14, r1, r7, r11           @ acc += a1*y_r[n - 1]
367     ldr     r10, [r0]                  @ r10 = dl[n]
368     str     r12, [r0], #4              @ save left input to delay line
369     smlal   r14, r1, r5, r10           @ acc += b0*dl[n]
370     mov     r11, r1, lsl #1            @ fix format for filter history
371     ldr     r12, [r3]                  @ load right input
372     smlal   r14, r1, r4, r12           @ acc += gain*x_r[n]
373     str     r12, [r0], #4              @ save right input to delay line
374     mov     r1, r1, lsl #1             @ fix format
375     ldmia   sp, { r12, r14 }           @ fetch delay line end addr and count from stack
376     str     r1, [r3], #4               @ save result
378     cmp     r0, r12                    @ need to wrap to start of delay?
379     subeq   r0, r0, #13*4*2            @ wrap back delay line ptr to start
381     subs    r14, r14, #1               @ are we finished?
382     strne   r14, [sp, #4]              @ nope, save count back to stack
383     bne     .cfloop
384     
385     @ save data back to struct
386     ldr     r12, =crossfeed_data + 4*4
387     stmia   r12, { r8-r11 }            @ save filter history
388     str     r0, [r12, #30*4]           @ save delay line index
389     add     sp, sp, #8                 @ remove temp variables from stack
390     ldmia   sp!, { r4-r11, pc }
391     .size   apply_crossfeed, .-apply_crossfeed
393 /****************************************************************************
394  * int dsp_downsample(int count, struct dsp_data *data,
395  *                    in32_t *src[], int32_t *dst[])
396  */
397     .section    .text
398     .global     dsp_downsample
399 dsp_downsample:
400     stmdb   sp!, { r4-r11, lr }     @ stack modified regs
401     ldmib   r1, { r5-r6 }           @ r5 = num_channels,r6 = resample_data.delta
402     sub     r5, r5, #1              @ pre-decrement num_channels for use
403     add     r4, r1, #12             @ r4 = &resample_data.phase
404     mov     r12, #0xff
405     orr     r12, r12, #0xff00       @ r12 = 0xffff
406 .dschannel_loop:
407     ldr     r1, [r4]                @ r1 = resample_data.phase
408     ldr     r7, [r2, r5, lsl #2]    @ r7 = s = src[ch - 1]
409     ldr     r8, [r3, r5, lsl #2]    @ r8 = d = dst[ch - 1]
410     add     r9, r4, #4              @ r9 = &last_sample[0]
411     ldr     r10, [r9, r5, lsl #2]   @ r10 = last_sample[ch - 1]
412     sub     r11, r0, #1             
413     ldr     r14, [r7, r11, lsl #2]  @ load last sample in s[] ...
414     str     r14, [r9, r5, lsl #2]   @ and write as next frame's last_sample
415     movs    r9, r1, lsr #16         @ r9 = pos = phase >> 16
416     ldreq   r11, [r7]               @ if pos = 0, load src[0] and jump into loop
417     beq     .dsuse_last_start
418     cmp     r9, r0                  @ if pos >= count, we're already done
419     bge     .dsloop_skip
421     @ Register usage in loop:
422     @ r0 = count, r1 = phase, r4 = &resample_data.phase, r5 = cur_channel,
423     @ r6 = delta, r7 = s, r8 = d, r9 = pos, r10 = s[pos - 1], r11 = s[pos]
424 .dsloop:
425     add     r9, r7, r9, lsl #2      @ r9 = &s[pos]
426     ldmda   r9, { r10, r11 }        @ r10 = s[pos - 1], r11 = s[pos]
427 .dsuse_last_start:
428     sub     r11, r11, r10           @ r11 = diff = s[pos] - s[pos - 1]
429     @ keep frac in lower bits to take advantage of multiplier early termination
430     and     r9, r1, r12             @ frac = phase & 0xffff
431     smull   r9, r14, r11, r9
432     add     r1, r1, r6              @ phase += delta
433     add     r10, r10, r9, lsr #16   @ r10 = out = s[pos - 1] + frac*diff
434     add     r10, r10, r14, lsl #16
435     str     r10, [r8], #4           @ *d++ = out
436     mov     r9, r1, lsr #16         @ pos = phase >> 16
437     cmp     r9, r0                  @ pos < count?
438     blt     .dsloop                 @ yup, do more samples
439 .dsloop_skip:
440     subs    r5, r5, #1
441     bpl     .dschannel_loop         @ if (--ch) >= 0, do another channel
442     sub     r1, r1, r0, lsl #16     @ wrap phase back to start
443     str     r1, [r4]                @ store back
444     ldr     r1, [r3]                @ r1 = &dst[0]
445     sub     r8, r8, r1              @ dst - &dst[0]
446     mov     r0, r8, lsr #2          @ convert bytes->samples
447     ldmia   sp!, { r4-r11, pc }     @ ... and we're out
448     .size   dsp_downsample, .-dsp_downsample
450 /****************************************************************************
451  * int dsp_upsample(int count, struct dsp_data *dsp,
452  *                  in32_t *src[], int32_t *dst[])
453  */
454     .section    .text
455     .global     dsp_upsample
456 dsp_upsample:
457     stmfd   sp!, { r4-r11, lr }     @ stack modified regs
458     ldmib   r1, { r5-r6 }           @ r5 = num_channels,r6 = resample_data.delta
459     sub     r5, r5, #1              @ pre-decrement num_channels for use
460     add     r4, r1, #12             @ r4 = &resample_data.phase
461     mov     r6, r6, lsl #16         @ we'll use carry to detect pos increments
462     stmfd   sp!, { r0, r4 }         @ stack count and &resample_data.phase
463 .uschannel_loop:
464     ldr     r12, [r4]               @ r12 = resample_data.phase
465     ldr     r7, [r2, r5, lsl #2]    @ r7 = s = src[ch - 1]
466     ldr     r8, [r3, r5, lsl #2]    @ r8 = d = dst[ch - 1]
467     add     r9, r4, #4              @ r9 = &last_sample[0]
468     mov     r1, r12, lsl #16        @ we'll use carry to detect pos increments
469     sub     r11, r0, #1             
470     ldr     r14, [r7, r11, lsl #2]  @ load last sample in s[] ...
471     ldr     r10, [r9, r5, lsl #2]   @ r10 = last_sample[ch - 1]
472     str     r14, [r9, r5, lsl #2]   @ and write as next frame's last_sample
473     movs    r14, r12, lsr #16       @ pos = resample_data.phase >> 16
474     beq     .usstart_0              @ pos = 0
475     cmp     r14, r0                 @ if pos >= count, we're already done
476     bge     .usloop_skip
477     add     r7, r7, r14, lsl #2     @ r7 = &s[pos]
478     ldr     r10, [r7, #-4]          @ r11 = s[pos - 1]
479     b       .usstart_0
481     @ Register usage in loop:
482     @ r0 = count, r1 = phase, r4 = &resample_data.phase, r5 = cur_channel,
483     @ r6 = delta, r7 = s, r8 = d, r9 = diff, r10 = s[pos - 1], r11 = s[pos]
484 .usloop_1:
485     mov     r10, r11                @ r10 = previous sample
486 .usstart_0:
487     ldr     r11, [r7], #4           @ r11 = next sample
488     mov     r4, r1, lsr #16         @ r4 = frac = phase >> 16
489     sub     r9, r11, r10            @ r9 = diff = s[pos] - s[pos - 1]
490 .usloop_0:
491     smull   r12, r14, r4, r9
492     adds    r1, r1, r6              @ phase += delta << 16
493     mov     r4, r1, lsr #16         @ r4 = frac = phase >> 16
494     add     r14, r10, r14, lsl #16
495     add     r14, r14, r12, lsr #16  @ r14 = out = s[pos - 1] + frac*diff
496     str     r14, [r8], #4           @ *d++ = out
497     bcc     .usloop_0               @ if carry is set, pos is incremented
498     subs    r0, r0, #1              @ if count > 0, do another sample
499     bgt     .usloop_1
500 .usloop_skip:
501     subs    r5, r5, #1
502     ldmfd   sp, { r0, r4 }          @ reload count and &resample_data.phase
503     bpl     .uschannel_loop         @ if (--ch) >= 0, do another channel
504     mov     r1, r1, lsr #16         @ wrap phase back to start of next frame
505     ldr     r2, [r3]                @ r1 = &dst[0]
506     str     r1, [r4]                @ store phase
507     sub     r8, r8, r2              @ dst - &dst[0]
508     mov     r0, r8, lsr #2          @ convert bytes->samples
509     add     sp, sp, #8              @ adjust stack for temp variables
510     ldmfd   sp!, { r4-r11, pc }     @ ... and we're out
511     .size       dsp_upsample, .-dsp_upsample
513 /****************************************************************************
514  *  void dsp_apply_gain(int count, struct dsp_data *data, int32_t *buf[])
515  */
516     .section .icode, "ax", %progbits
517     .align  2
518     .global dsp_apply_gain
519     .type   dsp_apply_gain, %function
520 dsp_apply_gain:
521     @ input: r0 = count, r1 = data, r2 = buf[]
522     stmfd   sp!, { r4-r8, lr }
524     ldr     r3, [r1,  #4]           @ r3 = data->num_channels
525     ldr     r4, [r1, #32]           @ r5 = data->gain
527 .dag_outerloop:
528     ldr     r1, [r2], #4            @ r1 = buf[0] and increment index of buf[]
529     subs    r12, r0, #1             @ r12 = r0 = count - 1
530     beq     .dag_singlesample       @ Zero? Only one sample!
532 .dag_innerloop:
533     ldmia   r1, { r5, r6 }          @ load r5, r6 from r1
534     smull   r7, r8, r5, r4          @ r7 = FRACMUL_SHL(r5, r4, 8)
535     smull   r14, r5, r6, r4         @ r14 = FRACMUL_SHL(r6, r4, 8)
536     subs    r12, r12, #2
537     mov     r7, r7, lsr #23
538     mov     r14, r14, lsr #23
539     orr     r7, r7, r8, asl #9
540     orr     r14, r14, r5, asl #9
541     stmia   r1!, { r7, r14 }        @ save r7, r14 to [r1] and increment r1
542     bgt     .dag_innerloop          @ end of inner loop
544     blt     .dag_evencount          @ < 0? even count
546 .dag_singlesample:
547     ldr     r5, [r1]                @ handle odd sample
548     smull   r7, r8, r5, r4          @ r7 = FRACMUL_SHL(r5, r4, 8)
549     mov     r7, r7, lsr #23
550     orr     r7, r7, r8, asl #9
551     str     r7, [r1]
553 .dag_evencount:
554     subs    r3, r3, #1
555     bgt     .dag_outerloop          @ end of outer loop
556                
557     ldmfd   sp!, { r4-r8, pc }
558     .size   dsp_apply_gain, .-dsp_apply_gain