sound_2gs.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 AGI_SOUND_2GS_H
#define AGI_SOUND_2GS_H
 
#include "common/frac.h"
#include "audio/audiostream.h"
 
namespace Agi {
 
// Sample data in SIERRASTANDARD files is in unsigned 8-bit format. A zero
// occurring in the sample data causes the ES5503 wavetable sound chip in
// Apple IIGS to halt the corresponding oscillator immediately. We preprocess
// the sample data by converting it to signed values and the instruments by
// detecting prematurely stopping samples beforehand.
//
// Note: None of the tested SIERRASTANDARD files have zeroes in them. So in
// practice there is no need to check for them. However, they still do exist
// in the sample resources.
#define ZERO_OFFSET 0x80
 
// Apple IIGS envelope update frequency defaults to 100Hz. It can be changed,
// so there might be differences per game, for example.
#define ENVELOPE_COEF 100 / _sampleRate
 
// MIDI player commands
#define MIDI_NOTE_OFF       0x8
#define MIDI_NOTE_ON        0x9
#define MIDI_CONTROLLER     0xB
#define MIDI_PROGRAM_CHANGE 0xC
#define MIDI_PITCH_WHEEL    0xE
 
#define MIDI_STOP_SEQUENCE  0xFC
#define MIDI_TIMER_SYNC     0xF8
 
// Size of the SIERRASTANDARD file (i.e. the wave file i.e. the sample data used by the instruments).
#define SIERRASTANDARD_SIZE 65536
 
// Maximum number of instruments in an Apple IIGS instrument set.
// Chosen empirically based on Apple IIGS AGI game data, increase if needed.
#define MAX_INSTRUMENTS 28
 
// The MIDI player allocates one generator for each note it starts to play.
// Here the maximum number of generators is defined. Feel free to increase
// this if it does not seem to be enough.
#define MAX_GENERATORS 16
 
#define ENVELOPE_SEGMENT_COUNT 8
#define MAX_OSCILLATOR_WAVES 127  // Maximum is one for every MIDI key
 
struct IIgsInstrumentHeader {
    struct {
        frac_t bp;      
        frac_t inc;     
    } env[ENVELOPE_SEGMENT_COUNT];
    uint8 seg;          
    uint8 bend;         
    uint8 vibDepth;     
    uint8 vibSpeed;     
    uint8 waveCount[2]; 
    struct {
        uint8 key;      
        uint32 offset;  
        uint32 size;    
        bool halt;      
        bool loop;      
        bool swap;      
        bool rightChannel;  
        int16 tune;     
    } wave[2][MAX_OSCILLATOR_WAVES];
 
    int8 *wavetableBase; 
 
    bool read(Common::SeekableReadStream &stream, bool ignoreAddr = false);
    bool finalize(int8 *wavetable, uint32 wavetableSize);
};
 
struct IIgsSampleHeader {
    uint16 type;
    uint8  pitch; 
    uint8  unknownByte_Ofs3; // 0x7F in Gold Rush's sound resource 60, 0 in all others.
    uint8  volume; 
    uint8  unknownByte_Ofs5; 
    uint16 instrumentSize; 
    uint16 sampleSize; 
    IIgsInstrumentHeader instrument;
 
    bool read(Common::SeekableReadStream &stream);
    bool finalize(int8 *sampleData);
};
 
class IIgsGenerator {
public:
    IIgsGenerator() : curInstrument(nullptr), key(-1), channel(-1) {
        memset(&osc, 0, sizeof(osc));
        seg = 0;
        a = 0;
        velocity = 0;
    }
 
    const IIgsInstrumentHeader *curInstrument; 
    int key;        
    int velocity;   
    int channel;    
    struct {
        int8 *base; 
        uint size;  
        frac_t p;   
        frac_t pd;  
        bool halt;  
        bool loop;  
        bool swap;  
        bool rightChannel;  
    } osc[2];
    int seg;        
    frac_t a;       
};
 
class IIgsMidi : public AgiSound {
public:
    IIgsMidi(byte resourceNr, byte *data, uint32 length, uint16 type);
    virtual const uint8 *getPtr() { return _ptr; }
    virtual void setPtr(const uint8 *ptr) { _ptr = ptr; }
    virtual void rewind() { _ptr = _data + 2; _ticks = 0; }
protected:
    const uint8 *_ptr; 
public:
    uint _ticks; 
};
 
class IIgsSample : public AgiSound {
public:
    IIgsSample(byte resourceNr, byte *data, uint32 length, uint16 type);
    ~IIgsSample() override { delete[] _sample; }
    uint16 type() override { return _header.type; }
    const IIgsSampleHeader &getHeader() const { return _header; }
    bool isValid() override { return _isValid; }
protected:
    IIgsSampleHeader _header;   
    int8 *_sample;              
    bool _isValid;
};
 
struct IIgsMidiProgramMapping {
    byte midiProgToInst[44]; 
    byte undefinedInst; 
 
    // Maps the MIDI program number to an instrument number
    byte map(uint midiProg) const {
        return midiProg < ARRAYSIZE(midiProgToInst) ? midiProgToInst[midiProg] : undefinedInst;
    }
};
 
struct IIgsInstrumentSetInfo {
    uint byteCount; 
    uint instCount; 
    const char *md5; 
    const char *waveFileMd5; 
    const IIgsMidiProgramMapping *progToInst; 
};
 
struct IIgsExeInfo {
    enum AgiGameID gameid;  
    const char *exePrefix;  
    uint agiVer;            
    uint exeSize;           
    uint instSetStart;      
    const IIgsInstrumentSetInfo *instSet; 
};
 
class IIgsMidiChannel {
public:
    IIgsMidiChannel() : _instrument(NULL), _volume(127) {}
    void setInstrument(const IIgsInstrumentHeader *instrument) { _instrument = instrument; }
    const IIgsInstrumentHeader *getInstrument() { return _instrument; }
    void setVolume(int volume) { _volume = volume; }
    int getVolume() { return _volume; }
private:
    const IIgsInstrumentHeader *_instrument;    
    int _volume;                                
};
 
class SoundGen2GS : public SoundGen, public Audio::AudioStream {
public:
    SoundGen2GS(AgiBase *vm, Audio::Mixer *pMixer);
    ~SoundGen2GS() override;
 
    void play(int resnum) override;
    void stop() override;
 
    int readBuffer(int16 *buffer, const int numSamples) override;
 
    bool isStereo() const override { return true; }
    bool endOfData() const override { return false; }
    int getRate() const override { return _sampleRate; }
 
private:
    // Loader methods
    bool loadInstruments();
    bool loadInstrumentHeaders(const Common::Path &exePath, const IIgsExeInfo &exeInfo);
    bool loadWaveFile(const Common::Path &wavePath, const IIgsExeInfo &exeInfo);
 
    const IIgsExeInfo *getIIgsExeInfo(enum AgiGameID gameid) const;
    void setProgramChangeMapping(const IIgsMidiProgramMapping *mapping);
 
    // Player methods
    void advancePlayer();       
    void advanceMidiPlayer();   
    uint generateOutput();      
 
    void haltGenerators();      
    uint activeGenerators();    
 
    void midiNoteOff(int channel, int note, int velocity);
    void midiNoteOn(int channel, int note, int velocity);
    double midiKeyToFreq(int key, double finetune);
    IIgsInstrumentHeader *getInstrument(uint8 program) { return &_instruments[_progToInst->map(program)]; }
    IIgsGenerator *allocateGenerator() { IIgsGenerator *g = &_generators[_nextGen++]; _nextGen %= 16; return g; }
 
    bool _disableMidi;  
    int _playingSound;  
    bool _playing;      
 
    IIgsGenerator _generators[MAX_GENERATORS];          
    uint _nextGen;                                      
    IIgsMidiChannel _channels[16];                      
    Common::Array<IIgsInstrumentHeader> _instruments;   
    const IIgsMidiProgramMapping *_progToInst;          
    int8 *_wavetable;                                   
    uint _ticks;                                        
    int16 *_out;                                        
    uint _outSize;                                      
 
    static const int kSfxMidiChannel = 15; 
};
 
} // End of namespace Agi
 
#endif /* AGI_SOUND_2GS_H */