PixelUtil.hpp

Go to the documentation of this file.

/*
 * Author: Sven Gothel <sgothel@jausoft.com>
 * Copyright Gothel Software e.K.
 *
 * SPDX-License-Identifier: MIT
 *
 * This Source Code Form is subject to the terms of the MIT License
 * If a copy of the MIT was not distributed with this file,
 * you can obtain one at https://opensource.org/license/mit/.
 */
#ifndef GAMP_RENDER_PIXEL_PIXELUTIL_HPP_
#define GAMP_RENDER_PIXEL_PIXELUTIL_HPP_
 
#include <climits>
#include <cstdint>
#include <limits>
 
#include <jau/basic_types.hpp>
#include <jau/int_math.hpp>
#include <jau/int_types.hpp>
#include <jau/math/recti.hpp>
#include <jau/math/vec2i.hpp>
#include <jau/string_util.hpp>
#include <jau/enum_util.hpp>
 
#include <gamp/GampTypes.hpp>
#include <gamp/render/RenderTypes.hpp>
 
namespace gamp::render::pixel {
    
    /** @addtogroup Gamp_Pixel
     *
     *  @{
     */
    
    /** Component types */
    enum class CType : uint8_t {
        /** undefined */
        none = 0,
        
        /** Red component */
        R = 1,
        /** Green component */
        G = 2,
        /** Blue component */
        B = 3,
        /** Alpha component */
        A = 4,
        /** Luminance component, e.g. grayscale or Y of YUV */
        Y = 10,
        /** U component of YUV */
        U = 11,
        /** V component of YUV */
        V = 12
    };
    JAU_MAKE_ENUM_STRING(CType, R, G, B, A, Y, U, V);
 
    typedef std::array<uint32_t, 4> u32array4_t;
    typedef std::array<CType, 4> comparray4_t;
    
    /** maximum index, denoting `no position` or `not found`. */
    inline constexpr uint32_t npos = std::numeric_limits<uint32_t>::max();
    
    /** Returns first index of given {@link CType} within `pool` , npos if not exists. */
    inline uint32_t find(CType s, jau::nsize_t poolCount, const comparray4_t& pool, bool mapRGB2Y) noexcept {
        uint32_t i=0;
        while( i < poolCount && pool[i] != s) { ++i; }
 
        if( poolCount == i ) {
            // Not found
            if( mapRGB2Y && 1 == poolCount && pool[0] == CType::Y &&
                ( CType::R == s ||
                  CType::G == s ||
                  CType::B == s ) )
            {
                // Special not-found case: Mapping LUMINANCE/Y -> RGB
                return 0;
            } else {
                return npos;
            }
        } else {
            return i;
        }
    }
    
    class ComponentMap {
      private:
        jau::nsize_t m_dstCount, m_srcCount;
        
        /**
         * Contains the source index for each destination index,
         * length is {@link Composition#componentCount()} of destination.
         */
        u32array4_t dst2src;
        /**
         * Contains the destination index for each source index,
         * length is {@link Composition#componentCount()} of source.
         */
        u32array4_t src2dst;
 
        /**
         * Contains the source index of RGBA components.
         */
        u32array4_t srcRGBA;
        bool hasSrcRGB;
 
      public:    
        constexpr ComponentMap(jau::nsize_t srcCompCount, const comparray4_t& srcCompOrder, 
                               jau::nsize_t dstCompCount, const comparray4_t& dstCompOrder) noexcept
        : m_dstCount(dstCompCount), m_srcCount(srcCompCount), dst2src(), src2dst() 
        {
            for(jau::nsize_t i=0; i<m_dstCount; ++i) {
                dst2src[i] = find(dstCompOrder[i], srcCompCount, srcCompOrder, true);
            }
            for(jau::nsize_t i=0; i<m_srcCount; ++i) {
                src2dst[i] = find(srcCompOrder[i], dstCompCount, dstCompOrder, true);
            }
            srcRGBA[0] = find(CType::R, srcCompCount, srcCompOrder, false);
            srcRGBA[0] = find(CType::G, srcCompCount, srcCompOrder, false);
            srcRGBA[0] = find(CType::B, srcCompCount, srcCompOrder, false);
            srcRGBA[0] = find(CType::A, srcCompCount, srcCompOrder, false);
            hasSrcRGB = npos != srcRGBA[0] && npos != srcRGBA[1] && npos != srcRGBA[2];
        }
    };
    
    /**
     * Returns shifted bytes from the given {@code data} at given {@code offset}
     * of maximal 4 {@code bytesPerPixel}.
     * @param bytesPerPixel number of bytes per pixel to fetch, a maximum of 4 are allowed
     * @param data byte buffer covering at least one complete pixel, i.e. bytesPerPixel bytes
     * @return the shifted 32bit integer value of the pixel
     */
    inline uint32_t getShifted32(uint32_t bytesPerPixel, const uint8_t* data) {
        if( bytesPerPixel > 4 ) {
            throw jau::IllegalArgumentError(std::to_string(bytesPerPixel)+" bytesPerPixel too big, i.e. > 4", E_FILE_LINE);
        }
        uint32_t res = 0;
        for(uint32_t i=0; i<bytesPerPixel; ++i) {
            res |= ( 0xffU & data[i] ) << CHAR_BIT*i;
        }
        return res;
    }
    /**
     * Returns shifted bytes from the given {@code data} at given {@code offset}
     * of maximal 8 {@code bytesPerPixel}.
     * @param bytesPerPixel number of bytes per pixel to fetch, a maximum of 8 are allowed
     * @param data byte buffer covering at least one complete pixel, i.e. bytesPerPixel bytes
     * @return the shifted 64bit integer value of the pixel
     */
    inline uint64_t getShifted64(uint32_t bytesPerPixel, const uint8_t* data) {
        if( bytesPerPixel > 8 ) {
            throw jau::IllegalArgumentError(std::to_string(bytesPerPixel)+" bytesPerPixel too big, i.e. > 8", E_FILE_LINE);
        }
        uint64_t res = 0;
        for(uint32_t i=0; i<bytesPerPixel; ++i) {
            res |= ( 0xffU & data[i] ) << CHAR_BIT*i;
        }
        return res;
    }
        
        
}  // namespace gamp::render::pixel
 
#endif /* GAMP_RENDER_PIXEL_PIXELUTIL_HPP_ */