SkJpegGainmapEncoder Class Reference

#include <SkJpegGainmapEncoder.h>

Static Public Member Functions
static bool	EncodeHDRGM (SkWStream *dst, const SkPixmap &base, const SkJpegEncoder::Options &baseOptions, const SkPixmap &gainmap, const SkJpegEncoder::Options &gainmapOptions, const SkGainmapInfo &gainmapInfo)
static bool	MakeMPF (SkWStream *dst, const SkData **images, size_t imageCount)

Detailed Description

Definition at line 17 of file SkJpegGainmapEncoder.h.

Member Function Documentation

EncodeHDRGM()

bool SkJpegGainmapEncoder::EncodeHDRGM ( SkWStream *  dst, const SkPixmap &  base, const SkJpegEncoder::Options &  baseOptions, const SkPixmap &  gainmap, const SkJpegEncoder::Options &  gainmapOptions, const SkGainmapInfo &  gainmapInfo  )

static

Encode an UltraHDR image to |dst|.

The base image is specified by |base|, and |baseOptions| controls the encoding behavior for the base image.

The gainmap image is specified by |gainmap|, and |gainmapOptions| controls the encoding behavior for the gainmap image.

The rendering behavior of the gainmap image is provided in |gainmapInfo|.

If |baseOptions| or |gainmapOptions| specify XMP metadata, then that metadata will be overwritten.

Returns true on success. Returns false on an invalid or unsupported |src|.

Definition at line 247 of file SkJpegGainmapEncoder.cpp.

                                                                         {
    // Encode the gainmap image with the HDRGM XMP metadata.
    sk_sp<SkData> gainmapData;
    {
        // We will include the HDRGM XMP metadata in the gainmap image.
        auto hdrgmXmp = get_hdrgm_xmp_data(gainmapInfo);
        gainmapData = encode_to_data(gainmap, gainmapOptions, hdrgmXmp.get());
        if (!gainmapData) {
            SkCodecPrintf("Failed to encode gainmap image.\n");
            return false;
        }
    }
 
    // Encode the base image with the Container XMP metadata.
    sk_sp<SkData> baseData;
    {
        auto containerXmp = get_gcontainer_xmp_data(static_cast<int32_t>(gainmapData->size()));
        baseData = encode_to_data(base, baseOptions, containerXmp.get());
        if (!baseData) {
            SkCodecPrintf("Failed to encode base image.\n");
            return false;
        }
    }
 
    // Combine them into an MPF.
    const SkData* images[] = {
            baseData.get(),
            gainmapData.get(),
    };
    return MakeMPF(dst, images, 2);
}

MakeMPF()

bool SkJpegGainmapEncoder::MakeMPF ( SkWStream *  dst, const SkData **  images, size_t  imageCount  )

static

Write a Multi Picture Format containing the |imageCount| images specified by |images|.

Definition at line 284 of file SkJpegGainmapEncoder.cpp.

                                                                                           {
    if (imageCount < 1) {
        return true;
    }
 
    // Create a scan of the primary image.
    SkJpegSegmentScanner primaryScan;
    primaryScan.onBytes(images[0]->data(), images[0]->size());
    if (!primaryScan.isDone()) {
        SkCodecPrintf("Failed to scan encoded primary image header.\n");
        return false;
    }
 
    // Copy the primary image up to its StartOfScan, then insert the MPF segment, then copy the rest
    // of the primary image, and all other images.
    size_t bytesRead = 0;
    size_t bytesWritten = 0;
    for (const auto& segment : primaryScan.getSegments()) {
        // Write all ECD before this segment.
        {
            size_t ecdBytesToWrite = segment.offset - bytesRead;
            if (!dst->write(images[0]->bytes() + bytesRead, ecdBytesToWrite)) {
                SkCodecPrintf("Failed to write entropy coded data.\n");
                return false;
            }
            bytesWritten += ecdBytesToWrite;
            bytesRead = segment.offset;
        }
 
        // If this isn't a StartOfScan, write just the segment.
        if (segment.marker != kJpegMarkerStartOfScan) {
            const size_t bytesToWrite = kJpegMarkerCodeSize + segment.parameterLength;
            if (!dst->write(images[0]->bytes() + bytesRead, bytesToWrite)) {
                SkCodecPrintf("Failed to copy segment.\n");
                return false;
            }
            bytesWritten += bytesToWrite;
            bytesRead += bytesToWrite;
            continue;
        }
 
        // We're now at the StartOfScan.
        const size_t bytesRemaining = images[0]->size() - bytesRead;
 
        // Compute the MPF offsets for the images.
        SkJpegMultiPictureParameters mpParams;
        {
            mpParams.images.resize(imageCount);
            const size_t mpSegmentSize = kJpegMarkerCodeSize + kJpegSegmentParameterLengthSize +
                                         mpParams.serialize()->size();
            mpParams.images[0].size =
                    static_cast<uint32_t>(bytesWritten + mpSegmentSize + bytesRemaining);
            uint32_t offset =
                    static_cast<uint32_t>(bytesRemaining + mpSegmentSize - kJpegMarkerCodeSize -
                                          kJpegSegmentParameterLengthSize - sizeof(kMpfSig));
            for (size_t i = 1; i < imageCount; ++i) {
                mpParams.images[i].dataOffset = offset;
                mpParams.images[i].size = static_cast<uint32_t>(images[i]->size());
                offset += mpParams.images[i].size;
            }
        }
 
        // Write the MPF segment.
        auto mpfSegment = get_mpf_segment(mpParams);
        if (!dst->write(mpfSegment->data(), mpfSegment->size())) {
            SkCodecPrintf("Failed to write MPF segment.\n");
            return false;
        }
 
        // Write the rest of the primary file.
        if (!dst->write(images[0]->bytes() + bytesRead, bytesRemaining)) {
            SkCodecPrintf("Failed to write remainder of primary image.\n");
            return false;
        }
        bytesRead += bytesRemaining;
        SkASSERT(bytesRead == images[0]->size());
        break;
    }
 
    // Write the remaining files.
    for (size_t i = 1; i < imageCount; ++i) {
        if (!dst->write(images[i]->data(), images[i]->size())) {
            SkCodecPrintf("Failed to write auxiliary image.\n");
        }
    }
    return true;
}

---

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

• third_party/skia/include/private/SkJpegGainmapEncoder.h
• third_party/skia/src/encode/SkJpegGainmapEncoder.cpp