Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/openal-0.0.8/src/arch/i386/mixaudio16_mmx_prk.c @ 17

Last change on this file since 17 was 17, checked in by landauf, 17 years ago

added openal
File size: 14.6 KB
RevLine 
[17]1/***************************************************************************
2 *   Copyright (C) 2005 by Prakash Punnoor                                 *
3 *   prakash@punnoor.de                                                    *
4 *                                                                         *
5 *   This program is free software; you can redistribute it and/or modify  *
6 *   it under the terms of the GNU Library General Public License as       *
7 *   published by the Free Software Foundation; either version 2 of the    *
8 *   License, or (at your option) any later version.                       *
9 *                                                                         *
10 *   This program is distributed in the hope that it will be useful,       *
11 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13 *   GNU General Public License for more details.                          *
14 *                                                                         *
15 *   You should have received a copy of the GNU Library General Public     *
16 *   License along with this program; if not, write to the                 *
17 *   Free Software Foundation, Inc.,                                       *
18 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19 ***************************************************************************/
20
21#include "mixaudio16_mmx_prk.h"
22
23#ifdef __MMX__
24#include <string.h>
25#include "x86_simd_support_prk.h"
26
27#ifdef HAVE_MMX_MEMCPY
28void _alMMXmemcpy(void* dst, void* src, unsigned int n);
29#endif /* HAVE_MMX_MEMCPY */
30
31
32/* prepare sign-extension from 16bit to 32 bit for stream ST */
33#define GET_SIGNMASK(ST)                                                        \
34        indata   = *(v4hi*)((ALshort*)entries[ST].data + offset);               \
35        signmask = (v4hi)(di)__builtin_ia32_pand((di)indata, (di)m.v);          \
36        signmask = __builtin_ia32_pcmpeqw(signmask, m.v);
37
38/* mix stream 0 */
39#define MIX_ST0                                                                 \
40        GET_SIGNMASK (0);                                                       \
41        loout = (v2si)__builtin_ia32_punpcklwd(indata, signmask);               \
42        hiout = (v2si)__builtin_ia32_punpckhwd(indata, signmask);
43
44/* sign-extension and mix stream ST */
45#define MIX(ST)                                                                 \
46        GET_SIGNMASK(ST)                                                        \
47        temp  = (v2si)__builtin_ia32_punpcklwd(indata, signmask);               \
48        loout = __builtin_ia32_paddd(loout, temp);                              \
49        temp  = (v2si)__builtin_ia32_punpckhwd(indata, signmask);               \
50        hiout = __builtin_ia32_paddd(hiout, temp);
51
52/* manual saturation to dst */
53#define SATURATE                                                                \
54        if (sample == (short)sample)                                            \
55                *dst = sample;                                                  \
56        else {                                                                  \
57                if(sample > 0 )                                                 \
58                        *dst = max_audioval;                                    \
59                else                                                            \
60                        *dst = min_audioval;                                    \
61        }
62
63/* manually mix LEN samples */
64#define MIX_MANUAL(STREAMS, LEN)                                                \
65        while (offset < LEN) {                                                  \
66                int sample = 0;                                                 \
67                                                                                \
68                for (st = 0; st < STREAMS; ++st)                                \
69                        sample += *((ALshort*)entries[st].data + offset);       \
70                                                                                \
71                SATURATE;                                                       \
72                ++dst;                                                          \
73                ++offset;                                                       \
74        }
75
76/* manually mix two streams of LEN samples */
77#define MIX_MANUAL2(LEN)                                                        \
78        while (offset < LEN) {                                                  \
79                int sample = *src1;                                             \
80                ++src1;                                                         \
81                sample += *src2;                                                \
82                ++src2;                                                         \
83                                                                                \
84                SATURATE;                                                       \
85                ++dst;                                                          \
86                ++offset;\
87        }
88
89
90#define MixAudio16_MMX_HEAD(STREAMS)                                            \
91        ALuint samples = entries[0].bytes;                                      \
92        ALuint samples_main;                                                    \
93        ALuint samples_pre;                                                     \
94        ALuint samples_post;                                                    \
95        ALuint offset;                                                          \
96        ALuint st;                                                              \
97                                                                                \
98        v4hi indata;                                                            \
99        v4hi signmask;                                                          \
100        v2si loout;                                                             \
101        v2si hiout;                                                             \
102        v2si temp;                                                              \
103                                                                                \
104        samples /= sizeof(ALshort);                                             \
105        offset = 0;                                                             \
106        if (samples < 40) {                                                     \
107                MIX_MANUAL(STREAMS, samples);                                   \
108                return;                                                         \
109        }                                                                       \
110                                                                                \
111        samples_pre = MMX_ALIGN - (aint)dst % MMX_ALIGN;                        \
112        samples_pre /= sizeof(ALshort);                                         \
113        samples_post = (samples - samples_pre) % 4;                             \
114        samples_main = samples - samples_post;                                  \
115                                                                                \
116        MIX_MANUAL(STREAMS, samples_pre);                                       \
117                                                                                \
118        while (offset < samples_main) {                                         \
119                                                                                \
120                MIX_ST0;
121
122#define MixAudio16_MMX_N_TAIL(STREAMS)                                          \
123                offset += 4;                                                    \
124        }                                                                       \
125        __builtin_ia32_emms();                                                  \
126                                                                                \
127        MIX_MANUAL(STREAMS, samples);                                           \
128        return;
129
130#define MixAudio16_MMX_TAIL(STREAMS)                                            \
131                *(v4hi*)dst = __builtin_ia32_packssdw(loout, hiout);            \
132                dst += 4;                                                       \
133                MixAudio16_MMX_N_TAIL(STREAMS);
134
135/* sign-extension and mix stream; for generic function */
136#define MIX_N                                                                   \
137        indata   = *(v4hi*)((ALshort*)src->data + offset);                      \
138        signmask = (v4hi)(di)__builtin_ia32_pand((di)indata, (di)m.v);          \
139        signmask = __builtin_ia32_pcmpeqw(signmask, m.v);                       \
140        temp  = (v2si)__builtin_ia32_punpcklwd(indata, signmask);               \
141        loout = __builtin_ia32_paddd(loout, temp);                              \
142        temp  = (v2si)__builtin_ia32_punpckhwd(indata, signmask);               \
143        hiout = __builtin_ia32_paddd(hiout, temp);
144
145
146
147union {
148        unsigned short s[4];
149        v4hi v;
150} ALIGN16(m) = {{0x8000, 0x8000, 0x8000, 0x8000}};
151
152
153void MixAudio16_MMX_n(ALshort *dst, alMixEntry *entries, ALuint numents)
154{
155        ALuint mod_streams = (numents + 3) % 4;
156        alMixEntry *src;
157        MixAudio16_MMX_HEAD(numents);
158        st = 1;
159        src = entries + 1;
160       
161        switch (mod_streams) {
162                do {
163        case 0:
164                        MIX_N;
165                        ++st;
166                        ++src;
167        case 3:
168                        MIX_N;
169                        ++st;
170                        ++src;
171        case 2:
172                        MIX_N;
173                        ++st;
174                        ++src;
175        case 1:
176                        MIX_N;
177                        ++st;
178                        ++src;
179                } while (st < numents);
180        }
181        *(v4hi*)dst = __builtin_ia32_packssdw(loout, hiout);
182        dst += 4;
183        MixAudio16_MMX_N_TAIL(numents);
184}
185
186void MixAudio16_MMX_0(UNUSED(ALshort *dst), UNUSED(alMixEntry *entries))
187{
188        return;
189}
190
191void MixAudio16_MMX_1(ALshort *dst, alMixEntry *entries)
192{
193        unsigned int len = entries->bytes;
194       
195#ifdef HAVE_MMX_MEMCPY
196        if (len < 300) {
197                memcpy(dst, entries->data, len);
198                return;
199        }
200        _alMMXmemcpy(dst, entries->data, len);
201#else
202        memcpy(dst, entries->data, len);
203#endif /* HAVE_MMX_MEMCPY */
204        return;
205}
206
207void MixAudio16_MMX_2(ALshort *dst, alMixEntry *entries)
208{
209
210        ALuint samples = entries[0].bytes;
211        ALuint samples_main;
212        ALuint samples_pre;
213        ALuint samples_post;
214        ALuint offset;
215       
216        ALshort *src1 = entries[0].data;
217        ALshort *src2 = entries[1].data;
218       
219        samples /= sizeof(ALshort);
220        offset = 0;
221        if (samples < 40) {
222                MIX_MANUAL2(samples);
223                return;
224        }
225       
226        samples_pre = MMX_ALIGN - (aint)dst % MMX_ALIGN;
227        samples_pre /= sizeof(ALshort);
228        samples_post = (samples - samples_pre) % 16;
229        samples_main = samples - samples_post;
230
231#define PADDSW                                                                  \
232        *(v4hi*)dst = __builtin_ia32_paddsw(*(v4hi*)src1, *(v4hi*)src2);        \
233        src1 += 4;                                                              \
234        src2 += 4;                                                              \
235        dst += 4;
236       
237       
238        MIX_MANUAL2(samples_pre);
239
240        while(offset < samples_main) {
241                PADDSW;
242                offset += 4 ;
243                PADDSW;
244                offset += 4;
245                PADDSW;
246                offset += 4;
247                PADDSW;
248                offset += 4;
249        }
250        __builtin_ia32_emms();
251       
252        MIX_MANUAL2(samples);
253        return;
254}
255
256void MixAudio16_MMX_3(ALshort *dst, alMixEntry *entries)
257{
258        MixAudio16_MMX_HEAD(3);
259        MIX(1);
260        MIX(2);
261        MixAudio16_MMX_TAIL(3);
262}
263
264void MixAudio16_MMX_4(ALshort *dst, alMixEntry *entries)
265{
266        MixAudio16_MMX_HEAD(4);
267        MIX(1);
268        MIX(2);
269        MIX(3);
270        MixAudio16_MMX_TAIL(4);
271}
272
273void MixAudio16_MMX_5(ALshort *dst, alMixEntry *entries)
274{
275        MixAudio16_MMX_HEAD(5);
276        MIX(1);
277        MIX(2);
278        MIX(3);
279        MIX(4);
280        MixAudio16_MMX_TAIL(5);
281}
282
283void MixAudio16_MMX_6(ALshort *dst, alMixEntry *entries)
284{
285        MixAudio16_MMX_HEAD(6);
286        MIX(1);
287        MIX(2);
288        MIX(3);
289        MIX(4);
290        MIX(5);
291        MixAudio16_MMX_TAIL(6);
292}
293
294void MixAudio16_MMX_7(ALshort *dst, alMixEntry *entries)
295{
296        MixAudio16_MMX_HEAD(7);
297        MIX(1);
298        MIX(2);
299        MIX(3);
300        MIX(4);
301        MIX(5);
302        MIX(6);
303        MixAudio16_MMX_TAIL(7);
304}
305
306void MixAudio16_MMX_8(ALshort *dst, alMixEntry *entries)
307{
308        MixAudio16_MMX_HEAD(8);
309        MIX(1);
310        MIX(2);
311        MIX(3);
312        MIX(4);
313        MIX(5);
314        MIX(6);
315        MIX(7);
316        MixAudio16_MMX_TAIL(8);
317}
318
319void MixAudio16_MMX_9(ALshort *dst, alMixEntry *entries)
320{
321        MixAudio16_MMX_HEAD(9);
322        MIX(1);
323        MIX(2);
324        MIX(3);
325        MIX(4);
326        MIX(5);
327        MIX(6);
328        MIX(7);
329        MIX(8);
330        MixAudio16_MMX_TAIL(9);
331}
332
333void MixAudio16_MMX_10(ALshort *dst, alMixEntry *entries)
334{
335        MixAudio16_MMX_HEAD(10);
336        MIX(1);
337        MIX(2);
338        MIX(3);
339        MIX(4);
340        MIX(5);
341        MIX(6);
342        MIX(7);
343        MIX(8);
344        MIX(9);
345        MixAudio16_MMX_TAIL(10);
346}
347
348void MixAudio16_MMX_11(ALshort *dst, alMixEntry *entries)
349{
350        MixAudio16_MMX_HEAD(11);
351        MIX(1);
352        MIX(2);
353        MIX(3);
354        MIX(4);
355        MIX(5);
356        MIX(6);
357        MIX(7);
358        MIX(8);
359        MIX(9);
360        MIX(10);
361        MixAudio16_MMX_TAIL(11);
362}
363
364void MixAudio16_MMX_12(ALshort *dst, alMixEntry *entries)
365{
366        MixAudio16_MMX_HEAD(12);
367        MIX(1);
368        MIX(2);
369        MIX(3);
370        MIX(4);
371        MIX(5);
372        MIX(6);
373        MIX(7);
374        MIX(8);
375        MIX(9);
376        MIX(10);
377        MIX(11);
378        MixAudio16_MMX_TAIL(12);
379}
380
381void MixAudio16_MMX_13(ALshort *dst, alMixEntry *entries)
382{
383        MixAudio16_MMX_HEAD(13);
384        MIX(1);
385        MIX(2);
386        MIX(3);
387        MIX(4);
388        MIX(5);
389        MIX(6);
390        MIX(7);
391        MIX(8);
392        MIX(9);
393        MIX(10);
394        MIX(11);
395        MIX(12);
396        MixAudio16_MMX_TAIL(13);
397}
398
399void MixAudio16_MMX_14(ALshort *dst, alMixEntry *entries)
400{
401        MixAudio16_MMX_HEAD(14);
402        MIX(1);
403        MIX(2);
404        MIX(3);
405        MIX(4);
406        MIX(5);
407        MIX(6);
408        MIX(7);
409        MIX(8);
410        MIX(9);
411        MIX(10);
412        MIX(11);
413        MIX(12);
414        MIX(13);
415        MixAudio16_MMX_TAIL(14);
416}
417
418void MixAudio16_MMX_15(ALshort *dst, alMixEntry *entries)
419{
420        MixAudio16_MMX_HEAD(15);
421        MIX(1);
422        MIX(2);
423        MIX(3);
424        MIX(4);
425        MIX(5);
426        MIX(6);
427        MIX(7);
428        MIX(8);
429        MIX(9);
430        MIX(10);
431        MIX(11);
432        MIX(12);
433        MIX(13);
434        MIX(14);
435        MixAudio16_MMX_TAIL(15);
436}
437
438void MixAudio16_MMX_16(ALshort *dst, alMixEntry *entries)
439{
440        MixAudio16_MMX_HEAD(16);
441        MIX(1);
442        MIX(2);
443        MIX(3);
444        MIX(4);
445        MIX(5);
446        MIX(6);
447        MIX(7);
448        MIX(8);
449        MIX(9);
450        MIX(10);
451        MIX(11);
452        MIX(12);
453        MIX(13);
454        MIX(14);
455        MIX(15);
456        MixAudio16_MMX_TAIL(16);
457}
458
459void MixAudio16_MMX_17(ALshort *dst, alMixEntry *entries)
460{
461        MixAudio16_MMX_HEAD(17);
462        MIX(1);
463        MIX(2);
464        MIX(3);
465        MIX(4);
466        MIX(5);
467        MIX(6);
468        MIX(7);
469        MIX(8);
470        MIX(9);
471        MIX(10);
472        MIX(11);
473        MIX(12);
474        MIX(13);
475        MIX(14);
476        MIX(15);
477        MIX(16);
478        MixAudio16_MMX_TAIL(17);
479}
480
481void MixAudio16_MMX_18(ALshort *dst, alMixEntry *entries)
482{
483        MixAudio16_MMX_HEAD(18);
484        MIX(1);
485        MIX(2);
486        MIX(3);
487        MIX(4);
488        MIX(5);
489        MIX(6);
490        MIX(7);
491        MIX(8);
492        MIX(9);
493        MIX(10);
494        MIX(11);
495        MIX(12);
496        MIX(13);
497        MIX(14);
498        MIX(15);
499        MIX(16);
500        MIX(17);
501        MixAudio16_MMX_TAIL(18);
502}
503
504void MixAudio16_MMX_19(ALshort *dst, alMixEntry *entries)
505{
506        MixAudio16_MMX_HEAD(19);
507        MIX(1);
508        MIX(2);
509        MIX(3);
510        MIX(4);
511        MIX(5);
512        MIX(6);
513        MIX(7);
514        MIX(8);
515        MIX(9);
516        MIX(10);
517        MIX(11);
518        MIX(12);
519        MIX(13);
520        MIX(14);
521        MIX(15);
522        MIX(16);
523        MIX(17);
524        MIX(18);
525        MixAudio16_MMX_TAIL(19);
526}
527
528void MixAudio16_MMX_20(ALshort *dst, alMixEntry *entries)
529{
530        MixAudio16_MMX_HEAD(20);
531        MIX(1);
532        MIX(2);
533        MIX(3);
534        MIX(4);
535        MIX(5);
536        MIX(6);
537        MIX(7);
538        MIX(8);
539        MIX(9);
540        MIX(10);
541        MIX(11);
542        MIX(12);
543        MIX(13);
544        MIX(14);
545        MIX(15);
546        MIX(16);
547        MIX(17);
548        MIX(18);
549        MIX(19);
550        MixAudio16_MMX_TAIL(20);
551}
552
553void MixAudio16_MMX_21(ALshort *dst, alMixEntry *entries)
554{
555        MixAudio16_MMX_HEAD(21);
556        MIX(1);
557        MIX(2);
558        MIX(3);
559        MIX(4);
560        MIX(5);
561        MIX(6);
562        MIX(7);
563        MIX(8);
564        MIX(9);
565        MIX(10);
566        MIX(11);
567        MIX(12);
568        MIX(13);
569        MIX(14);
570        MIX(15);
571        MIX(16);
572        MIX(17);
573        MIX(18);
574        MIX(19);
575        MIX(20);
576        MixAudio16_MMX_TAIL(21);
577}
578
579void MixAudio16_MMX_22(ALshort *dst, alMixEntry *entries)
580{
581        MixAudio16_MMX_HEAD(22);
582        MIX(1);
583        MIX(2);
584        MIX(3);
585        MIX(4);
586        MIX(5);
587        MIX(6);
588        MIX(7);
589        MIX(8);
590        MIX(9);
591        MIX(10);
592        MIX(11);
593        MIX(12);
594        MIX(13);
595        MIX(14);
596        MIX(15);
597        MIX(16);
598        MIX(17);
599        MIX(18);
600        MIX(19);
601        MIX(20);
602        MIX(21);
603        MixAudio16_MMX_TAIL(22);
604}
605
606void MixAudio16_MMX_23(ALshort *dst, alMixEntry *entries)
607{
608        MixAudio16_MMX_HEAD(23);
609        MIX(1);
610        MIX(2);
611        MIX(3);
612        MIX(4);
613        MIX(5);
614        MIX(6);
615        MIX(7);
616        MIX(8);
617        MIX(9);
618        MIX(10);
619        MIX(11);
620        MIX(12);
621        MIX(13);
622        MIX(14);
623        MIX(15);
624        MIX(16);
625        MIX(17);
626        MIX(18);
627        MIX(19);
628        MIX(20);
629        MIX(21);
630        MIX(22);
631        MixAudio16_MMX_TAIL(23);
632}
633
634void MixAudio16_MMX_24(ALshort *dst, alMixEntry *entries)
635{
636        MixAudio16_MMX_HEAD(24);
637        MIX(1);
638        MIX(2);
639        MIX(3);
640        MIX(4);
641        MIX(5);
642        MIX(6);
643        MIX(7);
644        MIX(8);
645        MIX(9);
646        MIX(10);
647        MIX(11);
648        MIX(12);
649        MIX(13);
650        MIX(14);
651        MIX(15);
652        MIX(16);
653        MIX(17);
654        MIX(18);
655        MIX(19);
656        MIX(20);
657        MIX(21);
658        MIX(22);
659        MIX(23);
660        MixAudio16_MMX_TAIL(24);
661}
662
663void MixAudio16_MMX_25(ALshort *dst, alMixEntry *entries)
664{
665        MixAudio16_MMX_HEAD(25);
666        MIX(1);
667        MIX(2);
668        MIX(3);
669        MIX(4);
670        MIX(5);
671        MIX(6);
672        MIX(7);
673        MIX(8);
674        MIX(9);
675        MIX(10);
676        MIX(11);
677        MIX(12);
678        MIX(13);
679        MIX(14);
680        MIX(15);
681        MIX(16);
682        MIX(17);
683        MIX(18);
684        MIX(19);
685        MIX(20);
686        MIX(21);
687        MIX(22);
688        MIX(23);
689        MIX(24);
690        MixAudio16_MMX_TAIL(25);
691}
692
693void MixAudio16_MMX_26(ALshort *dst, alMixEntry *entries)
694{
695        MixAudio16_MMX_HEAD(26);
696        MIX(1);
697        MIX(2);
698        MIX(3);
699        MIX(4);
700        MIX(5);
701        MIX(6);
702        MIX(7);
703        MIX(8);
704        MIX(9);
705        MIX(10);
706        MIX(11);
707        MIX(12);
708        MIX(13);
709        MIX(14);
710        MIX(15);
711        MIX(16);
712        MIX(17);
713        MIX(18);
714        MIX(19);
715        MIX(20);
716        MIX(21);
717        MIX(22);
718        MIX(23);
719        MIX(24);
720        MIX(25);
721        MixAudio16_MMX_TAIL(26);
722}
723
724void MixAudio16_MMX_27(ALshort *dst, alMixEntry *entries)
725{
726        MixAudio16_MMX_HEAD(27);
727        MIX(1);
728        MIX(2);
729        MIX(3);
730        MIX(4);
731        MIX(5);
732        MIX(6);
733        MIX(7);
734        MIX(8);
735        MIX(9);
736        MIX(10);
737        MIX(11);
738        MIX(12);
739        MIX(13);
740        MIX(14);
741        MIX(15);
742        MIX(16);
743        MIX(17);
744        MIX(18);
745        MIX(19);
746        MIX(20);
747        MIX(21);
748        MIX(22);
749        MIX(23);
750        MIX(24);
751        MIX(25);
752        MIX(26);
753        MixAudio16_MMX_TAIL(27);
754}
755
756void MixAudio16_MMX_28(ALshort *dst, alMixEntry *entries)
757{
758        MixAudio16_MMX_HEAD(28);
759        MIX(1);
760        MIX(2);
761        MIX(3);
762        MIX(4);
763        MIX(5);
764        MIX(6);
765        MIX(7);
766        MIX(8);
767        MIX(9);
768        MIX(10);
769        MIX(11);
770        MIX(12);
771        MIX(13);
772        MIX(14);
773        MIX(15);
774        MIX(16);
775        MIX(17);
776        MIX(18);
777        MIX(19);
778        MIX(20);
779        MIX(21);
780        MIX(22);
781        MIX(23);
782        MIX(24);
783        MIX(25);
784        MIX(26);
785        MIX(27);
786        MixAudio16_MMX_TAIL(28);
787}
788
789void MixAudio16_MMX_29(ALshort *dst, alMixEntry *entries)
790{
791        MixAudio16_MMX_HEAD(29);
792        MIX(1);
793        MIX(2);
794        MIX(3);
795        MIX(4);
796        MIX(5);
797        MIX(6);
798        MIX(7);
799        MIX(8);
800        MIX(9);
801        MIX(10);
802        MIX(11);
803        MIX(12);
804        MIX(13);
805        MIX(14);
806        MIX(15);
807        MIX(16);
808        MIX(17);
809        MIX(18);
810        MIX(19);
811        MIX(20);
812        MIX(21);
813        MIX(22);
814        MIX(23);
815        MIX(24);
816        MIX(25);
817        MIX(26);
818        MIX(27);
819        MIX(28);
820        MixAudio16_MMX_TAIL(29);
821}
822
823void MixAudio16_MMX_30(ALshort *dst, alMixEntry *entries)
824{
825        MixAudio16_MMX_HEAD(30);
826        MIX(1);
827        MIX(2);
828        MIX(3);
829        MIX(4);
830        MIX(5);
831        MIX(6);
832        MIX(7);
833        MIX(8);
834        MIX(9);
835        MIX(10);
836        MIX(11);
837        MIX(12);
838        MIX(13);
839        MIX(14);
840        MIX(15);
841        MIX(16);
842        MIX(17);
843        MIX(18);
844        MIX(19);
845        MIX(20);
846        MIX(21);
847        MIX(22);
848        MIX(23);
849        MIX(24);
850        MIX(25);
851        MIX(26);
852        MIX(27);
853        MIX(28);
854        MIX(29);
855        MixAudio16_MMX_TAIL(30);
856}
857
858void MixAudio16_MMX_31(ALshort *dst, alMixEntry *entries)
859{
860        MixAudio16_MMX_HEAD(31);
861        MIX(1);
862        MIX(2);
863        MIX(3);
864        MIX(4);
865        MIX(5);
866        MIX(6);
867        MIX(7);
868        MIX(8);
869        MIX(9);
870        MIX(10);
871        MIX(11);
872        MIX(12);
873        MIX(13);
874        MIX(14);
875        MIX(15);
876        MIX(16);
877        MIX(17);
878        MIX(18);
879        MIX(19);
880        MIX(20);
881        MIX(21);
882        MIX(22);
883        MIX(23);
884        MIX(24);
885        MIX(25);
886        MIX(26);
887        MIX(27);
888        MIX(28);
889        MIX(29);
890        MIX(30);
891        MixAudio16_MMX_TAIL(31);
892}
893
894void MixAudio16_MMX_32(ALshort *dst, alMixEntry *entries)
895{
896        MixAudio16_MMX_HEAD(32);
897        MIX(1);
898        MIX(2);
899        MIX(3);
900        MIX(4);
901        MIX(5);
902        MIX(6);
903        MIX(7);
904        MIX(8);
905        MIX(9);
906        MIX(10);
907        MIX(11);
908        MIX(12);
909        MIX(13);
910        MIX(14);
911        MIX(15);
912        MIX(16);
913        MIX(17);
914        MIX(18);
915        MIX(19);
916        MIX(20);
917        MIX(21);
918        MIX(22);
919        MIX(23);
920        MIX(24);
921        MIX(25);
922        MIX(26);
923        MIX(27);
924        MIX(28);
925        MIX(29);
926        MIX(30);
927        MIX(31);
928        MixAudio16_MMX_TAIL(32);
929}
930#endif /* __MMX__ */
Note: See TracBrowser for help on using the repository browser.