Logo Search packages:      
Sourcecode: scummvm version File versions

i386.cpp

/* Copyright (c) 2003-2004 Various contributors
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include "mt32emu.h"

#ifdef MT32EMU_HAVE_X86

namespace MT32Emu {

#ifndef _MSC_VER

#define eflag(value) __asm__ __volatile__("pushfl \n popfl \n" : : "a"(value))
#define cpuid_flag  (1 << 21)

static inline bool atti386_DetectCPUID() {
      unsigned int result;

      // Is there a cpuid?
      result = cpuid_flag; // set test
      eflag(result);
      if (!(result & cpuid_flag))
            return false;

      result = 0; // clear test
      eflag(result);
      if (result & cpuid_flag)
            return false;

      return true;
}

static inline bool atti386_DetectSIMD() {
      unsigned int result;

      if (atti386_DetectCPUID() == false)
            return false;

      /* check cpuid */
      __asm__ __volatile__(
            "movl   $1, %%eax        \n" \
            "cpuid                   \n" \
            "movl   %%edx, %0        \n" \
            : "=r"(result) : : "eax", "ebx", "ecx", "edx");

      if (result & (1 << 25))
            return true;

      return false;
}

static inline bool atti386_Detect3DNow() {
      unsigned int result;

      if (atti386_DetectCPUID() == false)
            return false;

      // get cpuid
      __asm__ __volatile__(
            "movl   $0x80000001, %%eax \n" \
            "cpuid                     \n" \
            "movl   %%edx, %0          \n" \
            : "=r"(result) : : "eax", "ebx", "ecx", "edx");

      if (result & 0x80000000)
            return true;

      return false;
}


static inline float atti386_iir_filter_sse(float *output, float *hist1_ptr, float *coef_ptr) {
      __asm__  __volatile__ (
            "pushl  %1                      \n" \
            "pushl  %2                      \n" \
            "movss  0(%0), %%xmm1           \n" \
            "movups 0(%1), %%xmm2           \n" \
            "movlps 0(%2), %%xmm3           \n" \
            "                               \n" \
            "shufps $0x44, %%xmm3, %%xmm3   \n" \
            "                               \n" \
            "mulps  %%xmm3, %%xmm2          \n" \
            "                               \n" \
            "subss  %%xmm2, %%xmm1          \n" \
            "shufps $0x39,  %%xmm2, %%xmm2  \n" \
            "subss  %%xmm2, %%xmm1          \n" \
            "                               \n" \
            "movss  %%xmm1, 0(%2)           \n" \
            "                               \n" \
            "shufps $0x39,  %%xmm2, %%xmm2  \n" \
            "addss  %%xmm2, %%xmm1          \n" \
            "                               \n" \
            "shufps $0x39,  %%xmm2, %%xmm2  \n" \
            "addss  %%xmm2, %%xmm1          \n" \
            "                               \n" \
            "movss  %%xmm3, 4(%2)           \n" \
            "                               \n" \
            "addl   $16, %1                 \n" \
            "addl   $8, %2                  \n" \
            "                               \n" \
            "movups 0(%1), %%xmm2           \n" \
            "                               \n" \
            "movlps 0(%2), %%xmm3           \n" \
            "shufps $0x44, %%xmm3, %%xmm3   \n" \
            "                               \n" \
            "mulps %%xmm3, %%xmm2           \n" \
            "                               \n" \
            "subss  %%xmm2, %%xmm1          \n" \
            "shufps $0x39,  %%xmm2, %%xmm2  \n" \
            "subss  %%xmm2, %%xmm1          \n" \
            "                               \n" \
            "movss %%xmm1, 0(%2)            \n" \
            "                               \n" \
            "shufps $0x39, %%xmm2, %%xmm2   \n" \
            "addss %%xmm2, %%xmm1           \n" \
            "                               \n" \
            "shufps $0x39, %%xmm2, %%xmm2   \n" \
            "addss %%xmm2, %%xmm1           \n" \
            "                               \n" \
            "movss %%xmm3, 4(%2)            \n" \
            "movss %%xmm1, 0(%0)            \n" \
            "popl %2                        \n" \
            "popl %1                        \n" \
            : : "r"(output), "r"(coef_ptr), "r"(hist1_ptr)
            : "xmm1", "xmm2", "xmm3", "memory");

      return *output;
}

static inline float atti386_iir_filter_3DNow(float output, float *hist1_ptr, float *coef_ptr) {
      float tmp;

      __asm__ __volatile__ (
            "movq %0, %%mm1       \n" \
            "                     \n" \
            "movl  %1, %%ebx      \n" \
            "movq 0(%%ebx), %%mm2 \n" \
            "                     \n" \
            "movl %2, %%eax;      \n" \
            "movq 0(%%eax), %%mm3 \n" \
            "                     \n" \
            "pfmul %%mm3, %%mm2   \n" \
            "pfsub %%mm2, %%mm1   \n" \
            "                     \n" \
            "psrlq $32, %%mm2     \n" \
            "pfsub %%mm2, %%mm1   \n" \
            "                     \n" \
            "movd %%mm1, %3       \n" \
            "                     \n" \
            "addl  $8, %%ebx      \n" \
            "movq 0(%%ebx), %%mm2 \n" \
            "movq 0(%%eax), %%mm3 \n" \
            "                     \n" \
            "pfmul %%mm3, %%mm2   \n" \
            "pfadd %%mm2, %%mm1   \n" \
            "                     \n" \
            "psrlq $32, %%mm2     \n" \
            "pfadd %%mm2, %%mm1   \n" \
            "                     \n" \
            "pushl %3             \n" \
            "popl 0(%%eax)        \n" \
            "                     \n" \
            "movd %%mm3, 4(%%eax) \n" \
            "                     \n" \
            "addl $8, %%ebx       \n" \
            "addl $8, %%eax       \n" \
            "                     \n" \
            "movq 0(%%ebx), %%mm2 \n" \
            "movq 0(%%eax), %%mm3 \n" \
            "                     \n" \
            "pfmul %%mm3, %%mm2   \n" \
            "pfsub %%mm2, %%mm1   \n" \
            "                     \n" \
            "psrlq $32, %%mm2     \n" \
            "pfsub %%mm2, %%mm1   \n" \
            "                     \n" \
            "movd %%mm1, %3       \n" \
            "                     \n" \
            "addl $8, %%ebx       \n" \
            "movq 0(%%ebx), %%mm2 \n" \
            "movq 0(%%eax), %%mm3 \n" \
            "                     \n" \
            "pfmul %%mm3, %%mm2   \n" \
            "pfadd %%mm2, %%mm1   \n" \
            "                     \n" \
            "psrlq $32, %%mm2     \n" \
            "pfadd %%mm2, %%mm1   \n" \
            "                     \n" \
            "pushl %3             \n" \
            "popl 0(%%eax)        \n" \
            "movd %%mm3, 4(%%eax) \n" \
            "                     \n" \
            "movd %%mm1, %0       \n" \
            "femms                \n" \
            : "=m"(output) : "g"(coef_ptr), "g"(hist1_ptr), "m"(tmp)
            : "eax", "ebx", "mm1", "mm2", "mm3", "memory");

      return output;
}

static inline void atti386_produceOutput1(int tmplen, Bit16s myvolume, Bit16s *useBuf, Bit16s *snd) {
      __asm__ __volatile__(
            "movl %0,  %%ecx      \n" \
            "movw %1,  %%ax       \n" \
            "shll $16, %%eax      \n" \
            "movw %1,  %%ax       \n" \
            "movd %%eax, %%mm3    \n" \
            "movd %%eax, %%mm2    \n" \
            "psllq $32, %%mm3     \n" \
            "por %%mm2, %%mm3     \n" \
            "movl %2, %%esi       \n" \
            "movl %3, %%edi       \n" \
            "1:                   \n" \
            "movq 0(%%esi), %%mm1 \n" \
            "movq 0(%%edi), %%mm2 \n" \
            "pmulhw %%mm3, %%mm1  \n" \
            "paddw %%mm2, %%mm1   \n" \
            "movq %%mm1, 0(%%edi) \n" \
            "                     \n" \
            "addl $8, %%esi       \n" \
            "addl $8, %%edi       \n" \
            "                     \n" \
            "decl %%ecx           \n" \
            "cmpl $0, %%ecx       \n" \
            "jg   1b              \n" \
            "emms                 \n" \
            : : "g"(tmplen), "g"(myvolume), "g"(useBuf), "g"(snd)
            : "eax", "ecx", "edi", "esi", "mm1", "mm2", "mm3", "memory");
}

static inline void atti386_produceOutput2(Bit32u len, Bit16s *snd, float *sndbufl, float *sndbufr, float *multFactor) {
      __asm__ __volatile__(
            "movl  %4, %%ecx         \n" \
            "shrl  $1, %%ecx         \n" \
            "addl  $4, %%ecx         \n" \
            "pushl %%ecx             \n" \
            "                        \n" \
            "movl %0, %%esi          \n" \
            "movups 0(%%esi), %%xmm1 \n" \
            "                        \n" \
            "movl %1, %%esi          \n" \
            "movl %2, %%edi          \n" \
            "1:                      \n" \
            "xorl %%eax, %%eax       \n" \
            "movw 0(%1), %%ax        \n" \
            "cwde                    \n" \
            "incl %1                 \n" \
            "incl %1                 \n" \
            "movd  %%eax, %%mm1      \n" \
            "psrlq $32, %%mm1        \n" \
            "movw 0(%1), %%ax        \n" \
            "incl %1                 \n" \
            "incl %1                 \n" \
            "movd %%eax, %%mm2       \n" \
            "por %%mm2, %%mm1        \n" \
            "                        \n" \
            "decl %%ecx              \n" \
            "jnz 1b                  \n" \
            "                        \n" \
            "popl %%ecx              \n" \
            "movl %1, %%esi          \n" \
            "movl %3, %%edi          \n" \
            "incl %%esi              \n" \
            "2:                      \n" \
            "decl %%ecx              \n" \
            "jnz 2b                  \n" \
            : : "g"(multFactor), "r"(snd), "g"(sndbufl), "g"(sndbufr), "g"(len)
            : "eax", "ecx", "edi", "esi", "mm1", "mm2", "xmm1", "memory");
}

static inline void atti386_mixBuffers(Bit16s * buf1, Bit16s *buf2, int len) {
      __asm__ __volatile__(
            "movl %0, %%ecx       \n" \
            "movl %1, %%esi       \n" \
            "movl %2, %%edi       \n" \
            "1:                   \n" \
            "movq 0(%%edi), %%mm1 \n" \
            "movq 0(%%esi), %%mm2 \n" \
            "paddw %%mm2, %%mm1   \n" \
            "movq %%mm1, 0(%%esi) \n" \
            "addl $8, %%edi       \n" \
            "addl $8, %%esi       \n" \
            "decl %%ecx           \n" \
            "cmpl $0, %%ecx       \n" \
            "jg   1b              \n" \
            "emms                 \n" \
            : : "g"(len), "g"(buf1), "g"(buf2)
            : "ecx", "edi", "esi", "mm1", "mm2", "memory");
}

static inline void atti386_mixBuffersRingMix(Bit16s * buf1, Bit16s *buf2, int len) {
      __asm__ __volatile__(
            "movl %0, %%ecx       \n" \
            "movl %1, %%esi       \n" \
            "movl %2, %%edi       \n" \
            "1:                   \n" \
            "movq 0(%%esi), %%mm1 \n" \
            "movq 0(%%edi), %%mm2 \n" \
            "movq %%mm1, %%mm3    \n" \
            "pmulhw %%mm2, %%mm1  \n" \
            "paddw %%mm3, %%mm1   \n" \
            "movq %%mm1, 0(%%esi) \n" \
            "addl $8, %%edi       \n" \
            "addl $8, %%esi       \n" \
            "decl %%ecx           \n" \
            "cmpl $0, %%ecx       \n" \
            "jg   1b              \n" \
            "emms                 \n" \
            : : "g"(len), "g"(buf1), "g"(buf2)
            : "ecx", "edi", "esi", "mm1", "mm2", "mm3", "memory");
}

static inline void atti386_mixBuffersRing(Bit16s * buf1, Bit16s *buf2, int len) {
      __asm__ __volatile__(
            "movl %0, %%ecx       \n" \
            "movl %1, %%esi       \n" \
            "movl %2, %%edi       \n" \
            "1:                   \n" \
            "movq 0(%%esi), %%mm1 \n" \
            "movq 0(%%edi), %%mm2 \n" \
            "pmulhw %%mm2, %%mm1  \n" \
            "movq %%mm1, 0(%%esi) \n" \
            "addl $8, %%edi       \n" \
            "addl $8, %%esi       \n" \
            "decl %%ecx           \n" \
            "cmpl $0, %%ecx       \n" \
            "jg   1b              \n" \
            "emms                 \n" \
            : : "g"(len), "g"(buf1), "g"(buf2)
            : "ecx", "edi", "esi", "mm1", "mm2", "memory");
}

static inline void atti386_partialProductOutput(int quadlen, Bit16s leftvol, Bit16s rightvol, Bit16s *partialBuf, Bit16s *p1buf) {
      __asm__ __volatile__(
            "movl %0, %%ecx       \n" \
            "movw %1, %%ax        \n" \
            "shll $16, %%eax      \n" \
            "movw %2, %%ax        \n" \
            "movd %%eax, %%mm1    \n" \
            "movd %%eax, %%mm2    \n" \
            "psllq $32, %%mm1     \n" \
            "por  %%mm2, %%mm1    \n" \
            "movl %3, %%edi       \n" \
            "movl %4, %%esi       \n" \
            "1:                   \n" \
            "movw 0(%%esi), %%bx  \n" \
            "addl $2, %%esi       \n" \
            "movw 0(%%esi), %%dx  \n" \
            "addl $2, %%esi       \n" \
            ""                        \
            "movw %%dx, %%ax      \n" \
            "shll $16, %%eax      \n" \
            "movw %%dx, %%ax      \n" \
            "movd %%eax, %%mm2    \n" \
            "psllq $32, %%mm2     \n" \
            "movw %%bx, %%ax      \n" \
            "shll $16, %%eax      \n" \
            "movw %%bx, %%ax      \n" \
            "movd %%eax, %%mm3    \n" \
            "por  %%mm3, %%mm2    \n" \
            ""                        \
            "pmulhw %%mm1, %%mm2  \n" \
            "movq %%mm2, 0(%%edi) \n" \
            "addl $8, %%edi       \n" \
            ""                        \
            "decl %%ecx           \n" \
            "cmpl $0, %%ecx       \n" \
            "jg 1b                \n" \
            "emms                 \n"  \
            : : "g"(quadlen), "g"(leftvol), "g"(rightvol), "g"(partialBuf), "g"(p1buf)
            : "eax", "ebx", "ecx", "edx", "edi", "esi", "mm1", "mm2", "mm3", "memory");
}

#endif

bool DetectSIMD() {
#ifdef _MSC_VER
      bool found_simd;
      __asm {
            pushfd
            pop eax // get EFLAGS into eax
            mov ebx,eax // keep a copy
            xor eax,0x200000
            // toggle CPUID bit

            push eax
            popfd // set new EFLAGS
            pushfd
            pop eax // EFLAGS back into eax

            xor eax,ebx
            // have we changed the ID bit?

            je NO_SIMD
            // No, no CPUID instruction

            // we could toggle the
            // ID bit so CPUID is present
            mov eax,1

            cpuid // get processor features
            test edx,1<<25 // check the SIMD bit
            jz NO_SIMD
            mov found_simd,1
            jmp DONE
            NO_SIMD:
            mov found_simd,0
            DONE:
      }
      return found_simd;
#else
      return atti386_DetectSIMD();
#endif
}

bool Detect3DNow() {
#ifdef _MSC_VER
      bool found3D = false;
      __asm {
            pushfd
            pop eax
            mov edx, eax
            xor eax, 00200000h
            push eax
            popfd
            pushfd
            pop eax
            xor eax, edx
            jz NO_3DNOW

            mov eax, 80000000h
            cpuid

            cmp eax, 80000000h
            jbe NO_3DNOW

            mov eax, 80000001h
            cpuid
            test edx, 80000000h
            jz NO_3DNOW
            mov found3D, 1
NO_3DNOW:

      }
      return found3D;
#else
      return atti386_Detect3DNow();
#endif
}

float iir_filter_sse(float input,float *hist1_ptr, float *coef_ptr, int revLevel) {
      float output;

      // 1st number of coefficients array is overall input scale factor, or filter gain
      output = input * (*coef_ptr++);

#ifdef _MSC_VER
      __asm {

            movss xmm1, output

            mov eax, coef_ptr
            movups xmm2, [eax]

            mov eax, hist1_ptr
            movlps xmm3, [eax]
            shufps xmm3, xmm3, 44h
            // hist1_ptr+1, hist1_ptr, hist1_ptr+1, hist1_ptr

            mulps xmm2, xmm3

            subss xmm1, xmm2
            // Rotate elements right
            shufps xmm2, xmm2, 39h
            subss xmm1, xmm2

            // Store new_hist
            movss DWORD PTR [eax], xmm1

            // Rotate elements right
            shufps xmm2, xmm2, 39h
            addss xmm1, xmm2

            // Rotate elements right
            shufps xmm2, xmm2, 39h
            addss xmm1, xmm2

            // Store previous hist
            movss DWORD PTR [eax+4], xmm3

            add coef_ptr, 16
            add hist1_ptr, 8

            mov eax, coef_ptr
            movups xmm2, [eax]

            mov eax, hist1_ptr
            movlps xmm3, [eax]
            shufps xmm3, xmm3, 44h
            // hist1_ptr+1, hist1_ptr, hist1_ptr+1, hist1_ptr

            mulps xmm2, xmm3

            subss xmm1, xmm2
            // Rotate elements right
            shufps xmm2, xmm2, 39h
            subss xmm1, xmm2

            // Store new_hist
            movss DWORD PTR [eax], xmm1

            // Rotate elements right
            shufps xmm2, xmm2, 39h
            addss xmm1, xmm2

            // Rotate elements right
            shufps xmm2, xmm2, 39h
            addss xmm1, xmm2

            // Store previous hist
            movss DWORD PTR [eax+4], xmm3

            movss output, xmm1
      }
#else
      output = atti386_iir_filter_sse(&output, hist1_ptr, coef_ptr);
#endif
      output *= ResonInv[revLevel];
      return output;
}

float iir_filter_3dnow(float input,float *hist1_ptr, float *coef_ptr, int revLevel) {
      float output;

      // 1st number of coefficients array is overall input scale factor, or filter gain
      output = input * (*coef_ptr++);

      // I find it very sad that 3DNow requires twice as many instructions as Intel's SSE
      // Intel does have the upper hand here.
#ifdef _MSC_VER
      float tmp;
      __asm {
            movq mm1, output
            mov ebx, coef_ptr
            movq mm2, [ebx]

            mov eax, hist1_ptr;
            movq mm3, [eax]

            pfmul mm2, mm3
            pfsub mm1, mm2

            psrlq mm2, 32
            pfsub mm1, mm2

            // Store new hist
            movd tmp, mm1

            add ebx, 8
            movq mm2, [ebx]
            movq mm3, [eax]

            pfmul mm2, mm3
            pfadd mm1, mm2

            psrlq mm2, 32
            pfadd mm1, mm2

            push tmp
            pop DWORD PTR [eax]

            movd DWORD PTR [eax+4], mm3

            add ebx, 8
            add eax, 8

            movq mm2, [ebx]
            movq mm3, [eax]

            pfmul mm2, mm3
            pfsub mm1, mm2

            psrlq mm2, 32
            pfsub mm1, mm2

            // Store new hist
            movd tmp, mm1

            add ebx, 8
            movq mm2, [ebx]
            movq mm3, [eax]

            pfmul mm2, mm3
            pfadd mm1, mm2

            psrlq mm2, 32
            pfadd mm1, mm2

            push tmp
            pop DWORD PTR [eax]
            movd DWORD PTR [eax+4], mm3

            movd output, mm1

            femms
      }
#else
      output = atti386_iir_filter_3DNow(output, hist1_ptr, coef_ptr);
#endif
      output *= ResonInv[revLevel];
      return output;
}

#if MT32EMU_USE_MMX > 0

int i386_partialProductOutput(int len, Bit16s leftvol, Bit16s rightvol, Bit16s *partialBuf, Bit16s *mixedBuf) {
      int tmplen = len >> 1;
      if (tmplen == 0) {
            return 0;
      }
#ifdef _MSC_VER
      __asm {
            mov ecx,tmplen
            mov ax, leftvol
            shl eax,16
            mov ax, rightvol
            movd mm1, eax
            movd mm2, eax
            psllq mm1, 32
            por mm1, mm2
            mov edi, partialBuf
            mov esi, mixedBuf
mmxloop1:
            mov bx, [esi]
            add esi,2
            mov dx, [esi]
            add esi,2

            mov ax, dx
            shl eax, 16
            mov ax, dx
            movd mm2,eax
            psllq mm2, 32
            mov ax, bx
            shl eax, 16
            mov ax, bx
            movd mm3,eax
            por mm2,mm3

            pmulhw mm2, mm1
            movq [edi], mm2
            add edi, 8

            dec ecx
            cmp ecx,0
            jg mmxloop1
            emms
      }
#else
      atti386_partialProductOutput(tmplen, leftvol, rightvol, partialBuf, mixedBuf);
#endif
      return tmplen << 1;
}

int i386_mixBuffers(Bit16s * buf1, Bit16s *buf2, int len) {
      int tmplen = len >> 2;
      if (tmplen == 0) {
            return 0;
      }
#ifdef _MSC_VER
      __asm {
            mov ecx, tmplen
            mov esi, buf1
            mov edi, buf2

mixloop1:
            movq mm1, [edi]
            movq mm2, [esi]
            paddw mm1,mm2
            movq [esi],mm1
            add edi,8
            add esi,8

            dec ecx
            cmp ecx,0
            jg mixloop1
            emms
      }
#else
      atti386_mixBuffers(buf1, buf2, tmplen);
#endif
      return tmplen << 2;
}


int i386_mixBuffersRingMix(Bit16s * buf1, Bit16s *buf2, int len) {
      int tmplen = len >> 2;
      if (tmplen == 0) {
            return 0;
      }
#ifdef _MSC_VER
      __asm {
            mov ecx, tmplen
            mov esi, buf1
            mov edi, buf2

mixloop2:
            movq mm1, [esi]
            movq mm2, [edi]
            movq mm3, mm1
            pmulhw mm1, mm2
            paddw mm1,mm3
            movq [esi],mm1
            add edi,8
            add esi,8

            dec ecx
            cmp ecx,0
            jg mixloop2
            emms
      }
#else
      atti386_mixBuffersRingMix(buf1, buf2, tmplen);
#endif
      return tmplen << 2;
}

int i386_mixBuffersRing(Bit16s * buf1, Bit16s *buf2, int len) {
      int tmplen = len >> 2;
      if (tmplen == 0) {
            return 0;
      }
#ifdef _MSC_VER
      __asm {
            mov ecx, tmplen
            mov esi, buf1
            mov edi, buf2

mixloop3:
            movq mm1, [esi]
            movq mm2, [edi]
            pmulhw mm1, mm2
            movq [esi],mm1
            add edi,8
            add esi,8

            dec ecx
            cmp ecx,0
            jg mixloop3
            emms
      }
#else
      atti386_mixBuffersRing(buf1, buf2, tmplen);
#endif
      return tmplen << 2;
}

int i386_produceOutput1(Bit16s *useBuf, Bit16s *stream, Bit32u len, Bit16s volume) {
      int tmplen = (len >> 1);
      if (tmplen == 0) {
            return 0;
      }
#ifdef _MSC_VER
      __asm {
            mov ecx, tmplen
            mov ax,volume
            shl eax,16
            mov ax,volume
            movd mm3,eax
            movd mm2,eax
            psllq mm3, 32
            por mm3,mm2
            mov esi, useBuf
            mov edi, stream
mixloop4:
            movq mm1, [esi]
            movq mm2, [edi]
            pmulhw mm1, mm3
            paddw mm1,mm2
            movq [edi], mm1

            add esi,8
            add edi,8

            dec ecx
            cmp ecx,0
            jg mixloop4
            emms
      }
#else
      atti386_produceOutput1(tmplen, volume, useBuf, stream);
#endif
      return tmplen << 1;
}

#endif

}

#endif

Generated by  Doxygen 1.6.0   Back to index