adlib.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/>.
 *
 *
 * This file is dual-licensed.
 * In addition to the GPLv3 license mentioned above, this code is also
 * licensed under LGPL 2.1. See LICENSES/COPYING.LGPL file for the
 * full text of the license.
 *
 */
 
#ifndef GOB_SOUND_ADLIB_H
#define GOB_SOUND_ADLIB_H
 
#include "common/mutex.h"
 
#include "audio/mixer.h"
 
namespace OPL {
    class OPL;
}
 
namespace Gob {
 
class AdLib {
public:
    AdLib(int callbackFrequency);
    virtual ~AdLib();
 
    bool isPlaying() const;    
    int32 getRepeating() const; 
 
    void setRepeating(int32 repCount);
 
    void startPlay();
    void stopPlay();
    void syncVolume();
 
protected:
    enum kVoice {
        kVoiceMelody0   =  0,
        kVoiceMelody1   =  1,
        kVoiceMelody2   =  2,
        kVoiceMelody3   =  3,
        kVoiceMelody4   =  4,
        kVoiceMelody5   =  5,
        kVoiceMelody6   =  6, // Only available in melody mode.
        kVoiceMelody7   =  7, // Only available in melody mode.
        kVoiceMelody8   =  8, // Only available in melody mode.
        kVoiceBaseDrum  =  6, // Only available in percussion mode.
        kVoiceSnareDrum =  7, // Only available in percussion mode.
        kVoiceTom       =  8, // Only available in percussion mode.
        kVoiceCymbal    =  9, // Only available in percussion mode.
        kVoiceHihat     = 10  // Only available in percussion mode.
    };
 
    enum kParam {
        kParamKeyScaleLevel =  0,
        kParamFreqMulti     =  1,
        kParamFeedback      =  2,
        kParamAttack        =  3,
        kParamSustain       =  4,
        kParamSustaining    =  5,
        kParamDecay         =  6,
        kParamRelease       =  7,
        kParamLevel         =  8,
        kParamAM            =  9,
        kParamVib           = 10,
        kParamKeyScaleRate  = 11,
        kParamFM            = 12,
        kParamWaveSelect    = 13
    };
 
    static const int kOperatorCount  = 18; 
    static const int kParamCount     = 14; 
    static const int kPitchStepCount = 25; 
    static const int kOctaveCount    =  8; 
    static const int kHalfToneCount  = 12; 
 
    static const int kOperatorsPerVoice = 2; 
 
    static const int kMelodyVoiceCount     =  9; 
    static const int kPercussionVoiceCount =  5; 
    static const int kMaxVoiceCount        = 11; 
 
    static const int kNoteCount = kHalfToneCount * kOctaveCount;
 
    static const int kMaxVolume = 0x007F;
    static const int kMaxPitch  = 0x3FFF;
    static const int kMidPitch  = 0x2000;
 
    static const int kStandardMidC = 60; 
    static const int kOPLMidC      = 48; 
 
 
 
    void writeOPL(byte reg, byte val);
 
    void end(bool killRepeat = false);
 
    virtual uint32 pollMusic(bool first) = 0;
 
    virtual void rewind() = 0;
 
    bool isPercussionMode() const;
 
    void setPercussionMode(bool percussion);
 
    void enableWaveSelect(bool enable);
 
    void setPitchRange(uint8 range);
 
    void setTremoloDepth(bool tremoloDepth);
 
    void setVibratoDepth(bool vibratoDepth);
 
    void setKeySplit(bool keySplit);
 
    void setVoiceTimbre(uint8 voice, const uint16 *params);
 
    void setVoiceVolume(uint8 voice, uint8 volume);
 
    void bendVoicePitch(uint8 voice, uint16 pitchBend);
 
    void noteOn(uint8 voice, uint8 note);
 
    void noteOff(uint8 voice);
 
    void setTimerFrequency(int timerFrequency);
 
private:
    static const uint8 kVolumeTable[Audio::Mixer::kMaxMixerVolume + 1];
 
    static const uint8 kOperatorType  [kOperatorCount];
    static const uint8 kOperatorOffset[kOperatorCount];
    static const uint8 kOperatorVoice [kOperatorCount];
 
    static const uint8 kVoiceMelodyOperator    [kOperatorsPerVoice][kMelodyVoiceCount];
    static const uint8 kVoicePercussionOperator[kOperatorsPerVoice][kPercussionVoiceCount];
 
    static const byte kPercussionMasks[kPercussionVoiceCount];
 
    static const uint16 kPianoParams    [kOperatorsPerVoice][kParamCount];
    static const uint16 kBaseDrumParams [kOperatorsPerVoice][kParamCount];
 
    static const uint16 kSnareDrumParams[kParamCount];
    static const uint16 kTomParams      [kParamCount];
    static const uint16 kCymbalParams   [kParamCount];
    static const uint16 kHihatParams    [kParamCount];
 
 
    OPL::OPL *_opl;
 
    Common::Mutex _mutex;
 
    int _volume;
 
    uint32 _toPoll;
 
    int32 _repCount;
 
    bool _first;
    bool _playing;
    bool _ended;
 
    bool _tremoloDepth;
    bool _vibratoDepth;
    bool _keySplit;
 
    bool _enableWaveSelect;
 
    bool _percussionMode;
    byte _percussionBits;
 
    uint8  _pitchRange;
    uint16 _pitchRangeStep;
 
    uint8 _voiceNote[kMaxVoiceCount]; // Last note of each voice
    uint8 _voiceOn  [kMaxVoiceCount]; // Whether each voice is currently on
 
    uint8 _operatorVolume[kOperatorCount]; // Volume of each operator
 
    byte _operatorParams[kOperatorCount][kParamCount]; // All operator parameters
 
    uint16  _freqs[kPitchStepCount][kHalfToneCount];
    uint16 *_freqPtr[kMaxVoiceCount];
 
    int _halfToneOffset[kMaxVoiceCount];
 
 
    void createOPL();
    void initOPL();
 
    void reset();
    void allOff();
 
    // Write global parameters into the OPL
    void writeTremoloVibratoDepthPercMode();
    void writeKeySplit();
 
    // Write operator parameters into the OPL
    void writeWaveSelect(uint8 oper);
    void writeTremoloVibratoSustainingKeyScaleRateFreqMulti(uint8 oper);
    void writeSustainRelease(uint8 oper);
    void writeAttackDecay(uint8 oper);
    void writeFeedbackFM(uint8 oper);
    void writeKeyScaleLevelVolume(uint8 oper);
    void writeAllParams(uint8 oper);
 
    void initOperatorParams();
    void initOperatorVolumes();
    void setOperatorParams(uint8 oper, const uint16 *params, uint8 wave);
 
    void voiceOff(uint8 voice);
 
    void initFreqs();
    void setFreqs(uint16 *freqs, int32 num, int32 denom);
    int32 calcFreq(int32 deltaDemiToneNum, int32 deltaDemiToneDenom);
    void resetFreqs();
 
    void changePitch(uint8 voice, uint16 pitchBend);
 
    void setFreq(uint8 voice, uint16 note, bool on);
 
    void onTimer();
};
 
} // End of namespace Gob
 
#endif // GOB_SOUND_ADLIB_H