src/streamdec.cpp

   1 /*
   2  * ALURE  OpenAL utility library
   3  * Copyright (c) 2009-2010 by Chris Robinson.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to
   7  * deal in the Software without restriction, including without limitation the
   8  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   9  * sell copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include "config.h"
  25
  26 #include "main.h"
  27
  28 #include <string.h>
  29
  30 #include <algorithm>
  31 #include <vector>
  32 #include <memory>
  33 #include <string>
  34 #include <istream>
  35 #include <fstream>
  36 #include <iostream>
  37 #include <sstream>
  38
  39
  40 static inline ALuint read_le32(std::istream *file)
  41 {
  42     ALubyte buffer[4];
  43     if(!file->read(reinterpret_cast<char*>(buffer), 4)) return 0;
  44     return buffer[0] | (buffer[1]<<8) | (buffer[2]<<16) | (buffer[3]<<24);
  45 }
  46
  47 static inline ALushort read_le16(std::istream *file)
  48 {
  49     ALubyte buffer[2];
  50     if(!file->read(reinterpret_cast<char*>(buffer), 2)) return 0;
  51     return buffer[0] | (buffer[1]<<8);
  52 }
  53
  54 static inline ALuint read_be32(std::istream *file)
  55 {
  56     ALubyte buffer[4];
  57     if(!file->read(reinterpret_cast<char*>(buffer), 4)) return 0;
  58     return (buffer[0]<<24) | (buffer[1]<<16) | (buffer[2]<<8) | buffer[3];
  59 }
  60
  61 static inline ALushort read_be16(std::istream *file)
  62 {
  63     ALubyte buffer[2];
  64     if(!file->read(reinterpret_cast<char*>(buffer), 2)) return 0;
  65     return (buffer[0]<<8) | buffer[1];
  66 }
  67
  68 static inline ALuint read_be80extended(std::istream *file)
  69 {
  70     ALubyte buffer[10];
  71     if(!file->read(reinterpret_cast<char*>(buffer), 10)) return 0;
  72     ALuint mantissa, last = 0;
  73     ALubyte exp = buffer[1];
  74     exp = 30 - exp;
  75     mantissa = (buffer[2]<<24) | (buffer[3]<<16) | (buffer[4]<<8) | buffer[5];
  76     while (exp--)
  77     {
  78         last = mantissa;
  79         mantissa >>= 1;
  80     }
  81     if((last&1)) mantissa++;
  82     return mantissa;
  83 }
  84
  85
  86 struct nullStream : public alureStream {
  87     virtual bool IsValid() { return false; }
  88     virtual bool GetFormat(ALenum*,ALuint*,ALuint*) { return false; }
  89     virtual ALuint GetData(ALubyte*,ALuint) { return 0; }
  90     virtual bool Rewind() { return false; }
  91     nullStream():alureStream(NULL) {}
  92 };
  93
  94
  95 struct customStream : public alureStream {
  96     void *usrFile;
  97     ALenum format;
  98     ALuint samplerate;
  99     ALuint blockAlign;
 100     MemDataInfo memInfo;
 101
 102     UserCallbacks cb;
 103
 104     virtual bool IsValid()
 105     { return usrFile != NULL; }
 106
 107     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 108     {
 109         if(format == AL_NONE)
 110         {
 111             if(!cb.get_fmt ||
 112                !cb.get_fmt(usrFile, &this->format, &samplerate, &blockAlign))
 113                 return false;
 114         }
 115
 116         *fmt = format;
 117         *frequency = samplerate;
 118         *blockalign = blockAlign;
 119         return true;
 120     }
 121
 122     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 123     { return cb.decode(usrFile, data, bytes); }
 124
 125     virtual bool Rewind()
 126     {
 127         if(cb.rewind && cb.rewind(usrFile))
 128             return true;
 129         SetError("Rewind failed");
 130         return false;
 131     }
 132
 133     customStream(const char *fname, const UserCallbacks &callbacks)
 134       : alureStream(NULL), usrFile(NULL), format(0), samplerate(0),
 135         blockAlign(0), cb(callbacks)
 136     { if(cb.open_file) usrFile = cb.open_file(fname); }
 137
 138     customStream(const MemDataInfo &memData, const UserCallbacks &callbacks)
 139       : alureStream(NULL), usrFile(NULL), format(0), samplerate(0),
 140         blockAlign(0), memInfo(memData), cb(callbacks)
 141     { if(cb.open_mem) usrFile = cb.open_mem(memInfo.Data, memInfo.Length); }
 142
 143     customStream(void *userdata, ALenum fmt, ALuint srate, const UserCallbacks &callbacks)
 144       : alureStream(NULL), usrFile(userdata), format(fmt), samplerate(srate),
 145         blockAlign(DetectBlockAlignment(format)), cb(callbacks)
 146     { }
 147
 148     virtual ~customStream()
 149     {
 150         if(cb.close && usrFile)
 151             cb.close(usrFile);
 152         usrFile = NULL;
 153     }
 154 };
 155
 156
 157 struct wavStream : public alureStream {
 158     ALenum format;
 159     int samplerate;
 160     int blockAlign;
 161     int sampleSize;
 162     long dataStart;
 163     long dataLen;
 164     size_t remLen;
 165
 166     virtual bool IsValid()
 167     { return (dataStart > 0 && format != AL_NONE); }
 168
 169     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 170     {
 171         *fmt = format;
 172         *frequency = samplerate;
 173         *blockalign = blockAlign;
 174         return true;
 175     }
 176
 177     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 178     {
 179         std::streamsize rem = ((remLen >= bytes) ? bytes : remLen) / blockAlign;
 180         fstream->read(reinterpret_cast<char*>(data), rem*blockAlign);
 181
 182         std::streamsize got = fstream->gcount();
 183         got -= got%blockAlign;
 184         remLen -= got;
 185
 186         if(BigEndian && sampleSize == 16)
 187         {
 188             for(std::streamsize i = 0;i < got;i+=2)
 189                 swap(data[i], data[i+1]);
 190         }
 191         else if(BigEndian && sampleSize == 32)
 192         {
 193             for(std::streamsize i = 0;i < got;i+=4)
 194             {
 195                 swap(data[i+0], data[i+3]);
 196                 swap(data[i+1], data[i+2]);
 197             }
 198         }
 199         else if(BigEndian && sampleSize == 64)
 200         {
 201             for(std::streamsize i = 0;i < got;i+=8)
 202             {
 203                 swap(data[i+0], data[i+7]);
 204                 swap(data[i+1], data[i+6]);
 205                 swap(data[i+2], data[i+5]);
 206                 swap(data[i+3], data[i+4]);
 207             }
 208         }
 209
 210         return got;
 211     }
 212
 213     virtual bool Rewind()
 214     {
 215         fstream->clear();
 216         if(fstream->seekg(dataStart))
 217         {
 218             remLen = dataLen;
 219             return true;
 220         }
 221
 222         SetError("Seek failed");
 223         return false;
 224     }
 225
 226     wavStream(std::istream *_fstream)
 227       : alureStream(_fstream), format(0), dataStart(0)
 228     {
 229         ALubyte buffer[25];
 230         int length;
 231
 232         if(!fstream->read(reinterpret_cast<char*>(buffer), 12) ||
 233            memcmp(buffer, "RIFF", 4) != 0 || memcmp(buffer+8, "WAVE", 4) != 0)
 234             return;
 235
 236         while(!dataStart || format == AL_NONE)
 237         {
 238             char tag[4];
 239             if(!fstream->read(tag, 4))
 240                 break;
 241
 242             /* read chunk length */
 243             length = read_le32(fstream);
 244
 245             if(memcmp(tag, "fmt ", 4) == 0 && length >= 16)
 246             {
 247                 /* Data type (should be 1 for PCM data, 3 for float PCM data,
 248                  * and 17 for IMA4 data) */
 249                 int type = read_le16(fstream);
 250                 if(type != 0x0001 && type != 0x0003 && type != 0x0011)
 251                     break;
 252
 253                 /* mono or stereo data */
 254                 int channels = read_le16(fstream);
 255
 256                 /* sample frequency */
 257                 samplerate = read_le32(fstream);
 258
 259                 /* skip four bytes */
 260                 fstream->ignore(4);
 261
 262                 /* bytes per block */
 263                 blockAlign = read_le16(fstream);
 264                 if(blockAlign == 0)
 265                     break;
 266
 267                 /* bits per sample */
 268                 sampleSize = read_le16(fstream);
 269
 270                 length -= 16;
 271
 272                 /* Look for any extra data and try to find the format */
 273                 int extrabytes = 0;
 274                 if(length >= 2)
 275                 {
 276                     extrabytes = read_le16(fstream);
 277                     length -= 2;
 278                 }
 279                 extrabytes = std::min(extrabytes, length);
 280
 281                 if(type == 0x0001)
 282                     format = GetSampleFormat(channels, sampleSize, false);
 283                 else if(type == 0x0003)
 284                     format = GetSampleFormat(channels, sampleSize, true);
 285                 else if(type == 0x0011 && extrabytes >= 2)
 286                 {
 287                     int samples = read_le16(fstream);
 288                     length -= 2;
 289
 290                     /* AL_EXT_IMA4 only supports 36 bytes-per-channel block
 291                      * alignment, which has 65 uncompressed sample frames */
 292                     if(blockAlign == 36*channels && samples == 65*channels &&
 293                        alIsExtensionPresent("AL_EXT_IMA4"))
 294                     {
 295                          if(channels == 1)
 296                              format = AL_FORMAT_MONO_IMA4;
 297                          else if(channels == 2)
 298                              format = AL_FORMAT_STEREO_IMA4;
 299                     }
 300                 }
 301             }
 302             else if(memcmp(tag, "data", 4) == 0)
 303             {
 304                 dataStart = fstream->tellg();
 305                 dataLen = remLen = length;
 306             }
 307
 308             fstream->seekg(length, std::ios_base::cur);
 309         }
 310
 311         if(dataStart > 0 && format != AL_NONE)
 312             fstream->seekg(dataStart);
 313     }
 314
 315     virtual ~wavStream()
 316     { }
 317 };
 318
 319 struct aiffStream : public alureStream {
 320     ALenum format;
 321     int samplerate;
 322     int blockAlign;
 323     int sampleSize;
 324     long dataStart;
 325     long dataLen;
 326     size_t remLen;
 327
 328     virtual bool IsValid()
 329     { return (dataStart > 0 && format != AL_NONE); }
 330
 331     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 332     {
 333         *fmt = format;
 334         *frequency = samplerate;
 335         *blockalign = blockAlign;
 336         return true;
 337     }
 338
 339     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 340     {
 341         std::streamsize rem = ((remLen >= bytes) ? bytes : remLen) / blockAlign;
 342         fstream->read(reinterpret_cast<char*>(data), rem*blockAlign);
 343
 344         std::streamsize got = fstream->gcount();
 345         got -= got%blockAlign;
 346         remLen -= got;
 347
 348         if(LittleEndian)
 349         {
 350             if(sampleSize == 2)
 351             {
 352                 for(std::streamsize i = 0;i < got;i+=2)
 353                     swap(data[i], data[i+1]);
 354             }
 355             else if(sampleSize == 4)
 356             {
 357                 for(std::streamsize i = 0;i < got;i+=4)
 358                 {
 359                     swap(data[i+0], data[i+3]);
 360                     swap(data[i+1], data[i+2]);
 361                 }
 362             }
 363         }
 364
 365         return got;
 366     }
 367
 368     virtual bool Rewind()
 369     {
 370         fstream->clear();
 371         if(fstream->seekg(dataStart))
 372         {
 373             remLen = dataLen;
 374             return true;
 375         }
 376
 377         SetError("Seek failed");
 378         return false;
 379     }
 380
 381     aiffStream(std::istream *_fstream)
 382       : alureStream(_fstream), format(0), dataStart(0)
 383     {
 384         ALubyte buffer[25];
 385         int length;
 386
 387         if(!fstream->read(reinterpret_cast<char*>(buffer), 12) ||
 388            memcmp(buffer, "FORM", 4) != 0 || memcmp(buffer+8, "AIFF", 4) != 0)
 389             return;
 390
 391         while(!dataStart || format == AL_NONE)
 392         {
 393             char tag[4];
 394             if(!fstream->read(tag, 4))
 395                 break;
 396
 397             /* read chunk length */
 398             length = read_be32(fstream);
 399
 400             if(memcmp(tag, "COMM", 4) == 0 && length >= 18)
 401             {
 402                 /* mono or stereo data */
 403                 int channels = read_be16(fstream);
 404
 405                 /* number of sample frames */
 406                 fstream->ignore(4);
 407
 408                 /* bits per sample */
 409                 sampleSize = read_be16(fstream) / 8;
 410
 411                 /* sample frequency */
 412                 samplerate = read_be80extended(fstream);
 413
 414                 /* block alignment */
 415                 blockAlign = channels * sampleSize;
 416
 417                 format = GetSampleFormat(channels, sampleSize*8, false);
 418
 419                 length -= 18;
 420             }
 421             else if(memcmp(tag, "SSND", 4) == 0)
 422             {
 423                 dataStart = fstream->tellg();
 424                 dataStart += 8;
 425                 dataLen = remLen = length - 8;
 426             }
 427
 428             fstream->seekg(length, std::ios_base::cur);
 429         }
 430
 431         if(dataStart > 0 && format != AL_NONE)
 432             fstream->seekg(dataStart);
 433     }
 434
 435     virtual ~aiffStream()
 436     { }
 437 };
 438
 439 #ifdef HAS_SNDFILE
 440 struct sndStream : public alureStream {
 441     SNDFILE *sndFile;
 442     SF_INFO sndInfo;
 443     ALenum format;
 444
 445     virtual bool IsValid()
 446     { return sndFile != NULL; }
 447
 448     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 449     {
 450         if(format == AL_NONE)
 451             format = GetSampleFormat(sndInfo.channels, 16, false);
 452         *fmt = format;
 453         *frequency = sndInfo.samplerate;
 454         *blockalign = sndInfo.channels*2;
 455         return true;
 456     }
 457
 458     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 459     {
 460         const ALuint frameSize = 2*sndInfo.channels;
 461         return psf_readf_short(sndFile, (short*)data, bytes/frameSize) * frameSize;
 462     }
 463
 464     virtual bool Rewind()
 465     {
 466         if(psf_seek(sndFile, 0, SEEK_SET) != -1)
 467             return true;
 468
 469         SetError("Seek failed");
 470         return false;
 471     }
 472
 473     sndStream(std::istream *_fstream)
 474       : alureStream(_fstream), sndFile(NULL), format(AL_NONE)
 475     {
 476         memset(&sndInfo, 0, sizeof(sndInfo));
 477
 478         if(!sndfile_handle) return;
 479
 480         static SF_VIRTUAL_IO streamIO = {
 481             get_filelen, seek,
 482             read, write, tell
 483         };
 484         sndFile = psf_open_virtual(&streamIO, SFM_READ, &sndInfo, this);
 485     }
 486
 487     virtual ~sndStream()
 488     {
 489         if(sndFile)
 490             psf_close(sndFile);
 491         sndFile = NULL;
 492     }
 493
 494 private:
 495     // libSndFile iostream callbacks
 496     static sf_count_t get_filelen(void *user_data)
 497     {
 498         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
 499         stream->clear();
 500
 501         std::streampos len = -1;
 502         std::streampos pos = stream->tellg();
 503         if(stream->seekg(0, std::ios_base::end))
 504         {
 505             len = stream->tellg();
 506             stream->seekg(pos);
 507         }
 508
 509         return len;
 510     }
 511
 512     static sf_count_t seek(sf_count_t offset, int whence, void *user_data)
 513     {
 514         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
 515         stream->clear();
 516
 517         if(whence == SEEK_CUR)
 518             stream->seekg(offset, std::ios_base::cur);
 519         else if(whence == SEEK_SET)
 520             stream->seekg(offset, std::ios_base::beg);
 521         else if(whence == SEEK_END)
 522             stream->seekg(offset, std::ios_base::end);
 523         else
 524             return -1;
 525
 526         return stream->tellg();
 527     }
 528
 529     static sf_count_t read(void *ptr, sf_count_t count, void *user_data)
 530     {
 531         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
 532         stream->clear();
 533         stream->read(static_cast<char*>(ptr), count);
 534         return stream->gcount();
 535     }
 536
 537     static sf_count_t write(const void*, sf_count_t, void*)
 538     { return -1; }
 539
 540     static sf_count_t tell(void *user_data)
 541     {
 542         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
 543         stream->clear();
 544         return stream->tellg();
 545     }
 546 };
 547 #else
 548 struct sndStream : public nullStream {
 549     sndStream(std::istream*){}
 550 };
 551 #endif
 552
 553 #ifdef HAS_VORBISFILE
 554 struct oggStream : public alureStream {
 555     OggVorbis_File oggFile;
 556     vorbis_info *oggInfo;
 557     int oggBitstream;
 558     ALenum format;
 559
 560     virtual bool IsValid()
 561     { return oggInfo != NULL; }
 562
 563     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 564     {
 565         if(format == AL_NONE)
 566             format = GetSampleFormat(oggInfo->channels, 16, false);
 567         *fmt = format;
 568         *frequency = oggInfo->rate;
 569         *blockalign = oggInfo->channels*2;
 570         return true;
 571     }
 572
 573     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 574     {
 575         ALuint got = 0;
 576         while(bytes > 0)
 577         {
 578             int res = pov_read(&oggFile, (char*)&data[got], bytes, BigEndian?1:0, 2, 1, &oggBitstream);
 579             if(res <= 0)
 580                 break;
 581             bytes -= res;
 582             got += res;
 583         }
 584         // 1, 2, and 4 channel files decode into the same channel order as
 585         // OpenAL, however 6(5.1), 7(6.1), and 8(7.1) channel files need to be
 586         // re-ordered
 587         if(oggInfo->channels == 6)
 588         {
 589             ALshort *samples = (ALshort*)data;
 590             for(ALuint i = 0;i < got/sizeof(ALshort);i+=6)
 591             {
 592                 // OpenAL : FL, FR, FC, LFE, RL, RR
 593                 // Vorbis : FL, FC, FR,  RL, RR, LFE
 594                 swap(samples[i+1], samples[i+2]);
 595                 swap(samples[i+3], samples[i+5]);
 596                 swap(samples[i+4], samples[i+5]);
 597             }
 598         }
 599         else if(oggInfo->channels == 7)
 600         {
 601             ALshort *samples = (ALshort*)data;
 602             for(ALuint i = 0;i < got/sizeof(ALshort);i+=7)
 603             {
 604                 // OpenAL : FL, FR, FC, LFE, RC, SL, SR
 605                 // Vorbis : FL, FC, FR,  SL, SR, RC, LFE
 606                 swap(samples[i+1], samples[i+2]);
 607                 swap(samples[i+3], samples[i+6]);
 608                 swap(samples[i+4], samples[i+6]);
 609                 swap(samples[i+5], samples[i+6]);
 610             }
 611         }
 612         else if(oggInfo->channels == 8)
 613         {
 614             ALshort *samples = (ALshort*)data;
 615             for(ALuint i = 0;i < got/sizeof(ALshort);i+=8)
 616             {
 617                 // OpenAL : FL, FR, FC, LFE, RL, RR, SL, SR
 618                 // Vorbis : FL, FC, FR,  SL, SR, RL, RR, LFE
 619                 swap(samples[i+1], samples[i+2]);
 620                 swap(samples[i+3], samples[i+7]);
 621                 swap(samples[i+4], samples[i+5]);
 622                 swap(samples[i+5], samples[i+6]);
 623                 swap(samples[i+6], samples[i+7]);
 624             }
 625         }
 626         return got;
 627     }
 628
 629     virtual bool Rewind()
 630     {
 631         if(pov_pcm_seek(&oggFile, 0) == 0)
 632             return true;
 633
 634         SetError("Seek failed");
 635         return false;
 636     }
 637
 638     oggStream(std::istream *_fstream)
 639       : alureStream(_fstream), oggInfo(NULL), oggBitstream(0), format(AL_NONE)
 640     {
 641         if(!vorbisfile_handle) return;
 642
 643         const ov_callbacks streamIO = {
 644             read, seek, close, tell
 645         };
 646
 647         if(pov_open_callbacks(this, &oggFile, NULL, 0, streamIO) == 0)
 648         {
 649             oggInfo = pov_info(&oggFile, -1);
 650             if(!oggInfo)
 651                 pov_clear(&oggFile);
 652         }
 653     }
 654
 655     virtual ~oggStream()
 656     {
 657         if(oggInfo)
 658             pov_clear(&oggFile);
 659         oggInfo = NULL;
 660     }
 661
 662 private:
 663     // libVorbisFile iostream callbacks
 664     static int seek(void *user_data, ogg_int64_t offset, int whence)
 665     {
 666         std::istream *stream = static_cast<oggStream*>(user_data)->fstream;
 667         stream->clear();
 668
 669         if(whence == SEEK_CUR)
 670             stream->seekg(offset, std::ios_base::cur);
 671         else if(whence == SEEK_SET)
 672             stream->seekg(offset, std::ios_base::beg);
 673         else if(whence == SEEK_END)
 674             stream->seekg(offset, std::ios_base::end);
 675         else
 676             return -1;
 677
 678         return stream->tellg();
 679     }
 680
 681     static size_t read(void *ptr, size_t size, size_t nmemb, void *user_data)
 682     {
 683         std::istream *stream = static_cast<oggStream*>(user_data)->fstream;
 684         stream->clear();
 685
 686         stream->read(static_cast<char*>(ptr), nmemb*size);
 687         size_t ret = stream->gcount();
 688         return ret/size;
 689     }
 690
 691     static long tell(void *user_data)
 692     {
 693         std::istream *stream = static_cast<oggStream*>(user_data)->fstream;
 694         stream->clear();
 695         return stream->tellg();
 696     }
 697
 698     static int close(void*)
 699     {
 700         return 0;
 701     }
 702 };
 703 #else
 704 struct oggStream : public nullStream {
 705     oggStream(std::istream*){}
 706 };
 707 #endif
 708
 709 #ifdef HAS_FLAC
 710 struct flacStream : public alureStream {
 711     FLAC__StreamDecoder *flacFile;
 712     ALenum format;
 713     ALuint samplerate;
 714     ALuint blockAlign;
 715     ALboolean useFloat;
 716
 717     std::vector<ALubyte> initialData;
 718
 719     ALubyte *outBytes;
 720     ALuint outLen;
 721     ALuint outTotal;
 722
 723     virtual bool IsValid()
 724     { return flacFile != NULL; }
 725
 726     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 727     {
 728         *fmt = format;
 729         *frequency = samplerate;
 730         *blockalign = blockAlign;
 731         return true;
 732     }
 733
 734     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 735     {
 736         outBytes = data;
 737         outTotal = 0;
 738         outLen = bytes;
 739
 740         if(initialData.size() > 0)
 741         {
 742             size_t rem = std::min(initialData.size(), (size_t)bytes);
 743             memcpy(data, &initialData[0], rem);
 744             outTotal += rem;
 745             initialData.erase(initialData.begin(), initialData.begin()+rem);
 746         }
 747
 748         while(outTotal < bytes)
 749         {
 750             if(pFLAC__stream_decoder_process_single(flacFile) == false ||
 751                pFLAC__stream_decoder_get_state(flacFile) == FLAC__STREAM_DECODER_END_OF_STREAM)
 752                 break;
 753         }
 754
 755         return outTotal;
 756     }
 757
 758     virtual bool Rewind()
 759     {
 760         if(pFLAC__stream_decoder_seek_absolute(flacFile, 0) != false)
 761         {
 762             initialData.clear();
 763             return true;
 764         }
 765
 766         SetError("Seek failed");
 767         return false;
 768     }
 769
 770     flacStream(std::istream *_fstream)
 771       : alureStream(_fstream), flacFile(NULL), format(AL_NONE), samplerate(0),
 772         blockAlign(0), useFloat(AL_FALSE)
 773     {
 774         if(!flac_handle) return;
 775
 776         flacFile = pFLAC__stream_decoder_new();
 777         if(flacFile)
 778         {
 779             if(pFLAC__stream_decoder_init_stream(flacFile, ReadCallback, SeekCallback, TellCallback, LengthCallback, EofCallback, WriteCallback, MetadataCallback, ErrorCallback, this) == FLAC__STREAM_DECODER_INIT_STATUS_OK)
 780             {
 781                 if(InitFlac())
 782                 {
 783                     // all ok
 784                     return;
 785                 }
 786
 787                 pFLAC__stream_decoder_finish(flacFile);
 788             }
 789             pFLAC__stream_decoder_delete(flacFile);
 790             flacFile = NULL;
 791         }
 792     }
 793
 794     virtual ~flacStream()
 795     {
 796         if(flacFile)
 797         {
 798             pFLAC__stream_decoder_finish(flacFile);
 799             pFLAC__stream_decoder_delete(flacFile);
 800             flacFile = NULL;
 801         }
 802     }
 803
 804 private:
 805     bool InitFlac()
 806     {
 807         // We need to decode some data to be able to get the channel count, bit
 808         // depth, and sample rate. It also ensures the file has FLAC data, as
 809         // the FLAC__stream_decoder_init_* functions can succeed on non-FLAC
 810         // Ogg files.
 811         outLen = 0;
 812         outTotal = 0;
 813         while(initialData.size() == 0)
 814         {
 815             if(pFLAC__stream_decoder_process_single(flacFile) == false ||
 816                pFLAC__stream_decoder_get_state(flacFile) == FLAC__STREAM_DECODER_END_OF_STREAM)
 817                 break;
 818         }
 819
 820         if(initialData.size() > 0)
 821             return true;
 822         return false;
 823     }
 824
 825     static FLAC__StreamDecoderWriteStatus WriteCallback(const FLAC__StreamDecoder*, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data)
 826     {
 827         flacStream *self = static_cast<flacStream*>(client_data);
 828         ALubyte *data = self->outBytes + self->outTotal;
 829         ALuint i = 0;
 830
 831         if(self->format == AL_NONE)
 832         {
 833             ALuint bps = frame->header.bits_per_sample;
 834             if(bps == 24 || bps == 32)
 835             {
 836                 self->format = GetSampleFormat(frame->header.channels, 32, true);
 837                 if(self->format != AL_NONE)
 838                 {
 839                     self->useFloat = AL_TRUE;
 840                     bps = 32;
 841                 }
 842                 else bps = 16;
 843             }
 844             if(self->format == AL_NONE)
 845                 self->format = GetSampleFormat(frame->header.channels, bps, false);
 846             self->blockAlign = frame->header.channels * bps/8;
 847             self->samplerate = frame->header.sample_rate;
 848         }
 849
 850         const ALboolean useFloat = self->useFloat;
 851         while(self->outTotal < self->outLen && i < frame->header.blocksize)
 852         {
 853             for(ALuint c = 0;c < frame->header.channels;c++)
 854             {
 855                 if(frame->header.bits_per_sample == 8)
 856                     ((ALubyte*)data)[c] = buffer[c][i]+128;
 857                 else if(frame->header.bits_per_sample == 16)
 858                     ((ALshort*)data)[c] = buffer[c][i];
 859                 else if(frame->header.bits_per_sample == 24)
 860                 {
 861                     if(useFloat)
 862                         ((ALfloat*)data)[c] = ((buffer[c][i]>=0) ?
 863                                                buffer[c][i]/(float)0x7FFFFF :
 864                                                buffer[c][i]/(float)0x800000);
 865                     else
 866                         ((ALshort*)data)[c] = buffer[c][i]>>8;
 867                 }
 868                 else if(frame->header.bits_per_sample == 32)
 869                 {
 870                     if(useFloat)
 871                         ((ALfloat*)data)[c] = ((buffer[c][i]>=0) ?
 872                                                buffer[c][i]/(float)0x7FFFFFFF :
 873                                                buffer[c][i]/(float)0x80000000u);
 874                     else
 875                         ((ALshort*)data)[c] = buffer[c][i]>>16;
 876                 }
 877             }
 878             self->outTotal += self->blockAlign;
 879             data += self->blockAlign;
 880             i++;
 881         }
 882
 883         if(i < frame->header.blocksize)
 884         {
 885             ALuint blocklen = (frame->header.blocksize-i) *
 886                               self->blockAlign;
 887             ALuint start = self->initialData.size();
 888
 889             self->initialData.resize(start+blocklen);
 890             data = &self->initialData[start];
 891
 892             do {
 893                 for(ALuint c = 0;c < frame->header.channels;c++)
 894                 {
 895                     if(frame->header.bits_per_sample == 8)
 896                         ((ALubyte*)data)[c] = buffer[c][i]+128;
 897                     else if(frame->header.bits_per_sample == 16)
 898                         ((ALshort*)data)[c] = buffer[c][i];
 899                     else if(frame->header.bits_per_sample == 24)
 900                     {
 901                         if(useFloat)
 902                             ((ALfloat*)data)[c] = ((buffer[c][i]>=0) ?
 903                                                    buffer[c][i]/(float)0x7FFFFF :
 904                                                    buffer[c][i]/(float)0x800000);
 905                         else
 906                             ((ALshort*)data)[c] = buffer[c][i]>>8;
 907                     }
 908                     else if(frame->header.bits_per_sample == 32)
 909                     {
 910                         if(useFloat)
 911                             ((ALfloat*)data)[c] = ((buffer[c][i]>=0) ?
 912                                                    buffer[c][i]/(float)0x7FFFFFFF :
 913                                                    buffer[c][i]/(float)0x80000000u);
 914                         else
 915                             ((ALshort*)data)[c] = buffer[c][i]>>16;
 916                     }
 917                 }
 918                 data += self->blockAlign;
 919                 i++;
 920             } while(i < frame->header.blocksize);
 921         }
 922
 923         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 924     }
 925     static void MetadataCallback(const FLAC__StreamDecoder*,const FLAC__StreamMetadata*,void*)
 926     {
 927     }
 928     static void ErrorCallback(const FLAC__StreamDecoder*,FLAC__StreamDecoderErrorStatus,void*)
 929     {
 930     }
 931
 932     static FLAC__StreamDecoderReadStatus ReadCallback(const FLAC__StreamDecoder*, FLAC__byte buffer[], size_t *bytes, void *client_data)
 933     {
 934         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 935         stream->clear();
 936
 937         if(*bytes <= 0)
 938             return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 939
 940         stream->read(reinterpret_cast<char*>(buffer), *bytes);
 941         *bytes = stream->gcount();
 942         if(*bytes == 0 && stream->eof())
 943             return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 944
 945         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 946     }
 947     static FLAC__StreamDecoderSeekStatus SeekCallback(const FLAC__StreamDecoder*, FLAC__uint64 absolute_byte_offset, void *client_data)
 948     {
 949         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 950         stream->clear();
 951
 952         if(!stream->seekg(absolute_byte_offset))
 953             return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 954         return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
 955     }
 956     static FLAC__StreamDecoderTellStatus TellCallback(const FLAC__StreamDecoder*, FLAC__uint64 *absolute_byte_offset, void *client_data)
 957     {
 958         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 959         stream->clear();
 960
 961         *absolute_byte_offset = stream->tellg();
 962         return FLAC__STREAM_DECODER_TELL_STATUS_OK;
 963     }
 964     static FLAC__StreamDecoderLengthStatus LengthCallback(const FLAC__StreamDecoder*, FLAC__uint64 *stream_length, void *client_data)
 965     {
 966         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 967         stream->clear();
 968
 969         std::streampos pos = stream->tellg();
 970         if(stream->seekg(0, std::ios_base::end))
 971         {
 972             *stream_length = stream->tellg();
 973             stream->seekg(pos);
 974         }
 975
 976         if(!stream->good())
 977             return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
 978         return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
 979     }
 980     static FLAC__bool EofCallback(const FLAC__StreamDecoder*, void *client_data)
 981     {
 982         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 983         return (stream->eof()) ? true : false;
 984     }
 985 };
 986 #else
 987 struct flacStream : public nullStream {
 988     flacStream(std::istream*){}
 989 };
 990 #endif
 991
 992
 993 #ifdef HAS_MPG123
 994 struct mp3Stream : public alureStream {
 995     mpg123_handle *mp3File;
 996     long samplerate;
 997     int channels;
 998     ALenum format;
 999
1000     virtual bool IsValid()
1001     { return mp3File != NULL; }
1002
1003     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
1004     {
1005         *fmt = format;
1006         *frequency = samplerate;
1007         *blockalign = channels*2;
1008         return true;
1009     }
1010
1011     virtual ALuint GetData(ALubyte *data, ALuint bytes)
1012     {
1013         ALuint amt = 0;
1014         while(bytes > 0)
1015         {
1016             size_t got = 0;
1017             int ret = pmpg123_read(mp3File, data, bytes, &got);
1018
1019             bytes -= got;
1020             data += got;
1021             amt += got;
1022
1023             if(ret == MPG123_NEW_FORMAT)
1024             {
1025                 long newrate;
1026                 int newchans, enc;
1027                 pmpg123_getformat(mp3File, &newrate, &newchans, &enc);
1028                 continue;
1029             }
1030             if(ret == MPG123_NEED_MORE)
1031             {
1032                 unsigned char data[4096];
1033                 fstream->read((char*)data, sizeof(data));
1034                 std::streamsize insize = fstream->gcount();
1035                 if(insize > 0 && pmpg123_feed(mp3File, data, insize) == MPG123_OK)
1036                     continue;
1037             }
1038             if(got == 0)
1039                 break;
1040         }
1041         return amt;
1042     }
1043
1044     virtual bool Rewind()
1045     {
1046         fstream->clear();
1047         std::istream::pos_type oldpos = fstream->tellg();
1048         fstream->seekg(0);
1049
1050         mpg123_handle *newFile = pmpg123_new(NULL, NULL);
1051         if(pmpg123_open_feed(newFile) == MPG123_OK)
1052         {
1053             unsigned char data[4096];
1054             long newrate;
1055             int newchans;
1056             int ret, enc;
1057
1058             ALuint amt, total = 0;
1059             do {
1060                 fstream->read((char*)data, sizeof(data));
1061                 amt = fstream->gcount();
1062                 if(amt == 0)  break;
1063                 total += amt;
1064                 ret = pmpg123_decode(newFile, data, amt, NULL, 0, NULL);
1065             } while(ret == MPG123_NEED_MORE && total < 64*1024);
1066
1067             if(ret == MPG123_NEW_FORMAT &&
1068                pmpg123_getformat(newFile, &newrate, &newchans, &enc) == MPG123_OK)
1069             {
1070                 if(pmpg123_format_none(newFile) == MPG123_OK &&
1071                    pmpg123_format(newFile, samplerate, channels, MPG123_ENC_SIGNED_16) == MPG123_OK)
1072                 {
1073                     // All OK
1074                     pmpg123_delete(mp3File);
1075                     mp3File = newFile;
1076                     return true;
1077                 }
1078             }
1079             pmpg123_delete(newFile);
1080         }
1081
1082         fstream->seekg(oldpos);
1083         SetError("Restart failed");
1084         return false;
1085     }
1086
1087     mp3Stream(std::istream *_fstream)
1088       : alureStream(_fstream), mp3File(NULL), format(AL_NONE)
1089     {
1090         if(!mp123_handle) return;
1091
1092         mp3File = pmpg123_new(NULL, NULL);
1093         if(pmpg123_open_feed(mp3File) == MPG123_OK)
1094         {
1095             unsigned char data[4096];
1096             int ret, enc;
1097
1098             ALuint amt, total = 0;
1099             do {
1100                 fstream->read((char*)data, sizeof(data));
1101                 amt = fstream->gcount();
1102                 if(amt == 0)  break;
1103                 total += amt;
1104                 ret = pmpg123_decode(mp3File, data, amt, NULL, 0, NULL);
1105             } while(ret == MPG123_NEED_MORE && total < 64*1024);
1106
1107             if(ret == MPG123_NEW_FORMAT &&
1108                pmpg123_getformat(mp3File, &samplerate, &channels, &enc) == MPG123_OK)
1109             {
1110                 format = GetSampleFormat(channels, 16, false);
1111                 if(pmpg123_format_none(mp3File) == MPG123_OK &&
1112                    pmpg123_format(mp3File, samplerate, channels, MPG123_ENC_SIGNED_16) == MPG123_OK)
1113                 {
1114                     // All OK
1115                     return;
1116                 }
1117             }
1118         }
1119         pmpg123_delete(mp3File);
1120         mp3File = NULL;
1121     }
1122
1123     virtual ~mp3Stream()
1124     {
1125         if(mp3File)
1126             pmpg123_delete(mp3File);
1127         mp3File = NULL;
1128     }
1129 };
1130 #else
1131 struct mp3Stream : public nullStream {
1132     mp3Stream(std::istream*){}
1133 };
1134 #endif
1135
1136
1137 #ifdef HAS_DUMB
1138 struct dumbStream : public alureStream {
1139     DUMBFILE_SYSTEM vfs;
1140     DUMBFILE *dumbFile;
1141     DUH *duh;
1142     DUH_SIGRENDERER *renderer;
1143     std::vector<sample_t> sampleBuf;
1144     ALuint lastOrder;
1145     ALenum format;
1146     ALCint samplerate;
1147
1148     virtual bool IsValid()
1149     { return renderer != NULL; }
1150
1151     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
1152     {
1153         if(format == AL_NONE)
1154         {
1155             format = GetSampleFormat(2, 32, true);
1156             if(format == AL_NONE)
1157                 format = AL_FORMAT_STEREO16;
1158         }
1159         *fmt = format;
1160         *frequency = samplerate;
1161         *blockalign = 2 * ((format==AL_FORMAT_STEREO16) ? sizeof(ALshort) :
1162                                                           sizeof(ALfloat));
1163         return true;
1164     }
1165
1166     virtual ALuint GetData(ALubyte *data, ALuint bytes)
1167     {
1168         ALuint ret = 0;
1169
1170         if(pdumb_it_sr_get_speed(pduh_get_it_sigrenderer(renderer)) == 0)
1171             return 0;
1172
1173         ALuint sample_count = bytes / ((format==AL_FORMAT_STEREO16) ?
1174                                        sizeof(ALshort) : sizeof(ALfloat));
1175
1176         sampleBuf.resize(sample_count);
1177         sample_t *samples[] = {
1178             &sampleBuf[0]
1179         };
1180
1181         pdumb_silence(samples[0], sample_count);
1182         ret = pduh_sigrenderer_generate_samples(renderer, 1.0f, 65536.0f/samplerate, sample_count/2, samples);
1183         ret *= 2;
1184         if(format == AL_FORMAT_STEREO16)
1185         {
1186             for(ALuint i = 0;i < ret;i++)
1187                 ((ALshort*)data)[i] = clamp(samples[0][i]>>8, -32768, 32767);
1188         }
1189         else
1190         {
1191             for(ALuint i = 0;i < ret;i++)
1192                 ((ALfloat*)data)[i] = ((samples[0][i]>=0) ?
1193                                        samples[0][i]/(float)0x7FFFFF :
1194                                        samples[0][i]/(float)0x800000);
1195         }
1196         ret *= ((format==AL_FORMAT_STEREO16) ? sizeof(ALshort) : sizeof(ALfloat));
1197
1198         return ret;
1199     }
1200
1201     virtual bool Rewind()
1202     {
1203         DUH_SIGRENDERER *newrenderer = pdumb_it_start_at_order(duh, 2, lastOrder);
1204         if(!newrenderer)
1205         {
1206             SetError("Could start renderer");
1207             return false;
1208         }
1209         pduh_end_sigrenderer(renderer);
1210         renderer = newrenderer;
1211         return true;
1212     }
1213
1214     virtual bool SetOrder(ALuint order)
1215     {
1216         DUH_SIGRENDERER *newrenderer = pdumb_it_start_at_order(duh, 2, order);
1217         if(!newrenderer)
1218         {
1219             SetError("Could not set order");
1220             return false;
1221         }
1222         pduh_end_sigrenderer(renderer);
1223         renderer = newrenderer;
1224
1225         lastOrder = order;
1226         return true;
1227     }
1228
1229     dumbStream(std::istream *_fstream)
1230       : alureStream(_fstream), dumbFile(NULL), duh(NULL), renderer(NULL),
1231         lastOrder(0), format(AL_NONE), samplerate(48000)
1232     {
1233         if(!dumb_handle) return;
1234
1235         ALCdevice *device = alcGetContextsDevice(alcGetCurrentContext());
1236         if(device)
1237             alcGetIntegerv(device, ALC_FREQUENCY, 1, &samplerate);
1238
1239         DUH* (*funcs[])(DUMBFILE*) = {
1240             pdumb_read_it,
1241             pdumb_read_xm,
1242             pdumb_read_s3m,
1243             pdumb_read_mod,
1244             NULL
1245         };
1246
1247         vfs.open = NULL;
1248         vfs.skip = skip;
1249         vfs.getc = read_char;
1250         vfs.getnc = read;
1251         vfs.close = NULL;
1252
1253         for(size_t i = 0;funcs[i];i++)
1254         {
1255             dumbFile = pdumbfile_open_ex(this, &vfs);
1256             if(dumbFile)
1257             {
1258                 duh = funcs[i](dumbFile);
1259                 if(duh)
1260                 {
1261                     renderer = pdumb_it_start_at_order(duh, 2, lastOrder);
1262                     if(renderer)
1263                     {
1264                         pdumb_it_set_loop_callback(pduh_get_it_sigrenderer(renderer), loop_cb, this);
1265                         break;
1266                     }
1267
1268                     punload_duh(duh);
1269                     duh = NULL;
1270                 }
1271
1272                 pdumbfile_close(dumbFile);
1273                 dumbFile = NULL;
1274             }
1275             fstream->clear();
1276             fstream->seekg(0);
1277         }
1278     }
1279
1280     virtual ~dumbStream()
1281     {
1282         if(renderer)
1283             pduh_end_sigrenderer(renderer);
1284         renderer = NULL;
1285
1286         if(duh)
1287             punload_duh(duh);
1288         duh = NULL;
1289
1290         if(dumbFile)
1291             pdumbfile_close(dumbFile);
1292         dumbFile = NULL;
1293     }
1294
1295 private:
1296     // DUMBFILE iostream callbacks
1297     static int skip(void *user_data, long offset)
1298     {
1299         std::istream *stream = static_cast<dumbStream*>(user_data)->fstream;
1300         stream->clear();
1301
1302         if(stream->seekg(offset, std::ios_base::cur))
1303             return 0;
1304         return -1;
1305     }
1306
1307     static long read(char *ptr, long size, void *user_data)
1308     {
1309         std::istream *stream = static_cast<dumbStream*>(user_data)->fstream;
1310         stream->clear();
1311
1312         stream->read(ptr, size);
1313         return stream->gcount();
1314     }
1315
1316     static int read_char(void *user_data)
1317     {
1318         std::istream *stream = static_cast<dumbStream*>(user_data)->fstream;
1319         stream->clear();
1320
1321         unsigned char ret;
1322         stream->read(reinterpret_cast<char*>(&ret), 1);
1323         if(stream->gcount() > 0)
1324             return ret;
1325         return -1;
1326     }
1327
1328     static int loop_cb(void *user_data)
1329     {
1330         dumbStream *self = static_cast<dumbStream*>(user_data);
1331         pdumb_it_sr_set_speed(pduh_get_it_sigrenderer(self->renderer), 0);
1332         return 0;
1333     }
1334 };
1335 #else
1336 struct dumbStream : public nullStream {
1337     dumbStream(std::istream*){}
1338 };
1339 #endif
1340
1341
1342 template <typename T>
1343 alureStream *get_stream_decoder(const T &fdata)
1344 {
1345     alureStream *stream;
1346
1347     std::map<ALint,UserCallbacks>::iterator i = InstalledCallbacks.begin();
1348     while(i != InstalledCallbacks.end() && i->first < 0)
1349     {
1350         stream = new customStream(fdata, i->second);
1351         if(stream->IsValid())
1352             return stream;
1353         delete stream;
1354         i++;
1355     }
1356
1357     std::istream *file = new InStream(fdata);
1358     if(!file->fail())
1359     {
1360         stream = new wavStream(file);
1361         if(stream->IsValid())
1362             return stream;
1363         delete stream;
1364
1365         file->clear();
1366         file->seekg(0, std::ios_base::beg);
1367         stream = new aiffStream(file);
1368         if(stream->IsValid())
1369             return stream;
1370         delete stream;
1371
1372         // Try libVorbisFile
1373         file->clear();
1374         file->seekg(0, std::ios_base::beg);
1375         stream = new oggStream(file);
1376         if(stream->IsValid())
1377             return stream;
1378         delete stream;
1379
1380         // Try libFLAC
1381         file->clear();
1382         file->seekg(0, std::ios_base::beg);
1383         stream = new flacStream(file);
1384         if(stream->IsValid())
1385             return stream;
1386         delete stream;
1387
1388         // Try DUMB
1389         file->clear();
1390         file->seekg(0, std::ios_base::beg);
1391         stream = new dumbStream(file);
1392         if(stream->IsValid())
1393             return stream;
1394         delete stream;
1395
1396         // Try libSndFile
1397         file->clear();
1398         file->seekg(0, std::ios_base::beg);
1399         stream = new sndStream(file);
1400         if(stream->IsValid())
1401             return stream;
1402         delete stream;
1403
1404         // Try MPG123
1405         file->clear();
1406         file->seekg(0, std::ios_base::beg);
1407         stream = new mp3Stream(file);
1408         if(stream->IsValid())
1409             return stream;
1410         delete stream;
1411
1412         SetError("Unsupported type");
1413         delete file;
1414     }
1415     else
1416     {
1417         SetError("Failed to open file");
1418         delete file;
1419     }
1420
1421     while(i != InstalledCallbacks.end())
1422     {
1423         stream = new customStream(fdata, i->second);
1424         if(stream->IsValid())
1425             return stream;
1426         delete stream;
1427         i++;
1428     }
1429
1430     return new nullStream;
1431 }
1432
1433 alureStream *create_stream(const char *fname)
1434 { return get_stream_decoder(fname); }
1435 alureStream *create_stream(const MemDataInfo &memData)
1436 { return get_stream_decoder(memData); }
1437
1438 alureStream *create_stream(ALvoid *userdata, ALenum format, ALuint rate, const UserCallbacks &cb)
1439 { return new customStream(userdata, format, rate, cb); }