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 struct Decoder {
  41     typedef std::auto_ptr<alureStream>(*FactoryType)(std::istream*);
  42     typedef std::vector<FactoryType> ListType;
  43
  44     static const ListType& GetList()
  45     { return AddList(NULL); }
  46
  47 protected:
  48     template<typename T>
  49     static std::auto_ptr<alureStream> Factory(std::istream *file)
  50     {
  51         std::auto_ptr<alureStream> ret(new T(file));
  52         if(ret->IsValid()) return ret;
  53         return std::auto_ptr<alureStream>();
  54     }
  55
  56     static const ListType& AddList(FactoryType func)
  57     {
  58         static ListType FuncList;
  59         if(func) FuncList.push_back(func);
  60         return FuncList;
  61     }
  62 };
  63 template<typename T>
  64 struct DecoderDecl : public Decoder {
  65     DecoderDecl() { AddList(Factory<T>); }
  66 };
  67
  68
  69 static inline ALuint read_le32(std::istream *file)
  70 {
  71     ALubyte buffer[4];
  72     if(!file->read(reinterpret_cast<char*>(buffer), 4)) return 0;
  73     return buffer[0] | (buffer[1]<<8) | (buffer[2]<<16) | (buffer[3]<<24);
  74 }
  75
  76 static inline ALushort read_le16(std::istream *file)
  77 {
  78     ALubyte buffer[2];
  79     if(!file->read(reinterpret_cast<char*>(buffer), 2)) return 0;
  80     return buffer[0] | (buffer[1]<<8);
  81 }
  82
  83 static inline ALuint read_be32(std::istream *file)
  84 {
  85     ALubyte buffer[4];
  86     if(!file->read(reinterpret_cast<char*>(buffer), 4)) return 0;
  87     return (buffer[0]<<24) | (buffer[1]<<16) | (buffer[2]<<8) | buffer[3];
  88 }
  89
  90 static inline ALushort read_be16(std::istream *file)
  91 {
  92     ALubyte buffer[2];
  93     if(!file->read(reinterpret_cast<char*>(buffer), 2)) return 0;
  94     return (buffer[0]<<8) | buffer[1];
  95 }
  96
  97 static inline ALuint read_be80extended(std::istream *file)
  98 {
  99     ALubyte buffer[10];
 100     if(!file->read(reinterpret_cast<char*>(buffer), 10)) return 0;
 101     ALuint mantissa, last = 0;
 102     ALubyte exp = buffer[1];
 103     exp = 30 - exp;
 104     mantissa = (buffer[2]<<24) | (buffer[3]<<16) | (buffer[4]<<8) | buffer[5];
 105     while (exp--)
 106     {
 107         last = mantissa;
 108         mantissa >>= 1;
 109     }
 110     if((last&1)) mantissa++;
 111     return mantissa;
 112 }
 113
 114
 115 struct nullStream : public alureStream {
 116     virtual bool IsValid() { return false; }
 117     virtual bool GetFormat(ALenum*,ALuint*,ALuint*) { return false; }
 118     virtual ALuint GetData(ALubyte*,ALuint) { return 0; }
 119     virtual bool Rewind() { return false; }
 120     nullStream():alureStream(NULL) {}
 121 };
 122
 123
 124 struct customStream : public alureStream {
 125     void *usrFile;
 126     ALenum format;
 127     ALuint samplerate;
 128     ALuint blockAlign;
 129     MemDataInfo memInfo;
 130
 131     UserCallbacks cb;
 132
 133     virtual bool IsValid()
 134     { return usrFile != NULL; }
 135
 136     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 137     {
 138         if(format == AL_NONE)
 139         {
 140             if(!cb.get_fmt || !cb.get_fmt(usrFile, &format, &samplerate, &blockAlign))
 141                 return false;
 142         }
 143         if(DetectBlockAlignment(format) != blockAlign)
 144             blockAlign = 0;
 145
 146         *fmt = format;
 147         *frequency = samplerate;
 148         *blockalign = blockAlign;
 149         return true;
 150     }
 151
 152     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 153     { return cb.decode(usrFile, data, bytes); }
 154
 155     virtual bool Rewind()
 156     {
 157         if(cb.rewind && cb.rewind(usrFile))
 158             return true;
 159         SetError("Rewind failed");
 160         return false;
 161     }
 162
 163     customStream(const char *fname, const UserCallbacks &callbacks)
 164       : alureStream(NULL), usrFile(NULL), format(0), samplerate(0),
 165         blockAlign(0), cb(callbacks)
 166     { if(cb.open_file) usrFile = cb.open_file(fname); }
 167
 168     customStream(const MemDataInfo &memData, const UserCallbacks &callbacks)
 169       : alureStream(NULL), usrFile(NULL), format(0), samplerate(0),
 170         blockAlign(0), memInfo(memData), cb(callbacks)
 171     { if(cb.open_mem) usrFile = cb.open_mem(memInfo.Data, memInfo.Length); }
 172
 173     customStream(void *userdata, ALenum fmt, ALuint srate, const UserCallbacks &callbacks)
 174       : alureStream(NULL), usrFile(userdata), format(fmt), samplerate(srate),
 175         blockAlign(DetectBlockAlignment(format)), cb(callbacks)
 176     { }
 177
 178     virtual ~customStream()
 179     {
 180         if(cb.close && usrFile)
 181             cb.close(usrFile);
 182         usrFile = NULL;
 183     }
 184 };
 185
 186
 187 struct wavStream : public alureStream {
 188     ALenum format;
 189     int samplerate;
 190     int blockAlign;
 191     int sampleSize;
 192     long dataStart;
 193     long dataLen;
 194     size_t remLen;
 195
 196     virtual bool IsValid()
 197     { return (dataStart > 0 && format != AL_NONE); }
 198
 199     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 200     {
 201         *fmt = format;
 202         *frequency = samplerate;
 203         *blockalign = blockAlign;
 204         return true;
 205     }
 206
 207     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 208     {
 209         std::streamsize rem = ((remLen >= bytes) ? bytes : remLen) / blockAlign;
 210         fstream->read(reinterpret_cast<char*>(data), rem*blockAlign);
 211
 212         std::streamsize got = fstream->gcount();
 213         got -= got%blockAlign;
 214         remLen -= got;
 215
 216         if(BigEndian && sampleSize == 16)
 217         {
 218             for(std::streamsize i = 0;i < got;i+=2)
 219                 swap(data[i], data[i+1]);
 220         }
 221         else if(BigEndian && sampleSize == 32)
 222         {
 223             for(std::streamsize i = 0;i < got;i+=4)
 224             {
 225                 swap(data[i+0], data[i+3]);
 226                 swap(data[i+1], data[i+2]);
 227             }
 228         }
 229         else if(BigEndian && sampleSize == 64)
 230         {
 231             for(std::streamsize i = 0;i < got;i+=8)
 232             {
 233                 swap(data[i+0], data[i+7]);
 234                 swap(data[i+1], data[i+6]);
 235                 swap(data[i+2], data[i+5]);
 236                 swap(data[i+3], data[i+4]);
 237             }
 238         }
 239
 240         return got;
 241     }
 242
 243     virtual bool Rewind()
 244     {
 245         fstream->clear();
 246         if(fstream->seekg(dataStart))
 247         {
 248             remLen = dataLen;
 249             return true;
 250         }
 251
 252         SetError("Seek failed");
 253         return false;
 254     }
 255
 256     wavStream(std::istream *_fstream)
 257       : alureStream(_fstream), format(0), dataStart(0)
 258     {
 259         ALubyte buffer[25];
 260         int length;
 261
 262         if(!fstream->read(reinterpret_cast<char*>(buffer), 12) ||
 263            memcmp(buffer, "RIFF", 4) != 0 || memcmp(buffer+8, "WAVE", 4) != 0)
 264             return;
 265
 266         while(!dataStart || format == AL_NONE)
 267         {
 268             char tag[4];
 269             if(!fstream->read(tag, 4))
 270                 break;
 271
 272             /* read chunk length */
 273             length = read_le32(fstream);
 274
 275             if(memcmp(tag, "fmt ", 4) == 0 && length >= 16)
 276             {
 277                 /* Data type (should be 1 for PCM data, 3 for float PCM data,
 278                  * and 17 for IMA4 data) */
 279                 int type = read_le16(fstream);
 280                 if(type != 0x0001 && type != 0x0003 && type != 0x0011)
 281                     break;
 282
 283                 /* mono or stereo data */
 284                 int channels = read_le16(fstream);
 285
 286                 /* sample frequency */
 287                 samplerate = read_le32(fstream);
 288
 289                 /* skip average bytes per second */
 290                 fstream->ignore(4);
 291
 292                 /* bytes per block */
 293                 blockAlign = read_le16(fstream);
 294                 if(blockAlign == 0)
 295                     break;
 296
 297                 /* bits per sample */
 298                 sampleSize = read_le16(fstream);
 299
 300                 length -= 16;
 301
 302                 /* Look for any extra data and try to find the format */
 303                 int extrabytes = 0;
 304                 if(length >= 2)
 305                 {
 306                     extrabytes = read_le16(fstream);
 307                     length -= 2;
 308                 }
 309                 extrabytes = std::min(extrabytes, length);
 310
 311                 if(type == 0x0001)
 312                     format = GetSampleFormat(channels, sampleSize, false);
 313                 else if(type == 0x0003)
 314                     format = GetSampleFormat(channels, sampleSize, true);
 315                 else if(type == 0x0011 && extrabytes >= 2)
 316                 {
 317                     int samples = read_le16(fstream);
 318                     length -= 2;
 319
 320                     /* AL_EXT_IMA4 only supports 36 bytes-per-channel block
 321                      * alignment, which has 65 uncompressed sample frames */
 322                     if(blockAlign == 36*channels && samples == 65*channels &&
 323                        alIsExtensionPresent("AL_EXT_IMA4"))
 324                     {
 325                          if(channels == 1)
 326                              format = AL_FORMAT_MONO_IMA4;
 327                          else if(channels == 2)
 328                              format = AL_FORMAT_STEREO_IMA4;
 329                     }
 330                 }
 331             }
 332             else if(memcmp(tag, "data", 4) == 0)
 333             {
 334                 dataStart = fstream->tellg();
 335                 dataLen = remLen = length;
 336             }
 337
 338             fstream->seekg(length, std::ios_base::cur);
 339         }
 340
 341         if(dataStart > 0 && format != AL_NONE)
 342             fstream->seekg(dataStart);
 343     }
 344
 345     virtual ~wavStream()
 346     { }
 347 };
 348 static DecoderDecl<wavStream> wavStream_decoder;
 349
 350
 351 struct aiffStream : public alureStream {
 352     ALenum format;
 353     int samplerate;
 354     int blockAlign;
 355     int sampleSize;
 356     long dataStart;
 357     long dataLen;
 358     size_t remLen;
 359
 360     virtual bool IsValid()
 361     { return (dataStart > 0 && format != AL_NONE); }
 362
 363     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 364     {
 365         *fmt = format;
 366         *frequency = samplerate;
 367         *blockalign = blockAlign;
 368         return true;
 369     }
 370
 371     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 372     {
 373         std::streamsize rem = ((remLen >= bytes) ? bytes : remLen) / blockAlign;
 374         fstream->read(reinterpret_cast<char*>(data), rem*blockAlign);
 375
 376         std::streamsize got = fstream->gcount();
 377         got -= got%blockAlign;
 378         remLen -= got;
 379
 380         if(LittleEndian)
 381         {
 382             if(sampleSize == 2)
 383             {
 384                 for(std::streamsize i = 0;i < got;i+=2)
 385                     swap(data[i], data[i+1]);
 386             }
 387             else if(sampleSize == 4)
 388             {
 389                 for(std::streamsize i = 0;i < got;i+=4)
 390                 {
 391                     swap(data[i+0], data[i+3]);
 392                     swap(data[i+1], data[i+2]);
 393                 }
 394             }
 395         }
 396
 397         return got;
 398     }
 399
 400     virtual bool Rewind()
 401     {
 402         fstream->clear();
 403         if(fstream->seekg(dataStart))
 404         {
 405             remLen = dataLen;
 406             return true;
 407         }
 408
 409         SetError("Seek failed");
 410         return false;
 411     }
 412
 413     aiffStream(std::istream *_fstream)
 414       : alureStream(_fstream), format(0), dataStart(0)
 415     {
 416         ALubyte buffer[25];
 417         int length;
 418
 419         if(!fstream->read(reinterpret_cast<char*>(buffer), 12) ||
 420            memcmp(buffer, "FORM", 4) != 0 || memcmp(buffer+8, "AIFF", 4) != 0)
 421             return;
 422
 423         while(!dataStart || format == AL_NONE)
 424         {
 425             char tag[4];
 426             if(!fstream->read(tag, 4))
 427                 break;
 428
 429             /* read chunk length */
 430             length = read_be32(fstream);
 431
 432             if(memcmp(tag, "COMM", 4) == 0 && length >= 18)
 433             {
 434                 /* mono or stereo data */
 435                 int channels = read_be16(fstream);
 436
 437                 /* number of sample frames */
 438                 fstream->ignore(4);
 439
 440                 /* bits per sample */
 441                 sampleSize = read_be16(fstream) / 8;
 442
 443                 /* sample frequency */
 444                 samplerate = read_be80extended(fstream);
 445
 446                 /* block alignment */
 447                 blockAlign = channels * sampleSize;
 448
 449                 format = GetSampleFormat(channels, sampleSize*8, false);
 450
 451                 length -= 18;
 452             }
 453             else if(memcmp(tag, "SSND", 4) == 0)
 454             {
 455                 dataStart = fstream->tellg();
 456                 dataStart += 8;
 457                 dataLen = remLen = length - 8;
 458             }
 459
 460             fstream->seekg(length, std::ios_base::cur);
 461         }
 462
 463         if(dataStart > 0 && format != AL_NONE)
 464             fstream->seekg(dataStart);
 465     }
 466
 467     virtual ~aiffStream()
 468     { }
 469 };
 470 static DecoderDecl<aiffStream> aiffStream_decoder;
 471
 472 #ifdef HAS_VORBISFILE
 473 struct oggStream : public alureStream {
 474     OggVorbis_File oggFile;
 475     vorbis_info *oggInfo;
 476     int oggBitstream;
 477     ALenum format;
 478
 479     virtual bool IsValid()
 480     { return oggInfo != NULL; }
 481
 482     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 483     {
 484         if(format == AL_NONE)
 485             format = GetSampleFormat(oggInfo->channels, 16, false);
 486         *fmt = format;
 487         *frequency = oggInfo->rate;
 488         *blockalign = oggInfo->channels*2;
 489         return true;
 490     }
 491
 492     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 493     {
 494         ALuint got = 0;
 495         while(bytes > 0)
 496         {
 497             int res = pov_read(&oggFile, (char*)&data[got], bytes, BigEndian?1:0, 2, 1, &oggBitstream);
 498             if(res <= 0)
 499                 break;
 500             bytes -= res;
 501             got += res;
 502         }
 503         // 1, 2, and 4 channel files decode into the same channel order as
 504         // OpenAL, however 6(5.1), 7(6.1), and 8(7.1) channel files need to be
 505         // re-ordered
 506         if(oggInfo->channels == 6)
 507         {
 508             ALshort *samples = (ALshort*)data;
 509             for(ALuint i = 0;i < got/sizeof(ALshort);i+=6)
 510             {
 511                 // OpenAL : FL, FR, FC, LFE, RL, RR
 512                 // Vorbis : FL, FC, FR,  RL, RR, LFE
 513                 swap(samples[i+1], samples[i+2]);
 514                 swap(samples[i+3], samples[i+5]);
 515                 swap(samples[i+4], samples[i+5]);
 516             }
 517         }
 518         else if(oggInfo->channels == 7)
 519         {
 520             ALshort *samples = (ALshort*)data;
 521             for(ALuint i = 0;i < got/sizeof(ALshort);i+=7)
 522             {
 523                 // OpenAL : FL, FR, FC, LFE, RC, SL, SR
 524                 // Vorbis : FL, FC, FR,  SL, SR, RC, LFE
 525                 swap(samples[i+1], samples[i+2]);
 526                 swap(samples[i+3], samples[i+6]);
 527                 swap(samples[i+4], samples[i+6]);
 528                 swap(samples[i+5], samples[i+6]);
 529             }
 530         }
 531         else if(oggInfo->channels == 8)
 532         {
 533             ALshort *samples = (ALshort*)data;
 534             for(ALuint i = 0;i < got/sizeof(ALshort);i+=8)
 535             {
 536                 // OpenAL : FL, FR, FC, LFE, RL, RR, SL, SR
 537                 // Vorbis : FL, FC, FR,  SL, SR, RL, RR, LFE
 538                 swap(samples[i+1], samples[i+2]);
 539                 swap(samples[i+3], samples[i+7]);
 540                 swap(samples[i+4], samples[i+5]);
 541                 swap(samples[i+5], samples[i+6]);
 542                 swap(samples[i+6], samples[i+7]);
 543             }
 544         }
 545         return got;
 546     }
 547
 548     virtual bool Rewind()
 549     {
 550         if(pov_pcm_seek(&oggFile, 0) == 0)
 551             return true;
 552
 553         SetError("Seek failed");
 554         return false;
 555     }
 556
 557     oggStream(std::istream *_fstream)
 558       : alureStream(_fstream), oggInfo(NULL), oggBitstream(0), format(AL_NONE)
 559     {
 560         if(!vorbisfile_handle) return;
 561
 562         const ov_callbacks streamIO = {
 563             read, seek, close, tell
 564         };
 565
 566         if(pov_open_callbacks(this, &oggFile, NULL, 0, streamIO) == 0)
 567         {
 568             oggInfo = pov_info(&oggFile, -1);
 569             if(!oggInfo)
 570                 pov_clear(&oggFile);
 571         }
 572     }
 573
 574     virtual ~oggStream()
 575     {
 576         if(oggInfo)
 577             pov_clear(&oggFile);
 578         oggInfo = NULL;
 579     }
 580
 581 private:
 582     // libVorbisFile iostream callbacks
 583     static int seek(void *user_data, ogg_int64_t offset, int whence)
 584     {
 585         std::istream *stream = static_cast<oggStream*>(user_data)->fstream;
 586         stream->clear();
 587
 588         if(whence == SEEK_CUR)
 589             stream->seekg(offset, std::ios_base::cur);
 590         else if(whence == SEEK_SET)
 591             stream->seekg(offset, std::ios_base::beg);
 592         else if(whence == SEEK_END)
 593             stream->seekg(offset, std::ios_base::end);
 594         else
 595             return -1;
 596
 597         return stream->tellg();
 598     }
 599
 600     static size_t read(void *ptr, size_t size, size_t nmemb, void *user_data)
 601     {
 602         std::istream *stream = static_cast<oggStream*>(user_data)->fstream;
 603         stream->clear();
 604
 605         stream->read(static_cast<char*>(ptr), nmemb*size);
 606         size_t ret = stream->gcount();
 607         return ret/size;
 608     }
 609
 610     static long tell(void *user_data)
 611     {
 612         std::istream *stream = static_cast<oggStream*>(user_data)->fstream;
 613         stream->clear();
 614         return stream->tellg();
 615     }
 616
 617     static int close(void*)
 618     {
 619         return 0;
 620     }
 621 };
 622 static DecoderDecl<oggStream> oggStream_decoder;
 623 #endif
 624
 625 #ifdef HAS_FLAC
 626 struct flacStream : public alureStream {
 627     FLAC__StreamDecoder *flacFile;
 628     ALenum format;
 629     ALuint samplerate;
 630     ALuint blockAlign;
 631     ALboolean useFloat;
 632
 633     std::vector<ALubyte> initialData;
 634
 635     ALubyte *outBytes;
 636     ALuint outLen;
 637     ALuint outTotal;
 638
 639     virtual bool IsValid()
 640     { return flacFile != NULL; }
 641
 642     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 643     {
 644         *fmt = format;
 645         *frequency = samplerate;
 646         *blockalign = blockAlign;
 647         return true;
 648     }
 649
 650     virtual ALuint GetData(ALubyte *data, ALuint bytes)
 651     {
 652         outBytes = data;
 653         outTotal = 0;
 654         outLen = bytes;
 655
 656         if(initialData.size() > 0)
 657         {
 658             size_t rem = std::min(initialData.size(), (size_t)bytes);
 659             memcpy(data, &initialData[0], rem);
 660             outTotal += rem;
 661             initialData.erase(initialData.begin(), initialData.begin()+rem);
 662         }
 663
 664         while(outTotal < bytes)
 665         {
 666             if(pFLAC__stream_decoder_process_single(flacFile) == false ||
 667                pFLAC__stream_decoder_get_state(flacFile) == FLAC__STREAM_DECODER_END_OF_STREAM)
 668                 break;
 669         }
 670
 671         return outTotal;
 672     }
 673
 674     virtual bool Rewind()
 675     {
 676         if(pFLAC__stream_decoder_seek_absolute(flacFile, 0) != false)
 677         {
 678             initialData.clear();
 679             return true;
 680         }
 681
 682         SetError("Seek failed");
 683         return false;
 684     }
 685
 686     flacStream(std::istream *_fstream)
 687       : alureStream(_fstream), flacFile(NULL), format(AL_NONE), samplerate(0),
 688         blockAlign(0), useFloat(AL_FALSE)
 689     {
 690         if(!flac_handle) return;
 691
 692         flacFile = pFLAC__stream_decoder_new();
 693         if(flacFile)
 694         {
 695             if(pFLAC__stream_decoder_init_stream(flacFile, ReadCallback, SeekCallback, TellCallback, LengthCallback, EofCallback, WriteCallback, MetadataCallback, ErrorCallback, this) == FLAC__STREAM_DECODER_INIT_STATUS_OK)
 696             {
 697                 if(InitFlac())
 698                 {
 699                     // all ok
 700                     return;
 701                 }
 702
 703                 pFLAC__stream_decoder_finish(flacFile);
 704             }
 705             pFLAC__stream_decoder_delete(flacFile);
 706             flacFile = NULL;
 707         }
 708     }
 709
 710     virtual ~flacStream()
 711     {
 712         if(flacFile)
 713         {
 714             pFLAC__stream_decoder_finish(flacFile);
 715             pFLAC__stream_decoder_delete(flacFile);
 716             flacFile = NULL;
 717         }
 718     }
 719
 720 private:
 721     bool InitFlac()
 722     {
 723         // We need to decode some data to be able to get the channel count, bit
 724         // depth, and sample rate. It also ensures the file has FLAC data, as
 725         // the FLAC__stream_decoder_init_* functions can succeed on non-FLAC
 726         // Ogg files.
 727         outLen = 0;
 728         outTotal = 0;
 729         while(initialData.size() == 0)
 730         {
 731             if(pFLAC__stream_decoder_process_single(flacFile) == false ||
 732                pFLAC__stream_decoder_get_state(flacFile) == FLAC__STREAM_DECODER_END_OF_STREAM)
 733                 break;
 734         }
 735
 736         if(initialData.size() > 0)
 737             return true;
 738         return false;
 739     }
 740
 741     static FLAC__StreamDecoderWriteStatus WriteCallback(const FLAC__StreamDecoder*, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data)
 742     {
 743         flacStream *self = static_cast<flacStream*>(client_data);
 744         ALubyte *data = self->outBytes + self->outTotal;
 745         ALuint i = 0;
 746
 747         if(self->format == AL_NONE)
 748         {
 749             ALuint bps = frame->header.bits_per_sample;
 750             if(bps == 24 || bps == 32)
 751             {
 752                 self->format = GetSampleFormat(frame->header.channels, 32, true);
 753                 if(self->format != AL_NONE)
 754                 {
 755                     self->useFloat = AL_TRUE;
 756                     bps = 32;
 757                 }
 758                 else bps = 16;
 759             }
 760             if(self->format == AL_NONE)
 761                 self->format = GetSampleFormat(frame->header.channels, bps, false);
 762             self->blockAlign = frame->header.channels * bps/8;
 763             self->samplerate = frame->header.sample_rate;
 764         }
 765
 766         const ALboolean useFloat = self->useFloat;
 767         while(self->outTotal < self->outLen && i < frame->header.blocksize)
 768         {
 769             for(ALuint c = 0;c < frame->header.channels;c++)
 770             {
 771                 if(frame->header.bits_per_sample == 8)
 772                     ((ALubyte*)data)[c] = buffer[c][i]+128;
 773                 else if(frame->header.bits_per_sample == 16)
 774                     ((ALshort*)data)[c] = buffer[c][i];
 775                 else if(frame->header.bits_per_sample == 24)
 776                 {
 777                     if(useFloat)
 778                         ((ALfloat*)data)[c] = ((buffer[c][i]>=0) ?
 779                                                buffer[c][i]/(float)0x7FFFFF :
 780                                                buffer[c][i]/(float)0x800000);
 781                     else
 782                         ((ALshort*)data)[c] = buffer[c][i]>>8;
 783                 }
 784                 else if(frame->header.bits_per_sample == 32)
 785                 {
 786                     if(useFloat)
 787                         ((ALfloat*)data)[c] = ((buffer[c][i]>=0) ?
 788                                                buffer[c][i]/(float)0x7FFFFFFF :
 789                                                buffer[c][i]/(float)0x80000000u);
 790                     else
 791                         ((ALshort*)data)[c] = buffer[c][i]>>16;
 792                 }
 793             }
 794             self->outTotal += self->blockAlign;
 795             data += self->blockAlign;
 796             i++;
 797         }
 798
 799         if(i < frame->header.blocksize)
 800         {
 801             ALuint blocklen = (frame->header.blocksize-i) *
 802                               self->blockAlign;
 803             ALuint start = self->initialData.size();
 804
 805             self->initialData.resize(start+blocklen);
 806             data = &self->initialData[start];
 807
 808             do {
 809                 for(ALuint c = 0;c < frame->header.channels;c++)
 810                 {
 811                     if(frame->header.bits_per_sample == 8)
 812                         ((ALubyte*)data)[c] = buffer[c][i]+128;
 813                     else if(frame->header.bits_per_sample == 16)
 814                         ((ALshort*)data)[c] = buffer[c][i];
 815                     else if(frame->header.bits_per_sample == 24)
 816                     {
 817                         if(useFloat)
 818                             ((ALfloat*)data)[c] = ((buffer[c][i]>=0) ?
 819                                                    buffer[c][i]/(float)0x7FFFFF :
 820                                                    buffer[c][i]/(float)0x800000);
 821                         else
 822                             ((ALshort*)data)[c] = buffer[c][i]>>8;
 823                     }
 824                     else if(frame->header.bits_per_sample == 32)
 825                     {
 826                         if(useFloat)
 827                             ((ALfloat*)data)[c] = ((buffer[c][i]>=0) ?
 828                                                    buffer[c][i]/(float)0x7FFFFFFF :
 829                                                    buffer[c][i]/(float)0x80000000u);
 830                         else
 831                             ((ALshort*)data)[c] = buffer[c][i]>>16;
 832                     }
 833                 }
 834                 data += self->blockAlign;
 835                 i++;
 836             } while(i < frame->header.blocksize);
 837         }
 838
 839         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 840     }
 841     static void MetadataCallback(const FLAC__StreamDecoder*,const FLAC__StreamMetadata*,void*)
 842     {
 843     }
 844     static void ErrorCallback(const FLAC__StreamDecoder*,FLAC__StreamDecoderErrorStatus,void*)
 845     {
 846     }
 847
 848     static FLAC__StreamDecoderReadStatus ReadCallback(const FLAC__StreamDecoder*, FLAC__byte buffer[], size_t *bytes, void *client_data)
 849     {
 850         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 851         stream->clear();
 852
 853         if(*bytes <= 0)
 854             return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 855
 856         stream->read(reinterpret_cast<char*>(buffer), *bytes);
 857         *bytes = stream->gcount();
 858         if(*bytes == 0 && stream->eof())
 859             return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 860
 861         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 862     }
 863     static FLAC__StreamDecoderSeekStatus SeekCallback(const FLAC__StreamDecoder*, FLAC__uint64 absolute_byte_offset, void *client_data)
 864     {
 865         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 866         stream->clear();
 867
 868         if(!stream->seekg(absolute_byte_offset))
 869             return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 870         return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
 871     }
 872     static FLAC__StreamDecoderTellStatus TellCallback(const FLAC__StreamDecoder*, FLAC__uint64 *absolute_byte_offset, void *client_data)
 873     {
 874         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 875         stream->clear();
 876
 877         *absolute_byte_offset = stream->tellg();
 878         return FLAC__STREAM_DECODER_TELL_STATUS_OK;
 879     }
 880     static FLAC__StreamDecoderLengthStatus LengthCallback(const FLAC__StreamDecoder*, FLAC__uint64 *stream_length, void *client_data)
 881     {
 882         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 883         stream->clear();
 884
 885         std::streampos pos = stream->tellg();
 886         if(stream->seekg(0, std::ios_base::end))
 887         {
 888             *stream_length = stream->tellg();
 889             stream->seekg(pos);
 890         }
 891
 892         if(!stream->good())
 893             return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
 894         return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
 895     }
 896     static FLAC__bool EofCallback(const FLAC__StreamDecoder*, void *client_data)
 897     {
 898         std::istream *stream = static_cast<flacStream*>(client_data)->fstream;
 899         return (stream->eof()) ? true : false;
 900     }
 901 };
 902 static DecoderDecl<flacStream> flacStream_decoder;
 903 #endif
 904
 905 #ifdef HAS_FLUIDSYNTH
 906 struct fluidStream : public alureStream {
 907 private:
 908     static const ALubyte MIDI_CHANNEL_MASK = 0x0F;
 909     static const ALubyte MIDI_EVENT_MASK   = 0xF0;
 910
 911     static const ALubyte MIDI_NOTEOFF    = 0x80;    // + note + velocity
 912     static const ALubyte MIDI_NOTEON     = 0x90;    // + note + velocity
 913     static const ALubyte MIDI_POLYPRESS  = 0xA0;    // + pressure (2 bytes)
 914     static const ALubyte MIDI_CTRLCHANGE = 0xB0;    // + ctrl + value
 915     static const ALubyte MIDI_PRGMCHANGE = 0xC0;    // + new patch
 916     static const ALubyte MIDI_CHANPRESS  = 0xD0;    // + pressure (1 byte)
 917     static const ALubyte MIDI_PITCHBEND  = 0xE0;    // + pitch bend (2 bytes)
 918     static const ALubyte MIDI_SPECIAL    = 0xF0;    // Special event
 919
 920     static const ALubyte MIDI_SYSEX    = 0xF0;      // SysEx begin
 921     static const ALubyte MIDI_SYSEXEND = 0xF7;      // SysEx end
 922     static const ALubyte MIDI_SONGPOS  = 0xF2;      // Song position
 923     static const ALubyte MIDI_SONGSEL  = 0xF3;      // Song select
 924     static const ALubyte MIDI_META     = 0xFF;      // Meta event begin
 925
 926     static const ALubyte MIDI_META_EOT   = 0x2F;    // End-of-track
 927     static const ALubyte MIDI_META_TEMPO = 0x51;    // Tempo change
 928
 929     struct MidiTrack {
 930         std::vector<ALubyte> data;
 931         size_t Offset;
 932         ALubyte LastEvent;
 933         ALdouble SamplesLeft;
 934
 935         MidiTrack() : Offset(0), LastEvent(0), SamplesLeft(0.)
 936         { }
 937         MidiTrack(const MidiTrack &rhs)
 938           : data(rhs.data), Offset(rhs.Offset), LastEvent(rhs.LastEvent),
 939             SamplesLeft(rhs.SamplesLeft)
 940         { }
 941
 942         void Reset()
 943         {
 944             Offset = 0;
 945             LastEvent = 0;
 946             SamplesLeft = 0.;
 947         }
 948
 949         const MidiTrack& operator=(const MidiTrack &rhs)
 950         {
 951             data = rhs.data;
 952             Offset = rhs.Offset;
 953             LastEvent = rhs.LastEvent;
 954             SamplesLeft = rhs.SamplesLeft;
 955             return *this;
 956         }
 957
 958         unsigned long ReadVarLen()
 959         {
 960             if(Offset >= data.size())
 961                 return 0;
 962
 963             unsigned long len = data[Offset]&0x7F;
 964             while((data[Offset]&0x80))
 965             {
 966                 if(++Offset >= data.size())
 967                     return 0;
 968                 len = (len<<7) | (data[Offset]&0x7F);
 969             }
 970             Offset++;
 971
 972             return len;
 973         }
 974     };
 975
 976     ALuint Divisions;
 977     std::vector<MidiTrack> Tracks;
 978
 979     ALenum format;
 980     ALsizei sampleRate;
 981     ALdouble samplesPerTick;
 982
 983     fluid_settings_t *fluidSettings;
 984     fluid_synth_t *fluidSynth;
 985     int fontID;
 986
 987 public:
 988     virtual bool IsValid()
 989     { return fluidSynth != NULL; }
 990
 991     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
 992     {
 993         if(format == AL_NONE)
 994         {
 995             format = GetSampleFormat(2, 32, true);
 996             if(format == AL_NONE)
 997                 format = AL_FORMAT_STEREO16;
 998         }
 999         *fmt = format;
1000         *frequency = sampleRate;
1001         *blockalign = 2 * ((format==AL_FORMAT_STEREO16) ? sizeof(ALshort) :
1002                                                           sizeof(ALfloat));
1003         return true;
1004     }
1005
1006     virtual ALuint GetData(ALubyte *data, ALuint bytes)
1007     {
1008         ALuint ret;
1009
1010         if(format == AL_FORMAT_STEREO16)
1011         {
1012             ALshort *ptr = reinterpret_cast<ALshort*>(data);
1013             ret = FillBuffer(ptr, bytes/2/sizeof(ALshort));
1014             ret *= 2 * sizeof(ALshort);
1015         }
1016         else
1017         {
1018             ALfloat *ptr = reinterpret_cast<ALfloat*>(data);
1019             ret = FillBuffer(ptr, bytes/2/sizeof(ALfloat));
1020             ret *= 2 * sizeof(ALfloat);
1021         }
1022
1023         return ret;
1024     }
1025
1026     virtual bool Rewind()
1027     {
1028         for(std::vector<MidiTrack>::iterator i = Tracks.begin(), end = Tracks.end();i != end;i++)
1029         {
1030             i->Reset();
1031             unsigned long val = i->ReadVarLen();
1032             i->SamplesLeft += val * samplesPerTick;
1033         }
1034         pfluid_synth_program_reset(fluidSynth);
1035         UpdateTempo(500000);
1036         return true;
1037     }
1038
1039     virtual bool SetPatchset(const char *sfont)
1040     {
1041         int newid = pfluid_synth_sfload(fluidSynth, sfont, true);
1042         if(newid == FLUID_FAILED)
1043         {
1044             SetError("Failed to load soundfont");
1045             return false;
1046         }
1047
1048         if(fontID != FLUID_FAILED)
1049             pfluid_synth_sfunload(fluidSynth, fontID, true);
1050         fontID = newid;
1051
1052         return true;
1053     }
1054
1055     fluidStream(std::istream *_fstream)
1056       : alureStream(_fstream), Divisions(100),
1057         format(AL_NONE), sampleRate(48000), samplesPerTick(1.),
1058         fluidSettings(NULL), fluidSynth(NULL), fontID(FLUID_FAILED)
1059     {
1060         if(!fsynth_handle) return;
1061
1062         ALCdevice *device = alcGetContextsDevice(alcGetCurrentContext());
1063         if(device)
1064             alcGetIntegerv(device, ALC_FREQUENCY, 1, &sampleRate);
1065
1066         char hdr[4];
1067         if(!fstream->read(hdr, 4))
1068             return;
1069
1070         if(memcmp(hdr, "MThd", 4) == 0)
1071         {
1072             ALuint len = read_be32(fstream);
1073             if(len != 6)
1074                 return;
1075
1076             int type = read_be16(fstream);
1077             if(type != 0 && type != 1)
1078                 return;
1079
1080             ALuint numtracks = read_be16(fstream);
1081
1082             Divisions = read_be16(fstream);
1083             UpdateTempo(500000);
1084
1085             Tracks.resize(numtracks);
1086             for(std::vector<MidiTrack>::iterator i = Tracks.begin(), end = Tracks.end();i != end;i++)
1087             {
1088                 if(!fstream->read(hdr, 4) || memcmp(hdr, "MTrk", 4) != 0)
1089                     return;
1090
1091                 ALuint len = read_be32(fstream);
1092                 i->data.resize(len);
1093                 if(!fstream->read(reinterpret_cast<char*>(&i->data[0]), len))
1094                     return;
1095
1096                 unsigned long val = i->ReadVarLen();
1097                 i->SamplesLeft += val * samplesPerTick;
1098             }
1099             SetupSynth();
1100         }
1101     }
1102
1103     virtual ~fluidStream()
1104     {
1105         if(fontID != FLUID_FAILED)
1106             pfluid_synth_sfunload(fluidSynth, fontID, true);
1107         fontID = FLUID_FAILED;
1108
1109         if(fluidSynth != NULL)
1110             pdelete_fluid_synth(fluidSynth);
1111         fluidSynth = NULL;
1112
1113         if(fluidSettings != NULL)
1114             pdelete_fluid_settings(fluidSettings);
1115         fluidSettings = NULL;
1116     }
1117
1118 private:
1119     template<typename T>
1120     ALuint FillBuffer(T *Buffer, ALuint BufferSamples)
1121     {
1122         ALuint SamplesInBuffer = 0;
1123         while(SamplesInBuffer < BufferSamples)
1124         {
1125             // Check if any tracks are still playing and how many samples are waiting to render
1126             size_t TracksPlaying = 0;
1127             ALuint SamplesToDo = BufferSamples - SamplesInBuffer;
1128             for(std::vector<MidiTrack>::iterator i = Tracks.begin(),
1129                                                  end = Tracks.end();i != end;i++)
1130             {
1131                 if(i->Offset < i->data.size())
1132                 {
1133                     SamplesToDo = std::min<ALuint>(SamplesToDo, i->SamplesLeft);
1134                     TracksPlaying++;
1135                 }
1136             }
1137             if(TracksPlaying == 0)
1138                 break;
1139
1140             if(SamplesToDo == 0)
1141             {
1142                 ProcessMidi();
1143                 continue;
1144             }
1145
1146             // Render samples
1147             WriteSamples(SamplesToDo, Buffer);
1148             Buffer += SamplesToDo*2;
1149             SamplesInBuffer += SamplesToDo;
1150
1151             for(std::vector<MidiTrack>::iterator i = Tracks.begin(),
1152                                                  end = Tracks.end();i != end;i++)
1153             {
1154                 if(i->Offset < i->data.size())
1155                     i->SamplesLeft -= SamplesToDo;
1156             }
1157         }
1158
1159         return SamplesInBuffer;
1160     }
1161
1162     void WriteSamples(ALuint count, short *buffer)
1163     { pfluid_synth_write_s16(fluidSynth, count, buffer, 0, 2, buffer, 1, 2); }
1164     void WriteSamples(ALuint count, float *buffer)
1165     { pfluid_synth_write_float(fluidSynth, count, buffer, 0, 2, buffer, 1, 2); }
1166
1167     void ProcessMidi()
1168     {
1169         ALuint newtempo = 0;
1170
1171         // Process more events
1172         std::vector<MidiTrack>::iterator i=Tracks.begin(), end=Tracks.end();
1173         while(i != end)
1174         {
1175             if(i->Offset >= i->data.size() || i->SamplesLeft >= 1.)
1176             {
1177                 i++;
1178                 continue;
1179             }
1180
1181             if(i->data.size() - i->Offset < 3)
1182             {
1183                 i->Offset = i->data.size();
1184                 i++;
1185                 continue;
1186             }
1187
1188             ALubyte event = i->data[i->Offset++];
1189             ALubyte parm1, parm2;
1190             if(!(event&0x80))
1191             {
1192                 event = i->LastEvent;
1193                 i->Offset--;
1194             }
1195             if((event&MIDI_EVENT_MASK) != MIDI_SPECIAL)
1196                 i->LastEvent = event;
1197             parm1 = i->data[i->Offset];
1198             parm2 = i->data[i->Offset+1];
1199
1200             int channel = event&MIDI_CHANNEL_MASK;
1201             switch(event&MIDI_EVENT_MASK)
1202             {
1203                 case MIDI_NOTEOFF:
1204                     pfluid_synth_noteoff(fluidSynth, channel, parm1);
1205                     i->Offset += 2;
1206                     break;
1207                 case MIDI_NOTEON:
1208                     pfluid_synth_noteon(fluidSynth, channel, parm1, parm2);
1209                     i->Offset += 2;
1210                     break;
1211                 case MIDI_POLYPRESS:
1212                     i->Offset += 2;
1213                     break;
1214
1215                 case MIDI_CTRLCHANGE:
1216                     pfluid_synth_cc(fluidSynth, channel, parm1, parm2);
1217                     i->Offset += 2;
1218                     break;
1219                 case MIDI_PRGMCHANGE:
1220                     pfluid_synth_program_change(fluidSynth, channel, parm1);
1221                     i->Offset += 1;
1222                     break;
1223
1224                 case MIDI_CHANPRESS:
1225                     pfluid_synth_channel_pressure(fluidSynth, channel, parm1);
1226                     i->Offset += 1;
1227                     break;
1228
1229                 case MIDI_PITCHBEND:
1230                     pfluid_synth_pitch_bend(fluidSynth, channel, (parm1&0x7F) | ((parm2&0x7F)<<7));
1231                     i->Offset += 2;
1232                     break;
1233
1234                 case MIDI_SPECIAL:
1235                     switch(event)
1236                     {
1237                         case MIDI_SYSEX:
1238                         {
1239                             unsigned long len = i->ReadVarLen();
1240                             if(i->data.size() - i->Offset < len)
1241                             {
1242                                 i->Offset = i->data.size();
1243                                 break;
1244                             }
1245
1246                             if(len > 1 && i->data[len-1] == MIDI_SYSEXEND)
1247                             {
1248                                 char *data = reinterpret_cast<char*>(&i->data[i->Offset]);
1249                                 pfluid_synth_sysex(fluidSynth, data, len-1, NULL, NULL, NULL, false);
1250                             }
1251                             i->Offset += len;
1252                             break;
1253                         }
1254                         case MIDI_SYSEXEND:
1255                         {
1256                             unsigned long len = i->ReadVarLen();
1257                             if(i->data.size() - i->Offset < len)
1258                             {
1259                                 i->Offset = i->data.size();
1260                                 break;
1261                             }
1262                             i->Offset += len;
1263                             break;
1264                         }
1265
1266                         case MIDI_SONGPOS:
1267                             i->Offset += 2;
1268                             break;
1269
1270                         case MIDI_SONGSEL:
1271                             i->Offset += 1;
1272                             break;
1273
1274                         case MIDI_META:
1275                         {
1276                             ALubyte metatype = i->data[i->Offset++];
1277                             unsigned long val = i->ReadVarLen();
1278
1279                             if(i->data.size() - i->Offset < val)
1280                             {
1281                                 i->Offset = i->data.size();
1282                                 break;
1283                             }
1284
1285                             if(metatype == MIDI_META_EOT)
1286                             {
1287                                 i->Offset = i->data.size();
1288                                 break;
1289                             }
1290
1291                             if(metatype == MIDI_META_TEMPO && val >= 3)
1292                             {
1293                                 newtempo = (i->data[i->Offset] << 16) |
1294                                            (i->data[i->Offset+1] << 8) |
1295                                            (i->data[i->Offset+2]);
1296                             }
1297
1298                             i->Offset += val;
1299                             break;
1300                         }
1301
1302                         default:
1303                             /* The rest of the special events don't have any
1304                              * data bytes */
1305                             break;
1306                     }
1307                     break;
1308
1309                 default:
1310                     /* Shouldn't ever get to here */
1311                     break;
1312             }
1313
1314             unsigned long val = i->ReadVarLen();
1315             i->SamplesLeft += val * samplesPerTick;
1316         }
1317         if(newtempo)
1318             UpdateTempo(newtempo);
1319     }
1320
1321     void UpdateTempo(ALuint tempo)
1322     {
1323         ALdouble sampletickrate = sampleRate / (1000000. / tempo) / Divisions;
1324
1325         for(std::vector<MidiTrack>::iterator i = Tracks.begin(),
1326                                              end = Tracks.end();i != end;i++)
1327         {
1328             if(i->Offset >= i->data.size())
1329                 continue;
1330             i->SamplesLeft = i->SamplesLeft / samplesPerTick * sampletickrate;
1331         }
1332         samplesPerTick = sampletickrate;
1333     }
1334
1335     void SetupSynth()
1336     {
1337         fluidSettings = pnew_fluid_settings();
1338         if(fluidSettings)
1339         {
1340             pfluid_settings_setnum(fluidSettings, "synth.gain", 0.5);
1341             pfluid_settings_setstr(fluidSettings, "synth.reverb.active", "yes");
1342             pfluid_settings_setstr(fluidSettings, "synth.chorus.active", "yes");
1343             pfluid_settings_setint(fluidSettings, "synth.polyphony", 256);
1344             pfluid_settings_setnum(fluidSettings, "synth.sample-rate", (double)sampleRate);
1345
1346             fluidSynth = pnew_fluid_synth(fluidSettings);
1347             if(fluidSynth)
1348             {
1349                 const char *soundfont = getenv("FLUID_SOUNDFONT");
1350                 if(soundfont && soundfont[0])
1351                     fontID = pfluid_synth_sfload(fluidSynth, soundfont, true);
1352             }
1353         }
1354     }
1355 };
1356 static DecoderDecl<fluidStream> fluidStream_decoder;
1357 #endif
1358
1359 #ifdef HAS_SNDFILE
1360 struct sndStream : public alureStream {
1361     SNDFILE *sndFile;
1362     SF_INFO sndInfo;
1363     ALenum format;
1364
1365     virtual bool IsValid()
1366     { return sndFile != NULL; }
1367
1368     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
1369     {
1370         if(format == AL_NONE)
1371             format = GetSampleFormat(sndInfo.channels, 16, false);
1372         *fmt = format;
1373         *frequency = sndInfo.samplerate;
1374         *blockalign = sndInfo.channels*2;
1375         return true;
1376     }
1377
1378     virtual ALuint GetData(ALubyte *data, ALuint bytes)
1379     {
1380         const ALuint frameSize = 2*sndInfo.channels;
1381         return psf_readf_short(sndFile, (short*)data, bytes/frameSize) * frameSize;
1382     }
1383
1384     virtual bool Rewind()
1385     {
1386         if(psf_seek(sndFile, 0, SEEK_SET) != -1)
1387             return true;
1388
1389         SetError("Seek failed");
1390         return false;
1391     }
1392
1393     sndStream(std::istream *_fstream)
1394       : alureStream(_fstream), sndFile(NULL), format(AL_NONE)
1395     {
1396         memset(&sndInfo, 0, sizeof(sndInfo));
1397
1398         if(!sndfile_handle) return;
1399
1400         static SF_VIRTUAL_IO streamIO = {
1401             get_filelen, seek,
1402             read, write, tell
1403         };
1404         sndFile = psf_open_virtual(&streamIO, SFM_READ, &sndInfo, this);
1405     }
1406
1407     virtual ~sndStream()
1408     {
1409         if(sndFile)
1410             psf_close(sndFile);
1411         sndFile = NULL;
1412     }
1413
1414 private:
1415     // libSndFile iostream callbacks
1416     static sf_count_t get_filelen(void *user_data)
1417     {
1418         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
1419         stream->clear();
1420
1421         std::streampos len = -1;
1422         std::streampos pos = stream->tellg();
1423         if(stream->seekg(0, std::ios_base::end))
1424         {
1425             len = stream->tellg();
1426             stream->seekg(pos);
1427         }
1428
1429         return len;
1430     }
1431
1432     static sf_count_t seek(sf_count_t offset, int whence, void *user_data)
1433     {
1434         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
1435         stream->clear();
1436
1437         if(whence == SEEK_CUR)
1438             stream->seekg(offset, std::ios_base::cur);
1439         else if(whence == SEEK_SET)
1440             stream->seekg(offset, std::ios_base::beg);
1441         else if(whence == SEEK_END)
1442             stream->seekg(offset, std::ios_base::end);
1443         else
1444             return -1;
1445
1446         return stream->tellg();
1447     }
1448
1449     static sf_count_t read(void *ptr, sf_count_t count, void *user_data)
1450     {
1451         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
1452         stream->clear();
1453         stream->read(static_cast<char*>(ptr), count);
1454         return stream->gcount();
1455     }
1456
1457     static sf_count_t write(const void*, sf_count_t, void*)
1458     { return -1; }
1459
1460     static sf_count_t tell(void *user_data)
1461     {
1462         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
1463         stream->clear();
1464         return stream->tellg();
1465     }
1466 };
1467 static DecoderDecl<sndStream> sndStream_decoder;
1468 #endif
1469
1470 #ifdef HAS_DUMB
1471 struct dumbStream : public alureStream {
1472     DUMBFILE_SYSTEM vfs;
1473     DUMBFILE *dumbFile;
1474     DUH *duh;
1475     DUH_SIGRENDERER *renderer;
1476     std::vector<sample_t> sampleBuf;
1477     ALuint lastOrder;
1478     ALenum format;
1479     ALCint samplerate;
1480
1481     virtual bool IsValid()
1482     { return renderer != NULL; }
1483
1484     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
1485     {
1486         if(format == AL_NONE)
1487         {
1488             format = GetSampleFormat(2, 32, true);
1489             if(format == AL_NONE)
1490                 format = AL_FORMAT_STEREO16;
1491         }
1492         *fmt = format;
1493         *frequency = samplerate;
1494         *blockalign = 2 * ((format==AL_FORMAT_STEREO16) ? sizeof(ALshort) :
1495                                                           sizeof(ALfloat));
1496         return true;
1497     }
1498
1499     virtual ALuint GetData(ALubyte *data, ALuint bytes)
1500     {
1501         ALuint ret = 0;
1502
1503         if(pdumb_it_sr_get_speed(pduh_get_it_sigrenderer(renderer)) == 0)
1504             return 0;
1505
1506         ALuint sample_count = bytes / ((format==AL_FORMAT_STEREO16) ?
1507                                        sizeof(ALshort) : sizeof(ALfloat));
1508
1509         sampleBuf.resize(sample_count);
1510         sample_t *samples[] = {
1511             &sampleBuf[0]
1512         };
1513
1514         pdumb_silence(samples[0], sample_count);
1515         ret = pduh_sigrenderer_generate_samples(renderer, 1.0f, 65536.0f/samplerate, sample_count/2, samples);
1516         ret *= 2;
1517         if(format == AL_FORMAT_STEREO16)
1518         {
1519             for(ALuint i = 0;i < ret;i++)
1520                 ((ALshort*)data)[i] = clamp(samples[0][i]>>8, -32768, 32767);
1521         }
1522         else
1523         {
1524             for(ALuint i = 0;i < ret;i++)
1525                 ((ALfloat*)data)[i] = ((samples[0][i]>=0) ?
1526                                        samples[0][i]/(float)0x7FFFFF :
1527                                        samples[0][i]/(float)0x800000);
1528         }
1529         ret *= ((format==AL_FORMAT_STEREO16) ? sizeof(ALshort) : sizeof(ALfloat));
1530
1531         return ret;
1532     }
1533
1534     virtual bool Rewind()
1535     {
1536         DUH_SIGRENDERER *newrenderer = pdumb_it_start_at_order(duh, 2, lastOrder);
1537         if(!newrenderer)
1538         {
1539             SetError("Could not start renderer");
1540             return false;
1541         }
1542         pduh_end_sigrenderer(renderer);
1543         renderer = newrenderer;
1544         return true;
1545     }
1546
1547     virtual bool SetOrder(ALuint order)
1548     {
1549         DUH_SIGRENDERER *newrenderer = pdumb_it_start_at_order(duh, 2, order);
1550         if(!newrenderer)
1551         {
1552             SetError("Could not set order");
1553             return false;
1554         }
1555         pduh_end_sigrenderer(renderer);
1556         renderer = newrenderer;
1557
1558         lastOrder = order;
1559         return true;
1560     }
1561
1562     dumbStream(std::istream *_fstream)
1563       : alureStream(_fstream), dumbFile(NULL), duh(NULL), renderer(NULL),
1564         lastOrder(0), format(AL_NONE), samplerate(48000)
1565     {
1566         if(!dumb_handle) return;
1567
1568         ALCdevice *device = alcGetContextsDevice(alcGetCurrentContext());
1569         if(device)
1570             alcGetIntegerv(device, ALC_FREQUENCY, 1, &samplerate);
1571
1572         DUH* (*funcs[])(DUMBFILE*) = {
1573             pdumb_read_it,
1574             pdumb_read_xm,
1575             pdumb_read_s3m,
1576             pdumb_read_mod,
1577             NULL
1578         };
1579
1580         vfs.open = NULL;
1581         vfs.skip = skip;
1582         vfs.getc = read_char;
1583         vfs.getnc = read;
1584         vfs.close = NULL;
1585
1586         for(size_t i = 0;funcs[i];i++)
1587         {
1588             dumbFile = pdumbfile_open_ex(this, &vfs);
1589             if(dumbFile)
1590             {
1591                 duh = funcs[i](dumbFile);
1592                 if(duh)
1593                 {
1594                     renderer = pdumb_it_start_at_order(duh, 2, lastOrder);
1595                     if(renderer)
1596                     {
1597                         pdumb_it_set_loop_callback(pduh_get_it_sigrenderer(renderer), loop_cb, this);
1598                         break;
1599                     }
1600
1601                     punload_duh(duh);
1602                     duh = NULL;
1603                 }
1604
1605                 pdumbfile_close(dumbFile);
1606                 dumbFile = NULL;
1607             }
1608             fstream->clear();
1609             fstream->seekg(0);
1610         }
1611     }
1612
1613     virtual ~dumbStream()
1614     {
1615         if(renderer)
1616             pduh_end_sigrenderer(renderer);
1617         renderer = NULL;
1618
1619         if(duh)
1620             punload_duh(duh);
1621         duh = NULL;
1622
1623         if(dumbFile)
1624             pdumbfile_close(dumbFile);
1625         dumbFile = NULL;
1626     }
1627
1628 private:
1629     // DUMBFILE iostream callbacks
1630     static int skip(void *user_data, long offset)
1631     {
1632         std::istream *stream = static_cast<dumbStream*>(user_data)->fstream;
1633         stream->clear();
1634
1635         if(stream->seekg(offset, std::ios_base::cur))
1636             return 0;
1637         return -1;
1638     }
1639
1640     static long read(char *ptr, long size, void *user_data)
1641     {
1642         std::istream *stream = static_cast<dumbStream*>(user_data)->fstream;
1643         stream->clear();
1644
1645         stream->read(ptr, size);
1646         return stream->gcount();
1647     }
1648
1649     static int read_char(void *user_data)
1650     {
1651         std::istream *stream = static_cast<dumbStream*>(user_data)->fstream;
1652         stream->clear();
1653
1654         unsigned char ret;
1655         stream->read(reinterpret_cast<char*>(&ret), 1);
1656         if(stream->gcount() > 0)
1657             return ret;
1658         return -1;
1659     }
1660
1661     static int loop_cb(void *user_data)
1662     {
1663         dumbStream *self = static_cast<dumbStream*>(user_data);
1664         pdumb_it_sr_set_speed(pduh_get_it_sigrenderer(self->renderer), 0);
1665         return 0;
1666     }
1667 };
1668 static DecoderDecl<dumbStream> dumbStream_decoder;
1669 #endif
1670
1671 #ifdef HAS_MODPLUG
1672 struct modStream : public alureStream {
1673     ModPlugFile *modFile;
1674     int lastOrder;
1675
1676     virtual bool IsValid()
1677     { return modFile != NULL; }
1678
1679     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
1680     {
1681         *fmt = AL_FORMAT_STEREO16;
1682         *frequency = 44100;
1683         *blockalign = 2 * sizeof(ALshort);
1684         return true;
1685     }
1686
1687     virtual ALuint GetData(ALubyte *data, ALuint bytes)
1688     {
1689         int ret = pModPlug_Read(modFile, data, bytes);
1690         if(ret < 0) return 0;
1691         return ret;
1692     }
1693
1694     virtual bool Rewind()
1695     { return SetOrder(lastOrder); }
1696
1697     virtual bool SetOrder(ALuint order)
1698     {
1699         std::vector<char> data(16384);
1700         ALuint total = 0;
1701         while(total < 2*1024*1024)
1702         {
1703             fstream->read(&data[total], data.size()-total);
1704             if(fstream->gcount() == 0) break;
1705             total += fstream->gcount();
1706             data.resize(total*2);
1707         }
1708         data.resize(total);
1709
1710         ModPlugFile *newMod = pModPlug_Load(&data[0], data.size());
1711         if(!newMod)
1712         {
1713             SetError("Could not reload data");
1714             return false;
1715         }
1716         pModPlug_Unload(modFile);
1717         modFile = newMod;
1718
1719         // There seems to be no way to tell if the seek succeeds
1720         pModPlug_SeekOrder(modFile, order);
1721         lastOrder = order;
1722
1723         return true;
1724     }
1725
1726     modStream(std::istream *_fstream)
1727       : alureStream(_fstream), modFile(NULL), lastOrder(0)
1728     {
1729         if(!mod_handle) return;
1730
1731         std::vector<char> data(16384);
1732         ALuint total = 0;
1733         while(total < 2*1024*1024)
1734         {
1735             fstream->read(&data[total], data.size()-total);
1736             if(fstream->gcount() == 0) break;
1737             total += fstream->gcount();
1738             data.resize(total*2);
1739         }
1740         data.resize(total);
1741
1742         modFile = pModPlug_Load(&data[0], data.size());
1743     }
1744
1745     virtual ~modStream()
1746     {
1747         if(modFile)
1748             pModPlug_Unload(modFile);
1749         modFile = NULL;
1750     }
1751 };
1752 static DecoderDecl<modStream> modStream_decoder;
1753 #endif
1754
1755 #ifdef HAS_MPG123
1756 struct mp3Stream : public alureStream {
1757     mpg123_handle *mp3File;
1758     long samplerate;
1759     int channels;
1760     ALenum format;
1761     std::ios::pos_type dataStart;
1762     std::ios::pos_type dataEnd;
1763
1764     virtual bool IsValid()
1765     { return mp3File != NULL; }
1766
1767     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
1768     {
1769         *fmt = format;
1770         *frequency = samplerate;
1771         *blockalign = channels*2;
1772         return true;
1773     }
1774
1775     virtual ALuint GetData(ALubyte *data, ALuint bytes)
1776     {
1777         ALuint amt = 0;
1778         while(bytes > 0)
1779         {
1780             size_t got = 0;
1781             int ret = pmpg123_read(mp3File, data, bytes, &got);
1782
1783             bytes -= got;
1784             data += got;
1785             amt += got;
1786
1787             if(ret == MPG123_NEW_FORMAT)
1788             {
1789                 long newrate;
1790                 int newchans, enc;
1791                 pmpg123_getformat(mp3File, &newrate, &newchans, &enc);
1792                 continue;
1793             }
1794             if(ret == MPG123_NEED_MORE)
1795             {
1796                 unsigned char data[4096];
1797                 ALint insize = std::min((ALint)sizeof(data),
1798                                         (ALint)(dataEnd-fstream->tellg()));
1799                 if(insize > 0)
1800                 {
1801                     fstream->read((char*)data, insize);
1802                     insize = fstream->gcount();
1803                 }
1804                 if(insize > 0 && pmpg123_feed(mp3File, data, insize) == MPG123_OK)
1805                     continue;
1806             }
1807             if(got == 0)
1808                 break;
1809         }
1810         return amt;
1811     }
1812
1813     virtual bool Rewind()
1814     {
1815         fstream->clear();
1816         std::istream::pos_type oldpos = fstream->tellg();
1817         fstream->seekg(dataStart);
1818
1819         mpg123_handle *newFile = pmpg123_new(NULL, NULL);
1820         if(pmpg123_open_feed(newFile) == MPG123_OK)
1821         {
1822             unsigned char data[4096];
1823             long newrate;
1824             int newchans;
1825             int enc;
1826
1827             ALuint amt, total = 0;
1828             int ret = MPG123_OK;
1829             do {
1830                 amt = std::min((ALint)sizeof(data),
1831                                (ALint)(dataEnd-fstream->tellg()));
1832                 fstream->read((char*)data, amt);
1833                 amt = fstream->gcount();
1834                 if(amt == 0)  break;
1835                 total += amt;
1836                 ret = pmpg123_decode(newFile, data, amt, NULL, 0, NULL);
1837             } while(ret == MPG123_NEED_MORE && total < 64*1024);
1838
1839             if(ret == MPG123_NEW_FORMAT &&
1840                pmpg123_getformat(newFile, &newrate, &newchans, &enc) == MPG123_OK)
1841             {
1842                 if(pmpg123_format_none(newFile) == MPG123_OK &&
1843                    pmpg123_format(newFile, samplerate, channels, MPG123_ENC_SIGNED_16) == MPG123_OK)
1844                 {
1845                     // All OK
1846                     pmpg123_delete(mp3File);
1847                     mp3File = newFile;
1848                     return true;
1849                 }
1850             }
1851             pmpg123_delete(newFile);
1852         }
1853
1854         fstream->seekg(oldpos);
1855         SetError("Restart failed");
1856         return false;
1857     }
1858
1859     mp3Stream(std::istream *_fstream)
1860       : alureStream(_fstream), mp3File(NULL), format(AL_NONE),
1861         dataStart(0), dataEnd(0)
1862     {
1863         if(!mp123_handle) return;
1864
1865         if(!FindDataChunk())
1866             return;
1867
1868         mp3File = pmpg123_new(NULL, NULL);
1869         if(pmpg123_open_feed(mp3File) == MPG123_OK)
1870         {
1871             unsigned char data[4096];
1872             int enc;
1873
1874             ALuint amt, total = 0;
1875             int ret = MPG123_OK;
1876             do {
1877                 amt = std::min((ALint)sizeof(data),
1878                                (ALint)(dataEnd-fstream->tellg()));
1879                 fstream->read((char*)data, amt);
1880                 amt = fstream->gcount();
1881                 if(amt == 0)  break;
1882                 total += amt;
1883                 ret = pmpg123_decode(mp3File, data, amt, NULL, 0, NULL);
1884             } while(ret == MPG123_NEED_MORE && total < 64*1024);
1885
1886             if(ret == MPG123_NEW_FORMAT &&
1887                pmpg123_getformat(mp3File, &samplerate, &channels, &enc) == MPG123_OK)
1888             {
1889                 format = GetSampleFormat(channels, 16, false);
1890                 if(pmpg123_format_none(mp3File) == MPG123_OK &&
1891                    pmpg123_format(mp3File, samplerate, channels, MPG123_ENC_SIGNED_16) == MPG123_OK)
1892                 {
1893                     // All OK
1894                     return;
1895                 }
1896             }
1897         }
1898         pmpg123_delete(mp3File);
1899         mp3File = NULL;
1900     }
1901
1902     virtual ~mp3Stream()
1903     {
1904         if(mp3File)
1905             pmpg123_delete(mp3File);
1906         mp3File = NULL;
1907     }
1908
1909 private:
1910     bool FindDataChunk()
1911     {
1912         ALubyte buffer[25];
1913         int length;
1914
1915         if(!fstream->read(reinterpret_cast<char*>(buffer), 12))
1916             return false;
1917
1918         if(memcmp(buffer, "RIFF", 4) != 0 || memcmp(buffer+8, "WAVE", 4) != 0)
1919         {
1920             dataStart = 0;
1921
1922             // Check for an ID3v2 tag, and skip it
1923             if(memcmp(buffer, "ID3", 3) == 0 &&
1924                buffer[3] <= 4 && buffer[4] != 0xff &&
1925                (buffer[5]&0x0f) == 0 && (buffer[6]&0x80) == 0 &&
1926                (buffer[7]&0x80) == 0 && (buffer[8]&0x80) == 0 &&
1927                (buffer[9]&0x80) == 0)
1928             {
1929                 dataStart = (buffer[6]<<21) | (buffer[7]<<14) |
1930                             (buffer[8]<< 7) | (buffer[9]    );
1931                 dataStart += ((buffer[5]&0x10) ? 20 : 10);
1932             }
1933
1934             if(fstream->seekg(0, std::ios_base::end))
1935             {
1936                 dataEnd = fstream->tellg();
1937                 fstream->seekg(dataStart);
1938             }
1939             return true;
1940         }
1941
1942         int type = 0;
1943         while(1)
1944         {
1945             char tag[4];
1946             if(!fstream->read(tag, 4))
1947                 break;
1948
1949             /* read chunk length */
1950             length = read_le32(fstream);
1951
1952             if(memcmp(tag, "fmt ", 4) == 0 && length >= 16)
1953             {
1954                 /* Data type (should be 0x0050 or 0x0055 for MP3 data) */
1955                 type = read_le16(fstream);
1956                 if(type != 0x0050 && type != 0x0055)
1957                     break;
1958                 length -= 2;
1959                 /* Ignore the rest of the chunk. Everything we need is in the
1960                  * data stream */
1961             }
1962             else if(memcmp(tag, "data", 4) == 0)
1963             {
1964                 if(type == 0x0050 || type == 0x0055)
1965                 {
1966                     dataStart = fstream->tellg();
1967                     dataEnd = dataStart;
1968                     dataEnd += length;
1969                     return true;
1970                 }
1971             }
1972
1973             fstream->seekg(length, std::ios_base::cur);
1974         }
1975
1976         return false;
1977     }
1978 };
1979 static DecoderDecl<mp3Stream> mp3Stream_decoder;
1980 #endif
1981
1982
1983 template <typename T>
1984 alureStream *get_stream_decoder(const T &fdata)
1985 {
1986     std::map<ALint,UserCallbacks>::iterator i = InstalledCallbacks.begin();
1987     while(i != InstalledCallbacks.end() && i->first < 0)
1988     {
1989         std::auto_ptr<alureStream> stream(new customStream(fdata, i->second));
1990         if(stream->IsValid()) return stream.release();
1991         i++;
1992     }
1993
1994     std::istream *file = new InStream(fdata);
1995     if(!file->fail())
1996     {
1997         Decoder::ListType Factories = Decoder::GetList();
1998         Decoder::ListType::iterator factory = Factories.begin();
1999         Decoder::ListType::iterator end = Factories.end();
2000         while(factory != end)
2001         {
2002             file->clear();
2003             file->seekg(0, std::ios_base::beg);
2004
2005             std::auto_ptr<alureStream> stream((*factory)(file));
2006             if(stream.get() != NULL) return stream.release();
2007
2008             factory++;
2009         }
2010
2011         SetError("Unsupported type");
2012         delete file;
2013     }
2014     else
2015     {
2016         SetError("Failed to open file");
2017         delete file;
2018     }
2019
2020     while(i != InstalledCallbacks.end())
2021     {
2022         std::auto_ptr<alureStream> stream(new customStream(fdata, i->second));
2023         if(stream->IsValid()) return stream.release();
2024         i++;
2025     }
2026
2027     return new nullStream;
2028 }
2029
2030 alureStream *create_stream(const char *fname)
2031 { return get_stream_decoder(fname); }
2032 alureStream *create_stream(const MemDataInfo &memData)
2033 { return get_stream_decoder(memData); }
2034
2035 alureStream *create_stream(ALvoid *userdata, ALenum format, ALuint rate, const UserCallbacks &cb)
2036 { return new customStream(userdata, format, rate, cb); }