openalbridge/wrappers.c
changeset 2529 51e5df1c8462
parent 2515 51d3f4b6293a
equal deleted inserted replaced
2528:a1e0306b9cd1 2529:51e5df1c8462
    16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
    16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
    17  */
    17  */
    18 
    18 
    19 #include "wrappers.h"
    19 #include "wrappers.h"
    20 
    20 
    21 extern char *prog;
       
    22 
    21 
    23 extern ALint Sources[MAX_SOURCES];
    22 #ifdef __CPLUSPLUS
    24 
    23 extern "C" {
    25 void *Malloc (size_t nbytes) {
    24 #endif 
    26         void *aptr;
       
    27         
    25         
    28         if ((aptr = malloc(nbytes)) == NULL)
    26         extern ALint *Sources;
    29                 err_dump("(%s) FATAL - not enough memory");
       
    30         
    27         
    31         return aptr;
    28         void *Malloc (size_t nbytes) {
    32 }
    29                 void *aptr;
    33 
    30                 
    34 
    31                 if ((aptr = malloc(nbytes)) == NULL)
    35 void *Realloc (void *aptr, size_t nbytes) {
    32                         err_dump("(%s) FATAL - not enough memory");
    36         aptr = realloc(aptr, nbytes);
    33                 
       
    34                 return aptr;
       
    35         }
    37         
    36         
    38         if (aptr == NULL) 
       
    39                 err_dump("(%s) FATAL - not enough memory");
       
    40         
    37         
    41         return aptr;
    38         void *Realloc (void *aptr, size_t nbytes) {
    42 }
    39                 aptr = realloc(aptr, nbytes);
    43 
    40                 
    44 
    41                 if (aptr == NULL) 
    45 FILE *Fopen (const char *fname, char *mode)	{
    42                         err_dump("(%s) FATAL - not enough memory");
    46         FILE *fp;
    43                 
       
    44                 return aptr;
       
    45         }
    47         
    46         
    48         fp = fopen(fname,mode);
       
    49         if (fp == NULL)
       
    50                 err_ret("(%s) ERROR - can't open file %s in mode '%s'", prog, fname, mode);
       
    51         
    47         
    52         return fp;
    48         FILE *Fopen (const char *fname, char *mode)	{
    53 }
    49                 FILE *fp;
    54 
    50                 
    55 /*TODO make a proper error reporting routine*/
    51                 fp = fopen(fname,mode);
    56 ALint AlGetError (const char *str) {
    52                 if (fp == NULL)
    57         ALenum error;
    53                         err_ret("(%s) ERROR - can't open file %s in mode '%s'", prog, fname, mode);
       
    54                 
       
    55                 return fp;
       
    56         }
    58         
    57         
    59         error = alGetError();
    58         /*TODO make a proper error reporting routine*/
    60         if (error != AL_NO_ERROR) {
    59         ALint AlGetError (const char *str) {
    61                 err_msg(str, prog);
    60                 ALenum error;
    62                 return error;
    61                 
    63         } else 
    62                 error = alGetError();
    64                 return AL_TRUE;
    63                 if (error != AL_NO_ERROR) {
    65 }
    64                         err_msg(str, prog);
    66 
    65                         return error;
    67 ALint AlGetError2 (const char *str, int num) {
    66                 } else 
    68         ALenum error;
    67                         return AL_TRUE;
       
    68         }
    69         
    69         
    70         error = alGetError();
    70         ALint AlGetError2 (const char *str, int num) {
    71         if (error != AL_NO_ERROR) {
    71                 ALenum error;
    72                 err_msg(str, prog, num);
    72                 
    73                 return error;
    73                 error = alGetError();
    74         } else 
    74                 if (error != AL_NO_ERROR) {
    75                 return AL_TRUE;
    75                         err_msg(str, prog, num);
    76 }
    76                         return error;
    77 
    77                 } else 
    78        void *helper_fadein(void *tmp) {
    78                         return AL_TRUE;
       
    79         }
       
    80         
       
    81         void *helper_fadein(void *tmp) {
    79                 ALfloat gain;
    82                 ALfloat gain;
    80                 ALfloat target_gain;
    83                 ALfloat target_gain;
    81                 fade_t *fade;
    84                 fade_t *fade;
    82                 uint32_t index; 
    85                 uint32_t index; 
    83                 uint16_t quantity; 
    86                 uint16_t quantity; 
    91                 err_msg("(%s) INFO - Fade-in in progress [index %d quantity %d]", prog, index, quantity);
    94                 err_msg("(%s) INFO - Fade-in in progress [index %d quantity %d]", prog, index, quantity);
    92 #endif
    95 #endif
    93                 
    96                 
    94                 /*save the volume desired after the fade*/
    97                 /*save the volume desired after the fade*/
    95                 alGetSourcef(Sources[index], AL_GAIN, &target_gain);
    98                 alGetSourcef(Sources[index], AL_GAIN, &target_gain);
    96                 if (target_gain > 1.0f || target_gain < 0.0f)
    99                 if (target_gain > 1.0f || target_gain <= 0.0f)
    97                         target_gain = 1.0f;
   100                         target_gain = 1.0f;
    98                 
   101                 
    99                 alSourcePlay(Sources[index]);
   102                 alSourcePlay(Sources[index]);
   100                 
   103                 
   101                 for (gain = 0.0f ; gain <= target_gain; gain += (float) quantity/10000) {
   104                 for (gain = 0.0f ; gain <= target_gain; gain += (float) quantity/10000) {
   154                 _endthread();
   157                 _endthread();
   155 #endif
   158 #endif
   156                 return 0;
   159                 return 0;
   157         }
   160         }
   158         
   161         
       
   162         
       
   163 #ifdef __CPLUSPLUS
       
   164 }
       
   165 #endif