Ticket #8852: kyra_mt32.patch

File kyra_mt32.patch, 18.5 KB (added by lordhoto, 15 years ago)

Patch against r31450

  • engines/kyra/sound.cpp

     
    152152        _musicParser = _sfxParser = 0;
    153153        _isMusicPlaying = _isSfxPlaying = false;
    154154        _eventFromMusic = false;
     155        _isLooping = false;
     156        _nextSysEx = 0;
    155157       
    156158        _nativeMT32 = _useC55 = false;
    157159
     160        _midiFile = 0;
     161        _sfxFile = 0;
     162
    158163        memset(_channel, 0, sizeof(_channel));
    159164        memset(_channelVolume, 50, sizeof(_channelVolume));
    160165        _channelVolume[10] = 100;
     
    169174SoundMidiPC::~SoundMidiPC() {
    170175        Common::StackLock lock(_mutex);
    171176
     177        _driver->setTimerCallback(0, 0);
     178
     179        _musicParser->unloadMusic();
     180        _sfxParser->unloadMusic();
     181        _musicParser->setMidiDriver(0);
     182        _sfxParser->setMidiDriver(0);
    172183        delete _musicParser;
    173184        delete _sfxParser;
     185        delete [] _midiFile;
     186        delete [] _sfxFile;
    174187
    175         _driver->setTimerCallback(0, 0);
    176188        close();
    177189}
    178190
     
    186198        _musicParser->setMidiDriver(this);
    187199        _sfxParser->setMidiDriver(this);
    188200
     201        if (!_nativeMT32)
     202                return true;
     203
     204        Common::String soundFile;
     205        Common::String pakFile;
     206        if (_vm->game() == GI_KYRA1) {
     207                soundFile = "INTRO";
     208                if (_vm->gameFlags().isTalkie)
     209                        pakFile = "XMI.PAK";
     210        } else if (_vm->game() == GI_KYRA2) {
     211                soundFile = "HOF_SYX";
     212                pakFile = "AUDIO.PAK";
     213        } else {
     214                return true;
     215        }
     216
     217        const char * const files[] = {
     218                soundFile.c_str(), 0
     219        };
     220
     221        AudioDataStruct data = { files, 1, 0, 0 };
     222        setSoundList(&data);
     223
     224        if (!pakFile.empty())
     225                _vm->resource()->loadPakFile(pakFile.c_str());
     226
     227        // Kyrandia 2 got special file for SFX
     228        if (_vm->game() == GI_KYRA2) {
     229                Common::String file = "K2SFX.";
     230                file += _useC55 ? "C55" : "XMI";
     231
     232                uint32 size = 0;
     233                _sfxFile = _vm->resource()->fileData(file.c_str(), &size);
     234                if (_sfxParser->loadMusic(_sfxFile, size)) {
     235                        _sfxParser->setTimerRate(getBaseTempo());
     236                        _sfxParser->setTempo(0);
     237                        _sfxParser->property(MidiParser::mpSmartJump, true);
     238                } else {
     239                        warning("Error parsing sfx track '%s'", file.c_str());
     240                }
     241        }
     242
     243        loadSoundFile(0);
     244        playTrack(0);
     245
     246        if (!pakFile.empty())
     247                _vm->resource()->unloadPakFile(pakFile.c_str());
     248
     249        while (_isMusicPlaying)
     250                g_system->delayMillis(10);
     251
     252        setSoundList(0);
     253
    189254        return true;
    190255}
    191256
    192257void SoundMidiPC::updateVolumeSettings() {
    193         _musicVolume = ConfMan.getInt("music_volume");
     258        uint8 musicVolume = ConfMan.getInt("music_volume");
    194259        _sfxVolume = ConfMan.getInt("sfx_volume");
    195260
    196         updateChannelVolume(_musicVolume);
     261        if (musicVolume != _musicVolume) {
     262                _musicVolume = musicVolume;
     263                Common::StackLock lock(_mutex);
     264                updateChannelVolume(_musicVolume);
     265        }
    197266}
    198267
    199268void SoundMidiPC::hasNativeMT32(bool nativeMT32) {
     
    249318        if ((b & 0xFFF0) == 0x74B0 && _eventFromMusic) {
    250319                debugC(9, kDebugLevelMain | kDebugLevelSound, "SoundMidiPC: Looping song");
    251320                _musicParser->property(MidiParser::mpAutoLoop, true);
     321                _isLooping = true;
    252322                return;
    253323        }
    254324
     
    297367                _channel[_virChannel[channel]]->send(b);
    298368}
    299369
     370void SoundMidiPC::sysEx(const byte *msg, uint16 length) {
     371        // Since Kyrandia doesn't have a long enough delay between some SysEx
     372        // commands we have to manually add one to allow the MT-32 to process
     373        // all data, elsewise we would get some overflow error from the MT-32
     374        uint32 curTime = g_system->getMillis();
     375        if (_nextSysEx > curTime)
     376                g_system->delayMillis(_nextSysEx - curTime);
     377        _nextSysEx = curTime + 50;
     378
     379        _driver->sysEx(msg, length);
     380}
     381
    300382void SoundMidiPC::metaEvent(byte type, byte *data, uint16 length) {
    301383        switch (type) {
    302384        case 0x2F:      // End of Track
    303385                if (_eventFromMusic) {
     386                        if (!_isLooping)
     387                                _isMusicPlaying = false;
     388
    304389                        // remap all channels
    305390                        for (int i = 0; i < 16; ++i)
    306391                                _virChannel[i] = i;
     
    314399        }
    315400}
    316401
    317 
    318 struct DeleterArray {
    319         void operator ()(byte *ptr) {
    320                 delete [] ptr;
    321         }
    322 };
    323 
    324402void SoundMidiPC::loadSoundFile(uint file) {
    325403        Common::StackLock lock(_mutex);
    326404
     
    332410                _isMusicPlaying = _isSfxPlaying = false;
    333411                _fadeStartTime = 0;
    334412                _fadeMusicOut = false;
     413                _isLooping = false;
    335414                updateChannelVolume(_musicVolume);
    336415                _musicParser->setTempo(0);
    337416                _sfxParser->setTempo(0);
    338417                _musicParser->property(MidiParser::mpAutoLoop, false);
    339                 _sfxParser->property(MidiParser::mpAutoLoop, false);
    340418                return;
    341419        }
    342420
     
    348426                return;
    349427        }
    350428
     429        _isMusicPlaying = _isSfxPlaying = false;
     430        _fadeStartTime = 0;
     431        _fadeMusicOut = false;
     432        _isLooping = false;
     433        _musicParser->setTimerRate(getBaseTempo());
     434        _musicParser->setTempo(0);
     435        _musicParser->property(MidiParser::mpAutoLoop, false);
     436
    351437        _currentTrack = filename;
    352438
    353         _midiFile = Common::SharedPtr<byte>(data, DeleterArray());
    354439        _musicParser->unloadMusic();
     440        if (_vm->game() != GI_KYRA2)
    355441
    356         _isMusicPlaying = _isSfxPlaying = false;
    357         _fadeStartTime = 0;
    358         _fadeMusicOut = false;
    359442        updateChannelVolume(_musicVolume);
    360443
    361         if (_musicParser->loadMusic(_midiFile.get(), size)) {
    362                 _musicParser->setTimerRate(getBaseTempo());
    363                 _musicParser->setTempo(0);
    364                 _musicParser->property(MidiParser::mpAutoLoop, false);
    365         } else {
     444        if (!_musicParser->loadMusic(data, size))
    366445                warning("Error parsing music track '%s'", filename.c_str());
    367         }
    368446
    369         if (_sfxParser->loadMusic(_midiFile.get(), size)) {
     447        if (_vm->game() != GI_KYRA2) {
    370448                _sfxParser->setTimerRate(getBaseTempo());
    371449                _sfxParser->setTempo(0);
    372                 _sfxParser->property(MidiParser::mpAutoLoop, false);
    373         } else {
    374                 warning("Error parsing sfx track '%s'", filename.c_str());
     450                _sfxParser->property(MidiParser::mpSmartJump, true);
     451                _sfxParser->unloadMusic();
     452                if (!_sfxParser->loadMusic(data, size))
     453                        warning("Error parsing sfx track '%s'", filename.c_str());
    375454        }
     455
     456        delete [] _midiFile;
     457        _midiFile = data;
    376458}
    377459
    378460void SoundMidiPC::onTimer(void *refCon) {
    379461        SoundMidiPC *sound = (SoundMidiPC *)refCon;
    380462        Common::StackLock lock(sound->_mutex);
    381463
    382         // this should be set to the fadeToBlack value
    383         static const uint32 musicFadeTime = 2 * 1000;
     464        // Kyra2 waits exaclty 60 ticks (a tick is 1/60s) for fadeout, so this
     465        // should be correct
     466        const uint32 musicFadeTime = 1 * 1000;
    384467
    385468        if (sound->_fadeMusicOut && sound->_fadeStartTime + musicFadeTime > sound->_vm->_system->getMillis()) {
    386469                byte volume = (byte)((musicFadeTime - (sound->_vm->_system->getMillis() - sound->_fadeStartTime)) * sound->_musicVolume / musicFadeTime);
     
    416499void SoundMidiPC::playTrack(uint8 track) {
    417500        Common::StackLock lock(_mutex);
    418501
    419         if (_musicParser && (track != 0 || _nativeMT32) && _musicEnabled) {
     502        if (_musicParser && (track != 0 || _nativeMT32) && _musicEnabled && _midiFile) {
    420503                _isMusicPlaying = true;
    421504                _fadeMusicOut = false;
    422505                _fadeStartTime = 0;
     506                _isLooping = false;
    423507                updateChannelVolume(_musicVolume);
    424508                _musicParser->setTrack(track);
    425509                _musicParser->jumpToTick(0);
     
    435519                _isMusicPlaying = false;
    436520                _fadeMusicOut = false;
    437521                _fadeStartTime = 0;
     522                _isLooping = false;
    438523                updateChannelVolume(_musicVolume);
    439524                _musicParser->setTrack(0);
    440525                _musicParser->jumpToTick(0);
     
    443528}
    444529
    445530void SoundMidiPC::playSoundEffect(uint8 track) {
    446         if (_sfxParser && _sfxEnabled) {
     531        if (_sfxParser && _sfxEnabled && ((_midiFile && _vm->game() != GI_KYRA2) || (_sfxFile && _vm->game() == GI_KYRA2))) {
    447532                _isSfxPlaying = true;
    448533                _sfxParser->setTrack(track);
    449534                _sfxParser->jumpToTick(0);
     
    466551
    467552        _curSfxFile = _curMusicTheme = file;
    468553        _sound->loadSoundFile(_curMusicTheme);
    469         _sound->playTrack(track);
     554        if (track != -1)
     555                _sound->playTrack(track);
    470556}
    471557
    472558void KyraEngine::snd_playSoundEffect(int track) {
     
    492578                assert(command*2+1 < _trackMapSize);
    493579                if (_curMusicTheme != _trackMap[command*2]) {
    494580                        if (_trackMap[command*2] != -1 && _trackMap[command*2] != -2)
    495                                 snd_playTheme(_trackMap[command*2]);
     581                                snd_playTheme(_trackMap[command*2], -1);
    496582                }
    497583
    498584                if (command != 1) {
    499585                        if (_lastMusicCommand != command) {
    500586                                _sound->haltTrack();
     587                                // Short delay like in the original,
     588                                // this is probably for MIDI sound.
     589                                _system->delayMillis(50);
    501590                                _sound->playTrack(_trackMap[command*2+1]);
    502591                        }
    503592                } else {
  • engines/kyra/staticres.cpp

     
    15841584
    15851585const int KyraEngine_v2::_dosTrackMapSize = ARRAYSIZE(KyraEngine_v2::_dosTrackMap);
    15861586
     1587const uint8 KyraEngine_v2::_midiMT32SfxMap[] = {
     1588        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     1589        0xFF, 0xFF, 0xFF, 0x31, 0x0B, 0x05, 0x24, 0x0D,
     1590        0xFF, 0xFF, 0x44, 0x37, 0x25, 0x49, 0x2B, 0x3D,
     1591        0x31, 0xFF, 0x38, 0xFF, 0x3E, 0x26, 0xFF, 0xFF,
     1592        0x3D, 0xFF, 0xFF, 0x1F, 0x46, 0x02, 0x2D, 0xFF,
     1593        0x2D, 0xFF, 0xFF, 0xFF, 0x0A, 0x0E, 0x18, 0x19,
     1594        0xFF, 0xFF, 0x3B, 0x09, 0x1A, 0xFF, 0x47, 0x4F,
     1595        0x0C, 0x09, 0xFF, 0xFF, 0x3D, 0xFF, 0xFF, 0x41,
     1596        0x42, 0x32, 0x1B, 0x18, 0x1D, 0x1D, 0x0F, 0x10,
     1597        0x11, 0x12, 0x13, 0x14, 0x15, 0x39, 0xFF, 0xFF,
     1598        0x22, 0x03, 0xFF, 0x38, 0x38, 0xFF, 0xFF, 0x32,
     1599        0x2B, 0x44, 0x20, 0x21, 0x43, 0x19, 0x3C, 0x28,
     1600        0x27, 0x0B, 0x18, 0x02, 0x3C, 0x03, 0x2E, 0x36,
     1601        0x01, 0x08, 0xFF, 0xFF, 0x29, 0x2A, 0x25, 0x4A,
     1602        0x45, 0x3E, 0x3A, 0x1B, 0xFF, 0xFF, 0xFF, 0xFF,
     1603        0x30, 0x04, 0xFF, 0x19, 0x27, 0x28, 0x18, 0x3A,
     1604        0x23, 0x04, 0x04, 0x04, 0xFF, 0x32, 0xFF, 0x06,
     1605        0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x35, 0x34,
     1606        0xFF, 0x3F, 0x2F, 0xFF, 0xFF, 0xFF, 0x35, 0xFF,
     1607        0x1D, 0xFF, 0xFF, 0x4F, 0xFF, 0x29, 0x0C, 0xFF,
     1608        0xFF, 0xFF, 0x1A, 0xFF, 0x07, 0x1B, 0x48, 0x33,
     1609        0x17, 0x33, 0x40, 0xFF, 0xFF, 0xFF, 0x1B, 0x4C,
     1610        0x4D, 0x4E, 0x1C, 0x2F, 0xFF, 0xFF, 0x35, 0xFF,
     1611        0xFF, 0xFF, 0xFF, 0xFF, 0x02, 0x16, 0xFF, 0x33,
     1612        0x3A, 0xFF, 0xFF, 0x1E, 0xFF, 0x4F, 0xFF, 0xFF,
     1613        0x16, 0x24, 0x01, 0xFF, 0x0C, 0x01, 0xFF, 0xFF,
     1614        0x29, 0xFF, 0x4C, 0x4D, 0x2F
     1615};
     1616
     1617const uint8 KyraEngine_v2::_midiGMSfxMap[] = {
     1618        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     1619        0xFF, 0xFF, 0xFF, 0x1F, 0x19, 0x13, 0x0C, 0x04,
     1620        0xFF, 0xFF, 0x2E, 0x12, 0xFF, 0x15, 0x0F, 0xFF,
     1621        0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x2F, 0xFF,
     1622        0x21, 0xFF, 0x24, 0xFF, 0xFF, 0x17, 0x30, 0xFF,
     1623        0x30, 0xFF, 0xFF, 0x31, 0xFF, 0x32, 0x16, 0x18,
     1624        0x33, 0xFF, 0x34, 0x14, 0xFF, 0xFF, 0x16, 0x35,
     1625        0x03, 0x14, 0x2F, 0x36, 0x21, 0xFF, 0x37, 0x38,
     1626        0x39, 0x21, 0xFF, 0x33, 0x3A, 0xFF, 0x05, 0x06,
     1627        0x07, 0x08, 0x09, 0x0A, 0x0B, 0x16, 0xFF, 0xFF,
     1628        0xFF, 0x18, 0xFF, 0x1A, 0x11, 0xFF, 0xFF, 0x21,
     1629        0x0F, 0xFF, 0x17, 0x17, 0xFF, 0x16, 0xFF, 0x17,
     1630        0x18, 0x15, 0x16, 0xFF, 0xFF, 0x18, 0x10, 0xFF,
     1631        0x01, 0x30, 0xFF, 0xFF, 0x0D, 0x0E, 0xFF, 0x1D,
     1632        0x40, 0xFF, 0xFF, 0x19, 0xFF, 0xFF, 0xFF, 0xFF,
     1633        0xFF, 0x02, 0x0D, 0x18, 0x17, 0x17, 0x16, 0xFF,
     1634        0x3C, 0x02, 0x02, 0x02, 0xFF, 0x21, 0xFF, 0x3D,
     1635        0x30, 0x3E, 0xFF, 0x27, 0xFF, 0xFF, 0x1C, 0x3F,
     1636        0x21, 0xFF, 0x11, 0xFF, 0x2D, 0x2D, 0x1C, 0x37,
     1637        0x22, 0xFF, 0xFF, 0x22, 0x37, 0x0D, 0xFF, 0x2F,
     1638        0x36, 0xFF, 0xFF, 0x21, 0x2C, 0x19, 0xFF, 0xFF,
     1639        0xFF, 0x20, 0xFF, 0xFF, 0xFF, 0xFF, 0x19, 0x25,
     1640        0x25, 0x25, 0x1A, 0x2B, 0xFF, 0x2A, 0x18, 0xFF,
     1641        0xFF, 0xFF, 0xFF, 0xFF, 0x17, 0x20, 0xFF, 0x20,
     1642        0xFF, 0xFF, 0xFF, 0x1B, 0x29, 0x22, 0xFF, 0x28,
     1643        0x20, 0xFF, 0x10, 0x28, 0xFF, 0x10, 0x26, 0x27,
     1644        0x0D, 0xFF, 0x25, 0x1C, 0x21
     1645};
     1646
    15871647void KyraEngine_v2::initInventoryButtonList() {
    15881648        delete [] _inventoryButtons;
    15891649
  • engines/kyra/kyra_v2.h

     
    897897        void snd_loadSoundFile(int id);
    898898
    899899        void playVoice(int high, int low);
     900
     901        static const uint8 _midiMT32SfxMap[];
     902        static const uint8 _midiGMSfxMap[];
    900903        void snd_playSoundEffect(int track);
    901904
    902905        // timer
  • engines/kyra/sound.h

     
    320320        int open();
    321321        void close();
    322322        void send(uint32 b);
     323        void sysEx(const byte *msg, uint16 length);
    323324        void metaEvent(byte type, byte *data, uint16 length);
    324325
    325326        void setTimerCallback(void *timerParam, void (*timerProc)(void *)) { }
     
    353354        bool _fadeMusicOut;
    354355
    355356        // Midi file related
    356         Common::SharedPtr<byte> _midiFile;
     357        byte *_midiFile;
    357358        Common::String _currentTrack;
    358359
     360        byte *_sfxFile;
     361
    359362        // Music related
    360363        MidiParser *_musicParser;
    361364
    362365        bool _isMusicPlaying;
    363366        bool _eventFromMusic;
     367        bool _isLooping;
    364368
    365369        // Sfx related
    366370        MidiParser *_sfxParser;
     
    368372        bool _isSfxPlaying;
    369373
    370374        // misc
     375        uint32 _nextSysEx;
    371376        bool _nativeMT32;
    372377        bool _useC55;
    373378        MidiDriver *_driver;
  • engines/kyra/kyra_v1.cpp

     
    185185
    186186        initStaticResource();
    187187
     188        if (!_sound->init())
     189                error("Couldn't init sound");
     190
    188191        _sound->setSoundList(&_soundData[kMusicIntro]);
    189192
    190193        _trackMap = _dosTrackMap;
    191194        _trackMapSize = _dosTrackMapSize;
    192195
    193         if (!_sound->init())
    194                 error("Couldn't init sound");
    195 
    196196        _sound->loadSoundFile(0);
    197197
    198198        setupButtonData();
  • engines/kyra/kyra_v2.cpp

     
    18381838        }
    18391839
    18401840        int16 vocIndex = (int16)READ_LE_UINT16(&_ingameSoundIndex[track * 2]);
    1841         if (vocIndex != -1)
     1841        // TODO: Maybe there is a way to let users select whether they want
     1842        // voc, midi or adl sfx (even though it makes no sense to choose anything but voc).
     1843        // For now this is used as a fallback only (if no voc file exists).
     1844        if (vocIndex != -1) {
    18421845                _sound->voicePlay(_ingameSoundList[vocIndex], true);
    1843         else if (_flags.platform == Common::kPlatformPC)
    1844                 // TODO ?? Maybe there is a way to let users select whether they want
    1845                 // voc, midi or adl sfx (even though it makes no sense to choose anything but voc).
    1846                 // For now this is used as a fallback only (if no voc file exists).
    1847                 KyraEngine::snd_playSoundEffect(track);
     1846        } else if (_flags.platform == Common::kPlatformPC) {
     1847                if (_sound->getSfxType() == Sound::kAdlib) {
     1848                        KyraEngine::snd_playSoundEffect(track);
     1849                } else if (_sound->getSfxType() == Sound::kMidiMT32) {
     1850                        if (_midiMT32SfxMap[track] != 0xFF)
     1851                                KyraEngine::snd_playSoundEffect(_midiMT32SfxMap[track]-1);
     1852                } else if (_sound->getSfxType() == Sound::kMidiGM) {
     1853                        if (_midiGMSfxMap[track] != 0xFF)
     1854                                KyraEngine::snd_playSoundEffect(_midiGMSfxMap[track]-1);
     1855                }
     1856        }
    18481857}
    18491858
    18501859#pragma mark -
  • sound/mididrv.h

     
    216216         * do NOT include the leading 0xF0 and the trailing 0xF7.
    217217         *
    218218         * Furthermore, the maximal supported length of a SysEx
    219          * is 254 bytes. Passing longer buffers can lead to
     219         * is 264 bytes. Passing longer buffers can lead to
    220220         * undefined behavior (most likely, a crash).
     221         * Re increased that value since Kyra uses 264 byte SysEx
     222         * commands before our maximal length was 254 bytes.
    221223         */
    222224        virtual void sysEx(const byte *msg, uint16 length) { }
    223225
  • backends/midi/alsa.cpp

     
    196196}
    197197
    198198void MidiDriver_ALSA::sysEx(const byte *msg, uint16 length) {
    199         unsigned char buf[256];
     199        unsigned char buf[266];
    200200
    201         assert(length + 2 <= 256);
     201        assert(uint(length + 2) <= sizeof(buf));
    202202
    203203        // Add SysEx frame
    204204        buf[0] = 0xF0;
  • backends/midi/dmedia.cpp

     
    1818 * along with this program; if not, write to the Free Software
    1919 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
    2020 *
    21  * $URL:$
     21 * $URL$
    2222 * $Id: dmedia.cpp$
    2323 */
    2424
     
    159159        MDevent event;
    160160        char buf [1024];
    161161
    162         assert(length + 2 <= 256);
     162        assert(length + 2 <= sizeof(buf));
    163163
    164164        memcpy(buf, msg, length);
    165165        buf[length] = MD_EOX;
  • backends/midi/camd.cpp

     
    114114}
    115115
    116116void MidiDriver_CAMD::sysEx(const byte *msg, uint16 length) {
    117         unsigned char buf[256];
     117        unsigned char buf[266];
    118118
    119         assert(length + 2 <= 256);
     119        assert(length + 2 <= sizeof(buf));
    120120
    121121        // Add SysEx frame
    122122        buf[0] = 0xF0;
  • backends/midi/seq.cpp

     
    149149        int position = 0;
    150150        const byte *chr = msg;
    151151
    152         assert(length + 2 <= 256);
     152        assert(length + 2 <= 266);
    153153
    154154        buf[position++] = SEQ_MIDIPUTC;
    155155        buf[position++] = 0xF0;
  • backends/midi/zodiac.cpp

     
    111111}
    112112
    113113void MidiDriver_Zodiac::sysEx(const byte *msg, uint16 length) {
    114         unsigned char buf[256];
     114        unsigned char buf[266];
    115115
    116116        buf[0] = 0xF0;
    117117        memcpy(buf + 1, msg, length);
  • backends/midi/coreaudio.cpp

     
    178178}
    179179
    180180void MidiDriver_CORE::sysEx(const byte *msg, uint16 length) {
    181         unsigned char buf[256];
     181        unsigned char buf[266];
    182182
    183         assert(length + 2 <= 256);
     183        assert(length + 2 <= sizeof(buf));
    184184        assert(_auGraph != NULL);
    185185
    186186        // Add SysEx frame
  • backends/midi/windows.cpp

     
    3939class MidiDriver_WIN : public MidiDriver_MPU401 {
    4040private:
    4141        MIDIHDR _streamHeader;
    42         byte _streamBuffer[256];        // SysEx blocks should be no larger than 256 bytes
     42        byte _streamBuffer[266];        // SysEx blocks should be no larger than 266 bytes
    4343        HANDLE _streamEvent;
    4444        HMIDIOUT _mo;
    4545        bool _isOpen;
     
    103103                return;
    104104        }
    105105
    106         assert(length+2 <= 256);
     106        assert(length+2 <= sizeof(_streamBuffer));
    107107
    108108        midiOutUnprepareHeader(_mo, &_streamHeader, sizeof(_streamHeader));
    109109
  • backends/midi/timidity.cpp

     
    490490        int position = 0;
    491491        const byte *chr = msg;
    492492
    493         assert(length + 2 <= 256);
     493        assert(length + 2 <= 266);
    494494
    495495        buf[position++] = SEQ_MIDIPUTC;
    496496        buf[position++] = 0xF0;