Revert of Add gamma/sRGB tag to SkImageInfo (patchset #1 id:1 of https://codereview.chromium.org/527073003/)
Reason for revert:
virtual gpu failures in layouttests
http://build.chromium.org/p/tryserver.blink/builders/linux_blink_dbg/builds/23717
[6:6:0903/041147:1700960503:INFO:SkBitmap.cpp(1003)] ../../third_party/skia/src/core/SkBitmap.cpp:1003: failed assertion "fPixelRef->info() == pixelRef->info()"
[6:6:0903/041147:1700961002:FATAL:SkBitmap.cpp(1003)] SK_CRASH
#0 0x7f9867df2c1e base::debug::StackTrace::StackTrace()
#1 0x7f9867e89e05 logging::LogMessage::~LogMessage()
#2 0x7f98689c4970 SkDebugf_FileLine()
#3 0x7f986870ebc6 SkBitmap::deepCopyTo()
#4 0x7f98690a3b6d blink::deepSkBitmapCopy()
#5 0x7f98690a3abe blink::ImageBuffer::copyImage()
#6 0x7f985fd4479e blink::ImageBitmap::ImageBitmap()
#7 0x7f985fd45942 blink::ImageBitmap::create()
#8 0x7f985fd84fdc blink::ImageBitmapFactories::createImageBitmap()
#9 0x7f985fd84d11 blink::ImageBitmapFactories::createImageBitmap()
#10 0x7f985ec9a7f2 blink::LocalDOMWindowV8Internal::createImageBitmap13Method()
#11 0x7f985ec96b0c blink::LocalDOMWindowV8Internal::createImageBitmapMethod()
#12 0x7f985ec91954 blink::LocalDOMWindowV8Internal::createImageBitmapMethodCallback()
#13 0x7f9869955af0 v8::internal::FunctionCallbackArguments::Call()
#14 0x7f98699833bd v8::internal::Builtin_HandleApiCall()
Original issue's description:
> Add gamma/sRGB tag to SkImageInfo
>
> This reverts commit 1cbc68f965
.
>
> requires this to land in blink https://codereview.chromium.org/531883002/
>
> Committed: https://skia.googlesource.com/skia/+/2f6abdecc5c2f21da13003c615903679abc73fc7
R=fmalita@google.com, reed@chromium.org
TBR=fmalita@google.com, reed@chromium.org
NOTREECHECKS=true
NOTRY=true
Author: reed@google.com
Review URL: https://codereview.chromium.org/535113002
This commit is contained in:
parent
c56653cdd2
commit
2bdf1f56c3
@ -119,7 +119,6 @@
|
||||
'../tests/ImageDecodingTest.cpp',
|
||||
'../tests/ImageFilterTest.cpp',
|
||||
'../tests/ImageGeneratorTest.cpp',
|
||||
'../tests/ImageInfoTest.cpp',
|
||||
'../tests/ImageIsOpaqueTest.cpp',
|
||||
'../tests/ImageNewShaderTest.cpp',
|
||||
'../tests/InfRectTest.cpp',
|
||||
|
@ -135,57 +135,37 @@ bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType,
|
||||
/**
|
||||
* Describe an image's dimensions and pixel type.
|
||||
*/
|
||||
struct SK_API SkImageInfo {
|
||||
public:
|
||||
SkImageInfo()
|
||||
: fWidth(0)
|
||||
, fHeight(0)
|
||||
, fColorType(kUnknown_SkColorType)
|
||||
, fAlphaType(kIgnore_SkAlphaType)
|
||||
, fProfile(kUnknown_Profile)
|
||||
, fGamma(0)
|
||||
{}
|
||||
|
||||
struct SkImageInfo {
|
||||
int fWidth;
|
||||
int fHeight;
|
||||
SkColorType fColorType;
|
||||
SkAlphaType fAlphaType;
|
||||
|
||||
/*
|
||||
* Return an info with the specified attributes, tagged as sRGB. Note that if the requested
|
||||
* color type does not make sense with sRGB (e.g. kAlpha_8) then the sRGB request is ignored.
|
||||
*
|
||||
* You can call isSRGB() on the returned info to determine if the request was fulfilled.
|
||||
*/
|
||||
static SkImageInfo MakeSRGB(int width, int height, SkColorType ct, SkAlphaType at);
|
||||
|
||||
/*
|
||||
* Return an info with the specified attributes, tagged with a specific gamma.
|
||||
* Note that if the requested gamma is unsupported for the requested color type, then the gamma
|
||||
* value will be set to 1.0 (the default).
|
||||
*
|
||||
* You can call gamma() to query the resulting gamma value.
|
||||
*/
|
||||
static SkImageInfo MakeWithGamma(int width, int height, SkColorType ct, SkAlphaType at,
|
||||
float gamma);
|
||||
|
||||
static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at) {
|
||||
return MakeWithGamma(width, height, ct, at, 1);
|
||||
SkImageInfo info = {
|
||||
width, height, ct, at
|
||||
};
|
||||
return info;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets colortype to the native ARGB32 type.
|
||||
*/
|
||||
static SkImageInfo MakeN32(int width, int height, SkAlphaType at) {
|
||||
return SkImageInfo(width, height, kN32_SkColorType, at, kExponential_Profile, 1);
|
||||
SkImageInfo info = {
|
||||
width, height, kN32_SkColorType, at
|
||||
};
|
||||
return info;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets colortype to the native ARGB32 type, and the alphatype to premul.
|
||||
*/
|
||||
static SkImageInfo MakeN32Premul(int width, int height) {
|
||||
return SkImageInfo(width, height, kN32_SkColorType, kPremul_SkAlphaType,
|
||||
kExponential_Profile, 1);
|
||||
SkImageInfo info = {
|
||||
width, height, kN32_SkColorType, kPremul_SkAlphaType
|
||||
};
|
||||
return info;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -196,17 +176,24 @@ public:
|
||||
}
|
||||
|
||||
static SkImageInfo MakeA8(int width, int height) {
|
||||
return SkImageInfo(width, height, kAlpha_8_SkColorType, kPremul_SkAlphaType,
|
||||
kUnknown_Profile, 0);
|
||||
SkImageInfo info = {
|
||||
width, height, kAlpha_8_SkColorType, kPremul_SkAlphaType
|
||||
};
|
||||
return info;
|
||||
}
|
||||
|
||||
static SkImageInfo MakeUnknown(int width, int height) {
|
||||
return SkImageInfo(width, height, kUnknown_SkColorType, kIgnore_SkAlphaType,
|
||||
kUnknown_Profile, 0);
|
||||
SkImageInfo info = {
|
||||
width, height, kUnknown_SkColorType, kIgnore_SkAlphaType
|
||||
};
|
||||
return info;
|
||||
}
|
||||
|
||||
static SkImageInfo MakeUnknown() {
|
||||
return SkImageInfo();
|
||||
SkImageInfo info = {
|
||||
0, 0, kUnknown_SkColorType, kIgnore_SkAlphaType
|
||||
};
|
||||
return info;
|
||||
}
|
||||
|
||||
int width() const { return fWidth; }
|
||||
@ -249,11 +236,8 @@ public:
|
||||
return 0 != memcmp(this, &other, sizeof(other));
|
||||
}
|
||||
|
||||
// DEPRECATED : use the static Unflatten
|
||||
void unflatten(SkReadBuffer&);
|
||||
void flatten(SkWriteBuffer&) const;
|
||||
|
||||
static SkImageInfo Unflatten(SkReadBuffer&);
|
||||
|
||||
int64_t getSafeSize64(size_t rowBytes) const {
|
||||
if (0 == fHeight) {
|
||||
@ -272,36 +256,6 @@ public:
|
||||
}
|
||||
|
||||
SkDEBUGCODE(void validate() const;)
|
||||
|
||||
/**
|
||||
* If the Info was tagged to be sRGB, return true, else return false.
|
||||
*/
|
||||
bool isSRGB() const { return kSRGB_Profile == fProfile; }
|
||||
|
||||
/**
|
||||
* If this was tagged with an explicit gamma value, return that value, else return 0.
|
||||
* If this was tagged as sRGB, return 0.
|
||||
*/
|
||||
float gamma() const { return fGamma; }
|
||||
|
||||
private:
|
||||
enum Profile {
|
||||
kUnknown_Profile,
|
||||
kSRGB_Profile,
|
||||
kExponential_Profile,
|
||||
};
|
||||
|
||||
uint32_t fProfile;
|
||||
float fGamma;
|
||||
|
||||
SkImageInfo(int width, int height, SkColorType ct, SkAlphaType at, Profile p, float g)
|
||||
: fWidth(width)
|
||||
, fHeight(height)
|
||||
, fColorType(ct)
|
||||
, fAlphaType(at)
|
||||
, fProfile(p)
|
||||
, fGamma(g)
|
||||
{}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
@ -9,53 +9,34 @@
|
||||
#include "SkReadBuffer.h"
|
||||
#include "SkWriteBuffer.h"
|
||||
|
||||
static bool color_type_supports_sRGB(SkColorType colorType) {
|
||||
switch (colorType) {
|
||||
case kRGBA_8888_SkColorType:
|
||||
case kBGRA_8888_SkColorType:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
static bool alpha_type_is_valid(SkAlphaType alphaType) {
|
||||
return (alphaType >= 0) && (alphaType <= kLastEnum_SkAlphaType);
|
||||
}
|
||||
|
||||
static bool color_type_supports_gamma(SkColorType colorType) {
|
||||
switch (colorType) {
|
||||
case kRGBA_8888_SkColorType:
|
||||
case kBGRA_8888_SkColorType:
|
||||
// case kLuminance ...
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
static bool color_type_is_valid(SkColorType colorType) {
|
||||
return (colorType >= 0) && (colorType <= kLastEnum_SkColorType);
|
||||
}
|
||||
|
||||
static float pin_gamma_to_legal(float gamma) {
|
||||
if (!SkScalarIsFinite(gamma)) {
|
||||
return 1;
|
||||
}
|
||||
// these limits are just made up -- feel free to change them within reason
|
||||
const float min_gamma = 0.01f;
|
||||
const float max_gamma = 4.0;
|
||||
return SkScalarPin(gamma, min_gamma, max_gamma);
|
||||
void SkImageInfo::unflatten(SkReadBuffer& buffer) {
|
||||
fWidth = buffer.read32();
|
||||
fHeight = buffer.read32();
|
||||
|
||||
uint32_t packed = buffer.read32();
|
||||
SkASSERT(0 == (packed >> 16));
|
||||
fAlphaType = (SkAlphaType)((packed >> 8) & 0xFF);
|
||||
fColorType = (SkColorType)((packed >> 0) & 0xFF);
|
||||
buffer.validate(alpha_type_is_valid(fAlphaType) &&
|
||||
color_type_is_valid(fColorType));
|
||||
}
|
||||
|
||||
SkImageInfo SkImageInfo::MakeSRGB(int width, int height, SkColorType ct, SkAlphaType at) {
|
||||
Profile p = color_type_supports_sRGB(ct) ? kSRGB_Profile : kUnknown_Profile;
|
||||
return SkImageInfo(width, height, ct, at, p, 0);
|
||||
}
|
||||
void SkImageInfo::flatten(SkWriteBuffer& buffer) const {
|
||||
buffer.write32(fWidth);
|
||||
buffer.write32(fHeight);
|
||||
|
||||
SkImageInfo SkImageInfo::MakeWithGamma(int width, int height, SkColorType ct, SkAlphaType at,
|
||||
float gamma) {
|
||||
Profile p;
|
||||
if (color_type_supports_gamma(ct)) {
|
||||
gamma = pin_gamma_to_legal(gamma);
|
||||
p = kExponential_Profile;
|
||||
} else {
|
||||
p = kUnknown_Profile;
|
||||
gamma = 0;
|
||||
}
|
||||
return SkImageInfo(width, height, ct, at, p, gamma);
|
||||
SkASSERT(0 == (fAlphaType & ~0xFF));
|
||||
SkASSERT(0 == (fColorType & ~0xFF));
|
||||
uint32_t packed = (fAlphaType << 8) | fColorType;
|
||||
buffer.write32(packed);
|
||||
}
|
||||
|
||||
bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType,
|
||||
@ -88,74 +69,3 @@ bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType,
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void SkImageInfo::unflatten(SkReadBuffer& buffer) {
|
||||
*this = Unflatten(buffer);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static bool alpha_type_is_valid(SkAlphaType alphaType) {
|
||||
return (alphaType >= 0) && (alphaType <= kLastEnum_SkAlphaType);
|
||||
}
|
||||
|
||||
static bool color_type_is_valid(SkColorType colorType) {
|
||||
return (colorType >= 0) && (colorType <= kLastEnum_SkColorType);
|
||||
}
|
||||
|
||||
static float igamma_to_gamma(int gamma3dot9) {
|
||||
return gamma3dot9 / 512.0f;
|
||||
}
|
||||
|
||||
static unsigned gamma_to_igamma(float gamma) {
|
||||
SkASSERT(gamma >= 0 && gamma < 8);
|
||||
int igamma = SkScalarRoundToInt(gamma * 512);
|
||||
SkASSERT(igamma >= 0 && igamma <= 0xFFF);
|
||||
return igamma;
|
||||
}
|
||||
|
||||
SkImageInfo SkImageInfo::Unflatten(SkReadBuffer& buffer) {
|
||||
int width = buffer.read32();
|
||||
int height = buffer.read32();
|
||||
uint32_t packed = buffer.read32();
|
||||
|
||||
SkColorType ct = (SkColorType)((packed >> 0) & 0xFF); // 8 bits for colortype
|
||||
SkAlphaType at = (SkAlphaType)((packed >> 8) & 0xFF); // 8 bits for alphatype
|
||||
if (!alpha_type_is_valid(at) || !color_type_is_valid(ct)) {
|
||||
return MakeUnknown();
|
||||
}
|
||||
|
||||
// Earlier formats always stored 0 in the upper 16 bits. That corresponds to
|
||||
// days before we had gamma/profile. That happens to correspond to kUnknown_Profile,
|
||||
// which means we can just ignore the gamma value anyways.
|
||||
//
|
||||
int iprofile = ((packed >> 16) & 0xF); // 4 bits for profile
|
||||
|
||||
switch (iprofile) {
|
||||
case kUnknown_Profile:
|
||||
return Make(width, height, ct, at);
|
||||
case kSRGB_Profile:
|
||||
return MakeSRGB(width, height, ct, at);
|
||||
case kExponential_Profile: {
|
||||
int igamma = packed >> 20; // 12 bits for gamma 3.9
|
||||
float gamma = igamma_to_gamma(igamma);
|
||||
return MakeWithGamma(width, height, ct, at, gamma);
|
||||
}
|
||||
default:
|
||||
(void)buffer.validate(false);
|
||||
return MakeUnknown();
|
||||
}
|
||||
}
|
||||
|
||||
void SkImageInfo::flatten(SkWriteBuffer& buffer) const {
|
||||
buffer.write32(fWidth);
|
||||
buffer.write32(fHeight);
|
||||
|
||||
SkASSERT(0 == (fColorType & ~0xFF)); // 8 bits for colortype
|
||||
SkASSERT(0 == (fAlphaType & ~0xFF)); // 8 bits for alphatype
|
||||
SkASSERT(0 == (fProfile & ~0xF)); // 4 bits for profile
|
||||
int igamma = gamma_to_igamma(fGamma); // 12 bits for gamma (if needed)
|
||||
|
||||
uint32_t packed = (igamma << 20) | (fProfile << 16) | (fAlphaType << 8) | fColorType;
|
||||
buffer.write32(packed);
|
||||
}
|
||||
|
@ -1,64 +0,0 @@
|
||||
/*
|
||||
* Copyright 2014 Google Inc.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "SkImageInfo.h"
|
||||
|
||||
#include "Test.h"
|
||||
|
||||
struct ImageInfoRec {
|
||||
int fWidth;
|
||||
int fHeight;
|
||||
SkColorType fColorType;
|
||||
SkAlphaType fAlphaType;
|
||||
float fGamma;
|
||||
bool fIsSRGB;
|
||||
};
|
||||
|
||||
static void check_info(skiatest::Reporter* reporter,
|
||||
const ImageInfoRec& expected, const SkImageInfo& info) {
|
||||
REPORTER_ASSERT(reporter, info.width() == expected.fWidth);
|
||||
REPORTER_ASSERT(reporter, info.height() == expected.fHeight);
|
||||
REPORTER_ASSERT(reporter, info.colorType() == expected.fColorType);
|
||||
REPORTER_ASSERT(reporter, info.alphaType() == expected.fAlphaType);
|
||||
REPORTER_ASSERT(reporter, info.gamma() == expected.fGamma);
|
||||
REPORTER_ASSERT(reporter, info.isSRGB() == expected.fIsSRGB);
|
||||
}
|
||||
|
||||
DEF_TEST(ImageInfo, reporter) {
|
||||
const float nan = SK_ScalarNaN;
|
||||
const float nice_gamma = 1.5f;
|
||||
const int W = 100;
|
||||
const int H = 200;
|
||||
SkImageInfo info;
|
||||
|
||||
const ImageInfoRec rec[] = {
|
||||
{ 0, 0, kUnknown_SkColorType, kIgnore_SkAlphaType, 0, false }, // MakeUnknown()
|
||||
{ W, H, kUnknown_SkColorType, kIgnore_SkAlphaType, 0, false }, // MakeUnknown(...)
|
||||
{ W, H, kN32_SkColorType, kPremul_SkAlphaType, 1, false }, // MakeN32Premul(...)
|
||||
{ W, H, kN32_SkColorType, kOpaque_SkAlphaType, 1, false }, // MakeN32(...)
|
||||
{ W, H, kAlpha_8_SkColorType, kPremul_SkAlphaType, 0, false }, // MakeA8()
|
||||
{ W, H, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType, 1, false }, // Make()
|
||||
{ W, H, kBGRA_8888_SkColorType, kPremul_SkAlphaType, 1, false }, // Make()
|
||||
{ W, H, kBGRA_8888_SkColorType, kPremul_SkAlphaType, 0, true }, // MakeSRGB()
|
||||
{ W, H, kN32_SkColorType, kPremul_SkAlphaType, 1, false }, // MakeWithGamma() NaN
|
||||
{ W, H, kAlpha_8_SkColorType, kPremul_SkAlphaType, 0, false }, // MakeWithGamma() bad ct for gamma
|
||||
{ W, H, kN32_SkColorType, kPremul_SkAlphaType, nice_gamma, false }, // MakeWithGamma() good
|
||||
};
|
||||
|
||||
check_info(reporter, rec[ 0], SkImageInfo::MakeUnknown());
|
||||
check_info(reporter, rec[ 1], SkImageInfo::MakeUnknown(W, H));
|
||||
check_info(reporter, rec[ 2], SkImageInfo::MakeN32Premul(W, H));
|
||||
check_info(reporter, rec[ 3], SkImageInfo::MakeN32(W, H, rec[3].fAlphaType));
|
||||
check_info(reporter, rec[ 4], SkImageInfo::MakeA8(W, H));
|
||||
check_info(reporter, rec[ 5], SkImageInfo::Make(W, H, rec[5].fColorType, rec[5].fAlphaType));
|
||||
check_info(reporter, rec[ 6], SkImageInfo::Make(W, H, rec[6].fColorType, rec[6].fAlphaType));
|
||||
check_info(reporter, rec[ 7], SkImageInfo::MakeSRGB(W, H, rec[7].fColorType, rec[7].fAlphaType));
|
||||
check_info(reporter, rec[ 8], SkImageInfo::MakeWithGamma(W, H, rec[8].fColorType, rec[8].fAlphaType, nan));
|
||||
check_info(reporter, rec[ 9], SkImageInfo::MakeWithGamma(W, H, rec[9].fColorType, rec[9].fAlphaType, nice_gamma));
|
||||
check_info(reporter, rec[10], SkImageInfo::MakeWithGamma(W, H, rec[10].fColorType, rec[10].fAlphaType, rec[10].fGamma));
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user