steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/mptrack/plugins/MidiInOut.cpp

548 lines
14 KiB
C++
Raw Blame History

/*
* MidiInOut.cpp
* -------------
* Purpose: A plugin for sending and receiving MIDI data.
* Notes : (currently none)
* Authors: Johannes Schultz (OpenMPT Devs)
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "MidiInOut.h"
#include "MidiInOutEditor.h"
#include "../../common/FileReader.h"
#include "../../soundlib/Sndfile.h"
#include "../Reporting.h"
#include <algorithm>
#include <sstream>
#ifdef MODPLUG_TRACKER
#include "../Mptrack.h"
#endif
#include "mpt/io/io.hpp"
#include "mpt/io/io_stdstream.hpp"
OPENMPT_NAMESPACE_BEGIN
IMixPlugin* MidiInOut::Create(VSTPluginLib &factory, CSoundFile &sndFile, SNDMIXPLUGIN *mixStruct)
{
try
{
return new (std::nothrow) MidiInOut(factory, sndFile, mixStruct);
} catch(RtMidiError &)
{
return nullptr;
}
}
MidiInOut::MidiInOut(VSTPluginLib &factory, CSoundFile &sndFile, SNDMIXPLUGIN *mixStruct)
: IMidiPlugin(factory, sndFile, mixStruct)
, m_inputDevice(m_midiIn)
, m_outputDevice(m_midiOut)
#ifdef MODPLUG_TRACKER
, m_programName(_T("Default"))
#endif // MODPLUG_TRACKER
{
m_mixBuffer.Initialize(2, 2);
InsertIntoFactoryList();
}
MidiInOut::~MidiInOut()
{
MidiInOut::Suspend();
}
uint32 MidiInOut::GetLatency() const
{
// There is only a latency if the user-provided latency value is greater than the negative output latency.
return mpt::saturate_round<uint32>(std::min(0.0, m_latency + GetOutputLatency()) * m_SndFile.GetSampleRate());
}
void MidiInOut::SaveAllParameters()
{
auto chunk = GetChunk(false);
if(chunk.empty())
return;
m_pMixStruct->defaultProgram = -1;
m_pMixStruct->pluginData.assign(chunk.begin(), chunk.end());
}
void MidiInOut::RestoreAllParameters(int32 program)
{
IMixPlugin::RestoreAllParameters(program); // First plugin version didn't use chunks.
SetChunk(mpt::as_span(m_pMixStruct->pluginData), false);
}
enum ChunkFlags
{
kLatencyCompensation = 0x01, // Implicit in current plugin version
kLatencyPresent = 0x02, // Latency value is present as double-precision float
kIgnoreTiming = 0x04, // Do not send timing and sequencing information
kFriendlyInputName = 0x08, // Preset also stores friendly name of input device
kFriendlyOutputName = 0x10, // Preset also stores friendly name of output device
};
IMixPlugin::ChunkData MidiInOut::GetChunk(bool /*isBank*/)
{
const std::string programName8 = mpt::ToCharset(mpt::Charset::UTF8, m_programName);
uint32 flags = kLatencyCompensation | kLatencyPresent | (m_sendTimingInfo ? 0 : kIgnoreTiming);
#ifdef MODPLUG_TRACKER
const std::string inFriendlyName = (m_inputDevice.index == MidiDevice::NO_MIDI_DEVICE) ? m_inputDevice.name : mpt::ToCharset(mpt::Charset::UTF8, theApp.GetFriendlyMIDIPortName(mpt::ToUnicode(mpt::Charset::UTF8, m_inputDevice.name), true, false));
const std::string outFriendlyName = (m_outputDevice.index == MidiDevice::NO_MIDI_DEVICE) ? m_outputDevice.name : mpt::ToCharset(mpt::Charset::UTF8, theApp.GetFriendlyMIDIPortName(mpt::ToUnicode(mpt::Charset::UTF8, m_outputDevice.name), false, false));
if(inFriendlyName != m_inputDevice.name)
{
flags |= kFriendlyInputName;
}
if(outFriendlyName != m_outputDevice.name)
{
flags |= kFriendlyOutputName;
}
#endif
std::ostringstream s;
mpt::IO::WriteRaw(s, "fEvN", 4); // VST program chunk magic
mpt::IO::WriteIntLE< int32>(s, GetVersion());
mpt::IO::WriteIntLE<uint32>(s, 1); // Number of programs
mpt::IO::WriteIntLE<uint32>(s, static_cast<uint32>(programName8.size()));
mpt::IO::WriteIntLE<uint32>(s, m_inputDevice.index);
mpt::IO::WriteIntLE<uint32>(s, static_cast<uint32>(m_inputDevice.name.size()));
mpt::IO::WriteIntLE<uint32>(s, m_outputDevice.index);
mpt::IO::WriteIntLE<uint32>(s, static_cast<uint32>(m_outputDevice.name.size()));
mpt::IO::WriteIntLE<uint32>(s, flags);
mpt::IO::WriteRaw(s, programName8.c_str(), programName8.size());
mpt::IO::WriteRaw(s, m_inputDevice.name.c_str(), m_inputDevice.name.size());
mpt::IO::WriteRaw(s, m_outputDevice.name.c_str(), m_outputDevice.name.size());
mpt::IO::WriteIntLE<uint64>(s, IEEE754binary64LE(m_latency).GetInt64());
#ifdef MODPLUG_TRACKER
if(flags & kFriendlyInputName)
{
mpt::IO::WriteIntLE<uint32>(s, static_cast<uint32>(inFriendlyName.size()));
mpt::IO::WriteRaw(s, inFriendlyName.c_str(), inFriendlyName.size());
}
if(flags & kFriendlyOutputName)
{
mpt::IO::WriteIntLE<uint32>(s, static_cast<uint32>(outFriendlyName.size()));
mpt::IO::WriteRaw(s, outFriendlyName.c_str(), outFriendlyName.size());
}
#endif
m_chunkData = s.str();
return mpt::byte_cast<mpt::const_byte_span>(mpt::as_span(m_chunkData));
}
// Try to match a port name against stored name or friendly name (preferred)
static void FindPort(MidiDevice::ID &id, unsigned int numPorts, const std::string &name, const std::string &friendlyName, MidiDevice &midiDevice, bool isInput)
{
bool foundFriendly = false;
for(unsigned int i = 0; i < numPorts; i++)
{
try
{
auto portName = midiDevice.GetPortName(i);
bool deviceNameMatches = (portName == name);
#ifdef MODPLUG_TRACKER
if(!friendlyName.empty() && friendlyName == mpt::ToCharset(mpt::Charset::UTF8, theApp.GetFriendlyMIDIPortName(mpt::ToUnicode(mpt::Charset::UTF8, portName), isInput, false)))
{
// Preferred match
id = i;
foundFriendly = true;
if(deviceNameMatches)
{
return;
}
}
#else
MPT_UNREFERENCED_PARAMETER(friendlyName)
#endif
if(deviceNameMatches && !foundFriendly)
{
id = i;
}
} catch(const RtMidiError &)
{
}
}
}
void MidiInOut::SetChunk(const ChunkData &chunk, bool /*isBank*/)
{
FileReader file(chunk);
if(!file.CanRead(9 * sizeof(uint32))
|| !file.ReadMagic("fEvN") // VST program chunk magic
|| file.ReadInt32LE() > GetVersion() // Plugin version
|| file.ReadUint32LE() < 1) // Number of programs
return;
uint32 nameStrSize = file.ReadUint32LE();
MidiDevice::ID inID = file.ReadUint32LE();
uint32 inStrSize = file.ReadUint32LE();
MidiDevice::ID outID = file.ReadUint32LE();
uint32 outStrSize = file.ReadUint32LE();
uint32 flags = file.ReadUint32LE();
std::string progName, inName, outName, inFriendlyName, outFriendlyName;
file.ReadString<mpt::String::maybeNullTerminated>(progName, nameStrSize);
m_programName = mpt::ToCString(mpt::Charset::UTF8, progName);
file.ReadString<mpt::String::maybeNullTerminated>(inName, inStrSize);
file.ReadString<mpt::String::maybeNullTerminated>(outName, outStrSize);
if(flags & kLatencyPresent)
m_latency = file.ReadDoubleLE();
else
m_latency = 0.0f;
m_sendTimingInfo = !(flags & kIgnoreTiming);
if(flags & kFriendlyInputName)
file.ReadString<mpt::String::maybeNullTerminated>(inFriendlyName, file.ReadUint32LE());
if(flags & kFriendlyOutputName)
file.ReadString<mpt::String::maybeNullTerminated>(outFriendlyName, file.ReadUint32LE());
// Try to match an input port name against stored name or friendly name (preferred)
FindPort(inID, m_midiIn.getPortCount(), inName, inFriendlyName, m_inputDevice, true);
FindPort(outID, m_midiOut.getPortCount(), outName, outFriendlyName, m_outputDevice, false);
SetParameter(MidiInOut::kInputParameter, DeviceIDToParameter(inID));
SetParameter(MidiInOut::kOutputParameter, DeviceIDToParameter(outID));
}
void MidiInOut::SetParameter(PlugParamIndex index, PlugParamValue value)
{
value = mpt::safe_clamp(value, 0.0f, 1.0f);
MidiDevice::ID newDevice = ParameterToDeviceID(value);
OpenDevice(newDevice, (index == kInputParameter));
// Update selection in editor
MidiInOutEditor *editor = dynamic_cast<MidiInOutEditor *>(GetEditor());
if(editor != nullptr)
editor->SetCurrentDevice((index == kInputParameter), newDevice);
}
float MidiInOut::GetParameter(PlugParamIndex index)
{
const MidiDevice &device = (index == kInputParameter) ? m_inputDevice : m_outputDevice;
return DeviceIDToParameter(device.index);
}
#ifdef MODPLUG_TRACKER
CString MidiInOut::GetParamName(PlugParamIndex param)
{
if(param == kInputParameter)
return _T("MIDI In");
else
return _T("MIDI Out");
}
// Parameter value as text
CString MidiInOut::GetParamDisplay(PlugParamIndex param)
{
const MidiDevice &device = (param == kInputParameter) ? m_inputDevice : m_outputDevice;
return mpt::ToCString(mpt::Charset::UTF8, device.name);
}
CAbstractVstEditor *MidiInOut::OpenEditor()
{
try
{
return new MidiInOutEditor(*this);
} catch(mpt::out_of_memory e)
{
mpt::delete_out_of_memory(e);
return nullptr;
}
}
#endif // MODPLUG_TRACKER
// Processing (we don't process any audio, only MIDI messages)
void MidiInOut::Process(float *, float *, uint32 numFrames)
{
if(m_midiOut.isPortOpen())
{
mpt::lock_guard<mpt::mutex> lock(m_mutex);
// Send MIDI clock
if(m_nextClock < 1)
{
if(m_sendTimingInfo)
{
m_outQueue.push_back(Message(GetOutputTimestamp(), 0xF8));
}
double bpm = m_SndFile.GetCurrentBPM();
if(bpm > 0.0)
{
m_nextClock += 2.5 * m_SndFile.GetSampleRate() / bpm;
}
}
m_nextClock -= numFrames;
double now = m_clock.Now() * (1.0 / 1000.0);
auto message = m_outQueue.begin();
while(message != m_outQueue.end() && message->m_time <= now)
{
try
{
m_midiOut.sendMessage(message->m_message, message->m_size);
} catch(const RtMidiError &)
{
}
message++;
}
m_outQueue.erase(m_outQueue.begin(), message);
}
}
void MidiInOut::InputCallback(double /*deltatime*/, std::vector<unsigned char> &message)
{
// We will check the bypass status before passing on the message, and not before entering the function,
// because otherwise we might read garbage if we toggle bypass status in the middle of a SysEx message.
bool isBypassed = IsBypassed();
if(message.empty())
{
return;
} else if(!m_bufferedInput.empty())
{
// SysEx message (continued)
m_bufferedInput.insert(m_bufferedInput.end(), message.begin(), message.end());
if(message.back() == 0xF7)
{
// End of message found!
if(!isBypassed)
ReceiveSysex(mpt::byte_cast<mpt::const_byte_span>(mpt::as_span(m_bufferedInput)));
m_bufferedInput.clear();
}
} else if(message.front() == 0xF0)
{
// Start of SysEx message...
if(message.back() != 0xF7)
m_bufferedInput.insert(m_bufferedInput.end(), message.begin(), message.end()); // ...but not the end!
else if(!isBypassed)
ReceiveSysex(mpt::byte_cast<mpt::const_byte_span>(mpt::as_span(message)));
} else if(!isBypassed)
{
// Regular message
uint32 msg = 0;
memcpy(&msg, message.data(), std::min(message.size(), sizeof(msg)));
ReceiveMidi(msg);
}
}
// Resume playback
void MidiInOut::Resume()
{
// Resume MIDI I/O
m_isResumed = true;
m_nextClock = 0;
m_outQueue.clear();
m_clock.SetResolution(1);
OpenDevice(m_inputDevice.index, true);
OpenDevice(m_outputDevice.index, false);
if(m_midiOut.isPortOpen() && m_sendTimingInfo)
{
MidiSend(0xFA); // Start
}
}
// Stop playback
void MidiInOut::Suspend()
{
// Suspend MIDI I/O
if(m_midiOut.isPortOpen() && m_sendTimingInfo)
{
try
{
unsigned char message[1] = { 0xFC }; // Stop
m_midiOut.sendMessage(message, 1);
} catch(const RtMidiError &)
{
}
}
//CloseDevice(inputDevice);
CloseDevice(m_outputDevice);
m_clock.SetResolution(0);
m_isResumed = false;
}
// Playback discontinuity
void MidiInOut::PositionChanged()
{
if(m_sendTimingInfo)
{
MidiSend(0xFC); // Stop
MidiSend(0xFA); // Start
}
}
void MidiInOut::Bypass(bool bypass)
{
if(bypass)
{
mpt::lock_guard<mpt::mutex> lock(m_mutex);
m_outQueue.clear();
}
IMidiPlugin::Bypass(bypass);
}
bool MidiInOut::MidiSend(uint32 midiCode)
{
if(!m_midiOut.isPortOpen() || IsBypassed())
{
// We need an output device to send MIDI messages to.
return true;
}
mpt::lock_guard<mpt::mutex> lock(m_mutex);
m_outQueue.push_back(Message(GetOutputTimestamp(), &midiCode, 3));
return true;
}
bool MidiInOut::MidiSysexSend(mpt::const_byte_span sysex)
{
if(!m_midiOut.isPortOpen() || IsBypassed())
{
// We need an output device to send MIDI messages to.
return true;
}
mpt::lock_guard<mpt::mutex> lock(m_mutex);
m_outQueue.push_back(Message(GetOutputTimestamp(), sysex.data(), sysex.size()));
return true;
}
void MidiInOut::HardAllNotesOff()
{
const bool wasSuspended = !IsResumed();
if(wasSuspended)
{
Resume();
}
for(uint8 mc = 0; mc < std::size(m_MidiCh); mc++) //all midi chans
{
PlugInstrChannel &channel = m_MidiCh[mc];
channel.ResetProgram();
SendMidiPitchBend(mc, EncodePitchBendParam(MIDIEvents::pitchBendCentre)); // centre pitch bend
MidiSend(MIDIEvents::CC(MIDIEvents::MIDICC_AllSoundOff, mc, 0)); // all sounds off
for(size_t i = 0; i < std::size(channel.noteOnMap); i++)
{
for(auto &c : channel.noteOnMap[i])
{
while(c != 0)
{
MidiSend(MIDIEvents::NoteOff(mc, static_cast<uint8>(i), 0));
c--;
}
}
}
}
if(wasSuspended)
{
Suspend();
}
}
// Open a device for input or output.
void MidiInOut::OpenDevice(MidiDevice::ID newDevice, bool asInputDevice)
{
MidiDevice &device = asInputDevice ? m_inputDevice : m_outputDevice;
if(device.index == newDevice && device.stream.isPortOpen())
{
// No need to re-open this device.
return;
}
CloseDevice(device);
device.index = newDevice;
device.stream.closePort();
if(device.index == kNoDevice)
{
// Dummy device
device.name = "<none>";
return;
}
device.name = device.GetPortName(newDevice);
//if(m_isResumed)
{
mpt::lock_guard<mpt::mutex> lock(m_mutex);
try
{
device.stream.openPort(newDevice);
if(asInputDevice)
{
m_midiIn.setCallback(InputCallback, this);
m_midiIn.ignoreTypes(false, true, true);
}
} catch(RtMidiError &error)
{
device.name = "Unavailable";
MidiInOutEditor *editor = dynamic_cast<MidiInOutEditor *>(GetEditor());
if(editor != nullptr)
{
Reporting::Error("MIDI device cannot be opened. Is it open in another application?\n\n" + error.getMessage(), "MIDI Input / Output", editor);
}
}
}
}
// Close an active device.
void MidiInOut::CloseDevice(MidiDevice &device)
{
if(device.stream.isPortOpen())
{
mpt::lock_guard<mpt::mutex> lock(m_mutex);
device.stream.closePort();
}
}
// Calculate the current output timestamp
double MidiInOut::GetOutputTimestamp() const
{
return m_clock.Now() * (1.0 / 1000.0) + GetOutputLatency() + m_latency;
}
// Get a device name
std::string MidiDevice::GetPortName(MidiDevice::ID port)
{
return stream.getPortName(port);
}
OPENMPT_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink