SkPngCodec.cpp File Reference

#include "src/codec/SkPngCodec.h"
#include "include/codec/SkPngChunkReader.h"
#include "include/codec/SkPngDecoder.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkStream.h"
#include "include/core/SkTypes.h"
#include "include/private/SkEncodedInfo.h"
#include "include/private/base/SkNoncopyable.h"
#include "include/private/base/SkTemplates.h"
#include "modules/skcms/skcms.h"
#include "src/codec/SkCodecPriv.h"
#include "src/codec/SkColorPalette.h"
#include "src/codec/SkPngPriv.h"
#include "src/codec/SkSwizzler.h"
#include "src/core/SkMemset.h"
#include "src/core/SkSwizzlePriv.h"
#include <csetjmp>
#include <algorithm>
#include <cstring>
#include <utility>
#include <png.h>
#include <pngconf.h>

Go to the source code of this file.

Classes
class	AutoCleanPng
class	SkPngNormalDecoder
class	SkPngInterlacedDecoder

Namespaces
namespace	SkPngDecoder

Macros
#define	PNG_JMPBUF(x)   png_jmpbuf((png_structp) x)

Functions
static void	sk_error_fn (png_structp png_ptr, png_const_charp msg)
void	sk_warning_fn (png_structp, png_const_charp msg)
static bool	is_chunk (const png_byte *chunk, const char *tag)
static bool	process_data (png_structp png_ptr, png_infop info_ptr, SkStream *stream, void *buffer, size_t bufferSize, size_t length)
static bool	needs_premul (SkAlphaType dstAT, SkEncodedInfo::Alpha encodedAlpha)
std::unique_ptr< SkEncodedInfo::ICCProfile >	read_color_profile (png_structp png_ptr, png_infop info_ptr)
static skcms_PixelFormat	png_select_xform_format (const SkEncodedInfo &info)
static SkCodec::Result	log_and_return_error (bool success)
static SkCodec::Result	read_header (SkStream *stream, SkPngChunkReader *chunkReader, SkCodec **outCodec, png_structp *png_ptrp, png_infop *info_ptrp)
SK_API bool	SkPngDecoder::IsPng (const void *, size_t)
SK_API std::unique_ptr< SkCodec >	SkPngDecoder::Decode (std::unique_ptr< SkStream >, SkCodec::Result *, SkCodecs::DecodeContext=nullptr)
SK_API std::unique_ptr< SkCodec >	SkPngDecoder::Decode (sk_sp< SkData >, SkCodec::Result *, SkCodecs::DecodeContext=nullptr)

Variables
constexpr int	kSetJmpOkay = 0
constexpr int	kPngError = 1
constexpr int	kStopDecoding = 2
static constexpr SkColorType	kXformSrcColorType = kRGBA_8888_SkColorType

Macro Definition Documentation

PNG_JMPBUF

#define PNG_JMPBUF

(

x

)

png_jmpbuf((png_structp) x)

Definition at line 54 of file SkPngCodec.cpp.

Function Documentation

is_chunk()

static bool is_chunk ( const png_byte *  chunk, const char *  tag  )

inlinestatic

Definition at line 147 of file SkPngCodec.cpp.

                                                                    {
    return memcmp(chunk + 4, tag, 4) == 0;
}

log_and_return_error()

static SkCodec::Result log_and_return_error ( bool  success )

static

Definition at line 501 of file SkPngCodec.cpp.

                                                        {
    if (success) return SkCodec::kIncompleteInput;
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
    SkAndroidFrameworkUtils::SafetyNetLog("117838472");
#endif
    return SkCodec::kErrorInInput;
}

needs_premul()

static bool needs_premul ( SkAlphaType  dstAT, SkEncodedInfo::Alpha  encodedAlpha  )

inlinestatic

Definition at line 270 of file SkPngCodec.cpp.

                                                                                    {
    return kPremul_SkAlphaType == dstAT && SkEncodedInfo::kUnpremul_Alpha == encodedAlpha;
}

png_select_xform_format()

static skcms_PixelFormat png_select_xform_format ( const SkEncodedInfo &  info )

static

Definition at line 471 of file SkPngCodec.cpp.

                                                                            {
    // We use kRGB and kRGBA formats because color PNGs are always RGB or RGBA.
    if (16 == info.bitsPerComponent()) {
        if (SkEncodedInfo::kRGBA_Color == info.color()) {
            return skcms_PixelFormat_RGBA_16161616BE;
        } else if (SkEncodedInfo::kRGB_Color == info.color()) {
            return skcms_PixelFormat_RGB_161616BE;
        }
    } else if (SkEncodedInfo::kGray_Color == info.color()) {
        return skcms_PixelFormat_G_8;
    }
 
    return skcms_PixelFormat_RGBA_8888;
}

process_data()

static bool process_data ( png_structp  png_ptr, png_infop  info_ptr, SkStream *  stream, void *  buffer, size_t  bufferSize, size_t  length  )

inlinestatic

Definition at line 151 of file SkPngCodec.cpp.

                                                                          {
    while (length > 0) {
        const size_t bytesToProcess = std::min(bufferSize, length);
        const size_t bytesRead = stream->read(buffer, bytesToProcess);
        png_process_data(png_ptr, info_ptr, (png_bytep) buffer, bytesRead);
        if (bytesRead < bytesToProcess) {
            return false;
        }
        length -= bytesToProcess;
    }
    return true;
}

read_color_profile()

std::unique_ptr< SkEncodedInfo::ICCProfile > read_color_profile	(	png_structp	png_ptr,
		png_infop	info_ptr
	)

Definition at line 366 of file SkPngCodec.cpp.

                                                                                  {
 
#if (PNG_LIBPNG_VER_MAJOR > 1) || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 6)
    // First check for an ICC profile
    png_bytep profile;
    png_uint_32 length;
    // The below variables are unused, however, we need to pass them in anyway or
    // png_get_iCCP() will return nothing.
    // Could knowing the |name| of the profile ever be interesting?  Maybe for debugging?
    png_charp name;
    // The |compression| is uninteresting since:
    //   (1) libpng has already decompressed the profile for us.
    //   (2) "deflate" is the only mode of decompression that libpng supports.
    int compression;
    if (PNG_INFO_iCCP == png_get_iCCP(png_ptr, info_ptr, &name, &compression, &profile,
            &length)) {
        auto data = SkData::MakeWithCopy(profile, length);
        return SkEncodedInfo::ICCProfile::Make(std::move(data));
    }
 
    // Second, check for sRGB.
    // Note that Blink does this first. This code checks ICC first, with the thinking that
    // an image has both truly wants the potentially more specific ICC chunk, with sRGB as a
    // backup in case the decoder does not support full color management.
    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sRGB)) {
        // sRGB chunks also store a rendering intent: Absolute, Relative,
        // Perceptual, and Saturation.
        // FIXME (scroggo): Extract this information from the sRGB chunk once
        //                  we are able to handle this information in
        //                  skcms_ICCProfile
        return nullptr;
    }
 
    // Default to SRGB gamut.
    skcms_Matrix3x3 toXYZD50 = skcms_sRGB_profile()->toXYZD50;
    // Next, check for chromaticities.
    png_fixed_point chrm[8];
    png_fixed_point gamma;
    if (png_get_cHRM_fixed(png_ptr, info_ptr, &chrm[0], &chrm[1], &chrm[2], &chrm[3], &chrm[4],
                           &chrm[5], &chrm[6], &chrm[7]))
    {
        float rx = png_fixed_point_to_float(chrm[2]);
        float ry = png_fixed_point_to_float(chrm[3]);
        float gx = png_fixed_point_to_float(chrm[4]);
        float gy = png_fixed_point_to_float(chrm[5]);
        float bx = png_fixed_point_to_float(chrm[6]);
        float by = png_fixed_point_to_float(chrm[7]);
        float wx = png_fixed_point_to_float(chrm[0]);
        float wy = png_fixed_point_to_float(chrm[1]);
 
        skcms_Matrix3x3 tmp;
        if (skcms_PrimariesToXYZD50(rx, ry, gx, gy, bx, by, wx, wy, &tmp)) {
            toXYZD50 = tmp;
        } else {
            // Note that Blink simply returns nullptr in this case. We'll fall
            // back to srgb.
        }
    }
 
    skcms_TransferFunction fn;
    if (PNG_INFO_gAMA == png_get_gAMA_fixed(png_ptr, info_ptr, &gamma)) {
        fn.a = 1.0f;
        fn.b = fn.c = fn.d = fn.e = fn.f = 0.0f;
        fn.g = png_inverted_fixed_point_to_float(gamma);
    } else {
        // Default to sRGB gamma if the image has color space information,
        // but does not specify gamma.
        // Note that Blink would again return nullptr in this case.
        fn = *skcms_sRGB_TransferFunction();
    }
 
    skcms_ICCProfile skcmsProfile;
    skcms_Init(&skcmsProfile);
    skcms_SetTransferFunction(&skcmsProfile, &fn);
    skcms_SetXYZD50(&skcmsProfile, &toXYZD50);
 
    return SkEncodedInfo::ICCProfile::Make(skcmsProfile);
#else // LIBPNG >= 1.6
    return nullptr;
#endif // LIBPNG >= 1.6
}

read_header()

static SkCodec::Result read_header ( SkStream *  stream, SkPngChunkReader *  chunkReader, SkCodec **  outCodec, png_structp *  png_ptrp, png_infop *  info_ptrp  )

static

Definition at line 795 of file SkPngCodec.cpp.

                                                                                {
    // The image is known to be a PNG. Decode enough to know the SkImageInfo.
    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr,
                                                 sk_error_fn, sk_warning_fn);
    if (!png_ptr) {
        return SkCodec::kInternalError;
    }
 
#ifdef PNG_SET_OPTION_SUPPORTED
    // This setting ensures that we display images with incorrect CMF bytes.
    // See crbug.com/807324.
    png_set_option(png_ptr, PNG_MAXIMUM_INFLATE_WINDOW, PNG_OPTION_ON);
#endif
 
    AutoCleanPng autoClean(png_ptr, stream, chunkReader, outCodec);
 
    png_infop info_ptr = png_create_info_struct(png_ptr);
    if (info_ptr == nullptr) {
        return SkCodec::kInternalError;
    }
 
    autoClean.setInfoPtr(info_ptr);
 
    if (setjmp(PNG_JMPBUF(png_ptr))) {
        return SkCodec::kInvalidInput;
    }
 
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
    // Hookup our chunkReader so we can see any user-chunks the caller may be interested in.
    // This needs to be installed before we read the png header.  Android may store ninepatch
    // chunks in the header.
    if (chunkReader) {
        png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_ALWAYS, (png_const_bytep)"", 0);
        png_set_read_user_chunk_fn(png_ptr, (png_voidp) chunkReader, sk_read_user_chunk);
    }
#endif
 
    const bool decodedBounds = autoClean.decodeBounds();
 
    if (!decodedBounds) {
        return SkCodec::kIncompleteInput;
    }
 
    // On success, decodeBounds releases ownership of png_ptr and info_ptr.
    if (png_ptrp) {
        *png_ptrp = png_ptr;
    }
    if (info_ptrp) {
        *info_ptrp = info_ptr;
    }
 
    // decodeBounds takes care of setting outCodec
    if (outCodec) {
        SkASSERT(*outCodec);
    }
    return SkCodec::kSuccess;
}

sk_error_fn()

static void sk_error_fn ( png_structp  png_ptr, png_const_charp  msg  )

static

Definition at line 67 of file SkPngCodec.cpp.

                                                                  {
    SkCodecPrintf("------ png error %s\n", msg);
    longjmp(PNG_JMPBUF(png_ptr), kPngError);
}

sk_warning_fn()

void sk_warning_fn	(	png_structp	,
		png_const_charp	msg
	)

Definition at line 72 of file SkPngCodec.cpp.

                                                     {
    SkCodecPrintf("----- png warning %s\n", msg);
}

Variable Documentation

kPngError

constexpr int kPngError = 1

constexpr

Definition at line 63 of file SkPngCodec.cpp.

kSetJmpOkay

constexpr int kSetJmpOkay = 0

constexpr

Definition at line 61 of file SkPngCodec.cpp.

kStopDecoding

constexpr int kStopDecoding = 2

constexpr

Definition at line 65 of file SkPngCodec.cpp.

kXformSrcColorType

constexpr SkColorType kXformSrcColorType = kRGBA_8888_SkColorType

staticconstexpr

Definition at line 268 of file SkPngCodec.cpp.