Ticket #8610: madmoose-axe-premix.diff

File madmoose-axe-premix.diff, 14.3 KB (added by SF/madm00se, 17 years ago)

Patch to remove premix channel

  • sound/mixer.cpp

     
    108108
    109109        _handleSeed = 0;
    110110
    111         _premixChannel = 0;
    112111        int i = 0;
    113112
    114113        for (i = 0; i < ARRAYSIZE(_volumeForSoundType); i++)
    … …  
    122121
    123122Mixer::~Mixer() {
    124123        stopAll(true);
    125 
    126         delete _premixChannel;
    127         _premixChannel = 0;
    128124}
    129125
    130126uint Mixer::getOutputRate() const {
    131127        return (uint)_syst->getOutputSampleRate();
    132128}
    133129
    134 void Mixer::setupPremix(AudioStream *stream, SoundType type) {
    135         Common::StackLock lock(_mutex);
    136 
    137         delete _premixChannel;
    138         _premixChannel = 0;
    139 
    140         if (stream == 0)
    141                 return;
    142 
    143         // Create the channel
    144         _premixChannel = new Channel(this, type, stream, false);
    145 }
    146 
    147130void Mixer::insertChannel(SoundHandle *handle, Channel *chan) {
    148131
    149132        int index = -1;
    … …  
    246229        //  zero the buf
    247230        memset(buf, 0, 2 * len * sizeof(int16));
    248231
    249         if (_premixChannel && !_premixChannel->isPaused())
    250                 _premixChannel->mix(buf, len);
    251 
    252         // now mix all channels
     232        // mix all channels
    253233        for (int i = 0; i != NUM_CHANNELS; i++)
    254234                if (_channels[i]) {
    255235                        if (_channels[i]->isFinished()) {
    … …  
    278258                        }
    279259                }
    280260        }
    281        
    282         // Note: the _premixChannel is *not* affected by stopAll!
    283261}
    284262
    285263void Mixer::stopID(int id) {
    … …  
    341319                        _channels[i]->pause(paused);
    342320                }
    343321        }
    344 
    345         // Unlike stopAll, we also pause the premix channel, if present.
    346         if (_premixChannel)
    347                 _premixChannel->pause(paused);
    348322}
    349323
    350324void Mixer::pauseID(int id, bool paused) {

  • sound/softsynth/emumidi.h

     
    3030protected:
    3131        bool _isOpen;
    3232        Audio::Mixer *_mixer;
     33        Audio::SoundHandle _mixerSoundHandle;
    3334
    3435private:
    3536        Common::TimerManager::TimerProc _timerProc;

  • sound/softsynth/ym2612.cpp

     
    741741
    742742        MidiDriver_Emulated::open();
    743743
    744         _mixer->setupPremix(this);
     744        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_mixerSoundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    745745        return 0;
    746746}
    747747
    … …  
    750750                return;
    751751        _isOpen = false;
    752752
    753         // Detach the premix callback handler
    754         _mixer->setupPremix(0);
     753        _mixer->stopHandle(_mixerSoundHandle);
    755754}
    756755
    757756void MidiDriver_YM2612::send(uint32 b) {

  • sound/softsynth/adlib.cpp

     
    847847        adlib_write(0xBD, 0x00);
    848848        create_lookup_table();
    849849
    850         _mixer->setupPremix(this);
     850        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_mixerSoundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    851851
    852852        return 0;
    853853}
    … …  
    857857                return;
    858858        _isOpen = false;
    859859
    860         // Detach the premix callback handler
    861         _mixer->setupPremix(0);
     860        _mixer->stopHandle(_mixerSoundHandle);
    862861
    863862        uint i;
    864863        for (i = 0; i < ARRAYSIZE(_voices); ++i) {

  • sound/mixer.h

     
    102102        OSystem *_syst;
    103103        Common::Mutex _mutex;
    104104
    105         Channel *_premixChannel;
    106 
    107105        int _volumeForSoundType[4];
    108106
    109107        uint32 _handleSeed;
    … …  
    130128
    131129
    132130        /**
    133          * Set the premix stream. This is mainly used for the adlib music, but
    134          * is not limited to it. The premix stream is invoked by the mixer whenever
    135          * it needs to generate any data, before any other mixing takes place.
    136          */
    137         void setupPremix(AudioStream *stream, SoundType type = kPlainSoundType);
    138 
    139 
    140 
    141         /**
    142131         * Start playing the given raw sound data.
    143132         * Internally, this simply creates an audio input stream wrapping the data
    144133         * (using the makeLinearInputStream factory function), which is then
    … …  
    201190
    202191
    203192        /**
    204          * Pause/unpause all sounds, including all regular channels and the
    205          * premix channel.
     193         * Pause/unpause all sounds, including all regular and permanent
     194         * channels
    206195         *
    207196         * @param paused true to pause everything, false to unpause
    208197         */

  • engines/sword1/music.cpp

     
    255255        _converter[0] = NULL;
    256256        _converter[1] = NULL;
    257257        _volumeL = _volumeR = 192;
    258         _mixer->setupPremix(this);
     258        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    259259}
    260260
    261261Music::~Music() {
    262         _mixer->setupPremix(0);
     262        _mixer->stopHandle(_soundHandle);
    263263        delete _converter[0];
    264264        delete _converter[1];
    265265}

  • engines/sword1/music.h

     
    2727#include "common/mutex.h"
    2828#include "common/file.h"
    2929#include "sound/audiostream.h"
     30#include "sound/mixer.h"
    3031#include "sound/rate.h"
    3132
    32 namespace Audio {
    33         class Mixer;
    34 }
    35 
    3633namespace Sword1 {
    3734
    3835#define TOTAL_TUNES 270
    … …  
    108105        MusicHandle _handles[2];
    109106        Audio::RateConverter *_converter[2];
    110107        Audio::Mixer *_mixer;
     108        Audio::SoundHandle _soundHandle;
    111109        uint32 _sampleRate;
    112110        Common::Mutex _mutex;
    113111

  • engines/sword2/sound.h

     
    176176
    177177        Common::Mutex _mutex;
    178178
     179        Audio::SoundHandle _mixerSoundHandle;
    179180        Audio::SoundHandle _leadInHandle;
    180181        Audio::SoundHandle _leadOutHandle;
    181182

  • engines/sword2/sound.cpp

     
    8383        _mixBuffer = NULL;
    8484        _mixBufferLen = 0;
    8585
    86         _vm->_mixer->setupPremix(this, Audio::Mixer::kMusicSoundType);
     86        _vm->_mixer->playInputStream(Audio::Mixer::kMusicSoundType, &_mixerSoundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    8787}
    8888
    8989Sound::~Sound() {
    90         _vm->_mixer->setupPremix(0);
     90        _vm->_mixer->stopHandle(_mixerSoundHandle);
    9191
    9292        clearFxQueue(true);
    9393        stopMusic(true);

  • engines/scumm/player_mod.h

     
    2626
    2727#include "scumm/scumm.h"
    2828#include "sound/audiostream.h"
     29#include "sound/mixer.h"
    2930
    3031namespace Audio {
    3132        class RateConverter;
    … …  
    7778        };
    7879
    7980        Audio::Mixer *_mixer;
     81        Audio::SoundHandle _soundHandle;
    8082
    8183        uint32 _mixamt;
    8284        uint32 _mixpos;

  • engines/scumm/player_nes.h

     
    2727#include "common/scummsys.h"
    2828#include "scumm/music.h"
    2929#include "sound/audiostream.h"
     30#include "sound/mixer.h"
    3031
    31 namespace Audio {
    32         class Mixer;
    33 }
    34 
    3532namespace Scumm {
    3633
    3734class ScummEngine;
    … …  
    8077
    8178        ScummEngine *_vm;
    8279        Audio::Mixer *_mixer;
     80        Audio::SoundHandle _soundHandle;
    8381        APUe::APU *_apu;
    8482        int _sample_rate;
    8583        int _samples_per_frame;

  • engines/scumm/player_v2.h

     
    2828#include "common/mutex.h"
    2929#include "scumm/music.h"
    3030#include "sound/audiostream.h"
     31#include "sound/mixer.h"
    3132
    32 namespace Audio {
    33         class Mixer;
    34 }
    35 
    3633namespace Scumm {
    3734
    3835class ScummEngine;
    … …  
    9693protected:
    9794        bool _isV3Game;
    9895        Audio::Mixer *_mixer;
     96        Audio::SoundHandle _soundHandle;
    9997        ScummEngine *_vm;
    10098
    10199        bool _pcjr;

  • engines/scumm/player_mod.cpp

     
    4646        _playproc = NULL;
    4747        _playparam = NULL;
    4848
    49         _mixer->setupPremix(this);
     49        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    5050}
    5151
    5252Player_MOD::~Player_MOD() {
    53         // Detach the premix callback handler
    54         _mixer->setupPremix(0);
     53        _mixer->stopHandle(_soundHandle);
    5554        for (int i = 0; i < MOD_MAXCHANS; i++) {
    5655                if (!_channels[i].id)
    5756                        continue;

  • engines/scumm/player_nes.cpp

     
    620620
    621621        APU_writeControl(0);
    622622
    623         _mixer->setupPremix(this);
     623        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    624624}
    625625
    626626Player_NES::~Player_NES() {
    627         _mixer->setupPremix(0);
     627        _mixer->stopHandle(_soundHandle);
    628628        delete _apu;
    629629}
    630630

  • engines/scumm/player_v2.cpp

     
    375375        set_pcjr(pcjr);
    376376        setMusicVolume(255);
    377377
    378         _mixer->setupPremix(this);
     378        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    379379}
    380380
    381381Player_V2::~Player_V2() {
    382382        mutex_up();
    383         // Detach the premix callback handler
    384         _mixer->setupPremix(0);
     383        _mixer->stopHandle(_soundHandle);
    385384        mutex_down();
    386385}
    387386

  • engines/agi/sound.h

     
    2626#define AGI_SOUND_H
    2727
    2828#include "sound/audiostream.h"
     29#include "sound/mixer.h"
    2930
    30 namespace Audio {
    31 class Mixer;
    32 } // End of namespace Audio
    33 
    3431namespace Agi {
    3532
    3633#define BUFFER_SIZE     410
    … …  
    128125
    129126private:
    130127        Audio::Mixer *_mixer;
     128        Audio::SoundHandle _soundHandle;
    131129        uint32 _sampleRate;
    132130
    133131        void premixerCall(int16 *buf, uint len);

  • engines/agi/sound.cpp

     
    324324        /*loadInstruments("demo.sys"); */
    325325#endif
    326326
    327         _mixer->setupPremix(this);
     327        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    328328
    329329        return r;
    330330}
    331331
    332332void SoundMgr::deinitSound() {
    333333        debugC(3, kDebugLevelSound, "()");
    334         _mixer->setupPremix(NULL);
     334        _mixer->stopHandle(_soundHandle);
    335335        free(sndBuffer);
    336336}
    337337

  • engines/kyra/sound_adlib.cpp

     
    406406
    407407        Common::Mutex _mutex;
    408408        Audio::Mixer *_mixer;
     409        Audio::SoundHandle _soundHandle;
    409410
    410411        bool _v2;
    411412
    … …  
    445446
    446447        _tablePtr1 = _tablePtr2 = 0;
    447448
    448         _mixer->setupPremix(this);
     449        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    449450
    450451        _samplesPerCallback = getRate() / CALLBACKS_PER_SECOND;
    451452        _samplesPerCallbackRemainder = getRate() % CALLBACKS_PER_SECOND;
    … …  
    456457}
    457458
    458459AdlibDriver::~AdlibDriver() {
    459         _mixer->setupPremix(0);
     460        _mixer->stopHandle(_soundHandle);
    460461        OPLDestroy(_adlib);
    461462        _adlib = 0;
    462463}

  • engines/kyra/sound.h

     
    5757
    5858namespace Audio {
    5959class AudioStream;
    60 class Mixer;
    61 class SoundHandle;
    6260} // end of namespace Audio
    6361
    6462namespace Kyra {

  • engines/sky/music/adlibmusic.h

     
    2626#include "sky/music/musicbase.h"
    2727#include "sound/audiostream.h"
    2828#include "sound/fmopl.h"
     29#include "sound/mixer.h"
    2930
    30 namespace Audio {
    31         class Mixer;
    32 }
    33 
    3431namespace Sky {
    3532
    3633class AdlibMusic : public Audio::AudioStream, public MusicBase {
    … …  
    5047private:
    5148        FM_OPL *_opl;
    5249        Audio::Mixer *_mixer;
     50        Audio::SoundHandle _soundHandle;
    5351        uint8 *_initSequence;
    5452        uint32 _sampleRate, _nextMusicPoll;
    5553        virtual void setupPointers(void);

  • engines/sky/music/adlibmusic.cpp

     
    3939
    4040        _opl = makeAdlibOPL(_sampleRate);
    4141
    42         _mixer->setupPremix(this);
     42        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    4343}
    4444
    4545AdlibMusic::~AdlibMusic(void) {
    4646
    47         _mixer->setupPremix(0);
     47        _mixer->stopHandle(_soundHandle);
    4848}
    4949
    5050void AdlibMusic::premixerCall(int16 *data, uint len) {

  • engines/cine/sound_driver.cpp

     
    6060        memset(_channelsVolumeTable, 0, sizeof(_channelsVolumeTable));
    6161        memset(_instrumentsTable, 0, sizeof(_instrumentsTable));
    6262        initCard();
    63         _mixer->setupPremix(this);
     63        _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
    6464}
    6565
    6666AdlibSoundDriver::~AdlibSoundDriver() {
    67         _mixer->setupPremix(NULL);
     67        _mixer->stopHandle(_soundHandle);
    6868}
    6969
    7070void AdlibSoundDriver::setupChannel(int channel, const byte *data, int instrument, int volume) {

  • engines/cine/sound_driver.h

     
    2727
    2828#include "sound/audiostream.h"
    2929#include "sound/fmopl.h"
     30#include "sound/mixer.h"
    3031
    31 namespace Audio {
    32         class Mixer;
    33 }
    34 
    3532namespace Cine {
    3633       
    3734class SoundDriver {
    … …  
    105102        FM_OPL *_opl;
    106103        int _sampleRate;
    107104        Audio::Mixer *_mixer;
     105        Audio::SoundHandle _soundHandle;
    108106
    109107        byte _vibrato;
    110108        int _channelsVolumeTable[4];