public static string CalculateCameraName(MixCastData.CameraCalibrationData camera)
{
if (!string.IsNullOrEmpty(camera.displayName))
{
return(camera.displayName);
}
if (!string.IsNullOrEmpty(camera.deviceName))
{
return(camera.deviceName);
}
int cameraIndex = 0;
for (int i = 0; i < MixCast.Settings.cameras.Count; i++)
{
if (MixCast.Settings.cameras[i] == camera)
{
break;
}
if (!string.IsNullOrEmpty(MixCast.Settings.cameras[i].displayName))
{
continue;
}
if (!string.IsNullOrEmpty(MixCast.Settings.cameras[i].deviceName))
{
continue;
}
cameraIndex++;
}
return(string.Format(Text.Localization.Get("Str_VRCamNameDefault"), "(" + (cameraIndex + 1).ToString() + ")"));
}
void UpdateSettings()
{
if (string.IsNullOrEmpty(_camID))
{
_camID = AudioDeviceManager.ALTNAMEFORNULL;
}
MixCastData.CameraCalibrationData curCam = MixCast.Settings.GetCameraByID(_camID);
if (curCam == null || curCam.audioData == null)
{
return; // shouldn't happen, but just in case.
}
var device = AudioDeviceManager.GetAudioDeviceByAltName(curCam.audioData.audioAltName);
if (device != null)
{
_adeviceAltName = device.audioDeviceAltName;
_adeviceBitsPerSample = (int)device.bitsPerSample;
_adeviceChannels = (int)device.channel;
_adeviceConfiguration = device.defaultSettings.audioConfig;
_adeviceSamplingRate = (int)device.samplingRate;
_adeviceDelayMs = (int)device.desktopDelayMs;
// deviceName = device.audioDeviceName; // commenting out so no import warning in SDK
}
}
static void AutoStartTimelapse(MixCastData.CameraCalibrationData cam)
{
if (!cam.recordingData.autoStartTimelapse)
{
return;
}
TimelapseCameras.Add(cam);
}
static void AutoStartRecording(MixCastData.CameraCalibrationData cam)
{
if (!cam.recordingData.autoStartRecording)
{
return;
}
RecordingCameras.Add(cam);
}
static void SetAutoStartForCamera(MixCastData.CameraCalibrationData cam)
{
if (cam == null || cam.recordingData == null)
{
return;
}
AutoStartRecording(cam);
AutoStartStreaming(cam);
AutoStartTimelapse(cam);
}
private void Update()
{
createCams.AddRange(MixCast.Settings.cameras);
destroyCams.AddRange(CameraInstances);
for (int i = 0; i < CameraInstances.Count; i++)
{
MixCastData.CameraCalibrationData camData = CameraInstances[i].Data;
for (int j = createCams.Count - 1; j >= 0; j--)
{
if (createCams[j] == camData)
{
createCams.RemoveAt(j);
}
}
}
for (int i = 0; i < MixCast.Settings.cameras.Count; i++)
{
for (int j = destroyCams.Count - 1; j >= 0; j--)
{
if (destroyCams[j].Data == MixCast.Settings.cameras[i])
{
destroyCams.RemoveAt(j);
}
}
}
for (int i = 0; i < destroyCams.Count; i++)
{
CameraInstances.Remove(destroyCams[i]);
Destroy(destroyCams[i].gameObject);
}
for (int i = 0; i < createCams.Count; i++)
{
bool wasPrefabActive = cameraPrefab.gameObject.activeSelf;
cameraPrefab.gameObject.SetActive(false);
CameraConfigContext instance = Instantiate(cameraPrefab, transform, false);
instance.Data = createCams[i];
CameraInstances.Add(instance);
cameraPrefab.gameObject.SetActive(wasPrefabActive);
instance.gameObject.SetActive(MixCast.Active);
}
destroyCams.Clear();
createCams.Clear();
// Process LibAVStuff logs
MixCastAV.LogOutput();
}
IEnumerator PlayWhenReady()
{
while (_instance == null || string.IsNullOrEmpty(_camID) || _camID == AudioDeviceManager.ALTNAMEFORNULL)
{
yield return(waitForFixedUpdate);
}
yield return(waitForEndOfFrame);
camData = MixCast.Settings.GetCameraByID(_camID);
if (camData != null)
{
PlayWithSettings(camData);
}
}
public static bool IsRealSense(MixCastData.CameraCalibrationData camData)
{
if (camData == null)
{
return(false);
}
if (camData.deviceName.Contains("RealSense") ||
camData.deviceName.Contains("realsense") ||
camData.deviceName.Contains("Realsense"))
{
return(true);
}
return(false);
}
void ApplyName(MixCastData.CameraCalibrationData data)
{
if (data != null)
{
text.text = MixCastDataUtility.CalculateCameraName(data);
lastCustomName = data.displayName;
lastCamDevice = data.deviceName;
}
else
{
text.text = "";
lastCustomName = null;
lastCamDevice = null;
}
}
static void AutoStartStreaming(MixCastData.CameraCalibrationData cam)
{
if (!cam.recordingData.autoStartStreaming)
{
return;
}
var cameraStreamUrl = StreamingServiceUtility.ConstructStreamUrl(cam.recordingData);
var globalStreamUrl = StreamingServiceUtility.ConstructStreamUrl(Settings.global);
var isStreamingConfigured = !string.IsNullOrEmpty(cameraStreamUrl) ||
!string.IsNullOrEmpty(globalStreamUrl);
if (!isStreamingConfigured)
{
return;
}
StreamingCameras.Add(cam);
}
public RETURNCHANGETYPE PlayWithSettings(MixCastData.CameraCalibrationData cam)
{
if (_suppressingPlayback)
{
return(RETURNCHANGETYPE.NothingNewDoNothing);
}
cam.audioData.delayMs = (int)cam.bufferTime;
micData = AudioDeviceManager.GetAudioDeviceByAltName(cam.audioData.audioAltName);
if (cam != null)
{
if (micData != null)
{
return(SetPlay(cam.audioData.audioAltName, (int)micData.channel, (int)micData.samplingRate, (int)micData.bitsPerSample,
cam.audioData.audioConfig, cam.audioData.volume, cam.audioData.desktopVolume, cam.audioData.delayMs));
}
cam.audioData.useAudioInput = false; // mic is null
return(SetPlay("", 0, 0, 0, cam.audioData.audioConfig, 0.0f, cam.audioData.desktopVolume, cam.audioData.delayMs));
}
return(SetPlay("", 0, 0, 0, MixCastAV.AUDIOCONFIG.NO_AUDIO, 0.0f, 0.0f, 0));
}
/// <summary>
/// Adds device info to the camera data.
/// </summary>
static void AddDeviceInfo(MixCastData.CameraCalibrationData camera, FeedDeviceManager.DeviceInfo device)
{
if (string.IsNullOrEmpty(camera.deviceAltName))
{
camera.deviceAltName = device.altname;
}
if (camera.deviceFramerate == 0)
{
camera.deviceFramerate = device.outputs
.Select(output => Convert.ToInt32(output.framerate))
.OrderBy(framerate => framerate)
.FirstOrDefault();
}
if (string.IsNullOrEmpty(camera.devicePixelFormat))
{
camera.devicePixelFormat = device.outputs
.Select(output => output.pixelFormat)
.FirstOrDefault();
}
}
public void DestroyedCamera(MixCastData.CameraCalibrationData camera)
{
for (int i = 0; i < displayingCameras.Count; i++)
{
if (displayingCameras[i] != camera)
{
continue;
}
int index = MixCast.Settings.cameras.IndexOf(camera);
if (index > 0)
{
displayingCameras[i] = MixCast.Settings.cameras[index - 1];
}
else if (index < MixCast.Settings.cameras.Count - 1)
{
displayingCameras[i] = MixCast.Settings.cameras[index + 1];
}
else
{
displayingCameras[i] = null;
}
}
}
public bool CameraInUse(MixCastData.CameraCalibrationData cam)
{
return(ShowingOutput && displayingCameras.Contains(cam));
}
