skdiff_utils.h File Reference

#include "tools/skdiff/skdiff.h"

Go to the source code of this file.

Functions
bool	are_buffers_equal (SkData *skdata1, SkData *skdata2)
sk_sp< SkData >	read_file (const char *file_path)
bool	get_bitmap (sk_sp< SkData > fileBits, DiffResource &resource, bool sizeOnly, bool ignoreColorSpace)
bool	write_bitmap (const SkString &path, const SkBitmap &bitmap)
SkString	filename_to_diff_filename (const SkString &filename)
SkString	filename_to_white_filename (const SkString &filename)
void	create_and_write_diff_image (DiffRecord *drp, DiffMetricProc dmp, const int colorThreshold, const SkString &outputDir, const SkString &filename)

Function Documentation

are_buffers_equal()

bool are_buffers_equal	(	SkData *	skdata1,
		SkData *	skdata2
	)

Returns true if the two buffers passed in are both non-nullptr, have the same length, and contain exactly the same byte values.

Definition at line 19 of file skdiff_utils.cpp.

                                                         {
    if ((nullptr == skdata1) || (nullptr == skdata2)) {
        return false;
    }
    if (skdata1->size() != skdata2->size()) {
        return false;
    }
    return (0 == memcmp(skdata1->data(), skdata2->data(), skdata1->size()));
}

create_and_write_diff_image()

void create_and_write_diff_image	(	DiffRecord *	drp,
		DiffMetricProc	dmp,
		const int	colorThreshold,
		const SkString &	outputDir,
		const SkString &	filename
	)

Calls compute_diff and handles the difference and white diff resources. If !outputDir.isEmpty(), writes out difference and white images.

Definition at line 157 of file skdiff_utils.cpp.

                                                           {
    const int w = drp->fBase.fBitmap.width();
    const int h = drp->fBase.fBitmap.height();
 
    if (w != drp->fComparison.fBitmap.width() || h != drp->fComparison.fBitmap.height()) {
        drp->fResult = DiffRecord::kDifferentSizes_Result;
    } else {
        drp->fDifference.fBitmap.allocN32Pixels(w, h);
 
        drp->fWhite.fBitmap.allocN32Pixels(w, h);
 
        SkASSERT(DiffRecord::kUnknown_Result == drp->fResult);
        compute_diff(drp, dmp, colorThreshold);
        SkASSERT(DiffRecord::kUnknown_Result != drp->fResult);
    }
 
    if (outputDir.isEmpty()) {
        drp->fDifference.fStatus = DiffResource::kUnspecified_Status;
        drp->fWhite.fStatus = DiffResource::kUnspecified_Status;
 
    } else {
        drp->fDifference.fFilename = filename_to_diff_filename(filename);
        drp->fDifference.fFullPath = outputDir;
        drp->fDifference.fFullPath.append(drp->fDifference.fFilename);
        drp->fDifference.fStatus = DiffResource::kSpecified_Status;
 
        drp->fWhite.fFilename = filename_to_white_filename(filename);
        drp->fWhite.fFullPath = outputDir;
        drp->fWhite.fFullPath.append(drp->fWhite.fFilename);
        drp->fWhite.fStatus = DiffResource::kSpecified_Status;
 
        if (DiffRecord::kDifferentPixels_Result == drp->fResult) {
            if (write_bitmap(drp->fDifference.fFullPath, drp->fDifference.fBitmap)) {
                drp->fDifference.fStatus = DiffResource::kExists_Status;
            } else {
                drp->fDifference.fStatus = DiffResource::kDoesNotExist_Status;
            }
            if (write_bitmap(drp->fWhite.fFullPath, drp->fWhite.fBitmap)) {
                drp->fWhite.fStatus = DiffResource::kExists_Status;
            } else {
                drp->fWhite.fStatus = DiffResource::kDoesNotExist_Status;
            }
        }
    }
}

filename_to_diff_filename()

SkString filename_to_diff_filename

(

const SkString &

filename

)

Given an image filename, returns the name of the file containing the associated difference image.

Definition at line 149 of file skdiff_utils.cpp.

                                                             {
    return filename_to_derived_filename(filename, "-diff.png");
}

filename_to_white_filename()

SkString filename_to_white_filename

(

const SkString &

filename

)

Given an image filename, returns the name of the file containing the "white" difference image.

Definition at line 153 of file skdiff_utils.cpp.

                                                              {
    return filename_to_derived_filename(filename, "-white.png");
}

get_bitmap()

bool get_bitmap	(	sk_sp< SkData >	fileBits,
		DiffResource &	resource,
		bool	sizeOnly,
		bool	ignoreColorSpace
	)

Decodes the fileBits into the resource.fBitmap. Returns false on failure.

Definition at line 37 of file skdiff_utils.cpp.

                                       {
    static constexpr const SkCodecs::Decoder decoders[] = {
        SkPngDecoder::Decoder(),
    };
 
    auto codec = SkCodec::MakeFromData(std::move(fileBits), decoders);
    if (!codec) {
        SkDebugf("ERROR: could not create codec for <%s>\n", resource.fFullPath.c_str());
        resource.fStatus = DiffResource::kCouldNotDecode_Status;
        return false;
    }
 
    // If we're "ignoring" color space, then we want the raw pixel values from each image, so we
    // decode to the original color space. If we want to account for color spaces, then we want to
    // decode each image to the same color space, so that colors that are the "same" (but encoded
    // differently) are transformed to some canonical representation prior to comparison.
    //
    // TODO: Use something wider than sRGB to avoid clipping with out-of-gamut colors.
    SkImageInfo info = codec->getInfo().makeColorType(kN32_SkColorType);
    if (!ignoreColorSpace) {
        info = info.makeColorSpace(SkColorSpace::MakeSRGB());
    }
 
    if (!resource.fBitmap.setInfo(info.makeColorType(kN32_SkColorType))) {
        SkDebugf("ERROR: could not set bitmap info for <%s>\n", resource.fFullPath.c_str());
        resource.fStatus = DiffResource::kCouldNotDecode_Status;
        return false;
    }
 
    if (sizeOnly) {
        return true;
    }
 
    if (!resource.fBitmap.tryAllocPixels()) {
        SkDebugf("ERROR: could not allocate pixels for <%s>\n", resource.fFullPath.c_str());
        resource.fStatus = DiffResource::kCouldNotDecode_Status;
        return false;
    }
 
    if (SkCodec::kSuccess != codec->getPixels(resource.fBitmap.info(),
            resource.fBitmap.getPixels(), resource.fBitmap.rowBytes())) {
        SkDebugf("ERROR: codec failed for basePath <%s>\n", resource.fFullPath.c_str());
        resource.fStatus = DiffResource::kCouldNotDecode_Status;
        return false;
    }
 
    resource.fStatus = DiffResource::kDecoded_Status;
    return true;
}

read_file()

sk_sp< SkData > read_file

(

const char *

file_path

)

Reads the file at the given path and returns its complete contents as an SkData object (or returns nullptr on error).

Definition at line 29 of file skdiff_utils.cpp.

                                               {
    sk_sp<SkData> data(SkData::MakeFromFileName(file_path));
    if (!data) {
        SkDebugf("WARNING: could not open file <%s> for reading\n", file_path);
    }
    return data;
}

write_bitmap()

bool write_bitmap	(	const SkString &	path,
		const SkBitmap &	bitmap
	)

Writes the bitmap as a PNG to the path specified.

Definition at line 97 of file skdiff_utils.cpp.

                                                                {
    SkBitmap copy;
    if (!copy.tryAllocPixels(bitmap.info().makeColorType(kN32_SkColorType))) {
        return false;
    }
    if (!bitmap.readPixels(copy.pixmap())) {
        return false;
    }
    force_all_opaque(copy);
 
    SkFILEWStream file(path.c_str());
    if (!file.isValid()) {
        return false;
    }
 
    return SkPngEncoder::Encode(&file, copy.pixmap(), {});
}