SkJpegEncoderImpl Class Reference

#include <SkJpegEncoderImpl.h>

Inheritance diagram for SkJpegEncoderImpl:

Public Member Functions
	~SkJpegEncoderImpl () override
Public Member Functions inherited from SkEncoder
bool	encodeRows (int numRows)
virtual	~SkEncoder ()

Static Public Member Functions
static std::unique_ptr< SkEncoder >	MakeRGB (SkWStream *dst, const SkPixmap &src, const SkJpegEncoder::Options &options, const SkJpegMetadataEncoder::SegmentList &metadata)
static std::unique_ptr< SkEncoder >	MakeYUV (SkWStream *dst, const SkYUVAPixmaps &srcYUVA, const SkColorSpace *srcYUVAColorSpace, const SkJpegEncoder::Options &options, const SkJpegMetadataEncoder::SegmentList &metadata)

Protected Member Functions
bool	onEncodeRows (int numRows) override
Protected Member Functions inherited from SkEncoder
virtual bool	onEncodeRows (int numRows)=0
	SkEncoder (const SkPixmap &src, size_t storageBytes)

Additional Inherited Members
Protected Attributes inherited from SkEncoder
const SkPixmap &	fSrc
int	fCurrRow
skia_private::AutoTMalloc< uint8_t >	fStorage

Detailed Description

Definition at line 57 of file SkJpegEncoderImpl.h.

Constructor & Destructor Documentation

~SkJpegEncoderImpl()

SkJpegEncoderImpl::~SkJpegEncoderImpl ( )

override

Definition at line 336 of file SkJpegEncoderImpl.cpp.

{}

Member Function Documentation

MakeRGB()

std::unique_ptr< SkEncoder > SkJpegEncoderImpl::MakeRGB ( SkWStream *  dst, const SkPixmap &  src, const SkJpegEncoder::Options &  options, const SkJpegMetadataEncoder::SegmentList &  metadata  )

static

Definition at line 304 of file SkJpegEncoderImpl.cpp.

                                                                  {
    if (!SkPixmapIsValid(src)) {
        return nullptr;
    }
    std::unique_ptr<SkJpegEncoderMgr> encoderMgr = SkJpegEncoderMgr::Make(dst);
    skjpeg_error_mgr::AutoPushJmpBuf jmp(encoderMgr->errorMgr());
    if (setjmp(jmp)) {
        return nullptr;
    }
 
    if (!encoderMgr->initializeRGB(src.info(), options, metadataSegments)) {
        return nullptr;
    }
    return std::unique_ptr<SkJpegEncoderImpl>(new SkJpegEncoderImpl(std::move(encoderMgr), src));
}

MakeYUV()

std::unique_ptr< SkEncoder > SkJpegEncoderImpl::MakeYUV ( SkWStream *  dst, const SkYUVAPixmaps &  srcYUVA, const SkColorSpace *  srcYUVAColorSpace, const SkJpegEncoder::Options &  options, const SkJpegMetadataEncoder::SegmentList &  metadata  )

static

Definition at line 282 of file SkJpegEncoderImpl.cpp.

                                                                  {
    if (!srcYUVA.isValid()) {
        return nullptr;
    }
    std::unique_ptr<SkJpegEncoderMgr> encoderMgr = SkJpegEncoderMgr::Make(dst);
    skjpeg_error_mgr::AutoPushJmpBuf jmp(encoderMgr->errorMgr());
    if (setjmp(jmp)) {
        return nullptr;
    }
 
    if (!encoderMgr->initializeYUV(srcYUVA.pixmapsInfo(), options, metadataSegments)) {
        return nullptr;
    }
    return std::unique_ptr<SkJpegEncoderImpl>(
            new SkJpegEncoderImpl(std::move(encoderMgr), srcYUVA));
}

onEncodeRows()

bool SkJpegEncoderImpl::onEncodeRows ( int  numRows )

overrideprotectedvirtual

Implements SkEncoder.

Definition at line 338 of file SkJpegEncoderImpl.cpp.

                                                {
    skjpeg_error_mgr::AutoPushJmpBuf jmp(fEncoderMgr->errorMgr());
    if (setjmp(jmp)) {
        return false;
    }
 
    if (fSrcYUVA) {
        // TODO(ccameron): Consider using jpeg_write_raw_data, to avoid having to re-pack the data.
        for (int i = 0; i < numRows; i++) {
            yuva_copy_row(*fSrcYUVA, fCurrRow + i, fStorage.get());
            JSAMPLE* jpegSrcRow = fStorage.get();
            jpeg_write_scanlines(fEncoderMgr->cinfo(), &jpegSrcRow, 1);
        }
    } else {
        const size_t srcBytes = SkColorTypeBytesPerPixel(fSrc.colorType()) * fSrc.width();
        const size_t jpegSrcBytes = fEncoderMgr->cinfo()->input_components * fSrc.width();
        const void* srcRow = fSrc.addr(0, fCurrRow);
        for (int i = 0; i < numRows; i++) {
            JSAMPLE* jpegSrcRow = (JSAMPLE*)(const_cast<void*>(srcRow));
            if (fEncoderMgr->proc()) {
                sk_msan_assert_initialized(srcRow, SkTAddOffset<const void>(srcRow, srcBytes));
                fEncoderMgr->proc()((char*)fStorage.get(),
                                    (const char*)srcRow,
                                    fSrc.width(),
                                    fEncoderMgr->cinfo()->input_components);
                jpegSrcRow = fStorage.get();
                sk_msan_assert_initialized(jpegSrcRow,
                                           SkTAddOffset<const void>(jpegSrcRow, jpegSrcBytes));
            } else {
                // Same as above, but this repetition allows determining whether a
                // proc was used when msan asserts.
                sk_msan_assert_initialized(jpegSrcRow,
                                           SkTAddOffset<const void>(jpegSrcRow, jpegSrcBytes));
            }
 
            jpeg_write_scanlines(fEncoderMgr->cinfo(), &jpegSrcRow, 1);
            srcRow = SkTAddOffset<const void>(srcRow, fSrc.rowBytes());
        }
    }
 
    fCurrRow += numRows;
    if (fCurrRow == fSrc.height()) {
        jpeg_finish_compress(fEncoderMgr->cinfo());
    }
 
    return true;
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/encode/SkJpegEncoderImpl.h
• third_party/skia/src/encode/SkJpegEncoderImpl.cpp