unsafe void OnpDisplay(void *opaque, void *picture)
{
lock (m_lock)
{
try
{
PixelData *px = (PixelData *)opaque;
MemoryHeap.CopyMemory(m_pBuffer, px->pPixelData, px->size);
m_frameRate++;
if (m_callback != null)
{
using (Bitmap frame = GetBitmap())
{
m_callback(frame);
}
}
}
catch (Exception ex)
{
if (m_excHandler != null)
{
m_excHandler(ex);
}
else
{
throw ex;
}
}
}
}
void AppGpuDumpMemoryProps(AppGpu gpu, StreamWriter output)
{
PhysicalDeviceMemoryProperties props = gpu.MemoryProps;
output.WriteLine("VkPhysicalDeviceMemoryProperties:");
output.WriteLine("=================================");
output.WriteLine("\tmemoryTypeCount = {0}", props.MemoryTypeCount);
for (int i = 0; i < props.MemoryTypeCount; i++)
{
MemoryType memoryType = props.MemoryTypes[i];
output.WriteLine("\tmemoryTypes[{0}] : ", i);
output.WriteLine("\t\tpropertyFlags = {0}", memoryType.PropertyFlags);
output.WriteLine("\t\theapIndex = {0}", memoryType.HeapIndex);
}
output.WriteLine("\tmemoryHeapCount = {0}", props.MemoryHeapCount);
for (int i = 0; i < props.MemoryHeapCount; i++)
{
MemoryHeap memoryHeap = props.MemoryHeaps[i];
output.WriteLine("\tmemoryHeaps[{0}] : ", i);
output.WriteLine("\t\tsize = {0}", memoryHeap.Size);
}
}
private FrameData DeepClone(IntPtr data, int size)
{
FrameData clone = new FrameData();
clone.Data = new IntPtr(MemoryHeap.Alloc(size));
MemoryHeap.CopyMemory(clone.Data.ToPointer(), data.ToPointer(), size);
clone.DataSize = size;
return(clone);
}
private FrameData DeepClone(byte[] buffer)
{
FrameData clone = new FrameData();
clone.Data = new IntPtr(MemoryHeap.Alloc(buffer.Length));
Marshal.Copy(buffer, 0, clone.Data, buffer.Length);
clone.DataSize = buffer.Length;
return(clone);
}
public void Dispose()
{
for (int i = 0; i < Sizes.Length; i++)
{
MemoryHeap.Free(Data[i]);
}
MemoryHeap.Free(Data);
}
public PlanarPixelData(int[] lineSizes)
{
Sizes = lineSizes;
Data = (byte **)MemoryHeap.Alloc(sizeof(byte *) * Sizes.Length);
for (int i = 0; i < Sizes.Length; i++)
{
Data[i] = (byte *)MemoryHeap.Alloc(sizeof(byte) * Sizes[i]);
}
}
public void SetFormat(BitmapFormat format)
{
m_format = format;
LibVlcMethods.libvlc_video_set_format(m_hMediaPlayer, m_format.Chroma.ToUtf8(), m_format.Width, m_format.Height, m_format.Pitch);
m_pBuffer = MemoryHeap.Alloc(m_format.ImageSize);
m_pixelData = new PixelData(m_format.ImageSize);
m_pixelDataPtr = GCHandle.Alloc(m_pixelData, GCHandleType.Pinned);
LibVlcMethods.libvlc_video_set_callbacks(m_hMediaPlayer, pLockCallback, pUnlockCallback, pDisplayCallback, m_pixelDataPtr.AddrOfPinnedObject());
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
m_timer.Dispose();
}
IntPtr zero = IntPtr.Zero;
LibVlcMethods.libvlc_video_set_callbacks(m_hMediaPlayer, zero, zero, zero, zero);
m_pixelDataPtr.Free();
m_pixelData.Dispose();
MemoryHeap.Free(m_pBuffer);
}
unsafe void OnpDisplay(void *opaque, void *picture)
{
lock (m_lock)
{
PixelData *px = (PixelData *)opaque;
MemoryHeap.CopyMemory(m_pBuffer, px->pPixelData, px->size);
m_frameRate++;
if (m_callback != null)
{
using (Bitmap frame = GetBitmap())
{
m_callback(frame);
}
}
}
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
m_callbacks = null;
if (m_queue != null && m_queue.Count > 0)
{
foreach (var item in m_queue)
{
MemoryHeap.Free(item.Data.ToPointer());
}
}
m_queue = null;
}
}
public void SetFormat(BitmapFormat format)
{
if (!format.IsRGB)
{
string msg = "IMemoryRenderer supports RGB pixel formats only. For YUV and/or planar pixel formats use IMemoryRendererEx";
throw new InvalidOperationException(msg);
}
m_format = format;
LibVlcMethods.libvlc_video_set_format(m_hMediaPlayer, m_format.Chroma.ToUtf8(), m_format.Width, m_format.Height, m_format.Pitch);
m_pBuffer = MemoryHeap.Alloc(m_format.ImageSize);
m_pixelData = new PixelData(m_format.ImageSize);
m_pixelDataPtr = GCHandle.Alloc(m_pixelData, GCHandleType.Pinned);
LibVlcMethods.libvlc_video_set_callbacks(m_hMediaPlayer, pLockCallback, pUnlockCallback, pDisplayCallback, m_pixelDataPtr.AddrOfPinnedObject());
}
private void OnImemRelease(void *data, char *cookie, uint dataSize, void *pData)
{
try
{
MemoryHeap.Free(pData);
}
catch (Exception ex)
{
if (m_excHandler != null)
{
m_excHandler(ex);
}
else
{
throw new Exception("imem-release callback failed", ex);
}
}
}
public void AddFrame(Bitmap frame)
{
Monitor.Enter(m_lock);
try
{
Rectangle rect = new Rectangle(0, 0, frame.Width, frame.Height);
BitmapData bmpData = frame.LockBits(rect, ImageLockMode.ReadOnly, frame.PixelFormat);
void *pData = bmpData.Scan0.ToPointer();
MemoryHeap.CopyMemory(m_data.pPixelData, pData, m_data.size);
frame.UnlockBits(bmpData);
}
finally
{
Monitor.Exit(m_lock);
}
}
public void Dispose()
{
MemoryHeap.Free(this.pPixelData);
}
public PixelData(int size)
{
this.size = size;
this.pPixelData = (byte *)MemoryHeap.Alloc(size);
}
