mirror of
https://forgejo.xatacraft.ru/Sunshine/mkxp-sunshine.git
synced 2026-08-19 21:39:57 +00:00
Gutted midi system
This commit is contained in:
Mathew Velasquez
parent
5bb407be96
commit
4be6c0d592
14 changed files with 0 additions and 1272 deletions
|
|
@ -184,22 +184,6 @@
|
|||
# rubyLoadpath=/usr/local/share/ruby/site_ruby
|
||||
|
||||
|
||||
# SoundFont to use for midi playback (via fluidsynth)
|
||||
# (default: none)
|
||||
#
|
||||
# midi.soundFont=/usr/share/mysoundfont.sf2
|
||||
|
||||
|
||||
# Activate "chorus" effect for midi playback
|
||||
#
|
||||
# midi.chorus=false
|
||||
|
||||
|
||||
# Activate "reverb" effect for midi playback
|
||||
#
|
||||
# midi.reverb=false
|
||||
|
||||
|
||||
# Number of OpenAL sources to allocate for SE playback.
|
||||
# If there are a lot of sounds playing at the same time
|
||||
# and audibly cutting each other off, try increasing
|
||||
|
|
|
|||
12
mkxp.pro
12
mkxp.pro
|
|
@ -68,10 +68,6 @@ unix {
|
|||
LIBS += -L$$STEAMWORKS/redistributable_bin/linux$$STEAMARCH -lsteam_api
|
||||
}
|
||||
}
|
||||
|
||||
SHARED_FLUID {
|
||||
PKGCONFIG += fluidsynth
|
||||
}
|
||||
}
|
||||
|
||||
win32 {
|
||||
|
|
@ -180,8 +176,6 @@ HEADERS += \
|
|||
src/windowvx.h \
|
||||
src/tilemapvx.h \
|
||||
src/tileatlasvx.h \
|
||||
src/sharedmidistate.h \
|
||||
src/fluid-fun.h \
|
||||
src/sdl-util.h \
|
||||
src/oneshot.h
|
||||
|
||||
|
|
@ -227,8 +221,6 @@ SOURCES += \
|
|||
src/tilemapvx.cpp \
|
||||
src/tileatlasvx.cpp \
|
||||
src/autotilesvx.cpp \
|
||||
src/midisource.cpp \
|
||||
src/fluid-fun.cpp \
|
||||
src/oneshot.cpp \
|
||||
binding-mri/steam-binding.cpp
|
||||
|
||||
|
|
@ -267,10 +259,6 @@ EMBED = \
|
|||
assets/icon.png \
|
||||
assets/gamecontrollerdb.txt
|
||||
|
||||
SHARED_FLUID {
|
||||
DEFINES += SHARED_FLUID
|
||||
}
|
||||
|
||||
defineReplace(xxdOutput) {
|
||||
return($$basename(1).xxd)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,7 +65,4 @@ ALDataSource *createSDLSource(SDL_RWops &ops,
|
|||
ALDataSource *createVorbisSource(SDL_RWops &ops,
|
||||
bool looped);
|
||||
|
||||
ALDataSource *createMidiSource(SDL_RWops &ops,
|
||||
bool looped);
|
||||
|
||||
#endif // ALDATASOURCE_H
|
||||
|
|
|
|||
|
|
@ -22,12 +22,10 @@
|
|||
#include "alstream.h"
|
||||
|
||||
#include "sharedstate.h"
|
||||
#include "sharedmidistate.h"
|
||||
#include "eventthread.h"
|
||||
#include "filesystem.h"
|
||||
#include "exception.h"
|
||||
#include "aldatasource.h"
|
||||
#include "fluid-fun.h"
|
||||
#include "sdl-util.h"
|
||||
#include "debugwriter.h"
|
||||
|
||||
|
|
@ -229,17 +227,6 @@ struct ALStreamOpenHandler : FileSystem::OpenHandler
|
|||
return true;
|
||||
}
|
||||
|
||||
if (!strcmp(sig, "MThd"))
|
||||
{
|
||||
shState->midiState().initIfNeeded(shState->config());
|
||||
|
||||
if (HAVE_FLUID)
|
||||
{
|
||||
source = createMidiSource(*srcOps, looped);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
source = createSDLSource(*srcOps, ext, STREAM_BUF_SIZE, looped);
|
||||
}
|
||||
catch (const Exception &e)
|
||||
|
|
|
|||
|
|
@ -24,7 +24,6 @@
|
|||
#include "audiostream.h"
|
||||
#include "soundemitter.h"
|
||||
#include "sharedstate.h"
|
||||
#include "sharedmidistate.h"
|
||||
#include "eventthread.h"
|
||||
#include "sdl-util.h"
|
||||
|
||||
|
|
@ -310,11 +309,6 @@ void Audio::seStop()
|
|||
p->se.stop();
|
||||
}
|
||||
|
||||
void Audio::setupMidi()
|
||||
{
|
||||
shState->midiState().initIfNeeded(shState->config());
|
||||
}
|
||||
|
||||
float Audio::bgmPos()
|
||||
{
|
||||
return p->bgm.playingOffset();
|
||||
|
|
|
|||
|
|
@ -63,7 +63,6 @@ public:
|
|||
int pitch = 100);
|
||||
void seStop();
|
||||
|
||||
void setupMidi();
|
||||
float bgmPos();
|
||||
float bgsPos();
|
||||
|
||||
|
|
|
|||
|
|
@ -155,9 +155,6 @@ void Config::read(int argc, char *argv[])
|
|||
PO_DESC(allowSymlinks, bool, false) \
|
||||
PO_DESC(iconPath, std::string, "") \
|
||||
PO_DESC(execName, std::string, "Game") \
|
||||
PO_DESC(midi.soundFont, std::string, "") \
|
||||
PO_DESC(midi.chorus, bool, false) \
|
||||
PO_DESC(midi.reverb, bool, false) \
|
||||
PO_DESC(SE.sourceCount, int, 6) \
|
||||
PO_DESC(pathCache, bool, true)
|
||||
|
||||
|
|
|
|||
|
|
@ -56,13 +56,6 @@ struct Config
|
|||
std::string iconPath;
|
||||
std::string execName;
|
||||
|
||||
struct
|
||||
{
|
||||
std::string soundFont;
|
||||
bool chorus;
|
||||
bool reverb;
|
||||
} midi;
|
||||
|
||||
struct
|
||||
{
|
||||
int sourceCount;
|
||||
|
|
|
|||
|
|
@ -1,67 +0,0 @@
|
|||
#include "fluid-fun.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <SDL_loadso.h>
|
||||
#include <SDL_platform.h>
|
||||
|
||||
#include "debugwriter.h"
|
||||
|
||||
#ifdef SHARED_FLUID
|
||||
#include <fluidsynth.h>
|
||||
#endif
|
||||
|
||||
#if __LINUX__ || __ANDROID__
|
||||
#define FLUID_LIB "libfluidsynth.so.1"
|
||||
#elif __MACOSX__
|
||||
#define FLUID_LIB "libfluidsynth.1.dylib"
|
||||
#elif __WINDOWS__
|
||||
#define FLUID_LIB "fluidsynth.dll"
|
||||
#else
|
||||
#error "platform not recognized"
|
||||
#endif
|
||||
|
||||
struct FluidFunctions fluid;
|
||||
|
||||
static void *so;
|
||||
|
||||
void initFluidFunctions()
|
||||
{
|
||||
#ifdef SHARED_FLUID
|
||||
|
||||
#define FLUID_FUN(name, type) \
|
||||
fluid.name = fluid_##name;
|
||||
|
||||
#define FLUID_FUN2(name, type, real_name) \
|
||||
fluid.name = real_name;
|
||||
|
||||
#else
|
||||
so = SDL_LoadObject(FLUID_LIB);
|
||||
|
||||
if (!so)
|
||||
goto fail;
|
||||
|
||||
#define FLUID_FUN(name, type) \
|
||||
fluid.name = (type) SDL_LoadFunction(so, "fluid_" #name); \
|
||||
if (!fluid.name) \
|
||||
goto fail;
|
||||
|
||||
#define FLUID_FUN2(name, type, real_name) \
|
||||
fluid.name = (type) SDL_LoadFunction(so, #real_name); \
|
||||
if (!fluid.name) \
|
||||
goto fail;
|
||||
#endif
|
||||
|
||||
FLUID_FUNCS
|
||||
FLUID_FUNCS2
|
||||
|
||||
return;
|
||||
|
||||
#ifndef SHARED_FLUID
|
||||
fail:
|
||||
Debug() << "Failed to load " FLUID_LIB ". Midi playback is disabled.";
|
||||
|
||||
memset(&fluid, 0, sizeof(fluid));
|
||||
SDL_UnloadObject(so);
|
||||
so = 0;
|
||||
#endif
|
||||
}
|
||||
|
|
@ -1,60 +0,0 @@
|
|||
#ifndef FLUIDFUN_H
|
||||
#define FLUIDFUN_H
|
||||
|
||||
typedef struct _fluid_hashtable_t fluid_settings_t;
|
||||
typedef struct _fluid_synth_t fluid_synth_t;
|
||||
|
||||
typedef int (*FLUIDSETTINGSSETNUMPROC)(fluid_settings_t* settings, const char *name, double val);
|
||||
typedef int (*FLUIDSETTINGSSETSTRPROC)(fluid_settings_t* settings, const char *name, const char *str);
|
||||
typedef int (*FLUIDSYNTHSFLOADPROC)(fluid_synth_t* synth, const char* filename, int reset_presets);
|
||||
typedef int (*FLUIDSYNTHSYSTEMRESETPROC)(fluid_synth_t* synth);
|
||||
typedef int (*FLUIDSYNTHWRITES16PROC)(fluid_synth_t* synth, int len, void* lout, int loff, int lincr, void* rout, int roff, int rincr);
|
||||
typedef int (*FLUIDSYNTHNOTEONPROC)(fluid_synth_t* synth, int chan, int key, int vel);
|
||||
typedef int (*FLUIDSYNTHNOTEOFFPROC)(fluid_synth_t* synth, int chan, int key);
|
||||
typedef int (*FLUIDSYNTHCHANNELPRESSUREPROC)(fluid_synth_t* synth, int chan, int val);
|
||||
typedef int (*FLUIDSYNTHPITCHBENDPROC)(fluid_synth_t* synth, int chan, int val);
|
||||
typedef int (*FLUIDSYNTHCCPROC)(fluid_synth_t* synth, int chan, int ctrl, int val);
|
||||
typedef int (*FLUIDSYNTHPROGRAMCHANGEPROC)(fluid_synth_t* synth, int chan, int program);
|
||||
|
||||
typedef fluid_settings_t* (*NEWFLUIDSETTINGSPROC)(void);
|
||||
typedef fluid_synth_t* (*NEWFLUIDSYNTHPROC)(fluid_settings_t* settings);
|
||||
typedef void (*DELETEFLUIDSETTINGSPROC)(fluid_settings_t* settings);
|
||||
typedef int (*DELETEFLUIDSYNTHPROC)(fluid_synth_t* synth);
|
||||
|
||||
#define FLUID_FUNCS \
|
||||
FLUID_FUN(settings_setnum, FLUIDSETTINGSSETNUMPROC) \
|
||||
FLUID_FUN(settings_setstr, FLUIDSETTINGSSETSTRPROC) \
|
||||
FLUID_FUN(synth_sfload, FLUIDSYNTHSFLOADPROC) \
|
||||
FLUID_FUN(synth_system_reset, FLUIDSYNTHSYSTEMRESETPROC) \
|
||||
FLUID_FUN(synth_write_s16, FLUIDSYNTHWRITES16PROC) \
|
||||
FLUID_FUN(synth_noteon, FLUIDSYNTHNOTEONPROC) \
|
||||
FLUID_FUN(synth_noteoff, FLUIDSYNTHNOTEOFFPROC) \
|
||||
FLUID_FUN(synth_channel_pressure, FLUIDSYNTHCHANNELPRESSUREPROC) \
|
||||
FLUID_FUN(synth_pitch_bend, FLUIDSYNTHPITCHBENDPROC) \
|
||||
FLUID_FUN(synth_cc, FLUIDSYNTHCCPROC) \
|
||||
FLUID_FUN(synth_program_change, FLUIDSYNTHPROGRAMCHANGEPROC)
|
||||
|
||||
/* Functions that don't fit into the default prefix naming scheme */
|
||||
#define FLUID_FUNCS2 \
|
||||
FLUID_FUN2(new_settings, NEWFLUIDSETTINGSPROC, new_fluid_settings) \
|
||||
FLUID_FUN2(new_synth, NEWFLUIDSYNTHPROC, new_fluid_synth) \
|
||||
FLUID_FUN2(delete_settings, DELETEFLUIDSETTINGSPROC, delete_fluid_settings) \
|
||||
FLUID_FUN2(delete_synth, DELETEFLUIDSYNTHPROC, delete_fluid_synth)
|
||||
|
||||
struct FluidFunctions
|
||||
{
|
||||
#define FLUID_FUN(name, type) type name;
|
||||
#define FLUID_FUN2(name, type, rn) type name;
|
||||
FLUID_FUNCS
|
||||
FLUID_FUNCS2
|
||||
#undef FLUID_FUN
|
||||
#undef FLUID_FUN2
|
||||
};
|
||||
|
||||
#define HAVE_FLUID fluid.new_synth
|
||||
|
||||
extern FluidFunctions fluid;
|
||||
|
||||
void initFluidFunctions();
|
||||
|
||||
#endif // FLUIDFUN_H
|
||||
|
|
@ -1,923 +0,0 @@
|
|||
/*
|
||||
** midisource.cpp
|
||||
**
|
||||
** This file is part of mkxp.
|
||||
**
|
||||
** Copyright (C) 2014 Jonas Kulla <Nyocurio@gmail.com>
|
||||
**
|
||||
** mkxp 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 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** mkxp 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 mkxp. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "aldatasource.h"
|
||||
|
||||
#include "al-util.h"
|
||||
#include "exception.h"
|
||||
#include "sharedstate.h"
|
||||
#include "sharedmidistate.h"
|
||||
#include "util.h"
|
||||
#include "debugwriter.h"
|
||||
#include "fluid-fun.h"
|
||||
|
||||
#include <SDL_rwops.h>
|
||||
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
|
||||
/* Vocabulary:
|
||||
*
|
||||
* Tick:
|
||||
* Ticks are the smallest batch of samples that fluidsynth
|
||||
* allows midi state changes to take effect in, ie. if two midi
|
||||
* events are fired within less than a tick, it will look as
|
||||
* if they fired at the same time. Midisource therefore always
|
||||
* synthesizes sample blocks which are multiples of ticks.
|
||||
* One tick is 64 samples, or 32 frames with two channels.
|
||||
*
|
||||
* Delta:
|
||||
* Deltas are the abstract time unit in which the relative
|
||||
* offsets between midi events are encoded.
|
||||
*/
|
||||
|
||||
#define TICK_FRAMES 32
|
||||
#define BUF_TICKS (STREAM_BUF_SIZE / TICK_FRAMES)
|
||||
#define DEFAULT_BPM 120
|
||||
#define MAX_CHANNELS 16
|
||||
|
||||
#define CC_CTRL_VOLUME 7
|
||||
#define CC_CTRL_EXPRESSION 11
|
||||
#define CC_CTRL_LOOP 111
|
||||
|
||||
#define CC_VAL_DEFAULT 127
|
||||
|
||||
enum MidiEventType
|
||||
{
|
||||
NoteOff,
|
||||
NoteOn,
|
||||
ChanTouch,
|
||||
PitchBend,
|
||||
CC,
|
||||
PC,
|
||||
Tempo,
|
||||
|
||||
Last
|
||||
};
|
||||
|
||||
struct ChannelEvent
|
||||
{
|
||||
uint8_t chan;
|
||||
};
|
||||
|
||||
struct NoteEvent : ChannelEvent
|
||||
{
|
||||
uint8_t key;
|
||||
uint8_t vel;
|
||||
};
|
||||
|
||||
struct NoteTouchEvent : ChannelEvent
|
||||
{
|
||||
uint8_t val;
|
||||
};
|
||||
|
||||
struct PitchBendEvent : ChannelEvent
|
||||
{
|
||||
uint16_t val;
|
||||
};
|
||||
|
||||
struct CCEvent : ChannelEvent
|
||||
{
|
||||
uint8_t ctrl;
|
||||
uint8_t val;
|
||||
};
|
||||
|
||||
struct PCEvent : ChannelEvent
|
||||
{
|
||||
uint8_t prog;
|
||||
};
|
||||
|
||||
struct TempoEvent
|
||||
{
|
||||
uint32_t bpm;
|
||||
};
|
||||
|
||||
struct MidiEvent
|
||||
{
|
||||
MidiEventType type;
|
||||
uint32_t delta;
|
||||
union
|
||||
{
|
||||
ChannelEvent chan;
|
||||
NoteEvent note;
|
||||
NoteTouchEvent chanTouch;
|
||||
PitchBendEvent pitchBend;
|
||||
CCEvent cc;
|
||||
PCEvent pc;
|
||||
TempoEvent tempo;
|
||||
} e;
|
||||
};
|
||||
|
||||
struct MidiReadHandler
|
||||
{
|
||||
virtual void onMidiHeader(uint16_t midiType, uint16_t trackCount, uint16_t division) = 0;
|
||||
virtual void onMidiTrackBegin() = 0;
|
||||
virtual void onMidiEvent(const MidiEvent &e, uint32_t absDelta) = 0;
|
||||
};
|
||||
|
||||
static void
|
||||
badMidiFormat()
|
||||
{
|
||||
throw Exception(Exception::MKXPError, "Midi: Bad format");
|
||||
}
|
||||
|
||||
/* File-like interface to a read-only memory buffer */
|
||||
struct MemChunk
|
||||
{
|
||||
const std::vector<uint8_t> &data;
|
||||
size_t i;
|
||||
|
||||
MemChunk(const std::vector<uint8_t> &data)
|
||||
: data(data),
|
||||
i(0)
|
||||
{}
|
||||
|
||||
uint8_t readByte()
|
||||
{
|
||||
if (i >= data.size())
|
||||
endOfFile();
|
||||
|
||||
return data[i++];
|
||||
}
|
||||
|
||||
void readData(void *buf, size_t n)
|
||||
{
|
||||
if (i + n > data.size())
|
||||
endOfFile();
|
||||
|
||||
memcpy(buf, &data[i], n);
|
||||
i += n;
|
||||
}
|
||||
|
||||
void skipData(size_t n)
|
||||
{
|
||||
if ((i += n) > data.size())
|
||||
endOfFile();
|
||||
}
|
||||
|
||||
void endOfFile()
|
||||
{
|
||||
throw Exception(Exception::MKXPError, "Midi: EOF");
|
||||
}
|
||||
};
|
||||
|
||||
static uint32_t
|
||||
readVarNum(MemChunk &chunk)
|
||||
{
|
||||
uint32_t result = 0;
|
||||
uint8_t byte;
|
||||
uint8_t len = 0;
|
||||
|
||||
do
|
||||
{
|
||||
/* A variable length number can at most be made of 4 bytes */
|
||||
if (++len > 4)
|
||||
badMidiFormat();
|
||||
|
||||
byte = chunk.readByte();
|
||||
result = (result << 0x7) | (byte & 0x7F);
|
||||
}
|
||||
while (byte & 0x80);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static T readBigEndian(MemChunk &chunk)
|
||||
{
|
||||
T result = 0;
|
||||
|
||||
for (size_t i = 0; i < sizeof(T); ++i)
|
||||
result = (result << 0x8) | chunk.readByte();
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static void
|
||||
readVoiceEvent(MidiEvent &e, MemChunk &chunk,
|
||||
uint8_t type, uint8_t data1, bool &handled)
|
||||
{
|
||||
e.e.chan.chan = (type & 0x0F);
|
||||
|
||||
uint8_t tmp;
|
||||
|
||||
switch (type >> 4)
|
||||
{
|
||||
case 0x8 :
|
||||
e.type = NoteOff;
|
||||
e.e.note.key = data1;
|
||||
chunk.readByte(); /* We don't care about velocity */
|
||||
break;
|
||||
|
||||
case 0x9 :
|
||||
e.type = NoteOn;
|
||||
e.e.note.key = data1;
|
||||
e.e.note.vel = chunk.readByte();
|
||||
break;
|
||||
|
||||
case 0xA :
|
||||
/* Note aftertouch unhandled */
|
||||
handled = false;
|
||||
break;
|
||||
|
||||
case 0xB :
|
||||
e.type = CC;
|
||||
e.e.cc.ctrl = data1;
|
||||
e.e.cc.val = chunk.readByte();
|
||||
break;
|
||||
|
||||
case 0xC :
|
||||
e.type = PC;
|
||||
e.e.pc.prog = data1;
|
||||
break;
|
||||
|
||||
case 0xD :
|
||||
e.type = ChanTouch;
|
||||
e.e.chanTouch.val = data1;
|
||||
break;
|
||||
|
||||
case 0xE :
|
||||
e.type = PitchBend;
|
||||
tmp = chunk.readByte();
|
||||
e.e.pitchBend.val = ((tmp & 0x7F) << 7) | (data1 & 0x7F);
|
||||
break;
|
||||
|
||||
default :
|
||||
assert(!"unreachable");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
readEvent(MidiReadHandler *handler, MemChunk &chunk,
|
||||
uint8_t &prevType, uint32_t &deltaBase, uint32_t &deltaCarry,
|
||||
bool &endOfTrack)
|
||||
{
|
||||
MidiEvent e;
|
||||
bool handled = true;
|
||||
|
||||
e.delta = readVarNum(chunk);
|
||||
|
||||
uint8_t type = chunk.readByte();
|
||||
|
||||
/* Check for running status */
|
||||
if (!(type & 0x80))
|
||||
{
|
||||
/* Running status for meta/system events is not allowed */
|
||||
if (prevType == 0)
|
||||
badMidiFormat();
|
||||
|
||||
/* Running status voice event: 'type' becomes
|
||||
* first data byte instead */
|
||||
readVoiceEvent(e, chunk, prevType, type, handled);
|
||||
goto event_read;
|
||||
}
|
||||
|
||||
if ((type >> 4) != 0xF)
|
||||
{
|
||||
/* Normal voice event */
|
||||
readVoiceEvent(e, chunk, type, chunk.readByte(), handled);
|
||||
prevType = type;
|
||||
}
|
||||
else if (type == 0xFF)
|
||||
{
|
||||
/* Meta event */
|
||||
uint8_t metaType = chunk.readByte();
|
||||
uint32_t len = readVarNum(chunk);
|
||||
|
||||
if (metaType == 0x51)
|
||||
{
|
||||
/* Tempo event */
|
||||
if (len != 3)
|
||||
badMidiFormat();
|
||||
|
||||
uint8_t data[3];
|
||||
chunk.readData(data, 3);
|
||||
|
||||
uint32_t mpqn = (data[0] << 0x10)
|
||||
| (data[1] << 0x08)
|
||||
| (data[2] << 0x00);
|
||||
|
||||
e.type = Tempo;
|
||||
e.e.tempo.bpm = 60000000 / mpqn;
|
||||
}
|
||||
else if (metaType == 0x2F)
|
||||
{
|
||||
/* End-of-track event */
|
||||
if (len != 0)
|
||||
badMidiFormat();
|
||||
|
||||
endOfTrack = true;
|
||||
handled = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
handled = false;
|
||||
}
|
||||
|
||||
if (!handled)
|
||||
chunk.skipData(len);
|
||||
|
||||
prevType = 0;
|
||||
}
|
||||
else if (type == 0xF0 || type == 0xF7)
|
||||
{
|
||||
/* SysEx event */
|
||||
uint32_t len = readVarNum(chunk);
|
||||
handled = false;
|
||||
chunk.skipData(len);
|
||||
|
||||
prevType = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
badMidiFormat();
|
||||
}
|
||||
|
||||
event_read:
|
||||
|
||||
if (handled)
|
||||
{
|
||||
e.delta += deltaCarry;
|
||||
deltaCarry = 0;
|
||||
deltaBase += e.delta;
|
||||
|
||||
handler->onMidiEvent(e, deltaBase);
|
||||
}
|
||||
else
|
||||
{
|
||||
deltaCarry += e.delta;
|
||||
}
|
||||
}
|
||||
|
||||
void readMidiTrack(MidiReadHandler *handler, MemChunk &chunk)
|
||||
{
|
||||
/* Track signature */
|
||||
char sig[5] = { 0 };
|
||||
chunk.readData(sig, 4);
|
||||
if (strcmp(sig, "MTrk"))
|
||||
badMidiFormat();
|
||||
|
||||
handler->onMidiTrackBegin();
|
||||
|
||||
uint32_t trackLen = readBigEndian<uint32_t>(chunk);
|
||||
|
||||
/* The combined delta of all events on this track so far */
|
||||
uint32_t deltaBase = 0;
|
||||
|
||||
/* If we don't care about an event, instead of inserting a
|
||||
* useless event, we carry over its delta into the next one */
|
||||
uint32_t deltaCarry = 0;
|
||||
|
||||
/* Holds the previous status byte for voice event, in case
|
||||
* we encounter a running status */
|
||||
uint8_t prevType = 0;
|
||||
|
||||
/* The 'EndOfTrack' meta event will toggle this flag on */
|
||||
bool endOfTrack = false;
|
||||
|
||||
size_t savedPos = chunk.i;
|
||||
|
||||
/* Read all events */
|
||||
while (!endOfTrack)
|
||||
readEvent(handler, chunk, prevType, deltaBase, deltaCarry, endOfTrack);
|
||||
|
||||
/* Check that the track byte length from the header
|
||||
* matches the amount we actually ended up reading */
|
||||
if ((chunk.i - savedPos) != trackLen)
|
||||
badMidiFormat();
|
||||
}
|
||||
|
||||
void readMidi(MidiReadHandler *handler, const std::vector<uint8_t> &data)
|
||||
{
|
||||
MemChunk chunk(data);
|
||||
|
||||
/* Midi signature */
|
||||
char sig[5] = { 0 };
|
||||
chunk.readData(sig, 4);
|
||||
if (strcmp(sig, "MThd"))
|
||||
badMidiFormat();
|
||||
|
||||
/* Header length must always be 6 */
|
||||
uint32_t hdrLen = readBigEndian<uint32_t>(chunk);
|
||||
if (hdrLen != 6)
|
||||
badMidiFormat();
|
||||
|
||||
/* Only types 0, 1, 2 exist */
|
||||
uint16_t type = readBigEndian<uint16_t>(chunk);
|
||||
if (type > 2)
|
||||
badMidiFormat();
|
||||
|
||||
/* Type 0 only contains one track */
|
||||
uint16_t trackCount = readBigEndian<uint16_t>(chunk);
|
||||
if (trackCount == 0)
|
||||
badMidiFormat();
|
||||
if (type == 0 && trackCount > 1)
|
||||
badMidiFormat();
|
||||
|
||||
uint16_t timeDiv = readBigEndian<uint16_t>(chunk);
|
||||
|
||||
handler->onMidiHeader(type, trackCount, timeDiv);
|
||||
|
||||
/* Read tracks */
|
||||
for (uint16_t i = 0; i < trackCount; ++i)
|
||||
readMidiTrack(handler, chunk);
|
||||
}
|
||||
|
||||
struct Track
|
||||
{
|
||||
std::vector<MidiEvent> events;
|
||||
|
||||
/* Combined deltas of all events */
|
||||
uint64_t length;
|
||||
|
||||
/* Event index that is resumed from after loop wraparound */
|
||||
int32_t loopI;
|
||||
|
||||
/* Difference between last event's position and length of
|
||||
* the longest overall track / song length */
|
||||
uint32_t loopOffsetEnd;
|
||||
|
||||
/* Delta offset from the loop beginning to event[loopI] */
|
||||
uint32_t loopOffsetStart;
|
||||
|
||||
bool valid;
|
||||
MidiEvent event;
|
||||
int32_t remDeltas;
|
||||
|
||||
uint32_t index;
|
||||
bool wrapAroundFlag;
|
||||
bool atEnd;
|
||||
|
||||
Track()
|
||||
: length(0),
|
||||
loopI(-1),
|
||||
loopOffsetEnd(0),
|
||||
loopOffsetStart(0),
|
||||
valid(false),
|
||||
index(0),
|
||||
wrapAroundFlag(false),
|
||||
atEnd(false)
|
||||
{}
|
||||
|
||||
void appendEvent(const MidiEvent &e)
|
||||
{
|
||||
length += e.delta;
|
||||
events.push_back(e);
|
||||
}
|
||||
|
||||
void scheduleEvent(bool looped)
|
||||
{
|
||||
if (valid)
|
||||
return;
|
||||
|
||||
/* At end and not looped? */
|
||||
if (index == events.size() && ((!looped || loopI < 0) || length == 0))
|
||||
{
|
||||
valid = false;
|
||||
atEnd = true;
|
||||
return;
|
||||
}
|
||||
|
||||
MidiEvent &e = events[index++];
|
||||
|
||||
event = e;
|
||||
remDeltas = e.delta;
|
||||
valid = true;
|
||||
|
||||
if (wrapAroundFlag)
|
||||
{
|
||||
remDeltas = loopOffsetEnd + loopOffsetStart;
|
||||
wrapAroundFlag = false;
|
||||
}
|
||||
|
||||
if (looped && (index == events.size()) && loopI >= 0)
|
||||
{
|
||||
index = loopI;
|
||||
wrapAroundFlag = true;
|
||||
}
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
valid = false;
|
||||
index = 0;
|
||||
wrapAroundFlag = false;
|
||||
atEnd = false;
|
||||
}
|
||||
};
|
||||
|
||||
/* Some songs use CC events for effects like fade-out,
|
||||
* slowly decreasing a channel's volume to 0. The problem is that
|
||||
* for looped songs, events are continuously fed into the synth
|
||||
* without restoring those controls back to their default value.
|
||||
* We can't reset them at the very beginning of tracks because it
|
||||
* might cause audible interactions with notes which are still decaying
|
||||
* past the end of the song. Therefore, we insert a fake CC event right
|
||||
* after the first NoteOn event for each channel which resets the
|
||||
* control to its default state while avoiding audible glitches.
|
||||
* If there is already a CC event for this control before the first
|
||||
* NoteOn event, we don't clobber it by not inserting our fake event. */
|
||||
template<uint8_t ctrl>
|
||||
struct CCResetter
|
||||
{
|
||||
bool chanHandled[MAX_CHANNELS];
|
||||
|
||||
CCResetter()
|
||||
{
|
||||
memset(&chanHandled, 0, sizeof(chanHandled));
|
||||
}
|
||||
|
||||
void handleEvent(const MidiEvent &e, Track &track)
|
||||
{
|
||||
if (e.type != NoteOn && e.type != CC)
|
||||
return;
|
||||
|
||||
uint8_t chan = e.e.chan.chan;
|
||||
|
||||
if (chanHandled[chan])
|
||||
return;
|
||||
|
||||
if (e.type == CC && e.e.cc.ctrl == ctrl)
|
||||
{
|
||||
/* Don't clobber the existing CC value */
|
||||
chanHandled[chan] = true;
|
||||
return;
|
||||
}
|
||||
else if (e.type == NoteOn)
|
||||
{
|
||||
chanHandled[chan] = true;
|
||||
|
||||
MidiEvent re;
|
||||
re.delta = 0;
|
||||
re.type = CC;
|
||||
re.e.cc.chan = chan;
|
||||
re.e.cc.ctrl = ctrl;
|
||||
re.e.cc.val = CC_VAL_DEFAULT;
|
||||
|
||||
track.appendEvent(re);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct MidiSource : ALDataSource, MidiReadHandler
|
||||
{
|
||||
const uint16_t freq;
|
||||
fluid_synth_t *synth;
|
||||
|
||||
int16_t synthBuf[BUF_TICKS*TICK_FRAMES*2];
|
||||
|
||||
std::vector<Track> tracks;
|
||||
CCResetter<CC_CTRL_VOLUME> volReset;
|
||||
CCResetter<CC_CTRL_EXPRESSION> expReset;
|
||||
|
||||
/* Index of longest track */
|
||||
uint8_t longestI;
|
||||
|
||||
bool looped;
|
||||
|
||||
/* Absolute delta at which we received the LOOP_MARKER CC event */
|
||||
uint32_t loopDelta;
|
||||
|
||||
/* Deltas per beat */
|
||||
uint16_t dpb;
|
||||
|
||||
int8_t pitchShift;
|
||||
|
||||
/* Deltas per tick */
|
||||
float playbackSpeed;
|
||||
|
||||
float genDeltasCarry;
|
||||
|
||||
/* MidiReadHandler (track that's currently being read) */
|
||||
int16_t curTrack;
|
||||
|
||||
MidiSource(SDL_RWops &ops,
|
||||
bool looped)
|
||||
: freq(SYNTH_SAMPLERATE),
|
||||
looped(looped),
|
||||
dpb(480),
|
||||
pitchShift(0),
|
||||
genDeltasCarry(0),
|
||||
curTrack(-1)
|
||||
{
|
||||
size_t dataLen = SDL_RWsize(&ops);
|
||||
std::vector<uint8_t> data(dataLen);
|
||||
|
||||
if (SDL_RWread(&ops, &data[0], 1, dataLen) < dataLen)
|
||||
{
|
||||
SDL_RWclose(&ops);
|
||||
throw Exception(Exception::MKXPError, "Reading midi data failed");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
readMidi(this, data);
|
||||
}
|
||||
catch (const Exception &)
|
||||
{
|
||||
SDL_RWclose(&ops);
|
||||
throw;
|
||||
}
|
||||
|
||||
synth = shState->midiState().allocateSynth();
|
||||
|
||||
uint64_t longest = 0;
|
||||
|
||||
for (size_t i = 0; i < tracks.size(); ++i)
|
||||
if (tracks[i].length > longest)
|
||||
{
|
||||
longest = tracks[i].length;
|
||||
longestI = i;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < tracks.size(); ++i)
|
||||
tracks[i].loopOffsetEnd = longest - tracks[i].length;
|
||||
|
||||
/* Enterbrain likes to be funny and put loop markers at
|
||||
* the very end of ME tracks */
|
||||
if (loopDelta >= longest)
|
||||
loopDelta = 0;
|
||||
|
||||
for (size_t i = 0; i < tracks.size(); ++i)
|
||||
{
|
||||
Track &track = tracks[i];
|
||||
|
||||
int64_t base = 0;
|
||||
for (size_t j = 0; j < track.events.size(); ++j)
|
||||
{
|
||||
MidiEvent &e = track.events[j];
|
||||
base += e.delta;
|
||||
|
||||
if (base < loopDelta)
|
||||
continue;
|
||||
|
||||
/* Don't make the last event loop eternally */
|
||||
if (j < track.events.size())
|
||||
{
|
||||
track.loopI = j;
|
||||
track.loopOffsetStart = base - loopDelta;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
updatePlaybackSpeed(DEFAULT_BPM);
|
||||
|
||||
// FIXME: It would make the code in 'fillBuffer' a lot nicer if
|
||||
// we could combine all tracks into one giant one on construction,
|
||||
// instead of having to constantly iterate through all of them
|
||||
}
|
||||
|
||||
~MidiSource()
|
||||
{
|
||||
shState->midiState().releaseSynth(synth);
|
||||
}
|
||||
|
||||
|
||||
void updatePlaybackSpeed(uint32_t bpm)
|
||||
{
|
||||
float deltaLength = 60.0f / (dpb * bpm);
|
||||
playbackSpeed = TICK_FRAMES / (deltaLength * freq);
|
||||
}
|
||||
|
||||
void activateEvent(const MidiEvent &e)
|
||||
{
|
||||
int16_t key = e.e.note.key;
|
||||
|
||||
/* Apply pitch shift if necessary */
|
||||
if ((e.type == NoteOn || e.type == NoteOff) && e.e.chan.chan != 9)
|
||||
{
|
||||
key += pitchShift;
|
||||
|
||||
/* Drop events whose keys are out of bounds */
|
||||
if (key < 0 || key > 127)
|
||||
return;
|
||||
}
|
||||
|
||||
switch (e.type)
|
||||
{
|
||||
case NoteOn:
|
||||
fluid.synth_noteon(synth, e.e.note.chan, key, e.e.note.vel);
|
||||
break;
|
||||
case NoteOff:
|
||||
fluid.synth_noteoff(synth, e.e.note.chan, key);
|
||||
break;
|
||||
case ChanTouch:
|
||||
fluid.synth_channel_pressure(synth, e.e.chanTouch.chan, e.e.chanTouch.val);
|
||||
break;
|
||||
case PitchBend:
|
||||
fluid.synth_pitch_bend(synth, e.e.pitchBend.chan, e.e.pitchBend.val);
|
||||
break;
|
||||
case CC:
|
||||
fluid.synth_cc(synth, e.e.cc.chan, e.e.cc.ctrl, e.e.cc.val);
|
||||
break;
|
||||
case PC:
|
||||
fluid.synth_program_change(synth, e.e.pc.chan, e.e.pc.prog);
|
||||
break;
|
||||
case Tempo:
|
||||
updatePlaybackSpeed(e.e.tempo.bpm);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void renderTicks(size_t count, size_t offset)
|
||||
{
|
||||
size_t bufOffset = offset * TICK_FRAMES * 2;
|
||||
int len = count * TICK_FRAMES;
|
||||
void *buffer = &synthBuf[bufOffset];
|
||||
|
||||
fluid.synth_write_s16(synth, len, buffer, 0, 2, buffer, 1, 2);
|
||||
}
|
||||
|
||||
/* MidiReadHandler */
|
||||
void onMidiHeader(uint16_t midiType, uint16_t trackCount, uint16_t division)
|
||||
{
|
||||
if (midiType != 0 && midiType != 1)
|
||||
throw Exception(Exception::MKXPError, "Midi: Type 2 not supported");
|
||||
|
||||
tracks.resize(trackCount);
|
||||
|
||||
// SMTP unhandled
|
||||
if (division & 0x8000)
|
||||
throw Exception(Exception::MKXPError, "Midi: SMTP parameters not supported");
|
||||
else
|
||||
dpb = division;
|
||||
}
|
||||
|
||||
void onMidiTrackBegin()
|
||||
{
|
||||
++curTrack;
|
||||
}
|
||||
|
||||
void onMidiEvent(const MidiEvent &e, uint32_t absDelta)
|
||||
{
|
||||
assert(curTrack >= 0 && curTrack < (int16_t) tracks.size());
|
||||
|
||||
Track &track = tracks[curTrack];
|
||||
|
||||
track.appendEvent(e);
|
||||
volReset.handleEvent(e, track);
|
||||
expReset.handleEvent(e, track);
|
||||
|
||||
if (e.type == CC && e.e.cc.ctrl == CC_CTRL_LOOP)
|
||||
loopDelta = absDelta;
|
||||
}
|
||||
|
||||
/* ALDataSource */
|
||||
Status fillBuffer(AL::Buffer::ID buf)
|
||||
{
|
||||
/* In case there is no currently scheduled one */
|
||||
for (size_t i = 0; i < tracks.size(); ++i)
|
||||
tracks[i].scheduleEvent(looped);
|
||||
|
||||
size_t remTicks = BUF_TICKS;
|
||||
|
||||
/* Iterate until all ticks that fit into the buffer
|
||||
* have been rendered */
|
||||
while (remTicks > 0)
|
||||
{
|
||||
/* Check for events that have to be activated now, activate them,
|
||||
* and schedule new ones if the queue isn't empty */
|
||||
for (size_t i = 0; i < tracks.size(); ++i)
|
||||
{
|
||||
Track &track = tracks[i];
|
||||
|
||||
/* We have to loop and ensure that the final scheduled
|
||||
* event lies in the future, as multiple events might
|
||||
* have to be activated at once */
|
||||
while (true)
|
||||
{
|
||||
if (!track.valid || track.remDeltas > 0)
|
||||
break;
|
||||
|
||||
int32_t prevOffset = track.remDeltas;
|
||||
|
||||
activateEvent(track.event);
|
||||
|
||||
track.valid = false;
|
||||
track.scheduleEvent(looped);
|
||||
|
||||
/* Negative deltas from the previous event have to
|
||||
* be carried over into the next to stay in sync */
|
||||
if (prevOffset < 0)
|
||||
track.remDeltas += prevOffset;
|
||||
|
||||
/* Ensure it lies in the future */
|
||||
if (track.remDeltas > 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
size_t nextEvent = (size_t) -1;
|
||||
bool allInvalid = true;
|
||||
|
||||
/* Search all tracks for the temporally nearest event */
|
||||
for (size_t i = 0; i < tracks.size(); ++i)
|
||||
{
|
||||
Track &track = tracks[i];
|
||||
|
||||
if (!track.valid)
|
||||
continue;
|
||||
|
||||
allInvalid = false;
|
||||
|
||||
uint32_t remDelta = track.remDeltas / playbackSpeed;
|
||||
|
||||
/* We need to render at least one tick regardless to
|
||||
* avoid an endless loop of waiting for the next event
|
||||
* to become current */
|
||||
if (remDelta < nextEvent)
|
||||
nextEvent = std::max<uint32_t>(remDelta, 1);
|
||||
}
|
||||
|
||||
/* Calculate amount of ticks we'll render next */
|
||||
size_t genTicks = allInvalid ? remTicks : std::min(remTicks, nextEvent);
|
||||
|
||||
if (genTicks == 0)
|
||||
continue;
|
||||
|
||||
renderTicks(genTicks, BUF_TICKS - remTicks);
|
||||
remTicks -= genTicks;
|
||||
|
||||
float genDeltas = (genTicks * playbackSpeed) + genDeltasCarry;
|
||||
|
||||
float intDeltas;
|
||||
genDeltasCarry = modff(genDeltas, &intDeltas);
|
||||
|
||||
/* Substract integer part of consumed deltas while carrying
|
||||
* over the fractional amount into the next iteration */
|
||||
for (size_t i = 0; i < tracks.size(); ++i)
|
||||
if (tracks[i].valid)
|
||||
tracks[i].remDeltas -= intDeltas;
|
||||
}
|
||||
|
||||
/* Fill AL buffer */
|
||||
AL::Buffer::uploadData(buf, AL_FORMAT_STEREO16, synthBuf, sizeof(synthBuf), freq);
|
||||
|
||||
if (tracks[longestI].atEnd)
|
||||
return EndOfStream;
|
||||
|
||||
return NoError;
|
||||
}
|
||||
|
||||
int sampleRate()
|
||||
{
|
||||
return freq;
|
||||
}
|
||||
|
||||
/* Midi sources cannot seek, and so always reset to beginning */
|
||||
void seekToOffset(float)
|
||||
{
|
||||
/* Reset synth */
|
||||
fluid.synth_system_reset(synth);
|
||||
|
||||
/* Reset runtime variables */
|
||||
genDeltasCarry = 0;
|
||||
updatePlaybackSpeed(DEFAULT_BPM);
|
||||
|
||||
/* Reset tracks */
|
||||
for (size_t i = 0; i < tracks.size(); ++i)
|
||||
tracks[i].reset();
|
||||
}
|
||||
|
||||
uint32_t loopStartFrames() { return 0; }
|
||||
|
||||
bool setPitch(float value)
|
||||
{
|
||||
// not completely correct, but close
|
||||
pitchShift = round((value > 1.0f ? 14 : 24) * (value - 1.0f));
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
ALDataSource *createMidiSource(SDL_RWops &ops,
|
||||
bool looped)
|
||||
{
|
||||
return new MidiSource(ops, looped);
|
||||
}
|
||||
|
|
@ -1,149 +0,0 @@
|
|||
/*
|
||||
** sharedmidistate.h
|
||||
**
|
||||
** This file is part of mkxp.
|
||||
**
|
||||
** Copyright (C) 2014 Jonas Kulla <Nyocurio@gmail.com>
|
||||
**
|
||||
** mkxp 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 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** mkxp 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 mkxp. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef SHAREDMIDISTATE_H
|
||||
#define SHAREDMIDISTATE_H
|
||||
|
||||
#include "config.h"
|
||||
#include "debugwriter.h"
|
||||
#include "fluid-fun.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#define SYNTH_INIT_COUNT 2
|
||||
#define SYNTH_SAMPLERATE 44100
|
||||
|
||||
struct Synth
|
||||
{
|
||||
fluid_synth_t *synth;
|
||||
bool inUse;
|
||||
};
|
||||
|
||||
struct SharedMidiState
|
||||
{
|
||||
bool inited;
|
||||
std::vector<Synth> synths;
|
||||
const std::string &soundFont;
|
||||
fluid_settings_t *flSettings;
|
||||
|
||||
SharedMidiState(const Config &conf)
|
||||
: inited(false),
|
||||
soundFont(conf.midi.soundFont)
|
||||
{}
|
||||
|
||||
~SharedMidiState()
|
||||
{
|
||||
/* We might have initialized, but if the consecutive libfluidsynth
|
||||
* load failed, no resources will have been allocated */
|
||||
if (!inited || !HAVE_FLUID)
|
||||
return;
|
||||
|
||||
fluid.delete_settings(flSettings);
|
||||
|
||||
for (size_t i = 0; i < synths.size(); ++i)
|
||||
{
|
||||
assert(!synths[i].inUse);
|
||||
fluid.delete_synth(synths[i].synth);
|
||||
}
|
||||
}
|
||||
|
||||
void initIfNeeded(const Config &conf)
|
||||
{
|
||||
if (inited)
|
||||
return;
|
||||
|
||||
inited = true;
|
||||
|
||||
initFluidFunctions();
|
||||
|
||||
if (!HAVE_FLUID)
|
||||
return;
|
||||
|
||||
flSettings = fluid.new_settings();
|
||||
fluid.settings_setnum(flSettings, "synth.gain", 1.0f);
|
||||
fluid.settings_setnum(flSettings, "synth.sample-rate", SYNTH_SAMPLERATE);
|
||||
fluid.settings_setstr(flSettings, "synth.chorus.active", conf.midi.chorus ? "yes" : "no");
|
||||
fluid.settings_setstr(flSettings, "synth.reverb.active", conf.midi.reverb ? "yes" : "no");
|
||||
|
||||
for (size_t i = 0; i < SYNTH_INIT_COUNT; ++i)
|
||||
addSynth(false);
|
||||
}
|
||||
|
||||
fluid_synth_t *allocateSynth()
|
||||
{
|
||||
assert(HAVE_FLUID);
|
||||
assert(inited);
|
||||
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < synths.size(); ++i)
|
||||
if (!synths[i].inUse)
|
||||
break;
|
||||
|
||||
if (i < synths.size())
|
||||
{
|
||||
fluid_synth_t *syn = synths[i].synth;
|
||||
fluid.synth_system_reset(syn);
|
||||
synths[i].inUse = true;
|
||||
|
||||
return syn;
|
||||
}
|
||||
else
|
||||
{
|
||||
return addSynth(true);
|
||||
}
|
||||
}
|
||||
|
||||
void releaseSynth(fluid_synth_t *synth)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < synths.size(); ++i)
|
||||
if (synths[i].synth == synth)
|
||||
break;
|
||||
|
||||
assert(i < synths.size());
|
||||
|
||||
synths[i].inUse = false;
|
||||
}
|
||||
|
||||
private:
|
||||
fluid_synth_t *addSynth(bool usedNow)
|
||||
{
|
||||
fluid_synth_t *syn = fluid.new_synth(flSettings);
|
||||
|
||||
if (!soundFont.empty())
|
||||
fluid.synth_sfload(syn, soundFont.c_str(), 1);
|
||||
else
|
||||
Debug() << "Warning: No soundfont specified, sound might be mute";
|
||||
|
||||
Synth synth;
|
||||
synth.inUse = usedNow;
|
||||
synth.synth = syn;
|
||||
synths.push_back(synth);
|
||||
|
||||
return syn;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // SHAREDMIDISTATE_H
|
||||
|
|
@ -40,7 +40,6 @@
|
|||
#include "quad.h"
|
||||
#include "binding.h"
|
||||
#include "exception.h"
|
||||
#include "sharedmidistate.h"
|
||||
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
|
|
@ -75,8 +74,6 @@ struct SharedStatePrivate
|
|||
RGSSThreadData &rtData;
|
||||
Config &config;
|
||||
|
||||
SharedMidiState midiState;
|
||||
|
||||
Graphics graphics;
|
||||
Input input;
|
||||
Audio audio;
|
||||
|
|
@ -114,7 +111,6 @@ struct SharedStatePrivate
|
|||
eThread(*threadData->ethread),
|
||||
rtData(*threadData),
|
||||
config(threadData->config),
|
||||
midiState(threadData->config),
|
||||
graphics(threadData),
|
||||
input(*threadData),
|
||||
audio(*threadData),
|
||||
|
|
@ -157,11 +153,6 @@ struct SharedStatePrivate
|
|||
/* Reuse starting values */
|
||||
TEXFBO::allocEmpty(gpTexFBO, globalTexW, globalTexH);
|
||||
TEXFBO::linkFBO(gpTexFBO);
|
||||
|
||||
/* RGSS3 games will call setup_midi, so there's
|
||||
* no need to do it on startup */
|
||||
if (rgssVer <= 2)
|
||||
midiState.initIfNeeded(threadData->config);
|
||||
}
|
||||
|
||||
~SharedStatePrivate()
|
||||
|
|
@ -243,7 +234,6 @@ GSATT(ShaderSet&, shaders)
|
|||
GSATT(TexPool&, texPool)
|
||||
GSATT(Quad&, gpQuad)
|
||||
GSATT(SharedFontState&, fontState)
|
||||
GSATT(SharedMidiState&, midiState)
|
||||
|
||||
void SharedState::setBindingData(void *data)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -89,8 +89,6 @@ struct SharedState
|
|||
SharedFontState &fontState() const;
|
||||
Font &defaultFont() const;
|
||||
|
||||
SharedMidiState &midiState() const;
|
||||
|
||||
sigc::signal<void> prepareDraw;
|
||||
|
||||
unsigned int genTimeStamp();
|
||||
|
|
|
|||
Loading…
Reference in a new issue