RasterPipelineCodeGeneratorTest.cpp File Reference

#include "include/core/SkColor.h"
#include "include/core/SkTypes.h"
#include "src/base/SkArenaAlloc.h"
#include "src/core/SkRasterPipeline.h"
#include "src/sksl/SkSLCompiler.h"
#include "src/sksl/SkSLProgramKind.h"
#include "src/sksl/SkSLProgramSettings.h"
#include "src/sksl/SkSLUtil.h"
#include "src/sksl/codegen/SkSLRasterPipelineBuilder.h"
#include "src/sksl/codegen/SkSLRasterPipelineCodeGenerator.h"
#include "src/sksl/ir/SkSLFunctionDeclaration.h"
#include "src/sksl/ir/SkSLProgram.h"
#include "src/sksl/tracing/SkSLDebugTracePriv.h"
#include "tests/Test.h"
#include <memory>
#include <optional>
#include <string>

Go to the source code of this file.

Functions
static void	test (skiatest::Reporter *r, const char *src, SkSpan< const float > uniforms, SkColor4f startingColor, std::optional< SkColor4f > expectedResult)
	DEF_TEST (SkSLRasterPipelineCodeGeneratorNestedTernaryTest, r)
	DEF_TEST (SkSLRasterPipelineCodeGeneratorArithmeticTest, r)
	DEF_TEST (SkSLRasterPipelineCodeGeneratorCoercedTypeTest, r)
	DEF_TEST (SkSLRasterPipelineCodeGeneratorIdentitySwizzle, r)
	DEF_TEST (SkSLRasterPipelineCodeGeneratorBitwiseNotTest, r)
	DEF_TEST (SkSLRasterPipelineCodeGeneratorComparisonIntrinsicTest, r)

Function Documentation

DEF_TEST() [1/6]

DEF_TEST	(	SkSLRasterPipelineCodeGeneratorArithmeticTest	,
		r
	)

Definition at line 115 of file RasterPipelineCodeGeneratorTest.cpp.

          {},
         /*startingColor=*/SkColor4f{0.0, 0.0, 0.0, 0.0},
         /*expectedResult=*/SkColor4f{0.499f, 0.499f, 0.499f, 0.499f});
}
 
DEF_TEST(SkSLRasterPipelineCodeGeneratorArithmeticTest, r) {

DEF_TEST() [2/6]

DEF_TEST	(	SkSLRasterPipelineCodeGeneratorBitwiseNotTest	,
		r
	)

Definition at line 144 of file RasterPipelineCodeGeneratorTest.cpp.

                                         {0.0, 1.0, 0.0, 1.0,
                                          1.0, 0.0, 0.0, 1.0};
    test(r,
         R"__SkSL__(
             uniform half4 colorGreen;
             uniform float4 colorRed;
             half4 main(half4 color) {
                 return ((colorGreen + colorRed) == float4(1.0, 1.0, 0.0, 2.0)) ? colorGreen
                                                                                : colorGreen.gr01;

DEF_TEST() [3/6]

DEF_TEST	(	SkSLRasterPipelineCodeGeneratorCoercedTypeTest	,
		r
	)

Definition at line 123 of file RasterPipelineCodeGeneratorTest.cpp.

                              {
                const half4 colorGreen = half4(0,1,0,1), colorRed = half4(1,0,0,1);
 
                half a = 3.0, b = 4.0, c = a + b - 2.0;
                if (a*a + b*b == c*c*c/5.0) {
                    int A = 3, B = 4, C = A + B - 2;
                    if (A*A + B*B == C*C*C/5) {
                        return colorGreen;

DEF_TEST() [4/6]

DEF_TEST	(	SkSLRasterPipelineCodeGeneratorComparisonIntrinsicTest	,
		r
	)

Definition at line 154 of file RasterPipelineCodeGeneratorTest.cpp.

                   {0.0, 0.0, 0.0, 0.0},
         /*expectedResult=*/SkColor4f{0.0, 1.0, 0.0, 1.0});
}
 
DEF_TEST(SkSLRasterPipelineCodeGeneratorIdentitySwizzle, r) {

DEF_TEST() [5/6]

DEF_TEST	(	SkSLRasterPipelineCodeGeneratorIdentitySwizzle	,
		r
	)

Definition at line 133 of file RasterPipelineCodeGeneratorTest.cpp.

          {},
         /*startingColor=*/SkColor4f{0.0, 0.0, 0.0, 0.0},
         /*expectedResult=*/SkColor4f{0.0f, 1.0f, 0.0f, 1.0f});
}
 

DEF_TEST() [6/6]

DEF_TEST	(	SkSLRasterPipelineCodeGeneratorNestedTernaryTest	,
		r
	)

Definition at line 106 of file RasterPipelineCodeGeneratorTest.cpp.

                                                              {
    // Add in your SkSL here.
    test(r,
         R"__SkSL__(
             half4 main(half4) {
                 half three = 3, one = 1, two = 2;
                 half result = (three > (one > two ? 2.0 : 5.0)) ? 1.0 : 0.499;
                 return half4(result);

test()

static void test ( skiatest::Reporter *  r, const char *  src, SkSpan< const float >  uniforms, SkColor4f  startingColor, std::optional< SkColor4f >  expectedResult  )

static

Definition at line 32 of file RasterPipelineCodeGeneratorTest.cpp.

                                                        {
    SkSL::Compiler compiler;
    SkSL::ProgramSettings settings;
    settings.fMaxVersionAllowed = SkSL::Version::k300;
    std::unique_ptr<SkSL::Program> program = compiler.convertProgram(
            SkSL::ProgramKind::kRuntimeColorFilter, std::string(src), settings);
    if (!program) {
        ERRORF(r, "Unexpected error compiling %s\n%s", src, compiler.errorText().c_str());
        return;
    }
    const SkSL::FunctionDeclaration* main = program->getFunction("main");
    if (!main) {
        ERRORF(r, "Program must have a 'main' function");
        return;
    }
    SkArenaAlloc alloc(/*firstHeapAllocation=*/1000);
    SkRasterPipeline pipeline(&alloc);
    pipeline.appendConstantColor(&alloc, startingColor);
    SkSL::DebugTracePriv debugTrace;
    std::unique_ptr<SkSL::RP::Program> rasterProg =
            SkSL::MakeRasterPipelineProgram(*program, *main->definition(), &debugTrace);
    if (!rasterProg && !expectedResult.has_value()) {
        // We didn't get a program, as expected. Test passes.
        return;
    }
    if (!rasterProg && expectedResult.has_value()) {
        ERRORF(r, "MakeRasterPipelineProgram failed");
        return;
    }
    if (rasterProg && !expectedResult.has_value()) {
        ERRORF(r, "MakeRasterPipelineProgram should have failed, but didn't");
        return;
    }
 
#if defined(DUMP_PROGRAMS)
    // Dump the program instructions via SkDebugf.
    SkDebugf("-----\n\n");
    SkDebugfStream stream;
    rasterProg->dump(&stream);
    SkDebugf("\n-----\n\n");
#endif
 
    // Append the SkSL program to the raster pipeline.
    rasterProg->appendStages(&pipeline, &alloc, /*callbacks=*/nullptr, uniforms);
 
    // Move the float values from RGBA into an 8888 memory buffer.
    uint32_t out[SkRasterPipeline_kMaxStride_highp] = {};
    SkRasterPipeline_MemoryCtx outCtx{/*pixels=*/out, /*stride=*/SkRasterPipeline_kMaxStride_highp};
    pipeline.append(SkRasterPipelineOp::store_8888, &outCtx);
    pipeline.run(0, 0, 1, 1);
 
    // Make sure the first pixel (exclusively) of `out` matches RGBA.
    uint32_t expected = expectedResult->toBytes_RGBA();
    REPORTER_ASSERT(r, out[0] == expected,
                    "Got:%02X%02X%02X%02X Expected:%02X%02X%02X%02X",
                    (out[0] >> 24) & 0xFF,
                    (out[0] >> 16) & 0xFF,
                    (out[0] >> 8) & 0xFF,
                    out[0] & 0xFF,
                    (expected >> 24) & 0xFF,
                    (expected >> 16) & 0xFF,
                    (expected >> 8) & 0xFF,
                    expected & 0xFF);
 
    // Make sure the rest of the pixels are untouched.
    for (size_t i = 1; i < std::size(out); ++i) {
        REPORTER_ASSERT(r, out[i] == 0);
    }
}