Mercurial Mercurial > hedgewars-draft / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
misc/openalbridge/loaders.c
changeset 3364 e5403e2bf02c
parent 3362 8d3b4d19ce27
child 3513 f589230fa21b
equal deleted inserted replaced
3363:bcd6d76db4f7 3364:e5403e2bf02c 
    19 #include "loaders.h"
 
    19 #include "loaders.h"
 
    20 #include "wrappers.h"
 
    20 #include "wrappers.h"
 
    21 #include "vorbis/vorbisfile.h"
 
    21 #include "vorbis/vorbisfile.h"
 
    22 #include "openalbridge_t.h"
 
    22 #include "openalbridge_t.h"
 
    23 
    23 
       
    24 
    24 int load_wavpcm (const char *filename, ALenum *format, char ** data, ALsizei *bitsize, ALsizei *freq) {
 
    25 int load_wavpcm (const char *filename, ALenum *format, char ** data, ALsizei *bitsize, ALsizei *freq) {
 
    25     WAV_header_t WAVHeader;
 
    26     WAV_header_t WAVHeader;
 
    26     FILE *wavfile;
 
    27     FILE *wavfile;
 
    27     int32_t t;
 
    28     int32_t t;
 
    28     uint32_t n = 0;
 
    29     uint32_t n = 0;
 
    76                 }
 
    77                 }
 
    77             }
 
    78             }
 
    78         }
 
    79         }
 
    79 
    80 
    80         if (t <= 0) {
 
    81         if (t <= 0) {
 
    81             /*eof*/
 
    82             // eof
 
    82             errno = EILSEQ;
 
    83             fprintf(stderr,"(Bridge Error) - wrong WAV header");
 
    83             err_ret("(%s) ERROR - wrong WAV header", prog);
 
    84             return -1;
 
    84             return AL_FALSE;
 
       
    85         }
 
    85         }
 
    86     } while (1);
 
    86     } while (1);
 
    87 
    87 
    88     fread(&WAVHeader.Subchunk2Size, sizeof(uint32_t), 1, wavfile);
 
    88     fread(&WAVHeader.Subchunk2Size, sizeof(uint32_t), 1, wavfile);
 
    89 
    89 
   100     } while (n < ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size));
 
   100     } while (n < ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size));
 
   101 
   101 
   102     fclose(wavfile);
 
   102     fclose(wavfile);
 
   103 
   103 
   104 #ifdef DEBUG
 
   104 #ifdef DEBUG
 
   105     err_msg("(%s) INFO - WAV data loaded", prog);
 
   105     fprintf(stderr,"(Bridge Info) - WAV data loaded");
 
   106 #endif
 
   106 #endif
 
   107 
   107 
   108     /*set parameters for OpenAL*/
 
   108     /*set parameters for OpenAL*/
 
   109     /*Valid formats are AL_FORMAT_MONO8, AL_FORMAT_MONO16, AL_FORMAT_STEREO8, and AL_FORMAT_STEREO16*/
 
   109     /*Valid formats are AL_FORMAT_MONO8, AL_FORMAT_MONO16, AL_FORMAT_STEREO8, and AL_FORMAT_STEREO16*/
 
   110     if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 1) {
 
   110     if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 1) {
 
   112             *format = AL_FORMAT_MONO8;
 
   112             *format = AL_FORMAT_MONO8;
 
   113         else {
 
   113         else {
 
   114             if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16)
 
   114             if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16)
 
   115                 *format = AL_FORMAT_MONO16;
 
   115                 *format = AL_FORMAT_MONO16;
 
   116             else {
 
   116             else {
 
   117                 errno = EILSEQ;
 
   117                 fprintf(stderr,"(Bridge Error) - wrong WAV header [bitsample value]");
 
   118                 err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog);
 
   118                 return -2;
 
   119                 return AL_FALSE;
 
       
   120             }
 
   119             }
 
   121         }
 
   120         }
 
   122     } else {
 
   121     } else {
 
   123         if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 2) {
 
   122         if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 2) {
 
   124             if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8)
 
   123             if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8)
 
   125                 *format = AL_FORMAT_STEREO8;
 
   124                 *format = AL_FORMAT_STEREO8;
 
   126             else {
 
   125             else {
 
   127                 if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16)
 
   126                 if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16)
 
   128                     *format = AL_FORMAT_STEREO16;
 
   127                     *format = AL_FORMAT_STEREO16;
 
   129                 else {
 
   128                 else {
 
   130                     errno = EILSEQ;
 
   129                     fprintf(stderr,"(Bridge Error) - wrong WAV header [bitsample value]");
 
   131                     err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog);
 
   130                     return -2;
 
   132                     return AL_FALSE;
 
       
   133                 }
 
   131                 }
 
   134             }
 
   132             }
 
   135         } else {
 
   133         } else {
 
   136             errno = EILSEQ;
 
   134             fprintf(stderr,"(Bridge Error) - wrong WAV header [format value]");
 
   137             err_ret("(%s) ERROR - wrong WAV header [format value]", prog);
 
   135             return -2;
 
   138             return AL_FALSE;
 
       
   139         }
 
   136         }
 
   140     }
 
   137     }
 
   141 
   138 
   142     *bitsize = ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size);
 
   139     *bitsize = ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size);
 
   143     *freq    = ENDIAN_LITTLE_32(WAVHeader.SampleRate);
 
   140     *freq    = ENDIAN_LITTLE_32(WAVHeader.SampleRate);
 
   144     return AL_TRUE;
 
   141     return 0;
 
   145 }
 
   142 }
 
   146 
   143 
   147 
   144 
   148 int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq) {
 
   145 int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq) {
 
   149     /*implementation inspired from http://www.devmaster.net/forums/showthread.php?t=1153 */
 
   146     /*implementation inspired from http://www.devmaster.net/forums/showthread.php?t=1153 */
 
   165 #endif
 
   162 #endif
 
   166 
   163 
   167     oggFile = Fopen(filename, "rb");
 
   164     oggFile = Fopen(filename, "rb");
 
   168     result = ov_open_callbacks(oggFile, &oggStream, NULL, 0, OV_CALLBACKS_DEFAULT);
 
   165     result = ov_open_callbacks(oggFile, &oggStream, NULL, 0, OV_CALLBACKS_DEFAULT);
 
   169     if (result < 0) {
 
   166     if (result < 0) {
 
   170         errno = EINVAL;
 
   167         fprintf(stderr,"(Bridge Error) - ov_open_callbacks() failed with %X", result);
 
   171         err_ret("(%s) ERROR - ov_fopen() failed with %X", prog, result);
 
       
   172         ov_clear(&oggStream);
 
   168         ov_clear(&oggStream);
 
   173         return -1;
 
   169         return -1;
 
   174     }
 
   170     }
 
   175 
   171 
   176     /*load OGG header and determine the decoded data size*/
 
   172     /*load OGG header and determine the decoded data size*/
 
   201         *format = AL_FORMAT_MONO16;
 
   197         *format = AL_FORMAT_MONO16;
 
   202     else {
 
   198     else {
 
   203         if (vorbisInfo->channels == 2)
 
   199         if (vorbisInfo->channels == 2)
 
   204             *format = AL_FORMAT_STEREO16;
 
   200             *format = AL_FORMAT_STEREO16;
 
   205         else {
 
   201         else {
 
   206             errno = EILSEQ;
 
   202             fprintf(stderr,"(Bridge Error) - wrong OGG header [channel %d]", vorbisInfo->channels);
 
   207             err_ret("(%s) ERROR - wrong OGG header [channel %d]", prog, vorbisInfo->channels);
 
       
   208             ov_clear(&oggStream);
 
   203             ov_clear(&oggStream);
 
   209             return -1;
 
   204             return -2;
 
   210         }
 
   205         }
 
   211     }
 
   206     }
 
   212 
   207 
   213     size = 0;
 
   208     size = 0;
 
   214 #ifdef __LITTLE_ENDIAN__
 
   209 #ifdef __LITTLE_ENDIAN__
 
   223             size += result;
 
   218             size += result;
 
   224         } else {
 
   219         } else {
 
   225             if (result == 0)
 
   220             if (result == 0)
 
   226                 break;
 
   221                 break;
 
   227             else {
 
   222             else {
 
   228                 errno = EILSEQ;
 
   223                 fprintf(stderr,"(Bridge Error) - End of file from OGG stream");
 
   229                 err_ret("(%s) ERROR - End of file from OGG stream", prog);
 
       
   230                 ov_clear(&oggStream);
 
   224                 ov_clear(&oggStream);
 
   231                 return -1;
 
   225                 return -3;
 
   232             }
 
   226             }
 
   233         }
 
   227         }
 
   234     }
 
   228     }
 
   235 
   229 
   236     /*set the last fields*/
 
   230     /*set the last fields*/
hedgewars-draft