Function to_float_packed

Engine/Lut.cpp:1228–1287

#endif // DEAD_CODE

void
to_float_packed(float* to,
                const float* from,
                const RectI & conversionRect,
                const RectI & srcBounds,
                const RectI & dstBounds,
                PixelPackingEnum inputPacking,
                PixelPackingEnum outputPacking,
                bool invertY,
                bool premult)
{
    if ( ( inputPacking == ePixelPackingPLANAR) || ( outputPacking == ePixelPackingPLANAR) ) {
        throw std::runtime_error("Invalid pixel format.");
    }

    ///clip the conversion rect to srcBounds and dstBounds
    RectI rect = conversionRect;
    if ( !clip(&rect, srcBounds) || !clip(&rect, dstBounds) ) {
        return;
    }


    bool inputHasAlpha = inputPacking == ePixelPackingBGRA || inputPacking == ePixelPackingRGBA;
    bool outputHasAlpha = outputPacking == ePixelPackingBGRA || outputPacking == ePixelPackingRGBA;
    int inROffset, inGOffset, inBOffset, inAOffset;
    int outROffset, outGOffset, outBOffset, outAOffset;
    getOffsetsForPacking(inputPacking, &inROffset, &inGOffset, &inBOffset, &inAOffset);
    getOffsetsForPacking(outputPacking, &outROffset, &outGOffset, &outBOffset, &outAOffset);


    int inPackingSize, outPackingSize;
    inPackingSize = inputHasAlpha ? 4 : 3;
    outPackingSize = outputHasAlpha ? 4 : 3;

    for (int y = rect.y1; y < rect.y2; ++y) {
        int srcY = y;
        if (invertY) {
            srcY = srcBounds.y2 - y - 1;
        }

        const float *src_pixels = from + (srcY * (srcBounds.x2 - srcBounds.x1) * inPackingSize);
        float *dst_pixels = to + (y * (dstBounds.x2 - dstBounds.x1) * outPackingSize);
        if ( ( inputPacking == outputPacking) && !premult ) {
            std::memcpy( dst_pixels, src_pixels, (rect.x2 - rect.x1) * sizeof(float) );
        } else {
            for (int x = rect.x1; x < conversionRect.x2; ++x) {
                int inCol = x * inPackingSize;
                int outCol = x * outPackingSize;
                float a = (inputHasAlpha && premult) ? src_pixels[inCol + inAOffset] : 1.f;

                dst_pixels[outCol + outROffset] = src_pixels[inCol + inROffset] * a;
                dst_pixels[outCol + outGOffset] = src_pixels[inCol + inGOffset] * a;
                dst_pixels[outCol + outBOffset] = src_pixels[inCol + inBOffset] * a;
                if (outputHasAlpha) {
                    dst_pixels[outCol + outAOffset] = a;
                }
            }
        }