public void FromMemoryBlockAndContiguousTest()
{
CMBlockBufferError err1;
CMBlockBufferError err2;
using (var bb = CMBlockBuffer.FromMemoryBlock(IntPtr.Zero, 16, null, 0, 5, CMBlockBufferFlags.AssureMemoryNow, out err1))
using (var bc = CMBlockBuffer.CreateContiguous(bb, null, 0, 5, CMBlockBufferFlags.AssureMemoryNow, out err2)) {
Assert.That(err1, Is.EqualTo(CMBlockBufferError.None), "FromMemoryBlock error");
Assert.That(err2, Is.EqualTo(CMBlockBufferError.None), "CreateContiguous error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)5), "FromMemoryBlock DataLength");
Assert.That(bc.DataLength, Is.EqualTo((nuint)5), "CreateContiguous DataLength");
}
using (var allocator = new CMCustomBlockAllocator())
using (var bb = CMBlockBuffer.FromMemoryBlock(IntPtr.Zero, 16, allocator, 0, 5, CMBlockBufferFlags.AssureMemoryNow, out err1))
using (var bc = CMBlockBuffer.CreateContiguous(bb, allocator, 0, 5, CMBlockBufferFlags.AssureMemoryNow, out err2)) {
Assert.That(err1, Is.EqualTo(CMBlockBufferError.None), "FromMemoryBlock error");
Assert.That(err2, Is.EqualTo(CMBlockBufferError.None), "CreateContiguous error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)5), "FromMemoryBlock DataLength");
Assert.That(bc.DataLength, Is.EqualTo((nuint)5), "CreateContiguous DataLength");
}
using (var allocator = new CustomAllocator(this))
using (var bb = CMBlockBuffer.FromMemoryBlock(IntPtr.Zero, 16, allocator, 0, 5, CMBlockBufferFlags.AssureMemoryNow, out err1)) {
Assert.That(err1, Is.EqualTo(CMBlockBufferError.None), "FromMemoryBlock error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)5), "FromMemoryBlock DataLength");
Assert.IsTrue(allocateCalled, "FromMemoryBlock AllocateCalled");
}
Assert.IsTrue(freeCalled, "FromMemoryBlock FreeCalled");
}
public void GetDataPointerTest()
{
byte [] data = new byte [] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9 };
byte [] tempBuffer = new byte [5];
GCHandle pinned = GCHandle.Alloc(data, GCHandleType.Pinned);
IntPtr pointer = pinned.AddrOfPinnedObject();
CMBlockBufferError err;
using (var buf = CMBlockBuffer.FromMemoryBlock(pointer, (uint)data.Length, null, 0, (uint)data.Length, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 1: {err}");
IntPtr outPtr = IntPtr.Zero;
nuint lengthAtOffset;
nuint totalLength;
err = buf.GetDataPointer(5, out lengthAtOffset, out totalLength, ref outPtr);
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 2: {err}");
Marshal.Copy(outPtr, tempBuffer, 0, (int)lengthAtOffset);
for (int i = 0; i < tempBuffer.Length; i++)
{
Assert.AreEqual((byte)(i + 5), tempBuffer [i], $"CMBlockBuffer GetDataPointerTest iteration: {i}");
}
}
pinned.Free();
}
public void CreateEmpty()
{
CMBlockBufferError err;
using (var bb = CMBlockBuffer.CreateEmpty(16, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), "error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)0), "DataLength");
}
}
public void FromMemoryBlockWithByteArrayTest()
{
byte [] data = new byte [32768];
CMBlockBufferError err;
using (var buf = CMBlockBuffer.FromMemoryBlock(data, 0, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), "CMBlockBufferError");
// dispose called before unpinning (ok)
}
}
public void AppendMemoryBlockWithByteArrayTest()
{
byte [] data = new byte [32768];
byte [] data2 = new byte [32768];
CMBlockBufferError err;
using (var buf = CMBlockBuffer.FromMemoryBlock(data, 0, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 1: {err}");
err = buf.AppendMemoryBlock(data2, 0, CMBlockBufferFlags.AssureMemoryNow);
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 2: {err}");
}
}
public void FromMemoryBlockWithManagedMemory()
{
byte [] data = new byte [32768];
GCHandle pinned = GCHandle.Alloc(data, GCHandleType.Pinned);
IntPtr pointer = pinned.AddrOfPinnedObject();
CMBlockBufferError err;
using (var buf = CMBlockBuffer.FromMemoryBlock(pointer, (uint)data.Length, null, 0, (uint)data.Length, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), "CMBlockBufferError");
// dispose called before unpinning (ok)
}
pinned.Free();
}
public void CreateReady()
{
TestRuntime.AssertSystemVersion(PlatformName.iOS, 8, 0, throwIfOtherPlatform: false);
TestRuntime.AssertSystemVersion(PlatformName.MacOSX, 10, 10, throwIfOtherPlatform: false);
CMBlockBufferError bbe;
using (var bb = CMBlockBuffer.CreateEmpty(0, CMBlockBufferFlags.AlwaysCopyData, out bbe)) {
CMSampleBufferError sbe;
using (var sb = CMSampleBuffer.CreateReady(bb, null, 0, null, null, out sbe)) {
Assert.That(sb.Handle, Is.Not.EqualTo(IntPtr.Zero), "CMSampleBuffer");
Assert.That(sbe, Is.EqualTo(CMSampleBufferError.None), "CMSampleBufferError");
}
}
}
private CGImage CreateImage(CMSampleBuffer sampleBuffer)
{
CGImage image = null;
CMFormatDescription formatDescription = sampleBuffer.GetFormatDescription();
var subType = formatDescription.MediaSubType;
CMBlockBuffer blockBuffer = sampleBuffer.GetDataBuffer();
if (blockBuffer != null)
{
if (subType != (int)CMVideoCodecType.JPEG)
{
throw new Exception("Block buffer must be JPEG encoded.");
}
var jpegData = new NSMutableData();
jpegData.Length = blockBuffer.DataLength;
blockBuffer.CopyDataBytes(0, blockBuffer.DataLength, jpegData.Bytes);
using (var imageSource = CGImageSource.FromData(jpegData)) {
var decodeOptions = new CGImageOptions {
ShouldAllowFloat = false,
ShouldCache = false
};
image = imageSource.CreateImage(0, decodeOptions);
}
}
else
{
if (subType != (int)CVPixelFormatType.CV32BGRA)
{
throw new Exception("Image buffer must be BGRA encoded.");
}
CVImageBuffer imageBuffer = sampleBuffer.GetImageBuffer();
using (var colorSpace = CGColorSpace.CreateDeviceRGB())
using (var bitmapContext = new CGBitmapContext(imageBuffer.Handle,
(int)imageBuffer.DisplaySize.Width, (int)imageBuffer.DisplaySize.Height, 8, 0, colorSpace, CGImageAlphaInfo.NoneSkipFirst)) {
image = bitmapContext.ToImage();
}
}
return(image);
}
public void CopyDataBytesUsingManagedArrayTest()
{
byte [] data = new byte [] { 0x0, 0x1, 0x2, 0x3, 0x4 };
byte [] destData;
CMBlockBufferError err;
using (var buf = CMBlockBuffer.FromMemoryBlock(data, 0, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 1: {err}");
err = buf.CopyDataBytes(0, (uint)data.Length, out destData);
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 2: {err}");
for (int i = 0; i < data.Length; i++)
{
Assert.AreEqual(data [0], destData [0], $"CMBlockBuffer CopyDataBytesUsingManagedArrayTest iteration: {i}");
}
}
}
public void CreateReady()
{
if (!TestRuntime.CheckSystemAndSDKVersion(8, 0))
{
Assert.Inconclusive("Requires iOS8");
}
CMBlockBufferError bbe;
using (var bb = CMBlockBuffer.CreateEmpty(0, CMBlockBufferFlags.AlwaysCopyData, out bbe)) {
CMSampleBufferError sbe;
using (var sb = CMSampleBuffer.CreateReady(bb, null, 0, null, null, out sbe)) {
Assert.That(sb.Handle, Is.Not.EqualTo(IntPtr.Zero), "CMSampleBuffer");
Assert.That(sbe, Is.EqualTo(CMSampleBufferError.None), "CMSampleBufferError");
}
}
}
public void ReplaceDataBytesManagedTest()
{
byte [] data = new byte [] { 0x0, 0x1, 0x2, 0x3, 0x4 };
byte [] replaceData = new byte [] { 0x5, 0x5, 0x5, 0x5, 0x5 };
CMBlockBufferError err;
using (var buf = CMBlockBuffer.FromMemoryBlock(data, 0, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 1: {err}");
err = buf.ReplaceDataBytes(replaceData, 0);
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 2: {err}");
for (int i = 0; i < data.Length; i++)
{
Assert.AreEqual(0x5, data [0], $"CMBlockBuffer ReplaceDataBytesManagedTest iteration: {i}");
}
}
}
public void CreateReadyWithPacketDescriptions()
{
TestRuntime.AssertSystemVersion(PlatformName.iOS, 8, 0, throwIfOtherPlatform: false);
TestRuntime.AssertSystemVersion(PlatformName.MacOSX, 10, 10, throwIfOtherPlatform: false);
CMBlockBufferError bbe;
using (var bb = CMBlockBuffer.CreateEmpty(0, CMBlockBufferFlags.AlwaysCopyData, out bbe)) {
CMFormatDescriptionError fde;
using (var fd = CMFormatDescription.Create(CMMediaType.ClosedCaption, (uint)CMClosedCaptionFormatType.CEA608, out fde)) {
CMSampleBufferError sbe;
using (var sb = CMSampleBuffer.CreateReadyWithPacketDescriptions(bb, fd, 1, CMTime.Indefinite, null, out sbe)) {
Assert.Null(sb, "CMSampleBuffer");
// the `null` does not match format description (but I lack a better test, at least it's callable)
Assert.That(sbe, Is.EqualTo(CMSampleBufferError.RequiredParameterMissing), "CMSampleBufferError");
}
}
}
}
protected ICMAttachmentBearer GetInstance(Type t)
{
if (!CMAttachmentInterfaceType.IsAssignableFrom(t))
{
throw new ArgumentException("t");
}
switch (t.Name)
{
case "CMBlockBuffer":
CMBlockBufferError bbe;
var result = CMBlockBuffer.CreateEmpty(0, CMBlockBufferFlags.AssureMemoryNow, out bbe);
if (bbe == CMBlockBufferError.None)
{
return(result);
}
else
{
throw new InvalidOperationException(string.Format("Could not create the new instance {0}.", bbe.ToString()));
}
case "CMSampleBuffer":
var pixelBuffer = new CVPixelBuffer(20, 10, CVPixelFormatType.CV24RGB);
CMFormatDescriptionError fde;
var desc = CMVideoFormatDescription.CreateForImageBuffer(pixelBuffer, out fde);
var sampleTiming = new CMSampleTimingInfo();
CMSampleBufferError sbe;
var sb = CMSampleBuffer.CreateForImageBuffer(pixelBuffer, true, desc, sampleTiming, out sbe);
if (sbe == CMSampleBufferError.None)
{
return(sb);
}
else
{
throw new InvalidOperationException(string.Format("Could not create the new instance {0}.", sbe.ToString()));
}
default:
throw new InvalidOperationException(string.Format("Could not create the new instance for type {0}.", t.Name));
}
}
public void AppendMemoryBlockWithManagedMemory()
{
byte [] data = new byte [32768];
byte [] data2 = new byte [32768];
GCHandle pinned = GCHandle.Alloc(data, GCHandleType.Pinned);
GCHandle pinned2 = GCHandle.Alloc(data2, GCHandleType.Pinned);
IntPtr pointer = pinned.AddrOfPinnedObject();
IntPtr pointer2 = pinned2.AddrOfPinnedObject();
CMBlockBufferError err;
using (var buf = CMBlockBuffer.FromMemoryBlock(pointer, (uint)data.Length, null, 0, (uint)data.Length, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 1: {err}");
err = buf.AppendMemoryBlock(pointer2, (uint)data2.Length, null, 0, (uint)data2.Length, CMBlockBufferFlags.AssureMemoryNow);
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 2: {err}");
}
pinned2.Free();
pinned.Free();
}
public void CreateReadyWithPacketDescriptions()
{
if (!TestRuntime.CheckSystemAndSDKVersion(8, 0))
{
Assert.Inconclusive("Requires iOS8");
}
CMBlockBufferError bbe;
using (var bb = CMBlockBuffer.CreateEmpty(0, CMBlockBufferFlags.AlwaysCopyData, out bbe)) {
CMFormatDescriptionError fde;
using (var fd = CMFormatDescription.Create(CMMediaType.ClosedCaption, (uint)CMClosedCaptionFormatType.CEA608, out fde)) {
CMSampleBufferError sbe;
using (var sb = CMSampleBuffer.CreateReadyWithPacketDescriptions(bb, fd, 1, CMTime.Indefinite, null, out sbe)) {
Assert.Null(sb, "CMSampleBuffer");
// the `null` does not match format description (but I lack a better test, at least it's callable)
Assert.That(sbe, Is.EqualTo(CMSampleBufferError.RequiredParameterMissing), "CMSampleBufferError");
}
}
}
}
public void AppendMemoryBlockTest()
{
CMBlockBufferError err1;
CMBlockBufferError err2;
using (var bb = CMBlockBuffer.FromMemoryBlock(IntPtr.Zero, 16, null, 0, 5, CMBlockBufferFlags.AssureMemoryNow, out err1)) {
Assert.That(err1, Is.EqualTo(CMBlockBufferError.None), "FromMemoryBlock error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)5), "FromMemoryBlock DataLength");
var ptr = Marshal.AllocHGlobal(16);
err2 = bb.AppendMemoryBlock(ptr, 16, null, 0, 5, CMBlockBufferFlags.AssureMemoryNow);
Assert.That(err2, Is.EqualTo(CMBlockBufferError.None), "AppendMemoryBlock error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)10), "AppendMemoryBlock DataLength");
}
using (var bb = CMBlockBuffer.FromMemoryBlock(IntPtr.Zero, 16, new CMCustomBlockAllocator(), 0, 5, CMBlockBufferFlags.AssureMemoryNow, out err1)) {
Assert.That(err1, Is.EqualTo(CMBlockBufferError.None), "FromMemoryBlock error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)5), "FromMemoryBlock DataLength");
var ptr = Marshal.AllocHGlobal(16);
err2 = bb.AppendMemoryBlock(ptr, 16, new CMCustomBlockAllocator(), 0, 5, CMBlockBufferFlags.AssureMemoryNow);
Assert.That(err2, Is.EqualTo(CMBlockBufferError.None), "AppendMemoryBlock error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)10), "AppendMemoryBlock DataLength");
}
allocateCalled = false;
freeCalled = false;
using (var allocator = new CustomAllocator(this))
using (var bb = CMBlockBuffer.FromMemoryBlock(IntPtr.Zero, 16, new CMCustomBlockAllocator(), 0, 5, CMBlockBufferFlags.AssureMemoryNow, out err1)) {
Assert.That(err1, Is.EqualTo(CMBlockBufferError.None), "FromMemoryBlock error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)5), "FromMemoryBlock DataLength");
var ptr = Marshal.AllocHGlobal(16);
err2 = bb.AppendMemoryBlock(ptr, 16, allocator, 0, 5, CMBlockBufferFlags.AssureMemoryNow);
Assert.That(err2, Is.EqualTo(CMBlockBufferError.None), "AppendMemoryBlock error");
Assert.That(bb.DataLength, Is.EqualTo((nuint)10), "FromMemoryBlock DataLength");
}
Assert.IsTrue(freeCalled, "FromMemoryBlock FreeCalled");
}
public void ReplaceDataBytesTest()
{
byte [] data = new byte [] { 0x0, 0x1, 0x2, 0x3, 0x4 };
byte [] replaceData = new byte [] { 0x5, 0x5, 0x5, 0x5, 0x5 };
GCHandle pinned = GCHandle.Alloc(data, GCHandleType.Pinned);
GCHandle replacePinned = GCHandle.Alloc(replaceData, GCHandleType.Pinned);
IntPtr pointer = pinned.AddrOfPinnedObject();
IntPtr replacePointer = replacePinned.AddrOfPinnedObject();
CMBlockBufferError err;
using (var buf = CMBlockBuffer.FromMemoryBlock(pointer, (uint)data.Length, null, 0, (uint)data.Length, CMBlockBufferFlags.AssureMemoryNow, out err)) {
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 1: {err}");
err = buf.ReplaceDataBytes(replacePointer, 0, (uint)replaceData.Length);
Assert.That(err, Is.EqualTo(CMBlockBufferError.None), $"CMBlockBufferError 2: {err}");
for (int i = 0; i < data.Length; i++)
{
Assert.AreEqual(0x5, data [0], $"CMBlockBuffer ReplaceDataBytesTest iteration: {i}");
}
}
pinned.Free();
replacePinned.Free();
}
