/// <summary>
/// Gets a value indicating whether the captured frame contains the specified metadata.
/// </summary>
/// <param name="metadata">The metadata to be queried.</param>
/// <returns>
/// <b>true</b> if the captured frame contains the specified metadata; otherwise, <b>false</b>.
/// </returns>
public bool SupportsMetadata(FrameMetadata metadata)
{
var result = NativeMethods.rs2_supports_frame_metadata(handle, metadata, out IntPtr error);
NativeHelper.ThrowExceptionForRsError(error);
return(result != 0);
}
private static BitmapSource ClearArea(BitmapSource frame, FrameMetadata metadata)
{
DrawingVisual visual = new DrawingVisual();
using (var context = visual.RenderOpen())
{
var fullRect = new Rect(0, 0, frame.PixelWidth, frame.PixelHeight);
var clearRect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height);
var clip = Geometry.Combine(
new RectangleGeometry(fullRect),
new RectangleGeometry(clearRect),
GeometryCombineMode.Exclude,
null);
context.PushClip(clip);
context.DrawImage(frame, fullRect);
}
var bitmap = new RenderTargetBitmap(
frame.PixelWidth, frame.PixelHeight,
frame.DpiX, frame.DpiY,
PixelFormats.Pbgra32);
bitmap.Render(visual);
var result = new CachedBitmap(bitmap, BitmapCreateOptions.None, BitmapCacheOption.Default);
if (result.CanFreeze && !result.IsFrozen)
{
result.Freeze();
}
return(result);
}
private static bool IsFullFrame(FrameMetadata metadata, Int32Size fullSize)
{
return(metadata.Left == 0 &&
metadata.Top == 0 &&
metadata.Width == fullSize.Width &&
metadata.Height == fullSize.Height);
}
public static bool IsFullFrame(FrameMetadata metadata, System.Drawing.Size fullSize)
{
return(metadata.Left == 0 &&
metadata.Top == 0 &&
metadata.Width == fullSize.Width &&
metadata.Height == fullSize.Height);
}
private static FrameMetadata GetFrameMetadata(BitmapFrame frame)
{
var metadata = (BitmapMetadata)frame.Metadata;
var delay = TimeSpan.FromMilliseconds(100);
var metadataDelay = metadata.GetQueryOrDefault("/grctlext/Delay", 10);
if (metadataDelay != 0)
{
delay = TimeSpan.FromMilliseconds(metadataDelay * 10);
}
var disposalMethod = (FrameDisposalMethod)metadata.GetQueryOrDefault("/grctlext/Disposal", 0);
var frameMetadata = new FrameMetadata
{
Left = metadata.GetQueryOrDefault("/imgdesc/Left", 0),
Top = metadata.GetQueryOrDefault("/imgdesc/Top", 0),
Width = metadata.GetQueryOrDefault("/imgdesc/Width", frame.PixelWidth),
Height = metadata.GetQueryOrDefault("/imgdesc/Height", frame.PixelHeight),
Delay = delay,
DisposalMethod = disposalMethod
};
return(frameMetadata);
}
private static FrameMetadata GetFrameMetadata(GifFrame gifMetadata)
{
var d = gifMetadata.Descriptor;
var frameMetadata = new FrameMetadata
{
Left = d.Left,
Top = d.Top,
Width = d.Width,
Height = d.Height,
Delay = TimeSpan.FromMilliseconds(100),
DisposalMethod = FrameDisposalMethod.None
};
var gce = gifMetadata.Extensions.OfType <GifGraphicControlExtension>().FirstOrDefault();
if (gce != null)
{
if (gce.Delay != 0)
{
frameMetadata.Delay = TimeSpan.FromMilliseconds(gce.Delay);
}
frameMetadata.DisposalMethod = (FrameDisposalMethod)gce.DisposalMethod;
}
return(frameMetadata);
}
//----------------------------------------------------------------------
#region private helpers
private static bool _isNotFullSize(FrameMetadata poMetadata, Size poFullSize)
{
return(poMetadata.miPositionX != 0 ||
poMetadata.miPositionY != 0 ||
poMetadata.moMetadata.miWidth != poFullSize.Width ||
poMetadata.moMetadata.miHeight != poFullSize.Height);
}
/// <summary>
/// Implements a function to be used in the Count Frame conversation processor.
/// </summary>
/// <param name="flowKey"></param>
/// <param name="frames"></param>
/// <returns></returns>
private (string key, int frames, int octets, int ip, int tcp, int udp) CountFrames(FlowKey flowKey, System.Collections.Generic.IEnumerable <Memory <byte> > frames)
{
(int octets, int ip, int tcp, int udp) GetFrameSize(Memory <byte> memory)
{
var meta = default(FrameMetadata);
var bytes = FrameMetadata.FromBytes(memory.Span, ref meta);
var packet = PacketDotNet.Packet.ParsePacket((PacketDotNet.LinkLayers)meta.LinkLayer, bytes.ToArray());
return(meta.OriginalLength,
packet.Extract <PacketDotNet.InternetPacket>() != null ? 1 : 0,
packet.Extract <PacketDotNet.TcpPacket>() != null ? 1 : 0,
packet.Extract <PacketDotNet.UdpPacket>() != null ? 1 : 0
);
}
var framesList = frames.ToList();
// intentionally it is computed in this inefficient way to test
// the implementated iteration over the input collection
return(flowKey.ToString(), framesList.Count,
framesList.Sum(x => GetFrameSize(x).octets),
framesList.Sum(x => GetFrameSize(x).ip),
framesList.Sum(x => GetFrameSize(x).tcp),
framesList.Sum(x => GetFrameSize(x).udp)
);
}
private static BitmapSource _restoreBackgroundFrame(
Size poFullSize,
BitmapSource poFrame,
FrameMetadata poMetadata)
{
if (_isNotFullSize(poMetadata, poFullSize))
{
var toVisual = new DrawingVisual();
using (var toContext = toVisual.RenderOpen())
{
var toFullRect = new Rect(0, 0, poFrame.PixelWidth, poFrame.PixelHeight);
var toRect = new Rect(poMetadata.miPositionX, poMetadata.miPositionY,
poMetadata.moMetadata.miWidth, poMetadata.moMetadata.miHeight
);
var toClip = Geometry.Combine(new RectangleGeometry(toFullRect),
new RectangleGeometry(toRect), GeometryCombineMode.Exclude, null
);
toContext.PushClip(toClip);
toContext.DrawImage(poFrame, toFullRect);
}
var toRenderer = new RenderTargetBitmap(
poFrame.PixelWidth, poFrame.PixelHeight,
poFrame.DpiX, poFrame.DpiY,
PixelFormats.Pbgra32
);
toRenderer.Render(toVisual);
var toFrame = new WriteableBitmap(toRenderer);
toFrame.Freeze();
return(toFrame);
}
return(null);
}
public static BitmapSource ClearArea(BitmapSource frame, FrameMetadata metadata)
{
var visual = new DrawingVisual();
using (var context = visual.RenderOpen())
{
var fullRect = new Rect(0, 0, frame.PixelWidth, frame.PixelHeight);
var clearRect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height);
var clip = Geometry.Combine(new RectangleGeometry(fullRect), new RectangleGeometry(clearRect), GeometryCombineMode.Exclude, null);
context.PushClip(clip);
context.DrawImage(frame, fullRect);
}
var bitmap = new RenderTargetBitmap(frame.PixelWidth, frame.PixelHeight, frame.DpiX, frame.DpiY, PixelFormats.Pbgra32);
bitmap.Render(visual);
if (bitmap.CanFreeze && !bitmap.IsFrozen)
{
bitmap.Freeze();
}
return(bitmap);
}
private static FrameMetadata _getFrameMetadata(BitmapFrame poFrame)
{
if (poFrame.Metadata is BitmapMetadata toMetadata)
{
var toGrctlext = toMetadata.GetQuery("/grctlext") as BitmapMetadata;
var toImgdesc = toMetadata.GetQuery("/imgdesc") as BitmapMetadata;
if (toGrctlext != null && toImgdesc != null)
{
var toFrameMetadata = new FrameMetadata
{
miPositionX = toImgdesc.GetQueryValue("/Left", 0),
miPositionY = toImgdesc.GetQueryValue("/Top", 0),
moMetadata = new Metadata
{
miWidth = toImgdesc.GetQueryValue("/Width", 0),
miHeight = toImgdesc.GetQueryValue("/Height", 0)
},
moDelay = TimeSpan.FromMilliseconds(toGrctlext.GetQueryValue("/Delay", 10) * 10),
meDisposalMethod = (eDisposalMethod)toGrctlext.GetQueryValue("/Disposal", 0)
};
// Handle malformed gif delays by setting a minimum delay
toFrameMetadata.moDelay = toFrameMetadata.moDelay.Ticks == 0
? TimeSpan.FromMilliseconds(50) : toFrameMetadata.moDelay;
return(toFrameMetadata);
}
}
return(null);
}
private FrameMetadata GetMetadata(Capture capture, OutputDuplicateFrameInformation frameInformation)
{
int totalBufferSize = frameInformation.TotalMetadataBufferSize;
if (totalBufferSize == 0)
{
return(null);
}
var toReturn = new FrameMetadata();
int actualLength;
var moveBuffer = new OutputDuplicateMoveRectangle[totalBufferSize];
capture.OutputDuplication.GetFrameMoveRects(moveBuffer.Length, moveBuffer, out actualLength);
Array.Resize(ref moveBuffer, actualLength / Marshal.SizeOf(typeof(OutputDuplicateMoveRectangle)));
toReturn.MoveRectangles = moveBuffer;
var dirtyBuffer = new RawRectangle[totalBufferSize];
capture.OutputDuplication.GetFrameDirtyRects(dirtyBuffer.Length, dirtyBuffer, out actualLength);
Array.Resize(ref dirtyBuffer, actualLength / Marshal.SizeOf(typeof(RawRectangle)));
toReturn.DirtyRectangles = dirtyBuffer;
return(toReturn);
}
/// <summary>
/// Gets the specified metadata from the captured frame.
/// </summary>
/// <param name="metadata">The metadata to retrieve from the captured frame.</param>
/// <returns>The metadata value.</returns>
public long GetMetadata(FrameMetadata metadata)
{
var value = NativeMethods.rs2_get_frame_metadata(handle, metadata, out IntPtr error);
NativeHelper.ThrowExceptionForRsError(error);
return(value);
}
void Generate()
{
void onNextFrame(ref ulong key, ref SpanByte value)
{
FrameKey frameKey = new FrameKey(key);
FrameMetadata frameMetadata = default;
var frameBytes = FrameMetadata.FromBytes(value.AsSpan(), ref frameMetadata);
_observer.OnNext(_processor(ref frameKey, ref frameMetadata, frameBytes));
}
_framesStore.ProcessEntries(onNextFrame, _cancel.Token);
_observer.OnCompleted();
}
public TTarget Invoke(FlowKey flowKey, IEnumerable <Memory <byte> > frames)
{
var firstTicks = _windowStart.Ticks;
var lastTicks = firstTicks + _duration.Ticks;
bool IsInWindow(Memory <byte> frame)
{
FrameMetadata frameMetadata = default;
FrameMetadata.FromBytes(frame.Span, ref frameMetadata);
return(frameMetadata.Ticks >= firstTicks && frameMetadata.Ticks < lastTicks);
}
return(_processor.Invoke(flowKey, frames.Where(IsInWindow)));
}
private static ObjectAnimationUsingKeyFrames GetAnimation(Image imageControl, BitmapSource source)
{
ObjectAnimationUsingKeyFrames animation = AnimationCache.GetAnimation(source, GetRepeatBehavior(imageControl));
if (animation == null)
{
GifFile file;
GifBitmapDecoder decoder = GetDecoder(source, out file) as GifBitmapDecoder;
if ((decoder == null) || (decoder.Frames.Count <= 1))
{
return(null);
}
Int32Size fullSize = GetFullSize(decoder, file);
int frameIndex = 0;
animation = new ObjectAnimationUsingKeyFrames();
TimeSpan zero = TimeSpan.Zero;
BitmapSource baseFrame = null;
foreach (BitmapFrame frame in decoder.Frames)
{
FrameMetadata metadata = GetFrameMetadata(decoder, file, frameIndex);
BitmapSource source3 = MakeFrame(fullSize, frame, metadata, baseFrame);
DiscreteObjectKeyFrame keyFrame = new DiscreteObjectKeyFrame(source3, zero);
animation.KeyFrames.Add(keyFrame);
zero += metadata.Delay;
FrameDisposalMethod disposalMethod = metadata.DisposalMethod;
switch (disposalMethod)
{
case FrameDisposalMethod.None:
case FrameDisposalMethod.DoNotDispose:
baseFrame = source3;
break;
case FrameDisposalMethod.RestoreBackground:
baseFrame = !IsFullFrame(metadata, fullSize) ? ClearArea(source3, metadata) : null;
break;
default:
break;
}
frameIndex++;
}
animation.Duration = zero;
animation.RepeatBehavior = GetActualRepeatBehavior(imageControl, decoder, file);
AnimationCache.AddAnimation(source, GetRepeatBehavior(imageControl), animation);
AnimationCache.IncrementReferenceCount(source, GetRepeatBehavior(imageControl));
}
return(animation);
}
public ConversationRecord <TData> Invoke(FlowKey flowKey, IEnumerable <Memory <byte> > frames)
{
var fwdPackets = new List <MetaPacket>();
var revPackets = new List <MetaPacket>();
var forwardKeyHash = flowKey.GetHashCode64();
var meta = new FrameMetadata();
FlowMetrics fwdMetrics = new FlowMetrics();
FlowMetrics revMetrics = new FlowMetrics();
DateTime? firstTimestamp = null;
foreach (var frame in frames)
{
var buffer = FrameMetadata.FromBytes(frame.Span, ref meta);
if (firstTimestamp == null)
{
firstTimestamp = new DateTime(meta.Ticks);
}
var packet = Packet.ParsePacket((LinkLayers)meta.LinkLayer, buffer.ToArray());
if (meta.FlowKeyHash == forwardKeyHash)
{
AddPacket(fwdPackets, ref fwdMetrics, ref meta, packet);
}
else
{
AddPacket(revPackets, ref revMetrics, ref meta, packet);
}
}
if (firstTimestamp != null)
{
// adjust metrics:
AdjustMetrics(ref fwdMetrics, firstTimestamp.Value);
AdjustMetrics(ref revMetrics, firstTimestamp.Value);
}
return(new ConversationRecord <TData>()
{
Key = flowKey,
ForwardMetrics = fwdMetrics,
ReverseMetrics = revMetrics,
Data = Invoke(ref flowKey, ref fwdMetrics, ref revMetrics, fwdPackets, revPackets)
});
}
private static BitmapSource MakeFrame(
Int32Size fullSize,
BitmapSource rawFrame, FrameMetadata metadata,
BitmapSource baseFrame)
{
if (baseFrame == null && IsFullFrame(metadata, fullSize))
{
// No previous image to combine with, and same size as the full image
// Just return the frame as is
return(rawFrame);
}
DrawingVisual visual = new DrawingVisual();
using (var context = visual.RenderOpen())
{
if (baseFrame != null)
{
var fullRect = new Rect(0, 0, fullSize.Width, fullSize.Height);
context.DrawImage(baseFrame, fullRect);
}
var rect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height);
context.DrawImage(rawFrame, rect);
}
var bitmap = new RenderTargetBitmap(
fullSize.Width, fullSize.Height,
96, 96,
PixelFormats.Pbgra32);
bitmap.Render(visual);
var result = new WriteableBitmap(bitmap);
bitmap = null;
if (result.CanFreeze && !result.IsFrozen)
{
result.Freeze();
}
return(result);
}
private string GetTagValues()
{
FrameMetadata metadata = currentAnimator.Metadata;
StringBuilder sb = new StringBuilder();
foreach (string tag in metadata.AnimationTags)
{
sb.AppendLine(tag);
}
foreach (var objectEntry in metadata.ObjectTags)
{
foreach (string tag in objectEntry.Value)
{
sb.Append(objectEntry.Key).Append(".").AppendLine(tag);
}
}
return(sb.ToString());
}
private static BitmapSource ClearArea(BitmapSource frame, FrameMetadata metadata)
{
DrawingVisual visual = new DrawingVisual();
using (DrawingContext context = visual.RenderOpen())
{
Rect rect = new Rect(0.0, 0.0, (double)frame.PixelWidth, (double)frame.PixelHeight);
Rect rect2 = new Rect((double)metadata.Left, (double)metadata.Top, (double)metadata.Width, (double)metadata.Height);
context.PushClip(Geometry.Combine(new RectangleGeometry(rect), new RectangleGeometry(rect2), GeometryCombineMode.Exclude, null));
context.DrawImage(frame, rect);
}
RenderTargetBitmap bitmap = new RenderTargetBitmap(frame.PixelWidth, frame.PixelHeight, frame.DpiX, frame.DpiY, PixelFormats.Pbgra32);
bitmap.Render(visual);
if (bitmap.CanFreeze && !bitmap.IsFrozen)
{
bitmap.Freeze();
}
return(bitmap);
}
private static BitmapSource MakeFrame(
BitmapSource fullImage,
BitmapSource rawFrame, FrameMetadata metadata,
BitmapSource baseFrame)
{
if (baseFrame == null &&
rawFrame.PixelWidth == fullImage.PixelWidth &&
rawFrame.PixelHeight == fullImage.PixelHeight)
{
// No previous image to combine with, and same size as the full image
// Just return the frame as is
return(rawFrame);
}
DrawingVisual visual = new DrawingVisual();
using (var context = visual.RenderOpen())
{
if (baseFrame != null)
{
var fullRect = new Rect(0, 0, fullImage.PixelWidth, fullImage.PixelHeight);
context.DrawImage(baseFrame, fullRect);
}
var rect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height);
context.DrawImage(rawFrame, rect);
}
var bitmap = new RenderTargetBitmap(
fullImage.PixelWidth, fullImage.PixelHeight,
fullImage.DpiX, fullImage.DpiY,
PixelFormats.Pbgra32);
bitmap.Render(visual);
if (bitmap.CanFreeze && !bitmap.IsFrozen)
{
bitmap.Freeze();
}
return(bitmap);
}
private string GetVarValues()
{
FrameMetadata metadata = currentAnimator.Metadata;
StringBuilder sb = new StringBuilder();
foreach (var entry in metadata.AnimationVars)
{
object value = GetValue(entry.Value);
sb.Append(entry.Key).Append(" = ").AppendLine(value.ToString());
}
foreach (var objectEntry in metadata.ObjectVars)
{
foreach (var varEntry in objectEntry.Value)
{
object value = GetValue(varEntry.Value);
sb.Append(objectEntry.Key).Append(".").Append(varEntry.Key).Append(" = ").AppendLine((value ?? string.Empty).ToString());
}
}
return(sb.ToString());
}
private static FrameMetadata GetFrameMetadata(GifFrame gifMetadata)
{
GifImageDescriptor descriptor = gifMetadata.Descriptor;
FrameMetadata metadata = new FrameMetadata {
Left = descriptor.Left,
Top = descriptor.Top,
Width = descriptor.Width,
Height = descriptor.Height,
Delay = TimeSpan.FromMilliseconds(100.0),
DisposalMethod = FrameDisposalMethod.None
};
GifGraphicControlExtension extension = gifMetadata.Extensions.OfType <GifGraphicControlExtension>().FirstOrDefault <GifGraphicControlExtension>();
if (extension != null)
{
if (extension.Delay != 0)
{
metadata.Delay = TimeSpan.FromMilliseconds((double)extension.Delay);
}
metadata.DisposalMethod = (FrameDisposalMethod)extension.DisposalMethod;
}
return(metadata);
}
//----------------------------------------------------------------------
#region private rendering
private static BitmapSource _renderFrame(
Size poFullSize,
BitmapSource poFrame,
FrameMetadata poMetadata,
BitmapSource poBaseFrame)
{
if (_isNotFullSize(poMetadata, poFullSize))
{
var toVisual = new DrawingVisual();
using (var toContext = toVisual.RenderOpen())
{
if (poBaseFrame != null)
{
var toFullRect = new Rect(0, 0, poFullSize.Width, poFullSize.Height);
toContext.DrawImage(poBaseFrame, toFullRect);
}
var toRect = new Rect(
poMetadata.miPositionX, poMetadata.miPositionY,
poMetadata.moMetadata.miWidth, poMetadata.moMetadata.miHeight
);
toContext.DrawImage(poFrame, toRect);
}
var toRenderer = new RenderTargetBitmap(
Convert.ToInt32(poFullSize.Width),
Convert.ToInt32(poFullSize.Height),
96, 96, PixelFormats.Pbgra32
);
toRenderer.Render(toVisual);
var toFrame = new WriteableBitmap(toRenderer);
toFrame.Freeze();
return(toFrame);
}
return(poFrame);
}
private static CompressedBitmapSource MakeFrame(
Int32Size fullSize,
CompressedBitmapSource rawFrame, FrameMetadata metadata,
CompressedBitmapSource baseFrame)
{
if (baseFrame == null && IsFullFrame(metadata, fullSize))
{
// No previous image to combine with, and same size as the full image
// Just return the frame as is
return(rawFrame);
}
WriteableBitmap bitmap;
if (baseFrame == null)
{
bitmap = new WriteableBitmap(fullSize.Width, fullSize.Height, 96, 96, PixelFormats.Pbgra32, null);
}
else
{
bitmap = new WriteableBitmap(baseFrame);
}
var rawBitmap = new WriteableBitmap(rawFrame);
bitmap.Blit(new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height), rawBitmap, new Rect(0, 0, rawFrame.Width, rawFrame.Height));
var result = new CompressedBitmapSource((BitmapSource)bitmap);
bitmap = null;
rawBitmap = null;
GC.Collect();
Dispatcher.CurrentDispatcher.Invoke(() => {}, DispatcherPriority.ContextIdle);
return(result);
}
public static extern Int32 GetVisibleFrame(UInt16 index, UInt16 timeout, IntPtr Buf, UInt32 BufSize, out FrameMetadata Metadata);
private void SelectedFrameChanged(object sender, EventArgs e)
{
FrameMetadata frame = FrameList.Current;
if (frame == null)
{
CurrentFrameImage = null;
return;
}
InnerNpkFile selectedFile = InnerFileList.Current;
DFO.Common.Images.Image image = null;
try
{
image = _editor.GetImage(selectedFile.Path, frame.Index);
}
catch (Exception)
{
// TODO: Log this and maybe display something
CurrentFrameImage = null;
return;
}
// Adjust position in bounding box according to frame coordinates
// go from (0, 0) based coordinates to (_smallestX, _smallestY) based coordinates
// (0, 0) -> (45, 50)
// (60, 55) -> (15, 5)
// frame x - _smallestX = bounding box X
// frame y - _smallestY = bounding box y
// Paint image in bounding box
// RGBA -> BGRA (for little endian platforms), (BGRA for big endian platforms) - seems to not be reversed for little endian???
// TODO: Make NpkReader able to output in variable format so it doesn't need to be converted
byte[] frameBytes = new byte[_width * _height * 4];
// Get X in frame
// bounding box X + _smallestX = frame x
// (5, 0) 5x5
// (3, 1), 10x6
// smallest x: 3
// smallest y: 0
// (0, 0): 0 + 3
for (int boundingBoxY = 0; boundingBoxY < _height; boundingBoxY++)
{
int frameY = boundingBoxY + _smallestY;
int rowOffset = boundingBoxY * _width * 4;
// if this row is above or below the current frame, draw a row of transparent pixels
if (frameY < image.Attributes.LocationY || frameY > image.Attributes.LocationY + image.Attributes.Height - 1)
{
for (int boundingBoxX = 0; boundingBoxX < _width; boundingBoxX++)
{
int pixelOffset = rowOffset + (boundingBoxX * 4);
frameBytes[pixelOffset] = 0;
frameBytes[pixelOffset + 1] = 0;
frameBytes[pixelOffset + 2] = 0;
frameBytes[pixelOffset + 3] = 0;
}
}
else
{
for (int boundingBoxX = 0; boundingBoxX < _width; boundingBoxX++)
{
int frameX = boundingBoxX + _smallestX;
int pixelOffset = rowOffset + (boundingBoxX * 4);
// if this column is to the left or right of the current frame, draw a transparent pixel
if (frameX < image.Attributes.LocationX || frameX > image.Attributes.LocationX + image.Attributes.Width - 1)
{
frameBytes[pixelOffset] = 0;
frameBytes[pixelOffset + 1] = 0;
frameBytes[pixelOffset + 2] = 0;
frameBytes[pixelOffset + 3] = 0;
}
else
{
// RGBA -> BGRA
int zeroBasedFrameY = frameY - image.Attributes.LocationY;
int zeroBasedFrameX = frameX - image.Attributes.LocationX;
int framePixelOffset = zeroBasedFrameY * image.Attributes.Width * 4 + zeroBasedFrameX * 4;
frameBytes[pixelOffset] = image.PixelData[framePixelOffset + 2]; // B
frameBytes[pixelOffset + 1] = image.PixelData[framePixelOffset + 1]; // G
frameBytes[pixelOffset + 2] = image.PixelData[framePixelOffset]; // R
frameBytes[pixelOffset + 3] = image.PixelData[framePixelOffset + 3]; // A
}
}
}
}
CurrentFrameImage = BitmapSource.Create(_width, _height, dpiX: 96, dpiY: 96, pixelFormat: PixelFormats.Bgra32, palette: null, pixels: frameBytes, stride: 4 * _width);
}
private static ObjectAnimationUsingKeyFrames?GetAnimation(Image imageControl, BitmapSource source)
{
ObjectAnimationUsingKeyFrames?animation = AnimationCache.GetAnimation(source,
GetRepeatBehavior(imageControl));
if (animation != null)
{
return(animation);
}
GifFile?gifMetadata;
var decoder = GetDecoder(source, out gifMetadata) as GifBitmapDecoder;
if (decoder != null && decoder.Frames.Count > 1)
{
Int32Size fullSize = GetFullSize(decoder, gifMetadata);
int index = 0;
animation = new ObjectAnimationUsingKeyFrames();
TimeSpan totalDuration = TimeSpan.Zero;
BitmapSource?baseFrame = null;
foreach (BitmapFrame rawFrame in decoder.Frames)
{
FrameMetadata metadata = GetFrameMetadata(decoder, gifMetadata, index);
BitmapSource frame = MakeFrame(fullSize, rawFrame, metadata, baseFrame);
var keyFrame = new DiscreteObjectKeyFrame(frame, totalDuration);
animation.KeyFrames.Add(keyFrame);
totalDuration += metadata.Delay;
switch (metadata.DisposalMethod)
{
case FrameDisposalMethod.None:
case FrameDisposalMethod.DoNotDispose:
baseFrame = frame;
break;
case FrameDisposalMethod.RestoreBackground:
if (IsFullFrame(metadata, fullSize))
{
baseFrame = null;
}
else
{
baseFrame = ClearArea(frame, metadata);
}
break;
case FrameDisposalMethod.RestorePrevious:
// Reuse same base frame
break;
}
index++;
}
animation.Duration = totalDuration;
animation.RepeatBehavior = GetActualRepeatBehavior(imageControl, decoder, gifMetadata);
AnimationCache.AddAnimation(source, GetRepeatBehavior(imageControl), animation);
return(animation);
}
return(null);
}
public static BitmapSource MakeFrame(System.Drawing.Size fullSize, BitmapSource rawFrame, FrameMetadata metadata, BitmapSource baseFrame)
{
//I removed this, so I could save the same as 32bpp
//if (baseFrame == null && IsFullFrame(metadata, fullSize))
//{
// // No previous image to combine with, and same size as the full image
// // Just return the frame as is
// return rawFrame;
//}
var visual = new DrawingVisual();
using (var context = visual.RenderOpen())
{
if (baseFrame != null)
{
var fullRect = new Rect(0, 0, fullSize.Width, fullSize.Height);
context.DrawImage(baseFrame, fullRect);
}
var rect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height);
context.DrawImage(rawFrame, rect);
}
//TODO: Test, DPI was hardcoded to 96.
var bitmap = new RenderTargetBitmap(fullSize.Width, fullSize.Height, rawFrame.DpiX, rawFrame.DpiY, PixelFormats.Pbgra32);
bitmap.Render(visual);
if (bitmap.CanFreeze && !bitmap.IsFrozen)
{
bitmap.Freeze();
}
return(bitmap);
}
static async Task Main(string[] args)
{
CvInvoke.Init();
if (!DepthAIInvoke.HaveDepthAI)
{
Console.WriteLine("The native binary is built without Depth AI support.");
return;
}
String win1 = "Depth AI (Press 'q' to quit)"; //The name of the window
CvInvoke.NamedWindow(win1); //Create the window using the specific name
MobilenetSsd mobilenet = new MobilenetSsd();
//This download the models and return the default configuration
await mobilenet.Init(onDownloadProgressChanged);
Config config = mobilenet.ModelConfig;
String[] labels = mobilenet.Labels;
using (Emgu.CV.DepthAI.Device d = new Device(""))
{
//String[] availableStreams = d.GetAvailableStreams();
using (CNNHostPipeline pipeline = d.CreatePipeline(JsonConvert.SerializeObject(config)))
{
if (pipeline.Ptr == IntPtr.Zero)
{
Console.WriteLine("Failed to create device pipeline.");
return;
}
while (_is_running)
{
using (NNetAndDataPackets packets = pipeline.GetAvailableNNetAndDataPackets(false))
{
HostDataPacket[] dataPackets = packets.HostDataPackets;
NNetPacket[] nnetPackets = packets.NNetPackets;
for (int i = 0; i < dataPackets.Length; i++)
{
if (dataPackets[i].GetPreviewOut(_render))
{
using (FrameMetadata fmeta = dataPackets[i].GetFrameMetadata())
{
if (i < nnetPackets.Length)
{
NNetPacket nnetPacket = nnetPackets[i];
using (FrameMetadata meta = nnetPacket.GetFrameMetadata())
{
_mostRecentDetections = nnetPacket.Detections;
}
}
if (_mostRecentDetections != null)
{
for (int j = 0; j < _mostRecentDetections.Length; j++)
{
DrawDetection(_mostRecentDetections[j], _render, labels);
}
}
CvInvoke.Imshow(win1, _render); //Show the image
}
}
else
{
//failed to get preview image
}
}
}
if (CvInvoke.WaitKey(1) > 0) //Press any key to stop
{
_is_running = false;
}
}
}
}
CvInvoke.DestroyAllWindows(); //Destroy all windows if key is pressed
}
