public void RTCRtpSendParametersCreateAndDeletePtr()
{
RTCRtpSendParametersInternal parametersInternal = new RTCRtpSendParametersInternal();
int encodingsLength = 2;
RTCRtpEncodingParametersInternal[] encodings = new RTCRtpEncodingParametersInternal[encodingsLength];
for (int i = 0; i < encodingsLength; i++)
{
encodings[i].active = true;
encodings[i].hasValueMaxBitrate = true;
encodings[i].maxBitrate = 10000000;
encodings[i].hasValueMaxFramerate = true;
encodings[i].maxFramerate = 30;
encodings[i].hasValueScaleResolutionDownBy = true;
encodings[i].scaleResolutionDownBy = 1.0;
encodings[i].rid = Marshal.StringToCoTaskMemAnsi(string.Empty);
}
parametersInternal.transactionId = Marshal.StringToCoTaskMemAnsi(string.Empty);
parametersInternal.encodingsLength = encodingsLength;
parametersInternal.encodings = IntPtrExtension.ToPtr(encodings);
RTCRtpSendParameters parameter = new RTCRtpSendParameters(parametersInternal);
IntPtr ptr = parameter.CreatePtr();
RTCRtpSendParameters.DeletePtr(ptr);
}
public void AsArrayReturnsByteArray()
{
byte[] source = { 1, 2, 3 };
IntPtr ptr = IntPtrExtension.ToPtr(source);
byte[] dest = ptr.AsArray <byte>(source.Length);
Assert.IsNotEmpty(dest);
CollectionAssert.AreEqual(source, dest);
}
public void AsArrayReturnsUlongArray()
{
ulong[] source = { 1, 2, 3 };
IntPtr ptr = IntPtrExtension.ToPtr(source);
ulong[] dest = ptr.AsArray <ulong>(source.Length);
Assert.IsNotEmpty(dest);
CollectionAssert.AreEqual(source, dest);
}
public void AsArrayReturnsStringArray()
{
string[] source = { "red", "blue", "yellow" };
IntPtr ptr = IntPtrExtension.ToPtr(source);
string[] dest = ptr.AsArray <string>(source.Length);
Assert.IsNotEmpty(dest);
CollectionAssert.AreEqual(source, dest);
}
public void AsArrayReturnsBoolArray()
{
bool[] source = { true, false, true };
IntPtr ptr = IntPtrExtension.ToPtr(source);
bool[] dest = ptr.AsArray <bool>(source.Length);
Assert.IsNotEmpty(dest);
CollectionAssert.AreEqual(source, dest);
}
public void AsArrayReturnsDoubleArray()
{
float[] source = { 0.1f, 0.2f, 0.3f };
IntPtr ptr = IntPtrExtension.ToPtr(source);
float[] dest = ptr.AsArray <float>(source.Length);
Assert.IsNotEmpty(dest);
CollectionAssert.AreEqual(source, dest);
}
public void AsArrayReturnsFloatArray()
{
double[] source = { 0.1, 0.2, 0.3 };
IntPtr ptr = IntPtrExtension.ToPtr(source);
double[] dest = ptr.AsArray <double>(source.Length);
Assert.IsNotEmpty(dest);
CollectionAssert.AreEqual(source, dest);
}
public IntPtr Execute(IExpression expression, IProcessReader processReader)
{
Contract.Requires(expression != null);
Contract.Requires(processReader != null);
switch (expression)
{
case ConstantExpression constantExpression:
return(IntPtrExtension.From(constantExpression.Value));
case NegateExpression negateExpression:
return(Execute(negateExpression.Expression, processReader).Negate());
case ModuleExpression moduleExpression:
{
var module = processReader.GetModuleByName(moduleExpression.Name);
if (module != null)
{
return(module.Start);
}
return(IntPtr.Zero);
}
case AddExpression addExpression:
return(Execute(addExpression.Lhs, processReader).Add(Execute(addExpression.Rhs, processReader)));
case SubtractExpression subtractExpression:
return(Execute(subtractExpression.Lhs, processReader).Sub(Execute(subtractExpression.Rhs, processReader)));
case MultiplyExpression multiplyExpression:
return(Execute(multiplyExpression.Lhs, processReader).Mul(Execute(multiplyExpression.Rhs, processReader)));
case DivideExpression divideExpression:
return(Execute(divideExpression.Lhs, processReader).Div(Execute(divideExpression.Rhs, processReader)));
case ReadMemoryExpression readMemoryExpression:
var readFromAddress = Execute(readMemoryExpression.Expression, processReader);
if (readMemoryExpression.ByteCount == 4)
{
return(IntPtrExtension.From(processReader.ReadRemoteInt32(readFromAddress)));
}
else
{
return(IntPtrExtension.From(processReader.ReadRemoteInt64(readFromAddress)));
}
default:
throw new ArgumentException($"Unsupported operation '{expression.GetType().FullName}'.");
}
}
