SkColorSpaceXformSteps Struct Reference

#include <SkColorSpaceXformSteps.h>

Classes
struct	Flags

Public Member Functions
	SkColorSpaceXformSteps ()
	SkColorSpaceXformSteps (const SkColorSpace *src, SkAlphaType srcAT, const SkColorSpace *dst, SkAlphaType dstAT)
template<typename S , typename D >
	SkColorSpaceXformSteps (const S &src, const D &dst)
void	apply (float rgba[4]) const
void	apply (SkRasterPipeline *) const

Public Attributes
Flags	flags
skcms_TransferFunction	srcTF
skcms_TransferFunction	dstTFInv
float	src_to_dst_matrix [9]

Detailed Description

Definition at line 19 of file SkColorSpaceXformSteps.h.

Constructor & Destructor Documentation

SkColorSpaceXformSteps() [1/3]

SkColorSpaceXformSteps::SkColorSpaceXformSteps ( )

inline

Definition at line 37 of file SkColorSpaceXformSteps.h.

{}

SkColorSpaceXformSteps() [2/3]

SkColorSpaceXformSteps::SkColorSpaceXformSteps	(	const SkColorSpace *	src,
		SkAlphaType	srcAT,
		const SkColorSpace *	dst,
		SkAlphaType	dstAT
	)

Definition at line 23 of file SkColorSpaceXformSteps.cpp.

                                                                                           {
    // Opaque outputs are treated as the same alpha type as the source input.
    // TODO: we'd really like to have a good way of explaining why we think this is useful.
    if (dstAT == kOpaque_SkAlphaType) {
        dstAT =  srcAT;
    }
 
    // We have some options about what to do with null src or dst here.
    // This pair seems to be the most consistent with legacy expectations.
    if (!src) { src = sk_srgb_singleton(); }
    if (!dst) { dst = src; }
 
    if (src->hash() == dst->hash() && srcAT == dstAT) {
        SkASSERT(SkColorSpace::Equals(src,dst));
        return;
    }
 
    this->flags.unpremul        = srcAT == kPremul_SkAlphaType;
    this->flags.linearize       = !src->gammaIsLinear();
    this->flags.gamut_transform = src->toXYZD50Hash() != dst->toXYZD50Hash();
    this->flags.encode          = !dst->gammaIsLinear();
    this->flags.premul          = srcAT != kOpaque_SkAlphaType && dstAT == kPremul_SkAlphaType;
 
    if (this->flags.gamut_transform) {
        skcms_Matrix3x3 src_to_dst;  // TODO: switch src_to_dst_matrix to row-major
        src->gamutTransformTo(dst, &src_to_dst);
 
        this->src_to_dst_matrix[0] = src_to_dst.vals[0][0];
        this->src_to_dst_matrix[1] = src_to_dst.vals[1][0];
        this->src_to_dst_matrix[2] = src_to_dst.vals[2][0];
 
        this->src_to_dst_matrix[3] = src_to_dst.vals[0][1];
        this->src_to_dst_matrix[4] = src_to_dst.vals[1][1];
        this->src_to_dst_matrix[5] = src_to_dst.vals[2][1];
 
        this->src_to_dst_matrix[6] = src_to_dst.vals[0][2];
        this->src_to_dst_matrix[7] = src_to_dst.vals[1][2];
        this->src_to_dst_matrix[8] = src_to_dst.vals[2][2];
    } else {
    #ifdef SK_DEBUG
        skcms_Matrix3x3 srcM, dstM;
        src->toXYZD50(&srcM);
        dst->toXYZD50(&dstM);
        SkASSERT(0 == memcmp(&srcM, &dstM, 9*sizeof(float)) && "Hash collision");
    #endif
    }
 
    // Fill out all the transfer functions we'll use.
    src->   transferFn(&this->srcTF   );
    dst->invTransferFn(&this->dstTFInv);
 
    // If we linearize then immediately reencode with the same transfer function, skip both.
    if ( this->flags.linearize       &&
        !this->flags.gamut_transform &&
         this->flags.encode          &&
         src->transferFnHash() == dst->transferFnHash())
    {
    #ifdef SK_DEBUG
        skcms_TransferFunction dstTF;
        dst->transferFn(&dstTF);
        for (int i = 0; i < 7; i++) {
            SkASSERT( (&srcTF.g)[i] == (&dstTF.g)[i] && "Hash collision" );
        }
    #endif
        this->flags.linearize  = false;
        this->flags.encode     = false;
    }
 
    // Skip unpremul...premul if there are no non-linear operations between.
    if ( this->flags.unpremul   &&
        !this->flags.linearize  &&
        !this->flags.encode     &&
         this->flags.premul)
    {
        this->flags.unpremul = false;
        this->flags.premul   = false;
    }
}

SkColorSpaceXformSteps() [3/3]

template<typename S , typename D >

SkColorSpaceXformSteps::SkColorSpaceXformSteps ( const S &  src, const D &  dst  )

inline

Definition at line 42 of file SkColorSpaceXformSteps.h.

        : SkColorSpaceXformSteps(src.colorSpace(), src.alphaType(),
                                 dst.colorSpace(), dst.alphaType()) {}

Member Function Documentation

apply() [1/2]

void SkColorSpaceXformSteps::apply

(

float

rgba[4]

)

const

apply() [2/2]

void SkColorSpaceXformSteps::apply

(

SkRasterPipeline *

p

)

const

Definition at line 139 of file SkColorSpaceXformSteps.cpp.

                                                            {
    if (flags.unpremul)        { p->append(SkRasterPipelineOp::unpremul); }
    if (flags.linearize)       { p->appendTransferFunction(srcTF); }
    if (flags.gamut_transform) { p->append(SkRasterPipelineOp::matrix_3x3, &src_to_dst_matrix); }
    if (flags.encode)          { p->appendTransferFunction(dstTFInv); }
    if (flags.premul)          { p->append(SkRasterPipelineOp::premul); }
}

Member Data Documentation

dstTFInv

skcms_TransferFunction SkColorSpaceXformSteps::dstTFInv

Definition at line 52 of file SkColorSpaceXformSteps.h.

flags

Flags SkColorSpaceXformSteps::flags

Definition at line 49 of file SkColorSpaceXformSteps.h.

src_to_dst_matrix

float SkColorSpaceXformSteps::src_to_dst_matrix[9]

Definition at line 53 of file SkColorSpaceXformSteps.h.

srcTF

skcms_TransferFunction SkColorSpaceXformSteps::srcTF

Definition at line 51 of file SkColorSpaceXformSteps.h.

---

The documentation for this struct was generated from the following files:

• third_party/skia/src/core/SkColorSpaceXformSteps.h
• third_party/skia/src/core/SkColorSpaceXformSteps.cpp