private void ChangeBandwitdh(int index)
{
if (_pc1 == null || _pc2 == null)
{
return;
}
ulong? bandwidth = bandwidthOptions.Values.ElementAt(index);
RTCRtpSender sender = _pc1.GetSenders().First();
RTCRtpSendParameters parameters = sender.GetParameters();
if (bandwidth == null)
{
parameters.encodings[0].maxBitrate = null;
parameters.encodings[0].minBitrate = null;
}
else
{
parameters.encodings[0].maxBitrate = bandwidth * 1000;
parameters.encodings[0].minBitrate = bandwidth * 1000;
}
RTCErrorType error = sender.SetParameters(parameters);
if (error != RTCErrorType.None)
{
Debug.LogErrorFormat("RTCRtpSender.SetParameters failed {0}", error);
}
}
private void AddTracks()
{
foreach (var track in videoStream.GetTracks())
{
pc1Senders.Add(_pc1.AddTrack(track, videoStream));
}
if (!videoUpdateStarted)
{
StartCoroutine(WebRTC.Update());
videoUpdateStarted = true;
}
RTCRtpCodecCapability[] codecs = null;
if (codecSelector.value == 0)
{
codecs = RTCRtpSender.GetCapabilities(TrackKind.Video).codecs;
}
else
{
RTCRtpCodecCapability preferredCodec = availableCodecs[codecSelector.value - 1];
codecs = new[] { preferredCodec };
}
RTCRtpTransceiver transceiver = _pc1.GetTransceivers().First();
RTCErrorType error = transceiver.SetCodecPreferences(codecs);
if (error != RTCErrorType.None)
{
Debug.LogErrorFormat("RTCRtpTransceiver.SetCodecPreferences failed. {0}", error);
}
}
/// <summary>
///
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public RTCError SetParameters(RTCRtpSendParameters parameters)
{
if (Track is VideoStreamTrack videoTrack)
{
foreach (var encoding in parameters.encodings)
{
var scale = encoding.scaleResolutionDownBy;
if (!scale.HasValue)
{
continue;
}
var error = WebRTC.ValidateTextureSize((int)(videoTrack.Texture.width / scale),
(int)(videoTrack.Texture.height / scale), Application.platform);
if (error.errorType != RTCErrorType.None)
{
return(error);
}
}
}
parameters.CreateInstance(out RTCRtpSendParametersInternal instance);
IntPtr ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(instance));
Marshal.StructureToPtr(instance, ptr, false);
RTCErrorType type = NativeMethods.SenderSetParameters(GetSelfOrThrow(), ptr);
Marshal.FreeCoTaskMem(ptr);
return(new RTCError {
errorType = type
});
}
public RTCErrorType SetParameters(RTCRtpSendParameters parameters)
{
IntPtr ptr = parameters.CreatePtr();
RTCErrorType error = NativeMethods.SenderSetParameters(self, ptr);
RTCRtpSendParameters.DeletePtr(ptr);
return(error);
}
/// <summary>
///
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public RTCErrorType SetParameters(RTCRtpSendParameters parameters)
{
parameters.CreateInstance(out RTCRtpSendParametersInternal instance);
IntPtr ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(instance));
Marshal.StructureToPtr(instance, ptr, false);
RTCErrorType error = NativeMethods.SenderSetParameters(self, ptr);
Marshal.FreeCoTaskMem(ptr);
return(error);
}
public RTCError PeerConnectionSetLocalDescription(IntPtr ptr)
{
IntPtr ptrError = IntPtr.Zero;
RTCErrorType errorType =
NativeMethods.PeerConnectionSetLocalDescriptionWithoutDescription(self, ptr, ref ptrError);
string message = ptrError != IntPtr.Zero ? ptrError.AsAnsiStringWithFreeMem() : null;
return(new RTCError {
errorType = errorType, message = message
});
}
public RTCErrorType SetCodecPreferences(RTCRtpCodecCapability[] codecs)
{
RTCRtpCodecCapabilityInternal[] array = Array.ConvertAll(codecs, v => v.Cast());
MarshallingArray <RTCRtpCodecCapabilityInternal> instance = array;
RTCErrorType error = NativeMethods.TransceiverSetCodecPreferences(self, instance.ptr, instance.length);
foreach (var v in array)
{
v.Dispose();
}
instance.Dispose();
return(error);
}
static void OnSetSessionDescFailure(IntPtr ptr, RTCErrorType type, string message)
{
WebRTC.Sync(ptr, () =>
{
if (WebRTC.Table[ptr] is RTCPeerConnection connection)
{
RTCError error = new RTCError {
errorType = type, message = message
};
connection.OnSetSessionDescriptionFailure(error);
}
});
}
static void OnFailureCreateSessionDesc(IntPtr ptr, RTCErrorType type, string message)
{
WebRTC.Sync(ptr, () =>
{
if (WebRTC.Table[ptr] is RTCPeerConnection connection)
{
connection.m_opSessionDesc.IsError = true;
connection.m_opSessionDesc.Error = new RTCError {
errorType = type, message = message
};
connection.m_opSessionDesc.Done();
}
});
}
/// <summary>
///
/// </summary>
/// <param name="track"></param>
/// <param name="stream"></param>
/// <returns></returns>
/// <seealso cref="RemoveTrack"/>
public RTCRtpSender AddTrack(MediaStreamTrack track, MediaStream stream = null)
{
if (track == null)
{
throw new ArgumentNullException("track is null.");
}
var streamId = stream?.Id;
RTCErrorType error = NativeMethods.PeerConnectionAddTrack(
GetSelfOrThrow(), track.GetSelfOrThrow(), streamId, out var ptr);
if (error != RTCErrorType.None)
{
throw new InvalidOperationException($"error occurred :{error}");
}
cacheTracks.Add(track);
return(CreateSender(ptr));
}
public IEnumerator SetParametersReturnNoError()
{
var camObj = new GameObject("Camera");
var cam = camObj.AddComponent <Camera>();
var videoStream = cam.CaptureStream(1280, 720, 1000000);
yield return(new WaitForSeconds(0.1f));
var test = new MonoBehaviourTest <SignalingPeers>();
test.component.AddStream(0, videoStream);
yield return(test);
test.component.CoroutineUpdate();
yield return(new WaitForSeconds(0.1f));
var senders = test.component.GetPeerSenders(0);
Assert.That(senders, Has.Count.GreaterThan(0));
foreach (var sender in senders)
{
var parameters = sender.GetParameters();
Assert.That(parameters.encodings, Has.Length.GreaterThan(0).And.All.Not.Null);
const uint framerate = 20;
parameters.encodings[0].maxFramerate = framerate;
RTCErrorType error = sender.SetParameters(parameters);
Assert.That(error, Is.EqualTo(RTCErrorType.None));
var parameters2 = sender.GetParameters();
Assert.That(parameters2.encodings[0].maxFramerate, Is.EqualTo(framerate));
}
test.component.Dispose();
foreach (var track in videoStream.GetTracks())
{
track.Dispose();
}
// wait for disposing video track.
yield return(0);
videoStream.Dispose();
Object.DestroyImmediate(camObj);
Object.DestroyImmediate(test.gameObject);
}
public IEnumerator SetParametersReturnNoError()
{
var camObj = new GameObject("Camera");
var cam = camObj.AddComponent <Camera>();
var videoStream = cam.CaptureStream(1280, 720, 1000000);
yield return(new WaitForSeconds(0.1f));
var test = new MonoBehaviourTest <SignalingPeers>();
test.component.SetStream(videoStream);
yield return(test);
test.component.CoroutineUpdate();
yield return(new WaitForSeconds(0.1f));
var senders = test.component.GetPeerSenders(0);
Assert.IsNotEmpty(senders);
foreach (var sender in senders)
{
var parameters = sender.GetParameters();
Assert.IsNotEmpty(parameters.encodings);
const uint framerate = 20;
parameters.encodings[0].maxFramerate = framerate;
RTCErrorType error = sender.SetParameters(parameters);
Assert.AreEqual(RTCErrorType.None, error);
var parameters2 = sender.GetParameters();
Assert.AreEqual(framerate, parameters2.encodings[0].maxFramerate);
}
test.component.Dispose();
foreach (var track in videoStream.GetTracks())
{
track.Dispose();
}
// wait for disposing video track.
yield return(0);
videoStream.Dispose();
Object.DestroyImmediate(camObj);
}
/// <summary>
///
/// </summary>
/// <param name="candidateInfo"></param>
public RTCIceCandidate(RTCIceCandidateInit candidateInfo = null)
{
candidateInfo = candidateInfo ?? new RTCIceCandidateInit();
if (candidateInfo.sdpMLineIndex == null && candidateInfo.sdpMid == null)
{
throw new ArgumentException("sdpMid and sdpMLineIndex are both null");
}
RTCIceCandidateInitInternal option = (RTCIceCandidateInitInternal)candidateInfo;
RTCErrorType error = NativeMethods.CreateIceCandidate(ref option, out self);
if (error != RTCErrorType.None)
{
throw new ArgumentException(
$"create candidate is failed. error type:{error}, " +
$"candidate:{candidateInfo.candidate}\n" +
$"sdpMid:{candidateInfo.sdpMid}\n" +
$"sdpMLineIndex:{candidateInfo.sdpMLineIndex}\n");
}
NativeMethods.IceCandidateGetCandidate(self, out _candidate);
}
static void PeerConnectionSetSessionDescFailure(IntPtr connection, RTCErrorType type, string message)
{
}
