/*

  SDL_mixer:  An audio mixer library based on the SDL library

  Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

  This file by Ryan C. Gordon (icculus@icculus.org)

  These are some internally supported special effects that use SDL_mixer's

  effect callback API. They are meant for speed over quality.  :)

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "SDL.h"

#include "SDL_endian.h"

#include "SDL_mixer.h"

#include "mixer.h"

#define MIX_INTERNAL_EFFECT__

#include "effects_internal.h"

/* profile code:

    #include <sys/time.h>

    #include <unistd.h>

    struct timeval tv1;

    struct timeval tv2;

    gettimeofday(&tv1, NULL);

        ... do your thing here ...

    gettimeofday(&tv2, NULL);

    printf("%ld\n", tv2.tv_usec - tv1.tv_usec);

*/

/*

 * Positional effects...panning, distance attenuation, etc.

 */

typedef struct _Eff_positionargs

{

    volatile float left_f;

    volatile float right_f;

    volatile Uint8 left_u8;

    volatile Uint8 right_u8;

    volatile float left_rear_f;

    volatile float right_rear_f;

    volatile float center_f;

    volatile float lfe_f;

    volatile Uint8 left_rear_u8;

    volatile Uint8 right_rear_u8;

    volatile Uint8 center_u8;

    volatile Uint8 lfe_u8;

    volatile float distance_f;

    volatile Uint8 distance_u8;

    volatile Sint16 room_angle;

    volatile int in_use;

    volatile int channels;

} position_args;

static position_args **pos_args_array = NULL;

static position_args *pos_args_global = NULL;

static int position_channels = 0;

void _Eff_PositionDeinit(void)

{

    int i;

    for (i = 0; i < position_channels; i++) {

        SDL_free(pos_args_array[i]);

    }

    position_channels = 0;

    SDL_free(pos_args_global);

    pos_args_global = NULL;

    SDL_free(pos_args_array);

    pos_args_array = NULL;

}

/* This just frees up the callback-specific data. */

static void SDLCALL _Eff_PositionDone(int channel, void *udata)

{

    (void)udata;

    if (channel < 0) {

        if (pos_args_global != NULL) {

            SDL_free(pos_args_global);

            pos_args_global = NULL;

        }

    }

    else if (pos_args_array[channel] != NULL) {

        SDL_free(pos_args_array[channel]);

        pos_args_array[channel] = NULL;

    }

}

static void SDLCALL _Eff_position_u8(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Uint8 *ptr = (Uint8 *) stream;

    int i;

    (void)chan;

    /*

     * if there's only a mono channnel (the only way we wouldn't have

     *  a len divisible by 2 here), then left_f and right_f are always

     *  1.0, and are therefore throwaways.

     */

    if (len % (int)sizeof(Uint16) != 0) {

        *ptr = (Uint8) (((float) *ptr) * args->distance_f);

        ptr++;

        len--;

    }

    if (args->room_angle == 180)

    for (i = 0; i < len; i += sizeof (Uint8) * 2) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

    }

    else for (i = 0; i < len; i += sizeof (Uint8) * 2) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

    }

}

static void SDLCALL _Eff_position_u8_c4(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Uint8 *ptr = (Uint8 *) stream;

    int i;

    (void)chan;

    /*

     * if there's only a mono channnel (the only way we wouldn't have

     *  a len divisible by 2 here), then left_f and right_f are always

     *  1.0, and are therefore throwaways.

     */

    if (len % (int)sizeof(Uint16) != 0) {

        *ptr = (Uint8) (((float) *ptr) * args->distance_f);

        ptr++;

        len--;

    }

    if (args->room_angle == 0)

    for (i = 0; i < len; i += sizeof (Uint8) * 6) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f) + 128);

        ptr++;

    }

    else if (args->room_angle == 90)

    for (i = 0; i < len; i += sizeof (Uint8) * 6) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f) + 128);

        ptr++;

    }

    else if (args->room_angle == 180)

    for (i = 0; i < len; i += sizeof (Uint8) * 6) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

    }

    else if (args->room_angle == 270)

    for (i = 0; i < len; i += sizeof (Uint8) * 6) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

    }

}

static void SDLCALL _Eff_position_u8_c6(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Uint8 *ptr = (Uint8 *) stream;

    int i;

    (void)chan;

    (void)len;

    /*

     * if there's only a mono channnel (the only way we wouldn't have

     *  a len divisible by 2 here), then left_f and right_f are always

     *  1.0, and are therefore throwaways.

     */

    if (len % (int)sizeof(Uint16) != 0) {

        *ptr = (Uint8) (((float) *ptr) * args->distance_f);

        ptr++;

        len--;

    }

    if (args->room_angle == 0)

    for (i = 0; i < len; i += sizeof (Uint8) * 6) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->center_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->lfe_f) * args->distance_f) + 128);

        ptr++;

    }

    else if (args->room_angle == 90)

    for (i = 0; i < len; i += sizeof (Uint8) * 6) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f/2) + 128)

            + (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f/2) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->lfe_f) * args->distance_f) + 128);

        ptr++;

    }

    else if (args->room_angle == 180)

    for (i = 0; i < len; i += sizeof (Uint8) * 6) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f/2) + 128)

            + (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f/2) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->lfe_f) * args->distance_f) + 128);

        ptr++;

    }

    else if (args->room_angle == 270)

    for (i = 0; i < len; i += sizeof (Uint8) * 6) {

        /* must adjust the sample so that 0 is the center */

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_rear_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->right_f) * args->distance_f) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_f) * args->distance_f/2) + 128)

            + (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->left_rear_f) * args->distance_f/2) + 128);

        ptr++;

        *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))

            * args->lfe_f) * args->distance_f) + 128);

        ptr++;

    }

}

/*

 * This one runs about 10.1 times faster than the non-table version, with

 *  no loss in quality. It does, however, require 64k of memory for the

 *  lookup table. Also, this will only update position information once per

 *  call; the non-table version always checks the arguments for each sample,

 *  in case the user has called Mix_SetPanning() or whatnot again while this

 *  callback is running.

 */

static void SDLCALL _Eff_position_table_u8(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Uint8 *ptr = (Uint8 *) stream;

    Uint32 *p;

    int i;

    Uint8 *l = ((Uint8 *) _Eff_volume_table) + (256 * args->left_u8);

    Uint8 *r = ((Uint8 *) _Eff_volume_table) + (256 * args->right_u8);

    Uint8 *d = ((Uint8 *) _Eff_volume_table) + (256 * args->distance_u8);

    (void)chan;

    if (args->room_angle == 180) {

        Uint8 *temp = l;

        l = r;

        r = temp;

    }

    /*

     * if there's only a mono channnel, then l[] and r[] are always

     *  volume 255, and are therefore throwaways. Still, we have to

     *  be sure not to overrun the audio buffer...

     */

    while (len % (int)sizeof(Uint32) != 0) {

        *ptr = d[l[*ptr]];

        ptr++;

        if (args->channels > 1) {

            *ptr = d[r[*ptr]];

            ptr++;

        }

        len -= args->channels;

    }

    p = (Uint32 *) ptr;

    for (i = 0; i < len; i += sizeof (Uint32)) {

#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)

        *p = (d[l[(*p & 0xFF000000) >> 24]] << 24) |

             (d[r[(*p & 0x00FF0000) >> 16]] << 16) |

             (d[l[(*p & 0x0000FF00) >>  8]] <<  8) |

             (d[r[(*p & 0x000000FF)      ]]     ) ;

#else

        *p = (d[r[(*p & 0xFF000000) >> 24]] << 24) |

             (d[l[(*p & 0x00FF0000) >> 16]] << 16) |

             (d[r[(*p & 0x0000FF00) >>  8]] <<  8) |

             (d[l[(*p & 0x000000FF)      ]]     ) ;

#endif

        ++p;

    }

}

static void SDLCALL _Eff_position_s8(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Sint8 *ptr = (Sint8 *) stream;

    int i;

    (void)chan;

    /*

     * if there's only a mono channnel (the only way we wouldn't have

     *  a len divisible by 2 here), then left_f and right_f are always

     *  1.0, and are therefore throwaways.

     */

    if (len % (int)sizeof(Sint16) != 0) {

        *ptr = (Sint8) (((float) *ptr) * args->distance_f);

        ptr++;

        len--;

    }

    if (args->room_angle == 180)

    for (i = 0; i < len; i += sizeof (Sint8) * 2) {

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f);

        ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f);

        ptr++;

    }

    else

    for (i = 0; i < len; i += sizeof (Sint8) * 2) {

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f);

        ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f);

        ptr++;

    }

}

static void SDLCALL _Eff_position_s8_c4(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Sint8 *ptr = (Sint8 *) stream;

    int i;

    (void)chan;

    /*

     * if there's only a mono channnel (the only way we wouldn't have

     *  a len divisible by 2 here), then left_f and right_f are always

     *  1.0, and are therefore throwaways.

     */

    if (len % (int)sizeof(Sint16) != 0) {

        *ptr = (Sint8) (((float) *ptr) * args->distance_f);

        ptr++;

        len--;

    }

    for (i = 0; i < len; i += sizeof (Sint8) * 4) {

      switch (args->room_angle) {

       case 0:

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;

        break;

       case 90:

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;

        break;

       case 180:

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;

        break;

       case 270:

        *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;

        break;

      }

    }

}

static void SDLCALL _Eff_position_s8_c6(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Sint8 *ptr = (Sint8 *) stream;

    int i;

    (void)chan;

    /*

     * if there's only a mono channnel (the only way we wouldn't have

     *  a len divisible by 2 here), then left_f and right_f are always

     *  1.0, and are therefore throwaways.

     */

    if (len % (int)sizeof(Sint16) != 0) {

        *ptr = (Sint8) (((float) *ptr) * args->distance_f);

        ptr++;

        len--;

    }

    for (i = 0; i < len; i += sizeof (Sint8) * 6) {

      switch (args->room_angle) {

       case 0:

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->center_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->lfe_f) * args->distance_f); ptr++;

        break;

       case 90:

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f / 2)

           + (Sint8)((((float) *ptr) * args->right_f) * args->distance_f / 2); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->lfe_f) * args->distance_f); ptr++;

        break;

       case 180:

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f / 2)

           + (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f / 2); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->lfe_f) * args->distance_f); ptr++;

        break;

       case 270:

        *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f / 2)

           + (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f / 2); ptr++;

        *ptr = (Sint8)((((float) *ptr) * args->lfe_f) * args->distance_f); ptr++;

        break;

      }

    }

}

/*

 * This one runs about 10.1 times faster than the non-table version, with

 *  no loss in quality. It does, however, require 64k of memory for the

 *  lookup table. Also, this will only update position information once per

 *  call; the non-table version always checks the arguments for each sample,

 *  in case the user has called Mix_SetPanning() or whatnot again while this

 *  callback is running.

 */

static void SDLCALL _Eff_position_table_s8(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Sint8 *ptr = (Sint8 *) stream;

    Uint32 *p;

    int i;

    Sint8 *l = ((Sint8 *) _Eff_volume_table) + (256 * args->left_u8);

    Sint8 *r = ((Sint8 *) _Eff_volume_table) + (256 * args->right_u8);

    Sint8 *d = ((Sint8 *) _Eff_volume_table) + (256 * args->distance_u8);

    (void)chan;

    if (args->room_angle == 180) {

        Sint8 *temp = l;

        l = r;

        r = temp;

    }

    while (len % (int)sizeof(Uint32) != 0) {

        *ptr = d[l[*ptr]];

        ptr++;

        if (args->channels > 1) {

            *ptr = d[r[*ptr]];

            ptr++;

        }

        len -= args->channels;

    }

    p = (Uint32 *) ptr;

    for (i = 0; i < len; i += sizeof (Uint32)) {

#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)

        *p = (d[l[((Sint16)(Sint8)((*p & 0xFF000000) >> 24))+128]] << 24) |

             (d[r[((Sint16)(Sint8)((*p & 0x00FF0000) >> 16))+128]] << 16) |

             (d[l[((Sint16)(Sint8)((*p & 0x0000FF00) >>  8))+128]] <<  8) |

             (d[r[((Sint16)(Sint8)((*p & 0x000000FF)     ))+128]]     ) ;

#else

        *p = (d[r[((Sint16)(Sint8)((*p & 0xFF000000) >> 24))+128]] << 24) |

             (d[l[((Sint16)(Sint8)((*p & 0x00FF0000) >> 16))+128]] << 16) |

             (d[r[((Sint16)(Sint8)((*p & 0x0000FF00) >>  8))+128]] <<  8) |

             (d[l[((Sint16)(Sint8)((*p & 0x000000FF)     ))+128]]     ) ;

#endif

        ++p;

    }

}

/* !!! FIXME : Optimize the code for 16-bit samples? */

static void SDLCALL _Eff_position_u16lsb(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Uint16 *ptr = (Uint16 *) stream;

    int i;

    (void)chan;

    for (i = 0; i < len; i += sizeof (Uint16) * 2) {

        Sint16 sampl = (Sint16) (SDL_SwapLE16(*(ptr+0)) - 32768);

        Sint16 sampr = (Sint16) (SDL_SwapLE16(*(ptr+1)) - 32768);

        Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)

                                    * args->distance_f) + 32768);

        Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)

                                    * args->distance_f) + 32768);

        if (args->room_angle == 180) {

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

        }

        else {

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

        }

    }

}

static void SDLCALL _Eff_position_u16lsb_c4(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Uint16 *ptr = (Uint16 *) stream;

    int i;

    (void)chan;

    for (i = 0; i < len; i += sizeof (Uint16) * 4) {

        Sint16 sampl = (Sint16) (SDL_SwapLE16(*(ptr+0)) - 32768);

        Sint16 sampr = (Sint16) (SDL_SwapLE16(*(ptr+1)) - 32768);

        Sint16 samplr = (Sint16) (SDL_SwapLE16(*(ptr+2)) - 32768);

        Sint16 samprr = (Sint16) (SDL_SwapLE16(*(ptr+3)) - 32768);

        Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)

                                    * args->distance_f) + 32768);

        Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)

                                    * args->distance_f) + 32768);

        Uint16 swaplr = (Uint16) ((Sint16) (((float) samplr * args->left_rear_f)

                                    * args->distance_f) + 32768);

        Uint16 swaprr = (Uint16) ((Sint16) (((float) samprr * args->right_rear_f)

                                    * args->distance_f) + 32768);

        switch (args->room_angle) {

        case 0:

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);

            break;

        case 90:

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);

            break;

        case 180:

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            break;

        case 270:

            *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            break;

        }

    }

}

static void SDLCALL _Eff_position_u16lsb_c6(int chan, void *stream, int len, void *udata)

{

    volatile position_args *args = (volatile position_args *) udata;

    Uint16 *ptr = (Uint16 *) stream;

    int i;

    (void)chan;

    for (i = 0; i < len; i += sizeof (Uint16) * 6) {

        Sint16 sampl = (Sint16) (SDL_SwapLE16(*(ptr+0)) - 32768);

        Sint16 sampr = (Sint16) (SDL_SwapLE16(*(ptr+1)) - 32768);

        Sint16 samplr = (Sint16) (SDL_SwapLE16(*(ptr+2)) - 32768);

        Sint16 samprr = (Sint16) (SDL_SwapLE16(*(ptr+3)) - 32768);

        Sint16 sampce = (Sint16) (SDL_SwapLE16(*(ptr+4)) - 32768);

        Sint16 sampwf = (Sint16) (SDL_SwapLE16(*(ptr+5)) - 32768);

        Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)

                                    * args->distance_f) + 32768);

        Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)

                                    * args->distance_f) + 32768);

        Uint16 swaplr = (Uint16) ((Sint16) (((float) samplr * args->left_rear_f)

                                    * args->distance_f) + 32768);

        Uint16 swaprr = (Uint16) ((Sint16) (((float) samprr * args->right_rear_f)

                                    * args->distance_f) + 32768);

        Uint16 swapce = (Uint16) ((Sint16) (((float) sampce * args->center_f)

                                    * args->distance_f) + 32768);

        Uint16 swapwf = (Uint16) ((Sint16) (((float) sampwf * args->lfe_f)

                                    * args->distance_f) + 32768);

        switch (args->room_angle) {

        case 0:

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapce);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapwf);

            break;

        case 90:

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr)/2 + (Uint16) SDL_SwapLE16(swaprr)/2;

            *(ptr++) = (Uint16) SDL_SwapLE16(swapwf);

            break;

        case 180:

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr)/2 + (Uint16) SDL_SwapLE16(swaplr)/2;

            *(ptr++) = (Uint16) SDL_SwapLE16(swapwf);

            break;

        case 270:

            *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapLE16(swapl)/2 + (Uint16) SDL_SwapLE16(swaplr)/2;

            *(ptr++) = (Uint16) SDL_SwapLE16(swapwf);

            break;

        }

    }

}

static void SDLCALL _Eff_position_s16lsb(int chan, void *stream, int len, void *udata)

{

    /* 16 signed bits (lsb) * 2 channels. */

    volatile position_args *args = (volatile position_args *) udata;

    Sint16 *ptr = (Sint16 *) stream;

    int i;

    (void)chan;

#if 0

    if (len % (int)(sizeof(Sint16) * 2)) {

        fprintf(stderr,"Not an even number of frames! len=%d\n", len);

        return;

    }

#endif

    for (i = 0; i < len; i += sizeof (Sint16) * 2) {

        Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+0))) *

                                    args->left_f) * args->distance_f);

        Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+1))) *

                                    args->right_f) * args->distance_f);

        if (args->room_angle == 180) {

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

        }

        else {

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

        }

    }

}

static void SDLCALL _Eff_position_s16lsb_c4(int chan, void *stream, int len, void *udata)

{

    /* 16 signed bits (lsb) * 4 channels. */

    volatile position_args *args = (volatile position_args *) udata;

    Sint16 *ptr = (Sint16 *) stream;

    int i;

    (void)chan;

    for (i = 0; i < len; i += sizeof (Sint16) * 4) {

        Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+0))) *

                                    args->left_f) * args->distance_f);

        Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+1))) *

                                    args->right_f) * args->distance_f);

        Sint16 swaplr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+1))) *

                                    args->left_rear_f) * args->distance_f);

        Sint16 swaprr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+2))) *

                                    args->right_rear_f) * args->distance_f);

        switch (args->room_angle) {

        case 0:

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);

            break;

        case 90:

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);

            break;

        case 180:

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            break;

        case 270:

            *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            break;

        }

    }

}

static void SDLCALL _Eff_position_s16lsb_c6(int chan, void *stream, int len, void *udata)

{

    /* 16 signed bits (lsb) * 6 channels. */

    volatile position_args *args = (volatile position_args *) udata;

    Sint16 *ptr = (Sint16 *) stream;

    int i;

    (void)chan;

    for (i = 0; i < len; i += sizeof (Sint16) * 6) {

        Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+0))) *

                                    args->left_f) * args->distance_f);

        Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+1))) *

                                    args->right_f) * args->distance_f);

        Sint16 swaplr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+2))) *

                                    args->left_rear_f) * args->distance_f);

        Sint16 swaprr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+3))) *

                                    args->right_rear_f) * args->distance_f);

        Sint16 swapce = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+4))) *

                                    args->center_f) * args->distance_f);

        Sint16 swapwf = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+5))) *

                                    args->lfe_f) * args->distance_f);

        switch (args->room_angle) {

        case 0:

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapce);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapwf);

            break;

        case 90:

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr)/2 + (Sint16) SDL_SwapLE16(swaprr)/2;

            *(ptr++) = (Sint16) SDL_SwapLE16(swapwf);

            break;

        case 180:

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr)/2 + (Sint16) SDL_SwapLE16(swaplr)/2;

            *(ptr++) = (Sint16) SDL_SwapLE16(swapwf);

            break;

        case 270:

            *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl);

            *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapr);

            *(ptr++) = (Sint16) SDL_SwapLE16(swapl)/2 + (Sint16) SDL_SwapLE16(swaplr)/2;

            *(ptr++) = (Sint16) SDL_SwapLE16(swapwf);

            break;

        }

    }

}

static void SDLCALL _Eff_position_u16msb(int chan, void *stream, int len, void *udata)

{

    /* 16 signed bits (lsb) * 2 channels. */

    volatile position_args *args = (volatile position_args *) udata;

    Uint16 *ptr = (Uint16 *) stream;

    int i;

    (void)chan;

    for (i = 0; i < len; i += sizeof (Sint16) * 2) {

        Sint16 sampl = (Sint16) (SDL_SwapBE16(*(ptr+0)) - 32768);

        Sint16 sampr = (Sint16) (SDL_SwapBE16(*(ptr+1)) - 32768);

        Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)

                                    * args->distance_f) + 32768);

        Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)

                                    * args->distance_f) + 32768);

        if (args->room_angle == 180) {

            *(ptr++) = (Uint16) SDL_SwapBE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swapl);

        }

        else {

            *(ptr++) = (Uint16) SDL_SwapBE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapBE16(swapr);

        }

    }

}

static void SDLCALL _Eff_position_u16msb_c4(int chan, void *stream, int len, void *udata)

{

    /* 16 signed bits (lsb) * 4 channels. */

    volatile position_args *args = (volatile position_args *) udata;

    Uint16 *ptr = (Uint16 *) stream;

    int i;

    (void)chan;

    for (i = 0; i < len; i += sizeof (Sint16) * 4) {

        Sint16 sampl = (Sint16) (SDL_SwapBE16(*(ptr+0)) - 32768);

        Sint16 sampr = (Sint16) (SDL_SwapBE16(*(ptr+1)) - 32768);

        Sint16 samplr = (Sint16) (SDL_SwapBE16(*(ptr+2)) - 32768);

        Sint16 samprr = (Sint16) (SDL_SwapBE16(*(ptr+3)) - 32768);

        Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)

                                    * args->distance_f) + 32768);

        Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)

                                    * args->distance_f) + 32768);

        Uint16 swaplr = (Uint16) ((Sint16) (((float) samplr * args->left_rear_f)

                                    * args->distance_f) + 32768);

        Uint16 swaprr = (Uint16) ((Sint16) (((float) samprr * args->right_rear_f)

                                    * args->distance_f) + 32768);

        switch (args->room_angle) {

        case 0:

            *(ptr++) = (Uint16) SDL_SwapBE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapBE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);

            break;

        case 90:

            *(ptr++) = (Uint16) SDL_SwapBE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);

            break;

        case 180:

            *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swapr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swapl);

            break;

        case 270:

            *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swapl);

            *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);

            *(ptr++) = (Uint16) SDL_SwapBE16(swapr);

            break;

        }

    }

}

static void SDLCALL _Eff_position_u16msb_c6(int chan, void *stream, int len, void *udata)

{

    /* 16 signed bits (lsb) * 6 channels. */

    volatile position_args *args = (volatile position_args *) udata;

    Uint16 *ptr = (Uint16 *) stream;

    int i;

    (void)chan;

    for (i = 0; i < len; i += sizeof (Sint16) * 6) {

        Sint16 sampl = (Sint16) (SDL_SwapBE16(*(ptr+0)) - 32768);

        Sint16 sampr = (Sint16) (SDL_SwapBE16(*(ptr+1)) - 32768);

        Sint16 samplr = (Sint16) (SDL_SwapBE16(*(ptr+2)) - 32768);