private static void EncodeMultiframe(PixelBuffer[] images, int count, WICFlags flags, Guid guidContainerFormat, Stream stream)
{
if (images.Length < 2)
{
throw new ArgumentException("Cannot encode to multiple frame. Image doesn't have multiple frame");
}
using (var encoder = Factory.CreateEncoder(guidContainerFormat))
using (var propBag = new PropertyBag())
{
using (var eInfo = encoder.EncoderInfo)
{
if (!eInfo.DoesSupportMultiframe())
{
throw new NotSupportedException("Cannot encode to multiple frame. Format is not supporting multiple frame");
}
}
encoder.Initialize(stream);
for (var i = 0; i < Math.Min(images.Length, count); i++)
{
var pixelBuffer = images[i];
using (var frame = encoder.CreateNewFrame(propBag))
{
EncodeImage(pixelBuffer, flags, frame);
}
}
encoder.Commit();
}
}
//-------------------------------------------------------------------------------------
// Encodes an image array
//-------------------------------------------------------------------------------------
private static void EncodeMultiframe(PixelBuffer[] images, int count, WICFlags flags, Guid guidContainerFormat, Stream stream)
{
if (images.Length < 2)
{
throw new ArgumentException("Cannot encode to multiple frame. Image doesn't have multiple frame");
}
using (var encoder = new WIC.BitmapEncoder(Factory, guidContainerFormat))
{
using (var eInfo = encoder.EncoderInfo)
{
if (!eInfo.IsMultiframeSupported)
{
throw new NotSupportedException("Cannot encode to multiple frame. Format is not supporting multiple frame");
}
}
encoder.Initialize(stream);
for (int i = 0; i < Math.Min(images.Length, count); i++)
{
var pixelBuffer = images[i];
using (var frame = new WIC.BitmapFrameEncode(encoder))
EncodeImage(pixelBuffer, flags, frame);
}
encoder.Commit();
}
}
//-------------------------------------------------------------------------------------
// Encodes a single frame
//-------------------------------------------------------------------------------------
private static void EncodeImage(PixelBuffer image, WICFlags flags, WIC.BitmapFrameEncode frame)
{
Guid pfGuid;
if (!ToWIC(image.Format, out pfGuid))
{
throw new NotSupportedException("Format not supported");
}
frame.Initialize();
frame.SetSize(image.Width, image.Height);
frame.SetResolution(72, 72);
Guid targetGuid = pfGuid;
frame.SetPixelFormat(ref targetGuid);
if (targetGuid != pfGuid)
{
using (var source = new WIC.Bitmap(Factory, image.Width, image.Height, pfGuid, new SDX.DataRectangle(image.DataPointer, image.RowStride), image.BufferStride))
{
using (var converter = new WIC.FormatConverter(Factory))
{
using (var palette = new WIC.Palette(Factory))
{
palette.Initialize(source, 256, true);
converter.Initialize(source, targetGuid, GetWICDither(flags), palette, 0, WIC.BitmapPaletteType.Custom);
int bpp = GetBitsPerPixel(targetGuid);
if (bpp == 0)
{
throw new NotSupportedException("Unable to determine the Bpp for the target format");
}
int rowPitch = (image.Width * bpp + 7) / 8;
int slicePitch = rowPitch * image.Height;
var temp = SDX.Utilities.AllocateMemory(slicePitch);
try
{
converter.CopyPixels(rowPitch, temp, slicePitch);
frame.Palette = palette;
frame.WritePixels(image.Height, temp, rowPitch, slicePitch);
}
finally
{
SDX.Utilities.FreeMemory(temp);
}
}
}
}
}
else
{
// No conversion required
frame.WritePixels(image.Height, image.DataPointer, image.RowStride, image.BufferStride);
}
frame.Commit();
}
private static void SaveToWICMemory(PixelBuffer[] pixelBuffer, int count, WICFlags flags, ImageFileType fileType, Stream stream)
{
if (count > 1)
{
EncodeMultiframe(pixelBuffer, count, flags, GetContainerFormatFromFileType(fileType), stream);
}
else
{
EncodeSingleFrame(pixelBuffer[0], flags, GetContainerFormatFromFileType(fileType), stream);
}
}
public _Form(Bitmap img, WICFlags flags)
{
_img = img;
_flags = flags;
SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
AutoScaleMode = AutoScaleMode.None;
FormBorderStyle = FormBorderStyle.None; //important
ShowInTaskbar = false; //optional
TopLevel = true; //optional
StartPosition = FormStartPosition.Manual;
Text = "Au.AWinImage.CaptureUI";
Cursor = _cursor = ACursor.LoadCursorFromMemory(Resources.Resources.red_cross_cursor, 32);
}
private static WIC.BitmapDitherType GetWICDither(WICFlags flags)
{
if ((flags & WICFlags.Dither) != 0)
{
return(WIC.BitmapDitherType.Ordered4x4);
}
if ((flags & WICFlags.DitherDiffusion) != 0)
{
return(WIC.BitmapDitherType.ErrorDiffusion);
}
return(WIC.BitmapDitherType.None);
}
private static WIC.BitmapInterpolationMode GetWICInterp(WICFlags flags)
{
if ((flags & WICFlags.FilterPoint) != 0)
{
return(WIC.BitmapInterpolationMode.NearestNeighbor);
}
if ((flags & WICFlags.FilterLinear) != 0)
{
return(WIC.BitmapInterpolationMode.Linear);
}
if ((flags & WICFlags.FilterCubic) != 0)
{
return(WIC.BitmapInterpolationMode.Cubic);
}
return(WIC.BitmapInterpolationMode.Fant);
}
private static void EncodeSingleFrame(PixelBuffer pixelBuffer, WICFlags flags, Guid guidContainerFormat, Stream stream)
{
using (var encoder = new WIC.BitmapEncoder(Factory, guidContainerFormat, stream))
{
using (var frame = new WIC.BitmapFrameEncode(encoder))
{
if (guidContainerFormat == WIC.ContainerFormatGuids.Bmp)
{
try
{
frame.Options.Set("EnableV5Header32bppBGRA", true);
}
catch
{
}
}
EncodeImage(pixelBuffer, flags, frame);
encoder.Commit();
}
}
}
//-------------------------------------------------------------------------------------
// Decodes a single frame
//-------------------------------------------------------------------------------------
private static Image DecodeSingleFrame(WICFlags flags, ImageDescription metadata, Guid convertGUID, WIC.BitmapFrameDecode frame)
{
var image = Image.New(metadata);
var pixelBuffer = image.PixelBuffer[0];
if (convertGUID == Guid.Empty)
{
frame.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
else
{
using (var converter = new WIC.FormatConverter(Factory))
{
converter.Initialize(frame, convertGUID, GetWICDither(flags), null, 0, WIC.BitmapPaletteType.Custom);
converter.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
}
return(image);
}
/// <summary>
/// Determines metadata for image
/// </summary>
/// <param name="flags">The flags.</param>
/// <param name="decoder">The decoder.</param>
/// <param name="frame">The frame.</param>
/// <param name="pixelFormat">The pixel format.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException">If pixel format is not supported.</exception>
private static ImageDescription?DecodeMetadata(WICFlags flags, WIC.BitmapDecoder decoder, WIC.BitmapFrameDecode frame, out Guid pixelFormat)
{
var size = frame.Size;
var metadata = new ImageDescription
{
Dimension = TextureDimension.Texture2D,
Width = size.Width,
Height = size.Height,
Depth = 1,
MipLevels = 1,
ArraySize = (flags & WICFlags.AllFrames) != 0 ? decoder.FrameCount : 1,
Format = DetermineFormat(frame.PixelFormat, flags, out pixelFormat)
};
if (metadata.Format == DXGI.Format.Unknown)
{
return(null);
}
return(metadata);
}
private static void EncodeSingleFrame(PixelBuffer pixelBuffer, WICFlags flags, Guid guidContainerFormat, Stream stream)
{
using (var encoder = Factory.CreateEncoder(guidContainerFormat, stream))
using (var propBag = new PropertyBag())
{
if (guidContainerFormat == ContainerFormatGuids.Bmp)
{
try
{
propBag.Set("EnableV5Header32bppBGRA", true);
}
catch
{
}
}
using (var frame = encoder.CreateNewFrame(propBag))
{
EncodeImage(pixelBuffer, flags, frame);
encoder.Commit();
}
}
}
//-------------------------------------------------------------------------------------
// Encodes an image array
//-------------------------------------------------------------------------------------
private static void EncodeMultiframe( PixelBuffer[] images, int count, WICFlags flags, Guid guidContainerFormat, Stream stream )
{
if ( images.Length < 2 )
throw new ArgumentException("Cannot encode to multiple frame. Image doesn't have multiple frame");
using (var encoder = new BitmapEncoder(Factory, guidContainerFormat))
{
using (var eInfo = encoder.EncoderInfo)
{
if (!eInfo.IsMultiframeSupported)
throw new NotSupportedException("Cannot encode to multiple frame. Format is not supporting multiple frame");
}
encoder.Initialize(stream);
for (int i = 0; i < Math.Min(images.Length, count); i++)
{
var pixelBuffer = images[i];
using (var frame = new BitmapFrameEncode(encoder))
EncodeImage(pixelBuffer, flags, frame);
}
encoder.Commit();
}
}
//-------------------------------------------------------------------------------------
// Returns the DXGI format and optionally the WIC pixel Guid to convert to
//-------------------------------------------------------------------------------------
private static DXGI.Format DetermineFormat(Guid pixelFormat, WICFlags flags, out Guid pixelFormatOut)
{
DXGI.Format format = ToDXGI(pixelFormat);
pixelFormatOut = Guid.Empty;
if (format == DXGI.Format.Unknown)
{
for (int i = 0; i < WICConvertTable.Length; ++i)
{
if (WICConvertTable[i].source == pixelFormat)
{
pixelFormatOut = WICConvertTable[i].target;
format = ToDXGI(WICConvertTable[i].target);
Debug.Assert(format != DXGI.Format.Unknown);
break;
}
}
}
// Handle special cases based on flags
switch (format)
{
case DXGI.Format.B8G8R8A8_UNorm: // BGRA
case DXGI.Format.B8G8R8X8_UNorm: // BGRX
if ((flags & WICFlags.ForceRgb) != 0)
{
format = DXGI.Format.R8G8B8A8_UNorm;
pixelFormatOut = WIC.PixelFormat.Format32bppRGBA;
}
break;
case DXGI.Format.R10G10B10_Xr_Bias_A2_UNorm:
if ((flags & WICFlags.NoX2Bias) != 0)
{
format = DXGI.Format.R10G10B10A2_UNorm;
pixelFormatOut = WIC.PixelFormat.Format32bppRGBA1010102;
}
break;
case DXGI.Format.B5G5R5A1_UNorm:
case DXGI.Format.B5G6R5_UNorm:
if ((flags & WICFlags.No16Bpp) != 0)
{
format = DXGI.Format.R8G8B8A8_UNorm;
pixelFormatOut = WIC.PixelFormat.Format32bppRGBA;
}
break;
case DXGI.Format.R1_UNorm:
if ((flags & WICFlags.FlagsAllowMono) == 0)
{
// By default we want to promote a black & white to greyscale since R1 is not a generally supported D3D format
format = DXGI.Format.R8_UNorm;
pixelFormatOut = WIC.PixelFormat.Format8bppGray;
}
break;
}
return format;
}
//-------------------------------------------------------------------------------------
// Decodes an image array, resizing/format converting as needed
//-------------------------------------------------------------------------------------
private static Image DecodeMultiframe(WICFlags flags, ImageDescription metadata, WIC.BitmapDecoder decoder)
{
var image = Image.New(metadata);
Guid sourceGuid;
if (!ToWIC(metadata.Format, out sourceGuid))
{
return(null);
}
for (int index = 0; index < metadata.ArraySize; ++index)
{
var pixelBuffer = image.PixelBuffer[index, 0];
using (var frame = decoder.GetFrame(index))
{
var pfGuid = frame.PixelFormat;
var size = frame.Size;
if (pfGuid == sourceGuid)
{
if (size.Width == metadata.Width && size.Height == metadata.Height)
{
// This frame does not need resized or format converted, just copy...
frame.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
else
{
// This frame needs resizing, but not format converted
using (var scaler = new WIC.BitmapScaler(Factory))
{
scaler.Initialize(frame, metadata.Width, metadata.Height, GetWICInterp(flags));
scaler.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
}
}
else
{
// This frame required format conversion
using (var converter = new WIC.FormatConverter(Factory))
{
converter.Initialize(frame, pfGuid, GetWICDither(flags), null, 0, WIC.BitmapPaletteType.Custom);
if (size.Width == metadata.Width && size.Height == metadata.Height)
{
converter.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
else
{
// This frame needs resizing, but not format converted
using (var scaler = new WIC.BitmapScaler(Factory))
{
scaler.Initialize(frame, metadata.Width, metadata.Height, GetWICInterp(flags));
scaler.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
}
}
}
}
}
return(image);
}
/// <summary>
/// Determines metadata for image
/// </summary>
/// <param name="flags">The flags.</param>
/// <param name="decoder">The decoder.</param>
/// <param name="frame">The frame.</param>
/// <param name="pixelFormat">The pixel format.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException">If pixel format is not supported.</exception>
private static ImageDescription? DecodeMetadata(WICFlags flags, BitmapDecoder decoder, BitmapFrameDecode frame, out Guid pixelFormat)
{
var size = frame.Size;
var metadata = new ImageDescription
{
Dimension = TextureDimension.Texture2D,
Width = size.Width,
Height = size.Height,
Depth = 1,
MipLevels = 1,
ArraySize = (flags & WICFlags.AllFrames) != 0 ? decoder.FrameCount : 1,
Format = DetermineFormat(frame.PixelFormat, flags, out pixelFormat)
};
if (metadata.Format == DXGI.Format.Unknown)
return null;
return metadata;
}
private static BitmapDitherType GetWICDither(WICFlags flags)
{
if ((flags & WICFlags.Dither) != 0)
return BitmapDitherType.Ordered4x4;
if ((flags & WICFlags.DitherDiffusion) != 0)
return BitmapDitherType.ErrorDiffusion;
return BitmapDitherType.None;
}
//-------------------------------------------------------------------------------------
// Returns the DXGI format and optionally the WIC pixel Guid to convert to
//-------------------------------------------------------------------------------------
private static DXGI.Format DetermineFormat(Guid pixelFormat, WICFlags flags, out Guid pixelFormatOut)
{
DXGI.Format format = ToDXGI(pixelFormat);
pixelFormatOut = Guid.Empty;
if (format == DXGI.Format.Unknown)
{
for (int i = 0; i < WICConvertTable.Length; ++i)
{
if (WICConvertTable[i].source == pixelFormat)
{
pixelFormatOut = WICConvertTable[i].target;
format = ToDXGI(WICConvertTable[i].target);
Debug.Assert(format != DXGI.Format.Unknown);
break;
}
}
}
// Handle special cases based on flags
switch (format)
{
case DXGI.Format.B8G8R8A8_UNorm: // BGRA
case DXGI.Format.B8G8R8X8_UNorm: // BGRX
if ((flags & WICFlags.ForceRgb) != 0)
{
format = DXGI.Format.R8G8B8A8_UNorm;
pixelFormatOut = WIC.PixelFormat.Format32bppRGBA;
}
break;
case DXGI.Format.R10G10B10_Xr_Bias_A2_UNorm:
if ((flags & WICFlags.NoX2Bias) != 0)
{
format = DXGI.Format.R10G10B10A2_UNorm;
pixelFormatOut = WIC.PixelFormat.Format32bppRGBA1010102;
}
break;
case DXGI.Format.B5G5R5A1_UNorm:
case DXGI.Format.B5G6R5_UNorm:
if ((flags & WICFlags.No16Bpp) != 0)
{
format = DXGI.Format.R8G8B8A8_UNorm;
pixelFormatOut = WIC.PixelFormat.Format32bppRGBA;
}
break;
case DXGI.Format.R1_UNorm:
if ((flags & WICFlags.FlagsAllowMono) == 0)
{
// By default we want to promote a black & white to greyscale since R1 is not a generally supported D3D format
format = DXGI.Format.R8_UNorm;
pixelFormatOut = WIC.PixelFormat.Format8bppGray;
}
break;
}
return(format);
}
private static BitmapInterpolationMode GetWICInterp(WICFlags flags)
{
if ((flags & WICFlags.FilterPoint) != 0)
return BitmapInterpolationMode.NearestNeighbor;
if ((flags & WICFlags.FilterLinear) != 0)
return BitmapInterpolationMode.Linear;
if ((flags & WICFlags.FilterCubic) != 0)
return BitmapInterpolationMode.Cubic;
return BitmapInterpolationMode.Fant;
}
/// <summary>
/// Creates image from a user-selected area of screen pixels. Or gets single pixel color, or just rectangle.
/// Returns false if cancelled.
/// </summary>
/// <param name="result">Receives results.</param>
/// <param name="flags"></param>
/// <param name="toolWindow">Owner window. Temporarily hides it and its owner windows.</param>
/// <remarks>
/// Gets all screen pixels and shows in a full-screen topmost window, where the user can select an area.
/// </remarks>
public static bool CaptureUI(out WICResult result, WICFlags flags = 0, AnyWnd toolWindow = default)
{
result = default;
switch (flags & (WICFlags.Image | WICFlags.Color | WICFlags.Rectangle))
{
case 0:
case WICFlags.Image:
case WICFlags.Color:
case WICFlags.Rectangle: break;
default: throw new ArgumentException();
}
AWnd[] aw = null; AWnd wTool = default;
try {
if (!toolWindow.IsEmpty)
{
wTool = toolWindow.Wnd;
aw = wTool.Get.OwnersAndThis(true);
foreach (var w in aw)
{
w.ShowLL(false);
}
using (new AInputBlocker(BIEvents.MouseClicks)) ATime.SleepDoEvents(300); //time for animations
}
g1:
RECT rs = SystemInformation.VirtualScreen;
//RECT rs = AScreen.Primary.Bounds; //for testing, to see Write output in other screen
Bitmap bs;
bool windowPixels = flags.HasAny(WICFlags.WindowDC | WICFlags.PrintWindow);
if (windowPixels)
{
if (!_WaitForHotkey("Press F3 to select window from mouse pointer."))
{
return(false);
}
var w = AWnd.FromMouse(WXYFlags.NeedWindow);
w.GetClientRect(out var rc, inScreen: true);
using var bw = Capture(w, w.ClientRect, flags.Has(WICFlags.PrintWindow));
bs = new Bitmap(rs.Width, rs.Height);
using var g = Graphics.FromImage(bs);
g.Clear(Color.Black);
g.DrawImage(bw, rc.left, rc.top);
}
else
{
bs = Capture(rs);
}
var f = new _Form(bs, flags);
f.Bounds = rs;
switch (f.ShowDialog())
{
case DialogResult.OK: break;
case DialogResult.Retry:
if (!windowPixels && !_WaitForHotkey("Press F3 when ready for new screenshot."))
{
return(false);
}
goto g1;
default: return(false);
}
var r = f.Result;
r.wnd = _WindowFromRect(r);
result = r;
}
finally {
if (aw != null)
{
foreach (var w in aw)
{
w.ShowLL(true);
}
if (wTool.IsAlive)
{
wTool.ShowNotMinimized();
wTool.ActivateLL();
}
}
}
return(true);
}
//-------------------------------------------------------------------------------------
// Decodes a single frame
//-------------------------------------------------------------------------------------
private static Image DecodeSingleFrame(WICFlags flags, ImageDescription metadata, Guid convertGUID, BitmapFrameDecode frame)
{
var image = Image.New(metadata);
var pixelBuffer = image.PixelBuffer[0];
if (convertGUID == Guid.Empty)
{
frame.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
else
{
using (var converter = new FormatConverter(Factory))
{
converter.Initialize(frame, convertGUID, GetWICDither(flags), null, 0, BitmapPaletteType.Custom);
converter.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
}
return image;
}
private static void EncodeSingleFrame( PixelBuffer pixelBuffer, WICFlags flags, Guid guidContainerFormat, Stream stream )
{
using (var encoder = new BitmapEncoder(Factory, guidContainerFormat, stream))
{
using (var frame = new BitmapFrameEncode(encoder))
{
if (guidContainerFormat == ContainerFormatGuids.Bmp)
{
try
{
frame.Options.Set("EnableV5Header32bppBGRA", true);
}
catch
{
}
}
EncodeImage(pixelBuffer, flags, frame);
encoder.Commit();
}
}
}
//-------------------------------------------------------------------------------------
// Encodes a single frame
//-------------------------------------------------------------------------------------
private static void EncodeImage( PixelBuffer image, WICFlags flags, BitmapFrameEncode frame)
{
Guid pfGuid;
if (! ToWIC(image.Format, out pfGuid))
throw new NotSupportedException("Format not supported");
frame.Initialize();
frame.SetSize(image.Width, image.Height);
frame.SetResolution(72, 72);
Guid targetGuid = pfGuid;
frame.SetPixelFormat(ref targetGuid);
if (targetGuid != pfGuid)
{
using (var source = new Bitmap(Factory, image.Width, image.Height, pfGuid, new DataRectangle(image.DataPointer, image.RowStride), image.BufferStride))
{
using (var converter = new FormatConverter(Factory))
{
using (var palette = new Palette(Factory))
{
palette.Initialize(source, 256, true);
converter.Initialize(source, targetGuid, GetWICDither(flags), palette, 0, BitmapPaletteType.Custom);
int bpp = GetBitsPerPixel(targetGuid);
if (bpp == 0) throw new NotSupportedException("Unable to determine the Bpp for the target format");
int rowPitch = (image.Width * bpp + 7) / 8;
int slicePitch = rowPitch * image.Height;
var temp = Utilities.AllocateMemory(slicePitch);
try
{
converter.CopyPixels(rowPitch, temp, slicePitch);
frame.Palette = palette;
frame.WritePixels(image.Height, temp, rowPitch, slicePitch);
}
finally
{
Utilities.FreeMemory(temp);
}
}
}
}
}
else
{
// No conversion required
frame.WritePixels(image.Height, image.DataPointer, image.RowStride, image.BufferStride);
}
frame.Commit();
}
//-------------------------------------------------------------------------------------
// Decodes an image array, resizing/format converting as needed
//-------------------------------------------------------------------------------------
private static Image DecodeMultiframe(WICFlags flags, ImageDescription metadata, BitmapDecoder decoder)
{
var image = Image.New(metadata);
Guid sourceGuid;
if (!ToWIC(metadata.Format, out sourceGuid))
return null;
for (int index = 0; index < metadata.ArraySize; ++index)
{
var pixelBuffer = image.PixelBuffer[index, 0];
using (var frame = decoder.GetFrame(index))
{
var pfGuid = frame.PixelFormat;
var size = frame.Size;
if (pfGuid == sourceGuid)
{
if (size.Width == metadata.Width && size.Height == metadata.Height)
{
// This frame does not need resized or format converted, just copy...
frame.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
else
{
// This frame needs resizing, but not format converted
using (var scaler = new BitmapScaler(Factory))
{
scaler.Initialize(frame, metadata.Width, metadata.Height, GetWICInterp(flags));
scaler.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
}
}
else
{
// This frame required format conversion
using (var converter = new FormatConverter(Factory))
{
converter.Initialize(frame, pfGuid, GetWICDither(flags), null, 0, BitmapPaletteType.Custom);
if (size.Width == metadata.Width && size.Height == metadata.Height)
{
converter.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
else
{
// This frame needs resizing, but not format converted
using (var scaler = new BitmapScaler(Factory))
{
scaler.Initialize(frame, metadata.Width, metadata.Height, GetWICInterp(flags));
scaler.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
}
}
}
}
}
}
return image;
}
private static void SaveToWICMemory(PixelBuffer[] pixelBuffer, int count, WICFlags flags, ImageFileType fileType, Stream stream)
{
if (count > 1)
EncodeMultiframe(pixelBuffer, count, flags, GetContainerFormatFromFileType(fileType), stream);
else
EncodeSingleFrame(pixelBuffer[0], flags, GetContainerFormatFromFileType(fileType), stream);
}
/// <summary>
/// Function to find the best buffer format for a given pixel format.
/// </summary>
/// <param name="sourcePixelFormat">Pixel format to translate.</param>
/// <param name="flags">Flags to apply to the pixel format conversion.</param>
/// <param name="updatedPixelFormat">The updated pixel format after flags are applied.</param>
/// <returns>The buffer format, or Unknown if the format couldn't be converted.</returns>
public BufferFormat FindBestFormat(Guid sourcePixelFormat, WICFlags flags, out Guid updatedPixelFormat)
{
BufferFormat result = GetGorgonFormat(sourcePixelFormat);
updatedPixelFormat = Guid.Empty;
if (result == BufferFormat.Unknown)
{
if (sourcePixelFormat == WIC.PixelFormat.Format96bppRGBFixedPoint)
{
updatedPixelFormat = WIC.PixelFormat.Format128bppRGBAFloat;
result = BufferFormat.R32G32B32A32_Float;
}
else
{
// Find the best fit format if we couldn't find an exact match.
for (int i = 0; i < _wicBestFitFormat.Length; i++)
{
if (_wicBestFitFormat[i].Source != sourcePixelFormat)
{
continue;
}
updatedPixelFormat = _wicBestFitFormat[i].Destination;
result = GetGorgonFormat(updatedPixelFormat);
// We couldn't find the format, bail out.
if (result == BufferFormat.Unknown)
{
return(result);
}
break;
}
}
}
switch (result)
{
case BufferFormat.B8G8R8A8_UIntNormal:
case BufferFormat.B8G8R8X8_UIntNormal:
if ((flags & WICFlags.ForceRGB) == WICFlags.ForceRGB)
{
result = BufferFormat.R8G8B8A8_UIntNormal;
updatedPixelFormat = WIC.PixelFormat.Format32bppRGBA;
}
break;
case BufferFormat.R10G10B10_XR_BIAS_A2_UIntNormal:
if ((flags & WICFlags.NoX2Bias) == WICFlags.NoX2Bias)
{
result = BufferFormat.R10G10B10A2_UIntNormal;
updatedPixelFormat = WIC.PixelFormat.Format32bppRGBA1010102;
}
break;
case BufferFormat.B5G5R5A1_UIntNormal:
case BufferFormat.B5G6R5_UIntNormal:
if ((flags & WICFlags.No16BPP) == WICFlags.No16BPP)
{
result = BufferFormat.R8G8B8A8_UIntNormal;
updatedPixelFormat = WIC.PixelFormat.Format32bppRGBA;
}
break;
case BufferFormat.R1_UIntNormal:
if ((flags & WICFlags.AllowMono) != WICFlags.AllowMono)
{
result = BufferFormat.R1_UIntNormal;
updatedPixelFormat = WIC.PixelFormat.Format8bppGray;
}
break;
}
return(result);
}
