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 DRACI_SOUND_H
#define DRACI_SOUND_H

#include "common/str.h"
#include "common/file.h"
#include "common/list.h"
#include "audio/mixer.h"

namespace Common {
class Archive;
class SeekableReadStream;
}

namespace Draci {

enum SoundFormat { RAW, RAW80, MP3, OGG, FLAC };    // RAW80 means skip the first 80 bytes

struct SoundSample {
    uint _offset;       // For internal use of LegacySoundArchive
    uint _length;

    uint _frequency;    // Only when _format == RAW or RAW80
    SoundFormat _format;

    byte *_data;        // At most one of these two pointer can be non-NULL
    Common::SeekableReadStream* _stream;

    SoundSample() : _offset(0), _length(0), _frequency(0), _format(RAW), _data(NULL), _stream(NULL) { }
    // The standard copy constructor is good enough, since we only store numbers and pointers.
    // Don't call close() automaticall in the destructor, otherwise copying causes SIGSEGV.
    void close() {
        delete[] _data;
        delete _stream;
        _data = NULL;
        _stream = NULL;
    }
};

class SoundArchive {
public:
    SoundArchive() { }
    virtual ~SoundArchive() { }

    virtual uint size() const = 0;

    virtual bool isOpen() const = 0;

    virtual void clearCache() = 0;

    virtual SoundSample *getSample(int i, uint freq) = 0;
};

class LegacySoundArchive : public SoundArchive {
public:
    LegacySoundArchive(const char *path, uint defaultFreq) :
    _path(NULL), _samples(NULL), _sampleCount(0), _defaultFreq(defaultFreq), _opened(false), _f(NULL) {
        openArchive(path);
    }
    ~LegacySoundArchive() override { closeArchive(); }

    void openArchive(const char *path);
    void closeArchive();

    uint size() const override { return _sampleCount; }
    bool isOpen() const override { return _opened; }

    void clearCache() override;
    SoundSample *getSample(int i, uint freq) override;

private:
    const char *_path;    
    SoundSample *_samples;          
    uint _sampleCount;         
    uint _defaultFreq;  
    bool _opened;            
    Common::File *_f;   
};

class ZipSoundArchive : public SoundArchive {
public:
    ZipSoundArchive() : _archive(NULL), _path(NULL), _extension(NULL), _format(RAW), _sampleCount(0), _defaultFreq(0), _cache() { }
    ~ZipSoundArchive() override { closeArchive(); }

    void openArchive(const char *path, const char *extension, SoundFormat format, int raw_frequency = 0);
    void closeArchive();

    uint size() const override { return _sampleCount; }
    bool isOpen() const override { return _archive != NULL; }

    void clearCache() override;
    SoundSample *getSample(int i, uint freq) override;

private:
    Common::Archive *_archive;
    const char *_path;
    const char *_extension;
    SoundFormat _format;
    uint _sampleCount;
    uint _defaultFreq;

    // Since we typically play at most 1 dubbing at a time, we could get
    // away with having just 1 record allocated and reusing it each time.
    // However, that would be thread-unsafe if two samples were played.
    // Although the player does not do that, it is nicer to allow for it in
    // principle.  For each dubbed sentence, we allocate a new record in
    // the following link-list, which is cleared during each location
    // change.  The dubbed samples themselves are manually deallocated
    // after they end.
    Common::List<SoundSample> _cache;
};

#define SOUND_HANDLES 10

enum sndHandleType {
    kFreeHandle,
    kEffectHandle,
    kVoiceHandle
};

struct SndHandle {
    Audio::SoundHandle handle;
    sndHandleType type;
};

// Taken from engines/saga/sound.h and simplified (in particular, removed
// decompression until we support compressed files too).
class Sound {
public:

    Sound(Audio::Mixer *mixer);
    ~Sound() {}

    uint playSound(const SoundSample *buffer, int volume, bool loop);
    void pauseSound();
    void resumeSound();
    void stopSound();
    bool isMutedSound() const { return _muteSound; }

    uint playVoice(const SoundSample *buffer);
    void pauseVoice();
    void resumeVoice();
    void stopVoice();
    bool isMutedVoice() const { return _muteVoice; }

    void stopAll() { stopVoice(); stopSound(); }

    void setVolume();

    bool showSubtitles() const { return _showSubtitles; }
    int talkSpeed() const { return _talkSpeed; }

 private:
    // Returns the length of the sound sample in miliseconds.
    uint playSoundBuffer(Audio::SoundHandle *handle, const SoundSample &buffer, int volume,
                sndHandleType handleType, bool loop);

    SndHandle *getHandle();

    Audio::Mixer *_mixer;

    bool _muteSound;
    bool _muteVoice;
    bool _showSubtitles;
    int _talkSpeed;

    SndHandle _handles[SOUND_HANDLES];
};

} // End of namespace Draci

#endif // DRACI_SOUND_H