SkGainmapInfo.cpp File Reference

#include "include/private/SkGainmapInfo.h"
#include "include/core/SkColor.h"
#include "include/core/SkData.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkStream.h"
#include "src/base/SkEndian.h"
#include "src/codec/SkCodecPriv.h"
#include "src/core/SkStreamPriv.h"
#include <cmath>
#include <cstdint>
#include <memory>

Go to the source code of this file.

Functions
static void	write_rational_be (SkDynamicMemoryWStream &s, float x)
static void	write_positive_rational_be (SkDynamicMemoryWStream &s, float x)
static bool	read_u16_be (SkStream *s, uint16_t *value)
static bool	read_u32_be (SkStream *s, uint32_t *value)
static bool	read_s32_be (SkStream *s, int32_t *value)
static bool	read_rational_be (SkStream *s, float *value)
static bool	read_positive_rational_be (SkStream *s, float *value)
static bool	read_iso_gainmap_version (SkStream *s)
static bool	read_iso_gainmap_info (SkStream *s, SkGainmapInfo &info)
static bool	is_single_channel (SkColor4f c)

Function Documentation

is_single_channel()

static bool is_single_channel ( SkColor4f  c )

static

Definition at line 244 of file SkGainmapInfo.cpp.

{ return c.fR == c.fG && c.fG == c.fB; };

read_iso_gainmap_info()

static bool read_iso_gainmap_info ( SkStream *  s, SkGainmapInfo &  info  )

static

Definition at line 121 of file SkGainmapInfo.cpp.

                                                                    {
    if (!read_iso_gainmap_version(s)) {
        SkCodecPrintf("Failed to read ISO 21496-1 version.\n");
        return false;
    }
 
    uint8_t flags = 0;
    if (!s->readU8(&flags)) {
        SkCodecPrintf("Failed to read ISO 21496-1 flags.\n");
        return false;
    }
    bool isMultiChannel = (flags & kIsMultiChannelMask) != 0;
    bool useBaseColourSpace = (flags & kUseBaseColourSpaceMask) != 0;
 
    float baseHdrHeadroom = 0.f;
    if (!read_positive_rational_be(s, &baseHdrHeadroom)) {
        SkCodecPrintf("Failed to read ISO 21496-1 base HDR headroom.\n");
        return false;
    }
    float altrHdrHeadroom = 0.f;
    if (!read_positive_rational_be(s, &altrHdrHeadroom)) {
        SkCodecPrintf("Failed to read ISO 21496-1 altr HDR headroom.\n");
        return false;
    }
 
    float gainMapMin[3] = {0.f};
    float gainMapMax[3] = {0.f};
    float gamma[3] = {0.f};
    float baseOffset[3] = {0.f};
    float altrOffset[3] = {0.f};
 
    int channelCount = isMultiChannel ? 3 : 1;
    for (int i = 0; i < channelCount; ++i) {
        if (!read_rational_be(s, gainMapMin + i)) {
            SkCodecPrintf("Failed to read ISO 21496-1 gainmap minimum.\n");
            return false;
        }
        if (!read_rational_be(s, gainMapMax + i)) {
            SkCodecPrintf("Failed to read ISO 21496-1 gainmap maximum.\n");
            return false;
        }
        if (!read_positive_rational_be(s, gamma + i)) {
            SkCodecPrintf("Failed to read ISO 21496-1 gamma.\n");
            return false;
        }
        if (!read_rational_be(s, baseOffset + i)) {
            SkCodecPrintf("Failed to read ISO 21496-1 base offset.\n");
            return false;
        }
        if (!read_rational_be(s, altrOffset + i)) {
            SkCodecPrintf("Failed to read ISO 21496-1 altr offset.\n");
            return false;
        }
    }
 
    info = SkGainmapInfo();
    if (!useBaseColourSpace) {
        info.fGainmapMathColorSpace = SkColorSpace::MakeSRGB();
    }
    if (baseHdrHeadroom < altrHdrHeadroom) {
        info.fBaseImageType = SkGainmapInfo::BaseImageType::kSDR;
        info.fDisplayRatioSdr = std::exp2(baseHdrHeadroom);
        info.fDisplayRatioHdr = std::exp2(altrHdrHeadroom);
    } else {
        info.fBaseImageType = SkGainmapInfo::BaseImageType::kHDR;
        info.fDisplayRatioHdr = std::exp2(baseHdrHeadroom);
        info.fDisplayRatioSdr = std::exp2(altrHdrHeadroom);
    }
    for (int i = 0; i < 3; ++i) {
        int j = i >= channelCount ? 0 : i;
        info.fGainmapRatioMin[i] = std::exp2(gainMapMin[j]);
        info.fGainmapRatioMax[i] = std::exp2(gainMapMax[j]);
        info.fGainmapGamma[i] = 1.f / gamma[j];
        switch (info.fBaseImageType) {
            case SkGainmapInfo::BaseImageType::kSDR:
                info.fEpsilonSdr[i] = baseOffset[j];
                info.fEpsilonHdr[i] = altrOffset[j];
                break;
            case SkGainmapInfo::BaseImageType::kHDR:
                info.fEpsilonHdr[i] = baseOffset[j];
                info.fEpsilonSdr[i] = altrOffset[j];
                break;
        }
    }
    return true;
}

read_iso_gainmap_version()

static bool read_iso_gainmap_version ( SkStream *  s )

static

Definition at line 99 of file SkGainmapInfo.cpp.

                                                  {
    // Ensure minimum version is 0.
    uint16_t minimum_version = 0;
    if (!read_u16_be(s, &minimum_version)) {
        SkCodecPrintf("Failed to read ISO 21496-1 minimum version.\n");
        return false;
    }
    if (minimum_version != 0) {
        SkCodecPrintf("Unsupported ISO 21496-1 minimum version.\n");
        return false;
    }
 
    // Ensure writer version is present. No value is invalid.
    uint16_t writer_version = 0;
    if (!read_u16_be(s, &writer_version)) {
        SkCodecPrintf("Failed to read ISO 21496-1 version.\n");
        return false;
    }
 
    return true;
}

read_positive_rational_be()

static bool read_positive_rational_be ( SkStream *  s, float *  value  )

static

Definition at line 86 of file SkGainmapInfo.cpp.

                                                                 {
    uint32_t numerator = 0;
    uint32_t denominator = 0;
    if (!read_u32_be(s, &numerator)) {
        return false;
    }
    if (!read_u32_be(s, &denominator)) {
        return false;
    }
    *value = static_cast<float>(static_cast<double>(numerator) / static_cast<double>(denominator));
    return true;
}

read_rational_be()

static bool read_rational_be ( SkStream *  s, float *  value  )

static

Definition at line 73 of file SkGainmapInfo.cpp.

                                                        {
    int32_t numerator = 0;
    uint32_t denominator = 0;
    if (!read_s32_be(s, &numerator)) {
        return false;
    }
    if (!read_u32_be(s, &denominator)) {
        return false;
    }
    *value = static_cast<float>(static_cast<double>(numerator) / static_cast<double>(denominator));
    return true;
}

read_s32_be()

static bool read_s32_be ( SkStream *  s, int32_t *  value  )

static

Definition at line 65 of file SkGainmapInfo.cpp.

                                                     {
    if (!s->readS32(value)) {
        return false;
    }
    *value = SkEndian_SwapBE32(*value);
    return true;
}

read_u16_be()

static bool read_u16_be ( SkStream *  s, uint16_t *  value  )

static

Definition at line 49 of file SkGainmapInfo.cpp.

                                                      {
    if (!s->readU16(value)) {
        return false;
    }
    *value = SkEndian_SwapBE16(*value);
    return true;
}

read_u32_be()

static bool read_u32_be ( SkStream *  s, uint32_t *  value  )

static

Definition at line 57 of file SkGainmapInfo.cpp.

                                                      {
    if (!s->readU32(value)) {
        return false;
    }
    *value = SkEndian_SwapBE32(*value);
    return true;
}

write_positive_rational_be()

static void write_positive_rational_be ( SkDynamicMemoryWStream &  s, float  x  )

static

Definition at line 38 of file SkGainmapInfo.cpp.

                                                                           {
    // TODO(b/338342146): Select denominator to get maximum precision and robustness.
    uint32_t denominator = 0x10000000;
    if (x > 1.f) {
        denominator = 0x1000;
    }
    uint32_t numerator = static_cast<uint32_t>(std::llround(static_cast<double>(x) * denominator));
    SkWStreamWriteU32BE(&s, numerator);
    SkWStreamWriteU32BE(&s, denominator);
}

write_rational_be()

static void write_rational_be ( SkDynamicMemoryWStream &  s, float  x  )

static

Definition at line 27 of file SkGainmapInfo.cpp.

                                                                  {
    // TODO(b/338342146): Select denominator to get maximum precision and robustness.
    uint32_t denominator = 0x10000000;
    if (std::abs(x) > 1.f) {
        denominator = 0x1000;
    }
    int32_t numerator = static_cast<int32_t>(std::llround(static_cast<double>(x) * denominator));
    SkWStreamWriteS32BE(&s, numerator);
    SkWStreamWriteU32BE(&s, denominator);
}