1817 lines
49 KiB
JavaScript
1817 lines
49 KiB
JavaScript
(function (context, $) {
|
|
|
|
"use strict";
|
|
|
|
context.JK = context.JK || {};
|
|
context.JK.FakeJamClient = function (app, p2pMessageFactory) {
|
|
var ChannelGroupIds = context.JK.ChannelGroupIds
|
|
var logger = context.JK.logger;
|
|
logger.info("*** Fake JamClient instance initialized. ***");
|
|
|
|
// Change this to false if you want to see FTUE with fake jam client
|
|
var ftueStatus = true;
|
|
var eventCallbackName = '';
|
|
var alertCallbackName = '';
|
|
var eventCallbackRate = 1000;
|
|
var vuValue = -70;
|
|
var vuChange = 10;
|
|
var callbackTimer = null;
|
|
var _mix = -30;
|
|
var device_id = -1;
|
|
var latencyCallback = null;
|
|
var frameSize = 2.5;
|
|
var fakeJamClientRecordings = null;
|
|
var p2pCallbacks = null;
|
|
var videoShared = false;
|
|
var metronomeActive = false;
|
|
var metronomeBPM = false;
|
|
var metronomeSound = false;
|
|
var metronomeMeter = 0;
|
|
var backingTrackPath = "";
|
|
var backingTrackLoop = false;
|
|
var simulateNoInputs = false;
|
|
|
|
function dbg(msg) {
|
|
logger.debug('FakeJamClient: ' + msg);
|
|
}
|
|
|
|
// Bummer that javascript doesn't have much in the way of reflection.
|
|
// arguments.callee.name would probably do what we want, but it's deprecated
|
|
// and not allowed when using "strict"
|
|
// (Wishing I could write a single function which debug logs the name of the
|
|
// current function and a JSON stringify of the arguments).
|
|
|
|
function getClientParentChildRole() {
|
|
// 0 = client
|
|
// 1 = parent
|
|
return 1;
|
|
}
|
|
|
|
function getParentClientId() {
|
|
return null;
|
|
}
|
|
|
|
function applySubscriptionPolicy() {
|
|
|
|
}
|
|
function OpenSystemBrowser(href) {
|
|
dbg("OpenSystemBrowser('" + href + "')");
|
|
context.window.open(href);
|
|
}
|
|
|
|
function RestartApplication() {
|
|
}
|
|
|
|
function ShutdownApplication() {
|
|
}
|
|
|
|
function FTUEPageEnter() {
|
|
}
|
|
|
|
function FTUEPageLeave() {
|
|
}
|
|
|
|
function FTUECancel() {
|
|
}
|
|
|
|
function FTUEGetMusicProfileName() {
|
|
|
|
if (simulateNoInputs) {
|
|
return "System Default (Playback Only)"
|
|
}
|
|
else {
|
|
return "FTUEAttempt-1"
|
|
}
|
|
}
|
|
|
|
function FTUESetMusicProfileName() {
|
|
|
|
}
|
|
|
|
function FTUESetPreferredMixerSampleRate() {
|
|
}
|
|
|
|
function FTUESetPreferredOutputSampleRate() {
|
|
}
|
|
|
|
function FTUESetPreferredChatSampleRate() {
|
|
}
|
|
|
|
function FTUEgetInputDeviceSampleRate() {
|
|
return 44100;
|
|
}
|
|
|
|
function FTUEgetOutputDeviceSampleRate() {
|
|
return 44100;
|
|
}
|
|
|
|
|
|
function FTUESelectVideoCaptureDevice(device, settings) {
|
|
return true;
|
|
}
|
|
|
|
function FTUESetVideoEncodeResolution(resolution) {
|
|
|
|
}
|
|
|
|
function testVideoRender() {
|
|
|
|
}
|
|
|
|
function FTUEGetVideoCaptureDeviceNames() {
|
|
return {"xy323ss": "Built-in Webcam HD"}
|
|
}
|
|
|
|
function FTUECurrentSelectedVideoDevice() {
|
|
//return {}
|
|
return {"xy323ss": "Built-in Webcam HD"}
|
|
}
|
|
|
|
function FTUEGetAvailableEncodeVideoResolutions() {
|
|
return {
|
|
1: "CIF (352X288)",
|
|
2: "VGA (640X480)",
|
|
3: "4CIF (704X576)",
|
|
4: "1/2WHD (640X360)",
|
|
5: "WHD (1280X720)",
|
|
6: "FHD (1920x1080)"
|
|
}
|
|
}
|
|
|
|
function FTUEGetVideoCaptureDeviceCapabilities() {
|
|
return {}
|
|
}
|
|
|
|
function FTUESetSendFrameRates(fps) {
|
|
|
|
}
|
|
|
|
function FTUEGetSendFrameRates() {
|
|
return {20: 20, 24: 24, 30: 30}
|
|
}
|
|
|
|
function GetCurrentVideoResolution() {
|
|
return 3;
|
|
}
|
|
|
|
function GetCurrentVideoFrameRate() {
|
|
return 30;
|
|
}
|
|
|
|
function GetSampleRate() {
|
|
return 48;
|
|
}
|
|
|
|
function FTUESetVideoShareEnable() {
|
|
|
|
}
|
|
|
|
function FTUEGetVideoShareEnable() {
|
|
return false;
|
|
}
|
|
|
|
function isSessVideoShared() {
|
|
return videoShared;
|
|
}
|
|
|
|
function SessStopVideoSharing() {
|
|
videoShared = false;
|
|
}
|
|
|
|
function SessStartVideoSharing(bitrate) {
|
|
if (!bitrate || typeof(bitrate) == "undefined") {
|
|
bitrate = 0
|
|
}
|
|
videoShared = true;
|
|
}
|
|
|
|
function IsVstLoaded() {
|
|
return false;
|
|
}
|
|
|
|
function hasVstAssignment() {
|
|
return false;
|
|
}
|
|
|
|
function FTUEGetInputLatency() {
|
|
dbg("FTUEGetInputLatency");
|
|
return 2;
|
|
}
|
|
|
|
function FTUESetInputLatency(latency) {
|
|
dbg("FTUESetInputLatency:" + latency);
|
|
}
|
|
|
|
function FTUEGetOutputLatency() {
|
|
dbg("FTUEGetOutputLatency");
|
|
return 2;
|
|
}
|
|
|
|
function FTUESetOutputLatency(latency) {
|
|
dbg("FTUESetOutputLatency:" + latency);
|
|
}
|
|
|
|
function FTUEGetVolumeRanges() {
|
|
dbg("FTUEGetVolumeRanges");
|
|
return {
|
|
input_maximum: 20,
|
|
input_minimum: -80,
|
|
output_maximum: 20,
|
|
output_minimum: -80
|
|
};
|
|
}
|
|
|
|
function FTUEHasControlPanel() {
|
|
dbg("FTUEHasControlPanel");
|
|
return true;
|
|
}
|
|
|
|
function FTUEGetFrameSize(newSize) {
|
|
dbg("FTUEGetFrameSize");
|
|
return frameSize;
|
|
}
|
|
|
|
function FTUESetFrameSize(newSize) {
|
|
dbg("FTUESetFrameSize:" + newSize);
|
|
// one of 2.5, 5 or 10
|
|
frameSize = newSize;
|
|
}
|
|
|
|
function FTUEOpenControlPanel() {
|
|
dbg("FTUEOpenControlPanel");
|
|
context.alert("Simulated ASIO Dialog");
|
|
}
|
|
|
|
function FTUEInit() {
|
|
dbg("FTUEInit");
|
|
}
|
|
|
|
function FTUERefreshDevices() {
|
|
dbg("FTUERefreshDevices()");
|
|
}
|
|
|
|
function FTUESave(b) {
|
|
dbg("FTUESave(" + b + ")");
|
|
return {};
|
|
}
|
|
|
|
function FTUEGetStatus() {
|
|
return ftueStatus;
|
|
}
|
|
|
|
function FTUESetStatus(b) {
|
|
ftueStatus = b;
|
|
}
|
|
|
|
function FTUESetMusicDevice(id) {
|
|
dbg("FTUESetMusicDevice");
|
|
}
|
|
|
|
function FTUEGetAudioDevices() {
|
|
return {
|
|
"devices": [{
|
|
"display_name": "Built-in",
|
|
"guid": "Built-in",
|
|
"input_count": 1,
|
|
"name": "Built-in",
|
|
"output_count": 1,
|
|
"port_audio_name": "Built-in"
|
|
}, {
|
|
"display_name": "JamKazam Virtual Monitor",
|
|
"guid": "JamKazam Virtual Monitor",
|
|
"input_count": 0,
|
|
"name": "JamKazam Virtual Monitor",
|
|
"output_count": 1,
|
|
"port_audio_name": "JamKazam Virtual Monitor"
|
|
}]
|
|
}
|
|
}
|
|
|
|
function FTUEGetDevices() {
|
|
dbg('FTUEGetMusicDevices');
|
|
return {
|
|
"ASIO4ALL v2": "ASIO4ALL v2 - ASIO",
|
|
"M-Audio FW ASIO": "M-AUDIO FW ASIO - ASIO"
|
|
};
|
|
}
|
|
|
|
function FTUEGetMusicInputs() {
|
|
dbg('FTUEGetMusicInputs');
|
|
return {
|
|
"i~11~MultiChannel (FWAPMulti)~0^i~11~Multichannel (FWAPMulti)~1": "Multichannel (FWAPMulti) - Channel 1/Multichannel (FWAPMulti) - Channel 2"
|
|
};
|
|
}
|
|
|
|
function FTUEGetMusicOutputs() {
|
|
dbg('FTUEGetMusicOutputs');
|
|
return {
|
|
"o~11~Multichannel (FWAPMulti)~0^o~11~Multichannel (FWAPMulti)~1": "Multichannel (FWAPMulti) - Channel 1/Multichannel (FWAPMulti) - Channel 2"
|
|
};
|
|
}
|
|
|
|
function FTUEGetChatInputs() {
|
|
dbg('FTUEGetChatInputs');
|
|
return {
|
|
"i~11~MultiChannel (FWAPMulti)~0^i~11~Multichannel (FWAPMulti)~1": "Multichannel (FWAPMulti) - Channel 1/Multichannel (FWAPMulti) - Channel 2"
|
|
};
|
|
}
|
|
|
|
function FTUEGetChannels() {
|
|
return {
|
|
"inputs": [
|
|
{
|
|
"assignment": 1,
|
|
"chat": false,
|
|
"device_id": "Built-in Microph",
|
|
"device_type": 5,
|
|
"id": "i~5~Built-in Microph~0~0~Built-in",
|
|
"name": "Built-in Microph - Left",
|
|
"number": 0
|
|
},
|
|
{
|
|
"assignment": 0,
|
|
"chat": false,
|
|
"device_id": "Built-in Microph",
|
|
"device_type": 5,
|
|
"id": "i~5~Built-in Microph~1~0~Built-in",
|
|
"name": "Built-in Microph - Right",
|
|
"number": 1
|
|
}
|
|
],
|
|
"outputs": [
|
|
{
|
|
"assignment": -1,
|
|
"chat": false,
|
|
"device_id": "Built-in Output",
|
|
"device_type": 5,
|
|
"id": "o~5~Built-in Output~0~0~Built-in",
|
|
"name": "Built-in Output - Left",
|
|
"number": 0
|
|
},
|
|
{
|
|
"assignment": -1,
|
|
"chat": false,
|
|
"device_id": "Built-in Output",
|
|
"device_type": 5,
|
|
"id": "o~5~Built-in Output~1~0~Built-in",
|
|
"name": "Built-in Output - Right",
|
|
"number": 1
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
function FTUEClearChannelAssignments() {
|
|
}
|
|
|
|
function FTUEClearChatInput() {
|
|
}
|
|
|
|
function FTUEGetAudioDevices() {
|
|
return {
|
|
"devices": [
|
|
{
|
|
"display_name": "Built-in",
|
|
"guid": "Built-in",
|
|
"input_count": 1,
|
|
"name": "Built-in",
|
|
"output_count": 1,
|
|
"port_audio_name": "Built-in"
|
|
},
|
|
{
|
|
"display_name": "JamKazam Virtual Monitor",
|
|
"guid": "JamKazam Virtual Monitor",
|
|
"input_count": 0,
|
|
"name": "JamKazam Virtual Monitor",
|
|
"output_count": 1,
|
|
"port_audio_name": "JamKazam Virtual Monitor"
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
function FTUEStartIoPerfTest() {
|
|
}
|
|
|
|
function FTUEGetIoPerfData() {
|
|
return {
|
|
"in_var": 0.15,
|
|
"out_var": 0.25,
|
|
"in_median": 399.9,
|
|
"out_median": 400.3,
|
|
"in_target": 400,
|
|
"out_target": 400
|
|
};
|
|
}
|
|
|
|
function FTUESetInputMusicDevice() {
|
|
}
|
|
|
|
function FTUESetOutputMusicDevice() {
|
|
}
|
|
|
|
function FTUEGetInputMusicDevice() {
|
|
return 'Built-in';
|
|
}
|
|
|
|
function FTUEGetOutputMusicDevice() {
|
|
return 'Built-in';
|
|
}
|
|
|
|
function FTUESetMusicInput() {
|
|
dbg('FTUESetMusicInput');
|
|
}
|
|
|
|
function FTUESetChatInput() {
|
|
dbg('FTUESetChatInput');
|
|
}
|
|
|
|
function FTUESetMusicOutput() {
|
|
dbg('FTUESetMusicOutput');
|
|
}
|
|
|
|
function FTUEGetInputVolume() {
|
|
dbg('FTUEGetInputVolume');
|
|
return -60;
|
|
}
|
|
|
|
function FTUESetInputVolume() {
|
|
dbg('FTUESetInputVolume');
|
|
}
|
|
|
|
function FTUEGetOutputVolume() {
|
|
dbg('FTUEGetOutputVolume');
|
|
return -40;
|
|
}
|
|
|
|
function FTUESetOutputVolume() {
|
|
dbg('FTUESetOutputVolume');
|
|
}
|
|
|
|
function FTUEGetChatInputVolume() {
|
|
dbg('FTUEGetChatInputVolume');
|
|
return -10;
|
|
}
|
|
|
|
function FTUESetChatInputVolume() {
|
|
dbg('FTUESetChatInputVolume');
|
|
}
|
|
|
|
function FTUERegisterVUCallbacks() {
|
|
dbg('FTUERegisterVUCallbacks');
|
|
}
|
|
|
|
function FTUERegisterLatencyCallback(functionName) {
|
|
dbg('FTUERegisterLatencyCallback');
|
|
latencyCallback = functionName;
|
|
}
|
|
|
|
function FTUEStartLatency() {
|
|
function cb() {
|
|
// Change 4192 to modify latency MS results (in microseconds)
|
|
eval(latencyCallback + "(10.0)");
|
|
}
|
|
|
|
context.setTimeout(cb, 1000);
|
|
}
|
|
|
|
function FTUEGetExpectedLatency() {
|
|
return {latencyknown: true, latency: 5}
|
|
}
|
|
|
|
function FTUEGetGoodConfigurationList() {
|
|
return ['default'];
|
|
}
|
|
|
|
function FTUEGetAllAudioConfigurations() {
|
|
return ['default'];
|
|
}
|
|
|
|
function FTUEGetGoodAudioConfigurations() {
|
|
return ['default'];
|
|
}
|
|
|
|
function FTUEGetConfigurationDevice() {
|
|
return 'Good Device';
|
|
}
|
|
|
|
function FTUELoadAudioConfiguration() {
|
|
return true;
|
|
}
|
|
|
|
function FTUEIsMusicDeviceWDM() {
|
|
return false;
|
|
}
|
|
|
|
function FTUECreateUpdatePlayBackProfile() {
|
|
return true;
|
|
}
|
|
|
|
function RegisterVolChangeCallBack(functionName) {
|
|
dbg('RegisterVolChangeCallBack');
|
|
}
|
|
|
|
|
|
function GetOS() {
|
|
return 100000000;
|
|
}
|
|
|
|
function GetOSAsString() {
|
|
//return "Win32";
|
|
return "MacOSX";
|
|
}
|
|
|
|
function LatencyUpdated(map) {
|
|
dbg('LatencyUpdated:' + JSON.stringify(map));
|
|
}
|
|
|
|
function LeaveSession(map) {
|
|
dbg('LeaveSession:' + JSON.stringify(map));
|
|
}
|
|
|
|
// this is not a real bridge method; purely used by the fake jam client
|
|
function RegisterP2PMessageCallbacks(callbacks) {
|
|
p2pCallbacks = callbacks;
|
|
}
|
|
|
|
function P2PMessageReceived(from, payload) {
|
|
|
|
dbg('P2PMessageReceived');
|
|
// this function is different in that the payload is a JSON ready string;
|
|
// whereas a real p2p message is base64 encoded binary packaged data
|
|
|
|
try {
|
|
payload = JSON.parse(payload);
|
|
}
|
|
catch (e) {
|
|
logger.warn("unable to parse payload as JSON from client %o, %o, %o", from, e, payload);
|
|
}
|
|
|
|
var callback = p2pCallbacks[payload.type];
|
|
if (callback) {
|
|
callback(from, payload);
|
|
}
|
|
}
|
|
|
|
function JoinSession(sessionId) {
|
|
dbg('JoinSession:' + sessionId);
|
|
}
|
|
|
|
function ParticipantLeft(session, participant) {
|
|
dbg('ParticipantLeft:' + JSON.stringify(session) + ',' +
|
|
JSON.stringify(participant));
|
|
}
|
|
|
|
function ParticipantJoined(session, participant) {
|
|
dbg('ParticipantJoined:' + JSON.stringify(session) + ',' +
|
|
JSON.stringify(participant));
|
|
}
|
|
|
|
function RecordTestBegin() {
|
|
dbg('RecordTestBegin');
|
|
}
|
|
|
|
function RecordTestEnd() {
|
|
dbg('RecordTestBegin');
|
|
}
|
|
|
|
function RecordTestPlayback() {
|
|
dbg('RecordTestBegin');
|
|
}
|
|
|
|
function SendP2PMessage(s1, s2) {
|
|
dbg('SendP2PMessage:' + s1 + ',' + s2);
|
|
}
|
|
|
|
function SetASIOEnabled(i1, i2, i3, i4, i5, i6) {
|
|
dbg('SetASIOEnabled(' + i1 + ',' + i2 + ',' + i3 + ',' + i4 + ',' + i5 + ',' + i6 + ')');
|
|
}
|
|
|
|
function SignalLatencyUpdated(client) {
|
|
dbg('SignalLatencyUpdated:' + JSON.stringify(client));
|
|
}
|
|
|
|
function SignalSendP2PMessage(s1, ba) {
|
|
dbg('SignalSendP2PMessage:' + JSON.stringify(arguments));
|
|
}
|
|
|
|
function StartPlayTest(s) {
|
|
dbg('StartPlayTest' + JSON.stringify(arguments));
|
|
}
|
|
|
|
function StartRecordTest(s) {
|
|
dbg('StartRecordTest' + JSON.stringify(arguments));
|
|
}
|
|
|
|
function StartRecording(recordingId, groupedClientTracks) {
|
|
dbg('StartRecording');
|
|
fakeJamClientRecordings.StartRecording(recordingId, groupedClientTracks);
|
|
}
|
|
|
|
function StopPlayTest() {
|
|
dbg('StopPlayTest');
|
|
}
|
|
|
|
function StopRecording(recordingId, groupedTracks, errorReason, detail) {
|
|
dbg('StopRecording');
|
|
fakeJamClientRecordings.StopRecording(recordingId, groupedTracks, errorReason, detail);
|
|
}
|
|
|
|
function AbortRecording(recordingId, errorReason, errorDetail) {
|
|
dbg('AbortRecording');
|
|
fakeJamClientRecordings.AbortRecording(recordingId, errorReason, errorDetail);
|
|
}
|
|
|
|
function OnTrySyncCommand(cmd) {
|
|
|
|
}
|
|
|
|
function GetRecordingManagerState() {
|
|
return {running: false}
|
|
}
|
|
|
|
function TestASIOLatency(s) {
|
|
dbg('TestASIOLatency' + JSON.stringify(arguments));
|
|
}
|
|
|
|
function TestLatency(clientID, callbackFunctionName, timeoutCallbackName) {
|
|
logger.debug("Fake JamClient: TestLatency called with client, " + clientID + " and callback function name: " + callbackFunctionName);
|
|
var response = {
|
|
clientID: clientID,
|
|
latency: 50
|
|
};
|
|
var js = callbackFunctionName + "(" + JSON.stringify(response) + ");";
|
|
eval(js);
|
|
}
|
|
|
|
function IsMyNetworkWireless() {
|
|
// 1=true, 0 = false, -1=unknown
|
|
return 1;
|
|
}
|
|
|
|
function SetNetworkTestScore(numClients) {
|
|
|
|
}
|
|
|
|
function SetVideoNetworkTestScore(numClients) {
|
|
|
|
}
|
|
|
|
function GetNetworkTestScore() {
|
|
return 8;
|
|
}
|
|
|
|
|
|
function GetVideoNetworkTestScore() {
|
|
return 8;
|
|
}
|
|
|
|
function SetLatencyTestBlocked(blocked) {
|
|
|
|
}
|
|
|
|
function isLatencyTestBlocked() {
|
|
return false;
|
|
}
|
|
|
|
function GetLastLatencyTestTimes() {
|
|
return {initiated: 10000, requested: 10000}
|
|
}
|
|
|
|
function GetASIODevices() {
|
|
var response = [{
|
|
"device_id": 0,
|
|
"device_name": "Realtek High Definition Audio",
|
|
"device_type": 0,
|
|
"interfaces": [{
|
|
"interface_id": 0,
|
|
"interface_name": "Realtek HDA SPDIF Out",
|
|
"pins": [{"is_input": false, "pin_id": 0, "pin_name": "PC Speaker"}]
|
|
}, {
|
|
"interface_id": 1,
|
|
"interface_name": "Realtek HD Audio rear output",
|
|
"pins": [{"is_input": false, "pin_id": 0, "pin_name": "PC Speaker"}]
|
|
}, {
|
|
"interface_id": 2,
|
|
"interface_name": "Realtek HD Audio Mic input",
|
|
"pins": [{"is_input": true, "pin_id": 0, "pin_name": "Recording Control"}]
|
|
}, {
|
|
"interface_id": 3,
|
|
"interface_name": "Realtek HD Audio Line input",
|
|
"pins": [{"is_input": true, "pin_id": 0, "pin_name": "Recording Control"}]
|
|
}, {
|
|
"interface_id": 4,
|
|
"interface_name": "Realtek HD Digital input",
|
|
"pins": [{"is_input": true, "pin_id": 0, "pin_name": "Capture"}]
|
|
}, {
|
|
"interface_id": 5,
|
|
"interface_name": "Realtek HD Audio Stereo input",
|
|
"pins": [{"is_input": true, "pin_id": 0, "pin_name": "Recording Control"}]
|
|
}],
|
|
"wavert_supported": false
|
|
}, {
|
|
"device_id": 1,
|
|
"device_name": "M-Audio FW Audiophile",
|
|
"device_type": 1,
|
|
"interfaces": [{
|
|
"interface_id": 0,
|
|
"interface_name": "FWAPMulti",
|
|
"pins": [{"is_input": false, "pin_id": 0, "pin_name": "Output"}, {
|
|
"is_input": true,
|
|
"pin_id": 1,
|
|
"pin_name": "Input"
|
|
}]
|
|
}, {
|
|
"interface_id": 1,
|
|
"interface_name": "FW AP 1/2",
|
|
"pins": [{"is_input": false, "pin_id": 0, "pin_name": "Output"}, {
|
|
"is_input": true,
|
|
"pin_id": 1,
|
|
"pin_name": "Input"
|
|
}]
|
|
}, {
|
|
"interface_id": 2,
|
|
"interface_name": "FW AP SPDIF",
|
|
"pins": [{"is_input": false, "pin_id": 0, "pin_name": "Output"}, {
|
|
"is_input": true,
|
|
"pin_id": 1,
|
|
"pin_name": "Input"
|
|
}]
|
|
}, {
|
|
"interface_id": 3,
|
|
"interface_name": "FW AP 3/4",
|
|
"pins": [{"is_input": false, "pin_id": 0, "pin_name": "Output"}]
|
|
}],
|
|
"wavert_supported": false
|
|
}, {
|
|
"device_id": 2,
|
|
"device_name": "Virtual Audio Cable",
|
|
"device_type": 2,
|
|
"interfaces": [{
|
|
"interface_id": 0,
|
|
"interface_name": "Virtual Cable 2",
|
|
"pins": [{"is_input": true, "pin_id": 0, "pin_name": "Capture"}, {
|
|
"is_input": false,
|
|
"pin_id": 1,
|
|
"pin_name": "Output"
|
|
}]
|
|
}, {
|
|
"interface_id": 1,
|
|
"interface_name": "Virtual Cable 1",
|
|
"pins": [{"is_input": true, "pin_id": 0, "pin_name": "Capture"}, {
|
|
"is_input": false,
|
|
"pin_id": 1,
|
|
"pin_name": "Output"
|
|
}]
|
|
}],
|
|
"wavert_supported": false
|
|
}, {
|
|
"device_id": 3,
|
|
"device_name": "WebCamDV WDM Audio Capture",
|
|
"device_type": 3,
|
|
"interfaces": [{
|
|
"interface_id": 0,
|
|
"interface_name": "WebCamDV Audio",
|
|
"pins": [{"is_input": true, "pin_id": 0, "pin_name": "Recording Control"}, {
|
|
"is_input": false,
|
|
"pin_id": 1,
|
|
"pin_name": "Volume Control"
|
|
}]
|
|
}],
|
|
"wavert_supported": false
|
|
}];
|
|
return response;
|
|
}
|
|
|
|
// Session Functions
|
|
|
|
function SessionCurrrentJamTrackPlayPosMs() {
|
|
return 0;
|
|
}
|
|
|
|
function GetJamTrackSettings() {
|
|
return {tracks: []}
|
|
}
|
|
|
|
function SessionGetJamTracksPlayDurationMs() {
|
|
return 60000;
|
|
}
|
|
|
|
function SessionAddTrack() {
|
|
}
|
|
|
|
function SessionAudioResync() {
|
|
logger.debug("Fake JamClient: SessionAudioResync()");
|
|
}
|
|
|
|
function getConnectionDetail(arg1, arg2) {
|
|
return {}
|
|
}
|
|
|
|
function SessionGetAllControlState(isMasterOrPersonal) {
|
|
var mixerIds = SessionGetIDs()
|
|
return SessionGetControlState(mixerIds, isMasterOrPersonal);
|
|
}
|
|
|
|
function SessionGetControlState(mixerIds, isMasterOrPersonal) {
|
|
dbg("SessionGetControlState");
|
|
var groups =
|
|
[ChannelGroupIds.MasterGroup,
|
|
ChannelGroupIds.MonitorGroup,
|
|
ChannelGroupIds.AudioInputMusicGroup,
|
|
ChannelGroupIds.AudioInputChatGroup,
|
|
ChannelGroupIds.AudioInputChatGroup,
|
|
ChannelGroupIds.UserMusicInputGroup,
|
|
ChannelGroupIds.UserChatInputGroup,
|
|
ChannelGroupIds.PeerMediaTrackGroup,
|
|
ChannelGroupIds.JamTrackGroup,
|
|
ChannelGroupIds.MetronomeGroup];
|
|
var names = [
|
|
"FWAPMulti",
|
|
"FWAPMulti",
|
|
"FWAPMulti",
|
|
"FWAPMulti",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
];
|
|
|
|
var media_types = [
|
|
"Master",
|
|
"Monitor",
|
|
"AudioInputMusic",
|
|
"AudioInputChat",
|
|
"StreamOutMusic",
|
|
"UserMusicInput",
|
|
"PeerAudioInputMusic",
|
|
"PeerMediaTrack",
|
|
"JamTrack",
|
|
"MetronomeTrack"
|
|
]
|
|
var clientIds = [
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"3933ebec-913b-43ab-a4d3-f21dc5f8955b",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
];
|
|
var response = [];
|
|
for (var i = 0; i < mixerIds.length; i++) {
|
|
|
|
// for testing no inputs, set simulateNoInputs = true
|
|
if (simulateNoInputs && i == 2) continue;
|
|
|
|
response.push({
|
|
client_id: clientIds[i],
|
|
group_id: groups[i],
|
|
id: mixerIds[i] + (isMasterOrPersonal ? 'm' : 'p'),
|
|
master: isMasterOrPersonal,
|
|
media_type: media_types[i],
|
|
monitor: !isMasterOrPersonal,
|
|
mute: false,
|
|
name: names[i],
|
|
range_high: 20,
|
|
range_low: -80,
|
|
record: true,
|
|
stereo: true,
|
|
volume_left: -40,
|
|
volume_right: -40,
|
|
pan: 0,
|
|
instrument_id: 50, // see globals.js
|
|
mode: isMasterOrPersonal,
|
|
rid: mixerIds[i]
|
|
});
|
|
}
|
|
return response;
|
|
}
|
|
|
|
function SessionGetIDs() {
|
|
return [
|
|
"FWAPMulti_0_10000",
|
|
"FWAPMulti_1_10100",
|
|
"FWAPMulti_2_10200",
|
|
"FWAPMulti_3_10500",
|
|
"User@208.191.152.98#",
|
|
"User@208.191.152.98_*"
|
|
];
|
|
}
|
|
|
|
function RegisterRecordingManagerCallbacks(commandStart, commandProgress, commandStop, commandsChanged) {
|
|
|
|
}
|
|
|
|
function RegisterRecordingCallbacks(startRecordingCallbackName, stopRecordingCallbackName, startedRecordingCallbackName, stoppedRecordingCallbackName, abortedRecordingCallbackName) {
|
|
fakeJamClientRecordings.RegisterRecordingCallbacks(startRecordingCallbackName, stopRecordingCallbackName, startedRecordingCallbackName, stoppedRecordingCallbackName, abortedRecordingCallbackName);
|
|
}
|
|
|
|
function SessionRegisterCallback(callbackName) {
|
|
eventCallbackName = callbackName;
|
|
if (callbackTimer) {
|
|
context.clearInterval(callbackTimer);
|
|
}
|
|
if (eventCallbackName) {
|
|
callbackTimer = context.setInterval(doCallbacks, eventCallbackRate);
|
|
}
|
|
}
|
|
|
|
function SessionSetAlertCallback(callback) {
|
|
alertCallbackName = callback;
|
|
|
|
// simulate a backend alert
|
|
/**setTimeout(function() {
|
|
eval(alertCallbackName + '(27)');
|
|
}, 3000)*/
|
|
}
|
|
|
|
function SessionSetConnectionStatusRefreshRate(milliseconds) {
|
|
dbg('SessionSetConnectionStatusRefreshRate: ' + milliseconds);
|
|
}
|
|
|
|
function SessionSetControlState(stringValue, isMasterOrPersonal) {
|
|
dbg('SessionSetControlState: ' + stringValue + " m/p=" + isMasterOrPersonal);
|
|
}
|
|
|
|
function SessionSetRecordingFilename(filename) {
|
|
}
|
|
|
|
function SessionSetRecordingFolder(folderName) {
|
|
}
|
|
|
|
function SessionStartPlay() {
|
|
}
|
|
|
|
function SessionStartRecording() {
|
|
}
|
|
|
|
function SessionStopPlay() {
|
|
}
|
|
|
|
function SessionStopRecording() {
|
|
}
|
|
|
|
function SessionAddPlayTrack() {
|
|
return true;
|
|
}
|
|
|
|
function SessionRemoveAllPlayTracks() {
|
|
}
|
|
|
|
function isSessionTrackPlaying() {
|
|
return false;
|
|
}
|
|
|
|
function SessionCurrrentPlayPosMs() {
|
|
return 0;
|
|
}
|
|
|
|
function SessionGetTracksPlayDurationMs() {
|
|
return 0;
|
|
}
|
|
|
|
function SessionGetDeviceLatency() {
|
|
return 10.0;
|
|
}
|
|
|
|
function SessionPageEnter() {
|
|
logger.debug("FakeJamClient: SessionPageEnter");
|
|
return {}
|
|
}
|
|
|
|
function SessionPageLeave() {
|
|
logger.debug("FakeJamClient: SessionPageLeave")
|
|
}
|
|
|
|
function SetMixerMode(mode) {
|
|
}
|
|
|
|
function SessionGetMasterLocalMix() {
|
|
logger.debug('SessionGetMasterLocalMix. Returning: ' + _mix);
|
|
return _mix;
|
|
}
|
|
|
|
function SessionSetMasterLocalMix(level) {
|
|
logger.debug('SessionSetMasterLocalMix(' + level + ')');
|
|
_mix = level;
|
|
}
|
|
|
|
function SessionSetUserName(client_id, name) {
|
|
|
|
}
|
|
|
|
function doCallbacks() {
|
|
var names = ["vu"];
|
|
//var ids = ["FWAPMulti_2_10200", "FWAPMulti_0_10000"];
|
|
var ids = ["i~11~MultiChannel (FWAPMulti)~0^i~11~Multichannel (FWAPMulti)~1",
|
|
"i~11~MultiChannel (FWAPMulti)~0^i~11~Multichannel (FWAPMulti)~2"];
|
|
|
|
var args = [];
|
|
for (var i = 0; i < ids.length; i++) {
|
|
for (var j = 0; j < names.length; j++) {
|
|
args.push('"' + names[j] + '"');
|
|
args.push('"' + ids[i] + '"');
|
|
args.push(vuValue);
|
|
}
|
|
}
|
|
var js = eventCallbackName + '(' + args.join(',') + ')';
|
|
//eval(js);
|
|
|
|
vuValue += vuChange;
|
|
if (vuValue > 10 || vuValue < -70) {
|
|
vuChange = vuChange * -1;
|
|
}
|
|
|
|
}
|
|
|
|
function SetVURefreshRate(rateMS) {
|
|
eventCallbackRate = rateMS;
|
|
if (callbackTimer) {
|
|
context.clearInterval(callbackTimer);
|
|
}
|
|
if (eventCallbackName) {
|
|
callbackTimer = context.setInterval(doCallbacks, eventCallbackRate);
|
|
}
|
|
}
|
|
|
|
// Track Functions
|
|
|
|
|
|
// Returns a list of objects representing all available audio devices and
|
|
// pins on the current system. On my windows box, I get 38 objects back.
|
|
// First couple examples included here. Note that the list tends to come
|
|
// back with all of the left inputs, then all the right inputs, then all
|
|
// the left outputs, then all the right outputs.
|
|
function TrackGetChannels() {
|
|
// Real example:
|
|
/*
|
|
{
|
|
device_id: "1394\\M-Audio&FW_Audiophile",
|
|
full_id: "i~1~\\\\?\\1394#m-audio&fw_audiophile#d4eb0700036c0d00#{6994ad04-93ef-11d0-a3cc-00a0c9223196}\\fwap_12",
|
|
id: "\\\\?\\1394#m-audio&fw_audiophile#d4eb0700036c0d00#{6994ad04-93ef-11d0-a3cc-00a0c9223196}\\fwap_12",
|
|
input: true,
|
|
left: true,
|
|
name: "M-Audio FW Audiophile: FW AP 1/2 - Left"
|
|
},
|
|
*/
|
|
|
|
// But we'll just build a list of names and fake it
|
|
var devices = [
|
|
"M-Audio FW Audiophile: FW AP 1/2"
|
|
//"M-Audio FW Audiophile: FW Multi 1/2",
|
|
//"M-Audio FW Audiophile: FW SPDIF 1/2",
|
|
//"Realtek High Definition Audio: Realtek HD Digital",
|
|
// "Realtek High Definition Audio: Realtek HD Line",
|
|
// "Realtek High Definition Audio: Realtek HD Audio Mic",
|
|
// "Realtek High Definition Audio: Realtek HD Audio Stereo",
|
|
//"WebCamDV WDM Audio Capture: WebCamDV Audio"
|
|
];
|
|
var suffixes = [" - Left", " - Right", " - Left", " - Right"];
|
|
var lefts = [true, false, true, false];
|
|
var inputs = [true, true, false, false];
|
|
var types = ["music", "non-music", "music", "non-music"];
|
|
var response = [];
|
|
var name, o, i, j;
|
|
for (j = 0; j < 4; j++) {
|
|
for (i = 0; i < devices.length; i++) {
|
|
name = devices[i] + suffixes[j];
|
|
o = {
|
|
device_id: name,
|
|
full_id: name,
|
|
id: name,
|
|
input: inputs[j],
|
|
left: lefts[j],
|
|
name: name,
|
|
device_type: types[j]
|
|
};
|
|
response.push(o);
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
function TrackGetCount() {
|
|
return 1; // Real version returns whatever was set
|
|
}
|
|
|
|
function TrackGetInstrument(trackNumber) {
|
|
if (trackNumber === 1) {
|
|
return 100;
|
|
}
|
|
else {
|
|
return 200;
|
|
}
|
|
}
|
|
|
|
function TrackGetChatEnable() {
|
|
return true;
|
|
}
|
|
|
|
function TrackSetChatEnable(chat) {
|
|
|
|
}
|
|
|
|
function TrackSaveAssignments() {
|
|
}
|
|
|
|
function TrackGetDevices() {
|
|
var response = {
|
|
"Built-in": "Built-in",
|
|
"ASIO4ALL v2": "ASIO4ALL v2 - ASIO",
|
|
"BEHRINGER USB AUDIO": "BEHRINGER USB AUDIO - ASIO",
|
|
"{2B7D1F21-FA6E-11D4-0002-DDCA793267F2}": "SoundMAX HD Audio O - WDM",
|
|
"{ABCC5A6C-C263-463B-A72F-A5BF64C86EBA}": "Generic USB Audio Device - WDM"
|
|
};
|
|
return response;
|
|
}
|
|
|
|
function TrackDeleteProfile(id) {
|
|
|
|
}
|
|
|
|
|
|
function TrackGetMusicDeviceID() {
|
|
return device_id;
|
|
}
|
|
|
|
function TrackSetMusicDevice(id) {
|
|
device_id = id;
|
|
}
|
|
|
|
function TrackGetMusicDeviceNames(input) {
|
|
var names = [];
|
|
names.push("Built-in");
|
|
return names;
|
|
}
|
|
|
|
// mock response of this method by allowing only even device IDs to open control panel
|
|
function TrackHasControlPanel() {
|
|
return true;
|
|
}
|
|
|
|
function TrackIsMusicDeviceType(type) {
|
|
return true;
|
|
}
|
|
|
|
function TrackGetChatUsesMusic() {
|
|
return 0;
|
|
}
|
|
|
|
function TrackSetChatUsesMusic(usesMusic) {
|
|
}
|
|
|
|
function TrackOpenControlPanel() {
|
|
return;
|
|
}
|
|
|
|
function TrackLoadAssignments() {
|
|
}
|
|
|
|
function TrackSave() {
|
|
}
|
|
|
|
// Set a Track Assignment.
|
|
// assignment is an enum:
|
|
// CHAT = -2, OUTPUT = -1, UNASSIGNED = 0
|
|
function TrackSetAssignment(chanId, isInput, assignment) {
|
|
}
|
|
|
|
// Get a Track Assignment.
|
|
function TrackGetAssignment(chanId, isInput) {
|
|
// CHAT = -2, OUTPUT = -1, UNASSIGNED = 0
|
|
return 0;
|
|
}
|
|
|
|
function TrackSetCount(count) {
|
|
}
|
|
|
|
function TrackSetInstrument(track, instrumentId) {
|
|
}
|
|
|
|
function JamTrackStopPlay() {
|
|
}
|
|
|
|
function JamTrackPlay() {
|
|
return true;
|
|
}
|
|
|
|
function JamTrackIsPlayable() {
|
|
return true;
|
|
}
|
|
|
|
function JamTrackGetTrackDetail() {
|
|
return {key_state: 'unknown'}
|
|
}
|
|
|
|
function JamTrackKeysRequest() {
|
|
}
|
|
|
|
function JamTrackDownload() {
|
|
}
|
|
|
|
// Method which sets volume
|
|
function UpdateMixer(mixerId) {
|
|
}
|
|
|
|
// scoring knobs
|
|
function GetScoreWorkTimingInterval() {
|
|
return {interval: 1000, backoff: 60000}
|
|
}
|
|
|
|
function SetScoreWorkTimingInterval(knobs) {
|
|
return true;
|
|
}
|
|
|
|
function SessionOpenBackingTrackFile(path, loop) {
|
|
backingTrackPath = path
|
|
backingTrackLoop = loop
|
|
}
|
|
|
|
function SessionSetBackingTrackFileLoop(path, loop) {
|
|
backingTrackPath = path
|
|
backingTrackLoop = loop
|
|
}
|
|
|
|
function SessionCloseBackingTrackFile(path) {
|
|
backingTrackPath = ""
|
|
}
|
|
|
|
function SessionOpenMetronome(bpm, click, meter, mode) {
|
|
logger.debug("Setting metronome BPM: ", bpm)
|
|
metronomeActive = true
|
|
metronomeBPM = bpm
|
|
metronomeSound = click
|
|
metronomeMeter = meter
|
|
}
|
|
|
|
//change setting - click. Mode 0: = mono, 1, = left ear, 2= right ear
|
|
function SessionSetMetronome(bpm, click, meter, mode) {
|
|
SessionOpenMetronome(bpm, click, meter, mode)
|
|
}
|
|
|
|
//close everywhere
|
|
function SessionCloseMetronome() {
|
|
metronomeActive = false
|
|
}
|
|
|
|
function setMetronomeOpenCallback(callback) {
|
|
|
|
}
|
|
|
|
function getMyNetworkState() {
|
|
return {
|
|
ntp_stable: Math.random() > 0.5
|
|
}
|
|
}
|
|
|
|
function getPeerState(clientId) {
|
|
return {
|
|
ntp_stable: Math.random() > 0.5
|
|
}
|
|
}
|
|
|
|
|
|
// stun
|
|
function NetworkTestResult() {
|
|
return {remote_udp_blocked: false}
|
|
}
|
|
|
|
// Client Update Functions
|
|
function IsAppInWritableVolume() {
|
|
return true;
|
|
}
|
|
|
|
function ClientUpdateVersion() {
|
|
return "Compiled 1.2.3";
|
|
}
|
|
|
|
function ClientUpdateStartDownload(url, progressCallback, successCallback, failureCallback) {
|
|
|
|
// simulate a bunch of download callbacks
|
|
var count = 0;
|
|
var max = 100;
|
|
var bytesReceived = 0;
|
|
var bytesTotal = 10000;
|
|
|
|
function fire() {
|
|
count++;
|
|
context.setTimeout(function () {
|
|
bytesReceived = ( count / max ) * bytesTotal;
|
|
context.JK.ClientUpdate.DownloadProgressCallback(bytesReceived, bytesTotal, 0, 0);
|
|
|
|
if (count < max) {
|
|
fire();
|
|
}
|
|
else {
|
|
context.JK.ClientUpdate.DownloadFailureCallback("/some/path/here");
|
|
}
|
|
}, 50);
|
|
}
|
|
|
|
fire();
|
|
|
|
}
|
|
|
|
function getBackingTrackList() {
|
|
return {
|
|
backing_tracks: [
|
|
{name: "This is a really long name for a song dude.mp3", size: 4283},
|
|
{name: "foo.mp3", size: 325783838}
|
|
]
|
|
};
|
|
}
|
|
|
|
function ClientUpdateStartUpdate(path, successCallback, failureCallback) {
|
|
}
|
|
|
|
// -------------------------------
|
|
// fake jam client methods
|
|
// not a part of the actual bridge
|
|
// -------------------------------
|
|
function SetFakeRecordingImpl(fakeRecordingsImpl) {
|
|
fakeJamClientRecordings = fakeRecordingsImpl;
|
|
}
|
|
|
|
function TestNetworkPktBwRate(targetClientId, successCallback, timeoutCallback, testType, duration, numClients, payloadSize) {
|
|
var progress = {
|
|
progress: true,
|
|
upthroughput: .95,
|
|
downthroughput: .95,
|
|
upjitter: 2.3,
|
|
downjitter: 2.3
|
|
}
|
|
var count = 0;
|
|
var interval = setInterval(function () {
|
|
|
|
eval(successCallback + "(" + JSON.stringify(progress) + ");");
|
|
|
|
if (progress.upthroughput < 1) {
|
|
progress.upthroughput += .05;
|
|
}
|
|
if (progress.downthroughput < 1) {
|
|
progress.downthroughput += .05;
|
|
}
|
|
|
|
count++;
|
|
if (count == duration) {
|
|
clearInterval(interval);
|
|
|
|
delete progress['progress']
|
|
progress.pass = true;
|
|
eval(successCallback + "(" + JSON.stringify(progress) + ");");
|
|
}
|
|
}, 1000);
|
|
}
|
|
|
|
function StopNetworkTest(targetClientId) {
|
|
}
|
|
|
|
function OnLoggedIn(userId, sessionToken) {
|
|
}
|
|
|
|
function OnLoggedOut() {
|
|
}
|
|
|
|
function UserAttention(option) {
|
|
}
|
|
|
|
function SessionGetMacHash() {
|
|
return null;
|
|
}
|
|
|
|
function IsFrontendVisible() {
|
|
return true;
|
|
}
|
|
|
|
function LastUsedProfileName() {
|
|
return 'default'
|
|
};
|
|
function SetLastUsedProfileName(name) {
|
|
return true;
|
|
};
|
|
function log(level, message) {
|
|
console.log("beep : " + message)
|
|
}
|
|
|
|
function getOperatingMode() {
|
|
if (location.pathname == '/latency_tester') {
|
|
return 'server';
|
|
}
|
|
else {
|
|
return 'client';
|
|
}
|
|
}
|
|
|
|
// passed an array of recording objects from the server
|
|
function GetLocalRecordingState(recordings) {
|
|
var result = {recordings: []};
|
|
var recordingResults = result.recordings;
|
|
|
|
var possibleAnswers = ['HQ', 'RT', 'MISSING', 'PARTIALLY_MISSING'];
|
|
|
|
$.each(recordings, function (i, recording) {
|
|
// just make up a random yes-hq/yes-rt/missing answer
|
|
var recordingResult = {};
|
|
recordingResult['aggregate_state'] = possibleAnswers[Math.floor((Math.random() * 4))];
|
|
recordingResults.push(recordingResult);
|
|
})
|
|
|
|
return result;
|
|
}
|
|
|
|
function OpenRecording(claimedRecording) {
|
|
return {success: true}
|
|
}
|
|
|
|
function PreviewRecording(claimedRecording) {
|
|
return OpenRecording(claimedRecording);
|
|
}
|
|
|
|
function CloseRecording() {
|
|
}
|
|
|
|
function ClosePreviewRecording() {
|
|
CloseRecording();
|
|
}
|
|
|
|
function OnDownloadAvailable() {
|
|
}
|
|
|
|
function SaveToClipboard(text) {
|
|
}
|
|
|
|
function IsNativeClient() { /* must always return false in all scenarios due to not ruin scoring !*/
|
|
return false;
|
|
}
|
|
|
|
function IsAudioStarted() {
|
|
logger.debug("FakeJamClient: IsAudioStarted");
|
|
return false;
|
|
}
|
|
|
|
function StopAudio() {
|
|
logger.debug("FakeJamClient: StopAudio");
|
|
}
|
|
|
|
function ResetPageCounters() {
|
|
logger.debug("FakeJamClient: ResetPageCounters");
|
|
}
|
|
|
|
function ReloadAudioSystem(leaveRunning, loadLastProfile, reinitAssignments) {
|
|
logger.debug("FakeJamClient: ReloadAudioSystem");
|
|
return {};
|
|
}
|
|
|
|
function SessionLiveBroadcastStart(host, port, mount, sourceUser, sourcePass, preferredClientId, bitrate) {
|
|
logger.debug("SessionLiveBroadcastStart requested");
|
|
}
|
|
|
|
function SessionLiveBroadcastStop() {
|
|
logger.debug("SessionLiveBroadcastStop requested");
|
|
}
|
|
|
|
function RegisterQuitCallback() {
|
|
}
|
|
|
|
function LeaveSessionAndMinimize() {
|
|
}
|
|
|
|
function SetAutoStart() {
|
|
}
|
|
|
|
function GetAutoStart() {
|
|
return true;
|
|
}
|
|
|
|
function SaveSettings() {
|
|
}
|
|
|
|
function GetUseStaticPort() {
|
|
return false;
|
|
}
|
|
|
|
function SetUseStaticPort() {
|
|
}
|
|
|
|
function GetStaticPort() {
|
|
return 0
|
|
}
|
|
|
|
function SetStaticPort() {
|
|
}
|
|
|
|
|
|
function VSTLoad() {
|
|
}
|
|
|
|
function VSTScan(callback) {
|
|
setTimeout(eval(callback + "()"), 1000)
|
|
}
|
|
|
|
function hasVstHost() {
|
|
return false;
|
|
}
|
|
|
|
function getPluginList() {
|
|
return {vsts: []}
|
|
}
|
|
|
|
function clearPluginList() {
|
|
}
|
|
|
|
function listTrackAssignments() {
|
|
return {}
|
|
}
|
|
|
|
// Javascript Bridge seems to camel-case
|
|
// Set the instance functions:
|
|
this.AbortRecording = AbortRecording;
|
|
this.OnTrySyncCommand = OnTrySyncCommand;
|
|
this.GetRecordingManagerState = GetRecordingManagerState;
|
|
this.GetASIODevices = GetASIODevices;
|
|
this.GetOS = GetOS;
|
|
this.GetOSAsString = GetOSAsString;
|
|
this.JoinSession = JoinSession;
|
|
this.LatencyUpdated = LatencyUpdated;
|
|
this.LeaveSession = LeaveSession;
|
|
this.P2PMessageReceived = P2PMessageReceived;
|
|
this.ParticipantJoined = ParticipantJoined;
|
|
this.ParticipantLeft = ParticipantLeft;
|
|
this.RecordTestBegin = RecordTestBegin;
|
|
this.RecordTestEnd = RecordTestEnd;
|
|
this.RecordTestPlayback = RecordTestPlayback;
|
|
this.RegisterVolChangeCallBack = RegisterVolChangeCallBack;
|
|
this.SendP2PMessage = SendP2PMessage;
|
|
this.SetASIOEnabled = SetASIOEnabled;
|
|
this.SignalLatencyUpdated = SignalLatencyUpdated;
|
|
this.SignalSendP2PMessage = SignalSendP2PMessage;
|
|
this.StartPlayTest = StartPlayTest;
|
|
this.StartRecordTest = StartRecordTest;
|
|
this.StartRecording = StartRecording;
|
|
this.StopPlayTest = StopPlayTest;
|
|
this.StopRecording = StopRecording;
|
|
this.TestASIOLatency = TestASIOLatency;
|
|
this.TestLatency = TestLatency;
|
|
this.IsMyNetworkWireless = IsMyNetworkWireless;
|
|
this.SetNetworkTestScore = SetNetworkTestScore;
|
|
this.GetNetworkTestScore = GetNetworkTestScore;
|
|
this.SetVideoNetworkTestScore = SetVideoNetworkTestScore;
|
|
this.GetVideoNetworkTestScore = GetVideoNetworkTestScore;
|
|
this.SetLatencyTestBlocked = SetLatencyTestBlocked;
|
|
this.isLatencyTestBlocked = isLatencyTestBlocked;
|
|
this.GetLastLatencyTestTimes = GetLastLatencyTestTimes;
|
|
this.RegisterQuitCallback = RegisterQuitCallback;
|
|
this.LeaveSessionAndMinimize = LeaveSessionAndMinimize;
|
|
this.GetAutoStart = GetAutoStart;
|
|
this.SetAutoStart = SetAutoStart;
|
|
this.GetUseStaticPort = GetUseStaticPort;
|
|
this.SetUseStaticPort = SetUseStaticPort;
|
|
this.GetStaticPort = GetStaticPort;
|
|
this.SetStaticPort = SetStaticPort;
|
|
this.connected = true;
|
|
|
|
// FTUE (round 3)
|
|
this.FTUESetInputMusicDevice = FTUESetInputMusicDevice;
|
|
this.FTUESetOutputMusicDevice = FTUESetOutputMusicDevice;
|
|
this.FTUEGetInputMusicDevice = FTUEGetInputMusicDevice;
|
|
this.FTUEGetOutputMusicDevice = FTUEGetOutputMusicDevice;
|
|
this.FTUEGetChatInputVolume = FTUEGetChatInputVolume;
|
|
this.FTUEGetChatInputs = FTUEGetChatInputs;
|
|
this.FTUEGetChannels = FTUEGetChannels;
|
|
this.FTUEGetAudioDevices = FTUEGetAudioDevices;
|
|
this.FTUEStartIoPerfTest = FTUEStartIoPerfTest;
|
|
this.FTUEGetIoPerfData = FTUEGetIoPerfData;
|
|
this.FTUEGetDevices = FTUEGetDevices;
|
|
this.FTUEGetFrameSize = FTUEGetFrameSize;
|
|
this.FTUECancel = FTUECancel;
|
|
this.FTUEPageEnter = FTUEPageEnter;
|
|
this.FTUEPageLeave = FTUEPageLeave;
|
|
this.FTUEGetMusicProfileName = FTUEGetMusicProfileName;
|
|
this.FTUESetMusicProfileName = FTUESetMusicProfileName;
|
|
this.FTUESetPreferredMixerSampleRate = FTUESetPreferredMixerSampleRate;
|
|
this.FTUESetPreferredOutputSampleRate = FTUESetPreferredOutputSampleRate;
|
|
this.FTUESetPreferredChatSampleRate = FTUESetPreferredChatSampleRate;
|
|
this.FTUEgetInputDeviceSampleRate = FTUEgetInputDeviceSampleRate;
|
|
this.FTUEgetOutputDeviceSampleRate = FTUEgetOutputDeviceSampleRate;
|
|
this.FTUEGetInputLatency = FTUEGetInputLatency;
|
|
this.FTUEGetInputVolume = FTUEGetInputVolume;
|
|
this.FTUEGetMusicInputs = FTUEGetMusicInputs;
|
|
this.FTUEGetMusicOutputs = FTUEGetMusicOutputs;
|
|
this.FTUEGetOutputLatency = FTUEGetOutputLatency;
|
|
this.FTUEGetOutputVolume = FTUEGetOutputVolume;
|
|
this.FTUEGetStatus = FTUEGetStatus;
|
|
this.FTUEGetVolumeRanges = FTUEGetVolumeRanges;
|
|
this.FTUEHasControlPanel = FTUEHasControlPanel;
|
|
this.FTUEInit = FTUEInit;
|
|
this.FTUEOpenControlPanel = FTUEOpenControlPanel;
|
|
this.FTUERegisterLatencyCallback = FTUERegisterLatencyCallback;
|
|
this.FTUERegisterVUCallbacks = FTUERegisterVUCallbacks;
|
|
this.FTUERefreshDevices = FTUERefreshDevices;
|
|
this.FTUESave = FTUESave;
|
|
this.FTUESetChatInput = FTUESetChatInput;
|
|
this.FTUESetChatInputVolume = FTUESetChatInputVolume;
|
|
this.FTUESetInputVolume = FTUESetInputVolume;
|
|
this.FTUESetFrameSize = FTUESetFrameSize;
|
|
this.FTUESetInputLatency = FTUESetInputLatency;
|
|
this.FTUESetMusicDevice = FTUESetMusicDevice;
|
|
this.FTUESetMusicInput = FTUESetMusicInput;
|
|
this.FTUESetMusicOutput = FTUESetMusicOutput;
|
|
this.FTUESetOutputLatency = FTUESetOutputLatency;
|
|
this.FTUESetOutputVolume = FTUESetOutputVolume;
|
|
this.FTUESetStatus = FTUESetStatus;
|
|
this.FTUEStartLatency = FTUEStartLatency;
|
|
this.FTUEGetExpectedLatency = FTUEGetExpectedLatency;
|
|
this.FTUEGetGoodConfigurationList = FTUEGetGoodConfigurationList;
|
|
this.FTUEGetAllAudioConfigurations = FTUEGetAllAudioConfigurations;
|
|
this.FTUEGetGoodAudioConfigurations = FTUEGetGoodAudioConfigurations;
|
|
this.FTUEGetConfigurationDevice = FTUEGetConfigurationDevice;
|
|
this.FTUEIsMusicDeviceWDM = FTUEIsMusicDeviceWDM;
|
|
this.FTUELoadAudioConfiguration = FTUELoadAudioConfiguration;
|
|
this.FTUEClearChannelAssignments = FTUEClearChannelAssignments;
|
|
this.FTUEClearChatInput = FTUEClearChatInput;
|
|
this.FTUECreateUpdatePlayBackProfile = FTUECreateUpdatePlayBackProfile;
|
|
|
|
// Session
|
|
this.SessionAddTrack = SessionAddTrack;
|
|
this.SessionCurrrentJamTrackPlayPosMs = SessionCurrrentJamTrackPlayPosMs;
|
|
this.SessionGetJamTracksPlayDurationMs = SessionGetJamTracksPlayDurationMs;
|
|
this.SessionGetControlState = SessionGetControlState;
|
|
this.SessionGetAllControlState = SessionGetAllControlState;
|
|
this.SessionSetUserName = SessionSetUserName;
|
|
this.SessionGetIDs = SessionGetIDs;
|
|
this.RegisterRecordingManagerCallbacks = RegisterRecordingManagerCallbacks;
|
|
this.RegisterRecordingCallbacks = RegisterRecordingCallbacks;
|
|
this.SessionRegisterCallback = SessionRegisterCallback;
|
|
this.SessionSetAlertCallback = SessionSetAlertCallback;
|
|
this.SessionSetControlState = SessionSetControlState;
|
|
this.SessionSetRecordingFilename = SessionSetRecordingFilename;
|
|
this.SessionSetRecordingFolder = SessionSetRecordingFolder;
|
|
this.SessionStartPlay = SessionStartPlay;
|
|
this.SessionStartRecording = SessionStartRecording;
|
|
this.SessionStopPlay = SessionStopPlay;
|
|
this.SessionAddPlayTrack = SessionAddPlayTrack;
|
|
this.SessionRemoveAllPlayTracks = SessionRemoveAllPlayTracks;
|
|
this.SessionStopRecording = SessionStopRecording;
|
|
this.isSessionTrackPlaying = isSessionTrackPlaying;
|
|
this.SessionCurrrentPlayPosMs = SessionCurrrentPlayPosMs;
|
|
this.SessionGetTracksPlayDurationMs = SessionGetTracksPlayDurationMs;
|
|
this.SessionPageEnter = SessionPageEnter;
|
|
this.SessionPageLeave = SessionPageLeave;
|
|
this.SetMixerMode = SetMixerMode;
|
|
|
|
this.SetVURefreshRate = SetVURefreshRate;
|
|
this.SessionGetMasterLocalMix = SessionGetMasterLocalMix;
|
|
this.SessionSetMasterLocalMix = SessionSetMasterLocalMix;
|
|
this.SessionGetDeviceLatency = SessionGetDeviceLatency;
|
|
this.SessionAudioResync = SessionAudioResync;
|
|
this.getConnectionDetail = getConnectionDetail;
|
|
|
|
// Track
|
|
this.TrackGetChannels = TrackGetChannels;
|
|
this.TrackSetAssignment = TrackSetAssignment;
|
|
this.TrackGetAssignment = TrackGetAssignment;
|
|
this.TrackSetCount = TrackSetCount;
|
|
this.TrackGetCount = TrackGetCount;
|
|
this.TrackSave = TrackSave;
|
|
this.TrackLoadAssignments = TrackLoadAssignments;
|
|
this.TrackSetInstrument = TrackSetInstrument;
|
|
this.TrackGetInstrument = TrackGetInstrument;
|
|
this.TrackSaveAssignments = TrackSaveAssignments;
|
|
|
|
this.TrackGetDevices = TrackGetDevices;
|
|
this.TrackDeleteProfile = TrackDeleteProfile;
|
|
this.TrackGetMusicDeviceID = TrackGetMusicDeviceID;
|
|
this.TrackSetMusicDevice = TrackSetMusicDevice;
|
|
this.TrackGetMusicDeviceNames = TrackGetMusicDeviceNames;
|
|
this.TrackHasControlPanel = TrackHasControlPanel;
|
|
this.TrackOpenControlPanel = TrackOpenControlPanel;
|
|
this.TrackIsMusicDeviceType = TrackIsMusicDeviceType;
|
|
|
|
this.TrackGetChatEnable = TrackGetChatEnable;
|
|
this.TrackSetChatEnable = TrackSetChatEnable;
|
|
|
|
this.TrackGetChatUsesMusic = TrackGetChatUsesMusic;
|
|
this.TrackSetChatUsesMusic = TrackSetChatUsesMusic;
|
|
|
|
this.GetJamTrackSettings = GetJamTrackSettings;
|
|
this.JamTrackStopPlay = JamTrackStopPlay;
|
|
this.JamTrackPlay = JamTrackPlay;
|
|
this.JamTrackIsPlayable = JamTrackIsPlayable;
|
|
this.JamTrackGetTrackDetail = JamTrackGetTrackDetail;
|
|
this.JamTrackKeysRequest = JamTrackKeysRequest;
|
|
this.JamTrackDownload = JamTrackDownload;
|
|
|
|
// Scoring Knobs
|
|
this.GetScoreWorkTimingInterval = GetScoreWorkTimingInterval;
|
|
this.SetScoreWorkTimingInterval = SetScoreWorkTimingInterval;
|
|
|
|
// Backing tracks:
|
|
this.getBackingTrackList = getBackingTrackList;
|
|
this.SessionCloseBackingTrackFile = SessionCloseBackingTrackFile;
|
|
this.SessionOpenBackingTrackFile = SessionOpenBackingTrackFile;
|
|
this.SessionSetBackingTrackFileLoop = SessionSetBackingTrackFileLoop;
|
|
|
|
// Metronome:
|
|
this.SessionCloseMetronome = SessionCloseMetronome;
|
|
this.SessionOpenMetronome = SessionOpenMetronome;
|
|
this.SessionSetMetronome = SessionSetMetronome;
|
|
this.setMetronomeOpenCallback = setMetronomeOpenCallback;
|
|
this.getMyNetworkState = getMyNetworkState;
|
|
this.getPeerState = getPeerState;
|
|
|
|
// Client Update
|
|
this.IsAppInWritableVolume = IsAppInWritableVolume;
|
|
this.ClientUpdateVersion = ClientUpdateVersion;
|
|
this.ClientUpdateStartDownload = ClientUpdateStartDownload;
|
|
this.ClientUpdateStartUpdate = ClientUpdateStartUpdate;
|
|
|
|
this.getClientParentChildRole = getClientParentChildRole;
|
|
this.getParentClientId = getParentClientId;
|
|
this.OpenSystemBrowser = OpenSystemBrowser;
|
|
this.RestartApplication = RestartApplication;
|
|
this.ShutdownApplication = ShutdownApplication;
|
|
|
|
// Websocket/Auth sessions
|
|
this.OnLoggedIn = OnLoggedIn;
|
|
this.OnLoggedOut = OnLoggedOut;
|
|
this.SessionGetMacHash = SessionGetMacHash;
|
|
|
|
this.UserAttention = UserAttention;
|
|
this.IsFrontendVisible = IsFrontendVisible;
|
|
this.LastUsedProfileName = LastUsedProfileName;
|
|
this.SetLastUsedProfileName = SetLastUsedProfileName;
|
|
|
|
// Recording Playback
|
|
this.GetLocalRecordingState = GetLocalRecordingState;
|
|
this.OpenRecording = OpenRecording;
|
|
this.CloseRecording = CloseRecording;
|
|
this.PreviewRecording = PreviewRecording;
|
|
this.ClosePreviewRecording = ClosePreviewRecording;
|
|
this.OnDownloadAvailable = OnDownloadAvailable;
|
|
|
|
// Video functionality:
|
|
this.testVideoRender = testVideoRender;
|
|
this.FTUESelectVideoCaptureDevice = FTUESelectVideoCaptureDevice;
|
|
this.FTUESetVideoEncodeResolution = FTUESetVideoEncodeResolution;
|
|
this.FTUEGetVideoCaptureDeviceNames = FTUEGetVideoCaptureDeviceNames;
|
|
this.FTUECurrentSelectedVideoDevice = FTUECurrentSelectedVideoDevice;
|
|
this.FTUEGetAvailableEncodeVideoResolutions = FTUEGetAvailableEncodeVideoResolutions;
|
|
this.FTUEGetVideoCaptureDeviceCapabilities = FTUEGetVideoCaptureDeviceCapabilities;
|
|
this.FTUEGetSendFrameRates = FTUEGetSendFrameRates;
|
|
this.FTUESetSendFrameRates = FTUESetSendFrameRates;
|
|
this.GetCurrentVideoResolution = GetCurrentVideoResolution;
|
|
this.GetCurrentVideoFrameRate = GetCurrentVideoFrameRate;
|
|
this.GetSampleRate = GetSampleRate;
|
|
this.FTUESetVideoShareEnable = FTUESetVideoShareEnable;
|
|
this.FTUEGetVideoShareEnable = FTUEGetVideoShareEnable;
|
|
this.isSessVideoShared = isSessVideoShared;
|
|
this.SessStopVideoSharing = SessStopVideoSharing;
|
|
this.SessStartVideoSharing = SessStartVideoSharing
|
|
|
|
this.IsVstLoaded = IsVstLoaded;
|
|
this.hasVstAssignment = hasVstAssignment;
|
|
|
|
// Clipboard
|
|
this.SaveToClipboard = SaveToClipboard;
|
|
|
|
// Capabilities
|
|
this.IsNativeClient = IsNativeClient;
|
|
|
|
// Audio
|
|
this.IsAudioStarted = IsAudioStarted;
|
|
this.StopAudio = StopAudio;
|
|
this.ResetPageCounters = ResetPageCounters;
|
|
this.ReloadAudioSystem = ReloadAudioSystem;
|
|
|
|
// Broadcasting
|
|
this.SessionLiveBroadcastStart = SessionLiveBroadcastStart;
|
|
this.SessionLiveBroadcastStop = SessionLiveBroadcastStop;
|
|
this.SessionSetConnectionStatusRefreshRate = SessionSetConnectionStatusRefreshRate;
|
|
|
|
// fake calls; not a part of the actual jam client
|
|
this.RegisterP2PMessageCallbacks = RegisterP2PMessageCallbacks;
|
|
this.SetFakeRecordingImpl = SetFakeRecordingImpl;
|
|
|
|
// network test
|
|
this.TestNetworkPktBwRate = TestNetworkPktBwRate;
|
|
this.StopNetworkTest = StopNetworkTest;
|
|
this.log = log;
|
|
this.getOperatingMode = getOperatingMode;
|
|
this.VSTLoad = VSTLoad;
|
|
this.VSTScan = VSTScan;
|
|
this.hasVstHost = hasVstHost;
|
|
this.getPluginList = getPluginList;
|
|
this.clearPluginList = clearPluginList;
|
|
this.listTrackAssignments = listTrackAssignments;
|
|
this.applySubscriptionPolicy = applySubscriptionPolicy;
|
|
this.clientID = "devtester";
|
|
};
|
|
|
|
})(window, jQuery);
|