effect_position.c
author Ozkan Sezer <sezero@users.sourceforge.net>
Sat, 21 Oct 2017 17:00:00 +0300
changeset 817 aef7a1784ffd
parent 800 cc4aef7fef64
child 848 3907db698eb5
permissions -rw-r--r--
Specify SDLCALL as the calling convention for API callbacks.
This is in parallel with bug #3745.
     1 /*
     2   SDL_mixer:  An audio mixer library based on the SDL library
     3   Copyright (C) 1997-2017 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 
    21   This file by Ryan C. Gordon (icculus@icculus.org)
    22 
    23   These are some internally supported special effects that use SDL_mixer's
    24   effect callback API. They are meant for speed over quality.  :)
    25 */
    26 
    27 /* $Id$ */
    28 
    29 #include <stdio.h>
    30 #include <stdlib.h>
    31 #include <string.h>
    32 
    33 #include "SDL.h"
    34 #include "SDL_endian.h"
    35 #include "SDL_mixer.h"
    36 #include "mixer.h"
    37 
    38 #define __MIX_INTERNAL_EFFECT__
    39 #include "effects_internal.h"
    40 
    41 /* profile code:
    42     #include <sys/time.h>
    43     #include <unistd.h>
    44     struct timeval tv1;
    45     struct timeval tv2;
    46 
    47     gettimeofday(&tv1, NULL);
    48 
    49         ... do your thing here ...
    50 
    51     gettimeofday(&tv2, NULL);
    52     printf("%ld\n", tv2.tv_usec - tv1.tv_usec);
    53 */
    54 
    55 
    56 /*
    57  * Positional effects...panning, distance attenuation, etc.
    58  */
    59 
    60 typedef struct _Eff_positionargs
    61 {
    62     volatile float left_f;
    63     volatile float right_f;
    64     volatile Uint8 left_u8;
    65     volatile Uint8 right_u8;
    66     volatile float left_rear_f;
    67     volatile float right_rear_f;
    68     volatile float center_f;
    69     volatile float lfe_f;
    70     volatile Uint8 left_rear_u8;
    71     volatile Uint8 right_rear_u8;
    72     volatile Uint8 center_u8;
    73     volatile Uint8 lfe_u8;
    74     volatile float distance_f;
    75     volatile Uint8 distance_u8;
    76     volatile Sint16 room_angle;
    77     volatile int in_use;
    78     volatile int channels;
    79 } position_args;
    80 
    81 static position_args **pos_args_array = NULL;
    82 static position_args *pos_args_global = NULL;
    83 static int position_channels = 0;
    84 
    85 void _Eff_PositionDeinit(void)
    86 {
    87     int i;
    88     for (i = 0; i < position_channels; i++) {
    89         SDL_free(pos_args_array[i]);
    90     }
    91 
    92     position_channels = 0;
    93 
    94     SDL_free(pos_args_global);
    95     pos_args_global = NULL;
    96     SDL_free(pos_args_array);
    97     pos_args_array = NULL;
    98 }
    99 
   100 
   101 /* This just frees up the callback-specific data. */
   102 static void SDLCALL _Eff_PositionDone(int channel, void *udata)
   103 {
   104     if (channel < 0) {
   105         if (pos_args_global != NULL) {
   106             SDL_free(pos_args_global);
   107             pos_args_global = NULL;
   108         }
   109     }
   110 
   111     else if (pos_args_array[channel] != NULL) {
   112         SDL_free(pos_args_array[channel]);
   113         pos_args_array[channel] = NULL;
   114     }
   115 }
   116 
   117 
   118 static void SDLCALL _Eff_position_u8(int chan, void *stream, int len, void *udata)
   119 {
   120     volatile position_args *args = (volatile position_args *) udata;
   121     Uint8 *ptr = (Uint8 *) stream;
   122     int i;
   123 
   124         /*
   125          * if there's only a mono channnel (the only way we wouldn't have
   126          *  a len divisible by 2 here), then left_f and right_f are always
   127          *  1.0, and are therefore throwaways.
   128          */
   129     if (len % sizeof (Uint16) != 0) {
   130         *ptr = (Uint8) (((float) *ptr) * args->distance_f);
   131         ptr++;
   132         len--;
   133     }
   134 
   135     if (args->room_angle == 180)
   136     for (i = 0; i < len; i += sizeof (Uint8) * 2) {
   137         /* must adjust the sample so that 0 is the center */
   138         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   139             * args->right_f) * args->distance_f) + 128);
   140         ptr++;
   141         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   142             * args->left_f) * args->distance_f) + 128);
   143         ptr++;
   144     }
   145     else for (i = 0; i < len; i += sizeof (Uint8) * 2) {
   146         /* must adjust the sample so that 0 is the center */
   147         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   148             * args->left_f) * args->distance_f) + 128);
   149         ptr++;
   150         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   151             * args->right_f) * args->distance_f) + 128);
   152         ptr++;
   153     }
   154 }
   155 static void SDLCALL _Eff_position_u8_c4(int chan, void *stream, int len, void *udata)
   156 {
   157     volatile position_args *args = (volatile position_args *) udata;
   158     Uint8 *ptr = (Uint8 *) stream;
   159     int i;
   160 
   161         /*
   162          * if there's only a mono channnel (the only way we wouldn't have
   163          *  a len divisible by 2 here), then left_f and right_f are always
   164          *  1.0, and are therefore throwaways.
   165          */
   166     if (len % sizeof (Uint16) != 0) {
   167         *ptr = (Uint8) (((float) *ptr) * args->distance_f);
   168         ptr++;
   169         len--;
   170     }
   171 
   172     if (args->room_angle == 0)
   173     for (i = 0; i < len; i += sizeof (Uint8) * 6) {
   174         /* must adjust the sample so that 0 is the center */
   175         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   176             * args->left_f) * args->distance_f) + 128);
   177         ptr++;
   178         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   179             * args->right_f) * args->distance_f) + 128);
   180         ptr++;
   181         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   182             * args->left_rear_f) * args->distance_f) + 128);
   183         ptr++;
   184         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   185             * args->right_rear_f) * args->distance_f) + 128);
   186         ptr++;
   187     }
   188     else if (args->room_angle == 90)
   189     for (i = 0; i < len; i += sizeof (Uint8) * 6) {
   190         /* must adjust the sample so that 0 is the center */
   191         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   192             * args->right_f) * args->distance_f) + 128);
   193         ptr++;
   194         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   195             * args->right_rear_f) * args->distance_f) + 128);
   196         ptr++;
   197         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   198             * args->left_f) * args->distance_f) + 128);
   199         ptr++;
   200         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   201             * args->left_rear_f) * args->distance_f) + 128);
   202         ptr++;
   203     }
   204     else if (args->room_angle == 180)
   205     for (i = 0; i < len; i += sizeof (Uint8) * 6) {
   206         /* must adjust the sample so that 0 is the center */
   207         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   208             * args->right_rear_f) * args->distance_f) + 128);
   209         ptr++;
   210         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   211             * args->left_rear_f) * args->distance_f) + 128);
   212         ptr++;
   213         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   214             * args->right_f) * args->distance_f) + 128);
   215         ptr++;
   216         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   217             * args->left_f) * args->distance_f) + 128);
   218         ptr++;
   219     }
   220     else if (args->room_angle == 270)
   221     for (i = 0; i < len; i += sizeof (Uint8) * 6) {
   222         /* must adjust the sample so that 0 is the center */
   223         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   224             * args->left_rear_f) * args->distance_f) + 128);
   225         ptr++;
   226         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   227             * args->left_f) * args->distance_f) + 128);
   228         ptr++;
   229         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   230             * args->right_rear_f) * args->distance_f) + 128);
   231         ptr++;
   232         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   233             * args->right_f) * args->distance_f) + 128);
   234         ptr++;
   235     }
   236 }
   237 
   238 
   239 static void SDLCALL _Eff_position_u8_c6(int chan, void *stream, int len, void *udata)
   240 {
   241     volatile position_args *args = (volatile position_args *) udata;
   242     Uint8 *ptr = (Uint8 *) stream;
   243     int i;
   244 
   245         /*
   246          * if there's only a mono channnel (the only way we wouldn't have
   247          *  a len divisible by 2 here), then left_f and right_f are always
   248          *  1.0, and are therefore throwaways.
   249          */
   250     if (len % sizeof (Uint16) != 0) {
   251         *ptr = (Uint8) (((float) *ptr) * args->distance_f);
   252         ptr++;
   253         len--;
   254     }
   255 
   256     if (args->room_angle == 0)
   257     for (i = 0; i < len; i += sizeof (Uint8) * 6) {
   258         /* must adjust the sample so that 0 is the center */
   259         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   260             * args->left_f) * args->distance_f) + 128);
   261         ptr++;
   262         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   263             * args->right_f) * args->distance_f) + 128);
   264         ptr++;
   265         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   266             * args->left_rear_f) * args->distance_f) + 128);
   267         ptr++;
   268         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   269             * args->right_rear_f) * args->distance_f) + 128);
   270         ptr++;
   271         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   272             * args->center_f) * args->distance_f) + 128);
   273         ptr++;
   274         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   275             * args->lfe_f) * args->distance_f) + 128);
   276         ptr++;
   277     }
   278     else if (args->room_angle == 90)
   279     for (i = 0; i < len; i += sizeof (Uint8) * 6) {
   280         /* must adjust the sample so that 0 is the center */
   281         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   282             * args->right_f) * args->distance_f) + 128);
   283         ptr++;
   284         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   285             * args->right_rear_f) * args->distance_f) + 128);
   286         ptr++;
   287         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   288             * args->left_f) * args->distance_f) + 128);
   289         ptr++;
   290         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   291             * args->left_rear_f) * args->distance_f) + 128);
   292         ptr++;
   293         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   294             * args->right_rear_f) * args->distance_f/2) + 128)
   295             + (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   296             * args->right_f) * args->distance_f/2) + 128);
   297         ptr++;
   298         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   299             * args->lfe_f) * args->distance_f) + 128);
   300         ptr++;
   301     }
   302     else if (args->room_angle == 180)
   303     for (i = 0; i < len; i += sizeof (Uint8) * 6) {
   304         /* must adjust the sample so that 0 is the center */
   305         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   306             * args->right_rear_f) * args->distance_f) + 128);
   307         ptr++;
   308         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   309             * args->left_rear_f) * args->distance_f) + 128);
   310         ptr++;
   311         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   312             * args->right_f) * args->distance_f) + 128);
   313         ptr++;
   314         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   315             * args->left_f) * args->distance_f) + 128);
   316         ptr++;
   317         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   318             * args->right_rear_f) * args->distance_f/2) + 128)
   319             + (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   320             * args->left_rear_f) * args->distance_f/2) + 128);
   321         ptr++;
   322         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   323             * args->lfe_f) * args->distance_f) + 128);
   324         ptr++;
   325     }
   326     else if (args->room_angle == 270)
   327     for (i = 0; i < len; i += sizeof (Uint8) * 6) {
   328         /* must adjust the sample so that 0 is the center */
   329         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   330             * args->left_rear_f) * args->distance_f) + 128);
   331         ptr++;
   332         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   333             * args->left_f) * args->distance_f) + 128);
   334         ptr++;
   335         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   336             * args->right_rear_f) * args->distance_f) + 128);
   337         ptr++;
   338         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   339             * args->right_f) * args->distance_f) + 128);
   340         ptr++;
   341         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   342             * args->left_f) * args->distance_f/2) + 128)
   343             + (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   344             * args->left_rear_f) * args->distance_f/2) + 128);
   345         ptr++;
   346         *ptr = (Uint8) ((Sint8) ((((float) (Sint8) (*ptr - 128))
   347             * args->lfe_f) * args->distance_f) + 128);
   348         ptr++;
   349     }
   350 }
   351 
   352 
   353 /*
   354  * This one runs about 10.1 times faster than the non-table version, with
   355  *  no loss in quality. It does, however, require 64k of memory for the
   356  *  lookup table. Also, this will only update position information once per
   357  *  call; the non-table version always checks the arguments for each sample,
   358  *  in case the user has called Mix_SetPanning() or whatnot again while this
   359  *  callback is running.
   360  */
   361 static void SDLCALL _Eff_position_table_u8(int chan, void *stream, int len, void *udata)
   362 {
   363     volatile position_args *args = (volatile position_args *) udata;
   364     Uint8 *ptr = (Uint8 *) stream;
   365     Uint32 *p;
   366     int i;
   367     Uint8 *l = ((Uint8 *) _Eff_volume_table) + (256 * args->left_u8);
   368     Uint8 *r = ((Uint8 *) _Eff_volume_table) + (256 * args->right_u8);
   369     Uint8 *d = ((Uint8 *) _Eff_volume_table) + (256 * args->distance_u8);
   370 
   371     if (args->room_angle == 180) {
   372         Uint8 *temp = l;
   373         l = r;
   374         r = temp;
   375     }
   376         /*
   377          * if there's only a mono channnel, then l[] and r[] are always
   378          *  volume 255, and are therefore throwaways. Still, we have to
   379          *  be sure not to overrun the audio buffer...
   380          */
   381     while (len % sizeof (Uint32) != 0) {
   382         *ptr = d[l[*ptr]];
   383         ptr++;
   384         if (args->channels > 1) {
   385             *ptr = d[r[*ptr]];
   386             ptr++;
   387         }
   388         len -= args->channels;
   389     }
   390 
   391     p = (Uint32 *) ptr;
   392 
   393     for (i = 0; i < len; i += sizeof (Uint32)) {
   394 #if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
   395         *p = (d[l[(*p & 0xFF000000) >> 24]] << 24) |
   396              (d[r[(*p & 0x00FF0000) >> 16]] << 16) |
   397              (d[l[(*p & 0x0000FF00) >>  8]] <<  8) |
   398              (d[r[(*p & 0x000000FF)      ]]     ) ;
   399 #else
   400         *p = (d[r[(*p & 0xFF000000) >> 24]] << 24) |
   401              (d[l[(*p & 0x00FF0000) >> 16]] << 16) |
   402              (d[r[(*p & 0x0000FF00) >>  8]] <<  8) |
   403              (d[l[(*p & 0x000000FF)      ]]     ) ;
   404 #endif
   405         ++p;
   406     }
   407 }
   408 
   409 
   410 static void SDLCALL _Eff_position_s8(int chan, void *stream, int len, void *udata)
   411 {
   412     volatile position_args *args = (volatile position_args *) udata;
   413     Sint8 *ptr = (Sint8 *) stream;
   414     int i;
   415 
   416         /*
   417          * if there's only a mono channnel (the only way we wouldn't have
   418          *  a len divisible by 2 here), then left_f and right_f are always
   419          *  1.0, and are therefore throwaways.
   420          */
   421     if (len % sizeof (Sint16) != 0) {
   422         *ptr = (Sint8) (((float) *ptr) * args->distance_f);
   423         ptr++;
   424         len--;
   425     }
   426 
   427     if (args->room_angle == 180)
   428     for (i = 0; i < len; i += sizeof (Sint8) * 2) {
   429         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f);
   430         ptr++;
   431         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f);
   432         ptr++;
   433     }
   434     else
   435     for (i = 0; i < len; i += sizeof (Sint8) * 2) {
   436         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f);
   437         ptr++;
   438         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f);
   439         ptr++;
   440     }
   441 }
   442 static void SDLCALL _Eff_position_s8_c4(int chan, void *stream, int len, void *udata)
   443 {
   444     volatile position_args *args = (volatile position_args *) udata;
   445     Sint8 *ptr = (Sint8 *) stream;
   446     int i;
   447 
   448         /*
   449          * if there's only a mono channnel (the only way we wouldn't have
   450          *  a len divisible by 2 here), then left_f and right_f are always
   451          *  1.0, and are therefore throwaways.
   452          */
   453     if (len % sizeof (Sint16) != 0) {
   454         *ptr = (Sint8) (((float) *ptr) * args->distance_f);
   455         ptr++;
   456         len--;
   457     }
   458 
   459     for (i = 0; i < len; i += sizeof (Sint8) * 4) {
   460       switch (args->room_angle) {
   461        case 0:
   462         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;
   463         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;
   464         *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;
   465         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;
   466     break;
   467        case 90:
   468         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;
   469         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;
   470         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;
   471         *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;
   472     break;
   473        case 180:
   474         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;
   475         *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;
   476         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;
   477         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;
   478     break;
   479        case 270:
   480         *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;
   481         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;
   482         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;
   483         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;
   484     break;
   485       }
   486     }
   487 }
   488 static void SDLCALL _Eff_position_s8_c6(int chan, void *stream, int len, void *udata)
   489 {
   490     volatile position_args *args = (volatile position_args *) udata;
   491     Sint8 *ptr = (Sint8 *) stream;
   492     int i;
   493 
   494         /*
   495          * if there's only a mono channnel (the only way we wouldn't have
   496          *  a len divisible by 2 here), then left_f and right_f are always
   497          *  1.0, and are therefore throwaways.
   498          */
   499     if (len % sizeof (Sint16) != 0) {
   500         *ptr = (Sint8) (((float) *ptr) * args->distance_f);
   501         ptr++;
   502         len--;
   503     }
   504 
   505     for (i = 0; i < len; i += sizeof (Sint8) * 6) {
   506       switch (args->room_angle) {
   507        case 0:
   508         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;
   509         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;
   510         *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;
   511         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;
   512         *ptr = (Sint8)((((float) *ptr) * args->center_f) * args->distance_f); ptr++;
   513         *ptr = (Sint8)((((float) *ptr) * args->lfe_f) * args->distance_f); ptr++;
   514     break;
   515        case 90:
   516         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;
   517         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;
   518         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;
   519         *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;
   520         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f / 2)
   521            + (Sint8)((((float) *ptr) * args->right_f) * args->distance_f / 2); ptr++;
   522         *ptr = (Sint8)((((float) *ptr) * args->lfe_f) * args->distance_f); ptr++;
   523     break;
   524        case 180:
   525         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;
   526         *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;
   527         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;
   528         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;
   529         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f / 2)
   530            + (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f / 2); ptr++;
   531         *ptr = (Sint8)((((float) *ptr) * args->lfe_f) * args->distance_f); ptr++;
   532     break;
   533        case 270:
   534         *ptr = (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f); ptr++;
   535         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f); ptr++;
   536         *ptr = (Sint8)((((float) *ptr) * args->right_rear_f) * args->distance_f); ptr++;
   537         *ptr = (Sint8)((((float) *ptr) * args->right_f) * args->distance_f); ptr++;
   538         *ptr = (Sint8)((((float) *ptr) * args->left_f) * args->distance_f / 2)
   539            + (Sint8)((((float) *ptr) * args->left_rear_f) * args->distance_f / 2); ptr++;
   540         *ptr = (Sint8)((((float) *ptr) * args->lfe_f) * args->distance_f); ptr++;
   541     break;
   542       }
   543     }
   544 }
   545 
   546 
   547 /*
   548  * This one runs about 10.1 times faster than the non-table version, with
   549  *  no loss in quality. It does, however, require 64k of memory for the
   550  *  lookup table. Also, this will only update position information once per
   551  *  call; the non-table version always checks the arguments for each sample,
   552  *  in case the user has called Mix_SetPanning() or whatnot again while this
   553  *  callback is running.
   554  */
   555 static void SDLCALL _Eff_position_table_s8(int chan, void *stream, int len, void *udata)
   556 {
   557     volatile position_args *args = (volatile position_args *) udata;
   558     Sint8 *ptr = (Sint8 *) stream;
   559     Uint32 *p;
   560     int i;
   561     Sint8 *l = ((Sint8 *) _Eff_volume_table) + (256 * args->left_u8);
   562     Sint8 *r = ((Sint8 *) _Eff_volume_table) + (256 * args->right_u8);
   563     Sint8 *d = ((Sint8 *) _Eff_volume_table) + (256 * args->distance_u8);
   564 
   565     if (args->room_angle == 180) {
   566         Sint8 *temp = l;
   567         l = r;
   568         r = temp;
   569     }
   570 
   571 
   572     while (len % sizeof (Uint32) != 0) {
   573         *ptr = d[l[*ptr]];
   574         ptr++;
   575         if (args->channels > 1) {
   576             *ptr = d[r[*ptr]];
   577             ptr++;
   578         }
   579         len -= args->channels;
   580     }
   581 
   582     p = (Uint32 *) ptr;
   583 
   584     for (i = 0; i < len; i += sizeof (Uint32)) {
   585 #if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
   586         *p = (d[l[((Sint16)(Sint8)((*p & 0xFF000000) >> 24))+128]] << 24) |
   587              (d[r[((Sint16)(Sint8)((*p & 0x00FF0000) >> 16))+128]] << 16) |
   588              (d[l[((Sint16)(Sint8)((*p & 0x0000FF00) >>  8))+128]] <<  8) |
   589              (d[r[((Sint16)(Sint8)((*p & 0x000000FF)     ))+128]]     ) ;
   590 #else
   591         *p = (d[r[((Sint16)(Sint8)((*p & 0xFF000000) >> 24))+128]] << 24) |
   592              (d[l[((Sint16)(Sint8)((*p & 0x00FF0000) >> 16))+128]] << 16) |
   593              (d[r[((Sint16)(Sint8)((*p & 0x0000FF00) >>  8))+128]] <<  8) |
   594              (d[l[((Sint16)(Sint8)((*p & 0x000000FF)     ))+128]]     ) ;
   595 #endif
   596         ++p;
   597     }
   598 
   599 
   600 }
   601 
   602 
   603 /* !!! FIXME : Optimize the code for 16-bit samples? */
   604 
   605 static void SDLCALL _Eff_position_u16lsb(int chan, void *stream, int len, void *udata)
   606 {
   607     volatile position_args *args = (volatile position_args *) udata;
   608     Uint16 *ptr = (Uint16 *) stream;
   609     int i;
   610 
   611     for (i = 0; i < len; i += sizeof (Uint16) * 2) {
   612         Sint16 sampl = (Sint16) (SDL_SwapLE16(*(ptr+0)) - 32768);
   613         Sint16 sampr = (Sint16) (SDL_SwapLE16(*(ptr+1)) - 32768);
   614 
   615         Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)
   616                                     * args->distance_f) + 32768);
   617         Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)
   618                                     * args->distance_f) + 32768);
   619 
   620     if (args->room_angle == 180) {
   621             *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   622             *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   623     }
   624     else {
   625             *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   626             *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   627     }
   628     }
   629 }
   630 static void SDLCALL _Eff_position_u16lsb_c4(int chan, void *stream, int len, void *udata)
   631 {
   632     volatile position_args *args = (volatile position_args *) udata;
   633     Uint16 *ptr = (Uint16 *) stream;
   634     int i;
   635 
   636     for (i = 0; i < len; i += sizeof (Uint16) * 4) {
   637         Sint16 sampl = (Sint16) (SDL_SwapLE16(*(ptr+0)) - 32768);
   638         Sint16 sampr = (Sint16) (SDL_SwapLE16(*(ptr+1)) - 32768);
   639         Sint16 samplr = (Sint16) (SDL_SwapLE16(*(ptr+2)) - 32768);
   640         Sint16 samprr = (Sint16) (SDL_SwapLE16(*(ptr+3)) - 32768);
   641 
   642         Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)
   643                                     * args->distance_f) + 32768);
   644         Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)
   645                                     * args->distance_f) + 32768);
   646         Uint16 swaplr = (Uint16) ((Sint16) (((float) samplr * args->left_rear_f)
   647                                     * args->distance_f) + 32768);
   648         Uint16 swaprr = (Uint16) ((Sint16) (((float) samprr * args->right_rear_f)
   649                                     * args->distance_f) + 32768);
   650 
   651     switch (args->room_angle) {
   652         case 0:
   653                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   654                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   655                 *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);
   656                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);
   657             break;
   658         case 90:
   659                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   660                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);
   661                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   662                 *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);
   663             break;
   664         case 180:
   665                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);
   666                 *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);
   667                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   668                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   669             break;
   670         case 270:
   671                 *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);
   672                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   673                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);
   674                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   675             break;
   676     }
   677     }
   678 }
   679 static void SDLCALL _Eff_position_u16lsb_c6(int chan, void *stream, int len, void *udata)
   680 {
   681     volatile position_args *args = (volatile position_args *) udata;
   682     Uint16 *ptr = (Uint16 *) stream;
   683     int i;
   684 
   685     for (i = 0; i < len; i += sizeof (Uint16) * 6) {
   686         Sint16 sampl = (Sint16) (SDL_SwapLE16(*(ptr+0)) - 32768);
   687         Sint16 sampr = (Sint16) (SDL_SwapLE16(*(ptr+1)) - 32768);
   688         Sint16 samplr = (Sint16) (SDL_SwapLE16(*(ptr+2)) - 32768);
   689         Sint16 samprr = (Sint16) (SDL_SwapLE16(*(ptr+3)) - 32768);
   690         Sint16 sampce = (Sint16) (SDL_SwapLE16(*(ptr+4)) - 32768);
   691         Sint16 sampwf = (Sint16) (SDL_SwapLE16(*(ptr+5)) - 32768);
   692 
   693         Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)
   694                                     * args->distance_f) + 32768);
   695         Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)
   696                                     * args->distance_f) + 32768);
   697         Uint16 swaplr = (Uint16) ((Sint16) (((float) samplr * args->left_rear_f)
   698                                     * args->distance_f) + 32768);
   699         Uint16 swaprr = (Uint16) ((Sint16) (((float) samprr * args->right_rear_f)
   700                                     * args->distance_f) + 32768);
   701         Uint16 swapce = (Uint16) ((Sint16) (((float) sampce * args->center_f)
   702                                     * args->distance_f) + 32768);
   703         Uint16 swapwf = (Uint16) ((Sint16) (((float) sampwf * args->lfe_f)
   704                                     * args->distance_f) + 32768);
   705 
   706     switch (args->room_angle) {
   707         case 0:
   708                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   709                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   710                 *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);
   711                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);
   712                 *(ptr++) = (Uint16) SDL_SwapLE16(swapce);
   713                 *(ptr++) = (Uint16) SDL_SwapLE16(swapwf);
   714             break;
   715         case 90:
   716                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   717                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);
   718                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   719                 *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);
   720                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr)/2 + (Uint16) SDL_SwapLE16(swaprr)/2;
   721                 *(ptr++) = (Uint16) SDL_SwapLE16(swapwf);
   722             break;
   723         case 180:
   724                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);
   725                 *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);
   726                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   727                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   728                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr)/2 + (Uint16) SDL_SwapLE16(swaplr)/2;
   729                 *(ptr++) = (Uint16) SDL_SwapLE16(swapwf);
   730             break;
   731         case 270:
   732                 *(ptr++) = (Uint16) SDL_SwapLE16(swaplr);
   733                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl);
   734                 *(ptr++) = (Uint16) SDL_SwapLE16(swaprr);
   735                 *(ptr++) = (Uint16) SDL_SwapLE16(swapr);
   736                 *(ptr++) = (Uint16) SDL_SwapLE16(swapl)/2 + (Uint16) SDL_SwapLE16(swaplr)/2;
   737                 *(ptr++) = (Uint16) SDL_SwapLE16(swapwf);
   738             break;
   739     }
   740     }
   741 }
   742 
   743 static void SDLCALL _Eff_position_s16lsb(int chan, void *stream, int len, void *udata)
   744 {
   745     /* 16 signed bits (lsb) * 2 channels. */
   746     volatile position_args *args = (volatile position_args *) udata;
   747     Sint16 *ptr = (Sint16 *) stream;
   748     int i;
   749 
   750 #if 0
   751     if (len % (sizeof(Sint16) * 2)) {
   752         fprintf(stderr,"Not an even number of frames! len=%d\n", len);
   753         return;
   754     }
   755 #endif
   756 
   757     for (i = 0; i < len; i += sizeof (Sint16) * 2) {
   758         Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+0))) *
   759                                     args->left_f) * args->distance_f);
   760         Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+1))) *
   761                                     args->right_f) * args->distance_f);
   762     if (args->room_angle == 180) {
   763             *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   764             *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   765     }
   766     else {
   767             *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   768             *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   769     }
   770     }
   771 }
   772 static void SDLCALL _Eff_position_s16lsb_c4(int chan, void *stream, int len, void *udata)
   773 {
   774     /* 16 signed bits (lsb) * 4 channels. */
   775     volatile position_args *args = (volatile position_args *) udata;
   776     Sint16 *ptr = (Sint16 *) stream;
   777     int i;
   778 
   779     for (i = 0; i < len; i += sizeof (Sint16) * 4) {
   780         Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+0))) *
   781                                     args->left_f) * args->distance_f);
   782         Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+1))) *
   783                                     args->right_f) * args->distance_f);
   784         Sint16 swaplr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+1))) *
   785                                     args->left_rear_f) * args->distance_f);
   786         Sint16 swaprr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+2))) *
   787                                     args->right_rear_f) * args->distance_f);
   788     switch (args->room_angle) {
   789         case 0:
   790                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   791                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   792                 *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);
   793                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);
   794             break;
   795         case 90:
   796                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   797                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);
   798                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   799                 *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);
   800             break;
   801         case 180:
   802                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);
   803                 *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);
   804                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   805                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   806             break;
   807         case 270:
   808                 *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);
   809                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   810                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);
   811                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   812             break;
   813     }
   814     }
   815 }
   816 
   817 static void SDLCALL _Eff_position_s16lsb_c6(int chan, void *stream, int len, void *udata)
   818 {
   819     /* 16 signed bits (lsb) * 6 channels. */
   820     volatile position_args *args = (volatile position_args *) udata;
   821     Sint16 *ptr = (Sint16 *) stream;
   822     int i;
   823 
   824     for (i = 0; i < len; i += sizeof (Sint16) * 6) {
   825         Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+0))) *
   826                                     args->left_f) * args->distance_f);
   827         Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+1))) *
   828                                     args->right_f) * args->distance_f);
   829         Sint16 swaplr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+2))) *
   830                                     args->left_rear_f) * args->distance_f);
   831         Sint16 swaprr = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+3))) *
   832                                     args->right_rear_f) * args->distance_f);
   833         Sint16 swapce = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+4))) *
   834                                     args->center_f) * args->distance_f);
   835         Sint16 swapwf = (Sint16) ((((float) (Sint16) SDL_SwapLE16(*(ptr+5))) *
   836                                     args->lfe_f) * args->distance_f);
   837     switch (args->room_angle) {
   838         case 0:
   839                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   840                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   841                 *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);
   842                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);
   843                 *(ptr++) = (Sint16) SDL_SwapLE16(swapce);
   844                 *(ptr++) = (Sint16) SDL_SwapLE16(swapwf);
   845             break;
   846         case 90:
   847                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   848                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);
   849                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   850                 *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);
   851                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr)/2 + (Sint16) SDL_SwapLE16(swaprr)/2;
   852                 *(ptr++) = (Sint16) SDL_SwapLE16(swapwf);
   853             break;
   854         case 180:
   855                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);
   856                 *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);
   857                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   858                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   859                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr)/2 + (Sint16) SDL_SwapLE16(swaplr)/2;
   860                 *(ptr++) = (Sint16) SDL_SwapLE16(swapwf);
   861             break;
   862         case 270:
   863                 *(ptr++) = (Sint16) SDL_SwapLE16(swaplr);
   864                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl);
   865                 *(ptr++) = (Sint16) SDL_SwapLE16(swaprr);
   866                 *(ptr++) = (Sint16) SDL_SwapLE16(swapr);
   867                 *(ptr++) = (Sint16) SDL_SwapLE16(swapl)/2 + (Sint16) SDL_SwapLE16(swaplr)/2;
   868                 *(ptr++) = (Sint16) SDL_SwapLE16(swapwf);
   869             break;
   870     }
   871     }
   872 }
   873 
   874 static void SDLCALL _Eff_position_u16msb(int chan, void *stream, int len, void *udata)
   875 {
   876     /* 16 signed bits (lsb) * 2 channels. */
   877     volatile position_args *args = (volatile position_args *) udata;
   878     Uint16 *ptr = (Uint16 *) stream;
   879     int i;
   880 
   881     for (i = 0; i < len; i += sizeof (Sint16) * 2) {
   882         Sint16 sampl = (Sint16) (SDL_SwapBE16(*(ptr+0)) - 32768);
   883         Sint16 sampr = (Sint16) (SDL_SwapBE16(*(ptr+1)) - 32768);
   884 
   885         Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)
   886                                     * args->distance_f) + 32768);
   887         Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)
   888                                     * args->distance_f) + 32768);
   889 
   890     if (args->room_angle == 180) {
   891             *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   892             *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
   893     }
   894     else {
   895             *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
   896             *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   897     }
   898     }
   899 }
   900 static void SDLCALL _Eff_position_u16msb_c4(int chan, void *stream, int len, void *udata)
   901 {
   902     /* 16 signed bits (lsb) * 4 channels. */
   903     volatile position_args *args = (volatile position_args *) udata;
   904     Uint16 *ptr = (Uint16 *) stream;
   905     int i;
   906 
   907     for (i = 0; i < len; i += sizeof (Sint16) * 4) {
   908         Sint16 sampl = (Sint16) (SDL_SwapBE16(*(ptr+0)) - 32768);
   909         Sint16 sampr = (Sint16) (SDL_SwapBE16(*(ptr+1)) - 32768);
   910         Sint16 samplr = (Sint16) (SDL_SwapBE16(*(ptr+2)) - 32768);
   911         Sint16 samprr = (Sint16) (SDL_SwapBE16(*(ptr+3)) - 32768);
   912 
   913         Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)
   914                                     * args->distance_f) + 32768);
   915         Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)
   916                                     * args->distance_f) + 32768);
   917         Uint16 swaplr = (Uint16) ((Sint16) (((float) samplr * args->left_rear_f)
   918                                     * args->distance_f) + 32768);
   919         Uint16 swaprr = (Uint16) ((Sint16) (((float) samprr * args->right_rear_f)
   920                                     * args->distance_f) + 32768);
   921 
   922     switch (args->room_angle) {
   923         case 0:
   924                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
   925                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   926                 *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);
   927                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);
   928             break;
   929         case 90:
   930                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   931                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);
   932                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
   933                 *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);
   934             break;
   935         case 180:
   936                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);
   937                 *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);
   938                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   939                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
   940             break;
   941         case 270:
   942                 *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);
   943                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
   944                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);
   945                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   946             break;
   947     }
   948     }
   949 }
   950 static void SDLCALL _Eff_position_u16msb_c6(int chan, void *stream, int len, void *udata)
   951 {
   952     /* 16 signed bits (lsb) * 6 channels. */
   953     volatile position_args *args = (volatile position_args *) udata;
   954     Uint16 *ptr = (Uint16 *) stream;
   955     int i;
   956 
   957     for (i = 0; i < len; i += sizeof (Sint16) * 6) {
   958         Sint16 sampl = (Sint16) (SDL_SwapBE16(*(ptr+0)) - 32768);
   959         Sint16 sampr = (Sint16) (SDL_SwapBE16(*(ptr+1)) - 32768);
   960         Sint16 samplr = (Sint16) (SDL_SwapBE16(*(ptr+2)) - 32768);
   961         Sint16 samprr = (Sint16) (SDL_SwapBE16(*(ptr+3)) - 32768);
   962         Sint16 sampce = (Sint16) (SDL_SwapBE16(*(ptr+4)) - 32768);
   963         Sint16 sampwf = (Sint16) (SDL_SwapBE16(*(ptr+5)) - 32768);
   964 
   965         Uint16 swapl = (Uint16) ((Sint16) (((float) sampl * args->left_f)
   966                                     * args->distance_f) + 32768);
   967         Uint16 swapr = (Uint16) ((Sint16) (((float) sampr * args->right_f)
   968                                     * args->distance_f) + 32768);
   969         Uint16 swaplr = (Uint16) ((Sint16) (((float) samplr * args->left_rear_f)
   970                                     * args->distance_f) + 32768);
   971         Uint16 swaprr = (Uint16) ((Sint16) (((float) samprr * args->right_rear_f)
   972                                     * args->distance_f) + 32768);
   973         Uint16 swapce = (Uint16) ((Sint16) (((float) sampce * args->center_f)
   974                                     * args->distance_f) + 32768);
   975         Uint16 swapwf = (Uint16) ((Sint16) (((float) sampwf * args->lfe_f)
   976                                     * args->distance_f) + 32768);
   977 
   978     switch (args->room_angle) {
   979         case 0:
   980                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
   981                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   982                 *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);
   983                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);
   984                 *(ptr++) = (Uint16) SDL_SwapBE16(swapce);
   985                 *(ptr++) = (Uint16) SDL_SwapBE16(swapwf);
   986             break;
   987         case 90:
   988                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   989                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);
   990                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
   991                 *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);
   992                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr)/2 + (Uint16) SDL_SwapBE16(swaprr)/2;
   993                 *(ptr++) = (Uint16) SDL_SwapBE16(swapwf);
   994             break;
   995         case 180:
   996                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);
   997                 *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);
   998                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
   999                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
  1000                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr)/2 + (Uint16) SDL_SwapBE16(swaplr)/2;
  1001                 *(ptr++) = (Uint16) SDL_SwapBE16(swapwf);
  1002             break;
  1003         case 270:
  1004                 *(ptr++) = (Uint16) SDL_SwapBE16(swaplr);
  1005                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl);
  1006                 *(ptr++) = (Uint16) SDL_SwapBE16(swaprr);
  1007                 *(ptr++) = (Uint16) SDL_SwapBE16(swapr);
  1008                 *(ptr++) = (Uint16) SDL_SwapBE16(swapl)/2 + (Uint16) SDL_SwapBE16(swaplr)/2;
  1009                 *(ptr++) = (Uint16) SDL_SwapBE16(swapwf);
  1010             break;
  1011     }
  1012     }
  1013 }
  1014 
  1015 static void SDLCALL _Eff_position_s16msb(int chan, void *stream, int len, void *udata)
  1016 {
  1017     /* 16 signed bits (lsb) * 2 channels. */
  1018     volatile position_args *args = (volatile position_args *) udata;
  1019     Sint16 *ptr = (Sint16 *) stream;
  1020     int i;
  1021 
  1022     for (i = 0; i < len; i += sizeof (Sint16) * 2) {
  1023         Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+0))) *
  1024                                     args->left_f) * args->distance_f);
  1025         Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+1))) *
  1026                                     args->right_f) * args->distance_f);
  1027         *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1028         *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1029     }
  1030 }
  1031 static void SDLCALL _Eff_position_s16msb_c4(int chan, void *stream, int len, void *udata)
  1032 {
  1033     /* 16 signed bits (lsb) * 4 channels. */
  1034     volatile position_args *args = (volatile position_args *) udata;
  1035     Sint16 *ptr = (Sint16 *) stream;
  1036     int i;
  1037 
  1038     for (i = 0; i < len; i += sizeof (Sint16) * 4) {
  1039         Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+0))) *
  1040                                     args->left_f) * args->distance_f);
  1041         Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+1))) *
  1042                                     args->right_f) * args->distance_f);
  1043         Sint16 swaplr = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+2))) *
  1044                                     args->left_rear_f) * args->distance_f);
  1045         Sint16 swaprr = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+3))) *
  1046                                     args->right_rear_f) * args->distance_f);
  1047     switch (args->room_angle) {
  1048         case 0:
  1049                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1050                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1051                 *(ptr++) = (Sint16) SDL_SwapBE16(swaplr);
  1052                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr);
  1053             break;
  1054         case 90:
  1055                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1056                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr);
  1057                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1058                 *(ptr++) = (Sint16) SDL_SwapBE16(swaplr);
  1059             break;
  1060         case 180:
  1061                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr);
  1062                 *(ptr++) = (Sint16) SDL_SwapBE16(swaplr);
  1063                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1064                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1065             break;
  1066         case 270:
  1067                 *(ptr++) = (Sint16) SDL_SwapBE16(swaplr);
  1068                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1069                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr);
  1070                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1071             break;
  1072     }
  1073     }
  1074 }
  1075 static void SDLCALL _Eff_position_s16msb_c6(int chan, void *stream, int len, void *udata)
  1076 {
  1077     /* 16 signed bits (lsb) * 6 channels. */
  1078     volatile position_args *args = (volatile position_args *) udata;
  1079     Sint16 *ptr = (Sint16 *) stream;
  1080     int i;
  1081 
  1082     for (i = 0; i < len; i += sizeof (Sint16) * 6) {
  1083         Sint16 swapl = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+0))) *
  1084                                     args->left_f) * args->distance_f);
  1085         Sint16 swapr = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+1))) *
  1086                                     args->right_f) * args->distance_f);
  1087         Sint16 swaplr = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+2))) *
  1088                                     args->left_rear_f) * args->distance_f);
  1089         Sint16 swaprr = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+3))) *
  1090                                     args->right_rear_f) * args->distance_f);
  1091         Sint16 swapce = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+4))) *
  1092                                     args->center_f) * args->distance_f);
  1093         Sint16 swapwf = (Sint16) ((((float) (Sint16) SDL_SwapBE16(*(ptr+5))) *
  1094                                     args->lfe_f) * args->distance_f);
  1095 
  1096     switch (args->room_angle) {
  1097         case 0:
  1098                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1099                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1100                 *(ptr++) = (Sint16) SDL_SwapBE16(swaplr);
  1101                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr);
  1102                 *(ptr++) = (Sint16) SDL_SwapBE16(swapce);
  1103                 *(ptr++) = (Sint16) SDL_SwapBE16(swapwf);
  1104             break;
  1105         case 90:
  1106                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1107                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr);
  1108                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1109                 *(ptr++) = (Sint16) SDL_SwapBE16(swaplr);
  1110                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr)/2 + (Sint16) SDL_SwapBE16(swaprr)/2;
  1111                 *(ptr++) = (Sint16) SDL_SwapBE16(swapwf);
  1112             break;
  1113         case 180:
  1114                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr);
  1115                 *(ptr++) = (Sint16) SDL_SwapBE16(swaplr);
  1116                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1117                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1118                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr)/2 + (Sint16) SDL_SwapBE16(swaplr)/2;
  1119                 *(ptr++) = (Sint16) SDL_SwapBE16(swapwf);
  1120             break;
  1121         case 270:
  1122                 *(ptr++) = (Sint16) SDL_SwapBE16(swaplr);
  1123                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl);
  1124                 *(ptr++) = (Sint16) SDL_SwapBE16(swaprr);
  1125                 *(ptr++) = (Sint16) SDL_SwapBE16(swapr);
  1126                 *(ptr++) = (Sint16) SDL_SwapBE16(swapl)/2 + (Sint16) SDL_SwapBE16(swaplr)/2;
  1127                 *(ptr++) = (Sint16) SDL_SwapBE16(swapwf);
  1128             break;
  1129     }
  1130     }
  1131 }
  1132 
  1133 static void SDLCALL _Eff_position_s32lsb(int chan, void *stream, int len, void *udata)
  1134 {
  1135     /* 32 signed bits (lsb) * 2 channels. */
  1136     volatile position_args *args = (volatile position_args *) udata;
  1137     Sint32 *ptr = (Sint32 *) stream;
  1138     int i;
  1139 
  1140 #if 0
  1141     if (len % (sizeof(Sint32) * 2)) {
  1142         fprintf(stderr,"Not an even number of frames! len=%d\n", len);
  1143         return;
  1144     }
  1145 #endif
  1146 
  1147     for (i = 0; i < len; i += sizeof (Sint32) * 2) {
  1148         Sint32 swapl = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+0))) *
  1149                                     args->left_f) * args->distance_f);
  1150         Sint32 swapr = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+1))) *
  1151                                     args->right_f) * args->distance_f);
  1152     if (args->room_angle == 180) {
  1153             *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1154             *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1155     }
  1156     else {
  1157             *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1158             *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1159     }
  1160     }
  1161 }
  1162 static void SDLCALL _Eff_position_s32lsb_c4(int chan, void *stream, int len, void *udata)
  1163 {
  1164     /* 32 signed bits (lsb) * 4 channels. */
  1165     volatile position_args *args = (volatile position_args *) udata;
  1166     Sint32 *ptr = (Sint32 *) stream;
  1167     int i;
  1168 
  1169     for (i = 0; i < len; i += sizeof (Sint32) * 4) {
  1170         Sint32 swapl = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+0))) *
  1171                                     args->left_f) * args->distance_f);
  1172         Sint32 swapr = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+1))) *
  1173                                     args->right_f) * args->distance_f);
  1174         Sint32 swaplr = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+1))) *
  1175                                     args->left_rear_f) * args->distance_f);
  1176         Sint32 swaprr = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+2))) *
  1177                                     args->right_rear_f) * args->distance_f);
  1178     switch (args->room_angle) {
  1179         case 0:
  1180                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1181                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1182                 *(ptr++) = (Sint32) SDL_SwapLE32(swaplr);
  1183                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr);
  1184             break;
  1185         case 90:
  1186                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1187                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr);
  1188                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1189                 *(ptr++) = (Sint32) SDL_SwapLE32(swaplr);
  1190             break;
  1191         case 180:
  1192                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr);
  1193                 *(ptr++) = (Sint32) SDL_SwapLE32(swaplr);
  1194                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1195                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1196             break;
  1197         case 270:
  1198                 *(ptr++) = (Sint32) SDL_SwapLE32(swaplr);
  1199                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1200                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr);
  1201                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1202             break;
  1203     }
  1204     }
  1205 }
  1206 
  1207 static void SDLCALL _Eff_position_s32lsb_c6(int chan, void *stream, int len, void *udata)
  1208 {
  1209     /* 32 signed bits (lsb) * 6 channels. */
  1210     volatile position_args *args = (volatile position_args *) udata;
  1211     Sint32 *ptr = (Sint32 *) stream;
  1212     int i;
  1213 
  1214     for (i = 0; i < len; i += sizeof (Sint32) * 6) {
  1215         Sint32 swapl = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+0))) *
  1216                                     args->left_f) * args->distance_f);
  1217         Sint32 swapr = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+1))) *
  1218                                     args->right_f) * args->distance_f);
  1219         Sint32 swaplr = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+2))) *
  1220                                     args->left_rear_f) * args->distance_f);
  1221         Sint32 swaprr = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+3))) *
  1222                                     args->right_rear_f) * args->distance_f);
  1223         Sint32 swapce = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+4))) *
  1224                                     args->center_f) * args->distance_f);
  1225         Sint32 swapwf = (Sint32) ((((float) (Sint32) SDL_SwapLE32(*(ptr+5))) *
  1226                                     args->lfe_f) * args->distance_f);
  1227     switch (args->room_angle) {
  1228         case 0:
  1229                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1230                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1231                 *(ptr++) = (Sint32) SDL_SwapLE32(swaplr);
  1232                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr);
  1233                 *(ptr++) = (Sint32) SDL_SwapLE32(swapce);
  1234                 *(ptr++) = (Sint32) SDL_SwapLE32(swapwf);
  1235             break;
  1236         case 90:
  1237                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1238                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr);
  1239                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1240                 *(ptr++) = (Sint32) SDL_SwapLE32(swaplr);
  1241                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr)/2 + (Sint32) SDL_SwapLE32(swaprr)/2;
  1242                 *(ptr++) = (Sint32) SDL_SwapLE32(swapwf);
  1243             break;
  1244         case 180:
  1245                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr);
  1246                 *(ptr++) = (Sint32) SDL_SwapLE32(swaplr);
  1247                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1248                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1249                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr)/2 + (Sint32) SDL_SwapLE32(swaplr)/2;
  1250                 *(ptr++) = (Sint32) SDL_SwapLE32(swapwf);
  1251             break;
  1252         case 270:
  1253                 *(ptr++) = (Sint32) SDL_SwapLE32(swaplr);
  1254                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl);
  1255                 *(ptr++) = (Sint32) SDL_SwapLE32(swaprr);
  1256                 *(ptr++) = (Sint32) SDL_SwapLE32(swapr);
  1257                 *(ptr++) = (Sint32) SDL_SwapLE32(swapl)/2 + (Sint32) SDL_SwapLE32(swaplr)/2;
  1258                 *(ptr++) = (Sint32) SDL_SwapLE32(swapwf);
  1259             break;
  1260     }
  1261     }
  1262 }
  1263 
  1264 static void SDLCALL _Eff_position_s32msb(int chan, void *stream, int len, void *udata)
  1265 {
  1266     /* 32 signed bits (lsb) * 2 channels. */
  1267     volatile position_args *args = (volatile position_args *) udata;
  1268     Sint32 *ptr = (Sint32 *) stream;
  1269     int i;
  1270 
  1271     for (i = 0; i < len; i += sizeof (Sint32) * 2) {
  1272         Sint32 swapl = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+0))) *
  1273                                     args->left_f) * args->distance_f);
  1274         Sint32 swapr = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+1))) *
  1275                                     args->right_f) * args->distance_f);
  1276         *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1277         *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1278     }
  1279 }
  1280 static void SDLCALL _Eff_position_s32msb_c4(int chan, void *stream, int len, void *udata)
  1281 {
  1282     /* 32 signed bits (lsb) * 4 channels. */
  1283     volatile position_args *args = (volatile position_args *) udata;
  1284     Sint32 *ptr = (Sint32 *) stream;
  1285     int i;
  1286 
  1287     for (i = 0; i < len; i += sizeof (Sint32) * 4) {
  1288         Sint32 swapl = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+0))) *
  1289                                     args->left_f) * args->distance_f);
  1290         Sint32 swapr = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+1))) *
  1291                                     args->right_f) * args->distance_f);
  1292         Sint32 swaplr = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+2))) *
  1293                                     args->left_rear_f) * args->distance_f);
  1294         Sint32 swaprr = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+3))) *
  1295                                     args->right_rear_f) * args->distance_f);
  1296     switch (args->room_angle) {
  1297         case 0:
  1298                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1299                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1300                 *(ptr++) = (Sint32) SDL_SwapBE32(swaplr);
  1301                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr);
  1302             break;
  1303         case 90:
  1304                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1305                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr);
  1306                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1307                 *(ptr++) = (Sint32) SDL_SwapBE32(swaplr);
  1308             break;
  1309         case 180:
  1310                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr);
  1311                 *(ptr++) = (Sint32) SDL_SwapBE32(swaplr);
  1312                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1313                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1314             break;
  1315         case 270:
  1316                 *(ptr++) = (Sint32) SDL_SwapBE32(swaplr);
  1317                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1318                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr);
  1319                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1320             break;
  1321     }
  1322     }
  1323 }
  1324 static void SDLCALL _Eff_position_s32msb_c6(int chan, void *stream, int len, void *udata)
  1325 {
  1326     /* 32 signed bits (lsb) * 6 channels. */
  1327     volatile position_args *args = (volatile position_args *) udata;
  1328     Sint32 *ptr = (Sint32 *) stream;
  1329     int i;
  1330 
  1331     for (i = 0; i < len; i += sizeof (Sint32) * 6) {
  1332         Sint32 swapl = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+0))) *
  1333                                     args->left_f) * args->distance_f);
  1334         Sint32 swapr = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+1))) *
  1335                                     args->right_f) * args->distance_f);
  1336         Sint32 swaplr = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+2))) *
  1337                                     args->left_rear_f) * args->distance_f);
  1338         Sint32 swaprr = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+3))) *
  1339                                     args->right_rear_f) * args->distance_f);
  1340         Sint32 swapce = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+4))) *
  1341                                     args->center_f) * args->distance_f);
  1342         Sint32 swapwf = (Sint32) ((((float) (Sint32) SDL_SwapBE32(*(ptr+5))) *
  1343                                     args->lfe_f) * args->distance_f);
  1344 
  1345     switch (args->room_angle) {
  1346         case 0:
  1347                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1348                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1349                 *(ptr++) = (Sint32) SDL_SwapBE32(swaplr);
  1350                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr);
  1351                 *(ptr++) = (Sint32) SDL_SwapBE32(swapce);
  1352                 *(ptr++) = (Sint32) SDL_SwapBE32(swapwf);
  1353             break;
  1354         case 90:
  1355                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1356                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr);
  1357                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1358                 *(ptr++) = (Sint32) SDL_SwapBE32(swaplr);
  1359                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr)/2 + (Sint32) SDL_SwapBE32(swaprr)/2;
  1360                 *(ptr++) = (Sint32) SDL_SwapBE32(swapwf);
  1361             break;
  1362         case 180:
  1363                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr);
  1364                 *(ptr++) = (Sint32) SDL_SwapBE32(swaplr);
  1365                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1366                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1367                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr)/2 + (Sint32) SDL_SwapBE32(swaplr)/2;
  1368                 *(ptr++) = (Sint32) SDL_SwapBE32(swapwf);
  1369             break;
  1370         case 270:
  1371                 *(ptr++) = (Sint32) SDL_SwapBE32(swaplr);
  1372                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl);
  1373                 *(ptr++) = (Sint32) SDL_SwapBE32(swaprr);
  1374                 *(ptr++) = (Sint32) SDL_SwapBE32(swapr);
  1375                 *(ptr++) = (Sint32) SDL_SwapBE32(swapl)/2 + (Sint32) SDL_SwapBE32(swaplr)/2;
  1376                 *(ptr++) = (Sint32) SDL_SwapBE32(swapwf);
  1377             break;
  1378     }
  1379     }
  1380 }
  1381 
  1382 static void SDLCALL _Eff_position_f32sys(int chan, void *stream, int len, void *udata)
  1383 {
  1384     /* float * 2 channels. */
  1385     volatile position_args *args = (volatile position_args *) udata;
  1386     float *ptr = (float *) stream;
  1387     int i;
  1388 
  1389     for (i = 0; i < len; i += sizeof (float) * 2) {
  1390         float swapl = ((*(ptr+0) * args->left_f) * args->distance_f);
  1391         float swapr = ((*(ptr+1) * args->right_f) * args->distance_f);
  1392         *(ptr++) = swapl;
  1393         *(ptr++) = swapr;
  1394     }
  1395 }
  1396 static void SDLCALL _Eff_position_f32sys_c4(int chan, void *stream, int len, void *udata)
  1397 {
  1398     /* float * 4 channels. */
  1399     volatile position_args *args = (volatile position_args *) udata;
  1400     float *ptr = (float *) stream;
  1401     int i;
  1402 
  1403     for (i = 0; i < len; i += sizeof (float) * 4) {
  1404         float swapl = ((*(ptr+0) * args->left_f) * args->distance_f);
  1405         float swapr = ((*(ptr+1) * args->right_f) * args->distance_f);
  1406         float swaplr = ((*(ptr+2) * args->left_rear_f) * args->distance_f);
  1407         float swaprr = ((*(ptr+3) * args->right_rear_f) * args->distance_f);
  1408         switch (args->room_angle) {
  1409         case 0:
  1410                 *(ptr++) = swapl;
  1411                 *(ptr++) = swapr;
  1412                 *(ptr++) = swaplr;
  1413                 *(ptr++) = swaprr;
  1414             break;
  1415         case 90:
  1416                 *(ptr++) = swapr;
  1417                 *(ptr++) = swaprr;
  1418                 *(ptr++) = swapl;
  1419                 *(ptr++) = swaplr;
  1420             break;
  1421         case 180:
  1422                 *(ptr++) = swaprr;
  1423                 *(ptr++) = swaplr;
  1424                 *(ptr++) = swapr;
  1425                 *(ptr++) = swapl;
  1426             break;
  1427         case 270:
  1428                 *(ptr++) = swaplr;
  1429                 *(ptr++) = swapl;
  1430                 *(ptr++) = swaprr;
  1431                 *(ptr++) = swapr;
  1432             break;
  1433         }
  1434     }
  1435 }
  1436 static void SDLCALL _Eff_position_f32sys_c6(int chan, void *stream, int len, void *udata)
  1437 {
  1438     /* float * 6 channels. */
  1439     volatile position_args *args = (volatile position_args *) udata;
  1440     float *ptr = (float *) stream;
  1441     int i;
  1442 
  1443     for (i = 0; i < len; i += sizeof (float) * 6) {
  1444         float swapl = ((*(ptr+0) * args->left_f) * args->distance_f);
  1445         float swapr = ((*(ptr+1) * args->right_f) * args->distance_f);
  1446         float swaplr = ((*(ptr+2) * args->left_rear_f) * args->distance_f);
  1447         float swaprr = ((*(ptr+3) * args->right_rear_f) * args->distance_f);
  1448         float swapce = ((*(ptr+4) * args->center_f) * args->distance_f);
  1449         float swapwf = ((*(ptr+5) * args->lfe_f) * args->distance_f);
  1450 
  1451     switch (args->room_angle) {
  1452         case 0:
  1453                 *(ptr++) = swapl;
  1454                 *(ptr++) = swapr;
  1455                 *(ptr++) = swaplr;
  1456                 *(ptr++) = swaprr;
  1457                 *(ptr++) = swapce;
  1458                 *(ptr++) = swapwf;
  1459             break;
  1460         case 90:
  1461                 *(ptr++) = swapr;
  1462                 *(ptr++) = swaprr;
  1463                 *(ptr++) = swapl;
  1464                 *(ptr++) = swaplr;
  1465                 *(ptr++) = swapr/2.0f + swaprr/2.0f;
  1466                 *(ptr++) = swapwf;
  1467             break;
  1468         case 180:
  1469                 *(ptr++) = swaprr;
  1470                 *(ptr++) = swaplr;
  1471                 *(ptr++) = swapr;
  1472                 *(ptr++) = swapl;
  1473                 *(ptr++) = swaprr/2.0f + swaplr/2.0f;
  1474                 *(ptr++) = swapwf;
  1475             break;
  1476         case 270:
  1477                 *(ptr++) = swaplr;
  1478                 *(ptr++) = swapl;
  1479                 *(ptr++) = swaprr;
  1480                 *(ptr++) = swapr;
  1481                 *(ptr++) = swapl/2.0f + swaplr/2.0f;
  1482                 *(ptr++) = swapwf;
  1483             break;
  1484     }
  1485     }
  1486 }
  1487 
  1488 static void init_position_args(position_args *args)
  1489 {
  1490     SDL_memset(args, '\0', sizeof (position_args));
  1491     args->in_use = 0;
  1492     args->room_angle = 0;
  1493     args->left_u8 = args->right_u8 = args->distance_u8 = 255;
  1494     args->left_f  = args->right_f  = args->distance_f  = 1.0f;
  1495     args->left_rear_u8 = args->right_rear_u8 = args->center_u8 = args->lfe_u8 = 255;
  1496     args->left_rear_f = args->right_rear_f = args->center_f = args->lfe_f = 1.0f;
  1497     Mix_QuerySpec(NULL, NULL, (int *) &args->channels);
  1498 }
  1499 
  1500 
  1501 static position_args *get_position_arg(int channel)
  1502 {
  1503     void *rc;
  1504     int i;
  1505 
  1506     if (channel < 0) {
  1507         if (pos_args_global == NULL) {
  1508             pos_args_global = SDL_malloc(sizeof (position_args));
  1509             if (pos_args_global == NULL) {
  1510                 Mix_SetError("Out of memory");
  1511                 return(NULL);
  1512             }
  1513             init_position_args(pos_args_global);
  1514         }
  1515 
  1516         return(pos_args_global);
  1517     }
  1518 
  1519     if (channel >= position_channels) {
  1520         rc = SDL_realloc(pos_args_array, (channel + 1) * sizeof (position_args *));
  1521         if (rc == NULL) {
  1522             Mix_SetError("Out of memory");
  1523             return(NULL);
  1524         }
  1525         pos_args_array = (position_args **) rc;
  1526         for (i = position_channels; i <= channel; i++) {
  1527             pos_args_array[i] = NULL;
  1528         }
  1529         position_channels = channel + 1;
  1530     }
  1531 
  1532     if (pos_args_array[channel] == NULL) {
  1533         pos_args_array[channel] = (position_args *)SDL_malloc(sizeof(position_args));
  1534         if (pos_args_array[channel] == NULL) {
  1535             Mix_SetError("Out of memory");
  1536             return(NULL);
  1537         }
  1538         init_position_args(pos_args_array[channel]);
  1539     }
  1540 
  1541     return(pos_args_array[channel]);
  1542 }
  1543 
  1544 
  1545 static Mix_EffectFunc_t get_position_effect_func(Uint16 format, int channels)
  1546 {
  1547     Mix_EffectFunc_t f = NULL;
  1548 
  1549     switch (format) {
  1550         case AUDIO_U8:
  1551         switch (channels) {
  1552             case 1:
  1553             case 2:
  1554                 f = (_Eff_build_volume_table_u8()) ? _Eff_position_table_u8 :
  1555                                                         _Eff_position_u8;
  1556                 break;
  1557             case 4:
  1558                 f = _Eff_position_u8_c4;
  1559                 break;
  1560             case 6:
  1561                 f = _Eff_position_u8_c6;
  1562                 break;
  1563             default:
  1564                 Mix_SetError("Unsupported audio channels");
  1565                 break;
  1566         }
  1567         break;
  1568 
  1569         case AUDIO_S8:
  1570         switch (channels) {
  1571             case 1:
  1572             case 2:
  1573                 f = (_Eff_build_volume_table_s8()) ? _Eff_position_table_s8 :
  1574                                                         _Eff_position_s8;
  1575                 break;
  1576             case 4:
  1577                 f = _Eff_position_s8_c4;
  1578                 break;
  1579             case 6:
  1580                 f = _Eff_position_s8_c6;
  1581                 break;
  1582             default:
  1583                 Mix_SetError("Unsupported audio channels");
  1584                 break;
  1585         }
  1586         break;
  1587 
  1588         case AUDIO_U16LSB:
  1589         switch (channels) {
  1590             case 1:
  1591             case 2:
  1592                 f = _Eff_position_u16lsb;
  1593                 break;
  1594             case 4:
  1595                 f = _Eff_position_u16lsb_c4;
  1596                 break;
  1597             case 6:
  1598                 f = _Eff_position_u16lsb_c6;
  1599                 break;
  1600             default:
  1601                 Mix_SetError("Unsupported audio channels");
  1602                 break;
  1603         }
  1604         break;
  1605 
  1606         case AUDIO_S16LSB:
  1607         switch (channels) {
  1608             case 1:
  1609             case 2:
  1610                 f = _Eff_position_s16lsb;
  1611                 break;
  1612             case 4:
  1613                 f = _Eff_position_s16lsb_c4;
  1614                 break;
  1615             case 6:
  1616                 f = _Eff_position_s16lsb_c6;
  1617                 break;
  1618             default:
  1619                 Mix_SetError("Unsupported audio channels");
  1620                 break;
  1621         }
  1622         break;
  1623 
  1624         case AUDIO_U16MSB:
  1625         switch (channels) {
  1626             case 1:
  1627             case 2:
  1628                 f = _Eff_position_u16msb;
  1629                 break;
  1630             case 4:
  1631                 f = _Eff_position_u16msb_c4;
  1632                 break;
  1633             case 6:
  1634                 f = _Eff_position_u16msb_c6;
  1635                 break;
  1636             default:
  1637                 Mix_SetError("Unsupported audio channels");
  1638                 break;
  1639         }
  1640         break;
  1641 
  1642         case AUDIO_S16MSB:
  1643         switch (channels) {
  1644             case 1:
  1645             case 2:
  1646                 f = _Eff_position_s16msb;
  1647                 break;
  1648             case 4:
  1649                 f = _Eff_position_s16msb_c4;
  1650                 break;
  1651             case 6:
  1652                 f = _Eff_position_s16msb_c6;
  1653                 break;
  1654             default:
  1655                 Mix_SetError("Unsupported audio channels");
  1656                 break;
  1657         }
  1658         break;
  1659 
  1660         case AUDIO_S32MSB:
  1661         switch (channels) {
  1662             case 1:
  1663             case 2:
  1664                 f = _Eff_position_s32msb;
  1665                 break;
  1666             case 4:
  1667                 f = _Eff_position_s32msb_c4;
  1668                 break;
  1669             case 6:
  1670                 f = _Eff_position_s32msb_c6;
  1671                 break;
  1672             default:
  1673                 Mix_SetError("Unsupported audio channels");
  1674                 break;
  1675         }
  1676         break;
  1677 
  1678         case AUDIO_S32LSB:
  1679         switch (channels) {
  1680             case 1:
  1681             case 2:
  1682                 f = _Eff_position_s32lsb;
  1683                 break;
  1684             case 4:
  1685                 f = _Eff_position_s32lsb_c4;
  1686                 break;
  1687             case 6:
  1688                 f = _Eff_position_s32lsb_c6;
  1689                 break;
  1690             default:
  1691                 Mix_SetError("Unsupported audio channels");
  1692                 break;
  1693         }
  1694         break;
  1695 
  1696         case AUDIO_F32SYS:
  1697         switch (channels) {
  1698             case 1:
  1699             case 2:
  1700                 f = _Eff_position_f32sys;
  1701                 break;
  1702             case 4:
  1703                 f = _Eff_position_f32sys_c4;
  1704                 break;
  1705             case 6:
  1706                 f = _Eff_position_f32sys_c6;
  1707                 break;
  1708             default:
  1709                 Mix_SetError("Unsupported audio channels");
  1710                 break;
  1711         }
  1712         break;
  1713 
  1714         default:
  1715             Mix_SetError("Unsupported audio format");
  1716             break;
  1717     }
  1718 
  1719     return(f);
  1720 }
  1721 
  1722 static Uint8 speaker_amplitude[6];
  1723 
  1724 static void set_amplitudes(int channels, int angle, int room_angle)
  1725 {
  1726     int left = 255, right = 255;
  1727     int left_rear = 255, right_rear = 255, center = 255;
  1728 
  1729     angle = SDL_abs(angle) % 360;  /* make angle between 0 and 359. */
  1730 
  1731     if (channels == 2)
  1732     {
  1733         /*
  1734          * We only attenuate by position if the angle falls on the far side
  1735          *  of center; That is, an angle that's due north would not attenuate
  1736          *  either channel. Due west attenuates the right channel to 0.0, and
  1737          *  due east attenuates the left channel to 0.0. Slightly east of
  1738          *  center attenuates the left channel a little, and the right channel
  1739          *  not at all. I think of this as occlusion by one's own head.  :)
  1740          *
  1741          *   ...so, we split our angle circle into four quadrants...
  1742          */
  1743         if (angle < 90) {
  1744             left = 255 - ((int) (255.0f * (((float) angle) / 89.0f)));
  1745         } else if (angle < 180) {
  1746             left = (int) (255.0f * (((float) (angle - 90)) / 89.0f));
  1747         } else if (angle < 270) {
  1748             right = 255 - ((int) (255.0f * (((float) (angle - 180)) / 89.0f)));
  1749         } else {
  1750             right = (int) (255.0f * (((float) (angle - 270)) / 89.0f));
  1751         }
  1752     }
  1753 
  1754     if (channels == 4 || channels == 6)
  1755     {
  1756         /*
  1757          *  An angle that's due north does not attenuate the center channel.
  1758          *  An angle in the first quadrant, 0-90, does not attenuate the RF.
  1759          *
  1760          *   ...so, we split our angle circle into 8 ...
  1761          *
  1762          *             CE
  1763          *             0
  1764          *     LF      |         RF
  1765          *             |
  1766          *  270<-------|----------->90
  1767          *             |
  1768          *     LR      |         RR
  1769          *            180
  1770          *
  1771          */
  1772         if (angle < 45) {
  1773             left = ((int) (255.0f * (((float) (180 - angle)) / 179.0f)));
  1774             left_rear = 255 - ((int) (255.0f * (((float) (angle + 45)) / 89.0f)));
  1775             right_rear = 255 - ((int) (255.0f * (((float) (90 - angle)) / 179.0f)));
  1776         } else if (angle < 90) {
  1777             center = ((int) (255.0f * (((float) (225 - angle)) / 179.0f)));
  1778             left = ((int) (255.0f * (((float) (180 - angle)) / 179.0f)));
  1779             left_rear = 255 - ((int) (255.0f * (((float) (135 - angle)) / 89.0f)));
  1780             right_rear = ((int) (255.0f * (((float) (90 + angle)) / 179.0f)));
  1781         } else if (angle < 135) {
  1782             center = ((int) (255.0f * (((float) (225 - angle)) / 179.0f)));
  1783             left = 255 - ((int) (255.0f * (((float) (angle - 45)) / 89.0f)));
  1784             right = ((int) (255.0f * (((float) (270 - angle)) / 179.0f)));
  1785             left_rear = ((int) (255.0f * (((float) (angle)) / 179.0f)));
  1786         } else if (angle < 180) {
  1787             center = 255 - ((int) (255.0f * (((float) (angle - 90)) / 89.0f)));
  1788             left = 255 - ((int) (255.0f * (((float) (225 - angle)) / 89.0f)));
  1789             right = ((int) (255.0f * (((float) (270 - angle)) / 179.0f)));
  1790             left_rear = ((int) (255.0f * (((float) (angle)) / 179.0f)));
  1791         } else if (angle < 225) {
  1792             center = 255 - ((int) (255.0f * (((float) (270 - angle)) / 89.0f)));
  1793             left = ((int) (255.0f * (((float) (angle - 90)) / 179.0f)));
  1794             right = 255 - ((int) (255.0f * (((float) (angle - 135)) / 89.0f)));
  1795             right_rear = ((int) (255.0f * (((float) (360 - angle)) / 179.0f)));
  1796         } else if (angle < 270) {
  1797             center = ((int) (255.0f * (((float) (angle - 135)) / 179.0f)));
  1798             left = ((int) (255.0f * (((float) (angle - 90)) / 179.0f)));
  1799             right = 255 - ((int) (255.0f * (((float) (315 - angle)) / 89.0f)));
  1800             right_rear = ((int) (255.0f * (((float) (360 - angle)) / 179.0f)));
  1801         } else if (angle < 315) {
  1802             center = ((int) (255.0f * (((float) (angle - 135)) / 179.0f)));
  1803             right = ((int) (255.0f * (((float) (angle - 180)) / 179.0f)));
  1804             left_rear = ((int) (255.0f * (((float) (450 - angle)) / 179.0f)));
  1805             right_rear = 255 - ((int) (255.0f * (((float) (angle - 225)) / 89.0f)));
  1806         } else {
  1807             right = ((int) (255.0f * (((float) (angle - 180)) / 179.0f)));
  1808             left_rear = ((int) (255.0f * (((float) (450 - angle)) / 179.0f)));
  1809             right_rear = 255 - ((int) (255.0f * (((float) (405 - angle)) / 89.0f)));
  1810         }
  1811     }
  1812 
  1813     if (left < 0) left = 0; if (left > 255) left = 255;
  1814     if (right < 0) right = 0; if (right > 255) right = 255;
  1815     if (left_rear < 0) left_rear = 0; if (left_rear > 255) left_rear = 255;
  1816     if (right_rear < 0) right_rear = 0; if (right_rear > 255) right_rear = 255;
  1817     if (center < 0) center = 0; if (center > 255) center = 255;
  1818 
  1819     if (room_angle == 90) {
  1820         speaker_amplitude[0] = (Uint8)left_rear;
  1821         speaker_amplitude[1] = (Uint8)left;
  1822         speaker_amplitude[2] = (Uint8)right_rear;
  1823         speaker_amplitude[3] = (Uint8)right;
  1824     }
  1825     else if (room_angle == 180) {
  1826     if (channels == 2) {
  1827             speaker_amplitude[0] = (Uint8)right;
  1828             speaker_amplitude[1] = (Uint8)left;
  1829     }
  1830     else {
  1831             speaker_amplitude[0] = (Uint8)right_rear;
  1832             speaker_amplitude[1] = (Uint8)left_rear;
  1833             speaker_amplitude[2] = (Uint8)right;
  1834             speaker_amplitude[3] = (Uint8)left;
  1835     }
  1836     }
  1837     else if (room_angle == 270) {
  1838         speaker_amplitude[0] = (Uint8)right;
  1839         speaker_amplitude[1] = (Uint8)right_rear;
  1840         speaker_amplitude[2] = (Uint8)left;
  1841         speaker_amplitude[3] = (Uint8)left_rear;
  1842     }
  1843     else {
  1844         speaker_amplitude[0] = (Uint8)left;
  1845         speaker_amplitude[1] = (Uint8)right;
  1846         speaker_amplitude[2] = (Uint8)left_rear;
  1847         speaker_amplitude[3] = (Uint8)right_rear;
  1848     }
  1849     speaker_amplitude[4] = (Uint8)center;
  1850     speaker_amplitude[5] = 255;
  1851 }
  1852 
  1853 int Mix_SetPosition(int channel, Sint16 angle, Uint8 distance);
  1854 
  1855 int Mix_SetPanning(int channel, Uint8 left, Uint8 right)
  1856 {
  1857     Mix_EffectFunc_t f = NULL;
  1858     int channels;
  1859     Uint16 format;
  1860     position_args *args = NULL;
  1861     int retval = 1;
  1862 
  1863     Mix_QuerySpec(NULL, &format, &channels);
  1864 
  1865     if (channels != 2 && channels != 4 && channels != 6)    /* it's a no-op; we call that successful. */
  1866         return(1);
  1867 
  1868     if (channels > 2) {
  1869         /* left = right = 255 => angle = 0, to unregister effect as when channels = 2 */
  1870         /* left = 255 =>  angle = -90;  left = 0 => angle = +89 */
  1871         int angle = 0;
  1872         if ((left != 255) || (right != 255)) {
  1873         angle = (int)left;
  1874             angle = 127 - angle;
  1875         angle = -angle;
  1876             angle = angle * 90 / 128; /* Make it larger for more effect? */
  1877         }
  1878         return(Mix_SetPosition(channel, angle, 0));
  1879     }
  1880 
  1881     f = get_position_effect_func(format, channels);
  1882     if (f == NULL)
  1883         return(0);
  1884 
  1885     Mix_LockAudio();
  1886     args = get_position_arg(channel);
  1887     if (!args) {
  1888         Mix_UnlockAudio();
  1889         return(0);
  1890     }
  1891 
  1892         /* it's a no-op; unregister the effect, if it's registered. */
  1893     if ((args->distance_u8 == 255) && (left == 255) && (right == 255)) {
  1894         if (args->in_use) {
  1895             retval = _Mix_UnregisterEffect_locked(channel, f);
  1896             Mix_UnlockAudio();
  1897             return(retval);
  1898         } else {
  1899             Mix_UnlockAudio();
  1900             return(1);
  1901         }
  1902     }
  1903 
  1904     args->left_u8 = left;
  1905     args->left_f = ((float) left) / 255.0f;
  1906     args->right_u8 = right;
  1907     args->right_f = ((float) right) / 255.0f;
  1908     args->room_angle = 0;
  1909 
  1910     if (!args->in_use) {
  1911         args->in_use = 1;
  1912         retval=_Mix_RegisterEffect_locked(channel, f, _Eff_PositionDone, (void*)args);
  1913     }
  1914 
  1915     Mix_UnlockAudio();
  1916     return(retval);
  1917 }
  1918 
  1919 
  1920 int Mix_SetDistance(int channel, Uint8 distance)
  1921 {
  1922     Mix_EffectFunc_t f = NULL;
  1923     Uint16 format;
  1924     position_args *args = NULL;
  1925     int channels;
  1926     int retval = 1;
  1927 
  1928     Mix_QuerySpec(NULL, &format, &channels);
  1929     f = get_position_effect_func(format, channels);
  1930     if (f == NULL)
  1931         return(0);
  1932 
  1933     Mix_LockAudio();
  1934     args = get_position_arg(channel);
  1935     if (!args) {
  1936         Mix_UnlockAudio();
  1937         return(0);
  1938     }
  1939 
  1940     distance = 255 - distance;  /* flip it to our scale. */
  1941 
  1942         /* it's a no-op; unregister the effect, if it's registered. */
  1943     if ((distance == 255) && (args->left_u8 == 255) && (args->right_u8 == 255)) {
  1944         if (args->in_use) {
  1945             retval = _Mix_UnregisterEffect_locked(channel, f);
  1946             Mix_UnlockAudio();
  1947             return(retval);
  1948         } else {
  1949             Mix_UnlockAudio();
  1950             return(1);
  1951         }
  1952     }
  1953 
  1954     args->distance_u8 = distance;
  1955     args->distance_f = ((float) distance) / 255.0f;
  1956     if (!args->in_use) {
  1957         args->in_use = 1;
  1958         retval = _Mix_RegisterEffect_locked(channel, f, _Eff_PositionDone, (void *) args);
  1959     }
  1960 
  1961     Mix_UnlockAudio();
  1962     return(retval);
  1963 }
  1964 
  1965 
  1966 int Mix_SetPosition(int channel, Sint16 angle, Uint8 distance)
  1967 {
  1968     Mix_EffectFunc_t f = NULL;
  1969     Uint16 format;
  1970     int channels;
  1971     position_args *args = NULL;
  1972     Sint16 room_angle = 0;
  1973     int retval = 1;
  1974 
  1975     Mix_QuerySpec(NULL, &format, &channels);
  1976     f = get_position_effect_func(format, channels);
  1977     if (f == NULL)
  1978         return(0);
  1979 
  1980     angle = SDL_abs(angle) % 360;  /* make angle between 0 and 359. */
  1981 
  1982     Mix_LockAudio();
  1983     args = get_position_arg(channel);
  1984     if (!args) {
  1985         Mix_UnlockAudio();
  1986         return(0);
  1987     }
  1988 
  1989         /* it's a no-op; unregister the effect, if it's registered. */
  1990     if ((!distance) && (!angle)) {
  1991         if (args->in_use) {
  1992             retval = _Mix_UnregisterEffect_locked(channel, f);
  1993             Mix_UnlockAudio();
  1994             return(retval);
  1995         } else {
  1996             Mix_UnlockAudio();
  1997             return(1);
  1998         }
  1999     }
  2000 
  2001     if (channels == 2)
  2002     {
  2003     if (angle > 180)
  2004         room_angle = 180; /* exchange left and right channels */
  2005     else room_angle = 0;
  2006     }
  2007 
  2008     if (channels == 4 || channels == 6)
  2009     {
  2010     if (angle > 315) room_angle = 0;
  2011     else if (angle > 225) room_angle = 270;
  2012     else if (angle > 135) room_angle = 180;
  2013     else if (angle > 45) room_angle = 90;
  2014     else room_angle = 0;
  2015     }
  2016 
  2017 
  2018     distance = 255 - distance;  /* flip it to scale Mix_SetDistance() uses. */
  2019 
  2020     set_amplitudes(channels, angle, room_angle);
  2021 
  2022     args->left_u8 = speaker_amplitude[0];
  2023     args->left_f = ((float) speaker_amplitude[0]) / 255.0f;
  2024     args->right_u8 = speaker_amplitude[1];
  2025     args->right_f = ((float) speaker_amplitude[1]) / 255.0f;
  2026     args->left_rear_u8 = speaker_amplitude[2];
  2027     args->left_rear_f = ((float) speaker_amplitude[2]) / 255.0f;
  2028     args->right_rear_u8 = speaker_amplitude[3];
  2029     args->right_rear_f = ((float) speaker_amplitude[3]) / 255.0f;
  2030     args->center_u8 = speaker_amplitude[4];
  2031     args->center_f = ((float) speaker_amplitude[4]) / 255.0f;
  2032     args->lfe_u8 = speaker_amplitude[5];
  2033     args->lfe_f = ((float) speaker_amplitude[5]) / 255.0f;
  2034     args->distance_u8 = distance;
  2035     args->distance_f = ((float) distance) / 255.0f;
  2036     args->room_angle = room_angle;
  2037     if (!args->in_use) {
  2038         args->in_use = 1;
  2039         retval = _Mix_RegisterEffect_locked(channel, f, _Eff_PositionDone, (void *) args);
  2040     }
  2041 
  2042     Mix_UnlockAudio();
  2043     return(retval);
  2044 }
  2045 
  2046 
  2047 /* end of effects_position.c ... */
  2048 
  2049 /* vi: set ts=4 sw=4 expandtab: */