core/code/audio/wavfile.cpp

   1 /*
   2     fegdk: FE Game Development Kit
   3     Copyright (C) 2001-2008 Alexey "waker" Yakovenko
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public
  16     License along with this library; if not, write to the Free
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19     Alexander Maltsev
  20     keltar@users.sourceforge.net
  21 */
  22
  23 #include "pch.h"
  24 #include "wavfile.h"
  25 #include "f_helpers.h"
  26 #include "basesounddriver.h"
  27 #include "f_engine.h"
  28
  29 namespace fe
  30 {
  31
  32         wavFeeder::wavFeeder (wavFile *file)
  33         {
  34                 mpFile = file;
  35         }
  36
  37         void wavFeeder::call (void *data)
  38         {
  39                 mpFile->update ();
  40         }
  41
  42         wavFile::wavFile (const char *name)
  43                 : baseSound (name)
  44                 , mFeeder (this)
  45         {
  46                 mName = name;
  47
  48                 mpBuffer = NULL;
  49                 mpPCMOut = NULL;
  50                 mbEOF = false;
  51                 mCurrentSection = -1;
  52                 mpFile = NULL;
  53                 mHaveBytes = 0;
  54                 mbLooping = false;
  55                 mbPaused = false;
  56                 mVolume = 0;
  57                 mbPlaying = false;
  58
  59                 mpFile = g_engine->getFileSystem ()->openFile (mName, FS_MODE_READ);
  60
  61                 fprintf (stderr, "loading %s from disk....\n", this->name ());
  62
  63                 if (mpFile)
  64                 {
  65                         // read WAV header
  66                         if (!mpFile->read (&mWavHeader, sizeof (wavHeader)))
  67                         {
  68                                 fprintf (stderr, "WAV header not found in %s\n", this->name ());
  69                                 mpFile->close ();
  70                                 mpFile = NULL;
  71                                 return;
  72                         }
  73
  74                         // checking
  75                         // TODO implement it
  76
  77                         if (mWavHeader.size < 2000000)
  78                         {
  79                                 mbStreaming = false;
  80                                 mpBuffer = g_engine->getSoundDriver ()->createBuffer (mWavHeader.samplesPerSecond, 16, mWavHeader.channels == 1 ? false : true, mWavHeader.dataSize, false);
  81                                 mpPCMOut = new char[mWavHeader.dataSize];
  82                                 mHaveBytes = mpFile->read (mpPCMOut, mWavHeader.dataSize);
  83                                 mpBuffer->write (mpPCMOut, mWavHeader.dataSize, (mWavHeader.channels == 1) ? baseSoundDriver::fmt_mono16 : baseSoundDriver::fmt_stereo16, mWavHeader.samplesPerSecond);
  84                                 delete[] mpPCMOut;
  85                                 mpPCMOut = NULL;
  86
  87                                 if (mpFile)
  88                                 {
  89                                         mpFile->close ();
  90                                         mpFile = NULL;
  91                                 }
  92                         }
  93                         else
  94                         {
  95                                 mbStreaming = true;
  96                                 mpPCMOut = new char[buffer_size * 2];
  97                                 mpBuffer = g_engine->getSoundDriver ()->createBuffer (mWavHeader.samplesPerSecond, 16, mWavHeader.channels == 1 ? false : true, buffer_size, true);
  98                                 mpBuffer->setFeeder (&mFeeder);
  99                         }
 100                 }
 101         }
 102
 103         wavFile::~wavFile (void)
 104         {
 105                 stop ();
 106                 if (mpBuffer)
 107                 {
 108                         mpBuffer->stop ();
 109                         mpBuffer->release ();
 110                         mpBuffer = NULL;
 111                 }
 112                 if (mpPCMOut)
 113                 {
 114                         delete[] mpPCMOut;
 115                         mpPCMOut = NULL;
 116                 }
 117
 118                 if (mpFile)
 119                 {
 120                         mpFile->close ();
 121                         mpFile = NULL;
 122                 }
 123         }
 124
 125         void wavFile::play (bool looping)
 126         {
 127                 if (!mpBuffer)
 128                         return;
 129
 130                 mbLooping = looping;
 131                 if (mbStreaming)
 132                 {
 133                         if (isPlaying ())
 134                         {
 135                                 // rewind & unpause
 136                                 mpFile->seek (sizeof (wavHeader), SEEK_SET);
 137                                 mbEOF = false;
 138                         }
 139                         else
 140                                 open ();
 141                 }
 142                 else
 143                         mpBuffer->setLooping (mbLooping);
 144
 145                 mpBuffer->play ();
 146                 mbPlaying = true;
 147         }
 148
 149         void wavFile::stop (void)
 150         {
 151                 if (mpBuffer)
 152                 {
 153                         mpBuffer->stop ();
 154                         mbPlaying = false;
 155                 }
 156                 if (mpFile)
 157                 {
 158                         mpFile->close ();
 159                         mpFile = NULL;
 160                 }
 161
 162                 mHaveBytes = 0;
 163         }
 164
 165         void wavFile::pause (bool onoff)
 166         {
 167                 if (mpBuffer)
 168                 {
 169                         mpBuffer->pause (onoff);
 170                 }
 171                 mbPlaying = !onoff;
 172         }
 173
 174         void wavFile::setVolume (float volume)
 175         {
 176                 mVolume = volume;
 177                 if (mpBuffer)
 178                         mpBuffer->setVolume (volume);
 179         }
 180
 181         bool wavFile::isPlaying (void) const
 182         {
 183                 return mbPlaying;
 184         }
 185
 186         int wavFile::getChannelsCount (void) const
 187         {
 188                 return mpBuffer->getChannelsCount ();
 189         }
 190
 191         void wavFile::open ()
 192         {
 193                 mbEOF = false;
 194                 mCurrentSection = -1;
 195                 mHaveBytes = 0;
 196                 mpFile = g_engine->getFileSystem ()->openFile (mName, FS_MODE_READ);
 197                 mpFile->read (&mWavHeader, sizeof (wavHeader));
 198                 mpBuffer->setFeeder (&mFeeder);
 199         }
 200
 201         void wavFile::update (void)
 202         {
 203                 if (!mpFile)
 204                         return;
 205                 for (;;)
 206                 {
 207                         if (!mpBuffer)
 208                                 break;
 209
 210                         if (mbPaused)
 211                                 break;
 212
 213                         while (!mbEOF && mHaveBytes < buffer_size)
 214                         {
 215                                 // read wav
 216                                 long ret = mpFile->read (mpPCMOut + mHaveBytes, buffer_size - mHaveBytes);
 217                                 if (ret == 0)
 218                                 {
 219                                         if (mbLooping)
 220                                         {
 221                                                 // rewind
 222                                                 mpFile->seek (sizeof (wavHeader), SEEK_SET);
 223                                                 mbEOF = false;
 224                                         }
 225                                         else
 226                                                 mbEOF = true;
 227                                 }
 228                                 else if (ret < 0)
 229                                 {
 230                                         // error
 231                                 }
 232                                 else
 233                                 {
 234                                         mHaveBytes += ret;
 235                                 }
 236                         }
 237
 238                         if (mbEOF && !mbLooping)
 239                         {
 240                                 stop ();
 241                                 return;
 242                         }
 243
 244
 245                         if (mHaveBytes || mbEOF)
 246                         {
 247         /*                      if (mEventStop)
 248                                 {
 249                                         DWORD signStop = WaitForSingleObject (mEventStop, 10);
 250                                         if (signStop == WAIT_OBJECT_0 && mbEOF && !mHaveBytes)
 251                                         {
 252                                                 stop ();
 253                                                 break;
 254                                         }
 255                                 }*/
 256
 257                                 if (mbEOF && !mHaveBytes)
 258                                 {
 259                                         break;
 260                                 }
 261
 262                                 bool updated = false;
 263
 264                                 if (mHaveBytes < buffer_size)
 265                                 {
 266                                         memset (mpPCMOut + buffer_size, 0, buffer_size - mHaveBytes);
 267                                         mHaveBytes = buffer_size;
 268                                 }
 269                                 int copybytes = min ((int)buffer_size, (int)mHaveBytes);
 270
 271                                 mpBuffer->write (mpPCMOut, copybytes, baseSoundDriver::fmt_stereo16, mWavHeader.samplesPerSecond);
 272
 273                                 updated = true;
 274
 275                                 if (updated && mHaveBytes > buffer_size)
 276                                 {
 277                                         memmove (mpPCMOut, &mpPCMOut[buffer_size], mHaveBytes - buffer_size);
 278                                         mHaveBytes -= buffer_size;
 279                                 }
 280                                 else if (updated)
 281                                         mHaveBytes = 0;
 282                         }
 283                         break;
 284                 }
 285         }
 286
 287         smartPtr <baseSound> wavFile::duplicate (void)
 288         {
 289                 return new wavFile (name ());
 290         }
 291
 292 }
 293