function getPorts() {
var inputCount = i.getPortCount(),
outputCount = o.getPortCount(),
id,
portMap = {inputs: [], outputs: []};
for (id = 0; id < inputCount; id++) {
if (!inputs[id]) {
inputs[id] = new midi.input();
inputs[id].openPort(id);
}
portMap.inputs.push(i.getPortName(id));
}
for (id = 0; id < outputCount; id++) {
if (!outputs[id]) {
outputs[id] = new midi.output();
outputs[id].openPort(id);
}
portMap.outputs.push(o.getPortName(id))
}
this.portMap = portMap;
return portMap;
}
setupMidi() {
let controllerInPortNumber = null;
let controllerOutPortNumber = null;
const controllerName = this.sharedConfig.get('midiController');
for (let i = 0; i < this.midiIn.getPortCount(); i++) {
if (this.midiIn.getPortName(i) == controllerName) {
controllerInPortNumber = i;
break;
}
}
for (let i = 0; i < this.midiOut.getPortCount(); i++) {
if (this.midiOut.getPortName(i) == controllerName) {
controllerOutPortNumber = i;
break;
}
}
if (controllerInPortNumber !== null && controllerOutPortNumber !== null) {
this.midiIn.openPort(controllerInPortNumber);
this.midiOut.openPort(controllerOutPortNumber);
this.useMidi = true;
this.midiIn.on('message', function(deltaTime, message) {
console.log('m:' + message + ' d:' + deltaTime);
});
} else {
console.warn('No midi controller found!');
this.useMidi = false;
}
}
lightArray.on('ready', function(){
// initialize midi stuff
midiInput = new midi.input();
midiInput.openVirtualPort("LightArray");
lightArray.start();
midiInput.on('message', function(time, message){console.log(message);
if (message[0] === 176 && 41 < message[1] < 46){
lightArray.update(message[1] - 42, message[2]);
}
});
// initialize remote
remoteBrowser = mdns.createBrowser(new mdns.ServiceType('lightarray', 'tcp'));
remoteBrowser.on('serviceUp', function(service) {
remoteAddress = service.addresses[0];
remotePort = service.port;
console.log('attempting connection to remote at ' + remoteAddress + ':' + remotePort)
remote = ioClient.connect("http://" + remoteAddress + ":" + remotePort);
if (remote){
console.log('successfully connected to remote');
lightArray.setRemote(remote);
}
});
remoteBrowser.start();
// initialize web server stuff
server.listen(8000);
console.log('listening');
});
const listMidiInputPorts = () => {
var inputs = []
for (var i = 0; i < input.getPortCount(); i++) {
inputs.push(input.getPortName(i))
}
input.closePort()
return inputs
}
function enumerate() {
console.log('Usage - specify numeric port arg as first argument');
console.log('input ports');
for(var i=0; i < inportcount; i++) {
var name = input.getPortName(i);
console.log(i + ' ' + name);
}
console.log();
console.log('output ports');
for(var i=0; i < outportcount; i++) {
var name = output.getPortName(i);
console.log(i + ' ' + name);
}
input.closePort();
output.closePort();
}
.on('connection', function(socket) {
try {
var input = new midi.input();
input.openPort(port);
input.on('message', function(delay, message) {
socket.emit('midi', message);
});
socket.on('disconnect', function() {
input.closePort(port);
});
} catch(e) {}
});
app.sockets.on('connection', function (socket) {
input.on('message', function(deltaTime, message) {
app.sockets.emit('message', { key: message[1], vol: message[2]});
console.log(message)
});
})
const main = () => {
const filename = process.argv[4]
const clockDeviceName = process.argv[2]
const messageDeviceName = process.argv[3]
Console.log('Starting recording to', filename)
const fileStream = fs.createWriteStream(filename)
const stdin = RxNode.fromStream(process.stdin, 'end')
stdin.finally(() => fileStream.end())
const clockInput = new midi.input()
clockInput.ignoreTypes(false, false, false)
const messageInput = new midi.input()
messageInput.ignoreTypes(false, false, false)
const closePorts = () => {
Console.log('Closing ports')
clockInput.closePort()
messageInput.closePort()
}
process.on('exit', closePorts)
process.on('SIGINT', closePorts)
process.on('uncaughtException', closePorts)
const clockInputSubject = new Rx.Subject()
clockInput.on('message', (deltaTime, message) => clockInputSubject.onNext([deltaTime, message]))
const clock = clockInputSubject.filter(R.flip(R.contains)([ClockTick, ClockStart]))
const messageInputSubject = new Rx.Subject()
messageInput.on('message', (deltaTime, message) => messageInputSubject.onNext([deltaTime, message]))
const messages = messageInputSubject.filter(R.complement(R.flip(R.contains)([ClockTick, ClockStart])))
clockInput.openPort(getPortNumber(clockDeviceName))
messageInput.openPort(getPortNumber(messageDeviceName))
const position = clock.scan(([phrase, bar, beat, tick], message) => {
if (R.equals(message, ClockStart)) {
return [0,0,0,0]
}
const tickOverflow = tick === 23 ? 1 : 0
tick = (tick + 1) % 24
const beatOverflow = beat === 3 && tickOverflow ? 1 : 0
beat = (beat + tickOverflow) % 4
const barOverflow = bar === 3 && beatOverflow ? 1 : 0
bar = (bar + beatOverflow) % 4
phrase += barOverflow
return [phrase, bar, beat, tick]
}, [0, 0, 0, 0])
messages.withLatestFrom(position, Array)
.map(R.reverse)
.map(JSON.stringify)
.subscribe(serializedData => fileStream.write(serializedData + '\n'))
}
socket.on('disconnect', function () {
try{
midi_input.closePort(0);
}catch(err){
console.log(err);
}
//midi_input = new midi.input();
});
prompt.get(properties, function (err, result) {
if (err) { return onErr(err); }
var inputId = result.inputId;
var outputId = result.outputId;
if (inputId) {
inputId = parseInt(result.inputId, 0);
console.log('Selected input device: ' + input.getPortName(inputId));
input.openPort(inputId);
}
if (outputId) {
outputId = parseInt(result.outputId, 0);
console.log('Selected output device: ' + output.getPortName(outputId));
output.openPort(inputId);
} else {
output = null;
}
});
module.exports.addInputRange = function(port, lowerBound, upperBound) {
var midiIn = new midi.input();
var portName = midiIn.getPortName(port);
midiIn.openPort(port);
midiIns[portName] = midiIn;
// If bounds are undefined, "learn" them
if (typeof lowerBound === "undefined") {
learnBounds();
} else {
finishSetup();
}
function learnBounds() {
console.log("Listening for lower bound note on %s...", portName);
midiIn.on("message", function learnBoundsHandler(dT, message) {
// Note On messages with velocity > 0
if (message[0] >= 0x90 && message[0] <= 0x9F && message[2] > 0) {
if (typeof lowerBound === "undefined") {
lowerBound = message[1];
console.log("Listening for upper bound note on %s...", portName);
} else {
upperBound = message[1];
midiIn.removeListener("message", learnBoundsHandler);
finishSetup();
}
}
});
}
function finishSetup() {
console.log("Connecting %s from %s to %s", portName, midiUtil.humanizeNote(lowerBound), midiUtil.humanizeNote(upperBound));
midiIn.on("message", function (deltaTime, message) {
return handleMIDI(portName, deltaTime, message);
});
for (var i = lowerBound; i <= upperBound; i++) {
sb.addPublish(portName + " - " + midiUtil.humanizeNote(i), "boolean", "false");
}
}
};
function finishSetup() {
console.log("Connecting %s from %s to %s", portName, midiUtil.humanizeNote(lowerBound), midiUtil.humanizeNote(upperBound));
midiIn.on("message", function (deltaTime, message) {
return handleMIDI(portName, deltaTime, message);
});
for (var i = lowerBound; i <= upperBound; i++) {
sb.addPublish(portName + " - " + midiUtil.humanizeNote(i), "boolean", "false");
}
}
stopRecording() {
if (this.useMidi) {
const note = this.sharedConfig.get('baseNote');
for (let i = 0; i < this.sharedConfig.get('steps'); i++)
this.midiOut.sendMessage([128, note+i, 0]);
this.midiIn.closePort();
this.midiOut.closePort();
}
clearInterval(this.intervalId);
}
midiIn.on("message", function learnBoundsHandler(dT, message) {
// Note On messages with velocity > 0
if (message[0] >= 0x90 && message[0] <= 0x9F && message[2] > 0) {
if (typeof lowerBound === "undefined") {
lowerBound = message[1];
console.log("Listening for upper bound note on %s...", portName);
} else {
upperBound = message[1];
midiIn.removeListener("message", learnBoundsHandler);
finishSetup();
}
}
});
io.sockets.on('connection', function (socket) {
sp.on('data', function(input){
var arduino_data = input;
input = parseInt(input);
buffer.push(input);
if (buffer.length == 6) {
var message = new Array(buffer[0], buffer[2], buffer[4]);
console.log(message);
io.sockets.emit('msg', {message : message});
buffer.splice(0, 5);
}
// socket.emit('one', {led : arduino_data});
});
midiIn.on('message', function(deltaTime, message) {
console.log('m:' + message + ' d:' + deltaTime);
io.sockets.emit('msg', {message : message});
});
/*
// note
socket.on('notedown',function(data){
midiOdata.message,100]);
console.log('Notedown: ' + data.message);
socket.broadcast.emit('playeddown',{'message':data.message});
});
// note stop
socket.on('noteup',function(data){
midiOut.sendMessage([128,data.message,100]);
console.log('Noteup : ' + data.message);
socket.broadcast.emit('playedup',{'message':data.message});
});
// controller
socket.on('controller',function(data){
var message = parseInt(data.message,10);
console.log('Log : ' + data.message);
midiOut.sendMessage([message,0,0]);
});
*/
});
const getPortNumber = name => {
const input = new midi.input()
const listMidiInputPorts = () => {
var inputs = []
for (var i = 0; i < input.getPortCount(); i++) {
inputs.push(input.getPortName(i))
}
input.closePort()
return inputs
}
var midiInputPorts = listMidiInputPorts()
Console.log(midiInputPorts, name, midiInputPorts.indexOf(name))
if (midiInputPorts.indexOf(name) == -1) {
throw `Port ${name} not found! Available ports: ${midiInputPorts.join(', ')}`
}
return midiInputPorts.indexOf(name)
}
io.sockets.on('connection', function (socket) {
try{
midi_input.openPort(0);
}catch(err){
console.log(err);
}
socket_reference = socket;
//get list of videos
fs.readdir("../public/vids", function(err, files){
socket.emit('videos', files);
});
//close the port
socket.on('disconnect', function () {
try{
midi_input.closePort(0);
}catch(err){
console.log(err);
}
//midi_input = new midi.input();
});
});
io.on('connection', function (socket) {
socket.emit('ping', true);
input.on('message', function(deltaTime, message) {
var note = [deltaTime, message];
if (recording) {
song.push(note);
}
else if (replaying) {
socket.emit('score', score.update(note));
}
socket.emit('note', note);
});
socket.on('record', function(data) {
recording = data;
if (recording) {
song = [];
console.log('Recording started');
}
else {
console.log('Recording stopped');
}
});
socket.on('replay', function(data) {
replaying = data;
if (replaying) {
score = new Score(song);
console.log('Replaying started');
}
else {
console.log('Replaying stopped');
}
});
});
var midi = require('midi');
var http = require('http');
var WebSocketServer = require('websocket').server;
var input = new midi.input();
var connections = [];
input.getPortCount();
input.getPortName(0);
// Configure a callback.
input.on('message', function(deltaTime, message) {
// The message is an array of numbers corresponding to the MIDI bytes:
// [status, data1, data2]
// https://www.cs.cf.ac.uk/Dave/Multimedia/node158.html has some helpful
// information interpreting the messages.
// console.log('m:' + message + ' d:' + deltaTime);
if (message.length === 1) { return; }
for (var c in connections) {
connections[c].sendUTF(JSON.stringify({ data: message }));
}
});
var server = http.createServer(function(request, response) {
console.log((new Date()) + ' Received request for ' + request.url);
response.writeHead(404);
response.end();
});
server.listen(8080, function() {
console.log((new Date()) + ' Server is listening on port 8080');
});
function onExit() {
console.log('Exit MIDISocket WebSocket Server');
input.closePort();
}
var midi = require('midi');
var input = new midi.input();
var output = new midi.output();
//input.getPortCount();
//input.getPortName(0);
output.openVirtualPort('NodeMidi');
var state='X', m1=0;
var MSB=0, LSB=[];
var x=0, y=0, z=0;
input.on('message', function(deltaTime, message) {
// m1スライダをガチャガチャ
if (message[0]==176 && message[1]==1){
m1=message[2];
output.sendMessage(message);
}
// ノブをいじった信号
else if(message[0]==176 && message[1]==99){
if(message[2]==0){ // knob X
state = 'X';
}
if(message[2]==2){ // knob Y
state = 'Y';
}
if(message[2]==4){ // knob Z
state = 'Z';
}
const instrumentChoices = Array.from({length: numInputs}, (_, i) => ({
name: input.getPortName(i),
value: i,
})).concat({name: 'Computer keyboard', value: -1});
var midi = require('midi');
var input = new midi.input();
input.getPortCount();
input.getPortName(0);
var state;
var MSB=0, LSB=[];
input.on('message', function(deltaTime, message) {
// ノブをいじった信号
if(message[0]==176 && message[1]==99){
if(message[2]==0){ // knob X
state = 'X';
console.log("X");
}
if(message[2]==2){ // knob Y
console.log("Y");
state = 'Y';
}
if(message[2]==4){ // knob Z
console.log("Z");
state = 'Z';
}
}
// MSBがきましたよ
else if(message[0]==176 && message[1]==6){
MSB = message[2]; // MSBを保存(必ずこのあとにLSBが来る)
}
// LSBがきましたよ
var midi = require('midi'),
mal = require('../'),
rtpmidi = require('rtpmidi');
var input = new midi.input(),
output = new midi.output();
input.openVirtualPort("Test Input");
input.ignoreTypes(false, false, false);
output.openVirtualPort("Test Output");
var session = rtpmidi.manager.createSession({
name: 'Network Session',
port: 5006
});
session.connect({
address: '127.0.0.1',
port: 5004
});
var port = new mal.VirtualPort();
// Add some inputs and outputs to our virtual port
port.addInput(input);
port.addInput(session);
port.addOutput(output);
port.addOutput(session);
var midi = require('midi'),
input = new midi.input(),
output = new midi.output(),
listener = false,
inputPortCount = input.getPortCount(),
outputPortCount = output.getPortCount(),
foundInputPort = false,
foundOutputPort = false,
i;
var transmitMessage = function(deltaTime, message) {
if(listener) {
listener(message);
}
};
input.on('message', transmitMessage);
// find input port
for(i = 0; i < inputPortCount; i++) {
if(input.getPortName(i).indexOf('Yamaha 01V96') !== -1) {
console.log('[mixer_midi] MIDI input port ' + i);
input.openPort(i);
var T = require('timbre');
var midi = require('midi');
var input = new midi.input();
input.openPort(0);
var synth = T("SynthDef").play();
synth.def = function(opts) {
var osc1, osc2, env;
osc1 = T("saw", {freq:opts.freq , mul:0.25});
osc2 = T("saw", {freq:opts.freq * 1.0045, mul:0.20});
var bpf = T("bpf", {freq: 660, Q: 3}, osc1, osc2);
env = T("adsr", {a:100,d:250,s:0.6,r:500}, bpf);
return env.on("ended", opts.doneAction).bang();
};
input.on('message', function(deltaTime, message) {
var note = message[1];
if (message[2] == 0) {
synth.noteOff(message[1]);
} else {
synth.noteOn(message[1], message[2]);
}
});
var express = require('express'),
app = express(),
server = require('http').Server(app),
io = require('socket.io')(server),
midi = require('midi'),
Score = require('./lib/score')
Dwolla = require('./lib/dwolla');
var song = [],
score = new Score(song),
recording = false,
replaying = false,
wager = 0.1,
players = [],
input = new midi.input(),
config = require(process.argv[3]),
dwolla = new Dwolla(config);
app.use("/", express.static(__dirname + '/public'));
app.get('/', function (req, res) {
res.sendfile(__dirname + '/index.html');
});
app.get('/status', function(req, res) {
res.send({
'recording': recording,
'replaying': replaying,
'score': score.update()
});
});
*/
const fs = require('fs');
const inquirer = require('inquirer');
const {parseMidi} = require('midi-file');
const midi = require('midi');
// Helpers
const isType = a => ({type}) => type === a;
const bye = msg => {
console.error(msg);
process.exit(1);
};
// Set up a new MIDI input.
const input = new midi.input();
const numInputs = input.getPortCount();
const instrumentChoices = Array.from({length: numInputs}, (_, i) => ({
name: input.getPortName(i),
value: i,
})).concat({name: 'Computer keyboard', value: -1});
// Pull in a list of tracks from the MIDI file.
const fileName = process.argv[2] || './rondo_alla_turca.mid';
const midiFile = fs.readFileSync(fileName);
const {header: {ticksPerBeat}, tracks} = parseMidi(midiFile);
// We only care about MIDI tracks containing "noteOn" signals. Filter the rest.
const trackChoices = tracks
.map(track => {
// Since we only care about "noteOn" signals, we'll remove other types
app.use(app.router);
app.use(express.static(path.join(__dirname, 'public')));
});
app.get('/', function(req, res) {
res.render('index', { title: 'Worldeater' });
});
var server = http.createServer(app);
var serverio = io.listen(server);
server.listen(app.get('port'));
console.log('listening on port ' + app.get('port'));
var midi = require('midi');
var inputName = "Daemon Input 0";
var input = new midi.input();
for (var i = 0; i < input.getPortCount(); ++i) {
if (input.getPortName(i) == inputName) {
console.log('Input found: ' + input.getPortName(i));
console.log('Opening ' + input.getPortName(i));
input.openPort(i);
}
}
input.on('message', function(deltaTime, message) {
console.log('input m:' + message + ' d:' + deltaTime);
serverio.sockets.emit('midi', message);
});
inquirer.prompt(questions).then(({
instrument,
track,
groupChords,
chordThreshold,
}) => {
function triggerNextNote () {
// Notes are grouped into their own arrays so that chords can be kept
// together. The first note of a group is played immediately; anything
// following that might have an offset added based on the cumulative
// deltaTime since the original note.
//
// This uses reduce for side-effects only (yuck).
track.shift().reduce((dt, chord) => {
const {noteNumber, velocity, deltaTime} = chord;
const playTime = dt + deltaTime;
setTimeout(_ => output.sendMessage([0x90, noteNumber, velocity]),
dt);
setTimeout(_ => output.sendMessage([0x80, noteNumber, 0]),
dt + 200);
return playTime;
}, 0);
// Exit the app once the last note is played.
if (!track.length) {bye('Thanks for playing!');}
}
// Group notes that play at the same time (or in quick succession) into
// chords.
track = track.reduce((acc, cur, i) => {
if (!groupChords || cur.deltaTime > chordThreshold || !i) {
// Make it the first note in its own chord.
acc.push([Object.assign({}, cur, {deltaTime: 0})]);
} else {
// Add it as part of an existing chord.
acc[acc.length - 1].push(cur);
}
return acc;
}, []);
// Listen to stdin for ctrl-c, ctrl-d, and esc.
const {stdin} = process;
stdin.setRawMode(true);
stdin.resume();
stdin.setEncoding('utf8');
stdin.on('data', key => {
if (['\u0003', '\u0004', '\u001b'].includes(key)) {process.exit();}
});
console.log('\nYou can exit at any time by hitting the Esc key.\n');
if (instrument === -1) {
// Also listen for anything else and trigger a keystroke.
stdin.on('data', triggerNextNote);
} else {
// If they chose MIDI, open the port and trigger on "noteOn" signals.
input.openPort(instrument);
input.on('message', (_, [status, __, velocity]) => {
if (status !== 0x90 || !velocity) {return;}
triggerNextNote();
});
}
});