/// <summary>
/// Function to read the data from a frame.
/// </summary>
/// <param name="wic">WIC interface.</param>
/// <param name="data">Image data to populate.</param>
/// <param name="srcFormat">Source image format.</param>
/// <param name="convertFormat">Conversion format.</param>
/// <param name="frame">Frame containing the image data.</param>
private void ReadFrame(GorgonWICImage wic, GorgonImageData data, Guid srcFormat, Guid convertFormat, BitmapFrameDecode frame)
{
var buffer = data.Buffers[0];
// We don't need to convert, so just leave.
if ((convertFormat == Guid.Empty) || (srcFormat == convertFormat))
{
frame.CopyPixels(buffer.PitchInformation.RowPitch, buffer.Data.BasePointer, buffer.PitchInformation.SlicePitch);
return;
}
// Perform conversion.
using (var converter = new FormatConverter(wic.Factory))
{
bool isIndexed = ((frame.PixelFormat == PixelFormat.Format8bppIndexed) ||
(frame.PixelFormat == PixelFormat.Format4bppIndexed) ||
(frame.PixelFormat == PixelFormat.Format2bppIndexed) ||
(frame.PixelFormat == PixelFormat.Format1bppIndexed));
Tuple <Palette, double, BitmapPaletteType> paletteInfo = null;
try
{
// If the pixel format is indexed, then retrieve a palette.
if (isIndexed)
{
paletteInfo = GetPaletteInfo(wic, null);
}
// If we've defined a palette for an indexed image, then copy it to a bitmap and set its palette.
if ((paletteInfo != null) && (paletteInfo.Item1 != null))
{
using (var tempBitmap = new Bitmap(wic.Factory, frame, BitmapCreateCacheOption.CacheOnDemand))
{
tempBitmap.Palette = paletteInfo.Item1;
converter.Initialize(tempBitmap, convertFormat, (BitmapDitherType)Dithering, paletteInfo.Item1, paletteInfo.Item2, paletteInfo.Item3);
converter.CopyPixels(buffer.PitchInformation.RowPitch, buffer.Data.BasePointer, buffer.PitchInformation.SlicePitch);
}
return;
}
// Only apply palettes to indexed image data.
converter.Initialize(frame, convertFormat, (BitmapDitherType)Dithering, null, 0.0, BitmapPaletteType.Custom);
converter.CopyPixels(buffer.PitchInformation.RowPitch, buffer.Data.BasePointer, buffer.PitchInformation.SlicePitch);
}
finally
{
if ((paletteInfo != null) && (paletteInfo.Item1 != null))
{
paletteInfo.Item1.Dispose();
}
}
}
}
private static Texture DecodeSingleframe(ImagingFactory imagingFactory, WicFlags flags, TextureDescription description, Guid convertGuid, BitmapFrameDecode frame)
{
var texture = new Texture(description);
var image = texture.Images[0];
if (convertGuid == Guid.Empty)
{
frame.CopyPixels(image.Data, image.RowPitch);
}
else
{
using (var converter = new FormatConverter(imagingFactory))
{
converter.Initialize(frame, convertGuid, GetWicDither(flags), null, 0, BitmapPaletteType.Custom);
converter.CopyPixels(image.Data, image.RowPitch);
}
}
return texture;
}
//-------------------------------------------------------------------------------------
// 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);
}
/// <summary>
/// 從WIC Frame建立貼圖資源(非DDS)
/// </summary>
/// <param name="d3dContext">If a Direct3D 11 device context is provided and the current device supports it for the given pixel format, it will auto-generate mipmaps.</param>
private static Result CreateWICTexture(Device device, DeviceContext d3dContext, BitmapFrameDecode frame, int maxsize, ResourceUsage usage, BindFlags bind, CpuAccessFlags cpuAccess, ResourceOptionFlags option, LoadFlags load, out Resource texture, out ShaderResourceView textureView)
{
texture = null;
textureView = null;
if (frame.Size.Width <= 0 || frame.Size.Height <= 0)
{
return(Result.InvalidArg);
}
if (maxsize == 0)
{
switch (device.FeatureLevel)
{
case FeatureLevel.Level_9_1:
case FeatureLevel.Level_9_2:
maxsize = 2048 /*D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION*/;
break;
case FeatureLevel.Level_9_3:
maxsize = 4096 /*D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION*/;
break;
case FeatureLevel.Level_10_0:
case FeatureLevel.Level_10_1:
maxsize = 8192 /*D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION*/;
break;
default:
maxsize = Resource.MaximumTexture2DSize; /*D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION*/
break;
}
}
Size2 frameSize = frame.Size;
Size2 targetSize;
if (frameSize.Width > maxsize || frameSize.Height > maxsize)
{
double ratio = Convert.ToDouble(frameSize.Height) / Convert.ToDouble(frameSize.Width);
if (frameSize.Width > frameSize.Height)
{
targetSize.Width = maxsize;
targetSize.Height = Math.Max(1, Convert.ToInt32(maxsize * ratio));
}
else
{
targetSize.Height = maxsize;
targetSize.Width = Math.Max(1, Convert.ToInt32(maxsize / ratio));
}
}
else
{
targetSize = frameSize;
}
#region Determine format
Guid sourceFormat = frame.PixelFormat;
Guid targetFormat = sourceFormat;
DXGI.Format format = sourceFormat.ConvertWICToDXGIFormat();
int bpp = 0;
if (format == DXGI.Format.Unknown)
{
if (sourceFormat == PixelFormat.Format96bppRGBFixedPoint)
{
if (WIC2)
{
targetFormat = PixelFormat.Format96bppRGBFloat;
format = DXGI.Format.R32G32B32_Float;
bpp = 96;
}
else
{
targetFormat = PixelFormat.Format128bppRGBAFloat;
format = DXGI.Format.R32G32B32A32_Float;
bpp = 128;
}
}
else
{
targetFormat = sourceFormat.ConvertToNearest();
format = targetFormat.ConvertWICToDXGIFormat();
bpp = PixelFormat.GetBitsPerPixel(targetFormat);
}
if (format == DXGI.Format.Unknown)
{
return(Result.GetResultFromWin32Error(unchecked ((int)0x80070032)));
}
}
else
{
bpp = PixelFormat.GetBitsPerPixel(sourceFormat);
}
if (format == DXGI.Format.R32G32B32_Float && d3dContext != null)
{
// Special case test for optional device support for autogen mipchains for R32G32B32_FLOAT
var formatSupport = device.CheckFormatSupport(format);
if (!formatSupport.HasFlag(FormatSupport.MipAutogen))
{
targetFormat = PixelFormat.Format128bppRGBAFloat;
format = DXGI.Format.R32G32B32A32_Float;
bpp = 128;
}
}
if (bpp == 0)
{
return(Result.Fail);
}
if (load.HasFlag(LoadFlags.ForceSrgb))
{
format = format.MakeSRgb();
}
else if (!load.HasFlag(LoadFlags.ignoreSrgb))
{
bool sRGB = false;
try {
var metareader = frame.MetadataQueryReader;
var containerFormat = metareader.ContainerFormat;
if (containerFormat == ContainerFormatGuids.Png)
{
// Check for sRGB chunk
if (metareader.TryGetMetadataByName("/sRGB/RenderingIntent", out var value) == Result.Ok)
{
sRGB = true;
}
}
else if (metareader.TryGetMetadataByName("System.Image.ColorSpace", out var value) == Result.Ok)
{
sRGB = true;
}
if (sRGB)
{
format = format.MakeSRgb();
}
} catch (SharpDXException) {
// BMP, ICO are not supported.
}
}
// Verify our target format is supported by the current device
var support = device.CheckFormatSupport(format);
if (!support.HasFlag(FormatSupport.Texture2D))
{
targetFormat = PixelFormat.Format32bppRGBA;
format = DXGI.Format.R8G8B8A8_UNorm;
bpp = 32;
}
#endregion
int stride = (targetSize.Width * bpp + 7) / 8; // round
int imageSize = stride * targetSize.Height;
IntPtr temp = System.Runtime.InteropServices.Marshal.AllocCoTaskMem(imageSize);
if (sourceFormat == targetFormat && frameSize == targetSize) // 不需要格式轉換 且 不需要改變大小
{
frame.CopyPixels(stride, new DataPointer(temp, imageSize));
}
else if (frameSize == targetSize) // 需要格式轉換
{
using (var factory = new ImagingFactory2())
using (var coverter = new FormatConverter(factory)) {
if (coverter.CanConvert(sourceFormat, targetFormat))
{
coverter.Initialize(frame, targetFormat, BitmapDitherType.ErrorDiffusion, null, 0, BitmapPaletteType.MedianCut);
coverter.CopyPixels(stride, new DataPointer(temp, imageSize));
}
else
{
return(Result.UnexpectedFailure);
}
}
}
else if (sourceFormat == targetFormat) // 需要改變大小
{
using (var factory = new ImagingFactory2())
using (var scaler = new BitmapScaler(factory)) {
scaler.Initialize(frame, targetSize.Width, targetSize.Height, BitmapInterpolationMode.Fant);
var pfScaler = scaler.PixelFormat;
if (targetFormat == pfScaler)
{
scaler.CopyPixels(stride, new DataPointer(temp, imageSize));
}
}
}
else // 需要格式轉換 且 需要改變大小
{
using (var factory = new ImagingFactory2())
using (var scaler = new BitmapScaler(factory))
using (var coverter = new FormatConverter(factory)) {
scaler.Initialize(frame, targetSize.Width, targetSize.Height, BitmapInterpolationMode.Fant);
var pfScaler = scaler.PixelFormat;
if (coverter.CanConvert(pfScaler, targetFormat))
{
coverter.Initialize(scaler, targetFormat, BitmapDitherType.ErrorDiffusion, null, 0, BitmapPaletteType.MedianCut);
coverter.CopyPixels(stride, new DataPointer(temp, imageSize));
}
else
{
return(Result.UnexpectedFailure);
}
}
}
var autogen = false;
if (d3dContext != null)
{
var formatSupport = device.CheckFormatSupport(format);
if (formatSupport.HasFlag(FormatSupport.MipAutogen))
{
autogen = true;
}
}
var texture2DDescription = new Texture2DDescription()
{
Width = targetSize.Width,
Height = targetSize.Height,
MipLevels = autogen ? 0 : 1,
ArraySize = 1,
Format = format,
SampleDescription = new DXGI.SampleDescription(1, 0),
Usage = usage,
CpuAccessFlags = cpuAccess,
};
if (autogen)
{
texture2DDescription.BindFlags = bind | BindFlags.RenderTarget;
texture2DDescription.OptionFlags = option | ResourceOptionFlags.GenerateMipMaps;
}
else
{
texture2DDescription.BindFlags = bind;
texture2DDescription.OptionFlags = option;
}
Result result = Result.Ok;
// 建立Texture2D !!!
try {
if (autogen)
{
texture = new Texture2D(device, texture2DDescription);
}
else
{
texture = new Texture2D(device, texture2DDescription, new DataBox[] { new DataBox(temp, stride, imageSize) });
}
} catch (SharpDXException e) {
System.Diagnostics.Debug.WriteLine(e.ToString());
result = Result.Fail;
}
if (result.Success)
{
var SRVDesc = new ShaderResourceViewDescription()
{
Format = format,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource()
{
MipLevels = autogen ? -1 : 1
},
};
try {
textureView = new ShaderResourceView(device, texture, SRVDesc);
if (autogen)
{
DataBox data = new DataBox(temp, stride, imageSize);
d3dContext.UpdateSubresource(data, texture);
d3dContext.GenerateMips(textureView);
}
} catch (Exception e) {
System.Diagnostics.Debug.WriteLine(e.ToString());
Utilities.Dispose(ref texture);
result = Result.Fail;
}
}
// 釋放 Unmanaged 資源
System.Runtime.InteropServices.Marshal.FreeCoTaskMem(temp);
return(result);
}