public static CanvasBitmap ToWin2D(this Bitmap bmp, ICanvasResourceCreator resourceCreator)
{
return(CanvasBitmap.CreateFromBytes(resourceCreator, bmp.Bytes, bmp.Width, bmp.Height, DirectXPixelFormat.B8G8R8A8UIntNormalized));
}
public Task <object> Create(byte[] imageData, int imageWidth, int imageHeight, int pixelByteCount)
{
return(Task.Run(() => {
return (object)CanvasBitmap.CreateFromBytes(CanvasDevice.GetSharedDevice(), imageData, imageWidth, imageHeight, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized, 96);
}));
}
public void DrawToSession([NotNull] CanvasControl sender, [NotNull] CanvasDrawingSession g, bool drawGrid = false)
{
switch (State)
{
case TileState.Locked:
if (RawImageData != null)
{
g.Clear(Colors.DarkKhaki); // wrong state
}
else
{
g.Clear(Colors.DarkGray); // which is lighter than 'Gray'
}
return;
case TileState.Corrupted:
g.Clear(Colors.Red);
return;
case TileState.Empty:
g.Clear(Colors.White);
if (drawGrid)
{
DrawGrid(g, Color.FromArgb(100, 155, 155, 155));
}
if (IsSelected)
{
DrawSelection(g);
}
return;
case TileState.Ready:
if (RawImageData == null)
{
g.Clear(Colors.Fuchsia); // Should not happen!
return;
}
g.Clear(Colors.White);
try
{
using (var bmp = CanvasBitmap.CreateFromBytes(sender, RawImageData, 256, 256, // these two should be doubled if we interpolate
DirectXPixelFormat.B8G8R8A8UIntNormalized, 96, CanvasAlphaMode.Premultiplied))
{
g.DrawImage(bmp, new Rect(0, 0, 256, 256));
g.Flush();
// you'll get "Exception thrown at 0x12F9AF43 (Microsoft.Graphics.Canvas.dll) in SlickUWP.exe: 0xC0000005: Access violation reading location 0x1B2EEF78. occurred"
// if you fail to flush before disposing of the bmp
}
}
catch
{
g.Clear(Colors.DarkOrange);
}
if (drawGrid)
{
DrawGrid(g, Color.FromArgb(100, 155, 155, 155));
}
if (IsSelected)
{
DrawSelection(g);
}
g.Flush();
return;
default:
throw new Exception("Non exhaustive switch in Tile_Draw");
}
}
public void Invalidate()
{
var animations = _animations;
if (animations == null || _canvas == null || _bitmaps == null)
{
return;
}
var index = _index;
var framesPerUpdate = _limitFps ? _animationFrameRate < 60 ? 1 : 2 : 1;
var enqueue = false;
if (_animationFrameRate < 60 && !_limitFps)
{
if (_skipFrame)
{
_skipFrame = false;
return;
}
_skipFrame = true;
}
for (int i = 0; i < animations.Length; i++)
{
if (_bitmaps[i] == null || animations[i] == null)
{
if (animations[i] != null)
{
var buffer = ArrayPool <byte> .Shared.Rent(256 * 256 * 4);
_bitmaps[i] = CanvasBitmap.CreateFromBytes(_canvas, buffer, _frameSize.Width, _frameSize.Height, DirectXPixelFormat.B8G8R8A8UIntNormalized);
ArrayPool <byte> .Shared.Return(buffer);
}
else
{
continue;
}
}
animations[i].RenderSync(_bitmaps[i], index[i]);
if (i == 1 && !_isLoopingEnabled[i])
{
IndexChanged?.Invoke(this, index[i]);
}
if (_startIndex[i] <= index[1] && index[i] + framesPerUpdate < animations[i].TotalFrame)
{
_index[i] += framesPerUpdate;
}
else
{
if (_isLoopingEnabled[i])
{
_index[i] = 0;
if (i == 1 && _value == 0 && _enqueued != 0 && _enqueuedState != null)
{
enqueue = true;
}
}
else if (i == 1)
{
lock (_subscribeLock)
{
_subscribed = false;
_unsubscribe = true;
_thread.Tick -= OnTick;
}
}
}
}
if (enqueue)
{
_subscribed = false;
_ = Dispatcher.RunIdleAsync(idle => SetValue(_enqueuedState, _enqueued));
}
}
public async void ProcessFrame(ProcessVideoFrameContext context)
{
// When using SupportedMemoryTypes => MediaMemoryTypes.GpuAndCpu we need to check if we're using GPU or CPU for the frame
// If we're on GPU, use InputFrame.Direct3DSurface
if (context.InputFrame.SoftwareBitmap == null)
{
using (var inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
using (var ds = renderTarget.CreateDrawingSession())
{
var chromaKeyEffect = new ChromaKeyEffect
{
Color = ChromaColor,
Source = inputBitmap,
Tolerance = Tolerance,
Feather = true
};
//only load bg image if it hasnt already been loaded or if image is different
if (_backgroundBitmap == null || _lastUsedImageFilePath != _imageFileName)
{
_backgroundBitmap = await CanvasBitmap.LoadAsync(ds, new Uri($"ms-appdata:///Local/{ImageFileName}"));
}
_lastUsedImageFilePath = _imageFileName; //keep track of any incoming image changes
var compositeEffect = new CompositeEffect
{
Sources = { _backgroundBitmap, chromaKeyEffect }
};
ds.DrawImage(compositeEffect);
}
return;
}
// If we're on CPU, use InputFrame.SoftwareBitmap
if (context.InputFrame.Direct3DSurface == null)
{
// InputFrame's raw pixels
byte[] inputFrameBytes = new byte[4 * context.InputFrame.SoftwareBitmap.PixelWidth * context.InputFrame.SoftwareBitmap.PixelHeight];
context.InputFrame.SoftwareBitmap.CopyToBuffer(inputFrameBytes.AsBuffer());
using (var inputBitmap = CanvasBitmap.CreateFromBytes(
_canvasDevice,
inputFrameBytes,
context.InputFrame.SoftwareBitmap.PixelWidth,
context.InputFrame.SoftwareBitmap.PixelHeight,
context.InputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat()))
using (var renderTarget = new CanvasRenderTarget(
_canvasDevice,
context.OutputFrame.SoftwareBitmap.PixelWidth,
context.OutputFrame.SoftwareBitmap.PixelHeight,
(float)context.OutputFrame.SoftwareBitmap.DpiX,
context.OutputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat(),
CanvasAlphaMode.Ignore))
{
using (var ds = renderTarget.CreateDrawingSession())
{
var chroma = new ChromaKeyEffect
{
Color = ChromaColor,
Source = inputBitmap,
Tolerance = Tolerance
};
//only load bg image if it hasnt already been loaded or if image is different
if (_backgroundBitmap == null || _lastUsedImageFilePath != _imageFileName)
{
_backgroundBitmap = await CanvasBitmap.LoadAsync(ds, new Uri($"ms-appdata:///Local/{ImageFileName}"));
}
//keep track of any incoming image changes
_lastUsedImageFilePath = _imageFileName;
var compositeEffect = new CompositeEffect {
Mode = CanvasComposite.Add
};
compositeEffect.Sources.Add(_backgroundBitmap);
compositeEffect.Sources.Add(chroma);
ds.DrawImage(compositeEffect);
}
}
}
}
// ** Methods ** //
// This is run for every video frame passed in the media pipleine (MediaPlayer, MediaCapture, etc)
public void ProcessFrame(ProcessVideoFrameContext context)
{
evaluatableVideoFrame = VideoFrame.CreateWithDirect3D11Surface(context.InputFrame.Direct3DSurface);
// ********** Draw Bounding Boxes with Win2D ********** //
// Use Direct3DSurface if using GPU memory
if (context.InputFrame.Direct3DSurface != null)
{
if (modelBindingComplete && options.PreferredDeviceKind != LearningModelDeviceKindPreview.LearningDeviceGpu)
{
options.PreferredDeviceKind = LearningModelDeviceKindPreview.LearningDeviceGpu;
}
using (var inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(canvasDevice, context.InputFrame.Direct3DSurface))
using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(canvasDevice, context.OutputFrame.Direct3DSurface))
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawImage(inputBitmap);
foreach (var box in filteredBoxes)
{
var x = (uint)Math.Max(box.X, 0);
var y = (uint)Math.Max(box.Y, 0);
var w = (uint)Math.Min(renderTarget.Bounds.Width - x, box.Width);
var h = (uint)Math.Min(renderTarget.Bounds.Height - y, box.Height);
// Draw the Text 10px above the top of the bounding box
ds.DrawText(box.Label, x, y - 10, Colors.Yellow);
ds.DrawRectangle(new Rect(x, y, w, h), new CanvasSolidColorBrush(canvasDevice, Colors.Yellow), 2f);
}
}
return;
}
// Use SoftwareBitmap if using CPU memory
if (context.InputFrame.SoftwareBitmap != null)
{
if (modelBindingComplete && options.PreferredDeviceKind != LearningModelDeviceKindPreview.LearningDeviceCpu)
{
options.PreferredDeviceKind = LearningModelDeviceKindPreview.LearningDeviceCpu;
}
// InputFrame's pixels
byte[] inputFrameBytes = new byte[4 * context.InputFrame.SoftwareBitmap.PixelWidth * context.InputFrame.SoftwareBitmap.PixelHeight];
context.InputFrame.SoftwareBitmap.CopyToBuffer(inputFrameBytes.AsBuffer());
using (var inputBitmap = CanvasBitmap.CreateFromBytes(canvasDevice, inputFrameBytes, context.InputFrame.SoftwareBitmap.PixelWidth, context.InputFrame.SoftwareBitmap.PixelHeight, context.InputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat()))
using (var renderTarget = new CanvasRenderTarget(canvasDevice, context.OutputFrame.SoftwareBitmap.PixelWidth, context.InputFrame.SoftwareBitmap.PixelHeight, (float)context.OutputFrame.SoftwareBitmap.DpiX, context.OutputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat(), CanvasAlphaMode.Premultiplied))
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawImage(inputBitmap);
foreach (var box in filteredBoxes)
{
var x = (uint)Math.Max(box.X, 0);
var y = (uint)Math.Max(box.Y, 0);
var w = (uint)Math.Min(context.OutputFrame.SoftwareBitmap.PixelWidth - x, box.Width);
var h = (uint)Math.Min(context.OutputFrame.SoftwareBitmap.PixelHeight - y, box.Height);
// Draw the Text 10px above the top of the bounding box
ds.DrawText(box.Label, x, y - 10, Colors.Yellow);
ds.DrawRectangle(new Rect(x, y, w, h), new CanvasSolidColorBrush(canvasDevice, Colors.Yellow), 2f);
}
}
}
}
public void TestBitmapPixelFormats()
{
using (new DisableDebugLayer())
{
var device = new CanvasDevice();
foreach (var format in AllPixelFormats())
{
// Unknown formats should not be supported.
if (!formatFlags.ContainsKey(format))
{
Assert.IsFalse(device.IsPixelFormatSupported(format));
ValidateCannotCreateBitmap(device, format, FirstSupportedAlphaMode(format));
continue;
}
// Optional formats may be legitimately not supported, depending on the device.
if (!device.IsPixelFormatSupported(format))
{
Assert.IsTrue((formatFlags[format] & FormatFlags.Optional) != 0);
ValidateCannotCreateBitmap(device, format, FirstSupportedAlphaMode(format));
continue;
}
// We should be able to create this format using all its supported alpha modes.
var lotsOfZeroes = new byte[1024];
foreach (var alphaMode in SupportedAlphaModes(format))
{
CanvasBitmap.CreateFromBytes(device, lotsOfZeroes, 4, 4, format, 96, alphaMode);
}
// Other alpha modes should not be supported.
foreach (var alphaMode in UnsupportedAlphaModes(format))
{
ValidateCannotCreateBitmap(device, format, alphaMode);
}
// We should also be able to create this format without explicitly specifying an alpha mode.
var bitmap = CanvasBitmap.CreateFromBytes(device, lotsOfZeroes, 4, 4, format);
Assert.AreEqual(FirstSupportedAlphaMode(format), bitmap.AlphaMode);
// Some formats can be drawn directly, while others cannot.
if ((formatFlags[format] & FormatFlags.CannotDraw) == 0)
{
ValidateCanDrawImage(device, bitmap);
}
else
{
ValidateCannotDrawImage(device, bitmap);
}
// But all formats should be drawable when used as effect inputs.
ValidateCanDrawImage(device, new ColorMatrixEffect {
Source = bitmap
});
// Make sure we can get and set pixels of this format.
var bytes = bitmap.GetPixelBytes();
Assert.IsTrue(bytes.All(b => b == 0));
var sequence = Enumerable.Range(0, bytes.Length)
.Select(value => (byte)value)
.ToArray();
bitmap.SetPixelBytes(sequence);
var otherBytes = bitmap.GetPixelBytes();
CollectionAssert.AreEqual(sequence, otherBytes);
}
}
}
private void CanvasAnimatedDraw(ICanvasAnimatedControl sender, CanvasAnimatedDrawEventArgs args)
{
DrawEventCount();
_nIteration++;
const float usedDpi = 96.0f;
if (_restart || _nIteration % 2048 == 0)
{
_restart = false;
CanvasResourcesCreate(null, null);
_g++;
}
bool oneState = true;
byte theState = 0;
for (int x = 0, bufferIndex = 0; x < _width; x++)
{
for (int y = 0; y < _height; y++, bufferIndex += 4)
{
byte state = (byte)((_next[x, y] = NextStateValue(_current, x, y)) & 0xff);
if (x == 0 && y == 0)
{
theState = state;
}
else if (theState != state)
{
oneState = false;
}
switch (state % 16)
{
case 0:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 255;
_buffer[bufferIndex + 2] = 255;
_buffer[bufferIndex + 3] = 255;
break;
case 1:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 255;
_buffer[bufferIndex + 2] = 180;
_buffer[bufferIndex + 3] = 255;
break;
case 2:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 255;
_buffer[bufferIndex + 2] = 100;
_buffer[bufferIndex + 3] = 255;
break;
case 3:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 255;
_buffer[bufferIndex + 2] = 0;
_buffer[bufferIndex + 3] = 255;
break;
case 4:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 180;
_buffer[bufferIndex + 2] = 0;
_buffer[bufferIndex + 3] = 255;
break;
case 5:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 100;
_buffer[bufferIndex + 2] = 0;
_buffer[bufferIndex + 3] = 255;
break;
case 6:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 0;
_buffer[bufferIndex + 2] = 0;
_buffer[bufferIndex + 3] = 255;
break;
case 7:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 0;
_buffer[bufferIndex + 2] = 100;
_buffer[bufferIndex + 3] = 255;
break;
case 8:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 0;
_buffer[bufferIndex + 2] = 180;
_buffer[bufferIndex + 3] = 255;
break;
case 9:
_buffer[bufferIndex + 0] = 255;
_buffer[bufferIndex + 1] = 0;
_buffer[bufferIndex + 2] = 255;
_buffer[bufferIndex + 3] = 255;
break;
case 10:
_buffer[bufferIndex + 0] = 180;
_buffer[bufferIndex + 1] = 0;
_buffer[bufferIndex + 2] = 255;
_buffer[bufferIndex + 3] = 255;
break;
case 11:
_buffer[bufferIndex + 0] = 100;
_buffer[bufferIndex + 1] = 0;
_buffer[bufferIndex + 2] = 255;
_buffer[bufferIndex + 3] = 255;
break;
case 12:
_buffer[bufferIndex + 0] = 0;
_buffer[bufferIndex + 1] = 0;
_buffer[bufferIndex + 2] = 255;
_buffer[bufferIndex + 3] = 255;
break;
case 13:
_buffer[bufferIndex + 0] = 0;
_buffer[bufferIndex + 1] = 100;
_buffer[bufferIndex + 2] = 255;
_buffer[bufferIndex + 3] = 255;
break;
case 14:
_buffer[bufferIndex + 0] = 0;
_buffer[bufferIndex + 1] = 180;
_buffer[bufferIndex + 2] = 255;
_buffer[bufferIndex + 3] = 255;
break;
default:
_buffer[bufferIndex + 0] = 0;
_buffer[bufferIndex + 1] = 255;
_buffer[bufferIndex + 2] = 255;
_buffer[bufferIndex + 3] = 255;
break;
}
}
}
if (oneState)
{
_restart = true;
}
using (var bitmap = CanvasBitmap.CreateFromBytes(sender, _buffer, _width, _height, DirectXPixelFormat.B8G8R8A8UIntNormalized, usedDpi))
{
args.DrawingSession.DrawImage(bitmap, new Rect(0, 0, _width, _height), new Rect(0, 0, _width, _height), 1, CanvasImageInterpolation.NearestNeighbor);
}
args.DrawingSession.DrawText($"FPS {FramesPerSecond:F2}", new Vector2(10, 10), Colors.Black);
args.DrawingSession.DrawText("Step " + _nIteration, new Vector2(10, 30), Colors.Black);
args.DrawingSession.DrawText("G " + _g, new Vector2(10, 50), Colors.Black);
var tmp = _next;
_next = _current;
_current = tmp;
}
public async Task OpenFileAsync(StorageFile file)
{
CanvasBitmap fileBitmap = null;
var extension = file.FileType;
switch (extension)
{
case ".bin":
var buffer = await FileIO.ReadBufferAsync(file);
var width = 0;
var height = 0;
var format = DirectXPixelFormat.B8G8R8A8UIntNormalized;
var dialogResult = await BinaryDetailsInputDialog.ShowAsync();
if (dialogResult == ContentDialogResult.Primary &&
ParseBinaryDetailsSizeBoxes(out width, out height))
{
fileBitmap = CanvasBitmap.CreateFromBytes(_canvasDevice, buffer, width, height, format);
}
break;
default:
// open it with win2d
using (var stream = await file.OpenReadAsync())
{
fileBitmap = await CanvasBitmap.LoadAsync(_canvasDevice, stream);
}
break;
}
if (fileBitmap != null)
{
var size = fileBitmap.SizeInPixels;
var backgroundSurface = _compositionGraphics.CreateDrawingSurface2(
new SizeInt32()
{
Width = (int)size.Width, Height = (int)size.Height
},
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
using (var drawingSession = CanvasComposition.CreateDrawingSession(backgroundSurface))
{
drawingSession.FillRectangle(0, 0, size.Width, size.Height, _backgroundCavnasBrush);
}
var imageSurface = _compositionGraphics.CreateDrawingSurface2(
new SizeInt32()
{
Width = (int)size.Width, Height = (int)size.Height
},
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
using (var drawingSession = CanvasComposition.CreateDrawingSession(imageSurface))
{
drawingSession.Clear(Colors.Transparent);
drawingSession.DrawImage(fileBitmap);
}
_backgroundBrush.Surface = backgroundSurface;
_imageBrush.Surface = imageSurface;
ImageGrid.Width = size.Width;
ImageGrid.Height = size.Height;
ImageScrollViewer.ChangeView(0, 0, 1, true);
if (_borderEnabled)
{
ImageBorderBrush.Color = Colors.Black;
}
_currentFile = file;
}
}
//private bool correctionFlag = false;
public void ProcessFrame(ProcessVideoFrameContext context)
{
using (CanvasBitmap inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
using (CanvasRenderTarget renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
using (CanvasDrawingSession ds = renderTarget.CreateDrawingSession())
using (var scaleEffect = new ScaleEffect())
using (CanvasSolidColorBrush solidColorBrush = new CanvasSolidColorBrush(_canvasDevice, _backgroundColor))
{
solidColorBrush.Opacity = _backgroundOpacity;
double rel = context.InputFrame.RelativeTime.Value.Ticks / (double)TimeSpan.TicksPerMillisecond;
//context.OutputFrame.Duration = new TimeSpan( (long)(frameLength * TimeSpan.TicksPerMillisecond));
int frameTimeCounter = (int)Math.Round(rel / _frameLength, 0);
int[] pitch = new int[_count];
int[] yaw = new int[_count];
int[] fov = new int[_count];
for (int i = 0; i < _count; i++)
{
try
{
//pitch[i] = this.pitch[ (frameTimeCounter + (int)Math.Round(offset, 0)) * (count) + i];
//fov[i] = this.fov[ (frameTimeCounter + (int)Math.Round(offset, 0)) * (count) + i];
//yaw[i] = this.yaw[ (frameTimeCounter + (int)Math.Round(offset, 0)) * (count) + i];
pitch[i] = this._pitch[(frameTimeCounter + (int)_offset) * (_count) + i];
fov[i] = this._fov[(frameTimeCounter + (int)_offset) * (_count) + i];
yaw[i] = this._yaw[(frameTimeCounter + (int)_offset) * (_count) + i];
}
catch (ArgumentOutOfRangeException ex)
{
Debug.WriteLine(ex.Message);
pitch[i] = 0;
fov[i] = 0;
yaw[i] = 0;
}
}
byte[] tab = Heatmap.GenerateHeatmap(pitch, yaw, fov);
CanvasBitmap cb = CanvasBitmap.CreateFromBytes(_canvasDevice, tab, 64, 64, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized, 96, CanvasAlphaMode.Premultiplied);
scaleEffect.Source = cb;
scaleEffect.Scale = new System.Numerics.Vector2((float)_width / 64, (float)_height / 64);
scaleEffect.InterpolationMode = CanvasImageInterpolation.Cubic;
scaleEffect.BorderMode = EffectBorderMode.Hard;
if (_graysclaleVideoFlag)
{
var grayScaleEffect = new GrayscaleEffect
{
BufferPrecision = CanvasBufferPrecision.Precision8UIntNormalized,
CacheOutput = false,
Source = inputBitmap
};
ds.DrawImage(grayScaleEffect);
}
else
{
ds.DrawImage(inputBitmap);
}
ds.DrawImage(scaleEffect, 0, 0, new Windows.Foundation.Rect {
Height = _height, Width = _width
}, _heatmapOpacity);
if (_generateDots)
{
for (int i = 0; i < _count; i++)
{
ds.FillCircle(yaw[i] * _width / 64, pitch[i] * _height / 64, _dotsRadius, _colors[i % 5]);
}
}
ds.FillRectangle(new Windows.Foundation.Rect {
Height = _height, Width = _width
}, solidColorBrush);
ds.Flush();
}
}
public void ProcessFrame(ProcessVideoFrameContext context)
{
// If memory type is CPU, the frame is in InputFrame.SoftwareBitmap.
// For GPU, the frame is in InputFrame.Direct3DSurface
if (context.InputFrame.SoftwareBitmap == null)
{
using (var inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
using (var ds = renderTarget.CreateDrawingSession())
{
var effect = new EdgeDetectionEffect
{
Source = inputBitmap,
Amount = this.Amount
};
ds.DrawImage(effect);
}
return;
}
// Testing issue with GPU
if (context.InputFrame.Direct3DSurface == null)
{
#if DEBUG
if (!debugOutputFlag)
{
Debug.WriteLine($"PixelFormat: {context.InputFrame.SoftwareBitmap.BitmapPixelFormat}");
debugOutputFlag = true;
}
#endif
// ********** Test for using SoftwareBitmap.Convert ********* //
//using (var inputBitmap = CanvasBitmap.CreateFromSoftwareBitmap(
// _canvasDevice,
// SoftwareBitmap.Convert(context.InputFrame.SoftwareBitmap, context.InputFrame.SoftwareBitmap.BitmapPixelFormat))) //PixelFormat: Bgra8
//using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
//using (var ds = renderTarget.CreateDrawingSession())
//{
// var effect = new EdgeDetectionEffect
// {
// Source = inputBitmap,
// Amount = this.Amount
// };
// ds.DrawImage(effect);
//}
// ********************************************************** //
// InputFrame's raw pixels
byte[] inputFrameBytes = new byte[4 * context.InputFrame.SoftwareBitmap.PixelWidth * context.InputFrame.SoftwareBitmap.PixelHeight];
context.InputFrame.SoftwareBitmap.CopyToBuffer(inputFrameBytes.AsBuffer());
using (var inputBitmap = CanvasBitmap.CreateFromBytes(
_canvasDevice,
inputFrameBytes,
context.InputFrame.SoftwareBitmap.PixelWidth,
context.InputFrame.SoftwareBitmap.PixelHeight,
context.InputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat()))
using (var renderTarget = new CanvasRenderTarget(
_canvasDevice,
context.OutputFrame.SoftwareBitmap.PixelWidth,
context.OutputFrame.SoftwareBitmap.PixelHeight,
(float)context.OutputFrame.SoftwareBitmap.DpiX,
context.OutputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat(),
CanvasAlphaMode.Premultiplied))
{
using (var ds = renderTarget.CreateDrawingSession())
{
var effect = new EdgeDetectionEffect
{
Source = inputBitmap,
Amount = this.Amount
};
ds.DrawImage(effect);
}
}
}
}
private async void GenerateButtonClicked(object sender, RoutedEventArgs e)
{
if (AutoGradientCheckBox.IsChecked.GetValueOrDefault())
{
_perlinNoiseEngine.InitializeGradients();
}
if (AutoPermutationsCheckBox.IsChecked.GetValueOrDefault())
{
_perlinNoiseEngine.InitializePermutation();
}
var actualWidth = (int)NoiseCanvasControl.ActualWidth;
var actualHeight = (int)NoiseCanvasControl.ActualHeight;
var octaves = (int)OctavesSlider.Value;
var frequency = (float)(FrequencySlider.Value / 1000);
var amplitude = (float)(AmplitudeSlider.Value / 1000);
var noisemap = await Task.Run(() => _perlinNoiseEngine.GenerateNoiseMap(actualWidth, actualHeight, octaves, frequency, amplitude));
var totalSize = actualWidth * actualHeight;
var noisebytes = new byte[totalSize * 4];
for (int i = 0; i < totalSize; i++)
{
noisebytes[i * 4] = noisemap[i];
noisebytes[i * 4 + 1] = noisemap[i];
noisebytes[i * 4 + 2] = noisemap[i];
noisebytes[i * 4 + 3] = 255;
}
_noisebitmap = CanvasBitmap.CreateFromBytes(NoiseCanvasControl, noisebytes, actualWidth, actualHeight, DirectXPixelFormat.B8G8R8A8UIntNormalized);
var shapemap = new byte[totalSize];
int centerX = actualWidth / 2;
int centerY = actualHeight / 2;
int radius = (int)((actualWidth / 2) * .8);
for (int y = 0; y < actualHeight; y++)
{
for (int x = 0; x < actualWidth; x++)
{
float distance = (float)Math.Sqrt(Math.Pow(x - centerX, 2) + Math.Pow(y - centerY, 2));
if (distance > radius)
{
continue;
}
float part = distance / radius;
byte value = (byte)(255 * (1 - part));
shapemap[y * actualWidth + x] = value;
}
}
var shapebytes = new byte[totalSize * 4];
for (int i = 0; i < totalSize; i++)
{
shapebytes[i * 4] = shapemap[i];
shapebytes[i * 4 + 1] = shapemap[i];
shapebytes[i * 4 + 2] = shapemap[i];
shapebytes[i * 4 + 3] = 255;
}
_shapebitmap = CanvasBitmap.CreateFromBytes(ShapeCanvasControl, shapebytes, actualWidth, actualHeight, DirectXPixelFormat.B8G8R8A8UIntNormalized);
var heightbytes = new byte[totalSize * 4];
for (int i = 0; i < totalSize; i++)
{
byte first = noisemap[i];
byte second = shapemap[i];
int temp = (first + second) / 2;
byte value = (byte)temp;
heightbytes[i * 4] = value;
heightbytes[i * 4 + 1] = value;
heightbytes[i * 4 + 2] = value;
heightbytes[i * 4 + 3] = 255;
}
_heightbitmap = CanvasBitmap.CreateFromBytes(HeightCanvasControl, heightbytes, actualWidth, actualHeight, DirectXPixelFormat.B8G8R8A8UIntNormalized);
var bytes = new byte[totalSize * 4];
for (int i = 0; i < totalSize; i++)
{
int value = (noisemap[i] + shapemap[i]) / 2;
int index = i * 4;
if (value < 100)
{
// dark blue - ocean
bytes[index] = 104;
bytes[index + 1] = 34;
bytes[index + 2] = 26;
bytes[index + 3] = 255;
}
else if (value < 128)
{
// lighter blue - shallow
bytes[index] = 212;
bytes[index + 1] = 118;
bytes[index + 2] = 58;
bytes[index + 3] = 255;
}
else if (value < 140)
{
// yellowish - coast
bytes[index] = 145;
bytes[index + 1] = 231;
bytes[index + 2] = 255;
bytes[index + 3] = 255;
}
else if (value < 180)
{
// green - grass/forest
bytes[index] = 43;
bytes[index + 1] = 149;
bytes[index + 2] = 63;
bytes[index + 3] = 255;
}
else if (value < 210)
{
// gray - mountain
bytes[index] = 100;
bytes[index + 1] = 100;
bytes[index + 2] = 100;
bytes[index + 3] = 255;
}
else
{
// white - snow
bytes[index] = 255;
bytes[index + 1] = 255;
bytes[index + 2] = 255;
bytes[index + 3] = 255;
}
}
_finalbitmap = CanvasBitmap.CreateFromBytes(FinalCanvasControl, bytes, actualWidth, actualHeight, DirectXPixelFormat.B8G8R8A8UIntNormalized);
NoiseCanvasControl.Invalidate();
ShapeCanvasControl.Invalidate();
HeightCanvasControl.Invalidate();
FinalCanvasControl.Invalidate();
}
public override void Init(WriteableBitmap bmp, IGrap9Attr attr = null)
{
var newbg = attr.bgurl != bgurl || attr.fgurl != fgurl || attr.hard != hard;
base.Init(bmp, attr);
b = bmp;
source = new CanvasRenderTarget(
device, b.PixelWidth, b.PixelHeight, 96,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized,
CanvasAlphaMode.Premultiplied
);
Canvas = new CanvasRenderTarget(
device, b.PixelWidth, b.PixelHeight, 96,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized,
CanvasAlphaMode.Premultiplied
);
Invalidate(true);
try
{
if (newbg)
{
if (fgurl != "")
{
var img = LayerPaint.Img.Create(fgurl);
Shape = CanvasBitmap.CreateFromBytes(
device, img.PixelBuffer, img.PixelWidth, img.PixelHeight,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized
);
}
else
{
var px = 200;
var csize = Canvas.Size;
var sample = new CanvasRenderTarget(device, 2 * px, 2 * px, 96,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized, CanvasAlphaMode.Premultiplied
);
var tb = new CanvasRadialGradientBrush(device, new[] {
new CanvasGradientStop()
{
Color = Color.FromArgb(255, 255, 255, 255), Position = hard
},
new CanvasGradientStop()
{
Color = Color.FromArgb(255, 0, 0, 0), Position = 1f
},
}, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Straight);
using (var s = sample.CreateDrawingSession())
{
tb.RadiusX = px; tb.RadiusY = px; tb.Center = new Vector2(px, px);
s.FillRectangle(0, 0, px * 2, px * 2, tb);
}
Shape = sample;
}
if (bgurl != "")
{
var img = LayerPaint.Img.Create(bgurl);
Texture = CanvasBitmap.CreateFromBytes(
device, img.PixelBuffer, img.PixelWidth, img.PixelHeight,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized
);
}
else
{
Texture = null;
}
//fgurl = bgurl= "";
}
}
catch (Exception e)
{
new Windows.UI.Popups.MessageDialog(e.ToString()).ShowMux();
}
Loadd();
}
public void ProcessFrame(ProcessVideoFrameContext context)
{
try
{
// When using SupportedMemoryTypes => MediaMemoryTypes.GpuAndCpu we need to check if we're using GPU or CPU for the frame
// If we're on GPU, use InputFrame.Direct3DSurface
if (context.InputFrame.SoftwareBitmap == null)
{
using (var inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawImage(inputBitmap);
ds.DrawImage(this._overlay, inputBitmap.Bounds);
}
return;
}
// If we're on CPU, use InputFrame.SoftwareBitmap
if (context.InputFrame.Direct3DSurface == null)
{
// InputFrame's raw pixels
byte[] inputFrameBytes = new byte[4 * context.InputFrame.SoftwareBitmap.PixelWidth * context.InputFrame.SoftwareBitmap.PixelHeight];
context.InputFrame.SoftwareBitmap.CopyToBuffer(inputFrameBytes.AsBuffer());
using (var inputBitmap = CanvasBitmap.CreateFromBytes(
_canvasDevice,
inputFrameBytes,
context.InputFrame.SoftwareBitmap.PixelWidth,
context.InputFrame.SoftwareBitmap.PixelHeight,
context.InputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat()))
using (var renderTarget = new CanvasRenderTarget(
_canvasDevice,
context.OutputFrame.SoftwareBitmap.PixelWidth,
context.OutputFrame.SoftwareBitmap.PixelHeight,
(float)context.OutputFrame.SoftwareBitmap.DpiX,
context.OutputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat(),
CanvasAlphaMode.Premultiplied))
{
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawImage(inputBitmap);
ds.DrawImage(this._overlay, inputBitmap.Bounds);
}
}
}
}
catch (Exception)
{
if (crashCount < 20)
{
crashCount++;
Debug.WriteLine($"ProcessFrame Exception: #{crashCount}");
}
else
{
//System.Exception HResult = 0x88990012
//Message = Objects used together must be created from the same factory instance. (Exception from HRESULT: 0x88990012)
//Source = System.Private.CoreLib
//StackTrace:
//at System.Runtime.InteropServices.WindowsRuntime.IClosable.Close()
//at System.Runtime.InteropServices.WindowsRuntime.IClosableToIDisposableAdapter.Dispose()
//at VideoEffects.Win2D.OverlayVideoEffect.ProcessFrame(ProcessVideoFrameContext context) in D:\GitHub\VideoDiary\src\VideoDiary.EffectsLibrary\Win2dEffects\OverlayVideoEffect.cs:line 66
throw;
}
}
}
private async Task ChatPhotoAsync(UpdateFileGenerationStart update, string[] args)
{
try
{
var conversion = JsonConvert.DeserializeObject <ChatPhotoConversion>(args[2]);
var sticker = await _protoService.SendAsync(new GetFile(conversion.StickerFileId)) as Telegram.Td.Api.File;
if (sticker == null || !sticker.Local.IsFileExisting())
{
_protoService.Send(new FinishFileGeneration(update.GenerationId, new Error(500, "FILE_GENERATE_LOCATION_INVALID No sticker found")));
return;
}
Background background = null;
var backgroundLink = await _protoService.SendAsync(new GetInternalLinkType(conversion.BackgroundUrl ?? string.Empty)) as InternalLinkTypeBackground;
if (backgroundLink != null)
{
background = await _protoService.SendAsync(new SearchBackground(backgroundLink.BackgroundName)) as Background;
}
else
{
var freeform = new[] { 0xDBDDBB, 0x6BA587, 0xD5D88D, 0x88B884 };
background = new Background(0, true, false, string.Empty,
new Document(string.Empty, "application/x-tgwallpattern", null, null, TdExtensions.GetLocalFile("Assets\\Background.tgv", "Background")),
new BackgroundTypePattern(new BackgroundFillFreeformGradient(freeform), 50, false, false));
}
if (background == null || (background.Document != null && !background.Document.DocumentValue.Local.IsFileExisting()))
{
_protoService.Send(new FinishFileGeneration(update.GenerationId, new Error(500, "FILE_GENERATE_LOCATION_INVALID No background found")));
return;
}
var device = CanvasDevice.GetSharedDevice();
var bitmaps = new List <CanvasBitmap>();
var sfondo = new CanvasRenderTarget(device, 640, 640, 96, DirectXPixelFormat.B8G8R8A8UIntNormalized, CanvasAlphaMode.Premultiplied);
using (var session = sfondo.CreateDrawingSession())
{
if (background.Type is BackgroundTypePattern pattern)
{
if (pattern.Fill is BackgroundFillFreeformGradient freeform)
{
var colors = freeform.GetColors();
var positions = new Vector2[]
{
new Vector2(0.80f, 0.10f),
new Vector2(0.35f, 0.25f),
new Vector2(0.20f, 0.90f),
new Vector2(0.65f, 0.75f),
};
using (var gradient = CanvasBitmap.CreateFromBytes(device, ChatBackgroundFreeform.GenerateGradientData(50, 50, colors, positions), 50, 50, DirectXPixelFormat.B8G8R8A8UIntNormalized))
using (var cache = await PlaceholderHelper.GetPatternBitmapAsync(device, null, background.Document.DocumentValue))
{
using (var scale = new ScaleEffect {
Source = gradient, BorderMode = EffectBorderMode.Hard, Scale = new Vector2(640f / 50f, 640f / 50f)
})
using (var colorize = new TintEffect {
Source = cache, Color = Color.FromArgb(0x76, 00, 00, 00)
})
using (var tile = new BorderEffect {
Source = colorize, ExtendX = CanvasEdgeBehavior.Wrap, ExtendY = CanvasEdgeBehavior.Wrap
})
using (var effect = new BlendEffect {
Foreground = tile, Background = scale, Mode = BlendEffectMode.Overlay
})
{
session.DrawImage(effect, new Rect(0, 0, 640, 640), new Rect(0, 0, 640, 640));
}
}
}
}
}
bitmaps.Add(sfondo);
var width = (int)(512d * conversion.Scale);
var height = (int)(512d * conversion.Scale);
var animation = await Task.Run(() => LottieAnimation.LoadFromFile(sticker.Local.Path, new Windows.Graphics.SizeInt32 {
Width = width, Height = height
}, false, null));
if (animation == null)
{
_protoService.Send(new FinishFileGeneration(update.GenerationId, new Error(500, "FILE_GENERATE_LOCATION_INVALID Can't load Lottie animation")));
return;
}
var composition = new MediaComposition();
var layer = new MediaOverlayLayer();
var buffer = ArrayPool <byte> .Shared.Rent(width *height * 4);
var framesPerUpdate = animation.FrameRate < 60 ? 1 : 2;
var duration = TimeSpan.Zero;
for (int i = 0; i < animation.TotalFrame; i += framesPerUpdate)
{
var bitmap = CanvasBitmap.CreateFromBytes(device, buffer, width, height, DirectXPixelFormat.B8G8R8A8UIntNormalized);
animation.RenderSync(bitmap, i);
var clip = MediaClip.CreateFromSurface(bitmap, TimeSpan.FromMilliseconds(1000d / 30d));
var overlay = new MediaOverlay(clip, new Rect(320 - (width / 2d), 320 - (height / 2d), width, height), 1);
overlay.Delay = duration;
layer.Overlays.Add(overlay);
duration += clip.OriginalDuration;
bitmaps.Add(bitmap);
}
composition.OverlayLayers.Add(layer);
composition.Clips.Add(MediaClip.CreateFromSurface(sfondo, duration));
var temp = await _protoService.GetFileAsync(update.DestinationPath);
var profile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto);
profile.Audio = null;
profile.Video.Bitrate = 1800000;
profile.Video.Width = 640;
profile.Video.Height = 640;
profile.Video.FrameRate.Numerator = 30;
profile.Video.FrameRate.Denominator = 1;
var progress = composition.RenderToFileAsync(temp, MediaTrimmingPreference.Precise, profile);
progress.Progress = (result, delta) =>
{
_protoService.Send(new SetFileGenerationProgress(update.GenerationId, 100, (int)delta));
};
var result = await progress;
if (result == TranscodeFailureReason.None)
{
_protoService.Send(new FinishFileGeneration(update.GenerationId, null));
}
else
{
_protoService.Send(new FinishFileGeneration(update.GenerationId, new Error(500, result.ToString())));
}
ArrayPool <byte> .Shared.Return(buffer);
foreach (var bitmap in bitmaps)
{
bitmap.Dispose();
}
}
catch (Exception ex)
{
_protoService.Send(new FinishFileGeneration(update.GenerationId, new Error(500, "FILE_GENERATE_LOCATION_INVALID " + ex.ToString())));
}
}
/// <summary>
/// Captures the ink from an <see cref="InkCanvas"/> control.
/// </summary>
/// <param name="canvas">
/// The <see cref="InkCanvas"/> control.
/// </param>
/// <param name="rootRenderElement">
/// A <see cref="FrameworkElement"/> which wraps the canvas.
/// </param>
/// <param name="encoderId">
/// A <see cref="BitmapEncoder"/> ID to use to render the image.
/// </param>
/// <returns>
/// Returns an awaitable task.
/// </returns>
public static async Task <StorageFile> CaptureInkAsImageAsync(
this InkCanvas canvas,
FrameworkElement rootRenderElement,
Guid encoderId)
{
var targetFile =
await
ApplicationData.Current.TemporaryFolder.CreateFileAsync(
$"{Guid.NewGuid()}.png",
CreationCollisionOption.ReplaceExisting);
if (targetFile != null)
{
var renderBitmap = new RenderTargetBitmap();
await renderBitmap.RenderAsync(rootRenderElement);
var bitmapSizeAt96Dpi = new Size(renderBitmap.PixelWidth, renderBitmap.PixelHeight);
var pixels = await renderBitmap.GetPixelsAsync();
var win2DDevice = CanvasDevice.GetSharedDevice();
using (
var target = new CanvasRenderTarget(
win2DDevice,
(float)rootRenderElement.ActualWidth,
(float)rootRenderElement.ActualHeight,
96.0f))
{
using (var drawingSession = target.CreateDrawingSession())
{
using (
var canvasBitmap = CanvasBitmap.CreateFromBytes(
win2DDevice,
pixels,
(int)bitmapSizeAt96Dpi.Width,
(int)bitmapSizeAt96Dpi.Height,
DirectXPixelFormat.B8G8R8A8UIntNormalized,
96.0f))
{
drawingSession.DrawImage(
canvasBitmap,
new Rect(0, 0, target.SizeInPixels.Width, target.SizeInPixels.Height),
new Rect(0, 0, bitmapSizeAt96Dpi.Width, bitmapSizeAt96Dpi.Height));
}
drawingSession.Units = CanvasUnits.Pixels;
drawingSession.DrawInk(canvas.InkPresenter.StrokeContainer.GetStrokes());
}
using (var stream = await targetFile.OpenAsync(FileAccessMode.ReadWrite))
{
var logicalDpi = DisplayInformation.GetForCurrentView().LogicalDpi;
var encoder = await BitmapEncoder.CreateAsync(encoderId, stream);
encoder.SetPixelData(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Ignore,
(uint)renderBitmap.PixelWidth,
(uint)renderBitmap.PixelHeight,
logicalDpi,
logicalDpi,
target.GetPixelBytes());
await encoder.FlushAsync();
}
}
}
return(targetFile);
}
public async Task OpenFileAsync(StorageFile file)
{
CanvasBitmap fileBitmap = null;
var extension = file.FileType;
switch (extension)
{
case ".bin":
var buffer = await FileIO.ReadBufferAsync(file);
var width = 0;
var height = 0;
var format = DirectXPixelFormat.B8G8R8A8UIntNormalized;
// If the image name ends in (width)x(height), then use that in the dialog
var fileName = file.Name;
var fileStem = fileName.Substring(0, fileName.LastIndexOf('.'));
var pattern = @".*[A-z](?<width>[0-9]+)x(?<height>[0-9]+)";
var match = Regex.Match(fileStem, pattern);
if (match.Success)
{
ResetBinaryDetailsInputDialog(int.Parse(match.Groups["width"].Value), int.Parse(match.Groups["height"].Value));
}
else
{
ResetBinaryDetailsInputDialog();
}
var dialogResult = await BinaryDetailsInputDialog.ShowAsync();
if (dialogResult == ContentDialogResult.Primary &&
ParseBinaryDetailsSizeBoxes(out width, out height))
{
fileBitmap = CanvasBitmap.CreateFromBytes(_canvasDevice, buffer, width, height, format);
}
break;
default:
// open it with win2d
using (var stream = await file.OpenReadAsync())
{
fileBitmap = await CanvasBitmap.LoadAsync(_canvasDevice, stream);
}
break;
}
if (fileBitmap != null)
{
var size = fileBitmap.SizeInPixels;
var backgroundSurface = _compositionGraphics.CreateDrawingSurface2(
new SizeInt32()
{
Width = (int)size.Width, Height = (int)size.Height
},
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
using (var drawingSession = CanvasComposition.CreateDrawingSession(backgroundSurface))
{
drawingSession.FillRectangle(0, 0, size.Width, size.Height, _backgroundCavnasBrush);
}
var imageSurface = _compositionGraphics.CreateDrawingSurface2(
new SizeInt32()
{
Width = (int)size.Width, Height = (int)size.Height
},
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
using (var drawingSession = CanvasComposition.CreateDrawingSession(imageSurface))
{
drawingSession.Clear(Colors.Transparent);
drawingSession.DrawImage(fileBitmap);
}
_backgroundBrush.Surface = backgroundSurface;
_imageBrush.Surface = imageSurface;
ImageGrid.Width = size.Width;
ImageGrid.Height = size.Height;
ImageScrollViewer.ChangeView(0, 0, 1, true);
if (_borderEnabled)
{
ImageBorderBrush.Color = Colors.Black;
}
_currentFile = file;
_currentBitmap = fileBitmap;
}
}
protected override com.codename1.ui.Image generatePeerImage()
{
int width = getWidth();
int height = getHeight();
if (width <= 0 || height <= 0)
{
width = getPreferredW();
height = getPreferredH();
}
if (element.Parent == null)
{
if (peerImage != null)
{
return((com.codename1.ui.Image)peerImage);
}
return(com.codename1.ui.Image.createImage(width, height));
}
CodenameOneImage img = new CodenameOneImage();
//img.@this();
img.name = "PeerImage: " + element.ToString();
IRandomAccessStream stream = new InMemoryRandomAccessStream();
CanvasBitmap cb = null;
using (AutoResetEvent are = new AutoResetEvent(false))
{
SilverlightImplementation.dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (element is WebView)
{
try
{
Task.Delay(TimeSpan.FromTicks(4).Duration()).GetAwaiter().GetResult();
((WebView)element).CapturePreviewToStreamAsync(stream).AsTask().GetAwaiter().GetResult();
stream.FlushAsync().AsTask().GetAwaiter().GetResult();
stream.Seek(0);
Task.Delay(TimeSpan.FromMilliseconds(10)).GetAwaiter().GetResult();
cb = CanvasBitmap.LoadAsync(SilverlightImplementation.screen, stream).AsTask().GetAwaiter().GetResult();
}
catch (Exception)
{
throw;
}
}
else
{
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
renderTargetBitmap.RenderAsync(element).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();
byte[] buf = renderTargetBitmap.GetPixelsAsync().AsTask().ConfigureAwait(false).GetAwaiter().GetResult().ToArray();
cb = CanvasBitmap.CreateFromBytes(SilverlightImplementation.screen, buf, width, height, SilverlightImplementation.pixelFormat, SilverlightImplementation.screen.Dpi);
}
img.image = new CanvasRenderTarget(SilverlightImplementation.screen, cb.SizeInPixels.Width, cb.SizeInPixels.Height, cb.Dpi);
img.graphics.destination.drawImage(cb, 0, 0);
img.graphics.destination.dispose();
are.Set();
}).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();
are.WaitOne();
}
return(com.codename1.ui.Image.createImage(img));
// return com.codename1.ui.Image.createImage(width, height);
}
private void StartBtn_Click(object sender, RoutedEventArgs e)
{
source = new CancellationTokenSource();
token = source.Token;
StopBtn.IsEnabled = true;
StartBtn.IsEnabled = false;
Task.Run(async() =>
{
Debug.WriteLine("Start Screen Cast");
while (token.IsCancellationRequested == false)
{
ValueSet valueSet = new ValueSet
{
{ "screen", isCompressData }
};
if (App.Connection != null)
{
stopwatch.Start();
AppServiceResponse response = await App.Connection.SendMessageAsync(valueSet);
var responseTime = stopwatch.Elapsed.Milliseconds;
var screenBytes = response.Message["screen"] as byte[];
var width = (int)response.Message["screenWidth"];
var height = (int)response.Message["screenHeight"];
double len = Math.Round((double)screenBytes.Length / 1024, 2);
if (swapChain == null)
{
await InitShapChain(width, height);
}
stopwatch.Restart();
var decompressTime = 0;
if (isCompressData == true)
{
screenBytes = Decompress(screenBytes);
decompressTime = stopwatch.Elapsed.Milliseconds;
stopwatch.Restart();
}
using (CanvasDrawingSession ds = SwapChainPanel.SwapChain.CreateDrawingSession(Colors.Transparent))
{
using (CanvasBitmap screen = CanvasBitmap.CreateFromBytes(device, screenBytes, width, height, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized))
{
ds.DrawImage(screen, new Windows.Foundation.Rect(0, 0, 800, 600));
}
}
SwapChainPanel.SwapChain.Present();
var drawTime = stopwatch.Elapsed.Milliseconds;
stopwatch.Stop();
Debug.WriteLine($"Response: {responseTime} ms Draw:{drawTime} ms Decompress: {decompressTime} ms Length: {len} Kb");
}
await Task.Delay(TimeSpan.FromMilliseconds(25));
}
Debug.WriteLine("Stop Screen Cast");
}, token);
}
public void ProcessFrame(ProcessVideoFrameContext context)
{
//using (CanvasBitmap inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
//using (CanvasRenderTarget renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
//using (CanvasDrawingSession ds = renderTarget.CreateDrawingSession())
//{
// var invert = new InvertEffect()
// {
// Source = inputBitmap
// };
// ds.DrawImage(invert);
//}
// When using SupportedMemoryTypes => MediaMemoryTypes.GpuAndCpu we need to check if we're using GPU or CPU for the frame
// If we're on GPU, use InputFrame.Direct3DSurface
if (context.InputFrame.SoftwareBitmap == null)
{
using (var inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
using (var ds = renderTarget.CreateDrawingSession())
{
var invert = new InvertEffect()
{
Source = inputBitmap
};
ds.DrawImage(invert);
}
return;
}
// If we're on CPU, use InputFrame.SoftwareBitmap
if (context.InputFrame.Direct3DSurface == null)
{
// InputFrame's raw pixels
byte[] inputFrameBytes = new byte[4 * context.InputFrame.SoftwareBitmap.PixelWidth * context.InputFrame.SoftwareBitmap.PixelHeight];
context.InputFrame.SoftwareBitmap.CopyToBuffer(inputFrameBytes.AsBuffer());
using (var inputBitmap = CanvasBitmap.CreateFromBytes(
_canvasDevice,
inputFrameBytes,
context.InputFrame.SoftwareBitmap.PixelWidth,
context.InputFrame.SoftwareBitmap.PixelHeight,
context.InputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat()))
using (var renderTarget = new CanvasRenderTarget(
_canvasDevice,
context.OutputFrame.SoftwareBitmap.PixelWidth,
context.OutputFrame.SoftwareBitmap.PixelHeight,
(float)context.OutputFrame.SoftwareBitmap.DpiX,
context.OutputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat(),
CanvasAlphaMode.Premultiplied))
{
using (var ds = renderTarget.CreateDrawingSession())
{
var invert = new InvertEffect()
{
Source = inputBitmap
};
ds.DrawImage(invert);
}
}
}
}
