#include <vtfpp/ImageConversion.h>
#include <algorithm>
#include <bit>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <memory>
#include <span>
#include <string_view>
#include <unordered_map>
#include <compressonator.h>
#include <sourcepp/Macros.h>
#include <sourcepp/MathExtended.h>
#include <stb_image.h>
#include <stb_image_resize2.h>
#include <stb_image_write.h>

Include dependency graph for ImageConversion.cpp:

Macros
#define	STB_IMAGE_IMPLEMENTATION
#define	STB_IMAGE_STATIC
#define	STBI_NO_FAILURE_STRINGS
#define	STBI_NO_STDIO
#define	STB_IMAGE_RESIZE_IMPLEMENTATION
#define	STB_IMAGE_RESIZE_STATIC
#define	STB_IMAGE_WRITE_IMPLEMENTATION
#define	STB_IMAGE_WRITE_STATIC
#define	STBI_WRITE_NO_STDIO
#define	VTFPP_REMAP_TO_8(value, shift)
#define	VTFPP_CONVERT_DETAIL(InputType, r, g, b, a, ...)
#define	VTFPP_CONVERT(InputType, r, g, b, a)
#define	VTFPP_CASE_CONVERT_AND_BREAK(InputType, r, g, b, a)
#define	VTFPP_REMAP_FROM_8(value, shift)
#define	VTFPP_CONVERT(InputType, ...)
#define	VTFPP_CASE_CONVERT_AND_BREAK(InputType, ...)
#define	VTFPP_REMAP_TO_16(value, shift)
#define	VTFPP_CONVERT_DETAIL(InputType, r, g, b, a, ...)
#define	VTFPP_CONVERT(InputType, r, g, b, a)
#define	VTFPP_CASE_CONVERT_AND_BREAK(InputType, r, g, b, a)
#define	VTFPP_CONVERT_REMAP(InputType, r, g, b, a)
#define	VTFPP_CASE_CONVERT_REMAP_AND_BREAK(InputType, r, g, b, a)
#define	VTFPP_REMAP_FROM_16(value, shift)
#define	VTFPP_CONVERT(InputType, ...)
#define	VTFPP_CASE_CONVERT_AND_BREAK(InputType, ...)
#define	VTFPP_CONVERT_DETAIL(InputType, r, g, b, a, ...)
#define	VTFPP_CONVERT(InputType, r, g, b, a)
#define	VTFPP_CASE_CONVERT_AND_BREAK(InputType, r, g, b, a)
#define	VTFPP_CONVERT(InputType, ...)
#define	VTFPP_CASE_CONVERT_AND_BREAK(InputType, ...)
#define	VTFPP_CREATE_GAMMA_LUTS(InputType)
#define	VTFPP_APPLY_GAMMA_RED(value)
#define	VTFPP_APPLY_GAMMA_GREEN(value)
#define	VTFPP_APPLY_GAMMA_BLUE(value)
#define	VTFPP_GAMMA_CORRECT(InputType, ...)
#define	VTFPP_CASE_GAMMA_CORRECT_AND_BREAK(InputType, ...)
#define	VTFPP_INVERT_GREEN(PixelType, ChannelName, ...)
#define	VTFPP_INVERT_GREEN_CASE(PixelType)
#define	VTFPP_INVERT_GREEN_CASE_CA_OVERRIDE(PixelType, ChannelName)

Macro Definition Documentation

◆ STB_IMAGE_IMPLEMENTATION

#define STB_IMAGE_IMPLEMENTATION

Definition at line 37 of file ImageConversion.cpp.

◆ STB_IMAGE_RESIZE_IMPLEMENTATION

#define STB_IMAGE_RESIZE_IMPLEMENTATION

Definition at line 43 of file ImageConversion.cpp.

◆ STB_IMAGE_RESIZE_STATIC

#define STB_IMAGE_RESIZE_STATIC

Definition at line 44 of file ImageConversion.cpp.

◆ STB_IMAGE_STATIC

#define STB_IMAGE_STATIC

Definition at line 38 of file ImageConversion.cpp.

◆ STB_IMAGE_WRITE_IMPLEMENTATION

#define STB_IMAGE_WRITE_IMPLEMENTATION

Definition at line 47 of file ImageConversion.cpp.

◆ STB_IMAGE_WRITE_STATIC

#define STB_IMAGE_WRITE_STATIC

Definition at line 48 of file ImageConversion.cpp.

◆ STBI_NO_FAILURE_STRINGS

#define STBI_NO_FAILURE_STRINGS

Definition at line 39 of file ImageConversion.cpp.

◆ STBI_NO_STDIO

#define STBI_NO_STDIO

Definition at line 40 of file ImageConversion.cpp.

◆ STBI_WRITE_NO_STDIO

#define STBI_WRITE_NO_STDIO

Definition at line 49 of file ImageConversion.cpp.

◆ VTFPP_APPLY_GAMMA_BLUE

#define VTFPP_APPLY_GAMMA_BLUE ( value )

Value:

static_cast<decltype(value)>(gammaLUTs.at(ImageFormatDetails::blue(PIXEL_TYPE::FORMAT))[value])

vtfpp::ImageFormatDetails::blue

constexpr int8_t blue(ImageFormat format)

Get the number of bits of precision of the blue channel in the given format.

Definition ImageFormats.h:290

◆ VTFPP_APPLY_GAMMA_GREEN

#define VTFPP_APPLY_GAMMA_GREEN ( value )

Value:

static_cast<decltype(value)>(gammaLUTs.at(ImageFormatDetails::green(PIXEL_TYPE::FORMAT))[value])

vtfpp::ImageFormatDetails::green

constexpr int8_t green(ImageFormat format)

Get the number of bits of precision of the green channel in the given format.

Definition ImageFormats.h:189

◆ VTFPP_APPLY_GAMMA_RED

#define VTFPP_APPLY_GAMMA_RED ( value )

Value:

static_cast<decltype(value)>(gammaLUTs.at(ImageFormatDetails::red(PIXEL_TYPE::FORMAT))[value])

vtfpp::ImageFormatDetails::red

constexpr int8_t red(ImageFormat format)

Get the number of bits of precision of the red channel in the given format.

Definition ImageFormats.h:89

◆ VTFPP_CASE_CONVERT_AND_BREAK [1/6]

#define VTFPP_CASE_CONVERT_AND_BREAK	(	InputType,
		r,
		g,
		b,
		a )

Value:

case InputType: { VTFPP_CONVERT(InputType, r, g, b, a); } break

VTFPP_CONVERT

#define VTFPP_CONVERT(InputType, r, g, b, a)

◆ VTFPP_CASE_CONVERT_AND_BREAK [2/6]

#define VTFPP_CASE_CONVERT_AND_BREAK	(	InputType,
		r,
		g,
		b,
		a )

Value:

case InputType: { VTFPP_CONVERT(InputType, r, g, b, a); } break

◆ VTFPP_CASE_CONVERT_AND_BREAK [3/6]

#define VTFPP_CASE_CONVERT_AND_BREAK	(	InputType,
		r,
		g,
		b,
		a )

Value:

case InputType: { VTFPP_CONVERT(InputType, r, g, b, a); } break

◆ VTFPP_CASE_CONVERT_AND_BREAK [4/6]

#define VTFPP_CASE_CONVERT_AND_BREAK	(		InputType,
			... )

Value:

case InputType: { VTFPP_CONVERT(InputType, __VA_ARGS__); } break

◆ VTFPP_CASE_CONVERT_AND_BREAK [5/6]

#define VTFPP_CASE_CONVERT_AND_BREAK	(		InputType,
			... )

Value:

case InputType: { VTFPP_CONVERT(InputType, __VA_ARGS__); } break

◆ VTFPP_CASE_CONVERT_AND_BREAK [6/6]

#define VTFPP_CASE_CONVERT_AND_BREAK	(		InputType,
			... )

Value:

case InputType: { VTFPP_CONVERT(InputType, __VA_ARGS__); } break

◆ VTFPP_CASE_CONVERT_REMAP_AND_BREAK

#define VTFPP_CASE_CONVERT_REMAP_AND_BREAK	(	InputType,
		r,
		g,
		b,
		a )

Value:

case InputType: { VTFPP_CONVERT_REMAP(InputType, r, g, b, a); } \

break

VTFPP_CONVERT_REMAP

#define VTFPP_CONVERT_REMAP(InputType, r, g, b, a)

◆ VTFPP_CASE_GAMMA_CORRECT_AND_BREAK

#define VTFPP_CASE_GAMMA_CORRECT_AND_BREAK	(		InputType,
			... )

Value:

case InputType: { VTFPP_CREATE_GAMMA_LUTS(InputType) VTFPP_GAMMA_CORRECT(InputType, __VA_ARGS__); } break

VTFPP_GAMMA_CORRECT

#define VTFPP_GAMMA_CORRECT(InputType,...)

VTFPP_CREATE_GAMMA_LUTS

#define VTFPP_CREATE_GAMMA_LUTS(InputType)

◆ VTFPP_CONVERT [1/6]

#define VTFPP_CONVERT	(	InputType,
		r,
		g,
		b,
		a )

Value:

VTFPP_CONVERT_DETAIL(InputType, r, g, b, a)

VTFPP_CONVERT_DETAIL

#define VTFPP_CONVERT_DETAIL(InputType, r, g, b, a,...)

◆ VTFPP_CONVERT [2/6]

#define VTFPP_CONVERT	(	InputType,
		r,
		g,
		b,
		a )

Value:

VTFPP_CONVERT_DETAIL(InputType, r, g, b, a)

◆ VTFPP_CONVERT [3/6]

#define VTFPP_CONVERT	(	InputType,
		r,
		g,
		b,
		a )

Value:

VTFPP_CONVERT_DETAIL(InputType, r, g, b, a)

◆ VTFPP_CONVERT [4/6]

#define VTFPP_CONVERT	(		InputType,
			... )

Value:

        std::span<ImagePixel::InputType> newDataSpan{reinterpret_cast<ImagePixel::InputType*>(newData.data()), newData.size() / sizeof(ImagePixel::InputType)}; \
        std::transform(imageDataSpan.begin(), imageDataSpan.end(), newDataSpan.begin(), [](ImagePixel::RGBA8888 pixel) -> ImagePixel::InputType { \
            return __VA_ARGS__; \
        })

◆ VTFPP_CONVERT [5/6]

#define VTFPP_CONVERT	(		InputType,
			... )

Value:

        std::span<ImagePixel::InputType> newDataSpan{reinterpret_cast<ImagePixel::InputType*>(newData.data()), newData.size() / sizeof(ImagePixel::InputType)}; \
        std::transform(imageDataSpan.begin(), imageDataSpan.end(), newDataSpan.begin(), [](ImagePixel::RGBA16161616 pixel) -> ImagePixel::InputType { \
            return __VA_ARGS__; \
        })

◆ VTFPP_CONVERT [6/6]

#define VTFPP_CONVERT	(		InputType,
			... )

Value:

        std::span<ImagePixel::InputType> newDataSpan{reinterpret_cast<ImagePixel::InputType*>(newData.data()), newData.size() / sizeof(ImagePixel::InputType)}; \
        std::transform(imageDataSpan.begin(), imageDataSpan.end(), newDataSpan.begin(), [](ImagePixel::RGBA32323232F pixel) -> ImagePixel::InputType { \
            return __VA_ARGS__; \
        })

◆ VTFPP_CONVERT_DETAIL [1/3]

#define VTFPP_CONVERT_DETAIL	(	InputType,
		r,
		g,
		b,
		a,
		... )

Value:

        std::span<const ImagePixel::InputType> imageDataSpan{reinterpret_cast<const ImagePixel::InputType*>(imageData.data()), imageData.size() / sizeof(ImagePixel::InputType)}; \
        std::transform(__VA_ARGS__ __VA_OPT__(,) imageDataSpan.begin(), imageDataSpan.end(), newDataSpan.begin(), [](ImagePixel::InputType pixel) -> ImagePixel::RGBA8888 { \
            return {(r), (g), (b), (a)}; \
        })

◆ VTFPP_CONVERT_DETAIL [2/3]

#define VTFPP_CONVERT_DETAIL	(	InputType,
		r,
		g,
		b,
		a,
		... )

Value:

        std::span<const ImagePixel::InputType> imageDataSpan{reinterpret_cast<const ImagePixel::InputType*>(imageData.data()), imageData.size() / sizeof(ImagePixel::InputType)}; \
        std::transform(__VA_ARGS__ __VA_OPT__(,) imageDataSpan.begin(), imageDataSpan.end(), newDataSpan.begin(), [](ImagePixel::InputType pixel) -> ImagePixel::RGBA16161616 { \
            return { static_cast<uint16_t>(r), static_cast<uint16_t>(g), static_cast<uint16_t>(b), static_cast<uint16_t>(a) }; \
        })

◆ VTFPP_CONVERT_DETAIL [3/3]

#define VTFPP_CONVERT_DETAIL	(	InputType,
		r,
		g,
		b,
		a,
		... )

Value:

std::span<const ImagePixel::InputType> imageDataSpan{reinterpret_cast<const ImagePixel::InputType*>(imageData.data()), imageData.size() / sizeof(ImagePixel::InputType)}; \

std::transform(__VA_ARGS__ __VA_OPT__(,) imageDataSpan.begin(), imageDataSpan.end(), newDataSpan.begin(), [](ImagePixel::InputType pixel) -> ImagePixel::RGBA32323232F { return {(r), (g), (b), (a)}; })

◆ VTFPP_CONVERT_REMAP

#define VTFPP_CONVERT_REMAP	(	InputType,
		r,
		g,
		b,
		a )

Value:

        do { \
            if constexpr (ImageFormatDetails::alpha(ImageFormat::InputType) > 1) { \
                VTFPP_CONVERT(InputType, \
                        VTFPP_REMAP_TO_16((r), ImageFormatDetails::red(ImageFormat::InputType)), \
                        VTFPP_REMAP_TO_16((g), ImageFormatDetails::green(ImageFormat::InputType)), \
                        VTFPP_REMAP_TO_16((b), ImageFormatDetails::blue(ImageFormat::InputType)), \
                        VTFPP_REMAP_TO_16((a), ImageFormatDetails::alpha(ImageFormat::InputType))); \
            } else if constexpr (ImageFormatDetails::alpha(ImageFormat::InputType) == 1) { \
                VTFPP_CONVERT(InputType, \
                        VTFPP_REMAP_TO_16((r), ImageFormatDetails::red(ImageFormat::InputType)), \
                        VTFPP_REMAP_TO_16((g), ImageFormatDetails::green(ImageFormat::InputType)), \
                        VTFPP_REMAP_TO_16((b), ImageFormatDetails::blue(ImageFormat::InputType)), \
                        (a) * 0xff); \
            } else { \
                VTFPP_CONVERT(InputType, \
                        VTFPP_REMAP_TO_16((r), ImageFormatDetails::red(ImageFormat::InputType)), \
                        VTFPP_REMAP_TO_16((g), ImageFormatDetails::green(ImageFormat::InputType)), \
                        VTFPP_REMAP_TO_16((b), ImageFormatDetails::blue(ImageFormat::InputType)), \
                        (a)); \
            } \
        } while (false)

◆ VTFPP_CREATE_GAMMA_LUTS

#define VTFPP_CREATE_GAMMA_LUTS ( InputType )

Value:

        std::unordered_map<uint8_t, std::array<uint8_t, 256>> gammaLUTs; \
        if constexpr (ImageFormatDetails::red(ImageFormat::InputType) > 0) { \
            if (!gammaLUTs.contains(ImageFormatDetails::red(ImageFormat::InputType))) { \
                gammaLUTs[ImageFormatDetails::red(ImageFormat::InputType)] = calculateGammaLUT(gamma, ImageFormatDetails::red(ImageFormat::InputType)); \
            } \
        } \
        if constexpr (ImageFormatDetails::green(ImageFormat::InputType) > 0) { \
            if (!gammaLUTs.contains(ImageFormatDetails::green(ImageFormat::InputType))) { \
                gammaLUTs[ImageFormatDetails::green(ImageFormat::InputType)] = calculateGammaLUT(gamma, ImageFormatDetails::green(ImageFormat::InputType)); \
            } \
        } \
        if constexpr (ImageFormatDetails::blue(ImageFormat::InputType) > 0) { \
            if (!gammaLUTs.contains(ImageFormatDetails::blue(ImageFormat::InputType))) { \
                gammaLUTs[ImageFormatDetails::blue(ImageFormat::InputType)] = calculateGammaLUT(gamma, ImageFormatDetails::blue(ImageFormat::InputType)); \
            } \
        }

◆ VTFPP_GAMMA_CORRECT

#define VTFPP_GAMMA_CORRECT	(		InputType,
			... )

Value:

        std::span imageDataSpan{reinterpret_cast<const ImagePixel::InputType*>(imageData.data()), imageData.size() / sizeof(ImagePixel::InputType)}; \
        std::span outSpan{reinterpret_cast<ImagePixel::InputType*>(out.data()), out.size() / sizeof(ImagePixel::InputType)}; \
        std::transform(imageDataSpan.begin(), imageDataSpan.end(), outSpan.begin(), [gammaLUTs](ImagePixel::InputType pixel) -> ImagePixel::InputType { \
            using PIXEL_TYPE = ImagePixel::InputType; \
            return __VA_ARGS__; \
        })

◆ VTFPP_INVERT_GREEN

#define VTFPP_INVERT_GREEN	(	PixelType,
		ChannelName,
		... )

Value:

        static constexpr auto channelSize = ImageFormatDetails::green(ImagePixel::PixelType::FORMAT); \
        std::span imageDataSpan{reinterpret_cast<const ImagePixel::PixelType*>(imageData.data()), imageData.size() / sizeof(ImagePixel::PixelType)}; \
        std::span outSpan{reinterpret_cast<ImagePixel::PixelType*>(out.data()), out.size() / sizeof(ImagePixel::PixelType)}; \
        std::transform(__VA_ARGS__ __VA_OPT__(,) imageDataSpan.begin(), imageDataSpan.end(), outSpan.begin(), [](ImagePixel::PixelType pixel) -> ImagePixel::PixelType { \
            if constexpr (std::same_as<decltype(pixel.ChannelName), float> || std::same_as<decltype(pixel.ChannelName), half>) { \
                pixel.ChannelName = static_cast<decltype(pixel.ChannelName)>(static_cast<float>(static_cast<uint64_t>(1) << channelSize) - 1.f - static_cast<float>(pixel.ChannelName)); \
            } else { \
                if constexpr (channelSize >= sizeof(uint32_t) * 8) { \
                    pixel.ChannelName = static_cast<decltype(pixel.ChannelName)>((static_cast<uint64_t>(1) << channelSize) - 1 - static_cast<uint32_t>(pixel.ChannelName)); \
                } else { \
                    pixel.ChannelName = static_cast<decltype(pixel.ChannelName)>(static_cast<uint32_t>(1 << channelSize) - 1 - static_cast<uint32_t>(pixel.ChannelName)); \
                } \
            } \
            return pixel; \
        })

◆ VTFPP_INVERT_GREEN_CASE

#define VTFPP_INVERT_GREEN_CASE ( PixelType )

Value:

case ImageFormat::PixelType: { VTFPP_INVERT_GREEN(PixelType, g); } break

VTFPP_INVERT_GREEN

#define VTFPP_INVERT_GREEN(PixelType, ChannelName,...)

◆ VTFPP_INVERT_GREEN_CASE_CA_OVERRIDE

#define VTFPP_INVERT_GREEN_CASE_CA_OVERRIDE	(		PixelType,
			ChannelName )

Value:

case ImageFormat::PixelType: { VTFPP_INVERT_GREEN(PixelType, ChannelName); } break

◆ VTFPP_REMAP_FROM_16

#define VTFPP_REMAP_FROM_16	(		value,
			shift )

Value:

static_cast<uint8_t>(math::remap<uint16_t>((value), (1 << 16) - 1, (1 << (shift)) - 1))

sourcepp::math::remap

constexpr T remap(T value, T l1, T h1, T l2, T h2)

Definition Math.h:34

◆ VTFPP_REMAP_FROM_8

#define VTFPP_REMAP_FROM_8	(		value,
			shift )

Value:

math::remap<uint8_t>((value), (1 << 8) - 1, (1 << (shift)) - 1)

◆ VTFPP_REMAP_TO_16

#define VTFPP_REMAP_TO_16	(		value,
			shift )

Value:

math::remap<uint16_t>((value), (1 << (shift)) - 1, (1 << 16) - 1)

◆ VTFPP_REMAP_TO_8

#define VTFPP_REMAP_TO_8	(		value,
			shift )

Value:

math::remap<uint8_t>((value), (1 << (shift)) - 1, (1 << 8) - 1)