openalbridge/wrappers.c
changeset 2444 ace11b7d8eab
parent 2443 fececcbc2189
child 2494 1e10a47cabea
equal deleted inserted replaced
2443:fececcbc2189 2444:ace11b7d8eab
    18 
    18 
    19 #include "wrappers.h"
    19 #include "wrappers.h"
    20 
    20 
    21 extern char *prog;
    21 extern char *prog;
    22 
    22 
    23 #ifdef __CPLUSPLUS
    23 //extern ALint *Sources;
    24 extern "C" {
    24 
    25 #endif 
    25 void *Malloc (size_t nbytes) {
       
    26         void *aptr;
    26         
    27         
    27         extern ALint *Sources;
    28         if ((aptr = malloc(nbytes)) == NULL)
       
    29                 err_dump("(%s) FATAL - not enough memory");
    28         
    30         
    29         void *Malloc (size_t nbytes) {
    31         return aptr;
    30                 void *aptr;
    32 }
    31                 
    33 
    32                 if ((aptr = malloc(nbytes)) == NULL)
    34 
    33                         err_dump("(%s) FATAL - not enough memory");
    35 void *Realloc (void *aptr, size_t nbytes) {
    34                 
    36         aptr = realloc(aptr, nbytes);
    35                 return aptr;
       
    36         }
       
    37         
    37         
       
    38         if (aptr == NULL) 
       
    39                 err_dump("(%s) FATAL - not enough memory");
    38         
    40         
    39         void *Realloc (void *aptr, size_t nbytes) {
    41         return aptr;
    40                 aptr = realloc(aptr, nbytes);
    42 }
    41                 
    43 
    42                 if (aptr == NULL) 
    44 
    43                         err_dump("(%s) FATAL - not enough memory");
    45 FILE *Fopen (const char *fname, char *mode)	{
    44                 
    46         FILE *fp;
    45                 return aptr;
       
    46         }
       
    47         
    47         
       
    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);
    48         
    51         
    49         FILE *Fopen (const char *fname, char *mode)	{
    52         return fp;
    50                 FILE *fp;
    53 }
    51                 
    54 
    52                 fp = fopen(fname,mode);
    55 /*TODO make a proper error reporting routine*/
    53                 if (fp == NULL)
    56 ALint AlGetError (const char *str) {
    54                         err_ret("(%s) ERROR - can't open file %s in mode '%s'", prog, fname, mode);
    57         ALenum error;
    55                 
       
    56                 return fp;
       
    57         }
       
    58         
    58         
    59         /*TODO make a proper error reporting routine*/
    59         error = alGetError();
    60         ALint AlGetError (const char *str) {
    60         if (error != AL_NO_ERROR) {
    61                 ALenum error;
    61                 err_msg(str, prog);
    62                 
    62                 return error;
    63                 error = alGetError();
    63         } else 
    64                 if (error != AL_NO_ERROR) {
    64                 return AL_TRUE;
    65                         err_msg(str, prog);
    65 }
    66                         return error;
    66 
    67                 } else 
    67 ALint AlGetError2 (const char *str, int num) {
    68                         return AL_TRUE;
    68         ALenum error;
    69         }
       
    70         
    69         
    71         ALint AlGetError2 (const char *str, int num) {
    70         error = alGetError();
    72                 ALenum error;
    71         if (error != AL_NO_ERROR) {
    73                 
    72                 err_msg(str, prog, num);
    74                 error = alGetError();
    73                 return error;
    75                 if (error != AL_NO_ERROR) {
    74         } else 
    76                         err_msg(str, prog, num);
    75                 return AL_TRUE;
    77                         return error;
    76 }
    78                 } else 
    77 
    79                         return AL_TRUE;
    78 /*       void *helper_fadein(void *tmp) {
    80         }
       
    81         
       
    82  /*       void *helper_fadein(void *tmp) {
       
    83                 ALfloat gain;
    79                 ALfloat gain;
    84                 ALfloat target_gain;
    80                 ALfloat target_gain;
    85                 fade_t *fade;
    81                 fade_t *fade;
    86                 uint32_t index; 
    82                 uint32_t index; 
    87                 uint16_t quantity; 
    83                 uint16_t quantity; 
   159 #endif
   155 #endif
   160                 return 0;
   156                 return 0;
   161         }
   157         }
   162         
   158         
   163         */
   159         */
   164 #ifdef __CPLUSPLUS
       
   165 }
       
   166 #endif