include/main.h

   1 #ifndef MAIN_H
   2 #define MAIN_H
   3
   4 #include "AL/alure.h"
   5 #include "alext.h"
   6
   7 #ifdef HAVE_SYS_TYPES_H
   8 #include <sys/types.h>
   9 #endif
  10 #ifdef HAVE_SYS_WAIT_H
  11 #include <sys/wait.h>
  12 #endif
  13 #ifdef HAVE_SIGNAL_H
  14 #include <signal.h>
  15 #endif
  16
  17 #ifdef HAVE_WINDOWS_H
  18
  19 #include <windows.h>
  20
  21 #else
  22
  23 #ifdef HAVE_DLFCN_H
  24 #include <dlfcn.h>
  25 #endif
  26
  27 #include <assert.h>
  28 #include <pthread.h>
  29 #ifdef HAVE_PTHREAD_NP_H
  30 #include <pthread_np.h>
  31 #endif
  32 #include <errno.h>
  33
  34 typedef pthread_mutex_t CRITICAL_SECTION;
  35 static inline void EnterCriticalSection(CRITICAL_SECTION *cs)
  36 {
  37     int ret;
  38     ret = pthread_mutex_lock(cs);
  39     assert(ret == 0);
  40 }
  41 static inline void LeaveCriticalSection(CRITICAL_SECTION *cs)
  42 {
  43     int ret;
  44     ret = pthread_mutex_unlock(cs);
  45     assert(ret == 0);
  46 }
  47 static inline void InitializeCriticalSection(CRITICAL_SECTION *cs)
  48 {
  49     pthread_mutexattr_t attrib;
  50     int ret;
  51
  52     ret = pthread_mutexattr_init(&attrib);
  53     assert(ret == 0);
  54
  55     ret = pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE);
  56 #ifdef HAVE_PTHREAD_NP_H
  57     if(ret != 0)
  58         ret = pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE);
  59 #endif
  60     assert(ret == 0);
  61     ret = pthread_mutex_init(cs, &attrib);
  62     assert(ret == 0);
  63
  64     pthread_mutexattr_destroy(&attrib);
  65 }
  66 static inline void DeleteCriticalSection(CRITICAL_SECTION *cs)
  67 {
  68     int ret;
  69     ret = pthread_mutex_destroy(cs);
  70     assert(ret == 0);
  71 }
  72
  73 #endif
  74
  75 #include <map>
  76 #include <streambuf>
  77 #include <istream>
  78 #include <list>
  79 #include <algorithm>
  80 #include <vector>
  81 #include <memory>
  82
  83 static const union {
  84     int val;
  85     char b[sizeof(int)];
  86 } endian_test = { 1 };
  87 static const bool LittleEndian = (endian_test.b[0] != 0);
  88 static const bool BigEndian = !LittleEndian;
  89
  90
  91 void *OpenLib(const char *libname);
  92 void CloseLib(void *handle);
  93 #ifndef DYNLOAD
  94 #define LOAD_FUNC(h, x) p##x = x
  95 #else
  96 void *GetLibProc(void *handle, const char *funcname);
  97
  98 template<typename T>
  99 void LoadFunc(void *handle, const char *funcname, T **funcptr)
 100 { *funcptr = reinterpret_cast<T*>(GetLibProc(handle, funcname)); }
 101
 102 #define LOAD_FUNC(h, x) LoadFunc((h), #x, &(p##x));                          \
 103 if(!(p##x))                                                                  \
 104 {                                                                            \
 105     CloseLib((h));                                                           \
 106     (h) = NULL;                                                              \
 107     return;                                                                  \
 108 }
 109 #endif
 110
 111
 112 void SetError(const char *err);
 113 ALuint DetectBlockAlignment(ALenum format);
 114 ALuint DetectCompressionRate(ALenum format);
 115 ALenum GetSampleFormat(ALuint channels, ALuint bits, bool isFloat);
 116
 117 struct UserCallbacks {
 118     void*     (*open_file)(const ALchar*);
 119     void*     (*open_mem)(const ALubyte*,ALuint);
 120     ALboolean (*get_fmt)(void*,ALenum*,ALuint*,ALuint*);
 121     ALuint    (*decode)(void*,ALubyte*,ALuint);
 122     ALboolean (*rewind)(void*);
 123     void      (*close)(void*);
 124 };
 125 extern std::map<ALint,UserCallbacks> InstalledCallbacks;
 126
 127
 128 struct alureStream {
 129     // Local copy of memory data
 130     ALubyte *data;
 131
 132     // Storage when reading chunks
 133     std::vector<ALubyte> dataChunk;
 134
 135     // Abstracted input stream
 136     std::istream *fstream;
 137
 138     virtual bool IsValid() = 0;
 139     virtual bool GetFormat(ALenum*,ALuint*,ALuint*) = 0;
 140     virtual ALuint GetData(ALubyte*,ALuint) = 0;
 141     virtual bool Rewind() = 0;
 142     virtual bool SetOrder(ALuint order)
 143     {
 144         if(!order) return Rewind();
 145         SetError("Invalid order for stream");
 146         return false;
 147     }
 148     virtual bool SetPatchset(const char*)
 149     { return true; }
 150
 151     alureStream(std::istream *_stream)
 152       : data(NULL), fstream(_stream)
 153     { StreamList.push_front(this); }
 154     virtual ~alureStream()
 155     {
 156         delete[] data;
 157         StreamList.erase(std::find(StreamList.begin(), StreamList.end(), this));
 158     }
 159
 160     static void Clear(void)
 161     {
 162         while(StreamList.size() > 0)
 163             alureDestroyStream(*(StreamList.begin()), 0, NULL);
 164     }
 165
 166     static bool Verify(alureStream *stream)
 167     {
 168         ListType::iterator i = std::find(StreamList.begin(), StreamList.end(), stream);
 169         return (i != StreamList.end());
 170     }
 171
 172 private:
 173     typedef std::list<alureStream*> ListType;
 174     static ListType StreamList;
 175 };
 176 void StopStream(alureStream *stream);
 177
 178
 179 struct MemDataInfo {
 180     const ALubyte *Data;
 181     size_t Length;
 182     size_t Pos;
 183
 184     MemDataInfo() : Data(NULL), Length(0), Pos(0)
 185     { }
 186     MemDataInfo(const MemDataInfo &inf) : Data(inf.Data), Length(inf.Length),
 187                                           Pos(inf.Pos)
 188     { }
 189 };
 190
 191 class MemStreamBuf : public std::streambuf {
 192     MemDataInfo memInfo;
 193
 194     virtual int_type underflow();
 195     virtual pos_type seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);
 196     virtual pos_type seekpos(pos_type pos, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);
 197
 198 public:
 199     MemStreamBuf(const MemDataInfo &data)
 200       : memInfo(data)
 201     {
 202         memInfo.Pos /= sizeof(char_type);
 203         memInfo.Length /= sizeof(char_type);
 204     }
 205     virtual ~MemStreamBuf() { }
 206 };
 207
 208 struct UserFuncs {
 209     void* (*open)(const char *filename, ALuint mode);
 210     void (*close)(void *f);
 211     ALsizei (*read)(void *f, ALubyte *buf, ALuint count);
 212     ALsizei (*write)(void *f, const ALubyte *buf, ALuint count);
 213     alureInt64 (*seek)(void *f, alureInt64 offset, int whence);
 214 };
 215 extern UserFuncs Funcs;
 216
 217 class FileStreamBuf : public std::streambuf {
 218     void *usrFile;
 219     UserFuncs fio;
 220
 221     char buffer[1024];
 222
 223     virtual int_type underflow();
 224     virtual pos_type seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);
 225     virtual pos_type seekpos(pos_type pos, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);
 226
 227 public:
 228     bool IsOpen()
 229     { return usrFile != NULL; }
 230
 231     FileStreamBuf(const char *filename, ALint mode)
 232       : usrFile(NULL), fio(Funcs)
 233     { usrFile = fio.open(filename, mode); }
 234     virtual ~FileStreamBuf()
 235     { if(usrFile) fio.close(usrFile); }
 236 };
 237
 238 class InStream : public std::istream {
 239 public:
 240     InStream(const char *filename)
 241       : std::istream(new FileStreamBuf(filename, 0))
 242     {
 243         if(!(static_cast<FileStreamBuf*>(rdbuf())->IsOpen()))
 244             clear(failbit);
 245     }
 246     InStream(const MemDataInfo &memInfo)
 247       : std::istream(new MemStreamBuf(memInfo))
 248     { }
 249     virtual ~InStream()
 250     { delete rdbuf(); }
 251 };
 252
 253
 254 static inline ALuint read_le32(std::istream *file)
 255 {
 256     ALubyte buffer[4];
 257     if(!file->read(reinterpret_cast<char*>(buffer), 4)) return 0;
 258     return buffer[0] | (buffer[1]<<8) | (buffer[2]<<16) | (buffer[3]<<24);
 259 }
 260
 261 static inline ALushort read_le16(std::istream *file)
 262 {
 263     ALubyte buffer[2];
 264     if(!file->read(reinterpret_cast<char*>(buffer), 2)) return 0;
 265     return buffer[0] | (buffer[1]<<8);
 266 }
 267
 268 static inline ALuint read_be32(std::istream *file)
 269 {
 270     ALubyte buffer[4];
 271     if(!file->read(reinterpret_cast<char*>(buffer), 4)) return 0;
 272     return (buffer[0]<<24) | (buffer[1]<<16) | (buffer[2]<<8) | buffer[3];
 273 }
 274
 275 static inline ALushort read_be16(std::istream *file)
 276 {
 277     ALubyte buffer[2];
 278     if(!file->read(reinterpret_cast<char*>(buffer), 2)) return 0;
 279     return (buffer[0]<<8) | buffer[1];
 280 }
 281
 282 static inline ALuint read_be80extended(std::istream *file)
 283 {
 284     ALubyte buffer[10];
 285     if(!file->read(reinterpret_cast<char*>(buffer), 10)) return 0;
 286     ALuint mantissa, last = 0;
 287     ALubyte exp = buffer[1];
 288     exp = 30 - exp;
 289     mantissa = (buffer[2]<<24) | (buffer[3]<<16) | (buffer[4]<<8) | buffer[5];
 290     while (exp--)
 291     {
 292         last = mantissa;
 293         mantissa >>= 1;
 294     }
 295     if((last&1)) mantissa++;
 296     return mantissa;
 297 }
 298
 299
 300 extern CRITICAL_SECTION cs_StreamPlay;
 301
 302 alureStream *create_stream(const char *fname);
 303 alureStream *create_stream(const MemDataInfo &memData);
 304 alureStream *create_stream(ALvoid *userdata, ALenum format, ALuint rate, const UserCallbacks &cb);
 305
 306 template <typename T>
 307 const T& clamp(const T& val, const T& min, const T& max)
 308 { return std::max(std::min(val, max), min); }
 309
 310 template <typename T>
 311 void swap(T &val1, T &val2)
 312 {
 313     val1 ^= val2;
 314     val2 ^= val1;
 315     val1 ^= val2;
 316 }
 317
 318
 319 struct Decoder {
 320     typedef std::auto_ptr<alureStream>(*FactoryType)(std::istream*);
 321     typedef std::vector<FactoryType> ListType;
 322
 323     static const ListType& GetList();
 324
 325 protected:
 326     static ListType& AddList(FactoryType func);
 327 };
 328
 329 template<typename T>
 330 struct DecoderDecl : public Decoder {
 331     DecoderDecl()
 332     {
 333         T::Init();
 334         AddList(Factory);
 335     }
 336     ~DecoderDecl()
 337     {
 338         ListType &list = AddList(NULL);
 339         list.erase(std::find(list.begin(), list.end(), Factory));
 340         T::Deinit();
 341     }
 342
 343 private:
 344     static std::auto_ptr<alureStream> Factory(std::istream *file)
 345     {
 346         std::auto_ptr<alureStream> ret(new T(file));
 347         if(ret->IsValid()) return ret;
 348         return std::auto_ptr<alureStream>();
 349     }
 350 };
 351
 352 #endif // MAIN_H