[14] | 1 | #include "alutInternal.h" |
---|
| 2 | #include <ctype.h> |
---|
| 3 | |
---|
| 4 | /****************************************************************************/ |
---|
| 5 | |
---|
| 6 | typedef enum |
---|
| 7 | { |
---|
| 8 | LittleEndian, |
---|
| 9 | BigEndian, |
---|
| 10 | UnknwonEndian /* has anybody still a PDP11? :-) */ |
---|
| 11 | } Endianess; |
---|
| 12 | |
---|
| 13 | /* test from Harbison & Steele, "C - A Reference Manual", section 6.1.2 */ |
---|
| 14 | static Endianess |
---|
| 15 | endianess (void) |
---|
| 16 | { |
---|
| 17 | union |
---|
| 18 | { |
---|
| 19 | long l; |
---|
| 20 | char c[sizeof (long)]; |
---|
| 21 | } u; |
---|
| 22 | |
---|
| 23 | u.l = 1; |
---|
| 24 | return (u.c[0] == 1) ? LittleEndian : |
---|
| 25 | ((u.c[sizeof (long) - 1] == 1) ? BigEndian : UnknwonEndian); |
---|
| 26 | } |
---|
| 27 | |
---|
| 28 | /****************************************************************************/ |
---|
| 29 | |
---|
| 30 | static int |
---|
| 31 | safeToLower (int c) |
---|
| 32 | { |
---|
| 33 | return isupper (c) ? tolower (c) : c; |
---|
| 34 | } |
---|
| 35 | |
---|
| 36 | static int |
---|
| 37 | hasSuffixIgnoringCase (const char *string, const char *suffix) |
---|
| 38 | { |
---|
| 39 | const char *stringPointer = string; |
---|
| 40 | const char *suffixPointer = suffix; |
---|
| 41 | |
---|
| 42 | if (suffix[0] == '\0') |
---|
| 43 | { |
---|
| 44 | return 1; |
---|
| 45 | } |
---|
| 46 | |
---|
| 47 | while (*stringPointer != '\0') |
---|
| 48 | { |
---|
| 49 | stringPointer++; |
---|
| 50 | } |
---|
| 51 | |
---|
| 52 | while (*suffixPointer != '\0') |
---|
| 53 | { |
---|
| 54 | suffixPointer++; |
---|
| 55 | } |
---|
| 56 | |
---|
| 57 | if (stringPointer - string < suffixPointer - suffix) |
---|
| 58 | { |
---|
| 59 | return 0; |
---|
| 60 | } |
---|
| 61 | |
---|
| 62 | while (safeToLower (*--suffixPointer) == safeToLower (*--stringPointer)) |
---|
| 63 | { |
---|
| 64 | if (suffixPointer == suffix) |
---|
| 65 | { |
---|
| 66 | return 1; |
---|
| 67 | } |
---|
| 68 | } |
---|
| 69 | |
---|
| 70 | return 0; |
---|
| 71 | } |
---|
| 72 | |
---|
| 73 | static BufferData * |
---|
| 74 | loadWavFile (InputStream *stream) |
---|
| 75 | { |
---|
| 76 | ALboolean found_header = AL_FALSE; |
---|
| 77 | UInt32LittleEndian chunkLength; |
---|
| 78 | Int32BigEndian magic; |
---|
| 79 | UInt16LittleEndian audioFormat; |
---|
| 80 | UInt16LittleEndian numChannels; |
---|
| 81 | UInt32LittleEndian sampleFrequency; |
---|
| 82 | UInt32LittleEndian byteRate; |
---|
| 83 | UInt16LittleEndian blockAlign; |
---|
| 84 | UInt16LittleEndian bitsPerSample; |
---|
| 85 | Codec *codec = _alutCodecLinear; |
---|
| 86 | |
---|
| 87 | if (!_alutInputStreamReadUInt32LE (stream, &chunkLength) || |
---|
| 88 | !_alutInputStreamReadInt32BE (stream, &magic)) |
---|
| 89 | { |
---|
| 90 | return NULL; |
---|
| 91 | } |
---|
| 92 | |
---|
| 93 | if (magic != 0x57415645) /* "WAVE" */ |
---|
| 94 | { |
---|
| 95 | _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE); |
---|
| 96 | return NULL; |
---|
| 97 | } |
---|
| 98 | |
---|
| 99 | while (1) |
---|
| 100 | { |
---|
| 101 | if (!_alutInputStreamReadInt32BE (stream, &magic) || |
---|
| 102 | !_alutInputStreamReadUInt32LE (stream, &chunkLength)) |
---|
| 103 | { |
---|
| 104 | return NULL; |
---|
| 105 | } |
---|
| 106 | |
---|
| 107 | if (magic == 0x666d7420) /* "fmt " */ |
---|
| 108 | { |
---|
| 109 | found_header = AL_TRUE; |
---|
| 110 | |
---|
| 111 | if (chunkLength < 16) |
---|
| 112 | { |
---|
| 113 | _alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); |
---|
| 114 | return NULL; |
---|
| 115 | } |
---|
| 116 | |
---|
| 117 | if (!_alutInputStreamReadUInt16LE (stream, &audioFormat) || |
---|
| 118 | !_alutInputStreamReadUInt16LE (stream, &numChannels) || |
---|
| 119 | !_alutInputStreamReadUInt32LE (stream, &sampleFrequency) || |
---|
| 120 | !_alutInputStreamReadUInt32LE (stream, &byteRate) || |
---|
| 121 | !_alutInputStreamReadUInt16LE (stream, &blockAlign) || |
---|
| 122 | !_alutInputStreamReadUInt16LE (stream, &bitsPerSample)) |
---|
| 123 | { |
---|
| 124 | return NULL; |
---|
| 125 | } |
---|
| 126 | |
---|
| 127 | if (!_alutInputStreamSkip (stream, chunkLength - 16)) |
---|
| 128 | { |
---|
| 129 | return NULL; |
---|
| 130 | } |
---|
| 131 | |
---|
| 132 | switch (audioFormat) |
---|
| 133 | { |
---|
| 134 | case 1: /* PCM */ |
---|
| 135 | codec = (bitsPerSample == 8 |
---|
| 136 | || endianess () == |
---|
| 137 | LittleEndian) ? _alutCodecLinear : _alutCodecPCM16; |
---|
| 138 | break; |
---|
| 139 | case 7: /* uLaw */ |
---|
| 140 | bitsPerSample *= 2; /* ToDo: ??? */ |
---|
| 141 | codec = _alutCodecULaw; |
---|
| 142 | break; |
---|
| 143 | default: |
---|
| 144 | _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE); |
---|
| 145 | return NULL; |
---|
| 146 | } |
---|
| 147 | } |
---|
| 148 | else if (magic == 0x64617461) /* "data" */ |
---|
| 149 | { |
---|
| 150 | ALvoid *data; |
---|
| 151 | if (!found_header) |
---|
| 152 | { |
---|
| 153 | /* ToDo: A bit wrong to check here, fmt chunk could come later... */ |
---|
| 154 | _alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); |
---|
| 155 | return NULL; |
---|
| 156 | } |
---|
| 157 | data = _alutInputStreamRead (stream, chunkLength); |
---|
| 158 | if (data == NULL) |
---|
| 159 | { |
---|
| 160 | return NULL; |
---|
| 161 | } |
---|
| 162 | return codec (data, chunkLength, numChannels, bitsPerSample, |
---|
| 163 | (ALfloat) sampleFrequency); |
---|
| 164 | } |
---|
| 165 | else |
---|
| 166 | { |
---|
| 167 | if (!_alutInputStreamSkip (stream, chunkLength)) |
---|
| 168 | { |
---|
| 169 | return NULL; |
---|
| 170 | } |
---|
| 171 | } |
---|
| 172 | |
---|
| 173 | if ((chunkLength & 1) && !_alutInputStreamEOF (stream) |
---|
| 174 | && !_alutInputStreamSkip (stream, 1)) |
---|
| 175 | { |
---|
| 176 | return NULL; |
---|
| 177 | } |
---|
| 178 | } |
---|
| 179 | } |
---|
| 180 | |
---|
| 181 | static BufferData * |
---|
| 182 | loadAUFile (InputStream *stream) |
---|
| 183 | { |
---|
| 184 | Int32BigEndian dataOffset; /* byte offset to data part, minimum 24 */ |
---|
| 185 | Int32BigEndian len; /* number of bytes in the data part, -1 = not known */ |
---|
| 186 | Int32BigEndian encoding; /* encoding of the data part, see AUEncoding */ |
---|
| 187 | Int32BigEndian sampleFrequency; /* number of samples per second */ |
---|
| 188 | Int32BigEndian numChannels; /* number of interleaved channels */ |
---|
| 189 | size_t length; |
---|
| 190 | Codec *codec; |
---|
| 191 | char *data; |
---|
| 192 | ALint bitsPerSample; |
---|
| 193 | |
---|
| 194 | if (!_alutInputStreamReadInt32BE (stream, &dataOffset) || |
---|
| 195 | !_alutInputStreamReadInt32BE (stream, &len) || |
---|
| 196 | !_alutInputStreamReadInt32BE (stream, &encoding) || |
---|
| 197 | !_alutInputStreamReadInt32BE (stream, &sampleFrequency) || |
---|
| 198 | !_alutInputStreamReadInt32BE (stream, &numChannels)) |
---|
| 199 | { |
---|
| 200 | return AL_FALSE; |
---|
| 201 | } |
---|
| 202 | |
---|
| 203 | length = (len == -1) ? |
---|
| 204 | (_alutInputStreamGetRemainingLength (stream) - AU_HEADER_SIZE - |
---|
| 205 | dataOffset) : (size_t) len; |
---|
| 206 | |
---|
| 207 | if (! |
---|
| 208 | (dataOffset >= AU_HEADER_SIZE && length > 0 && sampleFrequency >= 1 |
---|
| 209 | && numChannels >= 1)) |
---|
| 210 | { |
---|
| 211 | _alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); |
---|
| 212 | return AL_FALSE; |
---|
| 213 | } |
---|
| 214 | |
---|
| 215 | if (!_alutInputStreamSkip (stream, dataOffset - AU_HEADER_SIZE)) |
---|
| 216 | { |
---|
| 217 | return AL_FALSE; |
---|
| 218 | } |
---|
| 219 | |
---|
| 220 | switch (encoding) |
---|
| 221 | { |
---|
| 222 | case AU_ULAW_8: |
---|
| 223 | bitsPerSample = 16; |
---|
| 224 | codec = _alutCodecULaw; |
---|
| 225 | break; |
---|
| 226 | case AU_PCM_8: |
---|
| 227 | bitsPerSample = 8; |
---|
| 228 | codec = _alutCodecPCM8s; |
---|
| 229 | break; |
---|
| 230 | case AU_PCM_16: |
---|
| 231 | bitsPerSample = 16; |
---|
| 232 | codec = |
---|
| 233 | (endianess () == BigEndian) ? _alutCodecLinear : _alutCodecPCM16; |
---|
| 234 | break; |
---|
| 235 | case AU_ALAW_8: |
---|
| 236 | bitsPerSample = 16; |
---|
| 237 | codec = _alutCodecALaw; |
---|
| 238 | break; |
---|
| 239 | default: |
---|
| 240 | _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE); |
---|
| 241 | return AL_FALSE; |
---|
| 242 | } |
---|
| 243 | |
---|
| 244 | data = _alutInputStreamRead (stream, length); |
---|
| 245 | if (data == NULL) |
---|
| 246 | { |
---|
| 247 | return NULL; |
---|
| 248 | } |
---|
| 249 | return codec (data, length, numChannels, bitsPerSample, |
---|
| 250 | (ALfloat) sampleFrequency); |
---|
| 251 | } |
---|
| 252 | |
---|
| 253 | static BufferData * |
---|
| 254 | loadRawFile (InputStream *stream) |
---|
| 255 | { |
---|
| 256 | size_t length = _alutInputStreamGetRemainingLength (stream); |
---|
| 257 | ALvoid *data = _alutInputStreamRead (stream, length); |
---|
| 258 | if (data == NULL) |
---|
| 259 | { |
---|
| 260 | return NULL; |
---|
| 261 | } |
---|
| 262 | /* Guesses */ |
---|
| 263 | return _alutCodecLinear (data, length, 1, 8, 8000); |
---|
| 264 | } |
---|
| 265 | |
---|
| 266 | static BufferData * |
---|
| 267 | loadFile (InputStream *stream) |
---|
| 268 | { |
---|
| 269 | const char *fileName; |
---|
| 270 | Int32BigEndian magic; |
---|
| 271 | |
---|
| 272 | /* Raw files have no magic number - so use the fileName extension */ |
---|
| 273 | |
---|
| 274 | fileName = _alutInputStreamGetFileName (stream); |
---|
| 275 | if (fileName != NULL && hasSuffixIgnoringCase (fileName, ".raw")) |
---|
| 276 | { |
---|
| 277 | return loadRawFile (stream); |
---|
| 278 | } |
---|
| 279 | |
---|
| 280 | /* For other file formats, read the quasi-standard four byte magic number */ |
---|
| 281 | if (!_alutInputStreamReadInt32BE (stream, &magic)) |
---|
| 282 | { |
---|
| 283 | return AL_FALSE; |
---|
| 284 | } |
---|
| 285 | |
---|
| 286 | /* Magic number 'RIFF' == Microsoft '.wav' format */ |
---|
| 287 | if (magic == 0x52494646) |
---|
| 288 | { |
---|
| 289 | return loadWavFile (stream); |
---|
| 290 | } |
---|
| 291 | |
---|
| 292 | /* Magic number '.snd' == Sun & Next's '.au' format */ |
---|
| 293 | if (magic == 0x2E736E64) |
---|
| 294 | { |
---|
| 295 | return loadAUFile (stream); |
---|
| 296 | } |
---|
| 297 | |
---|
| 298 | _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_TYPE); |
---|
| 299 | return AL_FALSE; |
---|
| 300 | } |
---|
| 301 | |
---|
| 302 | ALuint |
---|
| 303 | _alutCreateBufferFromInputStream (InputStream *stream) |
---|
| 304 | { |
---|
| 305 | BufferData *bufferData; |
---|
| 306 | ALuint buffer; |
---|
| 307 | |
---|
| 308 | if (stream == NULL) |
---|
| 309 | { |
---|
| 310 | return AL_NONE; |
---|
| 311 | } |
---|
| 312 | |
---|
| 313 | bufferData = loadFile (stream); |
---|
| 314 | _alutInputStreamDestroy (stream); |
---|
| 315 | if (bufferData == NULL) |
---|
| 316 | { |
---|
| 317 | return AL_NONE; |
---|
| 318 | } |
---|
| 319 | |
---|
| 320 | buffer = _alutPassBufferData (bufferData); |
---|
| 321 | _alutBufferDataDestroy (bufferData); |
---|
| 322 | |
---|
| 323 | return buffer; |
---|
| 324 | } |
---|
| 325 | |
---|
| 326 | ALuint |
---|
| 327 | alutCreateBufferFromFile (const char *fileName) |
---|
| 328 | { |
---|
| 329 | InputStream *stream; |
---|
| 330 | if (!_alutSanityCheck ()) |
---|
| 331 | { |
---|
| 332 | return AL_NONE; |
---|
| 333 | } |
---|
| 334 | stream = _alutInputStreamConstructFromFile (fileName); |
---|
| 335 | return _alutCreateBufferFromInputStream (stream); |
---|
| 336 | } |
---|
| 337 | |
---|
| 338 | ALuint |
---|
| 339 | alutCreateBufferFromFileImage (const ALvoid *data, ALsizei length) |
---|
| 340 | { |
---|
| 341 | InputStream *stream; |
---|
| 342 | if (!_alutSanityCheck ()) |
---|
| 343 | { |
---|
| 344 | return AL_NONE; |
---|
| 345 | } |
---|
| 346 | stream = _alutInputStreamConstructFromMemory (data, length); |
---|
| 347 | return _alutCreateBufferFromInputStream (stream); |
---|
| 348 | } |
---|
| 349 | |
---|
| 350 | void * |
---|
| 351 | _alutLoadMemoryFromInputStream (InputStream *stream, ALenum *format, |
---|
| 352 | ALsizei *size, ALfloat *frequency) |
---|
| 353 | { |
---|
| 354 | BufferData *bufferData; |
---|
| 355 | ALenum fmt; |
---|
| 356 | void *data; |
---|
| 357 | |
---|
| 358 | if (stream == NULL) |
---|
| 359 | { |
---|
| 360 | return NULL; |
---|
| 361 | } |
---|
| 362 | |
---|
| 363 | bufferData = loadFile (stream); |
---|
| 364 | if (bufferData == NULL) |
---|
| 365 | { |
---|
| 366 | _alutInputStreamDestroy (stream); |
---|
| 367 | return NULL; |
---|
| 368 | } |
---|
| 369 | _alutInputStreamDestroy (stream); |
---|
| 370 | |
---|
| 371 | if (!_alutGetFormat (bufferData, &fmt)) |
---|
| 372 | { |
---|
| 373 | _alutBufferDataDestroy (bufferData); |
---|
| 374 | return NULL; |
---|
| 375 | } |
---|
| 376 | |
---|
| 377 | if (size != NULL) |
---|
| 378 | { |
---|
| 379 | *size = (ALsizei) _alutBufferDataGetLength (bufferData); |
---|
| 380 | } |
---|
| 381 | |
---|
| 382 | if (format != NULL) |
---|
| 383 | { |
---|
| 384 | *format = fmt; |
---|
| 385 | } |
---|
| 386 | |
---|
| 387 | if (frequency != NULL) |
---|
| 388 | { |
---|
| 389 | *frequency = _alutBufferDataGetSampleFrequency (bufferData); |
---|
| 390 | } |
---|
| 391 | |
---|
| 392 | data = _alutBufferDataGetData (bufferData); |
---|
| 393 | _alutBufferDataDetachData (bufferData); |
---|
| 394 | _alutBufferDataDestroy (bufferData); |
---|
| 395 | return data; |
---|
| 396 | } |
---|
| 397 | |
---|
| 398 | ALvoid * |
---|
| 399 | alutLoadMemoryFromFile (const char *fileName, ALenum *format, |
---|
| 400 | ALsizei *size, ALfloat *frequency) |
---|
| 401 | { |
---|
| 402 | InputStream *stream; |
---|
| 403 | if (!_alutSanityCheck ()) |
---|
| 404 | { |
---|
| 405 | return NULL; |
---|
| 406 | } |
---|
| 407 | stream = _alutInputStreamConstructFromFile (fileName); |
---|
| 408 | return _alutLoadMemoryFromInputStream (stream, format, size, frequency); |
---|
| 409 | } |
---|
| 410 | |
---|
| 411 | ALvoid * |
---|
| 412 | alutLoadMemoryFromFileImage (const ALvoid *data, ALsizei length, |
---|
| 413 | ALenum *format, ALsizei *size, |
---|
| 414 | ALfloat *frequency) |
---|
| 415 | { |
---|
| 416 | InputStream *stream; |
---|
| 417 | if (!_alutSanityCheck ()) |
---|
| 418 | { |
---|
| 419 | return NULL; |
---|
| 420 | } |
---|
| 421 | stream = _alutInputStreamConstructFromMemory (data, length); |
---|
| 422 | return _alutLoadMemoryFromInputStream (stream, format, size, frequency); |
---|
| 423 | } |
---|
| 424 | |
---|
| 425 | /* |
---|
| 426 | Yukky backwards compatibility crap. |
---|
| 427 | */ |
---|
| 428 | |
---|
| 429 | void |
---|
| 430 | alutLoadWAVFile (ALbyte *fileName, ALenum *format, void **data, ALsizei *size, |
---|
| 431 | ALsizei *frequency |
---|
| 432 | #if !defined(__APPLE__) |
---|
| 433 | , ALboolean *loop |
---|
| 434 | #endif |
---|
| 435 | ) |
---|
| 436 | { |
---|
| 437 | InputStream *stream; |
---|
| 438 | ALfloat freq; |
---|
| 439 | |
---|
| 440 | /* Don't do an _alutSanityCheck () because it's not required in ALUT 0.x.x */ |
---|
| 441 | |
---|
| 442 | stream = _alutInputStreamConstructFromFile (fileName); |
---|
| 443 | *data = _alutLoadMemoryFromInputStream (stream, format, size, &freq); |
---|
| 444 | if (*data == NULL) |
---|
| 445 | { |
---|
| 446 | return; |
---|
| 447 | } |
---|
| 448 | |
---|
| 449 | if (frequency) |
---|
| 450 | { |
---|
| 451 | *frequency = (ALsizei) freq; |
---|
| 452 | } |
---|
| 453 | |
---|
| 454 | #if !defined(__APPLE__) |
---|
| 455 | if (loop) |
---|
| 456 | { |
---|
| 457 | *loop = AL_FALSE; |
---|
| 458 | } |
---|
| 459 | #endif |
---|
| 460 | } |
---|
| 461 | |
---|
| 462 | void |
---|
| 463 | alutLoadWAVMemory (ALbyte *buffer, ALenum *format, void **data, ALsizei *size, |
---|
| 464 | ALsizei *frequency |
---|
| 465 | #if !defined(__APPLE__) |
---|
| 466 | , ALboolean *loop |
---|
| 467 | #endif |
---|
| 468 | ) |
---|
| 469 | { |
---|
| 470 | InputStream *stream; |
---|
| 471 | ALfloat freq; |
---|
| 472 | |
---|
| 473 | /* Don't do an _alutSanityCheck () because it's not required in ALUT 0.x.x */ |
---|
| 474 | |
---|
| 475 | /* ToDo: Can we do something less insane than passing 0x7FFFFFFF? */ |
---|
| 476 | stream = _alutInputStreamConstructFromMemory (buffer, 0x7FFFFFFF); |
---|
| 477 | _alutLoadMemoryFromInputStream (stream, format, size, &freq); |
---|
| 478 | if (*data == NULL) |
---|
| 479 | { |
---|
| 480 | return; |
---|
| 481 | } |
---|
| 482 | |
---|
| 483 | if (frequency) |
---|
| 484 | { |
---|
| 485 | *frequency = (ALsizei) freq; |
---|
| 486 | } |
---|
| 487 | |
---|
| 488 | #if !defined(__APPLE__) |
---|
| 489 | if (loop) |
---|
| 490 | { |
---|
| 491 | *loop = AL_FALSE; |
---|
| 492 | } |
---|
| 493 | #endif |
---|
| 494 | } |
---|
| 495 | |
---|
| 496 | void |
---|
| 497 | alutUnloadWAV (ALenum UNUSED (format), ALvoid *data, ALsizei UNUSED (size), |
---|
| 498 | ALsizei UNUSED (frequency)) |
---|
| 499 | { |
---|
| 500 | /* Don't do an _alutSanityCheck () because it's not required in ALUT 0.x.x */ |
---|
| 501 | |
---|
| 502 | free (data); |
---|
| 503 | } |
---|
| 504 | |
---|
| 505 | const char * |
---|
| 506 | alutGetMIMETypes (ALenum loader) |
---|
| 507 | { |
---|
| 508 | if (!_alutSanityCheck ()) |
---|
| 509 | { |
---|
| 510 | return NULL; |
---|
| 511 | } |
---|
| 512 | |
---|
| 513 | /* We do not distinguish the loaders yet... */ |
---|
| 514 | switch (loader) |
---|
| 515 | { |
---|
| 516 | case ALUT_LOADER_BUFFER: |
---|
| 517 | return "audio/basic,audio/x-raw,audio/x-wav"; |
---|
| 518 | |
---|
| 519 | case ALUT_LOADER_MEMORY: |
---|
| 520 | return "audio/basic,audio/x-raw,audio/x-wav"; |
---|
| 521 | |
---|
| 522 | default: |
---|
| 523 | _alutSetError (ALUT_ERROR_INVALID_ENUM); |
---|
| 524 | return NULL; |
---|
| 525 | } |
---|
| 526 | } |
---|