protected LeveledColor(
ColorSpace colorSpace,
PdfDirectObject baseObject
)
: base(colorSpace, baseObject)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderTarget" /> class.
/// </summary>
/// <param name="buffers">The render target buffers.</param>
/// <param name="colorSpace">The render target color space.</param>
/// <param name="sampling">The render target buffer sampling options.</param>
public RenderTarget(TargetBuffers buffers = TargetBuffers.Color0, ColorSpace colorSpace = ColorSpace.Linear, Sampling sampling = Sampling.None)
{
if (buffers == TargetBuffers.None)
{
throw new ArgumentException("Render target must have at least one buffer.", nameof(buffers));
}
if ((buffers & TargetBuffers.Color0) == TargetBuffers.Color0)
{
this.Color0 = new Texture2D(null, colorSpace, sampling);
}
if ((buffers & TargetBuffers.Color1) == TargetBuffers.Color1)
{
this.Color1 = new Texture2D(null, colorSpace, sampling);
}
if ((buffers & TargetBuffers.Color2) == TargetBuffers.Color2)
{
this.Color2 = new Texture2D(null, colorSpace, sampling);
}
if ((buffers & TargetBuffers.Color3) == TargetBuffers.Color3)
{
this.Color3 = new Texture2D(null, colorSpace, sampling);
}
if ((buffers & TargetBuffers.DepthStencil) == TargetBuffers.DepthStencil)
{
this.DepthStencil = new Texture2D(null, ColorSpace.sRGB, sampling & ~Sampling.Mipmap);
}
}
/// <summary>
/// Converts the colorspace of an image (in-place)
/// </summary>
/// <param name="cs">Colorspace to convert into</param>
/// <returns>Self</returns>
public Image ChangeColorSpace(ColorSpace cs) {
// Colorspace is already correct
if (_cm.colorspace == cs) return this;
byte[] ycbcr = new byte[3];
byte[] rgb = new byte[3];
if (_cm.colorspace == ColorSpace.RGB && cs == ColorSpace.YCbCr) {
/*
* Y' = + 0.299 * R'd + 0.587 * G'd + 0.114 * B'd
Cb = 128 - 0.168736 * R'd - 0.331264 * G'd + 0.5 * B'd
Cr = 128 + 0.5 * R'd - 0.418688 * G'd - 0.081312 * B'd
*
*/
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++) {
YCbCr.fromRGB(ref _raster[0][x, y], ref _raster[1][x, y], ref _raster[2][x, y]);
}
_cm.colorspace = ColorSpace.YCbCr;
} else if (_cm.colorspace == ColorSpace.YCbCr && cs == ColorSpace.RGB) {
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++) {
// 0 is LUMA
// 1 is BLUE
// 2 is RED
YCbCr.toRGB(ref _raster[0][x, y], ref _raster[1][x, y], ref _raster[2][x, y]);
}
_cm.colorspace = ColorSpace.RGB;
} else if (_cm.colorspace == ColorSpace.Gray && cs == ColorSpace.YCbCr) {
// To convert to YCbCr, we just add two 128-filled chroma channels
byte[,] Cb = new byte[width, height];
byte[,] Cr = new byte[width, height];
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++) {
Cb[x, y] = 128; Cr[x, y] = 128;
}
_raster = new byte[][,] { _raster[0], Cb, Cr };
_cm.colorspace = ColorSpace.YCbCr;
} else if (_cm.colorspace == ColorSpace.Gray && cs == ColorSpace.RGB) {
ChangeColorSpace(ColorSpace.YCbCr);
ChangeColorSpace(ColorSpace.RGB);
} else {
throw new Exception("Colorspace conversion not supported.");
}
return this;
}
internal static ColorRecord Load(ColorBookReader reader, ColorSpace colorSpace)
{
ColorRecord color = new ColorRecord();
color.Name = StringUtil.ReadValue(reader.ReadString());
color.Code = Encoding.ASCII.GetString(reader.ReadBytes(6));
color.Components = BaseColorComponent.LoadComponents(reader, colorSpace);
return color;
}
/// <summary>
/// Converts the color from a particualr color space to the specified <see cref="ColorSpace"/>.
/// </summary>
/// <param name="color">The color.</param>
/// <param name="sourceColorSpace">The color space of this instance.</param>
/// <param name="colorSpace">The color space.</param>
/// <returns>The color converted to the specified color space.</returns>
public static Color3 ToColorSpace(this Color3 color, ColorSpace sourceColorSpace, ColorSpace colorSpace)
{
// Nothing to do?
if (sourceColorSpace == colorSpace)
{
return color;
}
return sourceColorSpace == ColorSpace.Gamma ? color.ToLinear() : color.ToSRgb();
}
/// <summary>
/// Initializes a new instance of the <see cref="PortableDocumentImage" /> class.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="bitsPerComponent">The number of bits per component.</param>
/// <param name="bits">The bits.</param>
/// <param name="maskBits">The bits of the mask.</param>
/// <param name="interpolate">Interpolate if set to <c>true</c>.</param>
/// <param name="colorSpace">The color space.</param>
public PortableDocumentImage(int width, int height, int bitsPerComponent, byte[] bits, byte[] maskBits = null, bool interpolate = true, ColorSpace colorSpace = ColorSpace.DeviceRGB)
{
this.Width = width;
this.Height = height;
this.BitsPerComponent = bitsPerComponent;
this.ColorSpace = colorSpace;
this.Bits = bits;
this.MaskBits = maskBits;
this.Interpolate = interpolate;
this.ColorSpace = ColorSpace.DeviceRGB;
}
/// <summary>
/// Initializes a new instance of the <see cref="Texture2D" /> class.
/// </summary>
/// <param name="path">The source file path.</param>
/// <param name="colorSpace">The source image color space.</param>
/// <param name="sampling">The sampling options.</param>
public Texture2D(string path, ColorSpace colorSpace, Sampling sampling = Sampling.None) : base(GL.TEXTURE_2D, colorSpace, sampling)
{
this.Image = new TextureImage(this, GL.TEXTURE_2D);
if (path != null)
{
this.Ready = this.Load(path);
}
else
{
this.Ready = Task.CompletedTask;
}
}
internal static IColorComponents LoadComponents(ColorBookReader reader, ColorSpace colorSpace)
{
switch (colorSpace) {
case ColorSpace.RGB:
return ComponentRGB.Load(reader);
case ColorSpace.CMYK:
return ComponentCMYK.Load(reader);
case ColorSpace.Lab:
return ComponentLab.Load(reader);
default:
throw new NotSupportedException();
}
}
public static ColorSpace ToColorSpace(this TextureColorSpace textureColorSpace, ColorSpace colorSpaceReference, TextureHint textureHint)
{
var colorSpace = colorSpaceReference;
if (textureHint == TextureHint.Color)
{
if (textureColorSpace == TextureColorSpace.Linear)
{
colorSpace = ColorSpace.Linear;
}
else if (textureColorSpace == TextureColorSpace.Gamma)
{
colorSpace = ColorSpace.Gamma;
}
}
return colorSpace;
}
public TextStyle(
Font font,
double fontSize,
TextRenderModeEnum renderMode,
Color strokeColor,
ColorSpace strokeColorSpace,
Color fillColor,
ColorSpace fillColorSpace
)
{
this.font = font;
this.fontSize = fontSize;
this.renderMode = renderMode;
this.strokeColor = strokeColor;
this.strokeColorSpace = strokeColorSpace;
this.fillColor = fillColor;
this.fillColorSpace = fillColorSpace;
}
public ColorLocation(byte r, byte g, byte b, ColorSpace cs)
{
R = r;
G = g;
B = b;
switch (cs) {
case ColorSpace.RGB:
setLocationAsRGB();
break;
case ColorSpace.HSL:
setLocationAsHSL();
break;
case ColorSpace.HSV:
setLocationAsHSV();
break;
}
}
public override RenderFrame GetRenderFrame(RenderContext context)
{
// Get the relative frame
var relativeFrame = context.Tags.Get(RelativeSizeSource == RenderFrameRelativeMode.Current ? RenderFrame.Current : SceneGraphicsLayer.Master);
// Check if we need to resize it
if (currentFrame != null && (currentFrame.Descriptor != Descriptor || currentFrame.CheckIfResizeRequired(relativeFrame) || Descriptor.Format == RenderFrameFormat.LDR && colorSpace != context.GraphicsDevice.ColorSpace))
{
Dispose();
}
// Store the colorSpace
colorSpace = context.GraphicsDevice.ColorSpace;
// Allocate the render frame if necessary
// TODO: Should we use allocated shared textures from RenderContext?
return currentFrame ?? (currentFrame = RenderFrame.New(context.GraphicsDevice, Descriptor, relativeFrame));
}
/// <summary>
/// Initializes a new instance of the <see cref="TextureCube" /> class.
/// </summary>
/// <param name="path">The asset file path.</param>
/// <param name="colorSpace">The source image color space.</param>
/// <param name="sampling">The sampling options.</param>
public TextureCube(string path, ColorSpace colorSpace, Sampling sampling = Sampling.None) : base(GL.TEXTURE_CUBE_MAP, colorSpace, sampling)
{
this.PositiveX = new TextureImage(this, GL.TEXTURE_CUBE_MAP_POSITIVE_X);
this.PositiveY = new TextureImage(this, GL.TEXTURE_CUBE_MAP_POSITIVE_Y);
this.PositiveZ = new TextureImage(this, GL.TEXTURE_CUBE_MAP_POSITIVE_Z);
this.NegativeX = new TextureImage(this, GL.TEXTURE_CUBE_MAP_NEGATIVE_X);
this.NegativeY = new TextureImage(this, GL.TEXTURE_CUBE_MAP_NEGATIVE_Y);
this.NegativeZ = new TextureImage(this, GL.TEXTURE_CUBE_MAP_NEGATIVE_Z);
if (path != null)
{
this.Ready = this.Load(path);
}
else
{
this.Ready = Task.CompletedTask;
}
}
public ColorLocation(byte r, byte g, byte b, ColorSpace cs)
{
R = r;
G = g;
B = b;
switch (cs)
{
case ColorSpace.RGB:
setLocationAsRGB();
break;
case ColorSpace.HSL:
setLocationAsHSL();
break;
case ColorSpace.HSV:
setLocationAsHSV();
break;
}
}
public void SetColorSpace(ColorSpace value)
{
#if PLATFORM_AnyCPU
if (OperatingSystem.IsArm64)
#endif
#if PLATFORM_arm64 || PLATFORM_AnyCPU
NativeMethods.ARM64.QuantizeSettings_SetColorSpace(Instance, (UIntPtr)value);
#endif
#if PLATFORM_AnyCPU
else if (OperatingSystem.Is64Bit)
#endif
#if PLATFORM_x64 || PLATFORM_AnyCPU
NativeMethods.X64.QuantizeSettings_SetColorSpace(Instance, (UIntPtr)value);
#endif
#if PLATFORM_AnyCPU
else
#endif
#if PLATFORM_x86 || PLATFORM_AnyCPU
NativeMethods.X86.QuantizeSettings_SetColorSpace(Instance, (UIntPtr)value);
#endif
}
public PreviewRenderUtility()
{
m_PreviewScene = new PreviewScene("Preview Scene");
var l0 = CreateLight();
previewScene.AddGameObject(l0);
Light0 = l0.GetComponent <Light>();
var l1 = CreateLight();
previewScene.AddGameObject(l1);
Light1 = l1.GetComponent <Light>();
Light0.color = SceneView.kSceneViewFrontLight;
Light1.transform.rotation = Quaternion.Euler(340, 218, 177);
Light1.color = new Color(.4f, .4f, .45f, 0f) * .7f;
m_PixelPerfect = false;
// Set a default background color
defaultBackgroundColor = new Color(49.0f / 255.0f, 49.0f / 255.0f, 49.0f / 255.0f, 1.0f);
colorSpace = QualitySettings.activeColorSpace;
camera.backgroundColor = colorSpace == ColorSpace.Gamma ? defaultBackgroundColor : defaultBackgroundColor.linear;
if (Unsupported.IsDeveloperMode())
{
var stackTrace = new StackTrace();
for (int i = 0; i < stackTrace.FrameCount; i++)
{
var frame = stackTrace.GetFrame(i);
var type = frame.GetMethod().DeclaringType;
if (type != null && (type.IsSubclassOf(typeof(Editor)) || type.IsSubclassOf(typeof(EditorWindow))))
{
m_Type = type.Name;
break;
}
}
}
}
public static Dictionary <string, string> CollectReferenceImagePathsFor(ColorSpace colorSpace, RuntimePlatform runtimePlatform,
GraphicsDeviceType graphicsApi)
{
var result = new Dictionary <string, string>();
if (!Directory.Exists(ReferenceImagesRoot))
{
return(result);
}
var fullPathPrefix = string.Format("{0}/{1}/{2}/{3}/", ReferenceImagesRoot, colorSpace, runtimePlatform, graphicsApi);
foreach (var assetPath in AssetDatabase.GetAllAssetPaths()
.Where(p => p.StartsWith(ReferenceImagesRoot, StringComparison.OrdinalIgnoreCase))
.Where(p => fullPathPrefix.StartsWith(Path.GetDirectoryName(p)))
.OrderBy(p => p.Count(ch => ch == '/')))
{
// Skip directories
if (!File.Exists(assetPath))
{
continue;
}
var fileName = Path.GetFileNameWithoutExtension(assetPath);
if (fileName == null)
{
continue;
}
var texture = AssetDatabase.LoadAssetAtPath <Texture2D>(assetPath);
if (!texture)
{
continue;
}
result[fileName] = assetPath;
}
return(result);
}
public void PDFColorConstructor_Test()
{
ColorSpace cs = ColorSpace.RGB;
Color c = Color.Red;
PDFColor target = new PDFColor(cs, c);
Assert.AreEqual(c, target.Color);
Assert.AreEqual(cs, target.ColorSpace);
Assert.AreEqual(1.0, Math.Round(target.Red.Value, 2));
Assert.AreEqual(0.0, Math.Round(target.Green.Value, 2));
Assert.AreEqual(0.0, Math.Round(target.Blue.Value, 2));
cs = ColorSpace.G;
c = Color.Gray;
target = new PDFColor(cs, c);
Assert.AreEqual(cs, target.ColorSpace);
Assert.AreEqual(c, target.Color);
try
{
target = new PDFColor(ColorSpace.LAB, c);
Assert.Fail("LAB colour space is not supported");
}
catch (ArgumentException)
{
TestContext.WriteLine("Successfully caught the exception for the HSL Color space");
}
try
{
target = new PDFColor(ColorSpace.Custom, c);
Assert.Fail("Custom colour space is not supported");
}
catch (ArgumentException)
{
TestContext.WriteLine("Successfully caught the exception for the HSL Color space");
}
}
private void ConfigureTargetTexture(int width, int height)
{
bool flag = false;
if (this.m_TargetTexture && this.m_CurrentColorSpace != QualitySettings.activeColorSpace)
{
UnityEngine.Object.DestroyImmediate(this.m_TargetTexture);
}
if (!this.m_TargetTexture)
{
this.m_CurrentColorSpace = QualitySettings.activeColorSpace;
this.m_TargetTexture = new RenderTexture(0, 0, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default);
this.m_TargetTexture.name = "GameView RT";
this.m_TargetTexture.filterMode = FilterMode.Point;
this.m_TargetTexture.hideFlags = HideFlags.HideAndDontSave;
}
int num = Mathf.Max(1, QualitySettings.antiAliasing);
if (this.m_TargetTexture.width != width || this.m_TargetTexture.height != height || this.m_TargetTexture.antiAliasing != num)
{
this.m_TargetTexture.Release();
this.m_TargetTexture.width = width;
this.m_TargetTexture.height = height;
this.m_TargetTexture.antiAliasing = num;
flag = true;
if (this.m_TargetClamped)
{
Debug.LogWarningFormat("GameView reduced to a reasonable size for this system ({0}x{1})", new object[]
{
width,
height
});
}
}
this.m_TargetTexture.Create();
if (flag)
{
this.ClearTargetTexture();
}
}
internal static ImageColorSpace ToImageColorSpace(this ColorSpace colorSpace)
{
ValidationUtil.ValidateEnum(typeof(ColorSpace), colorSpace, nameof(colorSpace));
switch (colorSpace)
{
case ColorSpace.YV12: return(ImageColorSpace.YV12);
case ColorSpace.Uyvy: return(ImageColorSpace.Uyvy);
case ColorSpace.Yuyv: return(ImageColorSpace.Yuyv);
case ColorSpace.Yuv422: return(ImageColorSpace.Yuv422);
case ColorSpace.I420: return(ImageColorSpace.I420);
case ColorSpace.Rgb565: return(ImageColorSpace.Rgb565);
case ColorSpace.Rgb888: return(ImageColorSpace.Rgb888);
case ColorSpace.Argb8888: return(ImageColorSpace.Argb8888);
case ColorSpace.Bgra8888: return(ImageColorSpace.Bgra8888);
case ColorSpace.Rgba8888: return(ImageColorSpace.Rgba8888);
case ColorSpace.Bgrx8888: return(ImageColorSpace.Bgrx8888);
case ColorSpace.NV12: return(ImageColorSpace.NV12);
case ColorSpace.NV16: return(ImageColorSpace.NV16);
case ColorSpace.NV21: return(ImageColorSpace.NV21);
case ColorSpace.NV61: return(ImageColorSpace.NV61);
}
throw new NotSupportedException($"The ColorSpace.{colorSpace.ToString()} is not supported.");
}
private void ConfigureTargetTexture(int width, int height)
{
var clearTexture = false;
// Changing color space requires destroying the entire RT object and recreating it
if (m_TargetTexture && m_CurrentColorSpace != QualitySettings.activeColorSpace)
{
DestroyImmediate(m_TargetTexture);
}
if (!m_TargetTexture)
{
m_CurrentColorSpace = QualitySettings.activeColorSpace;
m_TargetTexture = new RenderTexture(0, 0, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
m_TargetTexture.name = "GameView RT";
m_TargetTexture.filterMode = FilterMode.Point;
m_TargetTexture.hideFlags = HideFlags.HideAndDontSave;
}
// Changes to these attributes require a release of the texture
if (m_TargetTexture.width != width || m_TargetTexture.height != height)
{
m_TargetTexture.Release();
m_TargetTexture.width = width;
m_TargetTexture.height = height;
m_TargetTexture.antiAliasing = 1;
clearTexture = true;
if (m_TargetClamped)
{
Debug.LogWarningFormat("GameView reduced to a reasonable size for this system ({0}x{1})", width, height);
}
}
m_TargetTexture.Create();
if (clearTexture)
{
ClearTargetTexture();
}
}
public void SetColorSpace(ColorSpace colorSpace)
{
if (handle == Types.INVALID_HANDLE)
{
return;
}
int val = 0;
switch (colorSpace)
{
case ColorSpace.Gamma:
val = HvrPlayerInterfaceAPI.COLOUR_SPACE_GAMMA;
break;
case ColorSpace.Linear:
val = HvrPlayerInterfaceAPI.COLOUR_SPACE_LINEAR;
break;
}
HvrPlayerInterfaceAPI.Viewport_SetColourSpace(handle, val);
}
public void Reset()
{
bool disposed = this.disposed;
if (disposed)
{
UIRAtlasManager.LogDisposeError();
}
else
{
UIRAtlasManager.s_MarkerReset.Begin();
this.m_Blitter.Reset();
this.m_UVs.Clear();
this.m_Allocator = new UIRAtlasAllocator(this.m_InitialSize, 4096, this.m_1SidePadding);
this.m_ForceReblitAll = false;
this.m_ColorSpace = QualitySettings.activeColorSpace;
UIRUtility.Destroy(this.atlas);
this.atlas = null;
UIRAtlasManager.s_MarkerReset.End();
this.m_ResetVersion = UIRAtlasManager.s_GlobalResetVersion;
}
}
public static ColorProfile GetProfile(ColorManagement colorManagement, ColorSpace colorSpace, bool isPreview = false)
{
if (colorManagement == null)
{
return(null);
}
switch (colorSpace)
{
case ColorSpace.Cmyk:
return(colorManagement.CmykColorProfile);
case ColorSpace.Grayscale:
return(colorManagement.GrayscaleColorProfile);
case ColorSpace.Rgb:
return(isPreview ? GetSrgbProfile() : colorManagement.RgbColorProfile);
default:
return(null);
}
}
public CWatcher(
CWatchImage[] cWatchImages,
string name,
WatcherType watcherType,
ColorSpace colorSpace,
int channel,
bool equalize,
ErrorMetric errorMetric
)
{
Name = name;
WatcherType = watcherType;
ColorSpace = colorSpace;
Channel = channel;
Equalize = equalize;
ErrorMetric = errorMetric;
CWatchImages = cWatchImages;
IsStandardCheck = WatcherType.Equals(WatcherType.Standard);
IsDuplicateFrameCheck = WatcherType.Equals(WatcherType.DuplicateFrame);
IsBestMatchCheck = WatcherType.Equals(WatcherType.BestMatch);
}
public static void CreatePageImageBasedOnPhysicalSize(Page pg, string filename, ImageType imgtype,
ColorSpace cspace)
{
// Get the dimensions, in pixels, of an image that is
// half the physical size of the page at a resolution of 96 DPI.
// The dimensions will be stored in the PixelWidth and
// PixelHeight fields of the PageImageParams object.
double scalefactor = 0.5;
double resolution = 96.0;
PageImageParams pip = ScalePage(pg, scalefactor, resolution);
pip.PageDrawFlags = DrawFlags.UseAnnotFaces;
pip.ImageColorSpace = cspace;
// Create the image and save it to a file.
// We want to create an image of the entire page, so we'll use the
// page's CropBox as the exportRect.
Image img = pg.GetImage(pg.CropBox, pip);
img.Save(filename, imgtype);
Console.WriteLine("Created " + filename + "...");
}
public bool Reload()
{
var result = false;
try
{
if (ValidOriginal)
{
if (ValidCurrent)
{
Current.Dispose(); Current = null;
}
ResetTransform();
Current = new MagickImage(Original);
Modified = true;
_last_colorspace_ = Current.ColorSpace;
result = true;
}
}
catch (Exception ex) { ex.ShowMessage(); }
return(result);
}
private async void GameSettingsChanged(object sender, GameSettingsChangedEventArgs e)
{
// Remark: we assume that GameStudioDatabase has already updated the compiler game settings,
// which is the case because this service is registered before the creation of this EditorContentLoader
if (e.GameSettings.GetOrCreate <RenderingSettings>().ColorSpace != currentColorSpace || e.GameSettings.GetOrCreate <EditorSettings>().RenderingMode != currentRenderingMode)
{
currentRenderingMode = e.GameSettings.GetOrCreate <EditorSettings>().RenderingMode;
currentColorSpace = e.GameSettings.GetOrCreate <RenderingSettings>().ColorSpace;
await BuildAndReloadAssets(Asset.Dependencies.ReferencedAssets.Select(x => x.AssetItem));
}
// Update navigation meshes that are previewed inside the current scene when the game settings's group settings for navigation meshes change
var navigationGroupsHash = e.GameSettings.GetOrCreate <NavigationSettings>().ComputeGroupsHash();
if (navigationGroupsHash != currentNavigationGroupsHash)
{
currentNavigationGroupsHash = navigationGroupsHash;
await BuildAndReloadAssets(Session.AllAssets.Where(x => x.AssetType == typeof(NavigationMeshAsset)).Select(x => x.AssetItem));
}
}
public TextStyle(
Font font,
double fontSize,
TextRenderModeEnum renderMode,
Color strokeColor,
ColorSpace strokeColorSpace,
Color fillColor,
ColorSpace fillColorSpace,
double scaleX,
double scaleY
)
{
this.font = font;
this.fontSize = fontSize;
this.renderMode = renderMode;
this.strokeColor = strokeColor;
this.strokeColorSpace = strokeColorSpace;
this.fillColor = fillColor;
this.fillColorSpace = fillColorSpace;
this.scaleX = scaleX;
this.scaleY = scaleY;
}
public static bool IsTextureSetupProblematic(Material material, ColorSpace colorSpace,
bool sRGBTexture, bool mipmapEnabled, bool alphaIsTransparency,
string texturePath, string materialPath,
ref string errorMessage)
{
if (material == null || !UsesSpineShader(material))
{
return(false);
}
bool isProblematic = false;
if (IsPMAMaterial(material))
{
// 'sRGBTexture = true' generates incorrectly weighted mipmaps at PMA textures,
// causing white borders due to undesired custom weighting.
if (sRGBTexture && mipmapEnabled && colorSpace == ColorSpace.Gamma)
{
errorMessage += string.Format("`{0}` : Problematic Texture Settings found: When enabling `Generate Mip Maps` in Gamma color space, it is recommended to disable `sRGB (Color Texture)` on `Premultiply alpha` textures. Otherwise you will receive white border artifacts on an atlas exported with default `Premultiply alpha` settings.\n(You can disable this warning in `Edit - Preferences - Spine`)\n", texturePath);
isProblematic = true;
}
if (alphaIsTransparency)
{
string materialName = System.IO.Path.GetFileName(materialPath);
errorMessage += string.Format("`{0}` and material `{1}` : Problematic Texture / Material Settings found: It is recommended to disable `Alpha Is Transparency` on `Premultiply alpha` textures.\nAssuming `Premultiply alpha` texture because `Straight Alpha Texture` is disabled at material). (You can disable this warning in `Edit - Preferences - Spine`)\n", texturePath, materialName);
isProblematic = true;
}
}
else // straight alpha texture
{
if (!alphaIsTransparency)
{
string materialName = System.IO.Path.GetFileName(materialPath);
errorMessage += string.Format("`{0}` and material `{1}` : Incorrect Texture / Material Settings found: It is strongly recommended to enable `Alpha Is Transparency` on `Straight alpha` textures.\nAssuming `Straight alpha` texture because `Straight Alpha Texture` is enabled at material). (You can disable this warning in `Edit - Preferences - Spine`)\n", texturePath, materialName);
isProblematic = true;
}
}
return(isProblematic);
}
/// <summary>
/// Try to convert from YCbCr to RGB colors
/// </summary>
/// <param name="sourceColorspace">The colorspace of the luma and chroma</param>
/// <param name="luma">The luma plane</param>
/// <param name="blueDifferential">The blue differential (Cb) plane</param>
/// <param name="redDifferential">The red differential (Cr) plane</param>
/// <param name="width">The width of the frame</param>
/// <param name="height">The height of the frame</param>
/// <returns>An RGB plane if this function succeeds. None otherwise</returns>
/// <remarks>
/// FFMPEG outputs 420mpeg2 (where the chroma samples are aligned horizontally, but
/// shifted a half-pixel down).
/// https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
/// </remarks>
public static Maybe<Color[][]> TryConvertFrameToRGB(
ColorSpace sourceColorspace,
byte[][] luma,
byte[][] blueDifferential,
byte[][] redDifferential,
int width,
int height
)
{
var inFrames = new YCrCbFrame
{
ColorSpace = sourceColorspace,
Luma = luma,
Cb = blueDifferential,
Cr = redDifferential,
Width = width,
Height = height,
};
if (Equals(sourceColorspace, ColorSpace.FourFourFour))
{
return TryConvertYCbCr444ToRGB(inFrames);
}
if (Equals(sourceColorspace, ColorSpace.FourTwoTwo))
{
return from horizontalUpconvert in TryConvert422To444(inFrames)
select TryConvertYCbCr444ToRGB(horizontalUpconvert);
}
if (Equals(sourceColorspace, ColorSpace.FourTwoZeroMpeg2))
{
return from verticalUpconvert in TryConvert420To422(inFrames)
from horizontalUpconvert in TryConvert422To444(verticalUpconvert)
select TryConvertYCbCr444ToRGB(horizontalUpconvert);
}
return Maybe<Color[][]>.Nothing;
}
/// <summary>
/// Updates this instance( <see cref="Position"/>, <see cref="Direction"/>, <see cref="HasBoundingBox"/>, <see cref="BoundingBox"/>, <see cref="BoundingBoxExt"/>
/// </summary>
/// <param name="colorSpace"></param>
public bool Update(ColorSpace colorSpace)
{
if (Type == null || !Enabled || !Type.Update(this))
{
return(false);
}
// Compute light direction and position
Vector3 lightDirection;
var lightDir = DefaultDirection;
Vector3.TransformNormal(ref lightDir, ref Entity.Transform.WorldMatrix, out lightDirection);
lightDirection.Normalize();
Position = Entity.Transform.WorldMatrix.TranslationVector;
Direction = lightDirection;
// Color
var colorLight = Type as IColorLight;
Color = (colorLight != null) ? colorLight.ComputeColor(colorSpace, Intensity) : new Color3();
// Compute bounding boxes
HasBoundingBox = false;
BoundingBox = new BoundingBox();
BoundingBoxExt = new BoundingBoxExt();
var directLight = Type as IDirectLight;
if (directLight != null && directLight.HasBoundingBox)
{
// Computes the bounding boxes
BoundingBox = directLight.ComputeBounds(Position, Direction);
BoundingBoxExt = new BoundingBoxExt(BoundingBox);
}
return(true);
}
/// <summary>
/// Texture をオリジナルのテクスチャアセット(png/jpg)ファイルのバイト列そのまま出力してよいかどうか判断する。
/// 具体的な条件は以下
///
/// * TextureAsset が存在する
/// * TextureImporter の maxSize が画像の縦横サイズ以上
/// * TextureImporter の色空間設定が exportColorSpace と一致する
/// * 各 Texture Type ごとの判定
///
/// Unity の Texture2D のデータは、その参照元であるテクスチャアセットファイルのデータと一致することはむしろ稀。
/// </summary>
public bool CanExportAsEditorAssetFile(Texture texture, ColorSpace exportColorSpace)
{
// Exists as UnityEditor Texture2D Assets ?
if (!EditorTextureUtility.TryGetAsEditorTexture2DAsset(texture, out var texture2D, out var textureImporter))
{
return(false);
}
// Maintain original width/height ?
if (!IsTextureSizeMaintained(textureImporter))
{
return(false);
}
// Equals color space ?
if (!IsFileColorSpaceSameWithExportColorSpace(textureImporter, exportColorSpace))
{
return(false);
}
// Each Texture Importer Type Validation
switch (textureImporter.textureType)
{
case TextureImporterType.Default:
break;
case TextureImporterType.NormalMap:
// A texture has "Normal map" TextureType is ALWAYS converted into normalized normal pixel by Unity.
// So we must copy it.
return(false);
default:
// Not Supported TextureImporterType
throw new ArgumentOutOfRangeException();
}
return(true);
}
public void SetColorSpace(ColorSpace colorSpace, bool isCombined = false)
{
ColorSpace oldval = ColorSpace;
ColorSpace newval = colorSpace;
if (oldval == newval) return;
var cmd = new Command.DelegateCommand(
() =>
{
_colorSpace = newval;
CallChangedColorSpace(false, ChangedValueType.Execute);
},
() =>
{
_colorSpace = oldval;
CallChangedColorSpace(false, ChangedValueType.Unexecute);
},
this,
isCombined);
Command.CommandManager.Execute(cmd);
}
private static double Convert(double c, ColorSpace sourceSpace, ColorSpace targetSpace)
{
// Convert source space --> sRGB --> target space.
switch (sourceSpace)
{
case ColorSpace.SRgb:
break;
case ColorSpace.Linear:
c = ColorHelper.ToSRgb(c);
break;
}
switch (targetSpace)
{
case ColorSpace.SRgb:
break;
case ColorSpace.Linear:
c = ColorHelper.ToLinear(c);
break;
}
return c;
}
public void IssueRenderThread()
{
if (canConnecttoActivity && !isInitrenderThread)
{
ColorSpace colorSpace = QualitySettings.activeColorSpace;
if (colorSpace == ColorSpace.Gamma)
{
Pvr_UnitySDKAPI.Render.UPvr_SetColorspaceType(0);
}
else if (colorSpace == ColorSpace.Linear)
{
Pvr_UnitySDKAPI.Render.UPvr_SetColorspaceType(1);
}
Pvr_UnitySDKPluginEvent.Issue(RenderEventType.InitRenderThread);
isInitrenderThread = true;
Debug.Log("IssueRenderThread end");
}
else
{
Debug.Log("IssueRenderThread canConnecttoActivity = " + canConnecttoActivity);
}
}
public static int fromColor(ColorSpace color)
{
if (color == ColorSpace.MONO)
{
return(0);
}
else if (color == ColorSpace.YUV420)
{
return(1);
}
else if (color == ColorSpace.YUV422)
{
return(2);
}
else if (color == ColorSpace.YUV444)
{
return(3);
}
else
{
throw new Exception("Colorspace not supported");
}
}
private int ExtractComponents(IntPtr colorID, ColorSpace colorSpace, ref byte c0, ref byte c1, ref byte c2, ref byte c3, ref byte gamutFlag)
{
if (!IsValidColorSpace(colorSpace))
{
return(PSError.kSPBadParameterError);
}
Color item = colors[colorID];
c0 = item.Component0;
c1 = item.Component1;
c2 = item.Component2;
c3 = item.Component3;
int error = PSError.kSPNoError;
if (item.ColorSpace != colorSpace)
{
error = ColorServicesConvert.Convert(item.ColorSpace, colorSpace, ref c0, ref c1, ref c2, ref c3);
}
return(error);
}
/// <summary>
/// Converts the color to a floating point representation in the target color space.
/// </summary>
/// <param name="color">The color.</param>
/// <param name="colorSpace">The target color space.</param>
/// <returns>The floating point representation.</returns>
public static Vector4 ToVector4(this Color color, ColorSpace colorSpace = ColorSpace.sRGB)
{
if (colorSpace == ColorSpace.sRGB)
{
return new Vector4
{
X = color.R / 255f,
Y = color.G / 255f,
Z = color.B / 255f,
W = color.A / 255f,
};
}
else
{
return new Vector4
{
X = ToLinear(color.R),
Y = ToLinear(color.G),
Z = ToLinear(color.B),
W = color.A / 255f,
};
}
}
public static int CalculateBufferSize(Size resolution, ColorSpace colorSpace)
{
if (resolution.Width <= 0)
{
throw new ArgumentOutOfRangeException(nameof(resolution), resolution.Width,
"width can't be less than or equal to zero.");
}
if (resolution.Height <= 0)
{
throw new ArgumentOutOfRangeException(nameof(resolution), resolution.Height,
"height can't be less than or equal to zero.");
}
ValidationUtil.ValidateEnum(typeof(ColorSpace), colorSpace, nameof(colorSpace));
uint bufferSize;
global::Interop.ImageUtil.CalculateBufferSize(resolution.Width, resolution.Height,
colorSpace.ToImageColorSpace(), out bufferSize)
.ThrowIfFailed("Failed to calculate buffer size for given parameter");
return((int)bufferSize);
}
public UGCanvasRenderTarget(UGSize canvasSize, float scale)
{
Size = canvasSize;
Scale = scale;
var width = (int)(scale * Width + .5F);
var height = (int)(scale * Height + .5F);
Bitmap native;
if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
{
using (var colorSpace = ColorSpace.Get(ColorSpace.Named.Srgb))
{
native = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888, true, colorSpace);
}
}
else
{
native = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888);
}
native.Density = (int)(160F * Scale + .5F);
_native = native;
}
private unsafe int ExtractComponents(ColorID colorID, ColorSpace colorSpace, byte *c0, byte *c1, byte *c2, byte *c3, byte *gamutFlag)
{
if (!IsValidColorSpace(colorSpace) || c0 == null || c1 == null || c2 == null || c3 == null)
{
return(PSError.kSPBadParameterError);
}
Color item = colors[colorID];
*c0 = item.Component0;
*c1 = item.Component1;
*c2 = item.Component2;
*c3 = item.Component3;
int error = PSError.kSPNoError;
if (item.ColorSpace != colorSpace)
{
error = ColorServicesConvert.Convert(item.ColorSpace, colorSpace, ref *c0, ref *c1, ref *c2, ref *c3);
}
return(error);
}
public ExtraVideoInfo(VideoInfo info)
{
Width = info.width;
Height = info.height;
Size = new Size(Width, Height);
Area = Width * Height;
AspectRatio = (double)Width / Height;
ColorSpace = info.pixel_type;
FrameCount = info.num_frames;
Info = info;
if (ColorSpace.IsRealPlanar())
{
var vi = info;
vi.width = Width / ColorSpace.GetWidthSubsample();
vi.height = Height / ColorSpace.GetHeightSubsample();
vi.pixel_type = ColorSpaces.CS_Y8;
Chroma = vi;
}
else
{
Chroma = this;
}
}
private void CheckBoxRandom_CheckedChanged(object sender, RoutedEventArgs e)
{
if (CheckBoxRandom.IsChecked == true)
{
_isRandomMode = true;
RectangleRandomColor1.SetBinding(Shape.FillProperty, _randomColorBinding);
RectangleRandomColor2.SetBinding(Shape.FillProperty, _randomColorBinding);
}
else
{
_isRandomMode = false;
CheckBoxIncrement.IsChecked = false;
SliderA2.Value = SliderA1.Value;
SliderB2.Value = SliderB1.Value;
SliderC2.Value = SliderC1.Value;
SliderD2.Value = SliderD1.Value;
RandomColor = ColorSpace.OpaqueBlack;
RectangleRandomColor1.SetBinding(Shape.FillProperty, _currentColor1Binding);
RectangleRandomColor2.SetBinding(Shape.FillProperty, _currentColor2Binding);
}
e.Handled = true;
}
public byte[] Compress(Color[] colors)
{
Debug.Assert(colors.Length == BlockFormat.TexelCount);
var colorSpace = new ColorSpace(colors);
var colorTable = BC1ColorTable.Create(colorSpace.MaxColor, colorSpace.MinColor);
var block = new BC2BlockData();
block.Color0 = colorTable[0];
block.Color1 = colorTable[1];
for (int i = 0; i < colors.Length; ++i)
{
var color32 = colors[i];
var color16 = ColorUtility.To16Bit(color32);
block.ColorIndexes[i] = ColorUtility.GetIndexOfClosestColor(colorTable, color16);
block.ColorAlphas[i] = color32.A >> 4; // Convert 8-bit alpha to 4-bit
}
return(block.ToBytes());
}
/// <summary>
/// Constructs a new FonetImage using the supplied bitmap.
/// </summary>
/// <remarks>
/// Does not hold a reference to the passed bitmap. Instead the
/// image data is extracted from <b>bitmap</b> on construction.
/// </remarks>
/// <param name="href">The location of <i>bitmap</i></param>
/// <param name="imageData">The image data</param>
public FonetImage(string href,
int width,
int height,
int bitPlans,
byte[] imageData)
{
this.m_href = href;
this.m_bitmaps = imageData;
this.width = width;
this.height = height;
//if (bitmap.RawFormat.Equals(ImageFormat.Jpeg))
// //{
// // JpegParser parser = new JpegParser(m_bitmaps);
// // JpegInfo info = parser.Parse();
// // m_bitsPerPixel = info.BitsPerSample;
// // m_colorSpace = new ColorSpace(info.ColourSpace);
// // width = info.Width;
// // height = info.Height;
// // // A "no-op" filter since the JPEG data is already compressed
// // filter = new DctFilter();
// //}
// //else
// //{
// // ExtractOtherImageBits(bitmap);
// // // Performs zip compression
// // filter = new FlateFilter();
// //}
//---------------------------------------------------
m_colorSpace = new ColorSpace(ColorSpace.DeviceRgb); //***
m_bitsPerPixel = bitPlans; // DEFAULT_BITPLANES; // 8
}
private bool TIFFjpeg_set_colorspace(ColorSpace colorspace)
{
try
{
m_compression.jpeg_set_colorspace(colorspace);
}
catch (Exception)
{
return false;
}
return true;
}
public static extern unsafe int* sws_getCoefficients(ColorSpace colorspace);
//Nav mesh settings can't be accessed via script :(
//Lightmapping is VERY version-specific. You may have to modify the settings that are compared
public void CaptureSettings() {
#if UNITY_5
#else
aoAmount = LightmapEditorSettings.aoAmount;
aoContrast = LightmapEditorSettings.aoContrast;
bounceBoost = LightmapEditorSettings.bounceBoost;
bounceIntensity = LightmapEditorSettings.bounceIntensity;
bounces = LightmapEditorSettings.bounces;
quality = LightmapEditorSettings.quality;
skyLightColor = LightmapEditorSettings.skyLightColor;
skyLightIntensity = LightmapEditorSettings.skyLightIntensity;
finalGatherContrastThreshold = LightmapEditorSettings.finalGatherContrastThreshold;
finalGatherGradientThreshold = LightmapEditorSettings.finalGatherGradientThreshold;
finalGatherInterpolationPoints = LightmapEditorSettings.finalGatherInterpolationPoints;
finalGatherRays = LightmapEditorSettings.finalGatherRays;
lastUsedResolution = LightmapEditorSettings.lastUsedResolution;
lockAtlas = LightmapEditorSettings.lockAtlas;
#if !(UNITY_3_0 || UNITY_3_0_0 || UNITY_3_1 || UNITY_3_2 || UNITY_3_3 || UNITY_3_4 || UNITY_3_5)
bakedColorSpace = LightmapSettings.bakedColorSpace;
#endif
#endif
ambientLight = RenderSettings.ambientLight;
#if UNITY_4_3 || UNITY_4_5 || UNITY_5 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 || UNITY_5_3
flareFadeSpeed = RenderSettings.flareFadeSpeed;
#endif
#if UNITY_3_0 || UNITY_3_0_0 || UNITY_3_1 || UNITY_3_2 || UNITY_3_3 || UNITY_3_4 || UNITY_3_5
#else
lightProbes = LightmapSettings.lightProbes;
padding = LightmapEditorSettings.padding;
#endif
flareStrength = RenderSettings.flareStrength;
fog = RenderSettings.fog;
fogColor = RenderSettings.fogColor;
fogDensity = RenderSettings.fogDensity;
fogEndDistance = RenderSettings.fogEndDistance;
fogMode = RenderSettings.fogMode;
fogStartDistance = RenderSettings.fogStartDistance;
haloStrength = RenderSettings.haloStrength;
skybox = RenderSettings.skybox;
lightmaps = LightmapSettings.lightmaps;
lightmapsMode = LightmapSettings.lightmapsMode;
aoMaxDistance = LightmapEditorSettings.aoMaxDistance;
maxAtlasHeight = LightmapEditorSettings.maxAtlasHeight;
maxAtlasWidth = LightmapEditorSettings.maxAtlasWidth;
resolution = LightmapEditorSettings.resolution;
textureCompression = LightmapEditorSettings.textureCompression;
}
public static PlanarImage FromBitmap(Bitmap source, PixelAlignmentType format, ColorSpace colorspace = ColorSpace.DEFAULT)
{
IntPtr context = SwScale.sws_getContext(source.Width, source.Height, m_rgbMapper[source.PixelFormat],
source.Width, source.Height, m_pixelTypeMapper[format],
SwScale.ConvertionFlags.SWS_BICUBIC, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
int* pCoef = SwScale.sws_getCoefficients(colorspace);
int* inv_table;
int* table;
int srcRange, dstRange, brightness, contrast, saturation;
int result = SwScale.sws_getColorspaceDetails(context, out inv_table, out srcRange, out table, out dstRange, out brightness, out contrast, out saturation);
if (result != -1)
{
result = SwScale.sws_setColorspaceDetails(context, pCoef, srcRange, table, dstRange, brightness, contrast, saturation);
}
PlanarImage yuv = new PlanarImage(source.Width, source.Height, format);
BitmapData data = source.LockBits(new Rectangle(0, 0, source.Width, source.Height), ImageLockMode.ReadOnly, source.PixelFormat);
unsafe
{
pInput[0] = (byte*)data.Scan0.ToPointer();
result = SwScale.sws_scale(context, pInput, new int[] { data.Stride, 0, 0, 0 }, 0, source.Height, yuv.PixelDataPointer, yuv.Pitches);
if (result != yuv.Height)
{
throw new InvalidOperationException();
}
}
source.UnlockBits(data);
SwScale.sws_freeContext(context);
return yuv;
}
public extern void ReadTextureImportInstructions(BuildTarget target, out TextureFormat desiredFormat, out ColorSpace colorSpace, out int compressionQuality);
/// <summary>
/// ��ColorSpace�Ƿ���ɫ������ģʽ��
/// </summary>
/// <param name="cs"><seealso cref="ColorSpace"/>������</param>
/// <returns>����ColorSpace��ɫ������ģʽʱ������true�������Ƿ�ɫ������ģʽ������false��</returns>
public static bool isColor(ColorSpace cs)
{
return (cs < ColorSpace.Vector);
}
private static KeyValuePair<ColorSpace, ColorSpaceName> newKVPName(ColorSpace colorSpace, string name, string nameShort, string nameC0, string nameC1, string nameC2, string nameC3, string description)
{
return KeyValuePairs.newKVP(colorSpace, new ColorSpaceName(colorSpace, name, nameShort, nameC0, nameC1, nameC2, nameC3, description));
}
/// <summary>
/// ��ָ���IJ�����ʼ�� ColorSpaceName �����ʵ��������������
/// </summary>
/// <param name="colorSpace">ɫ�ʿռ䡣</param>
/// <param name="name">ɫ�ʿռ�����ơ����硰CIEXYZ����</param>
/// <param name="nameShort">ɫ�ʿռ�Ķ����ƣ�����ͨ������д�����硰XYZ����</param>
/// <param name="nameC0">ͨ��0�����ơ�</param>
/// <param name="nameC1">ͨ��1�����ơ�</param>
/// <param name="nameC2">ͨ��2�����ơ�</param>
/// <param name="nameC3">ͨ��3�����ơ�</param>
public ColorSpaceName(ColorSpace colorSpace, string name, string nameShort, string nameC0, string nameC1, string nameC2, string nameC3)
: this(colorSpace, name, nameShort, nameC0, nameC1, nameC2, nameC3, string.Empty)
{
}
/// <summary>
/// ���� <seealso cref="ColorSpace"/> ��������Ϣ��
/// </summary>
/// <param name="cs">ɫ�ʿռ� <seealso cref="ColorSpace"/>������</param>
/// <returns>����������Ϣ��</returns>
public static ColorSpaceName findName(ColorSpace cs)
{
return KeyValuePairs.find(Names, cs);
}
/// <summary>
/// ��ָ���IJ�����ʼ�� ColorSpaceName �����ʵ����
/// </summary>
/// <param name="colorSpace">ɫ�ʿռ䡣</param>
/// <param name="name">ɫ�ʿռ�����ơ����硰CIEXYZ����</param>
/// <param name="nameShort">ɫ�ʿռ�Ķ����ƣ�����ͨ������д�����硰XYZ����</param>
/// <param name="nameC0">ͨ��0�����ơ�</param>
/// <param name="nameC1">ͨ��1�����ơ�</param>
/// <param name="nameC2">ͨ��2�����ơ�</param>
/// <param name="nameC3">ͨ��3�����ơ�</param>
/// <param name="description">������Ϣ��</param>
public ColorSpaceName(ColorSpace colorSpace, string name, string nameShort, string nameC0, string nameC1, string nameC2, string nameC3, string description)
{
this.colorSpace = colorSpace;
this.name = name;
this.nameShort = nameShort;
this.description = description;
this.nameChannels = new string[4] { nameC0, nameC1, nameC2, nameC3 };
}
public void SetColorSpace(ColorSpace value)
{
#if ANYCPU
if (NativeLibrary.Is64Bit)
#endif
#if WIN64 || ANYCPU
NativeMethods.X64.QuantizeSettings_SetColorSpace(Instance, (UIntPtr)value);
#endif
#if ANYCPU
else
#endif
#if !WIN64 || ANYCPU
NativeMethods.X86.QuantizeSettings_SetColorSpace(Instance, (UIntPtr)value);
#endif
}
public override bool VirtuallyEquals(ColorSpace other)
{
var otherColor = other as Cmyk;
if (otherColor != null)
{
return C.ApproximatelyEquals(otherColor.C) &&
M.ApproximatelyEquals(otherColor.M) &&
Y.ApproximatelyEquals(otherColor.Y) &&
K.ApproximatelyEquals(otherColor.K);
}
return false;
}
public override bool Equals(ColorSpace other)
{
var otherColor = other as Cmyk;
if (otherColor != null)
return C.Equals(otherColor.C) && M.Equals(otherColor.M) && Y.Equals(otherColor.Y) && K.Equals(otherColor.K);
return false;
}
public static Bitmap ToBitmap(PlanarImage source, PixelFormat format, ColorSpace colorspace = ColorSpace.DEFAULT)
{
IntPtr context = SwScale.sws_getContext(source.Width, source.Height, m_pixelTypeMapper[source.PixelType],
source.Width, source.Height, m_rgbMapper[format],
SwScale.ConvertionFlags.SWS_BICUBIC, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
int* pCoef = SwScale.sws_getCoefficients(colorspace);
int* inv_table;
int* table;
int srcRange, dstRange, brightness, contrast, saturation;
int result = SwScale.sws_getColorspaceDetails(context, out inv_table, out srcRange, out table, out dstRange, out brightness, out contrast, out saturation);
if (result != -1)
{
result = SwScale.sws_setColorspaceDetails(context, pCoef, srcRange, pCoef, dstRange, brightness, contrast, saturation);
}
Bitmap bmp = new Bitmap(source.Width, source.Height, format);
BitmapData data = bmp.LockBits(new Rectangle(0, 0, source.Width, source.Height), ImageLockMode.ReadWrite, format);
unsafe
{
pInput[0] = (byte*)data.Scan0.ToPointer();
result = SwScale.sws_scale(context, source.PixelDataPointer, source.Pitches, 0, source.Height, pInput, new int[] { data.Stride, 0, 0, 0 });
if (result != source.Height)
{
throw new InvalidOperationException();
}
}
bmp.UnlockBits(data);
if (bmp.Palette != null && bmp.Palette.Entries != null && bmp.Palette.Entries.Length > 0)
{
ColorPalette cp = bmp.Palette;
for (int i = 0; i < cp.Entries.Length; i++)
{
cp.Entries[i] = Color.FromArgb(i, i, i);
}
bmp.Palette = cp;
}
SwScale.sws_freeContext(context);
return bmp;
}