/* * Copyright 2022 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef ULTRAHDR_JPEGR_H #define ULTRAHDR_JPEGR_H #include #include #include "ultrahdr_api.h" #include "ultrahdr/ultrahdr.h" #include "ultrahdr/ultrahdrcommon.h" #include "ultrahdr/jpegdecoderhelper.h" #include "ultrahdr/jpegencoderhelper.h" namespace ultrahdr { // Default configurations // gainmap image downscale factor static const int kMapDimensionScaleFactorDefault = 1; static const int kMapDimensionScaleFactorAndroidDefault = 4; // JPEG compress quality (0 ~ 100) for base image static const int kBaseCompressQualityDefault = 95; // JPEG compress quality (0 ~ 100) for gain map static const int kMapCompressQualityDefault = 95; static const int kMapCompressQualityAndroidDefault = 85; // Gain map calculation static const bool kUseMultiChannelGainMapDefault = true; static const bool kUseMultiChannelGainMapAndroidDefault = false; // encoding preset static const uhdr_enc_preset_t kEncSpeedPresetDefault = UHDR_USAGE_BEST_QUALITY; static const uhdr_enc_preset_t kEncSpeedPresetAndroidDefault = UHDR_USAGE_REALTIME; // Default gamma value for gain map static const float kGainMapGammaDefault = 1.0f; // The current JPEGR version that we encode to static const char* const kJpegrVersion = "1.0"; /* * Holds information of jpeg image */ struct jpeg_info_struct { std::vector imgData = std::vector(0); std::vector iccData = std::vector(0); std::vector exifData = std::vector(0); std::vector xmpData = std::vector(0); std::vector isoData = std::vector(0); unsigned int width; unsigned int height; unsigned int numComponents; }; /* * Holds information of jpegr image */ struct jpegr_info_struct { unsigned int width; // copy of primary image width (for easier access) unsigned int height; // copy of primary image height (for easier access) jpeg_info_struct* primaryImgInfo = nullptr; jpeg_info_struct* gainmapImgInfo = nullptr; }; typedef struct jpeg_info_struct* j_info_ptr; typedef struct jpegr_info_struct* jr_info_ptr; class JpegR { public: JpegR(void* uhdrGLESCtxt = nullptr, int mapDimensionScaleFactor = kMapDimensionScaleFactorAndroidDefault, int mapCompressQuality = kMapCompressQualityAndroidDefault, bool useMultiChannelGainMap = kUseMultiChannelGainMapAndroidDefault, float gamma = kGainMapGammaDefault, uhdr_enc_preset_t preset = kEncSpeedPresetAndroidDefault, float minContentBoost = FLT_MIN, float maxContentBoost = FLT_MAX, float targetDispPeakBrightness = -1.0f); /*!\brief Encode API-0. * * Create ultrahdr jpeg image from raw hdr intent. * * Experimental only. * * Input hdr image is tonemapped to sdr image. A gainmap coefficient is computed between hdr and * sdr intent. sdr intent and gain map coefficient are compressed using jpeg encoding. compressed * gainmap is appended at the end of compressed sdr image. * * \param[in] hdr_intent hdr intent raw input image descriptor * \param[in, out] dest output image descriptor to store compressed ultrahdr image * \param[in] quality quality factor for sdr intent jpeg compression * \param[in] exif optional exif metadata that needs to be inserted in * compressed output * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t encodeJPEGR(uhdr_raw_image_t* hdr_intent, uhdr_compressed_image_t* dest, int quality, uhdr_mem_block_t* exif); /*!\brief Encode API-1. * * Create ultrahdr jpeg image from raw hdr intent and raw sdr intent. * * A gainmap coefficient is computed between hdr and sdr intent. sdr intent and gain map * coefficient are compressed using jpeg encoding. compressed gainmap is appended at the end of * compressed sdr image. * NOTE: Color transfer of sdr intent is expected to be sRGB. * * \param[in] hdr_intent hdr intent raw input image descriptor * \param[in] sdr_intent sdr intent raw input image descriptor * \param[in, out] dest output image descriptor to store compressed ultrahdr image * \param[in] quality quality factor for sdr intent jpeg compression * \param[in] exif optional exif metadata that needs to be inserted in * compressed output * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t encodeJPEGR(uhdr_raw_image_t* hdr_intent, uhdr_raw_image_t* sdr_intent, uhdr_compressed_image_t* dest, int quality, uhdr_mem_block_t* exif); /*!\brief Encode API-2. * * Create ultrahdr jpeg image from raw hdr intent, raw sdr intent and compressed sdr intent. * * A gainmap coefficient is computed between hdr and sdr intent. gain map coefficient is * compressed using jpeg encoding. compressed gainmap is appended at the end of compressed sdr * intent. ICC profile is added if one isn't present in the sdr intent JPEG image. * NOTE: Color transfer of sdr intent is expected to be sRGB. * NOTE: sdr intent raw and compressed inputs are expected to be related via compress/decompress * operations. * * \param[in] hdr_intent hdr intent raw input image descriptor * \param[in] sdr_intent sdr intent raw input image descriptor * \param[in] sdr_intent_compressed sdr intent compressed input image descriptor * \param[in, out] dest output image descriptor to store compressed ultrahdr * image * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t encodeJPEGR(uhdr_raw_image_t* hdr_intent, uhdr_raw_image_t* sdr_intent, uhdr_compressed_image_t* sdr_intent_compressed, uhdr_compressed_image_t* dest); /*!\brief Encode API-3. * * Create ultrahdr jpeg image from raw hdr intent and compressed sdr intent. * * The sdr intent is decoded and a gainmap coefficient is computed between hdr and sdr intent. * gain map coefficient is compressed using jpeg encoding. compressed gainmap is appended at the * end of compressed sdr image. ICC profile is added if one isn't present in the sdr intent JPEG * image. * NOTE: Color transfer of sdr intent is expected to be sRGB. * * \param[in] hdr_intent hdr intent raw input image descriptor * \param[in] sdr_intent_compressed sdr intent compressed input image descriptor * \param[in, out] dest output image descriptor to store compressed ultrahdr * image * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t encodeJPEGR(uhdr_raw_image_t* hdr_intent, uhdr_compressed_image_t* sdr_intent_compressed, uhdr_compressed_image_t* dest); /*!\brief Encode API-4. * * Create ultrahdr jpeg image from compressed sdr image and compressed gainmap image * * compressed gainmap image is added at the end of compressed sdr image. ICC profile is added if * one isn't present in the sdr intent compressed image. * * \param[in] base_img_compressed sdr intent compressed input image descriptor * \param[in] gainmap_img_compressed gainmap compressed image descriptor * \param[in] metadata gainmap metadata descriptor * \param[in, out] dest output image descriptor to store compressed ultrahdr * image * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t encodeJPEGR(uhdr_compressed_image_t* base_img_compressed, uhdr_compressed_image_t* gainmap_img_compressed, uhdr_gainmap_metadata_ext_t* metadata, uhdr_compressed_image_t* dest); /*!\brief Decode API. * * Decompress ultrahdr jpeg image. * * NOTE: This method requires that the ultrahdr input image contains an ICC profile with primaries * that match those of a color gamut that this library is aware of; Bt.709, Display-P3, or * Bt.2100. It also assumes the base image color transfer characteristics are sRGB. * * \param[in] uhdr_compressed_img compressed ultrahdr image descriptor * \param[in, out] dest output image descriptor to store decoded output * \param[in] max_display_boost (optional) the maximum available boost supported by a * display, the value must be greater than or equal * to 1.0 * \param[in] output_ct (optional) output color transfer * \param[in] output_format (optional) output pixel format * \param[in, out] gainmap_img (optional) output image descriptor to store decoded * gainmap image * \param[in, out] gainmap_metadata (optional) descriptor to store gainmap metadata * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. * * NOTE: This method only supports single gain map metadata values for fields that allow * multi-channel metadata values. * * NOTE: Not all combinations of output color transfer and output pixel format are supported. * Refer below table for supported combinations. * ---------------------------------------------------------------------- * | color transfer | color format | * ---------------------------------------------------------------------- * | SDR | 32bppRGBA8888 | * ---------------------------------------------------------------------- * | HDR_LINEAR | 64bppRGBAHalfFloat | * ---------------------------------------------------------------------- * | HDR_PQ | 32bppRGBA1010102 | * ---------------------------------------------------------------------- * | HDR_HLG | 32bppRGBA1010102 | * ---------------------------------------------------------------------- */ uhdr_error_info_t decodeJPEGR(uhdr_compressed_image_t* uhdr_compressed_img, uhdr_raw_image_t* dest, float max_display_boost = FLT_MAX, uhdr_color_transfer_t output_ct = UHDR_CT_LINEAR, uhdr_img_fmt_t output_format = UHDR_IMG_FMT_64bppRGBAHalfFloat, uhdr_raw_image_t* gainmap_img = nullptr, uhdr_gainmap_metadata_t* gainmap_metadata = nullptr); /*!\brief This function parses the bitstream and returns information that is useful for actual * decoding. This does not decode the image. That is handled by decodeJPEGR * * \param[in] uhdr_compressed_img compressed ultrahdr image descriptor * \param[in, out] uhdr_image_info image info descriptor * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t getJPEGRInfo(uhdr_compressed_image_t* uhdr_compressed_img, jr_info_ptr uhdr_image_info); /*!\brief set gain map dimension scale factor * NOTE: Applicable only in encoding scenario * * \param[in] mapDimensionScaleFactor scale factor * * \return none */ void setMapDimensionScaleFactor(int mapDimensionScaleFactor) { this->mMapDimensionScaleFactor = mapDimensionScaleFactor; } /*!\brief get gain map dimension scale factor * NOTE: Applicable only in encoding scenario * * \return mapDimensionScaleFactor */ int getMapDimensionScaleFactor() { return this->mMapDimensionScaleFactor; } /*!\brief set gain map compression quality factor * NOTE: Applicable only in encoding scenario * * \param[in] mapCompressQuality quality factor for gain map image compression * * \return none */ void setMapCompressQuality(int mapCompressQuality) { this->mMapCompressQuality = mapCompressQuality; } /*!\brief get gain map quality factor * NOTE: Applicable only in encoding scenario * * \return quality factor */ int getMapCompressQuality() { return this->mMapCompressQuality; } /*!\brief set gain map gamma * NOTE: Applicable only in encoding scenario * * \param[in] gamma gamma parameter that is used for gain map calculation * * \return none */ void setGainMapGamma(float gamma) { this->mGamma = gamma; } /*!\brief get gain map gamma * NOTE: Applicable only in encoding scenario * * \return gamma parameter */ float getGainMapGamma() { return this->mGamma; } /*!\brief enable / disable multi channel gain map * NOTE: Applicable only in encoding scenario * * \param[in] useMultiChannelGainMap enable / disable multi channel gain map * * \return none */ void setUseMultiChannelGainMap(bool useMultiChannelGainMap) { this->mUseMultiChannelGainMap = useMultiChannelGainMap; } /*!\brief check if multi channel gain map is enabled * NOTE: Applicable only in encoding scenario * * \return true if multi channel gain map is enabled, false otherwise */ bool isUsingMultiChannelGainMap() { return this->mUseMultiChannelGainMap; } /*!\brief set gain map min and max content boost * NOTE: Applicable only in encoding scenario * * \param[in] minBoost gain map min content boost * \param[in] maxBoost gain map max content boost * * \return none */ void setGainMapMinMaxContentBoost(float minBoost, float maxBoost) { this->mMinContentBoost = minBoost; this->mMaxContentBoost = maxBoost; } /*!\brief get gain map min max content boost * NOTE: Applicable only in encoding scenario * * \param[out] minBoost gain map min content boost * \param[out] maxBoost gain map max content boost * * \return none */ void getGainMapMinMaxContentBoost(float& minBoost, float& maxBoost) { minBoost = this->mMinContentBoost; maxBoost = this->mMaxContentBoost; } /* \brief Alias of Encode API-0. * * \deprecated This function is deprecated. Use its alias */ status_t encodeJPEGR(jr_uncompressed_ptr p010_image_ptr, ultrahdr_transfer_function hdr_tf, jr_compressed_ptr dest, int quality, jr_exif_ptr exif); /* \brief Alias of Encode API-1. * * \deprecated This function is deprecated. Use its actual */ status_t encodeJPEGR(jr_uncompressed_ptr p010_image_ptr, jr_uncompressed_ptr yuv420_image_ptr, ultrahdr_transfer_function hdr_tf, jr_compressed_ptr dest, int quality, jr_exif_ptr exif); /* \brief Alias of Encode API-2. * * \deprecated This function is deprecated. Use its actual */ status_t encodeJPEGR(jr_uncompressed_ptr p010_image_ptr, jr_uncompressed_ptr yuv420_image_ptr, jr_compressed_ptr yuv420jpg_image_ptr, ultrahdr_transfer_function hdr_tf, jr_compressed_ptr dest); /* \brief Alias of Encode API-3. * * \deprecated This function is deprecated. Use its actual */ status_t encodeJPEGR(jr_uncompressed_ptr p010_image_ptr, jr_compressed_ptr yuv420jpg_image_ptr, ultrahdr_transfer_function hdr_tf, jr_compressed_ptr dest); /* \brief Alias of Encode API-4. * * \deprecated This function is deprecated. Use its actual */ status_t encodeJPEGR(jr_compressed_ptr yuv420jpg_image_ptr, jr_compressed_ptr gainmapjpg_image_ptr, ultrahdr_metadata_ptr metadata, jr_compressed_ptr dest); /* \brief Alias of Decode API * * \deprecated This function is deprecated. Use its actual */ status_t decodeJPEGR(jr_compressed_ptr jpegr_image_ptr, jr_uncompressed_ptr dest, float max_display_boost = FLT_MAX, jr_exif_ptr exif = nullptr, ultrahdr_output_format output_format = ULTRAHDR_OUTPUT_HDR_LINEAR, jr_uncompressed_ptr gainmap_image_ptr = nullptr, ultrahdr_metadata_ptr metadata = nullptr); /* \brief Alias of getJPEGRInfo * * \deprecated This function is deprecated. Use its actual */ status_t getJPEGRInfo(jr_compressed_ptr jpegr_image_ptr, jr_info_ptr jpegr_image_info_ptr); /*!\brief This function receives iso block and / or xmp block and parses gainmap metadata and fill * the output descriptor. If both iso block and xmp block are available, then iso block is * preferred over xmp. * * \param[in] iso_data iso memory block * \param[in] iso_size iso block size * \param[in] xmp_data xmp memory block * \param[in] xmp_size xmp block size * \param[in, out] gainmap_metadata gainmap metadata descriptor * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t parseGainMapMetadata(uint8_t* iso_data, size_t iso_size, uint8_t* xmp_data, size_t xmp_size, uhdr_gainmap_metadata_ext_t* uhdr_metadata); /*!\brief This method is used to tone map a hdr image * * \param[in] hdr_intent hdr image descriptor * \param[in, out] sdr_intent sdr image descriptor * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t toneMap(uhdr_raw_image_t* hdr_intent, uhdr_raw_image_t* sdr_intent); /*!\brief This method takes hdr intent and sdr intent and computes gainmap coefficient. * * This method is called in the encoding pipeline. It takes uncompressed 8-bit and 10-bit yuv * images as input and calculates gainmap. * * NOTE: The input images must be the same resolution. * NOTE: The SDR input is assumed to use the sRGB transfer function. * * \param[in] sdr_intent sdr intent raw input image descriptor * \param[in] hdr_intent hdr intent raw input image descriptor * \param[in, out] gainmap_metadata gainmap metadata descriptor * \param[in, out] gainmap_img gainmap image descriptor * \param[in] sdr_is_601 (optional) if sdr_is_601 is true, then use BT.601 * gamut to represent sdr intent regardless of the value * present in the sdr intent image descriptor * \param[in] use_luminance (optional) used for single channel gainmap. If * use_luminance is true, gainmap calculation is based * on the pixel's luminance which is a weighted * combination of r, g, b channels; otherwise, gainmap * calculation is based of the maximun value of r, g, b * channels. * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t generateGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_image_t* hdr_intent, uhdr_gainmap_metadata_ext_t* gainmap_metadata, std::unique_ptr& gainmap_img, bool sdr_is_601 = false, bool use_luminance = true); protected: /*!\brief This method takes sdr intent, gainmap image and gainmap metadata and computes hdr * intent. This method is called in the decoding pipeline. The output hdr intent image will have * same color gamut as sdr intent. * * NOTE: The SDR input is assumed to use the sRGB transfer function. * * \param[in] sdr_intent sdr intent raw input image descriptor * \param[in] gainmap_img gainmap image descriptor * \param[in] gainmap_metadata gainmap metadata descriptor * \param[in] output_ct output color transfer * \param[in] output_format output pixel format * \param[in] max_display_boost the maximum available boost supported by a * display, the value must be greater than or equal * to 1.0 * \param[in, out] dest output image descriptor to store output * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t applyGainMap(uhdr_raw_image_t* sdr_intent, uhdr_raw_image_t* gainmap_img, uhdr_gainmap_metadata_ext_t* gainmap_metadata, uhdr_color_transfer_t output_ct, uhdr_img_fmt_t output_format, float max_display_boost, uhdr_raw_image_t* dest); private: /*!\brief compress gainmap image * * \param[in] gainmap_img gainmap image descriptor * \param[in] jpeg_enc_obj jpeg encoder object handle * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t compressGainMap(uhdr_raw_image_t* gainmap_img, JpegEncoderHelper* jpeg_enc_obj); /*!\brief This method is called to separate base image and gain map image from compressed * ultrahdr image * * \param[in] jpegr_image compressed ultrahdr image descriptor * \param[in, out] primary_image sdr image descriptor * \param[in, out] gainmap_image gainmap image descriptor * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t extractPrimaryImageAndGainMap(uhdr_compressed_image_t* jpegr_image, uhdr_compressed_image_t* primary_image, uhdr_compressed_image_t* gainmap_image); /*!\brief This function parses the bitstream and returns metadata that is useful for actual * decoding. This does not decode the image. That is handled by decompressImage(). * * \param[in] jpeg_image compressed jpeg image descriptor * \param[in, out] image_info image info descriptor * \param[in, out] img_width (optional) image width * \param[in, out] img_height (optional) image height * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t parseJpegInfo(uhdr_compressed_image_t* jpeg_image, j_info_ptr image_info, unsigned int* img_width = nullptr, unsigned int* img_height = nullptr); /*!\brief This method takes compressed sdr intent, compressed gainmap coefficient, gainmap * metadata and creates a ultrahdr image. This is done by first generating XMP packet from gainmap * metadata, then appending in the order, * SOI, APP2 (Exif is present), APP2 (XMP), base image, gain map image. * * NOTE: In the final output, EXIF package will appear if ONLY ONE of the following conditions is * fulfilled: * (1) EXIF package is available from outside input. I.e. pExif != nullptr. * (2) Compressed sdr intent has EXIF. * If both conditions are fulfilled, this method will return error indicating that it is unable to * choose which exif to be placed in the bitstream. * * \param[in] sdr_intent_compressed sdr intent image descriptor * \param[in] gainmap_compressed gainmap intent input image descriptor * \param[in] pExif exif block to be placed in the bitstream * \param[in] pIcc pointer to icc segment that needs to be added to the * compressed image * \param[in] icc_size size of icc segment * \param[in] metadata gainmap metadata descriptor * \param[in, out] dest output image descriptor to store compressed ultrahdr * image * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t appendGainMap(uhdr_compressed_image_t* sdr_intent_compressed, uhdr_compressed_image_t* gainmap_compressed, uhdr_mem_block_t* pExif, void* pIcc, size_t icc_size, uhdr_gainmap_metadata_ext_t* metadata, uhdr_compressed_image_t* dest); /*!\brief This method is used to convert a raw image from one gamut space to another gamut space * in-place. * * \param[in, out] image raw image descriptor * \param[in] src_encoding input gamut space * \param[in] dst_encoding destination gamut space * * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise. */ uhdr_error_info_t convertYuv(uhdr_raw_image_t* image, uhdr_color_gamut_t src_encoding, uhdr_color_gamut_t dst_encoding); /* * This method will check the validity of the input arguments. * * @param p010_image_ptr uncompressed HDR image in P010 color format * @param yuv420_image_ptr pointer to uncompressed SDR image struct. HDR image is expected to * be in 420p color format * @param hdr_tf transfer function of the HDR image * @param dest destination of the compressed JPEGR image. Please note that {@code maxLength} * represents the maximum available size of the desitination buffer, and it must be * set before calling this method. If the encoded JPEGR size exceeds * {@code maxLength}, this method will return {@code ERROR_JPEGR_BUFFER_TOO_SMALL}. * @return NO_ERROR if the input args are valid, error code is not valid. */ status_t areInputArgumentsValid(jr_uncompressed_ptr p010_image_ptr, jr_uncompressed_ptr yuv420_image_ptr, ultrahdr_transfer_function hdr_tf, jr_compressed_ptr dest_ptr); /* * This method will check the validity of the input arguments. * * @param p010_image_ptr uncompressed HDR image in P010 color format * @param yuv420_image_ptr pointer to uncompressed SDR image struct. HDR image is expected to * be in 420p color format * @param hdr_tf transfer function of the HDR image * @param dest destination of the compressed JPEGR image. Please note that {@code maxLength} * represents the maximum available size of the destination buffer, and it must be * set before calling this method. If the encoded JPEGR size exceeds * {@code maxLength}, this method will return {@code ERROR_JPEGR_BUFFER_TOO_SMALL}. * @param quality target quality of the JPEG encoding, must be in range of 0-100 where 100 is * the highest quality * @return NO_ERROR if the input args are valid, error code is not valid. */ status_t areInputArgumentsValid(jr_uncompressed_ptr p010_image_ptr, jr_uncompressed_ptr yuv420_image_ptr, ultrahdr_transfer_function hdr_tf, jr_compressed_ptr dest, int quality); // Configurations void* mUhdrGLESCtxt; // opengl es context int mMapDimensionScaleFactor; // gain map scale factor int mMapCompressQuality; // gain map quality factor bool mUseMultiChannelGainMap; // enable multichannel gain map float mGamma; // gain map gamma parameter uhdr_enc_preset_t mEncPreset; // encoding speed preset float mMinContentBoost; // min content boost recommendation float mMaxContentBoost; // max content boost recommendation float mTargetDispPeakBrightness; // target display max luminance in nits }; /* * Holds tonemapping results of a pixel */ struct GlobalTonemapOutputs { std::array rgb_out; float y_hdr; float y_sdr; }; /*!\brief Applies a global tone mapping, based on Chrome's HLG/PQ rendering implemented at * https://source.chromium.org/chromium/chromium/src/+/main:ui/gfx/color_transform.cc;l=1197-1252;drc=ac505aff1d29ec3bfcf317cb77d5e196a3664e92 * * \param[in] rgb_in hdr intent pixel in array format. * \param[in] headroom ratio between hdr and sdr peak luminances. Must be greater * than 1. If the input is normalized, then this is used to * stretch it linearly from [0.0..1.0] to [0.0..headroom] * \param[in] is_normalized marker to differentiate, if the input is normalized. * * \return tonemapped pixel in the normalized range [0.0..1.0] */ GlobalTonemapOutputs globalTonemap(const std::array& rgb_in, float headroom, bool is_normalized); } // namespace ultrahdr #endif // ULTRAHDR_JPEGR_H