/// <summary>
/// バリエーションエフェクトを送る
/// </summary>
/// <param name="Type">種別コード</param>
/// <param name="Depth">強さ</param>
public void VariationEffect(byte[] Type, short Depth)
{
if (!IsActive)
{
return;
}
var SystemEffectEx = new SysExMessage(new byte[] { 0xf0, 0x43, 0x10, 0x4c, 0x02, 0x01, 0x5a, 0x01, 0xf7 });
MikuOutDev.Send(SystemEffectEx);
var VariationEx = new List <byte>();
VariationEx.AddRange(new byte[] { 0xf0, 0x43, 0x10, 0x4c, 0x02, 0x01, 0x40 });
VariationEx.AddRange(Type);
VariationEx.Add(0xf7);
var ExMsg = new SysExMessage(VariationEx.ToArray());
MikuOutDev.Send(ExMsg);
EnableChannels.ForEach((Channel) =>
{
var DepthMsg = new ChannelMessage(ChannelCommand.Controller, Channel, 94, Depth);
MikuOutDev.Send(DepthMsg);
});
}
public override bool Equals(object obj)
{
#region Guard
if (!(obj is SysExMessage))
{
return(false);
}
#endregion
SysExMessage message = (SysExMessage)obj;
bool equals = true;
if (this.Length != message.Length)
{
equals = false;
}
for (int i = 0; i < this.Length && equals; i++)
{
if (this[i] != message[i])
{
equals = false;
}
}
return(equals);
}
/// <summary>
/// Callback called when data dump is received from device
/// </summary>
private void OnSysExMessageReceived(object sender, SysExMessageEventArgs e)
{
switch (e.Message.Length)
{
case ExpectedCommonDumpLength + SysExUtils.DumpPaddingSize:
_logger.Receive("Received Patch.Common");
_commonDump = e.Message;
break;
case ExpectedVfxDumpLength + SysExUtils.DumpPaddingSize:
_vfxDump = e.Message;
_logger.Receive("Received Patch.VocalEffect");
break;
}
_dumpCount++;
if (_dumpCount == 2)
{
_timer.Stop();
_device.StopRecording();
_device.Dispose();
DataDumpReceived?.Invoke(this,
new CommonAndVocalFxDumpReceivedEventArgs(new CommonAndVocalEffectPatch(_commonDump, _vfxDump)));
}
}
/// <summary>
/// Initializes the MidiHeaderBuilder with the specified SysExMessage.
/// </summary>
/// <param name="message">
/// The SysExMessage to use for initializing the MidiHeaderBuilder.
/// </param>
public void InitializeBuffer(SysExMessage message)
{
// If this is a start system exclusive message.
if (message.SysExType == SysExType.Start)
{
BufferLength = message.Length;
// Copy entire message.
for (int i = 0; i < BufferLength; i++)
{
data[i] = message[i];
}
}
// Else this is a continuation message.
else
{
BufferLength = message.Length - 1;
// Copy all but the first byte of message.
for (int i = 0; i < BufferLength; i++)
{
data[i] = message[i + 1];
}
}
}
internal void SendMessages(OutputMidi[] om, SysExMessage CommonMessage)
{
foreach (int i in outMidiList)
{
om[i].outMIDI.Send(CommonMessage);
}
}
public void Record(SysExMessage message)
{
if (clock.IsRunning)
{
buffer.Add(new TimestampedMessage(clock.Ticks, message));
}
}
/// <summary>
/// Copy data from sysex dump
/// </summary>
public void CopyFrom(SysExMessage message)
{
/**
* 12 -> SysEx header & address offset
* 13 -> Tone Name(12) + Reserve(1)
* 9 -> LFO
* 10 -> Oscillator
* 10 -> Filter
* 7 -> Amplifier
* 7 -> Common(6) + Reserve(1)
* 8 -> LFO Mod Control(4) + Reserve(4)
* 1 -> Checksum
* 1 -> Footer (0xF7)
*/
var data = message.GetBytes().Skip(12).ToArray();
if (data.Length - 2 != DumpLength)
{
throw new InvalidDumpSizeException(DumpLength, data.Length);
}
Name = Encoding.ASCII.GetString(data.Take(12).ToArray());
Lfo.CopyFrom(data.Skip(13).Take(9).ToArray());
Oscillator.CopyFrom(data.Skip(22).Take(10).ToArray());
Filter.CopyFrom(data.Skip(32).Take(10).ToArray());
Amplifier.CopyFrom(data.Skip(42).Take(7).ToArray());
Common.CopyFrom(data.Skip(49).Take(7).ToArray());
LfoModControl.CopyFrom(data.Skip(56).Take(8).ToArray());
}
/// <summary>
/// Callback called when data dump is received from device
/// </summary>
private void OnSysExMessageReceived(object sender, SysExMessageEventArgs e)
{
switch (e.Message.Length)
{
case ExpectedCommonDumpLength + SysExUtils.DumpPaddingSize:
_commonDump = e.Message;
_logger.Receive("Received Patch.Common");
break;
case ExpectedPartialDumpLength + SysExUtils.DumpPaddingSize:
{
// At 11 byte we have partial identifier, so we check value at that byte
var key = (DrumKey)e.Message[10];
_partialsDump[key] = e.Message;
_logger.Receive($"Received Patch.Partials[{key}]");
break;
}
}
_dumpCount++;
if (_dumpCount == 39)
{
_timer.Stop();
_device.StopRecording();
_device.Dispose();
DataDumpReceived?.Invoke(this,
new DrumKitPatchDumpReceivedEventArgs(new Patch(_commonDump, _partialsDump)));
}
}
private void HandleSysex(SysExMessage msg)
{
if (SysexCallback != null)
{
SysexCallback.Invoke(msg.Data);
}
}
void onSysExMessageReceived(object obj, SysExMessageEventArgs e)
{
SysExMessage m = e.Message;
if (debugPrintMIDI)
{
Console.WriteLine("SysEx Message: " + m.ToString());
}
}
private void HandleMidiInMessage(Sanford.Multimedia.Midi.SysExMessage msg)
{
var data = msg.GetBytes();
var kmsg = SysExMessage.Parse(data);
if (kmsg != null)
{
lock (MessageQueue)
MessageQueue.Enqueue(kmsg);
}
}
/// <summary>
/// Copy data from sysex dumps
/// </summary>
/// <param name="common">Common sysex message</param>
/// <param name="vfx">VFX sysex message</param>
public void CopyFrom(SysExMessage common, SysExMessage vfx)
{
// Skipping 12 bytes from front because it's header and address offset
// Skipping 2 bytes from end because it's checksum and sysex footer
var commonBytes = common.GetBytes().Skip(12).ToArray();
var vfxBytes = vfx.GetBytes().Skip(12).ToArray();
Common.CopyFrom(commonBytes.Take(commonBytes.Length - 2).ToArray());
VocalEffect.CopyFrom(vfxBytes.Take(vfxBytes.Length - 2).ToArray());
}
public void SendSysExMessage(SysExMessage msg)
{
var sem = new Sanford.Multimedia.Midi.SysExMessage(
new[] { (byte)SysExType.Start }
.Concat(SysExMessage.ManufacturerId)
.Concat(SysExMessage.ProductType)
.Concat(SysExMessage.DeviceId)
.Concat(msg.GetMessageContent())
.Concat(new byte[] { 247 })
.ToArray());
OutputMidiDevice.Send(sem);
}
private void Write(SysExMessage message)
{
// System exclusive message cancel running status.
runningStatus = 0;
trackData.Add((byte)message.Status);
WriteVariableLengthValue(message.Length - 1);
for (int i = 1; i < message.Length; i++)
{
trackData.Add(message[i]);
}
}
public virtual void Send(SysExMessage message)
{
#region Require
if (IsDisposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
#endregion
lock (lockObject)
{
headerBuilder.InitializeBuffer(message);
headerBuilder.Build();
// Prepare system exclusive buffer.
int result = midiOutPrepareHeader(Handle, headerBuilder.Result, SizeOfMidiHeader);
// If the system exclusive buffer was prepared successfully.
if (result == MidiDeviceException.MMSYSERR_NOERROR)
{
bufferCount++;
// Send system exclusive message.
result = midiOutLongMsg(Handle, headerBuilder.Result, SizeOfMidiHeader);
// If the system exclusive message could not be sent.
if (result != MidiDeviceException.MMSYSERR_NOERROR)
{
midiOutUnprepareHeader(Handle, headerBuilder.Result, SizeOfMidiHeader);
bufferCount--;
headerBuilder.Destroy();
// Throw an exception.
throw new OutputDeviceException(result);
}
}
// Else the system exclusive buffer could not be prepared.
else
{
// Destroy system exclusive buffer.
headerBuilder.Destroy();
// Throw an exception.
throw new OutputDeviceException(result);
}
}
}
public void SendMMCCommand(byte command)
{
byte[] MMC = new byte[6];
MMC[0] = 0xF0;
MMC[1] = 0x7F;
MMC[2] = 0x7F;
MMC[3] = 0x06;
MMC[4] = command;
MMC[5] = 0xF7;
SysExMessage sysex = new SysExMessage(MMC);
outDevice.Send(sysex);
}
/// <summary>
/// Copy data from sysex dumps
/// </summary>
/// <param name="common"></param>
/// <param name="partials"></param>
public void CopyFrom(SysExMessage common, Dictionary <DrumKey, SysExMessage> partials)
{
// Skipping 12 bytes from front because it's header and address offset
// Skipping 2 bytes from end because it's checksum and sysex footer
var commonBytes = common.GetBytes().Skip(12).ToArray();
Common.CopyFrom(commonBytes.Take(commonBytes.Length - 2).ToArray());
foreach (var partial in partials)
{
var bytes = partial.Value.GetBytes().Skip(12).ToArray();
Partials[partial.Key].CopyFrom(bytes.Take(bytes.Length - 2).ToArray());
}
}
/// <inheritdoc />
public void Read(int inputDeviceId, int outputDeviceId)
{
// Reset dump count counter
_dumpCount = 0;
// Initialize input device
_device = new InputDevice(inputDeviceId);
// Clear previous sysex dumps
_commonDump = null;
_partialsDump.Clear();
// Setup event handler for receiving SysEx messages
_device.SysExMessageReceived += OnSysExMessageReceived;
// Start recording input from device
_device.StartRecording();
// Start timer before running task, so we have timer on the same thread
// as the callbacks for timer and input device
_timer.Start();
// Request data dump from device on separate thread
Task.Run(() =>
{
// Need to make 50ms delay between requests to ensure
// that device will not hung up
using (var output = new OutputDevice(outputDeviceId))
{
_logger.Send("Request Patch.Common");
output.Send(SysExUtils.GetRequestDumpMessage(_commonAddressOffset, _commonDumpRequest));
Thread.Sleep(50);
foreach (var vdPair in EnumHelper.GetAllValuesAndDescriptions(typeof(DrumKey)))
{
var key = (DrumKey)vdPair.Value;
_logger.Send($"Request Patch.Partial[{key}]");
output.Send(SysExUtils.GetRequestDumpMessage(PartialAddressOffset(key), _partialDumpRequest));
Thread.Sleep(50);
}
}
});
}
/// <summary>
/// 歌詞を送信する
/// </summary>
/// <param name="Lyrics">歌詞コードの配列</param>
public void Lyrics(byte[] Lyrics)
{
if (!IsActive)
{
return;
}
var LyricEx = new List <byte>();
LyricEx.AddRange(new byte[] { 0xf0, 0x43, 0x79, 0x09, 0x11, 0x0a, 0x00 });
LyricEx.AddRange(Lyrics);
LyricEx.Add(0xf7);
var ExMsg = new SysExMessage(LyricEx.ToArray());
MikuOutDev.Send(ExMsg);
}
/// <summary>
/// ポケミクをリセットする
/// </summary>
public void Reset()
{
if (!IsActive)
{
return;
}
/* All Parameter Reset */
var AllParamReset = new SysExMessage(new byte[] { 0xf0, 0x43, 0x10, 0x4c, 0x00, 0x00, 0x7f, 0x00, 0xf7 });
MikuOutDev.Send(AllParamReset);
/* XG System ON */
var XGOn = new SysExMessage(new byte[] { 0xf0, 0x43, 0x10, 0x4c, 0x00, 0x00, 0x7e, 0x00, 0xf7 });
MikuOutDev.Send(XGOn);
}
/// <summary>
/// Copy data from sysex dumps
/// </summary>
/// <param name="common">Common sysex message</param>
/// <param name="partials">SysEx messages </param>
/// <param name="modifiers"></param>
public void CopyFrom(SysExMessage common, SysExMessage[] partials, SysExMessage modifiers)
{
// Skipping 12 bytes from front because it's header and address offset
// Skipping 2 bytes from end because it's checksum and sysex footer
var commonBytes = common.GetBytes().Skip(12).ToArray();
var partialsBytes = partials.Select(partial => partial.GetBytes().Skip(12).ToArray()).ToArray();
var modifiersBytes = modifiers.GetBytes().Skip(12).ToArray();
Common.CopyFrom(commonBytes.Take(commonBytes.Length - 2).ToArray());
for (var i = 0; i < _partials.Length; i++)
{
_partials[i].CopyFrom(partialsBytes[i].Take(partialsBytes[i].Length - 2).ToArray());
}
Modifiers.CopyFrom(modifiersBytes.Take(modifiersBytes.Length - 2).ToArray());
}
/// <summary>
/// Sysex messages received
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void HandleSysExMessageReceived(object sender, SysExMessageEventArgs e)
{
context.Post(delegate(object dummy)
{
int ticks = GetTicks();
string result = "\n\n";;
foreach (byte b in e.Message)
{
result += string.Format("{0:X2} ", b);
}
sysExRichTextBox.Text += result;
// insert event
SysExMessage SMsg = new SysExMessage(e.Message.GetBytes());
track1.Insert(ticks, SMsg);
}, null);
}
public static void Send(int displayNumber, string txt1, string txt2)
{
var model = DisplayList.Where(x => x.Number == displayNumber).FirstOrDefault();
string source = "F0 00 00 66 14 12";
byte[] resultTxt = Encoding.ASCII.GetBytes(txt1);
byte[] resultTxt2 = Encoding.ASCII.GetBytes(txt2);
byte[] result = source.Split(' ').Select(item => Convert.ToByte(item, 16)).ToArray();
byte[] resultPageFirstLine = model.FirstLine.Split(' ').Select(item => Convert.ToByte(item, 16)).ToArray();
byte[] resultPageSecondLine = model.SecondLine.Split(' ').Select(item => Convert.ToByte(item, 16)).ToArray();
int lenght = result.Length + resultTxt.Length + 2;
int lenght2 = result.Length + resultTxt2.Length + 2;
byte[] sum = new byte[lenght];
byte[] sum2 = new byte[lenght2];
result.CopyTo(sum, 0);
resultPageFirstLine.CopyTo(sum, result.Length);
resultTxt.CopyTo(sum, result.Length + 1);
sum[lenght - 1] = 247;
result.CopyTo(sum2, 0);
resultPageSecondLine.CopyTo(sum2, result.Length);
resultTxt2.CopyTo(sum2, result.Length + 1);
sum2[lenght - 1] = 247;
SysExMessage sysEx = new SysExMessage(sum);
SysExMessage sysEx2 = new SysExMessage(sum2);
SendToMidiDevice.SysExSend(sysEx);
SendToMidiDevice.SysExSend(sysEx2);
}
private static void InputDevice_SysEx(SysExMessage msg)
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
MscCommand mscCommand = MscCommand.getMscCommand(msg.Data);
if (mscCommand != null)
{
if (!mscMute)
{
for (int i = 0; i < CuelistCtrl.cues.Count; ++i)
{
Cue cue = CuelistCtrl.cues[i];
if (cue.trigger != null && cue.trigger.type == TriggerType.MSC && MscCommand.Compare(mscCommand, cue.trigger.mscCmd))
{
if (Core.win.saveTriggerCheckbox.IsChecked && Core.win.cueTable.SelectedIndex != i)
{
LogCtrl.Error("In: " + mscCommand.message);
}
else
{
LogCtrl.Success("In: " + mscCommand.message);
GoCtrl.Go(i);
}
return;
}
}
LogCtrl.Status("In: " + mscCommand.message);
}
else
{
LogCtrl.Warning("In: " + mscCommand.message);
}
}
}));
}
private void HandleSysExMessage(object state)
{
lock (lockObject)
{
IntPtr headerPtr = (IntPtr)state;
MidiHeader header = (MidiHeader)Marshal.PtrToStructure(headerPtr, typeof(MidiHeader));
if (!resetting)
{
for (int i = 0; i < header.bytesRecorded; i++)
{
sysExData.Add(Marshal.ReadByte(header.data, i));
}
if (sysExData[0] == 0xF0 && sysExData[sysExData.Count - 1] == 0xF7)
{
SysExMessage message = new SysExMessage(sysExData.ToArray());
sysExData.Clear();
OnSysExMessageReceived(new SysExMessageEventArgs(message));
}
int result = AddSysExBuffer();
if (result != MIDIExceptions.MMSYSERR_NOERROR)
{
Exception ex = new InputDeviceException(result);
OnError(new ErrorEventArgs(ex));
}
}
ReleaseBuffer(headerPtr);
}
}
private bool WriteResult(string valReq, XElement addrElement, SysExMessage msg, TimeSpan to)
{
var r = Driver.Device.SendWithResult(msg, to);
object result = null;
if (r is WriteValueMessage wvm)
{
result = wvm.Value;
}
if (r is WriteStringValueMessage wsm)
{
result = wsm.Value;
}
if (String.IsNullOrEmpty(valReq) || result == null)
{
return(false);
}
addrElement.Add(new XAttribute($"{valReq}Value", result));
return(true);
}
/// <summary>
/// コーラスを送る
/// </summary>
/// <param name="Type">種別コード</param>
/// <param name="Depth">強さ</param>
public void Chorus(byte[] Type, short Depth)
{
if (!IsActive)
{
return;
}
var ChorusEx = new List <byte>();
ChorusEx.AddRange(new byte[] { 0xf0, 0x43, 0x10, 0x4c, 0x02, 0x01, 0x20 });
ChorusEx.AddRange(Type);
ChorusEx.Add(0xf7);
var ExMsg = new SysExMessage(ChorusEx.ToArray());
MikuOutDev.Send(ExMsg);
EnableChannels.ForEach((Channel) =>
{
var DepthMsg = new ChannelMessage(ChannelCommand.Controller, Channel, 93, Depth);
MikuOutDev.Send(DepthMsg);
});
}
public virtual void Send(SysExMessage message)
{
}
private void sysExAnswer(SysExMessage m)
{
byte[] msg = m.Data;
byte[] stopBytes = { 240, 0, 32, 41, 2, 24, 21, 247 };
}
private void sysExAnswer(SysExMessage m)
{
byte[] msg = m.Data;
byte[] stopBytes = sysexHeader.Concat(new byte[] { 21, 247 }).ToArray();
}
/// <inheritdoc />
/// <summary>
/// Creates new instance of AnalogPatch using sysex dump
/// </summary>
public Patch(SysExMessage message) : this()
{
CopyFrom(message);
}
