private async Task <WebRTC.VideoTrackSource> InitAsync(CancellationToken token)
{
// Cache public properties on the Unity app thread.
int width = Constraints.width;
int height = Constraints.height;
double framerate = Constraints.framerate;
var deviceConfig = new LocalVideoDeviceInitConfig
{
videoDevice = WebcamDevice,
videoProfileId = VideoProfileId,
videoProfileKind = VideoProfileKind,
width = (width > 0 ? (uint?)width : null),
height = (height > 0 ? (uint?)height : null),
framerate = (framerate > 0 ? (double?)framerate : null),
enableMrc = EnableMixedRealityCapture,
enableMrcRecordingIndicator = EnableMRCRecordingIndicator
};
var formatMode = FormatMode;
// Continue the task outside the Unity app context, in order to avoid deadlock
// if OnDisable waits on this task.
bool accessGranted = await RequestAccessAsync(token).ConfigureAwait(continueOnCapturedContext: false);
if (!accessGranted)
{
return(null);
}
return(await CreateSourceAsync(formatMode, deviceConfig).ConfigureAwait(continueOnCapturedContext: false));
}
/// <summary>
/// Constructor for creating a local video device initialization settings marshaling struct.
/// </summary>
/// <param name="settings">The settings to initialize the newly created marshaling struct.</param>
/// <seealso cref="DeviceVideoTrackSource.CreateAsync(LocalVideoDeviceInitConfig)"/>
public LocalVideoDeviceMarshalInitConfig(LocalVideoDeviceInitConfig settings)
{
if (settings != null)
{
VideoDeviceId = settings.videoDevice.id;
VideoProfileId = settings.videoProfileId;
VideoProfileKind = settings.videoProfileKind;
Width = settings.width.GetValueOrDefault(0);
Height = settings.height.GetValueOrDefault(0);
Framerate = settings.framerate.GetValueOrDefault(0.0);
EnableMixedRealityCapture = (mrsBool)settings.enableMrc;
EnableMRCRecordingIndicator = (mrsBool)settings.enableMrcRecordingIndicator;
}
else
{
VideoDeviceId = string.Empty;
VideoProfileId = string.Empty;
VideoProfileKind = VideoProfileKind.Unspecified;
Width = 0;
Height = 0;
Framerate = 0.0;
EnableMixedRealityCapture = mrsBool.True;
EnableMRCRecordingIndicator = mrsBool.True;
}
}
public async Task AddVideoTrackFromDeviceAsync(string trackName)
{
await RequestMediaAccessAsync(StreamingCaptureMode.Video);
// Create the source
VideoCaptureDeviceInfo deviceInfo = VideoCaptureDevices.SelectedItem;
if (deviceInfo == null)
{
throw new InvalidOperationException("No video capture device selected");
}
var deviceConfig = new LocalVideoDeviceInitConfig
{
videoDevice = new VideoCaptureDevice {
id = deviceInfo.Id
},
};
VideoCaptureFormatViewModel formatInfo = VideoCaptureFormats.SelectedItem;
if (formatInfo != null)
{
deviceConfig.width = formatInfo.Format.width;
deviceConfig.height = formatInfo.Format.height;
deviceConfig.framerate = formatInfo.Format.framerate;
}
if (deviceInfo.SupportsVideoProfiles)
{
MediaCaptureVideoProfile profile = VideoProfiles.SelectedItem;
deviceConfig.videoProfileId = profile?.Id;
deviceConfig.videoProfileKind = SelectedVideoProfileKind;
}
var source = await DeviceVideoTrackSource.CreateAsync(deviceConfig);
// FIXME - this leaks the source, never disposed
// Crate the track
var trackConfig = new LocalVideoTrackInitConfig
{
trackName = trackName,
};
var track = LocalVideoTrack.CreateFromSource(source, trackConfig);
// FIXME - this probably leaks the track, never disposed
SessionModel.Current.VideoTracks.Add(new VideoTrackViewModel
{
Source = source,
Track = track,
TrackImpl = track,
IsRemote = false,
DeviceName = deviceInfo.DisplayName
});
SessionModel.Current.LocalTracks.Add(new TrackViewModel(Symbol.Video)
{
DisplayName = deviceInfo.DisplayName
});
}
static public async Task <VideoTrackSource> CreateAsync(LocalVideoDeviceInitConfig config = null)
{
Console.WriteLine("Calling Create Camera Method in thread {0}", Thread.CurrentThread.ManagedThreadId);
await Gate.WaitAsync();
if (VideoSource != null)
{
throw new SystemException("Camera instance already created and using");
}
Gate.Release();
VideoSource = await DeviceVideoTrackSource.CreateAsync(config);
return(VideoSource);
}
static private async Task StartStend()
{
var autoEvent = new AutoResetEvent(false);
bool video_translator = true;
bool file_created = false;
FileStream file = null;
Quartus quartus = Quartus.GetInstance();
Microcontroller arduino = Microcontroller.Create();
if (video_translator)
{
// Asynchronously retrieve a list of available video capture devices (webcams).
var deviceList = await DeviceVideoTrackSource.GetCaptureDevicesAsync();
// For example, print them to the standard output
foreach (var device in deviceList)
{
Console.WriteLine($"Found webcam {device.name} (id: {device.id})");
}
}
// Create a new peer connection automatically disposed at the end of the program
var pc = new PeerConnection();
// Initialize the connection with a STUN server to allow remote access
var config = SystemConfiguration.PeerConnectionSettings;
await pc.InitializeAsync(config);
Console.WriteLine("Peer connection initialized.");
//var chen = await pc.AddDataChannelAsync("sendDataChannel", true, true, cancellationToken: default);
Console.WriteLine("Opening local webcam...");
// pc - PeerConnection object
Transceiver videoTransceiver = null;
VideoTrackSource videoTrackSource = null;
LocalVideoTrack localVideoTrack = null;
LocalVideoDeviceInitConfig c = new LocalVideoDeviceInitConfig();
await VideoDeviceSelection();
videoTrackSource = await Camera.CreateAsync(SystemConfiguration.VideoDeviceSettings);
WebSocketSharp.WebSocket signaling = new WebSocketSharp.WebSocket(CreateSignalingServerUrl(), "id_token", "alpine");
pc.LocalSdpReadytoSend += (SdpMessage message) =>
{
//Console.WriteLine(SdpMessage.TypeToString(message.Type));
Console.WriteLine(message.Content);
//Console.WriteLine(HttpUtility.JavaScriptStringEncode(message.Content));
Console.WriteLine("Sdp offer to send: {\"data\":{\"description\":{\"type\":\"" + SdpMessage.TypeToString(message.Type) + "\",\"sdp\":\"" + HttpUtility.JavaScriptStringEncode(message.Content) + "\"}}}");
signaling.Send(message.ToABJson());
};
pc.RenegotiationNeeded += () =>
{
Console.WriteLine("Regotiation needed");
bool OfferCreated = pc.CreateOffer();
Console.WriteLine("OfferCreated? {0}", OfferCreated);
};
pc.DataChannelAdded += (DataChannel channel) =>
{
Console.WriteLine("Added data channel ID: {0}, Label: {1}; Reliable: {2}, Ordered: {3}", channel.ID, channel.Label, channel.Reliable, channel.Ordered);
if (channel.Label == "sendDataChannel")
{
channel.MessageReceived += (byte[] mess) => {
try
{
CTP_packet command = JsonSerializer.Deserialize <CTP_packet>(mess);
Console.WriteLine(arduino.SendCTP_Command(command));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
};
}
else
{
if (file_created == false)
{
file = new FileStream(channel.Label, FileMode.Append);
file_created = true;
}
channel.MessageReceived += async(byte[] mess) =>
{
// Console.WriteLine(System.Text.Encoding.Default.GetString(mess));
if (mess.Length == 3 && System.Text.Encoding.Default.GetString(mess) == "EOF")
{
string file_name = file.Name;
file.Close();
string t = await quartus.RunQuartusCommandAsync($"quartus_pgm -m jtag –o \"p;{file_name}@1\"");
File.Delete(file_name);
file_created = false;
}
else
{
WriteFileSegment(mess, file);
}
};
}
channel.StateChanged += () =>
{
Console.WriteLine("State change: {0}", channel.State);
};
};
pc.IceCandidateReadytoSend += (IceCandidate candidate) =>
{
//Console.WriteLine("Content: {0}, SdpMid: {1}, SdpMlineIndex: {2}", candidate.Content, candidate.SdpMid, candidate.SdpMlineIndex);
try
{
Console.WriteLine("Candidate to send: Content: {0}, SdpMid: {1}, SdpMlineIndex: {2}", candidate.Content, candidate.SdpMid, candidate.SdpMlineIndex);
signaling.Send(candidate.ToABJson());
}
catch (Exception e)
{
Console.WriteLine("Error to send local ice candidate");
}
};
//videoTrackSource.I420AVideoFrameReady += (frame) =>
//{
// Console.WriteLine("Argb32 frame ready. {0} : {1}", frame.width, frame.height);
// Console.WriteLine("DataA: {0}, DataU: {1}, DataV: {2}, DataY: {3}", Marshal.SizeOf(frame.dataA),
// Marshal.SizeOf(frame.dataU),
// Marshal.SizeOf(frame.dataV),
// Marshal.SizeOf(frame.dataY));
//};
signaling.OnMessage += async(sender, message) =>
{
(string header, string correct_message) = message.Data.DivideHeaderAndOriginalJSON();
Console.WriteLine("Correct message: {0}", correct_message);
Console.WriteLine("Header: {0}", header);
if (header == "{\"data\":{\"getRemoteMedia\":" && correct_message == "true")
{
Console.WriteLine("Create local video track...");
var trackSettings = new LocalVideoTrackInitConfig {
trackName = "webcam_track"
};
localVideoTrack = LocalVideoTrack.CreateFromSource(videoTrackSource, new LocalVideoTrackInitConfig {
trackName = "webcam_track"
});
Console.WriteLine("Create video transceiver and add webcam track...");
TransceiverInitSettings option = new TransceiverInitSettings();
option.Name = "webcam_track";
option.StreamIDs = new List <string> {
"webcam_name"
};
videoTransceiver = pc.AddTransceiver(MediaKind.Video, option);
videoTransceiver.DesiredDirection = Transceiver.Direction.SendOnly;
videoTransceiver.LocalVideoTrack = localVideoTrack;
bool OfferCreated = pc.CreateOffer();
Console.WriteLine("OfferCreated? {0}", OfferCreated);
}
//Console.WriteLine(message.Data);
if (header.IndexOf("candidate") != -1 && correct_message != "null")
{
try
{
var candidate = JsonSerializer.Deserialize <ICEJavaScriptNotation>(correct_message);
Console.WriteLine("Content of ice: {0}, SdpMid: {1}, SdpMLineIndex: {2}", candidate.candidate, candidate.sdpMid, candidate.sdpMLineIndex);
pc.AddIceCandidate(candidate.ToMRNetCoreNotation());
Console.WriteLine("Deserialized by ice_candidate");
//return;
}
catch (Exception)
{
Console.WriteLine("Could not deserialize as ice candidate");
}
}
if (header.IndexOf("description") != -1)
{
try
{
SdpMessage received_description = JsonSerializer.Deserialize <SDPJavaScriptNotation>(correct_message).ToMRNetCoreNotation();
await pc.SetRemoteDescriptionAsync(received_description);
if (received_description.Type == SdpMessageType.Offer)
{
bool res = pc.CreateAnswer();
Console.WriteLine("Answer created? {0}", res);
}
Console.WriteLine("Deserialized by sdp_message");
}
catch (Exception)
{
Console.WriteLine("Could not deserialize as sdp message");
}
}
};
pc.Connected += () =>
{
Console.WriteLine("Connected");
};
pc.IceStateChanged += (IceConnectionState newState) =>
{
if (newState == IceConnectionState.Disconnected)
{
Console.WriteLine("Disconected");
}
};
signaling.Connect();
if (!video_translator)
{
signaling.Send("{\"data\":{\"getRemoteMedia\":true}}");
}
//Console.WriteLine("Press a key to terminate the application...");
Console.ReadKey(true);
Console.WriteLine("Program termined.");
file?.Close();
pc?.Close();
signaling?.Close();
//arduino?.Close();
//(var a, var b) = ConvertString("{\"data\":{\"candidate\":null}}");
//Console.WriteLine("{0}, {1}", a, b);
}
protected async void OnEnable()
{
if (Source != null)
{
return;
}
#if PLATFORM_ANDROID
// Ensure Android binding is initialized before accessing the native implementation
Android.Initialize();
// Check for permission to access the camera
if (!Permission.HasUserAuthorizedPermission(Permission.Camera))
{
if (!_androidCameraRequestPending)
{
// Monitor the OnApplicationFocus(true) event during the next 5 minutes,
// and check for permission again each time (see below why).
_androidCameraRequestPending = true;
_androidCameraRequestRetryUntilTime = Time.time + 300;
// Display dialog requesting user permission. This will return immediately,
// and unfortunately there's no good way to tell when this completes. As a rule
// of thumb, application should lose focus, so check when focus resumes should
// be sufficient without having to poll every frame.
Permission.RequestUserPermission(Permission.Camera);
}
return;
}
#elif UNITY_WSA && !UNITY_EDITOR
// Request UWP access to video capture. The OS may show some popup dialog to the
// user to request permission. This will succeed only if the user grants permission.
try
{
// Note that the UWP UI thread and the main Unity app thread are always different.
// https://docs.unity3d.com/Manual/windowsstore-appcallbacks.html
// We leave the code below as an example of generic handling in case this would be used in
// some other place, and in case a future version of Unity decided to change that assumption,
// but currently OnEnable() is always invoked from the main Unity app thread so here the first
// branch is never taken.
if (UnityEngine.WSA.Application.RunningOnUIThread())
{
await RequestAccessAsync();
}
else
{
UnityEngine.WSA.Application.InvokeOnUIThread(() => RequestAccessAsync(), waitUntilDone: true);
}
}
catch (Exception ex)
{
// Log an error and prevent activation
Debug.LogError($"Video access failure: {ex.Message}.");
this.enabled = false;
return;
}
#endif
// Handle automatic capture format constraints
string videoProfileId = VideoProfileId;
var videoProfileKind = VideoProfileKind;
int width = Constraints.width;
int height = Constraints.height;
double framerate = Constraints.framerate;
#if ENABLE_WINMD_SUPPORT
if (FormatMode == LocalVideoSourceFormatMode.Automatic)
{
// Do not constrain resolution by default, unless the device calls for it (see below).
width = 0; // auto
height = 0; // auto
// Avoid constraining the framerate; this is generally not necessary (formats are listed
// with higher framerates first) and is error-prone as some formats report 30.0 FPS while
// others report 29.97 FPS.
framerate = 0; // auto
// For HoloLens, use video profile to reduce resolution and save power/CPU/bandwidth
if (global::Windows.Graphics.Holographic.HolographicSpace.IsAvailable)
{
if (!global::Windows.Graphics.Holographic.HolographicDisplay.GetDefault().IsOpaque)
{
if (global::Windows.ApplicationModel.Package.Current.Id.Architecture == global::Windows.System.ProcessorArchitecture.X86)
{
// Holographic AR (transparent) x86 platform - Assume HoloLens 1
videoProfileKind = WebRTC.VideoProfileKind.VideoRecording; // No profile in VideoConferencing
width = 896; // Target 896 x 504
}
else
{
// Holographic AR (transparent) non-x86 platform - Assume HoloLens 2
videoProfileKind = WebRTC.VideoProfileKind.VideoConferencing;
width = 960; // Target 960 x 540
}
}
}
}
#elif PLATFORM_ANDROID
if (FormatMode == LocalVideoSourceFormatMode.Automatic)
{
// Avoid constraining the framerate; this is generally not necessary (formats are listed
// with higher framerates first) and is error-prone as some formats report 30.0 FPS while
// others report 29.97 FPS.
framerate = 0; // auto
string deviceId = WebcamDevice.id;
if (string.IsNullOrEmpty(deviceId))
{
List <VideoCaptureDevice> listedDevices = await PeerConnection.GetVideoCaptureDevicesAsync();
if (listedDevices.Count > 0)
{
deviceId = listedDevices[0].id;
}
}
if (!string.IsNullOrEmpty(deviceId))
{
// Find the closest format to 720x480, independent of framerate
List <VideoCaptureFormat> formats = await DeviceVideoTrackSource.GetCaptureFormatsAsync(deviceId);
double smallestDiff = double.MaxValue;
bool hasFormat = false;
foreach (var fmt in formats)
{
double diff = Math.Abs(fmt.width - 720) + Math.Abs(fmt.height - 480);
if ((diff < smallestDiff) || !hasFormat)
{
hasFormat = true;
smallestDiff = diff;
width = (int)fmt.width;
height = (int)fmt.height;
}
}
if (hasFormat)
{
Debug.Log($"WebcamSource automated mode selected resolution {width}x{height} for Android video capture device #{deviceId}.");
}
}
}
#endif
// TODO - Fix codec selection (was as below before change)
// Force again PreferredVideoCodec right before starting the local capture,
// so that modifications to the property done after OnPeerInitialized() are
// accounted for.
//< FIXME
//PeerConnection.Peer.PreferredVideoCodec = PreferredVideoCodec;
// Check H.264 requests on Desktop (not supported)
//#if !ENABLE_WINMD_SUPPORT
// if (PreferredVideoCodec == "H264")
// {
// Debug.LogError("H.264 encoding is not supported on Desktop platforms. Using VP8 instead.");
// PreferredVideoCodec = "VP8";
// }
//#endif
// Create the track
var deviceConfig = new LocalVideoDeviceInitConfig
{
videoDevice = WebcamDevice,
videoProfileId = videoProfileId,
videoProfileKind = videoProfileKind,
width = (width > 0 ? (uint?)width : null),
height = (height > 0 ? (uint?)height : null),
framerate = (framerate > 0 ? (double?)framerate : null),
enableMrc = EnableMixedRealityCapture,
enableMrcRecordingIndicator = EnableMRCRecordingIndicator
};
try
{
var source = await DeviceVideoTrackSource.CreateAsync(deviceConfig);
AttachSource(source);
}
catch (Exception ex)
{
Debug.LogError($"Failed to create device track source for {nameof(WebcamSource)} component '{name}'.");
Debug.LogException(ex, this);
return;
}
}
protected async void OnEnable()
{
if (Source != null)
{
return;
}
#if UNITY_WSA && !UNITY_EDITOR
// Request UWP access to video capture. The OS may show some popup dialog to the
// user to request permission. This will succeed only if the user grants permission.
try
{
// Note that the UWP UI thread and the main Unity app thread are always different.
// https://docs.unity3d.com/Manual/windowsstore-appcallbacks.html
// We leave the code below as an example of generic handling in case this would be used in
// some other place, and in case a future version of Unity decided to change that assumption,
// but currently OnEnable() is always invoked from the main Unity app thread so here the first
// branch is never taken.
if (UnityEngine.WSA.Application.RunningOnUIThread())
{
await RequestAccessAsync();
}
else
{
UnityEngine.WSA.Application.InvokeOnUIThread(() => RequestAccessAsync(), waitUntilDone: true);
}
}
catch (Exception ex)
{
// Log an error and prevent activation
Debug.LogError($"Video access failure: {ex.Message}.");
this.enabled = false;
return;
}
#endif
string videoProfileId = VideoProfileId;
var videoProfileKind = VideoProfileKind;
int width = Constraints.width;
int height = Constraints.height;
double framerate = Constraints.framerate;
#if ENABLE_WINMD_SUPPORT
if (FormatMode == LocalVideoSourceFormatMode.Automatic)
{
// Do not constrain resolution by default, unless the device calls for it (see below).
width = 0; // auto
height = 0; // auto
// Avoid constraining the framerate; this is generally not necessary (formats are listed
// with higher framerates first) and is error-prone as some formats report 30.0 FPS while
// others report 29.97 FPS.
framerate = 0; // auto
// For HoloLens, use video profile to reduce resolution and save power/CPU/bandwidth
if (global::Windows.Graphics.Holographic.HolographicSpace.IsAvailable)
{
if (!global::Windows.Graphics.Holographic.HolographicDisplay.GetDefault().IsOpaque)
{
if (global::Windows.ApplicationModel.Package.Current.Id.Architecture == global::Windows.System.ProcessorArchitecture.X86)
{
// Holographic AR (transparent) x86 platform - Assume HoloLens 1
videoProfileKind = WebRTC.VideoProfileKind.VideoRecording; // No profile in VideoConferencing
width = 896; // Target 896 x 504
}
else
{
// Holographic AR (transparent) non-x86 platform - Assume HoloLens 2
videoProfileKind = WebRTC.VideoProfileKind.VideoConferencing;
width = 960; // Target 960 x 540
}
}
}
}
#endif
// TODO - Fix codec selection (was as below before change)
// Force again PreferredVideoCodec right before starting the local capture,
// so that modifications to the property done after OnPeerInitialized() are
// accounted for.
//< FIXME
//PeerConnection.Peer.PreferredVideoCodec = PreferredVideoCodec;
// Check H.264 requests on Desktop (not supported)
//#if !ENABLE_WINMD_SUPPORT
// if (PreferredVideoCodec == "H264")
// {
// Debug.LogError("H.264 encoding is not supported on Desktop platforms. Using VP8 instead.");
// PreferredVideoCodec = "VP8";
// }
//#endif
//// Ensure the track has a valid name
//string trackName = TrackName;
//if (trackName.Length == 0)
//{
// trackName = Guid.NewGuid().ToString();
// // Re-assign the generated track name for consistency
// TrackName = trackName;
//}
//SdpTokenAttribute.Validate(trackName, allowEmpty: false);
// Create the track
var deviceConfig = new LocalVideoDeviceInitConfig
{
videoDevice = WebcamDevice,
videoProfileId = videoProfileId,
videoProfileKind = videoProfileKind,
width = (width > 0 ? (uint?)width : null),
height = (height > 0 ? (uint?)height : null),
framerate = (framerate > 0 ? (double?)framerate : null),
enableMrc = EnableMixedRealityCapture,
enableMrcRecordingIndicator = EnableMRCRecordingIndicator
};
Source = await DeviceVideoTrackSource.CreateAsync(deviceConfig);
if (Source == null)
{
throw new Exception("Failed ot create webcam video source.");
}
IsStreaming = true;
VideoStreamStarted.Invoke(this);
}
async void OnClientConnected()
{
var pc = signaler.PeerConnection;
// Record video from local webcam, and send to remote peer
if (NeedVideo)
{
// For example, print them to the standard output
var deviceSettings = new LocalVideoDeviceInitConfig
{
width = VideoWidth,
height = VideoHeight,
};
if (VideoFps > 0)
{
deviceSettings.framerate = VideoFps;
}
if (VideoProfileId.Length > 0)
{
deviceSettings.videoProfileId = VideoProfileId;
}
Debug.Log($"Attempt to grab Camera - {deviceSettings.videoProfileId}: {deviceSettings.width}x{deviceSettings.height}@{deviceSettings.framerate}fps");
videoTrackSource = await DeviceVideoTrackSource.CreateAsync(deviceSettings);
Debug.Log($"Create local video track... {videoTrackSource}");
var trackSettings = new LocalVideoTrackInitConfig
{
trackName = "webcam_track"
};
localVideoTrack = LocalVideoTrack.CreateFromSource(videoTrackSource, trackSettings);
Debug.Log("Create video transceiver and add webcam track...");
videoTransceiver = pc.AddTransceiver(MediaKind.Video);
videoTransceiver.DesiredDirection = Transceiver.Direction.SendReceive;
videoTransceiver.LocalVideoTrack = localVideoTrack;
}
// Record audio from local microphone, and send to remote peer
if (NeedAudio)
{
Debug.Log("Opening local microphone...");
audioTrackSource = await DeviceAudioTrackSource.CreateAsync();
Debug.Log("Create local audio track...");
var trackSettings = new LocalAudioTrackInitConfig {
trackName = "mic_track"
};
localAudioTrack = LocalAudioTrack.CreateFromSource(audioTrackSource, trackSettings);
Debug.Log("Create audio transceiver and add mic track...");
audioTransceiver = pc.AddTransceiver(MediaKind.Audio);
audioTransceiver.DesiredDirection = Transceiver.Direction.SendReceive;
audioTransceiver.LocalAudioTrack = localAudioTrack;
}
// Start peer connection
int numFrames = 0;
pc.VideoTrackAdded += (RemoteVideoTrack track) =>
{
Debug.Log($"Attach Frame Listener...");
track.I420AVideoFrameReady += (I420AVideoFrame frame) =>
{
++numFrames;
if (numFrames % 60 == 0)
{
Debug.Log($"Received video frames: {numFrames}");
}
};
};
// we need a short delay here for the video stream to settle...
// I assume my Logitech webcam is sending some garbage frames in the beginning.
await Task.Delay(200);
pc.CreateOffer();
Debug.Log("Send offer to remote peer");
}
// This method might be run outside the app thread and should not access the Unity API.
private static async Task <WebRTC.VideoTrackSource> CreateSourceAsync(
LocalVideoSourceFormatMode formatMode, LocalVideoDeviceInitConfig deviceConfig)
{
// Handle automatic capture format constraints
#if ENABLE_WINMD_SUPPORT
if (formatMode == LocalVideoSourceFormatMode.Automatic)
{
// Do not constrain resolution by default, unless the device calls for it (see below).
deviceConfig.width = 0; // auto
deviceConfig.height = 0; // auto
// Avoid constraining the framerate; this is generally not necessary (formats are listed
// with higher framerates first) and is error-prone as some formats report 30.0 FPS while
// others report 29.97 FPS.
deviceConfig.framerate = 0; // auto
// For HoloLens, use video profile to reduce resolution and save power/CPU/bandwidth
if (global::Windows.Graphics.Holographic.HolographicSpace.IsAvailable)
{
if (!global::Windows.Graphics.Holographic.HolographicDisplay.GetDefault().IsOpaque)
{
if (global::Windows.ApplicationModel.Package.Current.Id.Architecture == global::Windows.System.ProcessorArchitecture.X86)
{
// Holographic AR (transparent) x86 platform - Assume HoloLens 1
deviceConfig.videoProfileKind = WebRTC.VideoProfileKind.VideoRecording; // No profile in VideoConferencing
deviceConfig.width = 896; // Target 896 x 504
}
else
{
// Holographic AR (transparent) non-x86 platform - Assume HoloLens 2
deviceConfig.videoProfileKind = WebRTC.VideoProfileKind.VideoConferencing;
deviceConfig.width = 960; // Target 960 x 540
}
}
}
}
#elif !UNITY_EDITOR && UNITY_ANDROID
if (formatMode == LocalVideoSourceFormatMode.Automatic)
{
// Avoid constraining the framerate; this is generally not necessary (formats are listed
// with higher framerates first) and is error-prone as some formats report 30.0 FPS while
// others report 29.97 FPS.
deviceConfig.framerate = 0; // auto
string deviceId = deviceConfig.videoDevice.id;
if (string.IsNullOrEmpty(deviceId))
{
// Continue the task outside the Unity app context, in order to avoid deadlock
// if OnDisable waits on this task.
IReadOnlyList <VideoCaptureDevice> listedDevices =
await PeerConnection.GetVideoCaptureDevicesAsync()
.ConfigureAwait(continueOnCapturedContext: false);
if (listedDevices.Count > 0)
{
deviceId = listedDevices[0].id;
}
}
if (!string.IsNullOrEmpty(deviceId))
{
// Find the closest format to 720x480, independent of framerate
// Continue the task outside the Unity app context, in order to avoid deadlock
// if OnDisable waits on this task.
IReadOnlyList <VideoCaptureFormat> formats =
await DeviceVideoTrackSource.GetCaptureFormatsAsync(deviceId)
.ConfigureAwait(continueOnCapturedContext: false);
double smallestDiff = double.MaxValue;
bool hasFormat = false;
foreach (var fmt in formats)
{
double diff = Math.Abs(fmt.width - 720) + Math.Abs(fmt.height - 480);
if ((diff < smallestDiff) || !hasFormat)
{
hasFormat = true;
smallestDiff = diff;
deviceConfig.width = fmt.width;
deviceConfig.height = fmt.height;
}
}
if (hasFormat)
{
Debug.Log($"WebcamSource automated mode selected resolution {deviceConfig.width}x{deviceConfig.height} for Android video capture device #{deviceId}.");
}
}
}
#endif
// TODO - Fix codec selection (was as below before change)
// Force again PreferredVideoCodec right before starting the local capture,
// so that modifications to the property done after OnPeerInitialized() are
// accounted for.
//< FIXME
//PeerConnection.Peer.PreferredVideoCodec = PreferredVideoCodec;
// Check H.264 requests on Desktop (not supported)
//#if !ENABLE_WINMD_SUPPORT
// if (PreferredVideoCodec == "H264")
// {
// Debug.LogError("H.264 encoding is not supported on Desktop platforms. Using VP8 instead.");
// PreferredVideoCodec = "VP8";
// }
//#endif
// Create the track
var createTask = DeviceVideoTrackSource.CreateAsync(deviceConfig);
// Continue the task outside the Unity app context, in order to avoid deadlock
// if OnDisable waits on this task.
return(await createTask.ConfigureAwait(continueOnCapturedContext : false));
}
