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