| /* |
| * Copyright 2025 Google LLC. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "include/core/SkStream.h" |
| #include "include/private/base/SkFloatingPoint.h" |
| #include "src/codec/SkHdrAgtmPriv.h" |
| #include "src/core/SkStreamPriv.h" |
| |
| namespace { |
| |
| // TODO(https://issuetracker.google.com/issues/40044808): Include operator== in SkColorSpace.h. |
| bool operator==(const SkColorSpacePrimaries& a, const SkColorSpacePrimaries& b) { |
| return memcmp(&a, &b, sizeof(a)) == 0; |
| } |
| |
| // Return x clamped to [a, b]. |
| template<typename T, typename U, typename V> |
| T clamp(T x, U a, V b) { |
| return std::min(std::max(x, static_cast<T>(a)), static_cast<T>(b)); |
| } |
| |
| // Convert f by scaling by `scale`, offsetting by `offset`, and then clamping the result to |
| // [`clamp_min`, `clamp_max`]. |
| uint16_t float_to_uint16(float f, |
| uint16_t clamp_min, uint16_t clamp_max, |
| uint16_t offset, float scale) { |
| int32_t v = static_cast<int32_t>(std::lround(f * scale)) + offset; |
| return clamp(v, clamp_min, clamp_max); |
| } |
| |
| // The inverse of float_to_uint16's conversion. |
| float uint16_to_float(uint16_t v, |
| uint16_t clamp_min, uint16_t clamp_max, |
| uint16_t offset, float scale) { |
| return (static_cast<int32_t>(clamp(v, clamp_min, clamp_max)) - offset) / scale; |
| } |
| |
| // Helper class to read individual fields of a uint8_t bitfield. |
| class BitfieldReader { |
| public: |
| bool readFromStream(SkMemoryStream& s) { |
| return s.readU8(&fBits); |
| } |
| uint8_t readBits(uint8_t bits) { |
| // Read the topmost `bits` bits, then shift them off. |
| uint8_t result = fBits >> (8 - bits); |
| fBits <<= bits; |
| fBitsRead += bits; |
| return result; |
| } |
| private: |
| uint8_t fBits = 0; |
| uint8_t fBitsRead = 0; |
| }; |
| |
| // Helper class to write individual fields of a uint8_t bitfield. |
| class BitfieldWriter { |
| public: |
| void writeBits(uint8_t value, uint8_t bits) { |
| // Ensure the value fits in `bits`. |
| SkASSERT(value <= (1 << bits) - 1); |
| fBits <<= bits; |
| fBits |= value; |
| fBitsWritten += bits; |
| } |
| void padAndWriteToStream(SkDynamicMemoryWStream& s) { |
| // Write the remaining bits as zero, then write the result. |
| SkASSERT(fBitsWritten <= 8); |
| fBits <<= (8 - fBitsWritten); |
| fBitsWritten = 8; |
| s.write8(fBits); |
| } |
| private: |
| uint8_t fBits = 0; |
| uint8_t fBitsWritten = 0; |
| }; |
| |
| // Wrapper to return false if the specified call returns false. Used to keep syntax parsing |
| // shorter. |
| #define RETURN_ON_FALSE(x) \ |
| do { \ |
| if (!(x)) { \ |
| SkDebugf("AGTM parsing failed %s at %d\n", #x, __LINE__); \ |
| return false; \ |
| } \ |
| } while (0) |
| |
| // All syntax elements listed in Annex C.2 (excluding reserved_zero). Parsing and serializing of |
| // an skhdr::Agtm is done in two steps: |
| // * converting from the metadata items to/from syntax elements (from Annex C.3) |
| // * serializing the syntax elements to/from a stream (from Annex C.2) |
| struct AgtmSyntax { |
| // Parse or write the syntax elements according to Annex C.2. |
| bool parse_application_info(SkMemoryStream& s); |
| void write_application_info(SkDynamicMemoryWStream& s); |
| |
| // Parse or write according to Table C.1. |
| bool parse_color_volume_transform(SkMemoryStream& s); |
| void write_color_volume_transform(SkDynamicMemoryWStream& s); |
| |
| // Parse or write according to Table C.3. |
| bool parse_adaptive_tone_map(SkMemoryStream& s); |
| void write_adaptive_tone_map(SkDynamicMemoryWStream& s); |
| |
| // Parse or write according to Table C.4. |
| bool parse_component_mixing(uint8_t a, SkMemoryStream& s); |
| void write_component_mixing(uint8_t a, SkDynamicMemoryWStream& s); |
| |
| // Parse or write according to Table C.5. |
| bool parse_gain_curve(uint8_t a, SkMemoryStream& s); |
| void write_gain_curve(uint8_t a, SkDynamicMemoryWStream& s); |
| |
| // syntax elements of smpte_st_2094_50_application_info() |
| uint8_t application_version; |
| |
| // syntax elements of smpte_st_2094_50_color_volume_transform() |
| uint8_t has_custom_hdr_reference_white_flag:1; |
| uint8_t has_adaptive_tone_map_flag:1; |
| uint16_t hdr_reference_white; |
| |
| // syntax elements of smpte_st_2094_50_adaptive_tone_map() |
| uint16_t baseline_hdr_headroom; |
| uint8_t use_reference_white_tone_mapping_flag:1; |
| uint8_t num_alternate_images:3; |
| uint8_t gain_application_space_chromaticities_flag:2; |
| uint8_t has_common_component_mix_params_flag:1; |
| uint8_t has_common_curve_params_flag:1; |
| uint16_t gain_application_space_chromaticities[8]; |
| uint16_t alternate_hdr_headrooms[4]; |
| |
| // syntax elements of smpte_st_2094_50_component_mixing() |
| uint8_t component_mixing_type[4]; |
| uint8_t has_component_mixing_coefficient_flag[4][6]; |
| uint16_t component_mixing_coefficient[4][6]; |
| |
| // syntax elements of smpte_st_2094_50_gain_curve() |
| uint8_t gain_curve_num_control_points_minus_1[4]; |
| uint8_t gain_curve_use_pchip_slope_flag[4]; |
| uint16_t gain_curve_control_points_x[4][32]; |
| uint16_t gain_curve_control_points_y[4][32]; |
| uint16_t gain_curve_control_points_theta[4][32]; |
| }; |
| |
| bool AgtmSyntax::parse_application_info(SkMemoryStream& s) { |
| RETURN_ON_FALSE(s.readU8(&application_version)); |
| RETURN_ON_FALSE(parse_color_volume_transform(s)); |
| return true; |
| } |
| |
| void AgtmSyntax::write_application_info(SkDynamicMemoryWStream& s) { |
| s.write8(application_version); |
| write_color_volume_transform(s); |
| } |
| |
| // Parse according to Table C.2. |
| bool AgtmSyntax::parse_color_volume_transform(SkMemoryStream& s) { |
| BitfieldReader flags; |
| RETURN_ON_FALSE(flags.readFromStream(s)); |
| has_custom_hdr_reference_white_flag = flags.readBits(1); |
| has_adaptive_tone_map_flag = flags.readBits(1); |
| const auto reserved_zero = flags.readBits(6); |
| RETURN_ON_FALSE(reserved_zero == 0); |
| if (has_custom_hdr_reference_white_flag == 1) { |
| RETURN_ON_FALSE(SkStreamPriv::ReadU16BE(&s, &hdr_reference_white)); |
| } |
| if (has_adaptive_tone_map_flag == 1) { |
| RETURN_ON_FALSE(parse_adaptive_tone_map(s)); |
| } |
| return true; |
| } |
| |
| void AgtmSyntax::write_color_volume_transform(SkDynamicMemoryWStream& s) { |
| BitfieldWriter flags; |
| flags.writeBits(has_custom_hdr_reference_white_flag, 1); |
| flags.writeBits(has_adaptive_tone_map_flag, 1); |
| flags.padAndWriteToStream(s); |
| if (has_custom_hdr_reference_white_flag) { |
| SkStreamPriv::WriteU16BE(&s, hdr_reference_white); |
| } |
| if (has_adaptive_tone_map_flag == 1) { |
| write_adaptive_tone_map(s); |
| } |
| } |
| |
| bool AgtmSyntax::parse_adaptive_tone_map(SkMemoryStream& s) { |
| RETURN_ON_FALSE(SkStreamPriv::ReadU16BE(&s, &baseline_hdr_headroom)); |
| BitfieldReader flags; |
| RETURN_ON_FALSE(flags.readFromStream(s) ); |
| use_reference_white_tone_mapping_flag = flags.readBits(1); |
| if (use_reference_white_tone_mapping_flag == 0) { |
| num_alternate_images = flags.readBits(3); |
| gain_application_space_chromaticities_flag = flags.readBits(2); |
| has_common_component_mix_params_flag = flags.readBits(1); |
| has_common_curve_params_flag = flags.readBits(1); |
| if (gain_application_space_chromaticities_flag == 3) { |
| for (uint8_t r = 0; r < 8; ++r) { |
| RETURN_ON_FALSE( |
| SkStreamPriv::ReadU16BE(&s, &gain_application_space_chromaticities[r])); |
| } |
| } |
| for (uint8_t a = 0; a < std::min(num_alternate_images, |
| skhdr::Agtm::kMaxNumAlternateImages); ++a) { |
| RETURN_ON_FALSE(SkStreamPriv::ReadU16BE(&s, &alternate_hdr_headrooms[a])); |
| RETURN_ON_FALSE(parse_component_mixing(a, s)); |
| RETURN_ON_FALSE(parse_gain_curve(a, s)); |
| } |
| } else { |
| const auto reserved_zero = flags.readBits(7); |
| RETURN_ON_FALSE(reserved_zero == 0); |
| } |
| return true; |
| } |
| |
| void AgtmSyntax::write_adaptive_tone_map(SkDynamicMemoryWStream& s) { |
| SkStreamPriv::WriteU16BE(&s, baseline_hdr_headroom); |
| BitfieldWriter flags; |
| flags.writeBits(use_reference_white_tone_mapping_flag, 1); |
| if (use_reference_white_tone_mapping_flag == 0) { |
| flags.writeBits(num_alternate_images, 3); |
| flags.writeBits(gain_application_space_chromaticities_flag, 2); |
| flags.writeBits(has_common_component_mix_params_flag, 1); |
| flags.writeBits(has_common_curve_params_flag, 1); |
| flags.padAndWriteToStream(s); |
| if (gain_application_space_chromaticities_flag == 3) { |
| for (uint8_t r = 0; r < 8; ++r) { |
| SkStreamPriv::WriteU16BE(&s, gain_application_space_chromaticities[r]); |
| } |
| } |
| for (uint8_t a = 0; a < num_alternate_images; ++a) { |
| SkStreamPriv::WriteU16BE(&s, alternate_hdr_headrooms[a]); |
| write_component_mixing(a, s); |
| write_gain_curve(a, s); |
| } |
| } else { |
| flags.padAndWriteToStream(s); |
| } |
| } |
| |
| bool AgtmSyntax::parse_component_mixing(uint8_t a, SkMemoryStream& s) { |
| if (a == 0 || has_common_component_mix_params_flag == 0) { |
| BitfieldReader flags; |
| RETURN_ON_FALSE(flags.readFromStream(s)); |
| component_mixing_type[a] = flags.readBits(2); |
| if (component_mixing_type[a] != 3) { |
| const auto reserved_zero = flags.readBits(6); |
| RETURN_ON_FALSE(reserved_zero == 0); |
| } else { |
| for (uint8_t k = 0; k < 6; ++k) { |
| has_component_mixing_coefficient_flag[a][k] = flags.readBits(1); |
| } |
| for (uint8_t k = 0; k < 6; ++k) { |
| if (has_component_mixing_coefficient_flag[a][k] == 1) { |
| RETURN_ON_FALSE( |
| SkStreamPriv::ReadU16BE(&s, &component_mixing_coefficient[a][k])); |
| } else { |
| component_mixing_coefficient[a][k] = 0; |
| } |
| } |
| } |
| } else { |
| component_mixing_type[a] = component_mixing_type[0]; |
| if (component_mixing_type[a] == 3) { |
| for (uint8_t k = 0; k < 6; ++k) { |
| component_mixing_coefficient[a][k] = component_mixing_coefficient[0][k]; |
| } |
| } |
| } |
| return true; |
| } |
| |
| void AgtmSyntax::write_component_mixing(uint8_t a, SkDynamicMemoryWStream& s) { |
| if (a == 0 || has_common_component_mix_params_flag == 0) { |
| BitfieldWriter flags; |
| flags.writeBits(component_mixing_type[a], 2); |
| if (component_mixing_type[a] == 3) { |
| for (uint8_t k = 0; k < 6; ++k) { |
| flags.writeBits(has_component_mixing_coefficient_flag[a][k], 1); |
| } |
| flags.padAndWriteToStream(s); |
| for (uint8_t k = 0; k < 6; ++k) { |
| if (has_component_mixing_coefficient_flag[a][k] == 1) { |
| SkStreamPriv::WriteU16BE(&s, component_mixing_coefficient[a][k]); |
| } |
| } |
| } else { |
| flags.padAndWriteToStream(s); |
| } |
| } |
| } |
| |
| bool AgtmSyntax::parse_gain_curve(uint8_t a, SkMemoryStream& s) { |
| if (a == 0 || has_common_curve_params_flag == 0) { |
| BitfieldReader flags; |
| RETURN_ON_FALSE(flags.readFromStream(s)); |
| gain_curve_num_control_points_minus_1[a] = flags.readBits(5); |
| gain_curve_use_pchip_slope_flag[a] = flags.readBits(1); |
| const auto reserved_zero = flags.readBits(2); |
| RETURN_ON_FALSE(reserved_zero == 0); |
| for (uint8_t c = 0; c < gain_curve_num_control_points_minus_1[a] + 1u; ++c) { |
| RETURN_ON_FALSE(SkStreamPriv::ReadU16BE(&s, &gain_curve_control_points_x[a][c])); |
| } |
| } else { |
| gain_curve_num_control_points_minus_1[a] = gain_curve_num_control_points_minus_1[0]; |
| gain_curve_use_pchip_slope_flag[a] = gain_curve_use_pchip_slope_flag[0]; |
| for (uint8_t c = 0; c < gain_curve_num_control_points_minus_1[a] + 1u; ++c) { |
| gain_curve_control_points_x[a][c] = gain_curve_control_points_x[0][c]; |
| } |
| } |
| for (uint8_t c = 0; c < gain_curve_num_control_points_minus_1[a] + 1u; ++c) { |
| RETURN_ON_FALSE(SkStreamPriv::ReadU16BE(&s, &gain_curve_control_points_y[a][c])); |
| } |
| if (gain_curve_use_pchip_slope_flag[a] == 0) { |
| for (uint8_t c = 0; c < gain_curve_num_control_points_minus_1[a] + 1u; ++c) { |
| RETURN_ON_FALSE(SkStreamPriv::ReadU16BE(&s, &gain_curve_control_points_theta[a][c])); |
| } |
| } |
| return true; |
| } |
| |
| void AgtmSyntax::write_gain_curve(uint8_t a, SkDynamicMemoryWStream& s) { |
| if (a == 0 || has_common_component_mix_params_flag == 0) { |
| BitfieldWriter flags; |
| flags.writeBits(gain_curve_num_control_points_minus_1[a], 5); |
| flags.writeBits(gain_curve_use_pchip_slope_flag[a], 1); |
| flags.padAndWriteToStream(s); |
| for (uint8_t c = 0; c < gain_curve_num_control_points_minus_1[a] + 1u; ++c) { |
| SkStreamPriv::WriteU16BE(&s, gain_curve_control_points_x[a][c]); |
| } |
| } |
| for (uint8_t c = 0; c < gain_curve_num_control_points_minus_1[a] + 1u; ++c) { |
| SkStreamPriv::WriteU16BE(&s, gain_curve_control_points_y[a][c]); |
| } |
| if (gain_curve_use_pchip_slope_flag[a] == 0) { |
| for (uint8_t c = 0; c < gain_curve_num_control_points_minus_1[a] + 1u; ++c) { |
| SkStreamPriv::WriteU16BE(&s, gain_curve_control_points_theta[a][c]); |
| } |
| } |
| } |
| |
| } // namespace |
| |
| namespace skhdr { |
| |
| bool Agtm::parse(const SkData* data) { |
| if (data == nullptr) { |
| return false; |
| } |
| SkMemoryStream s(data->data(), data->size()); |
| |
| // Parse the syntax according to clause C.2. |
| AgtmSyntax syntax; |
| memset(&syntax, 0, sizeof(syntax)); |
| if (!syntax.parse_application_info(s)) { |
| return false; |
| } |
| |
| // Apply the semantics to map syntax elements to metadata items according to clause C.3.3. |
| if (syntax.has_custom_hdr_reference_white_flag == 1) { |
| fHdrReferenceWhite = uint16_to_float(syntax.hdr_reference_white, 1u, 50000u, 0u, 5.f); |
| } else { |
| fHdrReferenceWhite = kDefaultHdrReferenceWhite; |
| } |
| if (syntax.has_adaptive_tone_map_flag == 0) { |
| fType = Type::kNone; |
| return true; |
| } |
| |
| // Semantics from clause C.3.4. |
| fBaselineHdrHeadroom = uint16_to_float(syntax.baseline_hdr_headroom, 0u, 60000u, 0u, 10000.f); |
| if (syntax.use_reference_white_tone_mapping_flag == 1) { |
| fType = Type::kReferenceWhite; |
| populateUsingRwtmo(); |
| return true; |
| } |
| |
| fType = Type::kCustom; |
| fNumAlternateImages = clamp(syntax.num_alternate_images, 0u, kMaxNumAlternateImages); |
| for (uint8_t a = 0; a < fNumAlternateImages; ++a) { |
| fAlternateHdrHeadroom[a] = uint16_to_float( |
| syntax.alternate_hdr_headrooms[a], 0u, 60000u, 0u, 10000.f); |
| } |
| |
| // Semantics from clause C.3.5. |
| switch (syntax.gain_application_space_chromaticities_flag) { |
| case 0: |
| fGainApplicationSpacePrimaries = SkNamedPrimaries::kRec709; |
| break; |
| case 1: |
| fGainApplicationSpacePrimaries = SkNamedPrimaries::kSMPTE_EG_432_1; |
| break; |
| case 2: |
| fGainApplicationSpacePrimaries = SkNamedPrimaries::kRec2020; |
| break; |
| case 3: { |
| fGainApplicationSpacePrimaries = { |
| .fRX = uint16_to_float( |
| syntax.gain_application_space_chromaticities[0], 0u, 50000u, 0u, 50000.f), |
| .fRY = uint16_to_float( |
| syntax.gain_application_space_chromaticities[1], 0u, 50000u, 0u, 50000.f), |
| .fGX = uint16_to_float( |
| syntax.gain_application_space_chromaticities[2], 0u, 50000u, 0u, 50000.f), |
| .fGY = uint16_to_float( |
| syntax.gain_application_space_chromaticities[3], 0u, 50000u, 0u, 50000.f), |
| .fBX = uint16_to_float( |
| syntax.gain_application_space_chromaticities[4], 0u, 50000u, 0u, 50000.f), |
| .fBY = uint16_to_float( |
| syntax.gain_application_space_chromaticities[5], 0u, 50000u, 0u, 50000.f), |
| .fWX = uint16_to_float( |
| syntax.gain_application_space_chromaticities[6], 0u, 50000u, 0u, 50000.f), |
| .fWY = uint16_to_float( |
| syntax.gain_application_space_chromaticities[7], 0u, 50000u, 0u, 50000.f), |
| }; |
| break; |
| } |
| default: |
| // This should never be hit because syntax.gain_application_space_chromaticities_flag |
| // is read as 2 bits. |
| SkUNREACHABLE; |
| break; |
| } |
| |
| // Semantics from clause C.3.6. |
| for (uint8_t a = 0; a < fNumAlternateImages; ++a) { |
| auto& mix = fGainFunction[a].fComponentMixing; |
| switch (syntax.component_mixing_type[a]) { |
| case 0: |
| mix = {.fMax = 1.f}; |
| break; |
| case 1: |
| mix = {.fComponent = 1.f}; |
| break; |
| case 2: |
| mix = { |
| .fRed = 1.f / 6.f, |
| .fGreen = 1.f / 6.f, |
| .fBlue = 1.f / 6.f, |
| .fMax = 1.f / 2.f, |
| }; |
| break; |
| case 3: |
| mix.fRed = uint16_to_float( |
| syntax.component_mixing_coefficient[a][0], 0u, 50000u, 0u, 50000.f); |
| mix.fGreen = uint16_to_float( |
| syntax.component_mixing_coefficient[a][1], 0u, 50000u, 0u, 50000.f); |
| mix.fBlue = uint16_to_float( |
| syntax.component_mixing_coefficient[a][2], 0u, 50000u, 0u, 50000.f); |
| mix.fMax = uint16_to_float( |
| syntax.component_mixing_coefficient[a][3], 0u, 50000u, 0u, 50000.f); |
| mix.fMin = uint16_to_float( |
| syntax.component_mixing_coefficient[a][4], 0u, 50000u, 0u, 50000.f); |
| mix.fComponent = uint16_to_float( |
| syntax.component_mixing_coefficient[a][5], 0u, 50000u, 0u, 50000.f); |
| break; |
| } |
| } |
| |
| // Semantics from clause C.3.7. |
| for (uint8_t a = 0; a < fNumAlternateImages; ++a) { |
| auto& cubic = fGainFunction[a].fPiecewiseCubic; |
| cubic.fNumControlPoints = syntax.gain_curve_num_control_points_minus_1[a] + 1u; |
| for (uint8_t c = 0; c < cubic.fNumControlPoints; ++c) { |
| cubic.fX[c] = uint16_to_float( |
| syntax.gain_curve_control_points_x[a][c], 0u, 64000u, 0u, 1000.f); |
| cubic.fY[c] = uint16_to_float( |
| syntax.gain_curve_control_points_y[a][c], 0u, 48000u, 24000u, 4000.f); |
| } |
| if (syntax.gain_curve_use_pchip_slope_flag[a] == 0) { |
| for (uint8_t c = 0; c < cubic.fNumControlPoints; ++c) { |
| const float theta = uint16_to_float( |
| syntax.gain_curve_control_points_theta[a][c], |
| 1u, 35999u, 18000u, 36000.f / SK_FloatPI); |
| cubic.fM[c] = std::tan(theta); |
| } |
| } else { |
| cubic.populateSlopeFromPCHIP(); |
| } |
| } |
| |
| return true; |
| } |
| |
| sk_sp<SkData> Agtm::serialize() const { |
| AgtmSyntax syntax; |
| memset(&syntax, 0, sizeof(syntax)); |
| |
| // Populate `syntax` according to the semantics in clause C.3. |
| syntax.application_version = 0; |
| syntax.has_custom_hdr_reference_white_flag = fHdrReferenceWhite != kDefaultHdrReferenceWhite; |
| if (syntax.has_custom_hdr_reference_white_flag) { |
| syntax.hdr_reference_white = float_to_uint16(fHdrReferenceWhite, 1u, 50000u, 0u, 5.f); |
| } |
| |
| syntax.has_adaptive_tone_map_flag = fType != Type::kNone; |
| |
| // Semantics from clause C.3.4. |
| syntax.baseline_hdr_headroom = float_to_uint16(fBaselineHdrHeadroom, 0u, 60000u, 0u, 10000.f); |
| syntax.use_reference_white_tone_mapping_flag = fType == Type::kReferenceWhite; |
| SkASSERT(fNumAlternateImages <= kMaxNumAlternateImages); |
| syntax.num_alternate_images = fNumAlternateImages; |
| for (uint8_t a = 0; a < fNumAlternateImages; ++a) { |
| syntax.alternate_hdr_headrooms[a] = float_to_uint16( |
| fAlternateHdrHeadroom[a], 0u, 60000u, 0u, 10000.f); |
| } |
| |
| // Semantics from clause C.3.5. |
| if (fGainApplicationSpacePrimaries == SkNamedPrimaries::kRec709) { |
| syntax.gain_application_space_chromaticities_flag = 0; |
| } else if (fGainApplicationSpacePrimaries == SkNamedPrimaries::kSMPTE_EG_432_1) { |
| syntax.gain_application_space_chromaticities_flag = 1; |
| } else if (fGainApplicationSpacePrimaries == SkNamedPrimaries::kRec2020) { |
| syntax.gain_application_space_chromaticities_flag = 2; |
| } else { |
| syntax.gain_application_space_chromaticities_flag = 3; |
| } |
| if (syntax.gain_application_space_chromaticities_flag == 3) { |
| syntax.gain_application_space_chromaticities[0] = float_to_uint16( |
| fGainApplicationSpacePrimaries.fRX, 0u, 50000u, 0u, 50000.f); |
| syntax.gain_application_space_chromaticities[1] = float_to_uint16( |
| fGainApplicationSpacePrimaries.fRY, 0u, 50000u, 0u, 50000.f); |
| syntax.gain_application_space_chromaticities[2] = float_to_uint16( |
| fGainApplicationSpacePrimaries.fGX, 0u, 50000u, 0u, 50000.f); |
| syntax.gain_application_space_chromaticities[3] = float_to_uint16( |
| fGainApplicationSpacePrimaries.fGY, 0u, 50000u, 0u, 50000.f); |
| syntax.gain_application_space_chromaticities[4] = float_to_uint16( |
| fGainApplicationSpacePrimaries.fBX, 0u, 50000u, 0u, 50000.f); |
| syntax.gain_application_space_chromaticities[5] = float_to_uint16( |
| fGainApplicationSpacePrimaries.fBY, 0u, 50000u, 0u, 50000.f); |
| syntax.gain_application_space_chromaticities[6] = float_to_uint16( |
| fGainApplicationSpacePrimaries.fWX, 0u, 50000u, 0u, 50000.f); |
| syntax.gain_application_space_chromaticities[7] = float_to_uint16( |
| fGainApplicationSpacePrimaries.fWY, 0u, 50000u, 0u, 50000.f); |
| } |
| |
| // Semantics from clause C.3.6. |
| syntax.has_common_component_mix_params_flag = 0; |
| for (uint8_t a = 0; a < fNumAlternateImages; ++a) { |
| auto& mix = fGainFunction[a].fComponentMixing; |
| if (mix.fRed == 0.f && mix.fGreen == 0.f && mix.fBlue == 0.f && |
| mix.fMax == 1.f && mix.fMin == 0.f && mix.fComponent == 0.f) { |
| syntax.component_mixing_type[a] = 0; |
| } else if (mix.fRed == 0.f && mix.fGreen == 0.f && mix.fBlue == 0.f && |
| mix.fMax == 0.f && mix.fMin == 0.f && mix.fComponent == 1.f) { |
| syntax.component_mixing_type[a] = 1; |
| } else if (mix.fRed == 1.f/6.f && mix.fGreen == 1.f/6.f && mix.fBlue == 1.f/6.f && |
| mix.fMax == 1.f/2.f && mix.fMin == 0.f && mix.fComponent == 0.f) { |
| syntax.component_mixing_type[a] = 2; |
| } else { |
| syntax.component_mixing_type[a] = 3; |
| syntax.component_mixing_coefficient[a][0] = |
| float_to_uint16(mix.fRed, 0u, 50000u, 0u, 50000.f); |
| syntax.component_mixing_coefficient[a][1] = |
| float_to_uint16(mix.fGreen, 0u, 50000u, 0u, 50000.f); |
| syntax.component_mixing_coefficient[a][2] = |
| float_to_uint16(mix.fBlue, 0u, 50000u, 0u, 50000.f); |
| syntax.component_mixing_coefficient[a][3] = |
| float_to_uint16(mix.fMax, 0u, 50000u, 0u, 50000.f); |
| syntax.component_mixing_coefficient[a][4] = |
| float_to_uint16(mix.fMin, 0u, 50000u, 0u, 50000.f); |
| syntax.component_mixing_coefficient[a][5] = |
| float_to_uint16(mix.fComponent, 0u, 50000u, 0u, 50000.f); |
| for (uint8_t k = 0; k < 6; ++k) { |
| syntax.has_component_mixing_coefficient_flag[a][k] = |
| syntax.component_mixing_coefficient[a][k] != 0; |
| } |
| } |
| } |
| |
| // Semantics from clause C.3.7. |
| syntax.has_common_curve_params_flag = 0; |
| for (uint8_t a = 0; a < fNumAlternateImages; ++a) { |
| auto& cubic = fGainFunction[a].fPiecewiseCubic; |
| SkASSERT(PiecewiseCubicFunction::kMinNumControlPoints <= cubic.fNumControlPoints); |
| SkASSERT(cubic.fNumControlPoints <= PiecewiseCubicFunction::kMaxNumControlPoints); |
| syntax.gain_curve_num_control_points_minus_1[a] = cubic.fNumControlPoints - 1u; |
| syntax.gain_curve_use_pchip_slope_flag[a] = 0; |
| for (uint8_t c = 0; c < cubic.fNumControlPoints; ++c) { |
| syntax.gain_curve_control_points_x[a][c] = |
| float_to_uint16(cubic.fX[c], 0u, 64000u, 0u, 1000.f); |
| } |
| for (uint8_t c = 0; c < cubic.fNumControlPoints; ++c) { |
| syntax.gain_curve_control_points_y[a][c] = |
| float_to_uint16(cubic.fY[c], 0u, 48000u, 24000u, 4000.f); |
| } |
| for (uint8_t c = 0; c < cubic.fNumControlPoints; ++c) { |
| float theta = std::atan(cubic.fM[c]); |
| syntax.gain_curve_control_points_theta[a][c] = |
| float_to_uint16(theta, 1u, 35999u, 18000u, 36000.f / SK_FloatPI); |
| } |
| |
| } |
| |
| // Write the syntax according to clause C.2. |
| SkDynamicMemoryWStream s; |
| syntax.write_application_info(s); |
| return s.detachAsData(); |
| } |
| |
| } // namespace skhdr |
| |
