PixelFormat.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_PIXELFORMAT_HPP_
#define GAMP_RENDER_PIXEL_PIXELFORMAT_HPP_
 
#include <bit>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <string_view>
#include <vector>
 
#include <jau/basic_types.hpp>
#include <jau/cpp_lang_util.hpp>
#include <jau/debug.hpp>
#include <jau/float_math.hpp>
#include <jau/int_math.hpp>
#include <jau/int_types.hpp>
#include <jau/math/recti.hpp>
#include <jau/math/vec2i.hpp>
#include <jau/ordered_atomic.hpp>
#include <jau/string_util.hpp>
#include <jau/enum_util.hpp>
 
#include <gamp/GampTypes.hpp>
#include <gamp/render/RenderTypes.hpp>
#include <gamp/render/pixel/PixelUtil.hpp>
 
namespace gamp::render::pixel {
    /** @defgroup Gamp_Pixel Gamp Pixel
     *  Pixel definition and conversion.
     *
     *  @{
     */
        
    using jau::math::Point2u32;
    
    class PixelFormats; // fwd
    
    /**
     * Packed pixel composition, i.e. layout of its components.
     *
     * Components are interleaved, i.e. packed.
     */
    class PixelFormat {
      private:
        friend class PixelFormats;
        
        jau::nsize_t m_compCount;
        comparray4_t m_compOrder;
        u32array4_t m_compMask;
        u32array4_t m_compBitCount;
        u32array4_t m_compBitShift;
        uint32_t m_bitsPerPixel;
        uint32_t m_bitStride;
        bool m_uniform;
        size_t m_hashCode;
        
        constexpr size_t hashCodeImpl() const noexcept {
            // 31 * x == (x << 5) - x
            size_t hash = 31 + m_bitStride;
            hash = ((hash << 5) - hash) + m_bitsPerPixel;
            hash = ((hash << 5) - hash) + m_compMask.size();
            for(size_t i=m_compOrder.size(); i-->0; ) {
                hash = ((hash << 5) - hash) + number(m_compOrder[i]);
            }
            for(size_t i=m_compMask.size(); i-->0; ) {
                hash = ((hash << 5) - hash) + m_compMask[i];
            }
            for(size_t i=m_compOrder.size(); i-->0; ) {
                hash = ((hash << 5) - hash) + m_compBitShift[i];
            }
            return hash;
        }
        
        static std::string toHexString(const u32array4_t& bitCount, const u32array4_t& mask, const u32array4_t& shift) {
            std::string sb("[");
            size_t l = mask.size();
            for(size_t i=0; i < l; ++i) {
                if(i > 0) {
                    sb.append(", ");
                }
                sb.append(std::to_string(bitCount[i])).append(": 0x")
                  .append(jau::to_hexstring(mask[i])).append(" << ").append(std::to_string(shift[i]));
            }
            return sb.append("]");
        }
        
        /**
         * @param componentOrder CType component type order of all components, see componentBitMask().
         * @param bpc bits per component
         * @param bitStride stride bits to next pixel
         */
        consteval_cxx20 PixelFormat(jau::nsize_t compCount, const comparray4_t& compOrder, 
                                    uint32_t bpc, uint32_t bitStride) noexcept
        : m_compCount(compCount), m_compOrder(compOrder), m_compMask(), m_compBitCount(), m_compBitShift(),
          m_bitsPerPixel(bpc * compCount), m_bitStride(bitStride),
          m_uniform(true), m_hashCode(0) 
        {
            const uint32_t compMask = ( 1 << bpc ) - 1;
            for(jau::nsize_t i = 0; i<m_compCount; ++i) {
                m_compMask[i] = compMask;
                m_compBitShift[i] = bpc * i;
                m_compBitCount[i] = bpc;
            }
            jau::consteval_assert(m_bitStride >= m_bitsPerPixel);
            m_hashCode = hashCodeImpl();
        }
 
        /**
         * @param componentOrder {@link CType Component type} order of all components, see {@link #componentBitMask()}.
         * @param componentMask bit-mask of of all components, see {@link #componentBitMask()}.
         * @param componentBitShift bit-shift of all components, see {@link #componentBitMask()}.
         * @param bitStride stride bits to next pixel
         */
        consteval_cxx20 PixelFormat(jau::nsize_t compCount, const comparray4_t& compOrder, 
                                    const u32array4_t& componentMask, const u32array4_t& componentBitShift, 
                                    uint32_t bitStride) noexcept 
        : m_compCount(compCount), m_compOrder(compOrder), m_compMask(componentMask), m_compBitCount(), m_compBitShift(componentBitShift),
          m_bitsPerPixel(0), m_bitStride(bitStride),
          m_uniform(true), m_hashCode(0) 
        {
            uint32_t bpp = 0;
            bool uniform = true;
            for(jau::nsize_t i = 0; i<m_compCount; ++i) {
                const uint32_t cmask = m_compMask[i];
                const uint32_t bitCount = std::popcount(cmask);
                bpp += bitCount;
                m_compBitCount[i] = bitCount;
                if( i > 0 && uniform ) {
                    uniform = m_compMask[i-1] == cmask;
                }
            }
            m_uniform = uniform;
            m_bitsPerPixel = bpp;
            jau::consteval_assert(m_bitStride >= m_bitsPerPixel);
            m_hashCode = hashCodeImpl();
        }
 
      public:    
        std::string toString() const noexcept {
            return jau::format_string_n(511, "PixelFmt[order %s, stride %u, bpp %u, uni %d, comp %sz: %s]",
                    jau::to_string(m_compOrder).c_str(), m_bitStride, m_bitsPerPixel, (int)m_uniform,
                    m_compMask.size(), toHexString(m_compBitCount, m_compMask, m_compBitShift).c_str());
        }
 
        /**
         * Returns {@code true} if all components are of same bit-size, e.g. {@link PixelFormat#RGBA8888 RGBA8888},
         * otherwise {@code false}, e.g. {@link PixelFormat#RGBA5551 RGBA5551}
         */
        constexpr bool isUniform() const noexcept { return m_uniform; }
        
        /**
         * Returns {@code true} if all components are packed, i.e. interleaved, e.g. {@link PixelFormat#RGBA8888 RGBA8888},
         * otherwise {@code false}.
         *
         * Instances of PixelFormat returns {@code true}.
         */
        constexpr bool isInterleaved() const noexcept { return true; }
        
        /** Number of components per pixel, e.g. 3 for {@link PixelFormat#RGBx8888 RGBx8888}. */
        constexpr jau::nsize_t size() const noexcept { return m_compCount; }
        
        /** Number of bits per pixel, e.g. 24 bits for {@link PixelFormat#RGBx8888 RGBx8888}. */
        constexpr uint32_t bitsPerPixel() const noexcept { return m_bitsPerPixel; }
        
        /**
         * Bit distance between pixels.
         *
         * For packed pixels e.g. 32 bits for {@link PixelFormat#RGBx8888 RGBx8888}.
         */
        constexpr uint32_t bitStride() const noexcept { return m_bitStride; }
        
        /** Number of bytes per pixel, i.e. packed {@link #bitStride()} in bytes, e.g. 4 for {@link PixelFormat#RGBx8888 RGBx8888}. */
        constexpr uint32_t bytesPerPixel() const noexcept { return (7+m_bitStride)/8; }
        
        /** Returns the {@link CType Component type} order of all components, see {@link #componentBitMask()}. */
        constexpr const comparray4_t& order() const noexcept { return m_compOrder; }
        
        /** Returns first index of given {@link CType} within {@link #componentOrder()}, -1 if not exists. */
        constexpr uint32_t find(CType s) const noexcept { return pixel::find(s, m_compCount, m_compOrder, false /* mapRGB2Y */); }
        
        constexpr const u32array4_t& bitMask() const noexcept { return m_compMask; }
        
        constexpr const u32array4_t& bitCount() const noexcept { return m_compBitCount; }
        
        constexpr const u32array4_t& bitShift() const noexcept { return m_compBitShift; }
 
        constexpr uint32_t toU32(uint8_t c1NormI8) const noexcept {
            return ( c1NormI8 & m_compMask[0] ) << m_compBitShift[0];
        }
        constexpr uint32_t toU32(uint8_t c1NormI8, uint8_t c2NormI8, uint8_t c3NormI8) const noexcept {
            return ( c1NormI8 & m_compMask[0] ) << m_compBitShift[0] |
                   ( c2NormI8 & m_compMask[1] ) << m_compBitShift[1] |
                   ( c3NormI8 & m_compMask[2] ) << m_compBitShift[2] ;
        }
        constexpr uint32_t toU32(uint8_t c1NormI8, uint8_t c2NormI8, uint8_t c3NormI8, uint8_t c4NormI8) const noexcept {
            return ( c1NormI8 & m_compMask[0] ) << m_compBitShift[0] |
                   ( c2NormI8 & m_compMask[1] ) << m_compBitShift[1] |
                   ( c3NormI8 & m_compMask[2] ) << m_compBitShift[2] |
                   ( c4NormI8 & m_compMask[3] ) << m_compBitShift[3] ;
        }
        uint32_t toU32(const uint8_t* src) const {
            if( m_compCount == 1 ) {
                return toU32(src[0]);
            } else if( m_compCount == 3 ) {
                return toU32(src[0], src[1], src[2]);
            } else if( m_compCount == 4 ) {
                return toU32(src[0], src[1], src[2], src[3]);
            } else {
                throw jau::InternalError("Unhandled format "+toString(), E_FILE_LINE);
            }
        }
 
        constexpr float toFloat(uint32_t v, jau::nsize_t cIdx, bool isShifted) const noexcept {
            if( isShifted ) {
                return float( ( v >> m_compBitShift[cIdx] ) & m_compMask[cIdx] ) / float( m_compMask[cIdx] ) ;
            } else {
                return float(   v                           & m_compMask[cIdx] ) / float( m_compMask[cIdx] ) ;
            }
        }
        constexpr uint32_t fromFloat(float f, uint32_t cIdx, bool shiftResult) const noexcept {
            uint32_t v = jau::round_to_uint(f * float(m_compMask[cIdx]));
            return shiftResult ? v << m_compBitShift[cIdx] : v;
        }
 
        constexpr uint32_t defaultValue(uint32_t cIdx, bool shiftResult) const noexcept {
            uint32_t v = ( CType::A == m_compOrder[cIdx] || CType::Y == m_compOrder[cIdx] )
                          ? m_compMask[cIdx] : 0;
            return shiftResult ? v << m_compBitShift[cIdx] : v;
        }
 
        constexpr size_t hashCode() const noexcept { return m_hashCode; }
        
        constexpr bool operator==(const PixelFormat& rhs ) const noexcept {
            if( this == &rhs ) {
                return true;
            }
            if( m_hashCode != rhs.m_hashCode ) {
                return false;
            }
            return m_bitStride == rhs.m_bitStride &&
                   m_bitsPerPixel == rhs.m_bitsPerPixel &&
                   m_compOrder == rhs.m_compOrder &&
                   m_compMask == rhs.m_compMask &&
                   m_compBitShift == rhs.m_compBitShift;
        }
    };
            
    /**
     * Pixel Rectangle identified by it's {@link #hashCode()}.
     * <p>
     * The {@link #getPixels()} are assumed to be immutable.
     * </p>
     */
    class PixelRectangle {
      public:
        ~PixelRectangle() noexcept = default;
        
        /**
         * <p>
         * Computes a hash code over:
         * <ul>
         *   <li>pixelformat</li>
         *   <li>size</li>
         *   <li>stride</li>
         *   <li>isGLOriented</li>
         *   <li>pixels</li>
         * </ul>
         * </p>
         * <p>
         * The hashCode shall be computed only once with first call
         * and stored for later retrieval to enhance performance.
         * </p>
         * <p>
         * {@inheritDoc}
         * </p>
         */
        virtual size_t hashCode() const noexcept = 0;
    
        /** Returns the {@link PixelFormat}. */
        virtual const PixelFormat& format() const noexcept = 0;
    
        /** Returns the size, i.e. width and height. */
        virtual const Point2u32& size() const noexcept = 0;
    
        /**
         * Returns stride in byte-size, i.e. byte count from one line to the next.
         * <p>
         * Must be >= {@link #getPixelformat()}.{@link PixelFormat#bytesPerPixel() bytesPerPixel()} * {@link #getSize()}.{@link DimensionImmutable#getWidth() getWidth()}.
         * </p>
         */
        virtual uint32_t stride() const noexcept = 0;
    
        /**
         * Returns <code>true</code> if the memory is laid out in
         * OpenGL's coordinate system, <i>origin at bottom left</i>.
         * Otherwise returns <code>false</code>, i.e. <i>origin at top left</i>.
         */
        virtual bool isGLOriented() const noexcept = 0;
    
        /** Returns the pixels. */
        virtual const uint8_t* pixels() const noexcept = 0;
    
        /** Returns the pixels, mutable. */
        virtual uint8_t* mutablePixels() noexcept = 0;
        
        virtual std::string toString() const = 0;
    };
    
    /**
     * Generic PixelRectangle implementation
     */
    class GenericPixelRect : public PixelRectangle {
      protected:
        const PixelFormat* m_pixelformat;
        Point2u32 m_size;
        uint32_t m_strideInBytes;
        bool m_isGLOriented;
        std::vector<uint8_t> m_data;
        mutable size_t m_hashCode = 0;
        mutable jau::sc_atomic_bool m_hashCodeComputed = false;
        mutable std::mutex m_mtx;
 
        size_t pixelHashCode() const noexcept {
            const size_t byte_width = size_t(m_size.x) * m_pixelformat->bytesPerPixel();
            size_t hash = 0;
            for(size_t y=0; y<m_size.y; ++y) {
                const uint8_t* line = &m_data[y*m_strideInBytes];
                for(size_t x=0; x<byte_width; ++x) {
                    hash = ((hash << 5) - hash) + line[x];
                }
            }
            return hash;
        }
                
      public:
        /**
         *
         * @param pixelformat
         * @param size
         * @param strideInBytes stride in byte-size, i.e. byte count from one line to the next.
         *                      If not zero, value must be >= <code>width * bytes-per-pixel</code>.
         *                      If zero, stride is set to <code>width * bytes-per-pixel</code>.
         * @param isGLOriented
         * @throws IllegalArgumentException if <code>strideInBytes</code> is invalid.
         * @throws IndexOutOfBoundsException if <code>pixels</code> has insufficient bytes left
         */
        GenericPixelRect(const PixelFormat& pixelformat, const Point2u32& size, uint32_t strideInBytes, bool isGLOriented)
        : m_pixelformat(&pixelformat), m_size(size), m_strideInBytes(strideInBytes), m_isGLOriented(isGLOriented),
          m_data(), m_hashCode(0), m_hashCodeComputed(false)
        {
            if( 0 != m_strideInBytes ) {
                if( m_strideInBytes < pixelformat.bytesPerPixel() * size.x) {
                    throw jau::IllegalArgumentError("Invalid stride "+std::to_string(m_strideInBytes)+
                        ", must be greater than bytesPerPixel "+std::to_string(pixelformat.bytesPerPixel())+
                        " * width "+std::to_string(size.x), E_FILE_LINE);
                }
            } else {
                m_strideInBytes = pixelformat.bytesPerPixel() * size.x;
            }
            const size_t capacity = size_t(m_strideInBytes) * m_size.y;
            m_data.reserve(capacity);
            m_data.resize(capacity);
        }
 
        GenericPixelRect(const GenericPixelRect& o) noexcept = delete; // too expensive
        GenericPixelRect& operator=(const GenericPixelRect&) noexcept = delete; // too expensive
        
        GenericPixelRect(GenericPixelRect&& o) noexcept
        : m_pixelformat(o.m_pixelformat), m_size(o.m_size), m_strideInBytes(o.m_strideInBytes), m_isGLOriented(o.m_isGLOriented),
          m_data(std::move(o.m_data)), m_hashCode(o.m_hashCode), m_hashCodeComputed(o.m_hashCodeComputed.load())
        { }        
        GenericPixelRect& operator=(GenericPixelRect&& o) noexcept
        {
            m_pixelformat = o.m_pixelformat;
            m_size = o.m_size;
            m_strideInBytes = o.m_strideInBytes;
            m_isGLOriented = o.m_isGLOriented;
            m_data = std::move(o.m_data);
            m_hashCode = o.m_hashCode;
            m_hashCodeComputed = o.m_hashCodeComputed.load();
            return *this;
        }
 
        size_t hashCode() const noexcept override {
            if( !m_hashCodeComputed ) { // DBL CHECKED OK atomic
                std::unique_lock<std::mutex> lock(m_mtx);
                if( !m_hashCodeComputed ) {
                    // 31 * x == (x << 5) - x
                    size_t hash = m_pixelformat->hashCode();
                    hash = ((hash << 5) - hash) + m_size.hashCode();
                    hash = ((hash << 5) - hash) + m_strideInBytes;
                    hash = ((hash << 5) - hash) + ( m_isGLOriented ? 1 : 0);
                    hash = ((hash << 5) - hash) + pixelHashCode();
                    m_hashCode = hash;
                    m_hashCodeComputed = true;
                }
            }
            return m_hashCode;
        }
 
        const PixelFormat& format() const noexcept override { return *m_pixelformat; }        
 
        const Point2u32& size() const noexcept override { return m_size; }
 
        uint32_t stride() const noexcept override { return m_strideInBytes; }        
 
        bool isGLOriented() const noexcept override { return m_isGLOriented; }        
 
        const uint8_t* pixels() const noexcept override { return m_data.data(); }
        uint8_t* mutablePixels() noexcept override { return m_data.data(); }        
 
        std::string toString() const override {
            return "PixelRect[obj "+jau::to_hexstring(this)+", "+m_pixelformat->toString()+", "+m_size.toString()+
                   ", stride "+std::to_string(m_strideInBytes)+", isGLOrient "+jau::to_string(m_isGLOriented)+"]";
        }
    };
    
    /**
     * Basic pixel formats
     * <p>
     * Notation follows OpenGL notation, i.e.
     * name consist of all it's component names
     * followed by their bit size.
     * </p>
     * <p>
     * Order of component names is from lowest-bit to highest-bit.
     * </p>
     * <p>
     * In case component-size is 1 byte (e.g. OpenGL data-type GL_UNSIGNED_BYTE),
     * component names are ordered from lowest-byte to highest-byte.
     * Note that OpenGL applies special interpretation if
     * data-type is e.g. GL_UNSIGNED_8_8_8_8_REV or GL_UNSIGNED_8_8_8_8_REV.
     * </p>
     * <p>
     * PixelFormat can be converted to OpenGL GLPixelAttributes
     * via
     * <pre>
     *  GLPixelAttributes glpa = GLPixelAttributes.convert(PixelFormat pixFmt, GLProfile glp);
     * </pre>
     * </p>
     * <p>
     * See OpenGL Specification 4.3 - February 14, 2013, Core Profile,
     * Section 8.4.4 Transfer of Pixel Rectangles, p. 161-174.
     * </ul>
     *
     * </p>
     */
    class PixelFormats {
      public: 
        /**
         * Stride is 8 bits, 8 bits per pixel, 1 component of 8 bits.
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_ALPHA (< GL3), GL_RED (>= GL3), data-type GL_UNSIGNED_BYTE</li>
         *   <li>AWT: <i>none</i></li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat LUMINANCE = PixelFormat(1, { CType::Y }, 8, 8);
    
        /**
         * Stride is 16 bits, 16 bits per pixel, 3 {@link PixelFormat#isUniform() discrete} components.
         * <p>
         * The {@link PixelFormat#isUniform() discrete} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>R: 0x1F <<  0</li>
         *   <li>G: 0x3F <<  5</li>
         *   <li>B: 0x1F << 11</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_RGB, data-type GL_UNSIGNED_SHORT_5_6_5_REV</li>
         *   <li>AWT: <i>None</i></li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat RGB565 = PixelFormat(3, { CType::R, CType::G, CType::B },
                                                             {   0x1F,    0x3F,    0x1F },
                                                             {   0,       5,       5+6 },
                                                          16 );
    
        /**
         * Stride is 16 bits, 16 bits per pixel, 3 {@link PixelFormat#isUniform() discrete} components.
         * <p>
         * The {@link PixelFormat#isUniform() discrete} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>B: 0x1F <<  0</li>
         *   <li>G: 0x3F <<  5</li>
         *   <li>R: 0x1F << 11</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_RGB, data-type GL_UNSIGNED_SHORT_5_6_5</li>
         *   <li>AWT: <i>None</i></li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat BGR565 = PixelFormat(3, { CType::B, CType::G, CType::R},
                                                             {   0x1F,    0x3F,    0x1F },
                                                             {   0,       5,       5+6 },
                                                          16 );
    
        /**
         * Stride is 16 bits, 16 bits per pixel, 4 {@link PixelFormat#isUniform() discrete} components.
         * <p>
         * The {@link PixelFormat#isUniform() discrete} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>R: 0x1F <<  0</li>
         *   <li>G: 0x1F <<  5</li>
         *   <li>B: 0x1F << 10</li>
         *   <li>A: 0x01 << 15</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_RGBA, data-type GL_UNSIGNED_SHORT_1_5_5_5_REV</li>
         *   <li>AWT: <i>None</i></li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat RGBA5551 = PixelFormat(4, { CType::R, CType::G, CType::B, CType::A},
                                                               {   0x1F,    0x1F,    0x1F,    0x01 },
                                                               {   0,          5,    5+5,     5+5+5 },
                                                            16 );
    
        /**
         * Stride is 16 bits, 16 bits per pixel, 4 {@link PixelFormat#isUniform() discrete} components.
         * <p>
         * The {@link PixelFormat#isUniform() discrete} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>A: 0x01 <<  0</li>
         *   <li>B: 0x1F <<  1</li>
         *   <li>G: 0x1F <<  6</li>
         *   <li>R: 0x1F << 11</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_RGBA, data-type GL_UNSIGNED_SHORT_5_5_5_1</li>
         *   <li>AWT: <i>None</i></li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat ABGR1555 = PixelFormat(4, { CType::A, CType::B, CType::G, CType::R },
                                                               {   0x01,    0x1F,    0x1F,    0x1F },
                                                               {   0,       1,       1+5,     1+5+5 },
                                                            16 );
    
        /**
         * Stride 24 bits, 24 bits per pixel, 3 {@link PixelFormat#isUniform() uniform} components of 8 bits.
         * <p>
         * The {@link PixelFormat#isUniform() uniform} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>R: 0xFF <<  0</li>
         *   <li>G: 0xFF <<  8</li>
         *   <li>B: 0xFF << 16</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_RGB, data-type GL_UNSIGNED_BYTE</li>
         *   <li>AWT: <i>None</i></li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat RGB888 = PixelFormat(3, { CType::R, CType::G, CType::B }, 8, 24);
    
        /**
         * Stride is 24 bits, 24 bits per pixel, 3 {@link PixelFormat#isUniform() uniform} components of of 8 bits.
         * <p>
         * The {@link PixelFormat#isUniform() uniform} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>B: 0xFF <<  0</li>
         *   <li>G: 0xFF <<  8</li>
         *   <li>R: 0xFF << 16</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_BGR (>= GL2), data-type GL_UNSIGNED_BYTE</li>
         *   <li>AWT: {@link java.awt.image.BufferedImage#TYPE_3BYTE_BGR TYPE_3BYTE_BGR}</li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat BGR888 = PixelFormat(3, { CType::B, CType::G, CType::R }, 8, 24);
    
        /**
         * Stride is 32 bits, 24 bits per pixel, 3 {@link PixelFormat#isUniform() uniform} components of 8 bits.
         * <p>
         * The {@link PixelFormat#isUniform() uniform} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>R: 0xFF <<  0</li>
         *   <li>G: 0xFF <<  8</li>
         *   <li>B: 0xFF << 16</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_RGBA, data-type GL_UNSIGNED_BYTE, with alpha discarded!</li>
         *   <li>AWT: {@link java.awt.image.BufferedImage#TYPE_INT_BGR TYPE_INT_BGR}</li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat RGBx8888 = PixelFormat(3, { CType::R, CType::G, CType::B }, 8, 32);
    
        /**
         * Stride is 32 bits, 24 bits per pixel, 3 {@link PixelFormat#isUniform() uniform} components of 8 bits.
         * <p>
         * The {@link PixelFormat#isUniform() uniform} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>B: 0xFF <<  0</li>
         *   <li>G: 0xFF <<  8</li>
         *   <li>R: 0xFF << 16</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_BGRA, data-type GL_UNSIGNED_BYTE - with alpha discarded!</li>
         *   <li>AWT: {@link java.awt.image.BufferedImage#TYPE_INT_RGB TYPE_INT_RGB}</li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat BGRx8888 = PixelFormat(3, { CType::B, CType::G, CType::R }, 8, 32);
    
        /**
         * Stride is 32 bits, 32 bits per pixel, 4 {@link PixelFormat#isUniform() uniform} components of 8 bits.
         * <p>
         * The {@link PixelFormat#isUniform() uniform} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>R: 0xFF <<  0</li>
         *   <li>G: 0xFF <<  8</li>
         *   <li>B: 0xFF << 16</li>
         *   <li>A: 0xFF << 24</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_RGBA, data-type GL_UNSIGNED_BYTE</li>
         *   <li>AWT: <i>None</i></li>
         *   <li>PointerIcon: OSX (NSBitmapImageRep)</li>
         *   <li>Window Icon: OSX (NSBitmapImageRep)</li>
         *   <li>PNGJ: Scanlines</li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat RGBA8888 = PixelFormat(4, { CType::R, CType::G, CType::B, CType::A }, 8, 32);
    
        /**
         * Stride is 32 bits, 32 bits per pixel, 4 {@link PixelFormat#isUniform() uniform} components of 8 bits.
         * <p>
         * The {@link PixelFormat#isUniform() uniform} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>A: 0xFF <<  0</li>
         *   <li>B: 0xFF <<  8</li>
         *   <li>G: 0xFF << 16</li>
         *   <li>R: 0xFF << 24</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_RGBA, data-type GL_UNSIGNED_INT_8_8_8_8</li>
         *   <li>AWT: {@link java.awt.image.BufferedImage#TYPE_4BYTE_ABGR TYPE_4BYTE_ABGR}</li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat ABGR8888 = PixelFormat(4, { CType::A, CType::B, CType::G, CType::R }, 8, 32);
    
        /**
         * Stride is 32 bits, 32 bits per pixel, 4 {@link PixelFormat#isUniform() uniform} components of 8 bits.
         * <p>
         * The {@link PixelFormat#isUniform() uniform} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>A: 0xFF <<  0</li>
         *   <li>R: 0xFF <<  8</li>
         *   <li>G: 0xFF << 16</li>
         *   <li>B: 0xFF << 24</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_BGRA, data-type GL_UNSIGNED_INT_8_8_8_8</li>
         *   <li>AWT: <i>None</i></li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat ARGB8888 = PixelFormat(4, { CType::A, CType::R, CType::G, CType::B }, 8, 32);
    
        /**
         * Stride is 32 bits, 32 bits per pixel, 4 {@link PixelFormat#isUniform() uniform} components of 8 bits.
         * <p>
         * The {@link PixelFormat#isUniform() uniform} {@link PixelFormat#composition components}
         * are interleaved in the order Low to High:
         * <ol>
         *   <li>B: 0xFF <<  0</li>
         *   <li>G: 0xFF <<  8</li>
         *   <li>R: 0xFF << 16</li>
         *   <li>A: 0xFF << 24</li>
         * </ol>
         * </p>
         * <p>
         * Compatible with:
         * <ul>
         *   <li>OpenGL: data-format GL_BGRA, data-type GL_UNSIGNED_BYTE</li>
         *   <li>AWT: {@link java.awt.image.BufferedImage#TYPE_INT_ARGB TYPE_INT_ARGB}</li>
         *   <li>PointerIcon: X11 (XCURSOR), Win32, AWT</li>
         *   <li>Window Icon: X11, Win32</li>
         * </ul>
         * </p>
         */
        static constexpr PixelFormat BGRA8888 = PixelFormat(4, { CType::B, CType::G, CType::R, CType::A }, 8, 32);
        
        static constexpr std::array<const PixelFormat*, 11> formats = { &LUMINANCE, &RGB565, &BGR565, 
            &RGBA5551, &ABGR1555, &RGB888, &BGR888, &RGBA8888, &ABGR8888, &ARGB8888, &BGRA8888 };
            
        /**
         * Returns the {@link PixelFormat} with reversed components of <code>fmt</code>.
         * If no reversed  {@link PixelFormat} is available, returns <code>fmt</code>.
         */
        static const PixelFormat& reverse(const PixelFormat& fmt) noexcept {
            if( fmt == RGB565 ) {
                return BGR565;
            } else if( fmt == BGR565 ) {
                return RGB565;
            } else if( fmt == RGBA5551 ) {
                return ABGR1555;
            } else if( fmt ==  ABGR1555 ) {
                return RGBA5551;
            } else if( fmt == RGB888 ) {
                return BGR888;
            } else if( fmt == BGR888 ) {
                return RGB888;
            } else if( fmt == RGBA8888 ) {
                return ABGR8888;
            } else if( fmt == ABGR8888 ) {
                return RGBA8888;
            } else if( fmt == ARGB8888 ) {
                return BGRA8888;
            } else if( fmt == BGRA8888 ) {
                return ABGR8888;
            } else {
                return fmt;
            }
        }
        
        static uint32_t toU32(const PixelFormat& dst_fmt, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
            if(dst_fmt == LUMINANCE) {
                const uint8_t l = (uint8_t) ( ( ( ( 0xff & r ) + ( 0xff & g ) + ( 0xff & b ) ) / 3 ) * a );
                return ( 0xff     ) << 24 | ( 0xff & l ) << 16 | ( 0xff & l ) << 8 | ( 0xff & l );
            } else if(dst_fmt == RGB888) {
                return ( 0xff     ) << 24 | ( 0xff & b ) << 16 | ( 0xff & g ) << 8 | ( 0xff & r );
            } else if(dst_fmt == BGR888) {
                return ( 0xff     ) << 24 | ( 0xff & r ) << 16 | ( 0xff & g ) << 8 | ( 0xff & b );
            } else if(dst_fmt == RGBA8888) {
                return ( 0xff & a ) << 24 | ( 0xff & b ) << 16 | ( 0xff & g ) << 8 | ( 0xff & r );
            } else if(dst_fmt == ABGR8888) {
                return ( 0xff & r ) << 24 | ( 0xff & g ) << 16 | ( 0xff & b ) << 8 | ( 0xff & a );
            } else if(dst_fmt == ARGB8888) {
                return ( 0xff & b ) << 24 | ( 0xff & g ) << 16 | ( 0xff & r ) << 8 | ( 0xff & a );
            } else if(dst_fmt == BGRA8888) {
                return ( 0xff & a ) << 24 | ( 0xff & r ) << 16 | ( 0xff & g ) << 8 | ( 0xff & b );
            } else {
                throw jau::InternalError("Unhandled format "+dst_fmt.toString(), E_FILE_LINE);
            }
        }        
        
        static uint32_t convertU32(const PixelFormat& dst_fmt, const PixelFormat& src_fmt, const uint8_t* src) {
            uint8_t r, g, b, a;
            jau::nsize_t srcOff = 0;
            if(src_fmt == LUMINANCE) {
                r  = src[srcOff++];  // R
                g  = r;              // G
                b  = r;              // B
                a  = (uint8_t) 0xff; // A
            } else if(src_fmt == RGB888) {
                r  = src[srcOff++];  // R
                g  = src[srcOff++];  // G
                b  = src[srcOff++];  // B
                a  = (uint8_t) 0xff; // A
            } else if(src_fmt == BGR888) {
                b  = src[srcOff++];  // B
                g  = src[srcOff++];  // G
                r  = src[srcOff++];  // R
                a  = (uint8_t) 0xff; // A
            } else if(src_fmt == RGBA8888) {
                r  = src[srcOff++];  // R
                g  = src[srcOff++];  // G
                b  = src[srcOff++];  // B
                a  = src[srcOff++];  // A
            } else if(src_fmt == ABGR8888) {
                a  = src[srcOff++];  // A
                b  = src[srcOff++];  // B
                g  = src[srcOff++];  // G
                r  = src[srcOff++];  // R
            } else if(src_fmt == ARGB8888) {
                a  = src[srcOff++];  // A
                r  = src[srcOff++];  // R
                g  = src[srcOff++];  // G
                b  = src[srcOff++];  // B
            } else if(src_fmt == BGRA8888) {
                b  = src[srcOff++];  // B
                g  = src[srcOff++];  // G
                r  = src[srcOff++];  // R
                a  = src[srcOff++];  // A
            } else {
                throw jau::InternalError("Unhandled format "+dst_fmt.toString(), E_FILE_LINE);
            }
            return toU32(dst_fmt, r, g, b, a);
        }
    
        static uint32_t convertU32(const PixelFormat& dst_fmt, const PixelFormat& src_fmt, uint32_t src_pixel) {
            uint8_t r, g, b, a;
            if( src_fmt == LUMINANCE ) {
                r = static_cast<uint8_t>(src_pixel);  // R
                g = r;                                // G
                b = r;                                // B
                a = static_cast<uint8_t>(0xff);       // A
            } else if( src_fmt == RGB888 ) {
                r = static_cast<uint8_t>(src_pixel);         // R
                g = static_cast<uint8_t>(src_pixel >> 8);    // G
                b = static_cast<uint8_t>(src_pixel >> 16);   // B
                a = static_cast<uint8_t>(0xff);              // A
            } else if( src_fmt == BGR888 ) {
                b = static_cast<uint8_t>(src_pixel);         // B
                g = static_cast<uint8_t>(src_pixel >> 8);    // G
                r = static_cast<uint8_t>(src_pixel >> 16);   // R
                a = static_cast<uint8_t>(0xff);              // A
            } else if( src_fmt == RGBA8888 ) {
                r = static_cast<uint8_t>(src_pixel);         // R
                g = static_cast<uint8_t>(src_pixel >> 8);    // G
                b = static_cast<uint8_t>(src_pixel >> 16);   // B
                a = static_cast<uint8_t>(src_pixel >> 24);   // A
            } else if( src_fmt == ABGR8888 ) {
                a = static_cast<uint8_t>(src_pixel);         // A
                b = static_cast<uint8_t>(src_pixel >> 8);    // B
                g = static_cast<uint8_t>(src_pixel >> 16);   // G
                r = static_cast<uint8_t>(src_pixel >> 24);   // R
            } else if( src_fmt == ARGB8888 ) {
                a = static_cast<uint8_t>(src_pixel);         // A
                r = static_cast<uint8_t>(src_pixel >> 8);    // R
                g = static_cast<uint8_t>(src_pixel >> 16);   // G
                b = static_cast<uint8_t>(src_pixel >> 24);   // B
            } else if( src_fmt == BGRA8888 ) {
                b = static_cast<uint8_t>(src_pixel);         // B
                g = static_cast<uint8_t>(src_pixel >> 8);    // G
                r = static_cast<uint8_t>(src_pixel >> 16);   // R
                a = static_cast<uint8_t>(src_pixel >> 24);   // A
            } else {
                throw jau::InternalError("Unhandled format " + dst_fmt.toString(), E_FILE_LINE);
            }
            return toU32(dst_fmt, r, g, b, a);
        }
        
        static GenericPixelRect convert(const PixelRectangle& src,
                                        const PixelFormat& destFmt, uint32_t ddestStride, bool isGLOriented) {
            uint32_t destStride;
            if( 0 != ddestStride ) {
                destStride = ddestStride;
            } else {
                destStride = destFmt.bytesPerPixel() * src.size().x;
            }
            GenericPixelRect dst(destFmt, src.size(), destStride, isGLOriented);
            // convert(src, dst);
            convert(src.size(),
                    src.pixels(), src.format(), src.isGLOriented(), src.stride(),
                    dst.mutablePixels(), dst.format(), dst.isGLOriented(), dst.stride());
            return dst;
        }
    
        /**
         * @param src source PixelRectangle
         * @param dst destination PixelRectangle
         */
        static void convert(const PixelRectangle& src, PixelRectangle& dst)
        {
            convert(src.size(),
                    src.pixels(), src.format(), src.isGLOriented(), src.stride(),
                    dst.mutablePixels(), dst.format(), dst.isGLOriented(), dst.stride());
        }
        
        /**
         * @param width width of the to be converted pixel rectangle
         * @param height height of the to be converted pixel rectangle
         * @param src_bb  {@link ByteBuffer} source
         * @param src_fmt source {@link PixelFormat}
         * @param src_glOriented if true, the source memory is laid out in OpenGL's coordinate system, <i>origin at bottom left</i>,
         *                       otherwise <i>origin at top left</i>.
         * @param src_lineStride line stride in byte-size for source, i.e. byte count from one line to the next.
         *                       Must be >= {@link PixelFormat.Composition#bytesPerPixel() src_fmt.comp.bytesPerPixel()} * width
         *                       or {@code zero} for default stride.
         * @param dst_bb  {@link ByteBuffer} sink
         * @param dst_fmt destination {@link PixelFormat}
         * @param dst_glOriented if true, the source memory is laid out in OpenGL's coordinate system, <i>origin at bottom left</i>,
         *                       otherwise <i>origin at top left</i>.
         * @param dst_lineStride line stride in byte-size for destination, i.e. byte count from one line to the next.
         *                       Must be >= {@link PixelFormat.Composition#bytesPerPixel() dst_fmt.comp.bytesPerPixel()} * width
         *                       or {@code zero} for default stride.
         *
         * @throws IllegalStateException
         * @throws IllegalArgumentException if {@code src_lineStride} or {@code dst_lineStride} is invalid
         */
        static void convert(const Point2u32& size,
                            const uint8_t* src_pixels, const PixelFormat& src_fmt, bool src_glOriented, uint32_t src_lineStride,
                                  uint8_t* dst_pixels, const PixelFormat& dst_fmt, bool dst_glOriented, uint32_t dst_lineStride) {
            const uint32_t height = size.y;
            const uint32_t width = size.x;          
            const uint32_t src_bpp = src_fmt.bytesPerPixel();
            const uint32_t dst_bpp = dst_fmt.bytesPerPixel();
            if( src_bpp > 4 ) {
                throw jau::IllegalArgumentError(jau::format_string_n<"Invalid source bpp %u, %s">(511, src_bpp, src_fmt.toString().c_str()), E_FILE_LINE);                                      
            }
            if( dst_bpp > 4 ) {
                throw jau::IllegalArgumentError(jau::format_string_n<"Invalid dest bpp %u, %s">(511, dst_bpp, dst_fmt.toString().c_str()), E_FILE_LINE);                                      
            }
    
            if( 0 != src_lineStride ) {
                if( src_lineStride < src_bpp * width ) {
                    throw jau::IllegalArgumentError(jau::format_string_n<"Invalid source stride %u, must be greater than bytesPerPixel %u * width %u">(511,
                      src_lineStride, src_bpp, width), E_FILE_LINE);                      
                }
            } else {
                src_lineStride = src_bpp * width;
            }
            if( 0 != dst_lineStride ) {
                if( dst_lineStride < dst_bpp * width ) {
                    throw jau::IllegalArgumentError(jau::format_string_n<"Invalid destination stride %u, must be greater than bytesPerPixel %u * width %u">(511,
                            dst_lineStride, dst_bpp, width), E_FILE_LINE);
                }
            } else {
                dst_lineStride = dst_bpp * width;
            }
    
            // final int src_comp_bitStride = src_comp.bitStride();
            const uint32_t dst_comp_bitStride = dst_fmt.bitStride();
            const bool vert_flip = src_glOriented != dst_glOriented;
            const bool fast_copy = src_fmt == dst_fmt && 0 == dst_comp_bitStride%8;
            #if 0
            if( DEBUG_MODE ) {
                System.err.println("XXX: size "+width+"x"+height+", fast_copy "+fast_copy);
                System.err.println("XXX: SRC fmt "+src_fmt+", "+src_comp+", stride "+src_lineStride+", isGLOrient "+src_glOriented);
                System.err.println("XXX: DST fmt "+dst_fmt+", "+dst_comp+", stride "+dst_lineStride+", isGLOrient "+dst_glOriented);
            }
            #endif
    
            if( fast_copy ) {
                // Fast copy
                if( !vert_flip && dst_lineStride == src_lineStride ) {
                    std::memcpy(dst_pixels, src_pixels, width*dst_lineStride*height);
                } else if( vert_flip ) {
                    for(uint32_t y=0; y<height; ++y) {
                        const uint32_t src_off = ( height - 1 - y ) * src_lineStride;
                        const uint32_t dst_off = dst_lineStride*y;
                        std::memcpy(dst_pixels+dst_off, src_pixels+src_off, width*dst_bpp);
                    }                    
                } else {
                    for(uint32_t y=0; y<height; ++y) {
                        const uint32_t src_off = y * src_lineStride;
                        const uint32_t dst_off = dst_lineStride*y;
                        std::memcpy(dst_pixels+dst_off, src_pixels+src_off, width*dst_bpp);
                    }
                }
            } else {
                // Conversion
                ComponentMap cmap(src_fmt.size(), src_fmt.order(), dst_fmt.size(), dst_fmt.order());
                
                for(uint32_t y=0; y<height; y++) {
                    const uint32_t src_off = vert_flip ? ( height - 1 - y ) * src_lineStride : y * src_lineStride;
                    const uint32_t dst_off = dst_lineStride*y;
                    const uint8_t* src_pos = src_pixels+src_off;
                    uint8_t* dst_pos = dst_pixels+dst_off;
                    for(uint32_t x=0; x<width; ++x) {
                        convert(cmap, dst_fmt, dst_pos, src_fmt, src_pos);
                    }
                    // srcBitStream.skip(( src_lineStride * 8 ) - ( src_comp_bitStride * width ));
                    dstBitStream.skip(( dst_lineStride * 8 ) - ( dst_comp_bitStride * width ));
                }
            }
        }
    
        static void convert(const ComponentMap& cmap,
                            const PixelFormat dstComp,
                            uint8_t* dstBitStream,
                            const PixelFormat& srcComp,
                            const uint8_t* srcBitStream) 
        {
            const jau::nsize_t sCompCount = srcComp.size();
            const jau::nsize_t dCompCount = dstComp.size();
            u32array4_t sc; //  = new int[sCompCount];
            u32array4_t dcDef; //  = new int[dCompCount];
            const u32array4_t& srcCompBitCount = srcComp.bitCount();
            const u32array4_t& srcCompBitMask = srcComp.bitMask();
            const u32array4_t& dstCompBitCount = dstComp.bitCount();
    
            // Fill w/ source values
            for(jau::nsize_t sIdx=0; sIdx<sCompCount; ++sIdx) {
                sc[sIdx] = srcBitStream.readBits31(srcCompBitCount[sIdx]) & srcCompBitMask[sIdx];
            }
            srcBitStream.skip(srcComp.bitStride() - srcComp.bitsPerPixel());
    
            // Cache missing defaults
            for(int i=0; i<dCompCount; i++) {
                dcDef[i] = dstComp.defaultValue(i, false);
            }
    
            if( 1 == dCompCount &&
                PixelFormat.CType::Y == dstComp.componentOrder()[0] &&
                cmap.hasSrcRGB
              )
            {
                // RGB[A] -> Y conversion
                final int r = sc[cmap.srcRGBA[0]];
                final int g = sc[cmap.srcRGBA[1]];
                final int b = sc[cmap.srcRGBA[2]];
                final float rF = srcComp.toFloat(r, cmap.srcRGBA[0], false);
                final float gF = srcComp.toFloat(g, cmap.srcRGBA[1], false);
                final float bF = srcComp.toFloat(b, cmap.srcRGBA[2], false);
                final int a;
                final float aF;
                /** if( 0 <= cmap.srcRGBA[3] ) { // disable premultiplied-alpha
                    a = sc[cmap.srcRGBA[3]];
                    aF = srcComp.toFloat(a, false, cmap.srcRGBA[3]);
                } else */ {
                    a = 1;
                    aF = 1f;
                }
                final float lF = ( rF + gF + bF ) * aF / 3f;
                final int v = dstComp.fromFloat(lF, 0, false);
    
                dstBitStream.writeBits31(dstCompBitCount[0], v);
                dstBitStream.skip(dstComp.bitStride() - dstComp.bitsPerPixel());
                if( DEBUG ) {
                    if( srcBitStream.position() <= 8*4 ) {
                        System.err.printf("convert: rgb[a] -> Y: rgb 0x%02X 0x%02X 0x%02X 0x%02X -> %f %f %f %f"+
                                " -> %f -> dstC 0 0x%08X (%d bits: %s)%n",
                                r, g, b, a,
                                rF, gF, bF, aF,
                                lF, v, dstCompBitCount[0], Bitstream.toBinString(true, v, dstCompBitCount[0])
                                );
                    }
                }
                return;
            }
    
            for(int dIdx=0; dIdx<dCompCount; dIdx++) {
                int sIdx;
                if( 0 <= ( sIdx = cmap.dst2src[dIdx] ) ) {
                    final float f = srcComp.toFloat(sc[sIdx], sIdx, false);
                    final int v = dstComp.fromFloat(f, dIdx, false);
                    dstBitStream.writeBits31(dstCompBitCount[dIdx], v);
                    if( DEBUG ) {
                        if( srcBitStream.position() <= 8*4 ) {
                            System.err.printf("convert: srcC %d: 0x%08X -> %f -> dstC %d 0x%08X (%d bits: %s)%n",
                                    sIdx, sc[sIdx], f, dIdx, v, dstCompBitCount[dIdx], Bitstream.toBinString(true, v, dstCompBitCount[dIdx]));
                        }
                    }
                } else {
                    dstBitStream.writeBits31(dstCompBitCount[dIdx], dcDef[dIdx]);
                    if( DEBUG ) {
                        if( srcBitStream.position() <= 8*4 ) {
                            System.err.printf("convert: srcC %d: undef -> dstC %d 0x%08X (%d bits: %s)%n",
                                    sIdx, dIdx, dcDef[dIdx], dstCompBitCount[dIdx], Bitstream.toBinString(true, dcDef[dIdx], dstCompBitCount[dIdx]));
                        }
                    }
                }
            }
            dstBitStream.skip(dstComp.bitStride() - dstComp.bitsPerPixel());
            return;
        }
    };
 
        
    /**@}*/
 
}  // namespace gamp::render::pixel
 
#endif /* GAMP_RENDER_PIXEL_PIXELFORMAT_HPP_ */