png_codec.cpp File Reference

#include "gm/gm.h"
#include "include/codec/SkCodec.h"
#include "include/codec/SkEncodedImageFormat.h"
#include "include/codec/SkPngDecoder.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkImage.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTemplates.h"
#include "src/base/SkAutoMalloc.h"
#include "src/core/SkSwizzlePriv.h"
#include "src/utils/SkOSPath.h"
#include "tools/flags/CommandLineFlags.h"
#include "tools/flags/CommonFlags.h"
#include <map>
#include <memory>
#include <string>
#include <vector>

Go to the source code of this file.

Classes
struct	DecodeResult
class	PNGCodecGM

Functions
	DEFINE_string (pngCodecGMImages, "", "Zero or more images or directories where to find PNG images to test with " "PNGCodecGM. Directories are scanned non-recursively. All files are assumed to be " "PNG images.")
	DEFINE_string (pngCodecDecodeMode, "", "One of \"get-all-pixels\", \"incremental\" or \"zero-init\".")
	DEFINE_string (pngCodecDstColorType, "", "One of \"force-grayscale\", " "\"force-nonnative-premul-color\" or \"get-from-canvas\".")
	DEFINE_string (pngCodecDstAlphaType, "", "One of \"premul\" or \"unpremul\".")
static constexpr const char *	sk_color_type_to_str (SkColorType colorType)
static constexpr const char *	sk_alpha_type_to_str (SkAlphaType alphaType)
static DecodeResult	decode (std::string path)
static std::string	registerGMsForImage (std::string path, PNGCodecGM::DecodeMode decodeMode, PNGCodecGM::DstColorType dstColorType, SkAlphaType dstAlphaType)
static std::string	parse_and_validate_flags (PNGCodecGM::DecodeMode *decodeMode, PNGCodecGM::DstColorType *dstColorType, SkAlphaType *dstAlphaType)
	DEF_GM_REGISTERER_FN ([]() -> std::string { PNGCodecGM::DecodeMode decodeMode;PNGCodecGM::DstColorType dstColorType;SkAlphaType dstAlphaType;if(std::string errorMsg=parse_and_validate_flags(&decodeMode, &dstColorType, &dstAlphaType);errorMsg !="") { return errorMsg;} skia_private::TArray< SkString > images;if(!CommonFlags::CollectImages(FLAGS_pngCodecGMImages, &images)) { return "Failed to collect images.";} for(const SkString &image :images) { if(std::string errorMsg=registerGMsForImage(image.c_str(), decodeMode, dstColorType, dstAlphaType);errorMsg !="") { return errorMsg;} } return "";})

Function Documentation

decode()

static DecodeResult decode ( std::string  path )

static

Definition at line 124 of file png_codec.cpp.

                                           {
    sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
    if (!encoded) {
        return {.errorMsg = SkStringPrintf("Could not read \"%s\".", path.c_str()).c_str()};
    }
    SkCodec::Result result;
    std::unique_ptr<SkCodec> codec = SkPngDecoder::Decode(SkMemoryStream::Make(encoded), &result);
    if (result != SkCodec::Result::kSuccess) {
        return {.errorMsg = SkStringPrintf("Could not create codec for \"%s\": %s.",
                                           path.c_str(),
                                           SkCodec::ResultToString(result))
                                    .c_str()};
    }
    return {.codec = std::move(codec)};
}

DEF_GM_REGISTERER_FN()

DEF_GM_REGISTERER_FN

(

[] () -> std::string { PNGCodecGM::DecodeMode decodeMode;PNGCodecGM::DstColorType dstColorType;SkAlphaType dstAlphaType;if(std::string errorMsg=parse_and_validate_flags(&decodeMode, &dstColorType, &dstAlphaType);errorMsg !="") { return errorMsg;} skia_private::TArray< SkString > images;if(!CommonFlags::CollectImages(FLAGS_pngCodecGMImages, &images)) { return "Failed to collect images.";} for(const SkString &image :images) { if(std::string errorMsg=registerGMsForImage(image.c_str(), decodeMode, dstColorType, dstAlphaType);errorMsg !="") { return errorMsg;} } return "";}

)

DEFINE_string() [1/4]

DEFINE_string	(	pngCodecDecodeMode	,
		""	,
		"One of \"get-all-pixels\"	,
		\"incremental\" or \"zero-init\"."
	)

DEFINE_string() [2/4]

DEFINE_string	(	pngCodecDstAlphaType	,
		""	,
		"One of \"premul\" or \"unpremul\"."
	)

DEFINE_string() [3/4]

DEFINE_string	(	pngCodecDstColorType	,
		""	,
		"One of \"force-grayscale\"	,
		" "\"force-nonnative-premul-color\" or \"get-from-canvas\"."
	)

DEFINE_string() [4/4]

DEFINE_string	(	pngCodecGMImages	,
		""	,
		"Zero or more images or directories where to find PNG images to test with " "PNGCodecGM. Directories are scanned non-recursively. All files are assumed to be " "PNG images."
	)

parse_and_validate_flags()

static std::string parse_and_validate_flags ( PNGCodecGM::DecodeMode *  decodeMode, PNGCodecGM::DstColorType *  dstColorType, SkAlphaType *  dstAlphaType  )

static

Definition at line 466 of file png_codec.cpp.

                                                                       {
    skia_private::THashMap<SkString, PNGCodecGM::DecodeMode> decodeModeValues = {
            {SkString("get-all-pixels"), PNGCodecGM::DecodeMode::kGetAllPixels},
            {SkString("incremental"), PNGCodecGM::DecodeMode::kIncremental},
            {SkString("zero-init"), PNGCodecGM::DecodeMode::kZeroInit},
    };
    if (SkString errorMsg = FLAGS_pngCodecDecodeMode.parseAndValidate(
                "--pngCodecDecodeMode", decodeModeValues, decodeMode);
        errorMsg != SkString()) {
        return errorMsg.c_str();
    }
 
    skia_private::THashMap<SkString, PNGCodecGM::DstColorType> dstColorTypeValues = {
            {SkString("get-from-canvas"), PNGCodecGM::DstColorType::kGetFromCanvas},
            {SkString("force-grayscale"), PNGCodecGM::DstColorType::kForceGrayscale},
            {SkString("force-nonnative-premul-color"),
             PNGCodecGM::DstColorType::kForceNonNativePremulColor},
    };
    if (SkString errorMsg = FLAGS_pngCodecDstColorType.parseAndValidate(
                "--pngCodecDstColorType", dstColorTypeValues, dstColorType);
        errorMsg != SkString()) {
        return errorMsg.c_str();
    }
 
    skia_private::THashMap<SkString, SkAlphaType> dstAlphaTypeValues = {
            {SkString("premul"), kPremul_SkAlphaType},
            {SkString("unpremul"), kUnpremul_SkAlphaType},
    };
    if (SkString errorMsg = FLAGS_pngCodecDstAlphaType.parseAndValidate(
                "--pngCodecDstAlphaType", dstAlphaTypeValues, dstAlphaType);
        errorMsg != SkString()) {
        return errorMsg.c_str();
    }
 
    return "";
}

registerGMsForImage()

static std::string registerGMsForImage ( std::string  path, PNGCodecGM::DecodeMode  decodeMode, PNGCodecGM::DstColorType  dstColorType, SkAlphaType  dstAlphaType  )

static

Definition at line 429 of file png_codec.cpp.

                                                                 {
    DecodeResult decodeResult = decode(path);
    if (decodeResult.errorMsg != "") {
        return decodeResult.errorMsg;
    }
 
    if (dstColorType == PNGCodecGM::DstColorType::kForceGrayscale &&
        decodeResult.codec->getInfo().colorType() != kGray_8_SkColorType) {
        return SkStringPrintf(
                       "image \"%s\" has color type %s; this is incompatible with the given "
                       "dstColorType argument: %s (expected image color type: %s)",
                       path.c_str(),
                       sk_color_type_to_str(decodeResult.codec->getInfo().colorType()),
                       PNGCodecGM::DstColorTypeToString(PNGCodecGM::DstColorType::kForceGrayscale),
                       sk_color_type_to_str(kGray_8_SkColorType))
                .c_str();
    }
 
    if (dstAlphaType == kUnpremul_SkAlphaType &&
        decodeResult.codec->getInfo().alphaType() == kOpaque_SkAlphaType) {
        return SkStringPrintf(
                       "image \"%s\" has alpha type %s; this is incompatible with the given "
                       "dstAlphaType argument: %s",
                       path.c_str(),
                       sk_alpha_type_to_str(kOpaque_SkAlphaType),
                       sk_alpha_type_to_str(kUnpremul_SkAlphaType))
                .c_str();
    }
 
    skiagm::Register(new PNGCodecGM(path, decodeMode, dstColorType, dstAlphaType));
    return "";
}

sk_alpha_type_to_str()

static constexpr const char * sk_alpha_type_to_str ( SkAlphaType  alphaType )

staticconstexpr

Definition at line 105 of file png_codec.cpp.

                                                                         {
    switch (alphaType) {
        case kUnknown_SkAlphaType:
            return "kUnknown_SkAlphaType";
        case kOpaque_SkAlphaType:
            return "kOpaque_SkAlphaType";
        case kPremul_SkAlphaType:
            return "kPremul_SkAlphaType";
        case kUnpremul_SkAlphaType:
            return "kUnpremul_SkAlphaType";
    }
    SkUNREACHABLE;
}

sk_color_type_to_str()

static constexpr const char * sk_color_type_to_str ( SkColorType  colorType )

staticconstexpr

Definition at line 47 of file png_codec.cpp.

                                                                         {
    switch (colorType) {
        case kUnknown_SkColorType:
            return "kUnknown_SkColorType";
        case kAlpha_8_SkColorType:
            return "kAlpha_8_SkColorType";
        case kRGB_565_SkColorType:
            return "kRGB_565_SkColorType";
        case kARGB_4444_SkColorType:
            return "kARGB_4444_SkColorType";
        case kRGBA_8888_SkColorType:
            return "kRGBA_8888_SkColorType";
        case kRGB_888x_SkColorType:
            return "kRGB_888x_SkColorType";
        case kBGRA_8888_SkColorType:
            return "kBGRA_8888_SkColorType";
        case kRGBA_1010102_SkColorType:
            return "kRGBA_1010102_SkColorType";
        case kBGRA_1010102_SkColorType:
            return "kBGRA_1010102_SkColorType";
        case kRGB_101010x_SkColorType:
            return "kRGB_101010x_SkColorType";
        case kBGR_101010x_SkColorType:
            return "kBGR_101010x_SkColorType";
        case kBGR_101010x_XR_SkColorType:
            return "kBGR_101010x_XR_SkColorType";
        case kGray_8_SkColorType:
            return "kGray_8_SkColorType";
        case kRGBA_F16Norm_SkColorType:
            return "kRGBA_F16Norm_SkColorType";
        case kRGBA_F16_SkColorType:
            return "kRGBA_F16_SkColorType";
        case kRGBA_F32_SkColorType:
            return "kRGBA_F32_SkColorType";
        case kR8G8_unorm_SkColorType:
            return "kR8G8_unorm_SkColorType";
        case kA16_float_SkColorType:
            return "kA16_float_SkColorType";
        case kR16G16_float_SkColorType:
            return "kR16G16_float_SkColorType";
        case kA16_unorm_SkColorType:
            return "kA16_unorm_SkColorType";
        case kR16G16_unorm_SkColorType:
            return "kR16G16_unorm_SkColorType";
        case kR16G16B16A16_unorm_SkColorType:
            return "kR16G16B16A16_unorm_SkColorType";
        case kSRGBA_8888_SkColorType:
            return "kSRGBA_8888_SkColorType";
        case kR8_unorm_SkColorType:
            return "kR8_unorm_SkColorType";
        case kRGBA_10x6_SkColorType:
            return "kRGBA_10x6_SkColorType";
        case kBGRA_10101010_XR_SkColorType:
            return "kBGRA_10101010_XR_SkColorType";
    }
    SkUNREACHABLE;
}