sound.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/".
 *
 */

#ifndef BAGEL_BOFLIB_SOUND_H
#define BAGEL_BOFLIB_SOUND_H

#include "audio/mixer.h"
#include "bagel/boflib/stdinc.h"
#include "bagel/boflib/llist.h"
#include "bagel/boflib/object.h"
#include "bagel/boflib/error.h"
#include "bagel/boflib/queue.h"

namespace Bagel {

//
// Wavemix-related constants
//
#define VOLUME_INDEX_MIN 0
#define VOLUME_INDEX_MAX 12
#define VOLUME_INDEX_DEFAULT 10

// Convert to ScummVM scale
#define VOLUME_SVM(x) ((x) * Audio::Mixer::kMaxChannelVolume / VOLUME_INDEX_MAX)
#define SVM_VOLUME(x) (((x) >= 252) ? VOLUME_INDEX_MAX : (x) * VOLUME_INDEX_MAX / 252)

#define SOUND_BUFFERED 0x0001
#define SOUND_ASYNCH 0x0002
#define SOUND_NOTIFY 0x0004
#define SOUND_AUTODELETE 0x0008
#define SOUND_LOOP 0x0010
#define SOUND_WAVE 0x0020
#define SOUND_MIDI 0x0040
#define SOUND_DONT_LOOP_TO_END 0x0080
#define SOUND_QUEUE 0x0100   // With wavemix: play after previous sound finishes
#define SOUND_MIX 0x0200     // Use wavemix to really play asynchronously
#define SOUND_ASAP 0x0400    // Play as soon as a channel is free (maybe now)
#define SOUND_WAIT 0x0800    // For wavemix: Set sound up but don't play it yet
#define SOUND_LOCK 0x1000    // Reserve this channel until user stops it
#define SOUND_PRELOAD 0x2000 // Only works for Resource MAC snd files
#define SOUND_OVEROK 0x4000  // OK to play another sound over this file
#define SND_MEMORY 0x8000    // Raw in-memory sound passed rather than a filename

#define SND_NODEFAULT 0
#define SND_SYNC 0
#define SND_ASYNC SOUND_ASYNCH

#define SOUND_TYPE_WAV 1
#define SOUND_TYPE_XM 2
#define SOUND_TYPE_QT 3
#define SOUND_TYPE_SMF 4

#define FMT_MILLISEC 1 // Time format specifiers.
#define FMT_BPM 2

#define NUM_QUEUES 8

class CBofSound : public CBofError, public CBofObject, public CLList {
public:
    friend class MusicPlayer;

    CBofSound();
    CBofSound(void *pWnd, const char *pszPathName, uint16 wFlags, int nLoops = 1);
    virtual ~CBofSound();
    void addToSoundChain();

    void initialize(const char *pszPathName, uint16 wFlags) {
        initialize(nullptr, pszPathName, wFlags);
    }
    void initialize(void *pWnd, const char *pszPathName, uint16 wFlags);
    void setDrivePath(const char *path) {}
    bool midiLoopPlaySegment(uint32 LoopBegin, uint32 LoopEnd = 0L, uint32 FirstPassBegin = 0L, uint32 TimeFmt = FMT_MILLISEC);
    bool play(uint32 StartOfPlay = 0L, uint32 TimeFmtFlag = FMT_MILLISEC);
    bool pause();
    bool resume();
    void stop();

    CBofSound *getNext() {
        return (CBofSound *)_pNext;
    }
    CBofSound *getPrev() {
        return (CBofSound *)_pPrev;
    }

    char *getFileName() {
        return &_szFileName[0];
    }

    void setFlags(uint16 wFlags) {
        _wFlags = wFlags;
    }
    uint16 getFlags() {
        return _wFlags;
    }

    bool playing() {
        return isPlaying();
    }

    bool isPlaying() {
        return _bPlaying;
    }
    bool isQueued() {
        return _bInQueue;
    }

    bool paused() {
        return _bPaused;
    }

    void setQSlot(int nSlot) {
        _iQSlot = nSlot;
    }
    int getQSlot() {
        return _iQSlot;
    }

    void setVolume(int nVol);
    int getVolume() {
        return _nVol;
    }

    static void initialize();
    static void shutdown();
    static void setVolume(int MidiVolume, int WaveVolume);

    static bool soundPlaying() {
        return (_nCount > 0) ? true : false;
    }

    static bool waveSoundPlaying();
    static bool midiSoundPlaying();
    static bool soundsPlayingNotOver();

    static void setQVol(int nSlot, int nVol);

    ErrorCode playWAV();

    static ErrorCode flushQueue(int nSlot);

    static void resetQVolumes();

    static bool pauseSounds();
    static bool resumeSounds();
    static void stopSounds();
    static void stopWaveSounds();
    static void stopMidiSounds();
    static void clearSounds();
    static void clearWaveSounds();
    static void clearMidiSounds();
    static void waitSounds();
    static void waitWaveSounds();
    static void waitMidiSounds();
    static bool handleMessages();
    static bool bofSleep(uint32 dwTime);
    static void audioTask();
    static bool soundsPlaying();
    static bool MidiAvailable() {
        return true;
    }
    static bool SoundAvailable() {
        return true;
    }
    static bool SoundVolumeAvailable() {
        return true;
    }
    static bool MidiVolumeAvailable() {
        return true;
    }

    static CBofSound *OnMCIStopped(WPARAM wParam, LPARAM lParam) {
        return nullptr;
    }
    static CBofSound *OnMMIOStopped(WPARAM wParam, LPARAM lParam) {
        return nullptr;
    }

private:
    bool loadSound();
    bool releaseSound();

private:
    char _szFileName[MAX_FNAME]; // Path spec for sound file
    int8 _chType = 0;            // Type of sound commands used

    uint16 _wLoops = 0;     // Number of times to loop the sound (0xFFFF means infinite)
    uint16 _wFlags = 0;     // Flags for playing
    bool _bPaused = false;  // Whether its paused
    bool _bPlaying = false; // Whether its playing

    bool _bExtensionsUsed = false;
    uint32 _dwPlayStart = 0;
    uint32 _dwRePlayStart = 0;
    uint32 _dwRePlayEnd = 0;
    Audio::SoundHandle _handle;
    byte *_pFileBuf = nullptr;
    uint32 _iFileSize = 0;

    int _iQSlot = 0;
    bool _bInQueue = false;
    bool _bStarted = false;
    int _nVol = 0;

    void *_pWnd = nullptr; // Parent window for messages

    static char _szDrivePath[MAX_DIRPATH]; // Path spec to drive
    static CBofSound *_pSoundChain;        // First item in chain or nullptr
    static int _nCount;                    // Count of active sounds
    static int _nWavCount;                 // Number of wave sound devices
    static int _nMidiCount;                // Number of midi sound devices
    static void *_pMainWnd;                // Window for message processing
    static bool _bInit;

    static int _nSlotVol[NUM_QUEUES];
    static CQueue *_cQueue[NUM_QUEUES];
};

#define CSound CBofSound

extern bool BofPlaySound(const char *pszSoundFile, uint32 nFlags, int iQSlot = 0);
extern bool BofPlaySoundEx(const char *pszSoundFile, uint32 nFlags, int iQSlot = 0, bool bWait = false);
extern bool MessageBeep(int uType);

#define sndPlaySound BofPlaySound

} // namespace Bagel

#endif