Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Core / CSharp / System / Windows / Media / PixelFormat.cs / 1 / PixelFormat.cs
//------------------------------------------------------------------------------
// Microsoft Avalon
// Copyright (c) Microsoft Corporation, 2003
//
// File: PixelFormat.cs
//
//-----------------------------------------------------------------------------
#pragma warning disable 1634, 1691 // Allow suppression of certain presharp messages
using System;
using System.Security;
using System.Security.Permissions;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;
using MS.Internal;
using MS.Win32;
using System.Diagnostics;
using System.Windows.Media;
using System.Globalization;
using System.Runtime.InteropServices;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
using UnsafeNativeMethods=MS.Win32.PresentationCore.UnsafeNativeMethods;
namespace System.Windows.Media
{
[System.Flags]
internal enum PixelFormatFlags
{
BitsPerPixelMask = 0x00FF,
BitsPerPixelUndefined = 0,
BitsPerPixel1 = 1,
BitsPerPixel2 = 2,
BitsPerPixel4 = 4,
BitsPerPixel8 = 8,
BitsPerPixel16 = 16,
BitsPerPixel24 = 24,
BitsPerPixel32 = 32,
BitsPerPixel48 = 48,
BitsPerPixel64 = 64,
BitsPerPixel96 = 96,
BitsPerPixel128 = 128,
IsGray = 0x00000100, // Grayscale only
IsCMYK = 0x00000200, // CMYK, not ARGB
IsSRGB = 0x00000400, // Gamma is approximately 2.2
IsScRGB = 0x00000800, // Gamma is 1.0
Premultiplied = 0x00001000, // Premultiplied Alpha
ChannelOrderMask = 0x0001E000,
ChannelOrderRGB = 0x00002000,
ChannelOrderBGR = 0x00004000,
ChannelOrderARGB = 0x00008000,
ChannelOrderABGR = 0x00010000,
Palettized = 0x00020000, // Pixels are indexes into a palette
NChannelAlpha = 0x00040000, // N-Channel format with alpha
IsNChannel = 0x00080000, // N-Channel format
}
#region PixelFormat
///
/// Describes the bit mask and shift for a specific pixelformat
///
public struct PixelFormatChannelMask
{
internal PixelFormatChannelMask(byte[] mask)
{
Debug.Assert(mask != null);
m_mask = mask;
}
///
/// The bitmask for a color channel
/// It will never be greater then 0xffffffff
///
public IList Mask
{
get
{
return new PartialList((byte[]) m_mask.Clone());
}
}
///
/// op_equality - returns whether or not the two pixel format channel masks are equal
///
public static bool operator == (PixelFormatChannelMask left, PixelFormatChannelMask right)
{
Object o1 = left;
Object o2 = right;
if (o1 == null)
{
return (o2 == null);
}
else if (o2 == null)
{
return false;
}
else
{
#pragma warning disable 6506
return left.m_mask.Equals(right.m_mask);
#pragma warning restore 6506
}
}
///
/// Equals - Returns whether or not the two pixel format channel masks are equal
///
public static bool Equals(PixelFormatChannelMask left, PixelFormatChannelMask right)
{
Object o1 = left;
Object o2 = right;
if (o1 == null)
{
return (o2 == null);
}
else if (o2 == null)
{
return false;
}
else
{
#pragma warning disable 6506
return left.m_mask.Equals(right.m_mask);
#pragma warning restore 6506
}
}
///
/// op_inequality - returns whether or not the two pixel format channel masks are not equal
///
public static bool operator != (PixelFormatChannelMask left, PixelFormatChannelMask right)
{
return !(left == right);
}
///
/// Equals - Returns whether or not this is equal to the Object
///
public override bool Equals(Object obj)
{
if ((null == obj) ||
!(obj is PixelFormatChannelMask))
{
return false;
}
return this == (PixelFormatChannelMask)obj;
}
///
/// GetHashCode - Returns a hash code
///
public override int GetHashCode()
{
int hash = 0;
for (int i=0; i
/// Pixel Format Definition for images and pixel-based surfaces
///
[TypeConverter (typeof(PixelFormatConverter))]
[Serializable]
public struct PixelFormat : IEquatable
{
///
/// Critical - Accesses closely controlled format guid
///
[SecurityCritical]
internal PixelFormat(Guid guidPixelFormat)
{
bool fBuiltIn = true;
byte[] guidBytes = guidPixelFormat.ToByteArray();
byte[] guidBuiltIn = WICPixelFormatGUIDs.WICPixelFormatDontCare.ToByteArray();
// If it's a built-in format, identify the pixel format enum.
for (int i=0; i (byte)PixelFormatEnum.Cmyk32)
{
fBuiltIn = false;
}
if (fBuiltIn)
{
m_format = (PixelFormatEnum) guidBytes[guidBytes.Length-1];
}
else
{
m_format = PixelFormatEnum.Extended;
}
m_flags = GetPixelFormatFlagsFromEnum(m_format) | GetPixelFormatFlagsFromGuid(guidPixelFormat);
m_bitsPerPixel = GetBitsPerPixelFromEnum(m_format);
m_guidFormat = new SecurityCriticalDataForSet (guidPixelFormat);
}
///
/// Critical - Accesses closely controlled format guid
/// TreatAsSafe - The input (enum) is validated in setting the format guid
///
[SecurityCritical, SecurityTreatAsSafe]
internal PixelFormat(PixelFormatEnum format)
{
m_format = format;
m_flags = GetPixelFormatFlagsFromEnum(format);
m_bitsPerPixel = GetBitsPerPixelFromEnum(format);
m_guidFormat = new SecurityCriticalDataForSet (PixelFormat.GetGuidFromFormat(format));
}
///
/// Construct a pixel format from a string that represents the format.
/// The purpose of this method is only for deserialization of PixelFormat.
/// The preferred way to construct a PixelFormat is with the PixelFormats class.
///
///
///
/// Critical - Accesses closely controlled format guid
/// TreatAsSafe - The input (string) is validated in setting the format guid
///
[SecurityCritical, SecurityTreatAsSafe]
internal PixelFormat(string pixelFormatString)
{
PixelFormatEnum format = PixelFormatEnum.Default;
if (pixelFormatString == null)
{
throw new System.ArgumentNullException("pixelFormatString");
}
string upperPixelFormatString = pixelFormatString.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
switch (upperPixelFormatString)
{
case "DEFAULT":
format = PixelFormatEnum.Default;
break;
case "EXTENDED":
format = PixelFormatEnum.Extended;
break;
case "INDEXED1":
format = PixelFormatEnum.Indexed1;
break;
case "INDEXED2":
format = PixelFormatEnum.Indexed2;
break;
case "INDEXED4":
format = PixelFormatEnum.Indexed4;
break;
case "INDEXED8":
format = PixelFormatEnum.Indexed8;
break;
case "BLACKWHITE":
format = PixelFormatEnum.BlackWhite;
break;
case "GRAY2":
format = PixelFormatEnum.Gray2;
break;
case "GRAY4":
format = PixelFormatEnum.Gray4;
break;
case "GRAY8":
format = PixelFormatEnum.Gray8;
break;
case "BGR555":
format = PixelFormatEnum.Bgr555;
break;
case "BGR565":
format = PixelFormatEnum.Bgr565;
break;
case "BGR24":
format = PixelFormatEnum.Bgr24;
break;
case "RGB24":
format = PixelFormatEnum.Rgb24;
break;
case "BGR101010":
format = PixelFormatEnum.Bgr101010;
break;
case "BGR32":
format = PixelFormatEnum.Bgr32;
break;
case "BGRA32":
format = PixelFormatEnum.Bgra32;
break;
case "PBGRA32":
format = PixelFormatEnum.Pbgra32;
break;
case "RGB48":
format = PixelFormatEnum.Rgb48;
break;
case "RGBA64":
format = PixelFormatEnum.Rgba64;
break;
case "PRGBA64":
format = PixelFormatEnum.Prgba64;
break;
case "GRAY16":
format = PixelFormatEnum.Gray16;
break;
case "GRAY32FLOAT":
format = PixelFormatEnum.Gray32Float;
break;
case "RGB128FLOAT":
format = PixelFormatEnum.Rgb128Float;
break;
case "RGBA128FLOAT":
format = PixelFormatEnum.Rgba128Float;
break;
case "PRGBA128FLOAT":
format = PixelFormatEnum.Prgba128Float;
break;
case "CMYK32":
format = PixelFormatEnum.Cmyk32;
break;
default:
throw new System.ArgumentException (SR.Get(SRID.Image_BadPixelFormat, pixelFormatString),
"pixelFormatString");
}
m_format = format;
m_flags = GetPixelFormatFlagsFromEnum(format);
m_bitsPerPixel = GetBitsPerPixelFromEnum(format);
m_guidFormat = new SecurityCriticalDataForSet (PixelFormat.GetGuidFromFormat(format));
}
static private Guid GetGuidFromFormat(PixelFormatEnum format)
{
switch (format)
{
case PixelFormatEnum.Default:
return WICPixelFormatGUIDs.WICPixelFormatDontCare;
case PixelFormatEnum.Indexed1:
return WICPixelFormatGUIDs.WICPixelFormat1bppIndexed;
case PixelFormatEnum.Indexed2:
return WICPixelFormatGUIDs.WICPixelFormat2bppIndexed;
case PixelFormatEnum.Indexed4:
return WICPixelFormatGUIDs.WICPixelFormat4bppIndexed;
case PixelFormatEnum.Indexed8:
return WICPixelFormatGUIDs.WICPixelFormat8bppIndexed;
case PixelFormatEnum.BlackWhite:
return WICPixelFormatGUIDs.WICPixelFormatBlackWhite;
case PixelFormatEnum.Gray2:
return WICPixelFormatGUIDs.WICPixelFormat2bppGray;
case PixelFormatEnum.Gray4:
return WICPixelFormatGUIDs.WICPixelFormat4bppGray;
case PixelFormatEnum.Gray8:
return WICPixelFormatGUIDs.WICPixelFormat8bppGray;
case PixelFormatEnum.Bgr555:
return WICPixelFormatGUIDs.WICPixelFormat16bppBGR555;
case PixelFormatEnum.Bgr565:
return WICPixelFormatGUIDs.WICPixelFormat16bppBGR565;
case PixelFormatEnum.Bgr24:
return WICPixelFormatGUIDs.WICPixelFormat24bppBGR;
case PixelFormatEnum.Rgb24:
return WICPixelFormatGUIDs.WICPixelFormat24bppRGB;
case PixelFormatEnum.Bgr101010:
return WICPixelFormatGUIDs.WICPixelFormat32bppBGR101010;
case PixelFormatEnum.Bgr32:
return WICPixelFormatGUIDs.WICPixelFormat32bppBGR;
case PixelFormatEnum.Bgra32:
return WICPixelFormatGUIDs.WICPixelFormat32bppBGRA;
case PixelFormatEnum.Pbgra32:
return WICPixelFormatGUIDs.WICPixelFormat32bppPBGRA;
case PixelFormatEnum.Rgb48:
return WICPixelFormatGUIDs.WICPixelFormat48bppRGB;
case PixelFormatEnum.Rgba64:
return WICPixelFormatGUIDs.WICPixelFormat64bppRGBA;
case PixelFormatEnum.Prgba64:
return WICPixelFormatGUIDs.WICPixelFormat64bppPRGBA;
case PixelFormatEnum.Gray16:
return WICPixelFormatGUIDs.WICPixelFormat16bppGray;
case PixelFormatEnum.Gray32Float:
return WICPixelFormatGUIDs.WICPixelFormat32bppGrayFloat;
case PixelFormatEnum.Rgb128Float:
return WICPixelFormatGUIDs.WICPixelFormat128bppRGBFloat;
case PixelFormatEnum.Rgba128Float:
return WICPixelFormatGUIDs.WICPixelFormat128bppRGBAFloat;
case PixelFormatEnum.Prgba128Float:
return WICPixelFormatGUIDs.WICPixelFormat128bppPRGBAFloat;
case PixelFormatEnum.Cmyk32:
return WICPixelFormatGUIDs.WICPixelFormat32bppCMYK;
}
throw new System.ArgumentException (SR.Get(SRID.Image_BadPixelFormat, format), "format");
}
private PixelFormatFlags FormatFlags
{
get
{
return m_flags;
}
}
///
/// op_equality - returns whether or not the two pixel formats are equal
///
public static bool operator == (PixelFormat left, PixelFormat right)
{
return (left.Guid == right.Guid);
}
///
/// op_inequality - returns whether or not the two pixel formats are not equal
///
public static bool operator != (PixelFormat left, PixelFormat right)
{
return (left.Guid != right.Guid);
}
///
/// Equals - Returns whether or not the two pixel formats are equal
///
public static bool Equals(PixelFormat left, PixelFormat right)
{
return (left.Guid == right.Guid);
}
///
/// Equals - Returns whether or not this is equal to the PixelFormat
///
public bool Equals(PixelFormat pixelFormat)
{
return this == pixelFormat;
}
///
/// Equals - Returns whether or not this is equal to the Object
///
public override bool Equals(Object obj)
{
if ((null == obj) ||
!(obj is PixelFormat))
{
return false;
}
return this == (PixelFormat)obj;
}
///
/// GetHashCode - Returns a hash code
///
public override int GetHashCode()
{
int hash = 0;
byte[] guidBytes = Guid.ToByteArray();
for (int i=0; i
/// The number of bits per pixel for this format.
///
///
/// Critical - Access unmanaged code
/// PublicOK - the pixel format info (an exsternal input) comes from a critical function which creates it based on the pixel format GUID
/// and has a TAS boundary tracking all setting of it.
/// LinkDemand - blocks information disclosure in partial trust scenario
///
public int BitsPerPixel
{
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
[SecurityCritical ]
get
{
return InternalBitsPerPixel;
}
}
///
/// The pixel format mask information for each channel.
///
///
/// Critical - Access unmanaged code
/// PublicOK - the pixel format info (an exsternal input) comes from a critical function which creates it based on the pixel format GUID
/// and has a TAS boundary tracking all setting of it.
/// LinkDemand - blocks information disclosure in partial trust scenario
///
public IList Masks
{
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
[SecurityCritical ]
get
{
IntPtr pixelFormatInfo = CreatePixelFormatInfo();
Debug.Assert(pixelFormatInfo != IntPtr.Zero);
UInt32 channelCount = 0;
PixelFormatChannelMask[] masks = null;
UInt32 cbBytes = 0;
try
{
HRESULT.Check(UnsafeNativeMethods.WICPixelFormatInfo.GetChannelCount(
pixelFormatInfo,
out channelCount
));
Debug.Assert(channelCount >= 1);
masks = new PixelFormatChannelMask[channelCount];
unsafe
{
for (uint i=0; i 0);
byte[] channelMask = new byte[cbBytes];
fixed (byte *pbChannelMask = channelMask)
{
HRESULT.Check(UnsafeNativeMethods.WICPixelFormatInfo.GetChannelMask(
pixelFormatInfo, i, cbBytes, pbChannelMask, out cbBytes));
Debug.Assert(cbBytes == channelMask.Length);
}
masks[i] = new PixelFormatChannelMask(channelMask);
}
}
}
finally
{
if (pixelFormatInfo != IntPtr.Zero)
{
UnsafeNativeMethods.MILUnknown.ReleaseInterface(ref pixelFormatInfo);
}
}
return new PartialList(masks);
}
}
///
/// Critical - Access unmanaged code
///
[SecurityCritical]
internal IntPtr CreatePixelFormatInfo()
{
IntPtr componentInfo = IntPtr.Zero;
IntPtr pixelFormatInfo = IntPtr.Zero;
using (FactoryMaker myFactory = new FactoryMaker())
{
try
{
Guid guidPixelFormat = this.Guid;
int hr = UnsafeNativeMethods.WICImagingFactory.CreateComponentInfo(
myFactory.ImagingFactoryPtr,
ref guidPixelFormat,
out componentInfo);
if (hr == (int)WinCodecErrors.WINCODEC_ERR_COMPONENTINITIALIZEFAILURE ||
hr == (int)WinCodecErrors.WINCODEC_ERR_COMPONENTNOTFOUND)
{
throw new System.NotSupportedException(SR.Get(SRID.Image_NoPixelFormatFound));
}
HRESULT.Check(hr);
Guid guidPixelFormatInfo = MILGuidData.IID_IWICPixelFormatInfo;
HRESULT.Check(UnsafeNativeMethods.MILUnknown.QueryInterface(
componentInfo,
ref guidPixelFormatInfo,
out pixelFormatInfo));
}
finally
{
if (componentInfo != IntPtr.Zero)
{
UnsafeNativeMethods.MILUnknown.ReleaseInterface(ref componentInfo);
}
}
}
return pixelFormatInfo;
}
///
/// Critical - Access unmanaged code
///
internal int InternalBitsPerPixel
{
[SecurityCritical]
get
{
if (m_bitsPerPixel == 0)
{
UInt32 bpp = 0;
IntPtr pixelFormatInfo = CreatePixelFormatInfo();
Debug.Assert(pixelFormatInfo != IntPtr.Zero);
try
{
HRESULT.Check(UnsafeNativeMethods.WICPixelFormatInfo.GetBitsPerPixel(
pixelFormatInfo,
out bpp
));
}
finally
{
if (pixelFormatInfo != IntPtr.Zero)
{
UnsafeNativeMethods.MILUnknown.ReleaseInterface(ref pixelFormatInfo);
}
}
m_bitsPerPixel = bpp;
}
return (int) m_bitsPerPixel;
}
}
internal bool HasAlpha
{
get
{
return ((FormatFlags & PixelFormatFlags.ChannelOrderABGR) != 0 ||
(FormatFlags & PixelFormatFlags.ChannelOrderARGB) != 0 ||
(FormatFlags & PixelFormatFlags.NChannelAlpha) != 0);
}
}
internal bool Palettized
{
get
{
return ((FormatFlags & PixelFormatFlags.Palettized) != 0);
}
}
internal PixelFormatEnum Format
{
get
{
return m_format;
}
}
internal Guid Guid
{
get
{
return m_guidFormat.Value;
}
}
///
/// Convert a PixelFormat to a string that represents it.
///
///
/// Critical - calls unmanaged code, accepts unmanaged handles as arguments
///
[SecurityCritical]
internal static PixelFormat GetPixelFormat (
SafeMILHandle /* IWICBitmapSource */ bitmapSource
)
{
Guid guidPixelFormat = WICPixelFormatGUIDs.WICPixelFormatDontCare;
HRESULT.Check(UnsafeNativeMethods.WICBitmapSource.GetPixelFormat(bitmapSource, out guidPixelFormat));
return new PixelFormat(guidPixelFormat);
}
///
/// Convert from the internal guid to the actual PixelFormat value.
///
///
///
/// Convert from the internal enum to the actual PixelFormat value.
///
///
/// m_guidFormat;
[NonSerialized]
private static readonly Guid WICPixelFormatPhotonFirst = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1d);
[NonSerialized]
private static readonly Guid WICPixelFormatPhotonLast = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x42);
}
#endregion // PixelFormat
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
// Microsoft Avalon
// Copyright (c) Microsoft Corporation, 2003
//
// File: PixelFormat.cs
//
//-----------------------------------------------------------------------------
#pragma warning disable 1634, 1691 // Allow suppression of certain presharp messages
using System;
using System.Security;
using System.Security.Permissions;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;
using MS.Internal;
using MS.Win32;
using System.Diagnostics;
using System.Windows.Media;
using System.Globalization;
using System.Runtime.InteropServices;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
using UnsafeNativeMethods=MS.Win32.PresentationCore.UnsafeNativeMethods;
namespace System.Windows.Media
{
[System.Flags]
internal enum PixelFormatFlags
{
BitsPerPixelMask = 0x00FF,
BitsPerPixelUndefined = 0,
BitsPerPixel1 = 1,
BitsPerPixel2 = 2,
BitsPerPixel4 = 4,
BitsPerPixel8 = 8,
BitsPerPixel16 = 16,
BitsPerPixel24 = 24,
BitsPerPixel32 = 32,
BitsPerPixel48 = 48,
BitsPerPixel64 = 64,
BitsPerPixel96 = 96,
BitsPerPixel128 = 128,
IsGray = 0x00000100, // Grayscale only
IsCMYK = 0x00000200, // CMYK, not ARGB
IsSRGB = 0x00000400, // Gamma is approximately 2.2
IsScRGB = 0x00000800, // Gamma is 1.0
Premultiplied = 0x00001000, // Premultiplied Alpha
ChannelOrderMask = 0x0001E000,
ChannelOrderRGB = 0x00002000,
ChannelOrderBGR = 0x00004000,
ChannelOrderARGB = 0x00008000,
ChannelOrderABGR = 0x00010000,
Palettized = 0x00020000, // Pixels are indexes into a palette
NChannelAlpha = 0x00040000, // N-Channel format with alpha
IsNChannel = 0x00080000, // N-Channel format
}
#region PixelFormat
///
/// Describes the bit mask and shift for a specific pixelformat
///
public struct PixelFormatChannelMask
{
internal PixelFormatChannelMask(byte[] mask)
{
Debug.Assert(mask != null);
m_mask = mask;
}
///
/// The bitmask for a color channel
/// It will never be greater then 0xffffffff
///
public IList Mask
{
get
{
return new PartialList((byte[]) m_mask.Clone());
}
}
///
/// op_equality - returns whether or not the two pixel format channel masks are equal
///
public static bool operator == (PixelFormatChannelMask left, PixelFormatChannelMask right)
{
Object o1 = left;
Object o2 = right;
if (o1 == null)
{
return (o2 == null);
}
else if (o2 == null)
{
return false;
}
else
{
#pragma warning disable 6506
return left.m_mask.Equals(right.m_mask);
#pragma warning restore 6506
}
}
///
/// Equals - Returns whether or not the two pixel format channel masks are equal
///
public static bool Equals(PixelFormatChannelMask left, PixelFormatChannelMask right)
{
Object o1 = left;
Object o2 = right;
if (o1 == null)
{
return (o2 == null);
}
else if (o2 == null)
{
return false;
}
else
{
#pragma warning disable 6506
return left.m_mask.Equals(right.m_mask);
#pragma warning restore 6506
}
}
///
/// op_inequality - returns whether or not the two pixel format channel masks are not equal
///
public static bool operator != (PixelFormatChannelMask left, PixelFormatChannelMask right)
{
return !(left == right);
}
///
/// Equals - Returns whether or not this is equal to the Object
///
public override bool Equals(Object obj)
{
if ((null == obj) ||
!(obj is PixelFormatChannelMask))
{
return false;
}
return this == (PixelFormatChannelMask)obj;
}
///
/// GetHashCode - Returns a hash code
///
public override int GetHashCode()
{
int hash = 0;
for (int i=0; i
/// Pixel Format Definition for images and pixel-based surfaces
///
[TypeConverter (typeof(PixelFormatConverter))]
[Serializable]
public struct PixelFormat : IEquatable
{
///
/// Critical - Accesses closely controlled format guid
///
[SecurityCritical]
internal PixelFormat(Guid guidPixelFormat)
{
bool fBuiltIn = true;
byte[] guidBytes = guidPixelFormat.ToByteArray();
byte[] guidBuiltIn = WICPixelFormatGUIDs.WICPixelFormatDontCare.ToByteArray();
// If it's a built-in format, identify the pixel format enum.
for (int i=0; i (byte)PixelFormatEnum.Cmyk32)
{
fBuiltIn = false;
}
if (fBuiltIn)
{
m_format = (PixelFormatEnum) guidBytes[guidBytes.Length-1];
}
else
{
m_format = PixelFormatEnum.Extended;
}
m_flags = GetPixelFormatFlagsFromEnum(m_format) | GetPixelFormatFlagsFromGuid(guidPixelFormat);
m_bitsPerPixel = GetBitsPerPixelFromEnum(m_format);
m_guidFormat = new SecurityCriticalDataForSet (guidPixelFormat);
}
///
/// Critical - Accesses closely controlled format guid
/// TreatAsSafe - The input (enum) is validated in setting the format guid
///
[SecurityCritical, SecurityTreatAsSafe]
internal PixelFormat(PixelFormatEnum format)
{
m_format = format;
m_flags = GetPixelFormatFlagsFromEnum(format);
m_bitsPerPixel = GetBitsPerPixelFromEnum(format);
m_guidFormat = new SecurityCriticalDataForSet (PixelFormat.GetGuidFromFormat(format));
}
///
/// Construct a pixel format from a string that represents the format.
/// The purpose of this method is only for deserialization of PixelFormat.
/// The preferred way to construct a PixelFormat is with the PixelFormats class.
///
///
///
/// Critical - Accesses closely controlled format guid
/// TreatAsSafe - The input (string) is validated in setting the format guid
///
[SecurityCritical, SecurityTreatAsSafe]
internal PixelFormat(string pixelFormatString)
{
PixelFormatEnum format = PixelFormatEnum.Default;
if (pixelFormatString == null)
{
throw new System.ArgumentNullException("pixelFormatString");
}
string upperPixelFormatString = pixelFormatString.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
switch (upperPixelFormatString)
{
case "DEFAULT":
format = PixelFormatEnum.Default;
break;
case "EXTENDED":
format = PixelFormatEnum.Extended;
break;
case "INDEXED1":
format = PixelFormatEnum.Indexed1;
break;
case "INDEXED2":
format = PixelFormatEnum.Indexed2;
break;
case "INDEXED4":
format = PixelFormatEnum.Indexed4;
break;
case "INDEXED8":
format = PixelFormatEnum.Indexed8;
break;
case "BLACKWHITE":
format = PixelFormatEnum.BlackWhite;
break;
case "GRAY2":
format = PixelFormatEnum.Gray2;
break;
case "GRAY4":
format = PixelFormatEnum.Gray4;
break;
case "GRAY8":
format = PixelFormatEnum.Gray8;
break;
case "BGR555":
format = PixelFormatEnum.Bgr555;
break;
case "BGR565":
format = PixelFormatEnum.Bgr565;
break;
case "BGR24":
format = PixelFormatEnum.Bgr24;
break;
case "RGB24":
format = PixelFormatEnum.Rgb24;
break;
case "BGR101010":
format = PixelFormatEnum.Bgr101010;
break;
case "BGR32":
format = PixelFormatEnum.Bgr32;
break;
case "BGRA32":
format = PixelFormatEnum.Bgra32;
break;
case "PBGRA32":
format = PixelFormatEnum.Pbgra32;
break;
case "RGB48":
format = PixelFormatEnum.Rgb48;
break;
case "RGBA64":
format = PixelFormatEnum.Rgba64;
break;
case "PRGBA64":
format = PixelFormatEnum.Prgba64;
break;
case "GRAY16":
format = PixelFormatEnum.Gray16;
break;
case "GRAY32FLOAT":
format = PixelFormatEnum.Gray32Float;
break;
case "RGB128FLOAT":
format = PixelFormatEnum.Rgb128Float;
break;
case "RGBA128FLOAT":
format = PixelFormatEnum.Rgba128Float;
break;
case "PRGBA128FLOAT":
format = PixelFormatEnum.Prgba128Float;
break;
case "CMYK32":
format = PixelFormatEnum.Cmyk32;
break;
default:
throw new System.ArgumentException (SR.Get(SRID.Image_BadPixelFormat, pixelFormatString),
"pixelFormatString");
}
m_format = format;
m_flags = GetPixelFormatFlagsFromEnum(format);
m_bitsPerPixel = GetBitsPerPixelFromEnum(format);
m_guidFormat = new SecurityCriticalDataForSet (PixelFormat.GetGuidFromFormat(format));
}
static private Guid GetGuidFromFormat(PixelFormatEnum format)
{
switch (format)
{
case PixelFormatEnum.Default:
return WICPixelFormatGUIDs.WICPixelFormatDontCare;
case PixelFormatEnum.Indexed1:
return WICPixelFormatGUIDs.WICPixelFormat1bppIndexed;
case PixelFormatEnum.Indexed2:
return WICPixelFormatGUIDs.WICPixelFormat2bppIndexed;
case PixelFormatEnum.Indexed4:
return WICPixelFormatGUIDs.WICPixelFormat4bppIndexed;
case PixelFormatEnum.Indexed8:
return WICPixelFormatGUIDs.WICPixelFormat8bppIndexed;
case PixelFormatEnum.BlackWhite:
return WICPixelFormatGUIDs.WICPixelFormatBlackWhite;
case PixelFormatEnum.Gray2:
return WICPixelFormatGUIDs.WICPixelFormat2bppGray;
case PixelFormatEnum.Gray4:
return WICPixelFormatGUIDs.WICPixelFormat4bppGray;
case PixelFormatEnum.Gray8:
return WICPixelFormatGUIDs.WICPixelFormat8bppGray;
case PixelFormatEnum.Bgr555:
return WICPixelFormatGUIDs.WICPixelFormat16bppBGR555;
case PixelFormatEnum.Bgr565:
return WICPixelFormatGUIDs.WICPixelFormat16bppBGR565;
case PixelFormatEnum.Bgr24:
return WICPixelFormatGUIDs.WICPixelFormat24bppBGR;
case PixelFormatEnum.Rgb24:
return WICPixelFormatGUIDs.WICPixelFormat24bppRGB;
case PixelFormatEnum.Bgr101010:
return WICPixelFormatGUIDs.WICPixelFormat32bppBGR101010;
case PixelFormatEnum.Bgr32:
return WICPixelFormatGUIDs.WICPixelFormat32bppBGR;
case PixelFormatEnum.Bgra32:
return WICPixelFormatGUIDs.WICPixelFormat32bppBGRA;
case PixelFormatEnum.Pbgra32:
return WICPixelFormatGUIDs.WICPixelFormat32bppPBGRA;
case PixelFormatEnum.Rgb48:
return WICPixelFormatGUIDs.WICPixelFormat48bppRGB;
case PixelFormatEnum.Rgba64:
return WICPixelFormatGUIDs.WICPixelFormat64bppRGBA;
case PixelFormatEnum.Prgba64:
return WICPixelFormatGUIDs.WICPixelFormat64bppPRGBA;
case PixelFormatEnum.Gray16:
return WICPixelFormatGUIDs.WICPixelFormat16bppGray;
case PixelFormatEnum.Gray32Float:
return WICPixelFormatGUIDs.WICPixelFormat32bppGrayFloat;
case PixelFormatEnum.Rgb128Float:
return WICPixelFormatGUIDs.WICPixelFormat128bppRGBFloat;
case PixelFormatEnum.Rgba128Float:
return WICPixelFormatGUIDs.WICPixelFormat128bppRGBAFloat;
case PixelFormatEnum.Prgba128Float:
return WICPixelFormatGUIDs.WICPixelFormat128bppPRGBAFloat;
case PixelFormatEnum.Cmyk32:
return WICPixelFormatGUIDs.WICPixelFormat32bppCMYK;
}
throw new System.ArgumentException (SR.Get(SRID.Image_BadPixelFormat, format), "format");
}
private PixelFormatFlags FormatFlags
{
get
{
return m_flags;
}
}
///
/// op_equality - returns whether or not the two pixel formats are equal
///
public static bool operator == (PixelFormat left, PixelFormat right)
{
return (left.Guid == right.Guid);
}
///
/// op_inequality - returns whether or not the two pixel formats are not equal
///
public static bool operator != (PixelFormat left, PixelFormat right)
{
return (left.Guid != right.Guid);
}
///
/// Equals - Returns whether or not the two pixel formats are equal
///
public static bool Equals(PixelFormat left, PixelFormat right)
{
return (left.Guid == right.Guid);
}
///
/// Equals - Returns whether or not this is equal to the PixelFormat
///
public bool Equals(PixelFormat pixelFormat)
{
return this == pixelFormat;
}
///
/// Equals - Returns whether or not this is equal to the Object
///
public override bool Equals(Object obj)
{
if ((null == obj) ||
!(obj is PixelFormat))
{
return false;
}
return this == (PixelFormat)obj;
}
///
/// GetHashCode - Returns a hash code
///
public override int GetHashCode()
{
int hash = 0;
byte[] guidBytes = Guid.ToByteArray();
for (int i=0; i
/// The number of bits per pixel for this format.
///
///
/// Critical - Access unmanaged code
/// PublicOK - the pixel format info (an exsternal input) comes from a critical function which creates it based on the pixel format GUID
/// and has a TAS boundary tracking all setting of it.
/// LinkDemand - blocks information disclosure in partial trust scenario
///
public int BitsPerPixel
{
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
[SecurityCritical ]
get
{
return InternalBitsPerPixel;
}
}
///
/// The pixel format mask information for each channel.
///
///
/// Critical - Access unmanaged code
/// PublicOK - the pixel format info (an exsternal input) comes from a critical function which creates it based on the pixel format GUID
/// and has a TAS boundary tracking all setting of it.
/// LinkDemand - blocks information disclosure in partial trust scenario
///
public IList Masks
{
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
[SecurityCritical ]
get
{
IntPtr pixelFormatInfo = CreatePixelFormatInfo();
Debug.Assert(pixelFormatInfo != IntPtr.Zero);
UInt32 channelCount = 0;
PixelFormatChannelMask[] masks = null;
UInt32 cbBytes = 0;
try
{
HRESULT.Check(UnsafeNativeMethods.WICPixelFormatInfo.GetChannelCount(
pixelFormatInfo,
out channelCount
));
Debug.Assert(channelCount >= 1);
masks = new PixelFormatChannelMask[channelCount];
unsafe
{
for (uint i=0; i 0);
byte[] channelMask = new byte[cbBytes];
fixed (byte *pbChannelMask = channelMask)
{
HRESULT.Check(UnsafeNativeMethods.WICPixelFormatInfo.GetChannelMask(
pixelFormatInfo, i, cbBytes, pbChannelMask, out cbBytes));
Debug.Assert(cbBytes == channelMask.Length);
}
masks[i] = new PixelFormatChannelMask(channelMask);
}
}
}
finally
{
if (pixelFormatInfo != IntPtr.Zero)
{
UnsafeNativeMethods.MILUnknown.ReleaseInterface(ref pixelFormatInfo);
}
}
return new PartialList(masks);
}
}
///
/// Critical - Access unmanaged code
///
[SecurityCritical]
internal IntPtr CreatePixelFormatInfo()
{
IntPtr componentInfo = IntPtr.Zero;
IntPtr pixelFormatInfo = IntPtr.Zero;
using (FactoryMaker myFactory = new FactoryMaker())
{
try
{
Guid guidPixelFormat = this.Guid;
int hr = UnsafeNativeMethods.WICImagingFactory.CreateComponentInfo(
myFactory.ImagingFactoryPtr,
ref guidPixelFormat,
out componentInfo);
if (hr == (int)WinCodecErrors.WINCODEC_ERR_COMPONENTINITIALIZEFAILURE ||
hr == (int)WinCodecErrors.WINCODEC_ERR_COMPONENTNOTFOUND)
{
throw new System.NotSupportedException(SR.Get(SRID.Image_NoPixelFormatFound));
}
HRESULT.Check(hr);
Guid guidPixelFormatInfo = MILGuidData.IID_IWICPixelFormatInfo;
HRESULT.Check(UnsafeNativeMethods.MILUnknown.QueryInterface(
componentInfo,
ref guidPixelFormatInfo,
out pixelFormatInfo));
}
finally
{
if (componentInfo != IntPtr.Zero)
{
UnsafeNativeMethods.MILUnknown.ReleaseInterface(ref componentInfo);
}
}
}
return pixelFormatInfo;
}
///
/// Critical - Access unmanaged code
///
internal int InternalBitsPerPixel
{
[SecurityCritical]
get
{
if (m_bitsPerPixel == 0)
{
UInt32 bpp = 0;
IntPtr pixelFormatInfo = CreatePixelFormatInfo();
Debug.Assert(pixelFormatInfo != IntPtr.Zero);
try
{
HRESULT.Check(UnsafeNativeMethods.WICPixelFormatInfo.GetBitsPerPixel(
pixelFormatInfo,
out bpp
));
}
finally
{
if (pixelFormatInfo != IntPtr.Zero)
{
UnsafeNativeMethods.MILUnknown.ReleaseInterface(ref pixelFormatInfo);
}
}
m_bitsPerPixel = bpp;
}
return (int) m_bitsPerPixel;
}
}
internal bool HasAlpha
{
get
{
return ((FormatFlags & PixelFormatFlags.ChannelOrderABGR) != 0 ||
(FormatFlags & PixelFormatFlags.ChannelOrderARGB) != 0 ||
(FormatFlags & PixelFormatFlags.NChannelAlpha) != 0);
}
}
internal bool Palettized
{
get
{
return ((FormatFlags & PixelFormatFlags.Palettized) != 0);
}
}
internal PixelFormatEnum Format
{
get
{
return m_format;
}
}
internal Guid Guid
{
get
{
return m_guidFormat.Value;
}
}
///
/// Convert a PixelFormat to a string that represents it.
///
///
/// Critical - calls unmanaged code, accepts unmanaged handles as arguments
///
[SecurityCritical]
internal static PixelFormat GetPixelFormat (
SafeMILHandle /* IWICBitmapSource */ bitmapSource
)
{
Guid guidPixelFormat = WICPixelFormatGUIDs.WICPixelFormatDontCare;
HRESULT.Check(UnsafeNativeMethods.WICBitmapSource.GetPixelFormat(bitmapSource, out guidPixelFormat));
return new PixelFormat(guidPixelFormat);
}
///
/// Convert from the internal guid to the actual PixelFormat value.
///
///
///
/// Convert from the internal enum to the actual PixelFormat value.
///
///
/// m_guidFormat;
[NonSerialized]
private static readonly Guid WICPixelFormatPhotonFirst = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1d);
[NonSerialized]
private static readonly Guid WICPixelFormatPhotonLast = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x42);
}
#endregion // PixelFormat
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- BamlResourceContent.cs
- XmlReader.cs
- SafeCryptoHandles.cs
- Converter.cs
- EntityContainerEntitySet.cs
- ScrollChangedEventArgs.cs
- UserMapPath.cs
- AuthenticatedStream.cs
- WeakEventTable.cs
- WSHttpBindingCollectionElement.cs
- DataRecordInternal.cs
- WebPartZoneCollection.cs
- PatternMatchRules.cs
- Preprocessor.cs
- ExpressionParser.cs
- WinEventWrap.cs
- StringValidator.cs
- Msmq4SubqueuePoisonHandler.cs
- ConfigurationLockCollection.cs
- ReaderOutput.cs
- WebResourceUtil.cs
- Pair.cs
- ObjectDataSourceDisposingEventArgs.cs
- DataGridViewBand.cs
- SystemUnicastIPAddressInformation.cs
- PageCodeDomTreeGenerator.cs
- XmlEntity.cs
- MsdtcWrapper.cs
- LoadedEvent.cs
- AudioLevelUpdatedEventArgs.cs
- Point3D.cs
- SqlDataSourceCache.cs
- SqlAliasesReferenced.cs
- SoapAttributeAttribute.cs
- RepeaterCommandEventArgs.cs
- ObjRef.cs
- CodeIdentifier.cs
- SqlDependency.cs
- GcHandle.cs
- X509Certificate.cs
- GeneralTransformGroup.cs
- WriteLineDesigner.xaml.cs
- CellLabel.cs
- OleDbDataReader.cs
- PagesSection.cs
- ProcessHostFactoryHelper.cs
- SqlRewriteScalarSubqueries.cs
- InputProcessorProfiles.cs
- Stacktrace.cs
- MailWebEventProvider.cs
- TableItemProviderWrapper.cs
- UnhandledExceptionEventArgs.cs
- RowType.cs
- CursorInteropHelper.cs
- HtmlValidatorAdapter.cs
- XmlBufferedByteStreamReader.cs
- WmlCommandAdapter.cs
- HtmlWindow.cs
- DoubleLinkListEnumerator.cs
- AbandonedMutexException.cs
- DecoratedNameAttribute.cs
- CodeAttributeDeclarationCollection.cs
- ControlBuilder.cs
- PropertyItemInternal.cs
- InkCanvasInnerCanvas.cs
- TransformGroup.cs
- StringOutput.cs
- ProjectionRewriter.cs
- ExtensibleClassFactory.cs
- Add.cs
- ToolboxItemAttribute.cs
- XmlWellformedWriter.cs
- SeverityFilter.cs
- Message.cs
- BaseComponentEditor.cs
- Cursors.cs
- UserUseLicenseDictionaryLoader.cs
- EntityViewGenerationAttribute.cs
- XmlQualifiedNameTest.cs
- SafeFileHandle.cs
- RsaSecurityTokenAuthenticator.cs
- mediaeventshelper.cs
- XmlUrlResolver.cs
- HttpListenerResponse.cs
- Tracer.cs
- UnaryQueryOperator.cs
- EndPoint.cs
- FilteredReadOnlyMetadataCollection.cs
- XmlSignatureProperties.cs
- mediaeventargs.cs
- WhiteSpaceTrimStringConverter.cs
- SelfIssuedAuthAsymmetricKey.cs
- MobileUserControl.cs
- PolyQuadraticBezierSegment.cs
- SecurityKeyIdentifierClause.cs
- LookupNode.cs
- RelationshipDetailsRow.cs
- HttpCapabilitiesBase.cs
- DebugView.cs
- LambdaCompiler.Expressions.cs