brianosman | 54f30c1 | 2016-07-18 10:53:52 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "include/core/SkColorSpace.h" |
| 9 | #include "src/core/SkColorSpacePriv.h" |
| 10 | #include "src/gpu/GrColorSpaceXform.h" |
| 11 | #include "src/gpu/glsl/GrGLSLColorSpaceXformHelper.h" |
| 12 | #include "src/gpu/glsl/GrGLSLFragmentProcessor.h" |
| 13 | #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h" |
Brian Osman | 7c2114f | 2016-10-20 15:34:06 -0400 | [diff] [blame] | 14 | |
Mike Klein | e03a176 | 2018-08-22 11:52:16 -0400 | [diff] [blame] | 15 | sk_sp<GrColorSpaceXform> GrColorSpaceXform::Make(SkColorSpace* src, SkAlphaType srcAT, |
| 16 | SkColorSpace* dst, SkAlphaType dstAT) { |
Mike Klein | e03a176 | 2018-08-22 11:52:16 -0400 | [diff] [blame] | 17 | SkColorSpaceXformSteps steps(src, srcAT, dst, dstAT); |
Brian Osman | 3567c14 | 2018-06-18 10:20:32 -0400 | [diff] [blame] | 18 | return steps.flags.mask() == 0 ? nullptr /* Noop transform */ |
| 19 | : sk_make_sp<GrColorSpaceXform>(steps); |
brianosman | 54f30c1 | 2016-07-18 10:53:52 -0700 | [diff] [blame] | 20 | } |
brianosman | 5a7ae7e | 2016-09-12 12:07:25 -0700 | [diff] [blame] | 21 | |
brianosman | b9c5137 | 2016-09-15 11:09:45 -0700 | [diff] [blame] | 22 | bool GrColorSpaceXform::Equals(const GrColorSpaceXform* a, const GrColorSpaceXform* b) { |
| 23 | if (a == b) { |
| 24 | return true; |
| 25 | } |
| 26 | |
Brian Osman | 3567c14 | 2018-06-18 10:20:32 -0400 | [diff] [blame] | 27 | if (!a || !b || a->fSteps.flags.mask() != b->fSteps.flags.mask()) { |
brianosman | b9c5137 | 2016-09-15 11:09:45 -0700 | [diff] [blame] | 28 | return false; |
| 29 | } |
| 30 | |
Brian Osman | 3567c14 | 2018-06-18 10:20:32 -0400 | [diff] [blame] | 31 | if (a->fSteps.flags.linearize && |
| 32 | 0 != memcmp(&a->fSteps.srcTF, &b->fSteps.srcTF, sizeof(a->fSteps.srcTF))) { |
Brian Osman | f06ead9 | 2017-10-30 13:47:41 -0400 | [diff] [blame] | 33 | return false; |
| 34 | } |
| 35 | |
Brian Osman | 3567c14 | 2018-06-18 10:20:32 -0400 | [diff] [blame] | 36 | if (a->fSteps.flags.gamut_transform && |
| 37 | 0 != memcmp(&a->fSteps.src_to_dst_matrix, &b->fSteps.src_to_dst_matrix, |
| 38 | sizeof(a->fSteps.src_to_dst_matrix))) { |
| 39 | return false; |
| 40 | } |
| 41 | |
| 42 | if (a->fSteps.flags.encode && |
| 43 | 0 != memcmp(&a->fSteps.dstTFInv, &b->fSteps.dstTFInv, sizeof(a->fSteps.dstTFInv))) { |
Brian Osman | f06ead9 | 2017-10-30 13:47:41 -0400 | [diff] [blame] | 44 | return false; |
| 45 | } |
| 46 | |
| 47 | return true; |
brianosman | b9c5137 | 2016-09-15 11:09:45 -0700 | [diff] [blame] | 48 | } |
| 49 | |
Brian Osman | f28e55d | 2018-10-03 16:35:54 -0400 | [diff] [blame] | 50 | SkColor4f GrColorSpaceXform::apply(const SkColor4f& srcColor) { |
| 51 | SkColor4f result = srcColor; |
| 52 | fSteps.apply(result.vec()); |
| 53 | return result; |
| 54 | } |
| 55 | |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 56 | ////////////////////////////////////////////////////////////////////////////// |
| 57 | |
| 58 | class GrGLColorSpaceXformEffect : public GrGLSLFragmentProcessor { |
| 59 | public: |
| 60 | void emitCode(EmitArgs& args) override { |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 61 | const GrColorSpaceXformEffect& proc = args.fFp.cast<GrColorSpaceXformEffect>(); |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 62 | GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; |
| 63 | GrGLSLUniformHandler* uniformHandler = args.fUniformHandler; |
| 64 | |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 65 | fColorSpaceHelper.emitCode(uniformHandler, proc.colorXform()); |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 66 | |
Brian Osman | 12c5d29 | 2020-07-13 16:11:35 -0400 | [diff] [blame^] | 67 | SkString childColor = this->invokeChild(0, args.fInputColor, args); |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 68 | |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 69 | SkString xformedColor; |
| 70 | fragBuilder->appendColorGamutXform(&xformedColor, childColor.c_str(), &fColorSpaceHelper); |
| 71 | fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, xformedColor.c_str()); |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 72 | } |
| 73 | |
| 74 | private: |
| 75 | void onSetData(const GrGLSLProgramDataManager& pdman, |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 76 | const GrFragmentProcessor& fp) override { |
| 77 | const GrColorSpaceXformEffect& proc = fp.cast<GrColorSpaceXformEffect>(); |
| 78 | fColorSpaceHelper.setData(pdman, proc.colorXform()); |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 79 | } |
| 80 | |
| 81 | GrGLSLColorSpaceXformHelper fColorSpaceHelper; |
| 82 | |
| 83 | typedef GrGLSLFragmentProcessor INHERITED; |
| 84 | }; |
| 85 | |
| 86 | ////////////////////////////////////////////////////////////////////////////// |
| 87 | |
| 88 | GrColorSpaceXformEffect::GrColorSpaceXformEffect(std::unique_ptr<GrFragmentProcessor> child, |
| 89 | sk_sp<GrColorSpaceXform> colorXform) |
| 90 | : INHERITED(kGrColorSpaceXformEffect_ClassID, OptFlags(child.get())) |
| 91 | , fColorXform(std::move(colorXform)) { |
Brian Osman | 54867de | 2020-07-10 14:22:57 -0400 | [diff] [blame] | 92 | this->registerChild(std::move(child)); |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 93 | } |
| 94 | |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 95 | GrColorSpaceXformEffect::GrColorSpaceXformEffect(const GrColorSpaceXformEffect& that) |
| 96 | : INHERITED(kGrColorSpaceXformEffect_ClassID, that.optimizationFlags()) |
| 97 | , fColorXform(that.fColorXform) { |
| 98 | this->cloneAndRegisterAllChildProcessors(that); |
| 99 | } |
| 100 | |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 101 | std::unique_ptr<GrFragmentProcessor> GrColorSpaceXformEffect::clone() const { |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 102 | return std::unique_ptr<GrFragmentProcessor>(new GrColorSpaceXformEffect(*this)); |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 103 | } |
| 104 | |
| 105 | bool GrColorSpaceXformEffect::onIsEqual(const GrFragmentProcessor& s) const { |
| 106 | const GrColorSpaceXformEffect& other = s.cast<GrColorSpaceXformEffect>(); |
| 107 | return GrColorSpaceXform::Equals(fColorXform.get(), other.fColorXform.get()); |
| 108 | } |
| 109 | |
| 110 | void GrColorSpaceXformEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps, |
| 111 | GrProcessorKeyBuilder* b) const { |
| 112 | b->add32(GrColorSpaceXform::XformKey(fColorXform.get())); |
| 113 | } |
| 114 | |
| 115 | GrGLSLFragmentProcessor* GrColorSpaceXformEffect::onCreateGLSLInstance() const { |
| 116 | return new GrGLColorSpaceXformEffect(); |
| 117 | } |
| 118 | |
| 119 | GrFragmentProcessor::OptimizationFlags GrColorSpaceXformEffect::OptFlags( |
| 120 | const GrFragmentProcessor* child) { |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 121 | return (child ? ProcessorOptimizationFlags(child) : kAll_OptimizationFlags) & |
| 122 | (kCompatibleWithCoverageAsAlpha_OptimizationFlag | |
Brian Osman | 5d92ae2 | 2020-01-31 15:54:33 -0500 | [diff] [blame] | 123 | kPreservesOpaqueInput_OptimizationFlag | |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 124 | kConstantOutputForConstantInput_OptimizationFlag); |
Brian Osman | 3567c14 | 2018-06-18 10:20:32 -0400 | [diff] [blame] | 125 | } |
| 126 | |
Brian Osman | 5d92ae2 | 2020-01-31 15:54:33 -0500 | [diff] [blame] | 127 | SkPMColor4f GrColorSpaceXformEffect::constantOutputForConstantInput( |
| 128 | const SkPMColor4f& input) const { |
Brian Osman | 12c5d29 | 2020-07-13 16:11:35 -0400 | [diff] [blame^] | 129 | const auto c0 = ConstantOutputForConstantInput(this->childProcessor(0), input); |
Brian Osman | 5d92ae2 | 2020-01-31 15:54:33 -0500 | [diff] [blame] | 130 | return this->fColorXform->apply(c0.unpremul()).premul(); |
| 131 | } |
| 132 | |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 133 | std::unique_ptr<GrFragmentProcessor> GrColorSpaceXformEffect::Make( |
| 134 | std::unique_ptr<GrFragmentProcessor> child, |
| 135 | SkColorSpace* src, SkAlphaType srcAT, |
| 136 | SkColorSpace* dst, SkAlphaType dstAT) { |
| 137 | return Make(std::move(child), GrColorSpaceXform::Make(src, srcAT, dst, dstAT)); |
Brian Osman | c4f93ca | 2017-10-17 17:15:52 -0400 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | std::unique_ptr<GrFragmentProcessor> GrColorSpaceXformEffect::Make( |
| 141 | std::unique_ptr<GrFragmentProcessor> child, |
John Stiles | 3e62762 | 2020-06-29 12:47:04 -0400 | [diff] [blame] | 142 | sk_sp<GrColorSpaceXform> colorXform) { |
Michael Ludwig | a3c45c7 | 2019-01-17 17:26:48 -0500 | [diff] [blame] | 143 | if (!colorXform) { |
| 144 | return child; |
| 145 | } |
| 146 | |
| 147 | return std::unique_ptr<GrFragmentProcessor>(new GrColorSpaceXformEffect(std::move(child), |
| 148 | std::move(colorXform))); |
| 149 | } |