SkPngEncoderImpl.cpp File Reference

#include "src/encode/SkPngEncoderImpl.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
#include "include/core/SkDataTable.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/encode/SkEncoder.h"
#include "include/encode/SkPngEncoder.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkNoncopyable.h"
#include "include/private/base/SkTemplates.h"
#include "modules/skcms/skcms.h"
#include "src/base/SkMSAN.h"
#include "src/codec/SkPngPriv.h"
#include "src/encode/SkImageEncoderFns.h"
#include "src/encode/SkImageEncoderPriv.h"
#include "src/image/SkImage_Base.h"
#include <algorithm>
#include <csetjmp>
#include <cstdint>
#include <cstring>
#include <memory>
#include <utility>
#include <vector>
#include <png.h>
#include <pngconf.h>

Go to the source code of this file.

Classes
class	SkPngEncoderMgr

Namespaces
namespace	SkPngEncoder

Functions
static void	sk_error_fn (png_structp png_ptr, png_const_charp msg)
static void	sk_write_fn (png_structp png_ptr, png_bytep data, png_size_t len)
static transform_scanline_proc	choose_proc (const SkImageInfo &info)
static void	set_icc (png_structp png_ptr, png_infop info_ptr, const SkImageInfo &info, const skcms_ICCProfile *profile, const char *profile_description)
SK_API std::unique_ptr< SkEncoder >	SkPngEncoder::Make (SkWStream *dst, const SkPixmap &src, const Options &options)
SK_API bool	SkPngEncoder::Encode (SkWStream *dst, const SkPixmap &src, const Options &options)
SK_API sk_sp< SkData >	SkPngEncoder::Encode (GrDirectContext *ctx, const SkImage *img, const Options &options)

Variables
static constexpr bool	kSuppressPngEncodeWarnings = true

Function Documentation

choose_proc()

static transform_scanline_proc choose_proc ( const SkImageInfo &  info )

static

Definition at line 267 of file SkPngEncoderImpl.cpp.

                                                                    {
    switch (info.colorType()) {
        case kUnknown_SkColorType:
            break;
 
        // TODO: I don't think this can just use kRGBA's procs.
        // kPremul is especially tricky here, since it's presumably TF⁻¹(rgb * a),
        // so to get at unpremul rgb we'd need to undo the transfer function first.
        case kSRGBA_8888_SkColorType:
            return nullptr;
 
        case kRGBA_8888_SkColorType:
            switch (info.alphaType()) {
                case kOpaque_SkAlphaType:
                    return transform_scanline_RGBX;
                case kUnpremul_SkAlphaType:
                    return transform_scanline_memcpy;
                case kPremul_SkAlphaType:
                    return transform_scanline_rgbA;
                default:
                    SkDEBUGFAIL("unknown alpha type");
                    return nullptr;
            }
        case kBGRA_8888_SkColorType:
            switch (info.alphaType()) {
                case kOpaque_SkAlphaType:
                    return transform_scanline_BGRX;
                case kUnpremul_SkAlphaType:
                    return transform_scanline_BGRA;
                case kPremul_SkAlphaType:
                    return transform_scanline_bgrA;
                default:
                    SkDEBUGFAIL("unknown alpha type");
                    return nullptr;
            }
        case kRGB_565_SkColorType:
            return transform_scanline_565;
        case kRGB_888x_SkColorType:
            return transform_scanline_RGBX;
        case kARGB_4444_SkColorType:
            switch (info.alphaType()) {
                case kOpaque_SkAlphaType:
                    return transform_scanline_444;
                case kPremul_SkAlphaType:
                    return transform_scanline_4444;
                default:
                    SkDEBUGFAIL("unknown alpha type");
                    return nullptr;
            }
        case kGray_8_SkColorType:
            return transform_scanline_memcpy;
 
        case kRGBA_F16Norm_SkColorType:
        case kRGBA_F16_SkColorType:
            switch (info.alphaType()) {
                case kOpaque_SkAlphaType:
                case kUnpremul_SkAlphaType:
                    return transform_scanline_F16;
                case kPremul_SkAlphaType:
                    return transform_scanline_F16_premul;
                default:
                    SkDEBUGFAIL("unknown alpha type");
                    return nullptr;
            }
        case kRGBA_F32_SkColorType:
            switch (info.alphaType()) {
                case kOpaque_SkAlphaType:
                case kUnpremul_SkAlphaType:
                    return transform_scanline_F32;
                case kPremul_SkAlphaType:
                    return transform_scanline_F32_premul;
                default:
                    SkDEBUGFAIL("unknown alpha type");
                    return nullptr;
            }
        case kRGBA_1010102_SkColorType:
            switch (info.alphaType()) {
                case kOpaque_SkAlphaType:
                case kUnpremul_SkAlphaType:
                    return transform_scanline_1010102;
                case kPremul_SkAlphaType:
                    return transform_scanline_1010102_premul;
                default:
                    SkDEBUGFAIL("unknown alpha type");
                    return nullptr;
            }
        case kBGRA_1010102_SkColorType:
            switch (info.alphaType()) {
                case kOpaque_SkAlphaType:
                case kUnpremul_SkAlphaType:
                    return transform_scanline_bgra_1010102;
                case kPremul_SkAlphaType:
                    return transform_scanline_bgra_1010102_premul;
                default:
                    SkDEBUGFAIL("unknown alpha type");
                    return nullptr;
            }
        case kRGB_101010x_SkColorType:
            return transform_scanline_101010x;
        case kBGR_101010x_SkColorType:
            return transform_scanline_bgr_101010x;
        case kBGR_101010x_XR_SkColorType:
            switch (info.alphaType()) {
                case kOpaque_SkAlphaType:
                    return transform_scanline_bgr_101010x_xr;
                default:
                    SkDEBUGFAIL("unsupported color type");
                    return nullptr;
            }
        case kBGRA_10101010_XR_SkColorType:
            return transform_scanline_bgra_10101010_xr;
        case kAlpha_8_SkColorType:
            return transform_scanline_A8_to_GrayAlpha;
        case kR8G8_unorm_SkColorType:
        case kR16G16_unorm_SkColorType:
        case kR16G16_float_SkColorType:
        case kA16_unorm_SkColorType:
        case kA16_float_SkColorType:
        case kR16G16B16A16_unorm_SkColorType:
        case kR8_unorm_SkColorType:
        case kRGBA_10x6_SkColorType:
            return nullptr;
    }
    SkDEBUGFAIL("unsupported color type");
    return nullptr;
}

set_icc()

static void set_icc ( png_structp  png_ptr, png_infop  info_ptr, const SkImageInfo &  info, const skcms_ICCProfile *  profile, const char *  profile_description  )

static

Definition at line 394 of file SkPngEncoderImpl.cpp.

                                                     {
    sk_sp<SkData> icc = icc_from_color_space(info, profile, profile_description);
    if (!icc) {
        return;
    }
 
#if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5)
    const char* name = "Skia";
    png_const_bytep iccPtr = icc->bytes();
#else
    SkString str("Skia");
    char* name = str.data();
    png_charp iccPtr = (png_charp)icc->writable_data();
#endif
    png_set_iCCP(png_ptr, info_ptr, name, 0, iccPtr, icc->size());
}

sk_error_fn()

static void sk_error_fn ( png_structp  png_ptr, png_const_charp  msg  )

static

Definition at line 57 of file SkPngEncoderImpl.cpp.

                                                                  {
    if (!kSuppressPngEncodeWarnings) {
        SkDebugf("libpng encode error: %s\n", msg);
    }
 
    longjmp(png_jmpbuf(png_ptr), 1);
}

sk_write_fn()

static void sk_write_fn ( png_structp  png_ptr, png_bytep  data, png_size_t  len  )

static

Definition at line 65 of file SkPngEncoderImpl.cpp.

                                                                             {
    SkWStream* stream = (SkWStream*)png_get_io_ptr(png_ptr);
    if (!stream->write(data, len)) {
        png_error(png_ptr, "sk_write_fn cannot write to stream");
    }
}

Variable Documentation

kSuppressPngEncodeWarnings

constexpr bool kSuppressPngEncodeWarnings = true

staticconstexpr

Definition at line 55 of file SkPngEncoderImpl.cpp.