src/codec_sndfile.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 #include <assert.h>
  30
  31 #include <istream>
  32
  33 #include <sndfile.h>
  34
  35
  36 #ifdef _WIN32
  37 #define SNDFILE_LIB "libsndfile-1.dll"
  38 #elif defined(__APPLE__)
  39 #define SNDFILE_LIB "libsndfile.1.dylib"
  40 #else
  41 #define SNDFILE_LIB "libsndfile.so.1"
  42 #endif
  43
  44 static void *sndfile_handle;
  45 #define MAKE_FUNC(x) static typeof(x)* p##x
  46 MAKE_FUNC(sf_close);
  47 MAKE_FUNC(sf_open_virtual);
  48 MAKE_FUNC(sf_readf_short);
  49 MAKE_FUNC(sf_seek);
  50 #undef MAKE_FUNC
  51
  52
  53 struct sndStream : public alureStream {
  54 private:
  55     SNDFILE *sndFile;
  56     SF_INFO sndInfo;
  57     ALenum format;
  58
  59 public:
  60     static void Init()
  61     {
  62         sndfile_handle = OpenLib(SNDFILE_LIB);
  63         if(!sndfile_handle) return;
  64
  65         LOAD_FUNC(sndfile_handle, sf_close);
  66         LOAD_FUNC(sndfile_handle, sf_open_virtual);
  67         LOAD_FUNC(sndfile_handle, sf_readf_short);
  68         LOAD_FUNC(sndfile_handle, sf_seek);
  69     }
  70     static void Deinit()
  71     {
  72         if(sndfile_handle)
  73             CloseLib(sndfile_handle);
  74         sndfile_handle = NULL;
  75     }
  76
  77     virtual bool IsValid()
  78     { return sndFile != NULL; }
  79
  80     virtual bool GetFormat(ALenum *fmt, ALuint *frequency, ALuint *blockalign)
  81     {
  82         if(format == AL_NONE)
  83             format = GetSampleFormat(sndInfo.channels, 16, false);
  84         *fmt = format;
  85         *frequency = sndInfo.samplerate;
  86         *blockalign = sndInfo.channels*2;
  87         return true;
  88     }
  89
  90     virtual ALuint GetData(ALubyte *data, ALuint bytes)
  91     {
  92         const ALuint frameSize = 2*sndInfo.channels;
  93         return psf_readf_short(sndFile, (short*)data, bytes/frameSize) * frameSize;
  94     }
  95
  96     virtual bool Rewind()
  97     {
  98         if(psf_seek(sndFile, 0, SEEK_SET) != -1)
  99             return true;
 100
 101         SetError("Seek failed");
 102         return false;
 103     }
 104
 105     sndStream(std::istream *_fstream)
 106       : alureStream(_fstream), sndFile(NULL), format(AL_NONE)
 107     {
 108         memset(&sndInfo, 0, sizeof(sndInfo));
 109
 110         if(!sndfile_handle) return;
 111
 112         static SF_VIRTUAL_IO streamIO = {
 113             get_filelen, seek,
 114             read, write, tell
 115         };
 116         sndFile = psf_open_virtual(&streamIO, SFM_READ, &sndInfo, this);
 117     }
 118
 119     virtual ~sndStream()
 120     {
 121         if(sndFile)
 122             psf_close(sndFile);
 123         sndFile = NULL;
 124     }
 125
 126 private:
 127     // libSndFile iostream callbacks
 128     static sf_count_t get_filelen(void *user_data)
 129     {
 130         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
 131         stream->clear();
 132
 133         std::streampos len = -1;
 134         std::streampos pos = stream->tellg();
 135         if(stream->seekg(0, std::ios_base::end))
 136         {
 137             len = stream->tellg();
 138             stream->seekg(pos);
 139         }
 140
 141         return len;
 142     }
 143
 144     static sf_count_t seek(sf_count_t offset, int whence, void *user_data)
 145     {
 146         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
 147         stream->clear();
 148
 149         if((whence == SEEK_CUR && stream->seekg(offset, std::ios_base::cur)) ||
 150            (whence == SEEK_SET && stream->seekg(offset, std::ios_base::beg)) ||
 151            (whence == SEEK_END && stream->seekg(offset, std::ios_base::end)))
 152             return stream->tellg();
 153
 154         return -1;
 155     }
 156
 157     static sf_count_t read(void *ptr, sf_count_t count, void *user_data)
 158     {
 159         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
 160         stream->clear();
 161         stream->read(static_cast<char*>(ptr), count);
 162         return stream->gcount();
 163     }
 164
 165     static sf_count_t write(const void*, sf_count_t, void*)
 166     { return -1; }
 167
 168     static sf_count_t tell(void *user_data)
 169     {
 170         std::istream *stream = static_cast<sndStream*>(user_data)->fstream;
 171         stream->clear();
 172         return stream->tellg();
 173     }
 174 };
 175 static DecoderDecl<sndStream,0> sndStream_decoder;
 176 Decoder &alure_init_sndfile(void)
 177 { return sndStream_decoder; }