path: root/thirdparty/cvtt/ConvectionKernels_ETC.cpp

/*
Convection Texture Tools
Copyright (c) 2018-2019 Eric Lasota

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject
to the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-------------------------------------------------------------------------------------

Portions based on DirectX Texture Library (DirectXTex)

Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the MIT License.

http://go.microsoft.com/fwlink/?LinkId=248926
*/
#include "ConvectionKernels_Config.h"

#if !defined(CVTT_SINGLE_FILE) || defined(CVTT_SINGLE_FILE_IMPL)

#include "ConvectionKernels.h"
#include "ConvectionKernels_ETC.h"
#include "ConvectionKernels_ETC1.h"
#include "ConvectionKernels_ETC2.h"
#include "ConvectionKernels_ETC2_Rounding.h"
#include "ConvectionKernels_ParallelMath.h"
#include "ConvectionKernels_FakeBT709_Rounding.h"

#include <cmath>

const int cvtt::Internal::ETCComputer::g_flipTables[2][2][8] =
{
    {
        { 0, 1, 4, 5, 8, 9, 12, 13 },
        { 2, 3, 6, 7, 10, 11, 14, 15 }
    },
    {
        { 0, 1, 2, 3, 4, 5, 6, 7 },
        { 8, 9, 10, 11, 12, 13, 14, 15 }
    },
};

cvtt::ParallelMath::Float cvtt::Internal::ETCComputer::ComputeErrorUniform(const MUInt15 pixelA[3], const MUInt15 pixelB[3])
{
    MSInt16 d0 = ParallelMath::LosslessCast<MSInt16>::Cast(pixelA[0]) - ParallelMath::LosslessCast<MSInt16>::Cast(pixelB[0]);
    MFloat fd0 = ParallelMath::ToFloat(d0);
    MFloat error = fd0 * fd0;
    for (int ch = 1; ch < 3; ch++)
    {
        MSInt16 d = ParallelMath::LosslessCast<MSInt16>::Cast(pixelA[ch]) - ParallelMath::LosslessCast<MSInt16>::Cast(pixelB[ch]);
        MFloat fd = ParallelMath::ToFloat(d);
        error = error + fd * fd;
    }
    return error;
}

cvtt::ParallelMath::Float cvtt::Internal::ETCComputer::ComputeErrorWeighted(const MUInt15 reconstructed[3], const MFloat preWeightedPixel[3], const Options options)
{
    MFloat dr = ParallelMath::ToFloat(reconstructed[0]) * options.redWeight - preWeightedPixel[0];
    MFloat dg = ParallelMath::ToFloat(reconstructed[1]) * options.greenWeight - preWeightedPixel[1];
    MFloat db = ParallelMath::ToFloat(reconstructed[2]) * options.blueWeight - preWeightedPixel[2];

    return dr * dr + dg * dg + db * db;
}

cvtt::ParallelMath::Float cvtt::Internal::ETCComputer::ComputeErrorFakeBT709(const MUInt15 reconstructed[3], const MFloat preWeightedPixel[3])
{
    MFloat yuv[3];
    ConvertToFakeBT709(yuv, reconstructed);

    MFloat dy = yuv[0] - preWeightedPixel[0];
    MFloat du = yuv[1] - preWeightedPixel[1];
    MFloat dv = yuv[2] - preWeightedPixel[2];

    return dy * dy + du * du + dv * dv;
}

void cvtt::Internal::ETCComputer::TestHalfBlock(MFloat &outError, MUInt16 &outSelectors, MUInt15 quantizedPackedColor, const MUInt15 pixels[8][3], const MFloat preWeightedPixels[8][3], const MSInt16 modifiers[4], bool isDifferential, const Options &options)
{
    MUInt15 quantized[3];
    MUInt15 unquantized[3];

    for (int ch = 0; ch < 3; ch++)
    {
        quantized[ch] = (ParallelMath::RightShift(quantizedPackedColor, (ch * 5)) & ParallelMath::MakeUInt15(31));

        if (isDifferential)
            unquantized[ch] = (quantized[ch] << 3) | ParallelMath::RightShift(quantized[ch], 2);
        else
            unquantized[ch] = (quantized[ch] << 4) | quantized[ch];
    }

    MUInt16 selectors = ParallelMath::MakeUInt16(0);
    MFloat totalError = ParallelMath::MakeFloatZero();

    MUInt15 u15_255 = ParallelMath::MakeUInt15(255);
    MSInt16 s16_zero = ParallelMath::MakeSInt16(0);

    MUInt15 unquantizedModified[4][3];
    for (unsigned int s = 0; s < 4; s++)
        for (int ch = 0; ch < 3; ch++)
            unquantizedModified[s][ch] = ParallelMath::Min(ParallelMath::ToUInt15(ParallelMath::Max(ParallelMath::ToSInt16(unquantized[ch]) + modifiers[s], s16_zero)), u15_255);

    bool isUniform = ((options.flags & cvtt::Flags::Uniform) != 0);
    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);

    for (int px = 0; px < 8; px++)
    {
        MFloat bestError = ParallelMath::MakeFloat(FLT_MAX);
        MUInt16 bestSelector = ParallelMath::MakeUInt16(0);

        for (unsigned int s = 0; s < 4; s++)
        {
            MFloat error;
            if (isFakeBT709)
                error = ComputeErrorFakeBT709(unquantizedModified[s], preWeightedPixels[px]);
            else if (isUniform)
                error = ComputeErrorUniform(pixels[px], unquantizedModified[s]);
            else
                error = ComputeErrorWeighted(unquantizedModified[s], preWeightedPixels[px], options);

            ParallelMath::FloatCompFlag errorBetter = ParallelMath::Less(error, bestError);
            bestSelector = ParallelMath::Select(ParallelMath::FloatFlagToInt16(errorBetter), ParallelMath::MakeUInt16(s), bestSelector);
            bestError = ParallelMath::Min(error, bestError);
        }

        totalError = totalError + bestError;
        selectors = selectors | (bestSelector << (px * 2));
    }

    outError = totalError;
    outSelectors = selectors;
}

void cvtt::Internal::ETCComputer::TestHalfBlockPunchthrough(MFloat &outError, MUInt16 &outSelectors, MUInt15 quantizedPackedColor, const MUInt15 pixels[8][3], const MFloat preWeightedPixels[8][3], const ParallelMath::Int16CompFlag isTransparent[8], const MUInt15 modifier, const Options &options)
{
    MUInt15 quantized[3];
    MUInt15 unquantized[3];

    for (int ch = 0; ch < 3; ch++)
    {
        quantized[ch] = (ParallelMath::RightShift(quantizedPackedColor, (ch * 5)) & ParallelMath::MakeUInt15(31));
        unquantized[ch] = (quantized[ch] << 3) | ParallelMath::RightShift(quantized[ch], 2);
    }

    MUInt16 selectors = ParallelMath::MakeUInt16(0);
    MFloat totalError = ParallelMath::MakeFloatZero();

    MUInt15 u15_255 = ParallelMath::MakeUInt15(255);
    MSInt16 s16_zero = ParallelMath::MakeSInt16(0);

    MUInt15 unquantizedModified[3][3];
    for (int ch = 0; ch < 3; ch++)
    {
        unquantizedModified[0][ch] = ParallelMath::Max(unquantized[ch], modifier) - modifier;
        unquantizedModified[1][ch] = unquantized[ch];
        unquantizedModified[2][ch] = ParallelMath::Min(unquantized[ch] + modifier, u15_255);
    }

    bool isUniform = ((options.flags & cvtt::Flags::Uniform) != 0);
    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);

    for (int px = 0; px < 8; px++)
    {
        ParallelMath::FloatCompFlag isTransparentFloat = ParallelMath::Int16FlagToFloat(isTransparent[px]);

        MFloat bestError = ParallelMath::MakeFloat(FLT_MAX);
        MUInt15 bestSelector = ParallelMath::MakeUInt15(0);

        for (unsigned int s = 0; s < 3; s++)
        {
            MFloat error;
            if (isFakeBT709)
                error = ComputeErrorFakeBT709(unquantizedModified[s], preWeightedPixels[px]);
            else if (isUniform)
                error = ComputeErrorUniform(pixels[px], unquantizedModified[s]);
            else
                error = ComputeErrorWeighted(unquantizedModified[s], preWeightedPixels[px], options);

            ParallelMath::FloatCompFlag errorBetter = ParallelMath::Less(error, bestError);
            bestSelector = ParallelMath::Select(ParallelMath::FloatFlagToInt16(errorBetter), ParallelMath::MakeUInt15(s), bestSelector);
            bestError = ParallelMath::Min(error, bestError);
        }

        // Annoying quirk: The ETC encoding machinery assumes that selectors are in the table order in the spec, which isn't
        // the same as their encoding bits, so the transparent index is actually 1 and the valid indexes are 0, 2, and 3.

        // Remap selector 1 to 2, and 2 to 3
        bestSelector = ParallelMath::Min(ParallelMath::MakeUInt15(3), bestSelector << 1);

        // Mark zero transparent as 
        ParallelMath::ConditionalSet(bestError, isTransparentFloat, ParallelMath::MakeFloatZero());
        ParallelMath::ConditionalSet(bestSelector, isTransparent[px], ParallelMath::MakeUInt15(1));

        totalError = totalError + bestError;
        selectors = selectors | (ParallelMath::LosslessCast<MUInt16>::Cast(bestSelector) << (px * 2));
    }

    outError = totalError;
    outSelectors = selectors;
}

void cvtt::Internal::ETCComputer::FindBestDifferentialCombination(int flip, int d, const ParallelMath::Int16CompFlag canIgnoreSector[2], ParallelMath::Int16CompFlag& bestIsThisMode, MFloat& bestTotalError, MUInt15& bestFlip, MUInt15& bestD, MUInt15 bestColors[2], MUInt16 bestSelectors[2], MUInt15 bestTables[2], DifferentialResolveStorage &drs)
{
    // We do this part scalar because most of the cost benefit of parallelization is in error evaluation,
    // and this code has a LOT of early-outs and disjointed index lookups that vary heavily between blocks
    // and save a lot of time.
    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        bool canIgnore[2] = { ParallelMath::Extract(canIgnoreSector[0], block), ParallelMath::Extract(canIgnoreSector[1], block) };
        bool canIgnoreEither = canIgnore[0] || canIgnore[1];
        float blockBestTotalError = ParallelMath::Extract(bestTotalError, block);
        float bestDiffErrors[2] = { FLT_MAX, FLT_MAX };
        uint16_t bestDiffSelectors[2] = { 0, 0 };
        uint16_t bestDiffColors[2] = { 0, 0 };
        uint16_t bestDiffTables[2] = { 0, 0 };
        for (int sector = 0; sector < 2; sector++)
        {
            unsigned int sectorNumAttempts = ParallelMath::Extract(drs.diffNumAttempts[sector], block);
            for (unsigned int i = 0; i < sectorNumAttempts; i++)
            {
                float error = ParallelMath::Extract(drs.diffErrors[sector][i], block);
                if (error < bestDiffErrors[sector])
                {
                    bestDiffErrors[sector] = error;
                    bestDiffSelectors[sector] = ParallelMath::Extract(drs.diffSelectors[sector][i], block);
                    bestDiffColors[sector] = ParallelMath::Extract(drs.diffColors[sector][i], block);
                    bestDiffTables[sector] = ParallelMath::Extract(drs.diffTables[sector][i], block);
                }
            }
        }

        if (canIgnore[0])
            bestDiffColors[0] = bestDiffColors[1];
        else if (canIgnore[1])
            bestDiffColors[1] = bestDiffColors[0];

        // The best differential possibilities must be better than the best total error
        if (bestDiffErrors[0] + bestDiffErrors[1] < blockBestTotalError)
        {
            // Fast path if the best possible case is legal
            if (canIgnoreEither || ETCDifferentialIsLegalScalar(bestDiffColors[0], bestDiffColors[1]))
            {
                ParallelMath::PutBoolInt16(bestIsThisMode, block, true);
                ParallelMath::PutFloat(bestTotalError, block, bestDiffErrors[0] + bestDiffErrors[1]);
                ParallelMath::PutUInt15(bestFlip, block, flip);
                ParallelMath::PutUInt15(bestD, block, d);
                for (int sector = 0; sector < 2; sector++)
                {
                    ParallelMath::PutUInt15(bestColors[sector], block, bestDiffColors[sector]);
                    ParallelMath::PutUInt16(bestSelectors[sector], block, bestDiffSelectors[sector]);
                    ParallelMath::PutUInt15(bestTables[sector], block, bestDiffTables[sector]);
                }
            }
            else
            {
                // Slow path: Sort the possible cases by quality, and search valid combinations
                // TODO: Pre-flatten the error lists so this is nicer to cache
                unsigned int numSortIndexes[2] = { 0, 0 };
                for (int sector = 0; sector < 2; sector++)
                {
                    unsigned int sectorNumAttempts = ParallelMath::Extract(drs.diffNumAttempts[sector], block);

                    for (unsigned int i = 0; i < sectorNumAttempts; i++)
                    {
                        if (ParallelMath::Extract(drs.diffErrors[sector][i], block) < blockBestTotalError)
                            drs.attemptSortIndexes[sector][numSortIndexes[sector]++] = i;
                    }

                    struct SortPredicate
                    {
                        const MFloat *diffErrors;
                        int block;

                        bool operator()(uint16_t a, uint16_t b) const
                        {
                            float errorA = ParallelMath::Extract(diffErrors[a], block);
                            float errorB = ParallelMath::Extract(diffErrors[b], block);

                            if (errorA < errorB)
                                return true;
                            if (errorA > errorB)
                                return false;

                            return a < b;
                        }
                    };

                    SortPredicate sp;
                    sp.diffErrors = drs.diffErrors[sector];
                    sp.block = block;

                    std::sort<uint16_t*, const SortPredicate&>(drs.attemptSortIndexes[sector], drs.attemptSortIndexes[sector] + numSortIndexes[sector], sp);
                }

                int scannedElements = 0;
                for (unsigned int i = 0; i < numSortIndexes[0]; i++)
                {
                    unsigned int attemptIndex0 = drs.attemptSortIndexes[0][i];
                    float error0 = ParallelMath::Extract(drs.diffErrors[0][attemptIndex0], block);

                    scannedElements++;

                    if (error0 >= blockBestTotalError)
                        break;

                    float maxError1 = ParallelMath::Extract(bestTotalError, block) - error0;
                    uint16_t diffColor0 = ParallelMath::Extract(drs.diffColors[0][attemptIndex0], block);

                    if (maxError1 < bestDiffErrors[1])
                        break;

                    for (unsigned int j = 0; j < numSortIndexes[1]; j++)
                    {
                        unsigned int attemptIndex1 = drs.attemptSortIndexes[1][j];
                        float error1 = ParallelMath::Extract(drs.diffErrors[1][attemptIndex1], block);

                        scannedElements++;

                        if (error1 >= maxError1)
                            break;

                        uint16_t diffColor1 = ParallelMath::Extract(drs.diffColors[1][attemptIndex1], block);

                        if (ETCDifferentialIsLegalScalar(diffColor0, diffColor1))
                        {
                            blockBestTotalError = error0 + error1;

                            ParallelMath::PutBoolInt16(bestIsThisMode, block, true);
                            ParallelMath::PutFloat(bestTotalError, block, blockBestTotalError);
                            ParallelMath::PutUInt15(bestFlip, block, flip);
                            ParallelMath::PutUInt15(bestD, block, d);
                            ParallelMath::PutUInt15(bestColors[0], block, diffColor0);
                            ParallelMath::PutUInt15(bestColors[1], block, diffColor1);
                            ParallelMath::PutUInt16(bestSelectors[0], block, ParallelMath::Extract(drs.diffSelectors[0][attemptIndex0], block));
                            ParallelMath::PutUInt16(bestSelectors[1], block, ParallelMath::Extract(drs.diffSelectors[1][attemptIndex1], block));
                            ParallelMath::PutUInt15(bestTables[0], block, ParallelMath::Extract(drs.diffTables[0][attemptIndex0], block));
                            ParallelMath::PutUInt15(bestTables[1], block, ParallelMath::Extract(drs.diffTables[1][attemptIndex1], block));
                            break;
                        }
                    }
                }
            }
        }
    }
}

cvtt::ParallelMath::Int16CompFlag cvtt::Internal::ETCComputer::ETCDifferentialIsLegalForChannel(const MUInt15 &a, const MUInt15 &b)
{
    MSInt16 diff = ParallelMath::LosslessCast<MSInt16>::Cast(b) - ParallelMath::LosslessCast<MSInt16>::Cast(a);

    return ParallelMath::Less(ParallelMath::MakeSInt16(-5), diff) & ParallelMath::Less(diff, ParallelMath::MakeSInt16(4));
}

cvtt::ParallelMath::Int16CompFlag cvtt::Internal::ETCComputer::ETCDifferentialIsLegal(const MUInt15 &a, const MUInt15 &b)
{
    MUInt15 mask = ParallelMath::MakeUInt15(31);

    return ETCDifferentialIsLegalForChannel(ParallelMath::RightShift(a, 10), ParallelMath::RightShift(b, 10))
        & ETCDifferentialIsLegalForChannel(ParallelMath::RightShift(a, 5) & mask, ParallelMath::RightShift(b, 5) & mask)
        & ETCDifferentialIsLegalForChannel(a & mask, b & mask);
}

bool cvtt::Internal::ETCComputer::ETCDifferentialIsLegalForChannelScalar(const uint16_t &a, const uint16_t &b)
{
    int16_t diff = static_cast<int16_t>(b) - static_cast<int16_t>(a);

    return (-4 <= diff) && (diff <= 3);
}

bool cvtt::Internal::ETCComputer::ETCDifferentialIsLegalScalar(const uint16_t &a, const uint16_t &b)
{
    MUInt15 mask = ParallelMath::MakeUInt15(31);

    return ETCDifferentialIsLegalForChannelScalar((a >> 10), (b >> 10))
        & ETCDifferentialIsLegalForChannelScalar((a >> 5) & 31, (b >> 5) & 31)
        & ETCDifferentialIsLegalForChannelScalar(a & 31, b & 31);
}

void cvtt::Internal::ETCComputer::EncodeTMode(uint8_t *outputBuffer, MFloat &bestError, const ParallelMath::Int16CompFlag isIsolated[16], const MUInt15 pixels[16][3], const MFloat preWeightedPixels[16][3], const Options &options)
{
    bool isUniform = ((options.flags & cvtt::Flags::Uniform) != 0);
    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);

    ParallelMath::Int16CompFlag bestIsThisMode = ParallelMath::MakeBoolInt16(false);

    MUInt15 isolatedTotal[3] = { ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0) };
    MUInt15 lineTotal[3] = { ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0) };

    MUInt15 numPixelsIsolated = ParallelMath::MakeUInt15(0);

    // To speed this up, we compute line total as the sum, then subtract out isolated
    for (unsigned int px = 0; px < 16; px++)
    {
        for (int ch = 0; ch < 3; ch++)
        {
            isolatedTotal[ch] = isolatedTotal[ch] + ParallelMath::SelectOrZero(isIsolated[px], pixels[px][ch]);
            lineTotal[ch] = lineTotal[ch] + pixels[px][ch];
        }
        numPixelsIsolated = numPixelsIsolated + ParallelMath::SelectOrZero(isIsolated[px], ParallelMath::MakeUInt15(1));
    }

    for (int ch = 0; ch < 3; ch++)
        lineTotal[ch] = lineTotal[ch] - isolatedTotal[ch];

    MUInt15 numPixelsLine = ParallelMath::MakeUInt15(16) - numPixelsIsolated;

    MUInt15 isolatedAverageQuantized[3];
    MUInt15 isolatedAverageTargets[3];
    {
        int divisors[ParallelMath::ParallelSize];
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
            divisors[block] = ParallelMath::Extract(numPixelsIsolated, block) * 34;

        MUInt15 addend = (numPixelsIsolated << 4) | numPixelsIsolated;
        for (int ch = 0; ch < 3; ch++)
        {
            // isolatedAverageQuantized[ch] = (isolatedTotal[ch] * 2 + numPixelsIsolated * 17) / (numPixelsIsolated * 34);

            MUInt15 numerator = isolatedTotal[ch] + isolatedTotal[ch];
            if (!isFakeBT709)
                numerator = numerator + addend;

            for (int block = 0; block < ParallelMath::ParallelSize; block++)
            {
                int divisor = divisors[block];
                if (divisor == 0)
                    ParallelMath::PutUInt15(isolatedAverageQuantized[ch], block, 0);
                else
                    ParallelMath::PutUInt15(isolatedAverageQuantized[ch], block, ParallelMath::Extract(numerator, block) / divisor);
            }

            isolatedAverageTargets[ch] = numerator;
        }
    }

    if (isFakeBT709)
        ResolveTHFakeBT709Rounding(isolatedAverageQuantized, isolatedAverageTargets, numPixelsIsolated);

    MUInt15 isolatedColor[3];
    for (int ch = 0; ch < 3; ch++)
        isolatedColor[ch] = (isolatedAverageQuantized[ch]) | (isolatedAverageQuantized[ch] << 4);

    MFloat isolatedError[16];
    for (int px = 0; px < 16; px++)
    {
        if (isFakeBT709)
            isolatedError[px] = ComputeErrorFakeBT709(isolatedColor, preWeightedPixels[px]);
        else if (isUniform)
            isolatedError[px] = ComputeErrorUniform(pixels[px], isolatedColor);
        else
            isolatedError[px] = ComputeErrorWeighted(isolatedColor, preWeightedPixels[px], options);
    }

    MSInt32 bestSelectors = ParallelMath::MakeSInt32(0);
    MUInt15 bestTable = ParallelMath::MakeUInt15(0);
    MUInt15 bestLineColor = ParallelMath::MakeUInt15(0);

    MSInt16 maxLine = ParallelMath::LosslessCast<MSInt16>::Cast(numPixelsLine);
    MSInt16 minLine = ParallelMath::MakeSInt16(0) - maxLine;

    int16_t clusterMaxLine = 0;
    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        int16_t blockMaxLine = ParallelMath::Extract(maxLine, block);
        if (blockMaxLine > clusterMaxLine)
            clusterMaxLine = blockMaxLine;
    }

    int16_t clusterMinLine = -clusterMaxLine;

    int lineDivisors[ParallelMath::ParallelSize];
    for (int block = 0; block < ParallelMath::ParallelSize; block++)
        lineDivisors[block] = ParallelMath::Extract(numPixelsLine, block) * 34;

    MUInt15 lineAddend = (numPixelsLine << 4) | numPixelsLine;

    for (int table = 0; table < 8; table++)
    {
        int numUniqueColors[ParallelMath::ParallelSize];
        MUInt15 uniqueQuantizedColors[31];

        for (int block = 0; block < ParallelMath::ParallelSize; block++)
            numUniqueColors[block] = 0;

        MUInt15 modifier = ParallelMath::MakeUInt15(cvtt::Tables::ETC2::g_thModifierTable[table]);
        MUInt15 modifierOffset = (modifier + modifier);

        for (int16_t offsetPremultiplier = clusterMinLine; offsetPremultiplier <= clusterMaxLine; offsetPremultiplier++)
        {
            MSInt16 clampedOffsetPremultiplier = ParallelMath::Max(minLine, ParallelMath::Min(maxLine, ParallelMath::MakeSInt16(offsetPremultiplier)));
            MSInt16 modifierAddend = ParallelMath::CompactMultiply(clampedOffsetPremultiplier, modifierOffset);

            MUInt15 quantized[3];
            if (isFakeBT709)
            {
                MUInt15 targets[3];
                for (int ch = 0; ch < 3; ch++)
                {
                    //quantized[ch] = std::min<int16_t>(15, std::max(0, (lineTotal[ch] * 2 + modifierOffset * offsetPremultiplier)) / (numDAIILine * 34));
                    MUInt15 numerator = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(ParallelMath::MakeSInt16(0), ParallelMath::LosslessCast<MSInt16>::Cast(lineTotal[ch] + lineTotal[ch]) + modifierAddend));
                    MUInt15 divided = ParallelMath::MakeUInt15(0);
                    for (int block = 0; block < ParallelMath::ParallelSize; block++)
                    {
                        int divisor = lineDivisors[block];
                        if (divisor == 0)
                            ParallelMath::PutUInt15(divided, block, 0);
                        else
                            ParallelMath::PutUInt15(divided, block, ParallelMath::Extract(numerator, block) / divisor);
                    }
                    quantized[ch] = ParallelMath::Min(ParallelMath::MakeUInt15(15), divided);
                    targets[ch] = numerator;
                }

                ResolveTHFakeBT709Rounding(quantized, targets, numPixelsLine);
            }
            else
            {
                for (int ch = 0; ch < 3; ch++)
                {
                    //quantized[ch] = std::min<int16_t>(15, std::max(0, (lineTotal[ch] * 2 + numDAIILine * 17 + modifierOffset * offsetPremultiplier)) / (numDAIILine * 34));
                    MUInt15 numerator = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(ParallelMath::MakeSInt16(0), ParallelMath::LosslessCast<MSInt16>::Cast(lineTotal[ch] + lineTotal[ch] + lineAddend) + modifierAddend));
                    MUInt15 divided = ParallelMath::MakeUInt15(0);
                    for (int block = 0; block < ParallelMath::ParallelSize; block++)
                    {
                        int divisor = lineDivisors[block];
                        if (divisor == 0)
                            ParallelMath::PutUInt15(divided, block, 0);
                        else
                            ParallelMath::PutUInt15(divided, block, ParallelMath::Extract(numerator, block) / divisor);
                    }
                    quantized[ch] = ParallelMath::Min(ParallelMath::MakeUInt15(15), divided);
                }
            }

            MUInt15 packedColor = quantized[0] | (quantized[1] << 5) | (quantized[2] << 10);

            for (int block = 0; block < ParallelMath::ParallelSize; block++)
            {
                uint16_t blockPackedColor = ParallelMath::Extract(packedColor, block);
                if (numUniqueColors[block] == 0 || blockPackedColor != ParallelMath::Extract(uniqueQuantizedColors[numUniqueColors[block] - 1], block))
                    ParallelMath::PutUInt15(uniqueQuantizedColors[numUniqueColors[block]++], block, blockPackedColor);
            }
        }

        // Stripe unfilled unique colors
        int maxUniqueColors = 0;
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
        {
            if (numUniqueColors[block] > maxUniqueColors)
                maxUniqueColors = numUniqueColors[block];
        }

        for (int block = 0; block < ParallelMath::ParallelSize; block++)
        {
            uint16_t fillColor = ParallelMath::Extract(uniqueQuantizedColors[0], block);

            int numUnique = numUniqueColors[block];
            for (int fill = numUnique + 1; fill < maxUniqueColors; fill++)
                ParallelMath::PutUInt15(uniqueQuantizedColors[fill], block, fillColor);
        }

        for (int ci = 0; ci < maxUniqueColors; ci++)
        {
            MUInt15 lineColors[3][3];
            for (int ch = 0; ch < 3; ch++)
            {
                MUInt15 quantizedChannel = (ParallelMath::RightShift(uniqueQuantizedColors[ci], (ch * 5)) & ParallelMath::MakeUInt15(15));

                MUInt15 unquantizedColor = (quantizedChannel << 4) | quantizedChannel;
                lineColors[0][ch] = ParallelMath::Min(ParallelMath::MakeUInt15(255), unquantizedColor + modifier);
                lineColors[1][ch] = unquantizedColor;
                lineColors[2][ch] = ParallelMath::ToUInt15(ParallelMath::Max(ParallelMath::MakeSInt16(0), ParallelMath::LosslessCast<MSInt16>::Cast(unquantizedColor) - ParallelMath::LosslessCast<MSInt16>::Cast(modifier)));
            }

            MSInt32 selectors = ParallelMath::MakeSInt32(0);
            MFloat error = ParallelMath::MakeFloatZero();
            for (int px = 0; px < 16; px++)
            {
                MFloat pixelError = isolatedError[px];

                MUInt15 pixelBestSelector = ParallelMath::MakeUInt15(0);
                for (int i = 0; i < 3; i++)
                {
                    MFloat error = isUniform ? ComputeErrorUniform(lineColors[i], pixels[px]) : ComputeErrorWeighted(lineColors[i], preWeightedPixels[px], options);
                    ParallelMath::FloatCompFlag errorBetter = ParallelMath::Less(error, pixelError);
                    pixelError = ParallelMath::Min(error, pixelError);
                    pixelBestSelector = ParallelMath::Select(ParallelMath::FloatFlagToInt16(errorBetter), ParallelMath::MakeUInt15(i + 1), pixelBestSelector);
                }

                error = error + pixelError;
                selectors = selectors | (ParallelMath::ToInt32(pixelBestSelector) << (px * 2));
            }

            ParallelMath::Int16CompFlag errorBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(error, bestError));
            bestError = ParallelMath::Min(error, bestError);

            if (ParallelMath::AnySet(errorBetter))
            {
                ParallelMath::ConditionalSet(bestLineColor, errorBetter, uniqueQuantizedColors[ci]);
                ParallelMath::ConditionalSet(bestSelectors, errorBetter, selectors);
                ParallelMath::ConditionalSet(bestTable, errorBetter, ParallelMath::MakeUInt15(table));
                bestIsThisMode = bestIsThisMode | errorBetter;
            }
        }
    }

    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        if (ParallelMath::Extract(bestIsThisMode, block))
        {
            uint32_t lowBits = 0;
            uint32_t highBits = 0;

            uint16_t blockBestLineColor = ParallelMath::Extract(bestLineColor, block);
            ParallelMath::ScalarUInt16 blockIsolatedAverageQuantized[3];

            for (int ch = 0; ch < 3; ch++)
                blockIsolatedAverageQuantized[ch] = ParallelMath::Extract(isolatedAverageQuantized[ch], block);

            uint16_t blockBestTable = ParallelMath::Extract(bestTable, block);
            int32_t blockBestSelectors = ParallelMath::Extract(bestSelectors, block);

            ParallelMath::ScalarUInt16 lineColor[3];
            for (int ch = 0; ch < 3; ch++)
                lineColor[ch] = (blockBestLineColor >> (ch * 5)) & 15;

            EmitTModeBlock(outputBuffer + block * 8, lineColor, blockIsolatedAverageQuantized, blockBestSelectors, blockBestTable, true);
        }
    }
}

void cvtt::Internal::ETCComputer::EncodeHMode(uint8_t *outputBuffer, MFloat &bestError, const ParallelMath::Int16CompFlag groupings[16], const MUInt15 pixels[16][3], HModeEval &he, const MFloat preWeightedPixels[16][3], const Options &options)
{
    bool isUniform = ((options.flags & cvtt::Flags::Uniform) != 0);
    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);

    MUInt15 zero15 = ParallelMath::MakeUInt15(0);

    MUInt15 counts[2] = { zero15, zero15 };

    ParallelMath::Int16CompFlag bestIsThisMode = ParallelMath::MakeBoolInt16(false);

    MUInt15 totals[2][3] =
    {
        { zero15, zero15, zero15 },
        { zero15, zero15, zero15 }
    };

    for (unsigned int px = 0; px < 16; px++)
    {
        for (int ch = 0; ch < 3; ch++)
        {
            totals[0][ch] = totals[0][ch] + pixels[px][ch];
            totals[1][ch] = totals[1][ch] + ParallelMath::SelectOrZero(groupings[px], pixels[px][ch]);
        }
        counts[1] = counts[1] + ParallelMath::SelectOrZero(groupings[px], ParallelMath::MakeUInt15(1));
    }

    for (int ch = 0; ch < 3; ch++)
        totals[0][ch] = totals[0][ch] - totals[1][ch];
    counts[0] = ParallelMath::MakeUInt15(16) - counts[1];

    MUInt16 bestSectorBits = ParallelMath::MakeUInt16(0);
    MUInt16 bestSignBits = ParallelMath::MakeUInt16(0);
    MUInt15 bestColors[2] = { zero15, zero15 };
    MUInt15 bestTable = ParallelMath::MakeUInt15(0);

    for (int table = 0; table < 8; table++)
    {
        MUInt15 numUniqueColors = zero15;

        int modifier = cvtt::Tables::ETC1::g_thModifierTable[table];

        for (int sector = 0; sector < 2; sector++)
        {
            for (int block = 0; block < ParallelMath::ParallelSize; block++)
            {
                int blockNumUniqueColors = 0;
                uint16_t blockUniqueQuantizedColors[31];

                int maxOffsetMultiplier = ParallelMath::Extract(counts[sector], block);
                int minOffsetMultiplier = -maxOffsetMultiplier;

                int modifierOffset = modifier * 2;

                int blockSectorCounts = ParallelMath::Extract(counts[sector], block);
                int blockSectorTotals[3];
                for (int ch = 0; ch < 3; ch++)
                    blockSectorTotals[ch] = ParallelMath::Extract(totals[sector][ch], block);

                for (int offsetPremultiplier = minOffsetMultiplier; offsetPremultiplier <= maxOffsetMultiplier; offsetPremultiplier++)
                {
                    // TODO: This isn't ideal for FakeBT709
                    int16_t quantized[3];
                    for (int ch = 0; ch < 3; ch++)
                    {
                        if (blockSectorCounts == 0)
                            quantized[ch] = 0;
                        else
                            quantized[ch] = std::min<int16_t>(15, std::max<int16_t>(0, (blockSectorTotals[ch] * 2 + blockSectorCounts * 17 + modifierOffset * offsetPremultiplier)) / (blockSectorCounts * 34));
                    }

                    uint16_t packedColor = (quantized[0] << 10) | (quantized[1] << 5) | quantized[2];
                    if (blockNumUniqueColors == 0 || packedColor != blockUniqueQuantizedColors[blockNumUniqueColors - 1])
                    {
                        assert(blockNumUniqueColors < 32);
                        blockUniqueQuantizedColors[blockNumUniqueColors++] = packedColor;
                    }
                }

                ParallelMath::PutUInt15(he.numUniqueColors[sector], block, blockNumUniqueColors);

                int baseIndex = 0;
                if (sector == 1)
                    baseIndex = ParallelMath::Extract(he.numUniqueColors[0], block);

                for (int i = 0; i < blockNumUniqueColors; i++)
                    ParallelMath::PutUInt15(he.uniqueQuantizedColors[baseIndex + i], block, blockUniqueQuantizedColors[i]);
            }
        }

        MUInt15 totalColors = he.numUniqueColors[0] + he.numUniqueColors[1];
        int maxErrorColors = 0;
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
            maxErrorColors = std::max<int>(maxErrorColors, ParallelMath::Extract(totalColors, block));

        for (int block = 0; block < ParallelMath::ParallelSize; block++)
        {
            int lastColor = ParallelMath::Extract(totalColors, block);
            uint16_t stripeColor = ParallelMath::Extract(he.uniqueQuantizedColors[0], block);
            for (int i = lastColor; i < maxErrorColors; i++)
                ParallelMath::PutUInt15(he.uniqueQuantizedColors[i], block, stripeColor);
        }

        for (int ci = 0; ci < maxErrorColors; ci++)
        {
            MUInt15 fifteen = ParallelMath::MakeUInt15(15);
            MUInt15 twoFiftyFive = ParallelMath::MakeUInt15(255);
            MSInt16 zeroS16 = ParallelMath::MakeSInt16(0);

            MUInt15 colors[2][3];
            for (int ch = 0; ch < 3; ch++)
            {
                MUInt15 quantizedChannel = ParallelMath::RightShift(he.uniqueQuantizedColors[ci], ((2 - ch) * 5)) & fifteen;

                MUInt15 unquantizedColor = (quantizedChannel << 4) | quantizedChannel;
                colors[0][ch] = ParallelMath::Min(twoFiftyFive, unquantizedColor + modifier);
                colors[1][ch] = ParallelMath::ToUInt15(ParallelMath::Max(zeroS16, ParallelMath::LosslessCast<MSInt16>::Cast(unquantizedColor) - ParallelMath::MakeSInt16(modifier)));
            }

            MUInt16 signBits = ParallelMath::MakeUInt16(0);
            for (int px = 0; px < 16; px++)
            {
                MFloat errors[2];
                for (int i = 0; i < 2; i++)
                {
                    if (isFakeBT709)
                        errors[i] = ComputeErrorFakeBT709(colors[i], preWeightedPixels[px]);
                    else if (isUniform)
                        errors[i] = ComputeErrorUniform(colors[i], pixels[px]);
                    else
                        errors[i] = ComputeErrorWeighted(colors[i], preWeightedPixels[px], options);
                }

                ParallelMath::Int16CompFlag errorOneLess = ParallelMath::FloatFlagToInt16(ParallelMath::Less(errors[1], errors[0]));
                he.errors[ci][px] = ParallelMath::Min(errors[0], errors[1]);
                signBits = signBits | ParallelMath::SelectOrZero(errorOneLess, ParallelMath::MakeUInt16(1 << px));
            }
            he.signBits[ci] = signBits;
        }

        int maxUniqueColorCombos = 0;
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
        {
            int numUniqueColorCombos = ParallelMath::Extract(he.numUniqueColors[0], block) * ParallelMath::Extract(he.numUniqueColors[1], block);
            if (numUniqueColorCombos > maxUniqueColorCombos)
                maxUniqueColorCombos = numUniqueColorCombos;
        }

        MUInt15 indexes[2] = { zero15, zero15 };
        MUInt15 maxIndex[2] = { he.numUniqueColors[0] - ParallelMath::MakeUInt15(1), he.numUniqueColors[1] - ParallelMath::MakeUInt15(1) };

        int block1Starts[ParallelMath::ParallelSize];
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
            block1Starts[block] = ParallelMath::Extract(he.numUniqueColors[0], block);

        for (int combo = 0; combo < maxUniqueColorCombos; combo++)
        {
            MUInt15 index0 = indexes[0] + ParallelMath::MakeUInt15(1);
            ParallelMath::Int16CompFlag index0Overflow = ParallelMath::Less(maxIndex[0], index0);
            ParallelMath::ConditionalSet(index0, index0Overflow, ParallelMath::MakeUInt15(0));

            MUInt15 index1 = ParallelMath::Min(maxIndex[1], indexes[1] + ParallelMath::SelectOrZero(index0Overflow, ParallelMath::MakeUInt15(1)));
            indexes[0] = index0;
            indexes[1] = index1;

            int ci0[ParallelMath::ParallelSize];
            int ci1[ParallelMath::ParallelSize];
            MUInt15 color0;
            MUInt15 color1;

            for (int block = 0; block < ParallelMath::ParallelSize; block++)
            {
                ci0[block] = ParallelMath::Extract(index0, block);
                ci1[block] = ParallelMath::Extract(index1, block) + block1Starts[block];
                ParallelMath::PutUInt15(color0, block, ParallelMath::Extract(he.uniqueQuantizedColors[ci0[block]], block));
                ParallelMath::PutUInt15(color1, block, ParallelMath::Extract(he.uniqueQuantizedColors[ci1[block]], block));
            }

            MFloat totalError = ParallelMath::MakeFloatZero();
            MUInt16 sectorBits = ParallelMath::MakeUInt16(0);
            MUInt16 signBits = ParallelMath::MakeUInt16(0);
            for (int px = 0; px < 16; px++)
            {
                MFloat errorCI0;
                MFloat errorCI1;
                MUInt16 signBits0;
                MUInt16 signBits1;

                for (int block = 0; block < ParallelMath::ParallelSize; block++)
                {
                    ParallelMath::PutFloat(errorCI0, block, ParallelMath::Extract(he.errors[ci0[block]][px], block));
                    ParallelMath::PutFloat(errorCI1, block, ParallelMath::Extract(he.errors[ci1[block]][px], block));
                    ParallelMath::PutUInt16(signBits0, block, ParallelMath::Extract(he.signBits[ci0[block]], block));
                    ParallelMath::PutUInt16(signBits1, block, ParallelMath::Extract(he.signBits[ci1[block]], block));
                }

                totalError = totalError + ParallelMath::Min(errorCI0, errorCI1);

                MUInt16 bitPosition = ParallelMath::MakeUInt16(1 << px);

                ParallelMath::Int16CompFlag error1Better = ParallelMath::FloatFlagToInt16(ParallelMath::Less(errorCI1, errorCI0));

                sectorBits = sectorBits | ParallelMath::SelectOrZero(error1Better, bitPosition);
                signBits = signBits | (bitPosition & ParallelMath::Select(error1Better, signBits1, signBits0));
            }

            ParallelMath::FloatCompFlag totalErrorBetter = ParallelMath::Less(totalError, bestError);
            ParallelMath::Int16CompFlag totalErrorBetter16 = ParallelMath::FloatFlagToInt16(totalErrorBetter);
            if (ParallelMath::AnySet(totalErrorBetter16))
            {
                bestIsThisMode = bestIsThisMode | totalErrorBetter16;
                ParallelMath::ConditionalSet(bestTable, totalErrorBetter16, ParallelMath::MakeUInt15(table));
                ParallelMath::ConditionalSet(bestColors[0], totalErrorBetter16, color0);
                ParallelMath::ConditionalSet(bestColors[1], totalErrorBetter16, color1);
                ParallelMath::ConditionalSet(bestSectorBits, totalErrorBetter16, sectorBits);
                ParallelMath::ConditionalSet(bestSignBits, totalErrorBetter16, signBits);
                bestError = ParallelMath::Min(totalError, bestError);
            }
        }
    }

    if (ParallelMath::AnySet(bestIsThisMode))
    {
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
        {
            if (!ParallelMath::Extract(bestIsThisMode, block))
                continue;

            ParallelMath::ScalarUInt16 blockBestColors[2] = { ParallelMath::Extract(bestColors[0], block), ParallelMath::Extract(bestColors[1], block) };
            ParallelMath::ScalarUInt16 blockBestSectorBits = ParallelMath::Extract(bestSectorBits, block);
            ParallelMath::ScalarUInt16 blockBestSignBits = ParallelMath::Extract(bestSignBits, block);
            ParallelMath::ScalarUInt16 blockBestTable = ParallelMath::Extract(bestTable, block);

            EmitHModeBlock(outputBuffer + block * 8, blockBestColors, blockBestSectorBits, blockBestSignBits, blockBestTable, true);
        }
    }
}

void cvtt::Internal::ETCComputer::EncodeVirtualTModePunchthrough(uint8_t *outputBuffer, MFloat &bestError, const ParallelMath::Int16CompFlag isIsolatedBase[16], const MUInt15 pixels[16][3], const MFloat preWeightedPixels[16][3], const ParallelMath::Int16CompFlag isTransparent[16], const ParallelMath::Int16CompFlag& anyTransparent, const ParallelMath::Int16CompFlag& allTransparent, const Options &options)
{
    // We treat T and H mode as the same mode ("Virtual T mode") with punchthrough, because of how the colors work:
    //
    // T mode: C1, C2+M, Transparent, C2-M
    // H mode: C1+M, C1-M, Transparent, C2-M
    //
    // So in either case, we have 2 colors +/- a modifier, and a third unique color, which is basically T mode except without the middle color.
    // The only thing that matters is whether it's better to store the isolated color as T mode color 1, or store it offset in H mode color 2.
    //
    // Sometimes it won't even be possible to store it in H mode color 2 because the table low bit derives from a numeric comparison of the colors,
    // but unlike opaque blocks, we can't flip them.
    bool isUniform = ((options.flags & cvtt::Flags::Uniform) != 0);
    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);

    ParallelMath::FloatCompFlag isTransparentF[16];
    for (int px = 0; px < 16; px++)
        isTransparentF[px] = ParallelMath::Int16FlagToFloat(isTransparent[px]);

    ParallelMath::Int16CompFlag bestIsThisMode = ParallelMath::MakeBoolInt16(false);
    ParallelMath::Int16CompFlag bestIsHMode = ParallelMath::MakeBoolInt16(false);

    MUInt15 isolatedTotal[3] = { ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0) };
    MUInt15 lineTotal[3] = { ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0) };

    MUInt15 numPixelsIsolated = ParallelMath::MakeUInt15(0);
    MUInt15 numPixelsLine = ParallelMath::MakeUInt15(0);

    ParallelMath::Int16CompFlag isIsolated[16];
    ParallelMath::Int16CompFlag isLine[16];

    for (unsigned int px = 0; px < 16; px++)
    {
        ParallelMath::Int16CompFlag isOpaque = ParallelMath::Not(isTransparent[px]);
        isIsolated[px] = isIsolatedBase[px] & isOpaque;
        isLine[px] = ParallelMath::Not(isIsolatedBase[px]) & isOpaque;
    }

    for (unsigned int px = 0; px < 16; px++)
    {
        for (int ch = 0; ch < 3; ch++)
        {
            isolatedTotal[ch] = isolatedTotal[ch] + ParallelMath::SelectOrZero(isIsolated[px], pixels[px][ch]);
            lineTotal[ch] = lineTotal[ch] + ParallelMath::SelectOrZero(isLine[px], pixels[px][ch]);
        }
        numPixelsIsolated = numPixelsIsolated + ParallelMath::SelectOrZero(isIsolated[px], ParallelMath::MakeUInt15(1));
        numPixelsLine = numPixelsLine + ParallelMath::SelectOrZero(isLine[px], ParallelMath::MakeUInt15(1));
    }

    MUInt15 isolatedAverageQuantized[3];
    MUInt15 hModeIsolatedQuantized[8][3];
    MUInt15 isolatedAverageTargets[3];
    {
        int divisors[ParallelMath::ParallelSize];
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
            divisors[block] = ParallelMath::Extract(numPixelsIsolated, block) * 34;

        MUInt15 addend = (numPixelsIsolated << 4) | numPixelsIsolated;
        for (int ch = 0; ch < 3; ch++)
        {
            // isolatedAverageQuantized[ch] = (isolatedTotal[ch] * 2 + numPixelsIsolated * 17) / (numPixelsIsolated * 34);

            MUInt15 numerator = isolatedTotal[ch] + isolatedTotal[ch];
            if (!isFakeBT709)
                numerator = numerator + addend;

            MUInt15 hModeIsolatedNumerators[8];
            for (int table = 0; table < 8; table++)
            {
                // FIXME: Handle fake BT.709 correctly
                MUInt15 offsetTotal = isolatedTotal[ch] + ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::CompactMultiply(ParallelMath::MakeUInt15(cvtt::Tables::ETC2::g_thModifierTable[table]), numPixelsIsolated));

                hModeIsolatedNumerators[table] = (offsetTotal + offsetTotal) + addend;
            }

            for (int block = 0; block < ParallelMath::ParallelSize; block++)
            {
                int divisor = divisors[block];
                if (divisor == 0)
                {
                    ParallelMath::PutUInt15(isolatedAverageQuantized[ch], block, 0);
                    for (int table = 0; table < 8; table++)
                        ParallelMath::PutUInt15(hModeIsolatedQuantized[table][ch], block, 0);
                }
                else
                {
                    ParallelMath::PutUInt15(isolatedAverageQuantized[ch], block, ParallelMath::Extract(numerator, block) / divisor);
                    for (int table = 0; table < 8; table++)
                        ParallelMath::PutUInt15(hModeIsolatedQuantized[table][ch], block, ParallelMath::Extract(hModeIsolatedNumerators[table], block) / divisor);
                }
            }

            isolatedAverageTargets[ch] = numerator;
        }
    }

    if (isFakeBT709)
        ResolveTHFakeBT709Rounding(isolatedAverageQuantized, isolatedAverageTargets, numPixelsIsolated);

    for (int table = 0; table < 8; table++)
        for (int ch = 0; ch < 3; ch++)
            hModeIsolatedQuantized[table][ch] = ParallelMath::Min(ParallelMath::MakeUInt15(15), hModeIsolatedQuantized[table][ch]);

    MUInt15 isolatedColor[3];
    for (int ch = 0; ch < 3; ch++)
        isolatedColor[ch] = (isolatedAverageQuantized[ch]) | (isolatedAverageQuantized[ch] << 4);

    MFloat isolatedError[16];
    for (int px = 0; px < 16; px++)
    {
        if (isFakeBT709)
            isolatedError[px] = ComputeErrorFakeBT709(isolatedColor, preWeightedPixels[px]);
        else if (isUniform)
            isolatedError[px] = ComputeErrorUniform(pixels[px], isolatedColor);
        else
            isolatedError[px] = ComputeErrorWeighted(isolatedColor, preWeightedPixels[px], options);

        ParallelMath::ConditionalSet(isolatedError[px], isTransparentF[px], ParallelMath::MakeFloatZero());
    }

    MSInt32 bestSelectors = ParallelMath::MakeSInt32(0);
    MUInt15 bestTable = ParallelMath::MakeUInt15(0);
    MUInt15 bestLineColor = ParallelMath::MakeUInt15(0);
    MUInt15 bestIsolatedColor = ParallelMath::MakeUInt15(0);
    MUInt15 bestHModeColor2 = ParallelMath::MakeUInt15(0);
    ParallelMath::Int16CompFlag bestUseHMode = ParallelMath::MakeBoolInt16(false);

    MSInt16 maxLine = ParallelMath::LosslessCast<MSInt16>::Cast(numPixelsLine);
    MSInt16 minLine = ParallelMath::MakeSInt16(0) - maxLine;

    int16_t clusterMaxLine = 0;
    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        int16_t blockMaxLine = ParallelMath::Extract(maxLine, block);
        if (blockMaxLine > clusterMaxLine)
            clusterMaxLine = blockMaxLine;
    }

    int16_t clusterMinLine = -clusterMaxLine;

    int lineDivisors[ParallelMath::ParallelSize];
    for (int block = 0; block < ParallelMath::ParallelSize; block++)
        lineDivisors[block] = ParallelMath::Extract(numPixelsLine, block) * 34;

    MUInt15 lineAddend = (numPixelsLine << 4) | numPixelsLine;

    for (int table = 0; table < 8; table++)
    {
        int numUniqueColors[ParallelMath::ParallelSize];
        MUInt15 uniqueQuantizedColors[31];

        for (int block = 0; block < ParallelMath::ParallelSize; block++)
            numUniqueColors[block] = 0;

        MUInt15 modifier = ParallelMath::MakeUInt15(cvtt::Tables::ETC2::g_thModifierTable[table]);
        MUInt15 modifierOffset = (modifier + modifier);

        for (int16_t offsetPremultiplier = clusterMinLine; offsetPremultiplier <= clusterMaxLine; offsetPremultiplier += 2)
        {
            MSInt16 clampedOffsetPremultiplier = ParallelMath::Max(minLine, ParallelMath::Min(maxLine, ParallelMath::MakeSInt16(offsetPremultiplier)));
            MSInt16 modifierAddend = ParallelMath::CompactMultiply(clampedOffsetPremultiplier, modifierOffset);

            MUInt15 quantized[3];
            if (isFakeBT709)
            {
                MUInt15 targets[3];
                for (int ch = 0; ch < 3; ch++)
                {
                    //quantized[ch] = std::min<int16_t>(15, std::max(0, (lineTotal[ch] * 2 + modifierOffset * offsetPremultiplier)) / (numDAIILine * 34));
                    MUInt15 numerator = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(ParallelMath::MakeSInt16(0), ParallelMath::LosslessCast<MSInt16>::Cast(lineTotal[ch] + lineTotal[ch]) + modifierAddend));
                    MUInt15 divided = ParallelMath::MakeUInt15(0);
                    for (int block = 0; block < ParallelMath::ParallelSize; block++)
                    {
                        int divisor = lineDivisors[block];
                        if (divisor == 0)
                            ParallelMath::PutUInt15(divided, block, 0);
                        else
                            ParallelMath::PutUInt15(divided, block, ParallelMath::Extract(numerator, block) / divisor);
                    }
                    quantized[ch] = ParallelMath::Min(ParallelMath::MakeUInt15(15), divided);
                    targets[ch] = numerator;
                }

                ResolveTHFakeBT709Rounding(quantized, targets, numPixelsLine);
            }
            else
            {
                for (int ch = 0; ch < 3; ch++)
                {
                    //quantized[ch] = std::min<int16_t>(15, std::max(0, (lineTotal[ch] * 2 + numDAIILine * 17 + modifierOffset * offsetPremultiplier)) / (numDAIILine * 34));
                    MUInt15 numerator = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(ParallelMath::MakeSInt16(0), ParallelMath::LosslessCast<MSInt16>::Cast(lineTotal[ch] + lineTotal[ch] + lineAddend) + modifierAddend));
                    MUInt15 divided = ParallelMath::MakeUInt15(0);
                    for (int block = 0; block < ParallelMath::ParallelSize; block++)
                    {
                        int divisor = lineDivisors[block];
                        if (divisor == 0)
                            ParallelMath::PutUInt15(divided, block, 0);
                        else
                            ParallelMath::PutUInt15(divided, block, ParallelMath::Extract(numerator, block) / divisor);
                    }
                    quantized[ch] = ParallelMath::Min(ParallelMath::MakeUInt15(15), divided);
                }
            }

            MUInt15 packedColor = (quantized[0] << 10) | (quantized[1] << 5) | quantized[2];

            for (int block = 0; block < ParallelMath::ParallelSize; block++)
            {
                uint16_t blockPackedColor = ParallelMath::Extract(packedColor, block);
                if (numUniqueColors[block] == 0 || blockPackedColor != ParallelMath::Extract(uniqueQuantizedColors[numUniqueColors[block] - 1], block))
                    ParallelMath::PutUInt15(uniqueQuantizedColors[numUniqueColors[block]++], block, blockPackedColor);
            }
        }

        // Stripe unfilled unique colors
        int maxUniqueColors = 0;
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
        {
            if (numUniqueColors[block] > maxUniqueColors)
                maxUniqueColors = numUniqueColors[block];
        }

        for (int block = 0; block < ParallelMath::ParallelSize; block++)
        {
            uint16_t fillColor = ParallelMath::Extract(uniqueQuantizedColors[0], block);

            int numUnique = numUniqueColors[block];
            for (int fill = numUnique + 1; fill < maxUniqueColors; fill++)
                ParallelMath::PutUInt15(uniqueQuantizedColors[fill], block, fillColor);
        }

        MFloat hModeErrors[16];
        MUInt15 hModeUnquantizedColor[3];
        for (int ch = 0; ch < 3; ch++)
        {
            MUInt15 quantizedChannel = hModeIsolatedQuantized[table][ch];

            MUInt15 unquantizedCh = (quantizedChannel << 4) | quantizedChannel;
            hModeUnquantizedColor[ch] = ParallelMath::ToUInt15(ParallelMath::Max(ParallelMath::MakeSInt16(0), ParallelMath::LosslessCast<MSInt16>::Cast(unquantizedCh) - ParallelMath::LosslessCast<MSInt16>::Cast(modifier)));
        }

        for (int px = 0; px < 16; px++)
        {
            hModeErrors[px] = isUniform ? ComputeErrorUniform(hModeUnquantizedColor, pixels[px]) : ComputeErrorWeighted(hModeUnquantizedColor, preWeightedPixels[px], options);
            ParallelMath::ConditionalSet(hModeErrors[px], isTransparentF[px], ParallelMath::MakeFloatZero());
        }

        MUInt15 packedHModeColor2 = (hModeIsolatedQuantized[table][0] << 10) | (hModeIsolatedQuantized[table][1] << 5) | hModeIsolatedQuantized[table][2];
        ParallelMath::Int16CompFlag tableLowBitIsZero = ((table & 1) == 0) ? ParallelMath::MakeBoolInt16(true) : ParallelMath::MakeBoolInt16(false);

        for (int ci = 0; ci < maxUniqueColors; ci++)
        {
            MUInt15 lineColors[2][3];
            for (int ch = 0; ch < 3; ch++)
            {
                MUInt15 quantizedChannel = (ParallelMath::RightShift(uniqueQuantizedColors[ci], 10 - (ch * 5)) & ParallelMath::MakeUInt15(15));

                MUInt15 unquantizedColor = (quantizedChannel << 4) | quantizedChannel;
                lineColors[0][ch] = ParallelMath::Min(ParallelMath::MakeUInt15(255), unquantizedColor + modifier);
                lineColors[1][ch] = ParallelMath::ToUInt15(ParallelMath::Max(ParallelMath::MakeSInt16(0), ParallelMath::LosslessCast<MSInt16>::Cast(unquantizedColor) - ParallelMath::LosslessCast<MSInt16>::Cast(modifier)));
            }

            MUInt15 bestLineSelector[16];
            MFloat bestLineError[16];
            for (int px = 0; px < 16; px++)
            {
                MFloat lineErrors[2];
                for (int i = 0; i < 2; i++)
                    lineErrors[i] = isUniform ? ComputeErrorUniform(lineColors[i], pixels[px]) : ComputeErrorWeighted(lineColors[i], preWeightedPixels[px], options);

                ParallelMath::Int16CompFlag firstIsBetter = ParallelMath::FloatFlagToInt16(ParallelMath::LessOrEqual(lineErrors[0], lineErrors[1]));
                bestLineSelector[px] = ParallelMath::Select(firstIsBetter, ParallelMath::MakeUInt15(1), ParallelMath::MakeUInt15(3));
                bestLineError[px] = ParallelMath::Min(lineErrors[0], lineErrors[1]);

                ParallelMath::ConditionalSet(bestLineError[px], isTransparentF[px], ParallelMath::MakeFloatZero());
            }

            // One case considered here was if it was possible to force H mode to be valid when the line color is unused.
            // That case isn't actually useful because it's equivalent to the isolated color being unused at maximum offset,
            // which is always checked after a swap.
            MFloat tModeError = ParallelMath::MakeFloatZero();
            MFloat hModeError = ParallelMath::MakeFloatZero();
            for (int px = 0; px < 16; px++)
            {
                tModeError = tModeError + ParallelMath::Min(bestLineError[px], isolatedError[px]);
                hModeError = hModeError + ParallelMath::Min(bestLineError[px], hModeErrors[px]);
            }

            ParallelMath::FloatCompFlag hLessError = ParallelMath::Less(hModeError, tModeError);

            MUInt15 packedHModeColor1 = uniqueQuantizedColors[ci];

            ParallelMath::Int16CompFlag hModeTableLowBitMustBeZero = ParallelMath::Less(packedHModeColor1, packedHModeColor2);

            ParallelMath::Int16CompFlag hModeIsLegal = ParallelMath::Equal(hModeTableLowBitMustBeZero, tableLowBitIsZero);
            ParallelMath::Int16CompFlag useHMode = ParallelMath::FloatFlagToInt16(hLessError) & hModeIsLegal;

            MFloat roundBestError = tModeError;
            ParallelMath::ConditionalSet(roundBestError, ParallelMath::Int16FlagToFloat(useHMode), hModeError);

            ParallelMath::Int16CompFlag errorBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(roundBestError, bestError));
            ParallelMath::FloatCompFlag useHModeF = ParallelMath::Int16FlagToFloat(useHMode);

            if (ParallelMath::AnySet(errorBetter))
            {
                MSInt32 selectors = ParallelMath::MakeSInt32(0);
                for (int px = 0; px < 16; px++)
                {
                    MUInt15 selector = bestLineSelector[px];

                    MFloat isolatedPixelError = ParallelMath::Select(useHModeF, hModeErrors[px], isolatedError[px]);
                    ParallelMath::Int16CompFlag isolatedBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(isolatedPixelError, bestLineError[px]));

                    ParallelMath::ConditionalSet(selector, isolatedBetter, ParallelMath::MakeUInt15(0));
                    ParallelMath::ConditionalSet(selector, isTransparent[px], ParallelMath::MakeUInt15(2));
                    selectors = selectors | (ParallelMath::ToInt32(selector) << (px * 2));
                }

                bestError = ParallelMath::Min(bestError, roundBestError);
                ParallelMath::ConditionalSet(bestLineColor, errorBetter, uniqueQuantizedColors[ci]);
                ParallelMath::ConditionalSet(bestSelectors, errorBetter, selectors);
                ParallelMath::ConditionalSet(bestTable, errorBetter, ParallelMath::MakeUInt15(table));
                ParallelMath::ConditionalSet(bestIsHMode, errorBetter, useHMode);
                ParallelMath::ConditionalSet(bestHModeColor2, errorBetter, packedHModeColor2);
                
                bestIsThisMode = bestIsThisMode | errorBetter;
            }
        }
    }

    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        if (ParallelMath::Extract(bestIsThisMode, block))
        {
            uint32_t lowBits = 0;
            uint32_t highBits = 0;

            uint16_t blockBestLineColor = ParallelMath::Extract(bestLineColor, block);
            ParallelMath::ScalarUInt16 blockIsolatedAverageQuantized[3];

            for (int ch = 0; ch < 3; ch++)
                blockIsolatedAverageQuantized[ch] = ParallelMath::Extract(isolatedAverageQuantized[ch], block);

            uint16_t blockBestTable = ParallelMath::Extract(bestTable, block);
            int32_t blockBestSelectors = ParallelMath::Extract(bestSelectors, block);

            ParallelMath::ScalarUInt16 lineColor[3];
            for (int ch = 0; ch < 3; ch++)
                lineColor[ch] = (blockBestLineColor >> (10 - (ch * 5))) & 15;

            if (ParallelMath::Extract(bestIsHMode, block))
            {
                // T mode: C1, C2+M, Transparent, C2-M
                // H mode: C1+M, C1-M, Transparent, C2-M
                static const ParallelMath::ScalarUInt16 selectorRemapSector[4] = { 1, 0, 1, 0 };
                static const ParallelMath::ScalarUInt16 selectorRemapSign[4] = { 1, 0, 0, 1 };

                // Remap selectors
                ParallelMath::ScalarUInt16 signBits = 0;
                ParallelMath::ScalarUInt16 sectorBits = 0;
                int32_t blockBestSelectors = ParallelMath::Extract(bestSelectors, block);
                for (int px = 0; px < 16; px++)
                {
                    int32_t selector = (blockBestSelectors >> (px * 2)) & 3;
                    sectorBits |= (selectorRemapSector[selector] << px);
                    signBits |= (selectorRemapSign[selector] << px);
                }

                ParallelMath::ScalarUInt16 blockColors[2] = { blockBestLineColor, ParallelMath::Extract(bestHModeColor2, block) };

                EmitHModeBlock(outputBuffer + block * 8, blockColors, sectorBits, signBits, blockBestTable, false);
            }
            else
                EmitTModeBlock(outputBuffer + block * 8, lineColor, blockIsolatedAverageQuantized, blockBestSelectors, blockBestTable, false);
        }
    }
}


cvtt::ParallelMath::UInt15 cvtt::Internal::ETCComputer::DecodePlanarCoeff(const MUInt15 &coeff, int ch)
{
    if (ch == 1)
        return (coeff << 1) | (ParallelMath::RightShift(coeff, 6));
    else
        return (coeff << 2) | (ParallelMath::RightShift(coeff, 4));
}

void cvtt::Internal::ETCComputer::EncodePlanar(uint8_t *outputBuffer, MFloat &bestError, const MUInt15 pixels[16][3], const MFloat preWeightedPixels[16][3], const Options &options)
{
    // NOTE: If it's desired to do this in another color space, the best way to do it would probably be
    // to do everything in that color space and then transform it back to RGB.

    // We compute H = (H-O)/4 and V= (V-O)/4 to simplify the math

    // error = (x*H + y*V + O - C)^2
    MFloat h[3] = { ParallelMath::MakeFloatZero(), ParallelMath::MakeFloatZero(), ParallelMath::MakeFloatZero() };
    MFloat v[3] = { ParallelMath::MakeFloatZero(), ParallelMath::MakeFloatZero(), ParallelMath::MakeFloatZero() };
    MFloat o[3] = { ParallelMath::MakeFloatZero(), ParallelMath::MakeFloatZero(), ParallelMath::MakeFloatZero() };

    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);
    bool isUniform = ((options.flags & cvtt::Flags::Uniform) != 0);

    MFloat totalError = ParallelMath::MakeFloatZero();
    MUInt15 bestCoeffs[3][3];	// [Channel][Coeff]
    for (int ch = 0; ch < 3; ch++)
    {
        float fhh = 0.f;
        float fho = 0.f;
        float fhv = 0.f;
        float foo = 0.f;
        float fov = 0.f;
        float fvv = 0.f;
        MFloat fc = ParallelMath::MakeFloatZero();
        MFloat fh = ParallelMath::MakeFloatZero();
        MFloat fv = ParallelMath::MakeFloatZero();
        MFloat fo = ParallelMath::MakeFloatZero();

        float &foh = fho;
        float &fvh = fhv;
        float &fvo = fov;

        for (int px = 0; px < 16; px++)
        {
            float x = static_cast<float>(px % 4);
            float y = static_cast<float>(px / 4);
            MFloat c = isFakeBT709 ? preWeightedPixels[px][ch] : ParallelMath::ToFloat(pixels[px][ch]);

            // (x*H + y*V + O - C)^2
            fhh += x * x;
            fhv += x * y;
            fho += x;
            fh = fh - c * x;

            fvh += y * x;
            fvv += y * y;
            fvo += y;
            fv = fv - c * y;

            foh += x;
            fov += y;
            foo += 1;
            fo = fo - c;

            fh = fh - c * x;
            fv = fv - c * y;
            fo = fo - c;
            fc = fc + c * c;
        }

        //float totalError = fhh * h * h + fho * h*o + fhv * h*v + foo * o * o + fov * o*v + fvv * v * v + fh * h + fv * v + fo * o + fc;

        // error = fhh*h^2 + fho*h*o + fhv*h*v + foo*o^2 + fov*o*v + fvv*v^2 + fh*h + fv*v + fo*o + fc
        // derror/dh = 2*fhh*h + fho*o + fhv*v + fh
        // derror/dv = fhv*h + fov*o + 2*fvv*v + fv
        // derror/do = fho*h + 2*foo*o + fov*v + fo

        // Solve system of equations
        // h o v 1 = 0
        // -------
        // d e f g  R0
        // i j k l  R1
        // m n p q  R2

        float d = 2.0f * fhh;
        float e = fho;
        float f = fhv;
        MFloat gD = fh;

        float i = fhv;
        float j = fov;
        float k = 2.0f * fvv;
        MFloat lD = fv;

        float m = fho;
        float n = 2.0f * foo;
        float p = fov;
        MFloat qD = fo;

        {
            // Factor out first column from R1 and R2
            float r0to1 = -i / d;
            float r0to2 = -m / d;

            // 0 j1 k1 l1D
            float j1 = j + r0to1 * e;
            float k1 = k + r0to1 * f;
            MFloat l1D = lD + gD * r0to1;

            // 0 n1 p1 q1D
            float n1 = n + r0to2 * e;
            float p1 = p + r0to2 * f;
            MFloat q1D = qD + gD * r0to2;

            // Factor out third column from R2
            float r1to2 = -p1 / k1;

            // 0 n2 0 q2D
            float n2 = n1 + r1to2 * j1;
            MFloat q2D = q1D + l1D * r1to2;

            o[ch] = -q2D / n2;

            // Factor out second column from R1
            // 0 n2 0 q2D

            float r2to1 = -j1 / n2;

            // 0 0 k1 l2D
            // 0 n2 0 q2D
            MFloat l2D = l1D + q2D * r2to1;

            float elim2 = -f / k1;
            float elim1 = -e / n2;

            // d 0 0 g2D
            MFloat g2D = gD + l2D * elim2 + q2D * elim1;

            // n2*o + q2 = 0
            // o = -q2 / n2
            h[ch] = -g2D / d;
            v[ch] = -l2D / k1;
        }

        // Undo the local transformation
        h[ch] = h[ch] * 4.0f + o[ch];
        v[ch] = v[ch] * 4.0f + o[ch];
    }

    if (isFakeBT709)
    {
        MFloat oRGB[3];
        MFloat hRGB[3];
        MFloat vRGB[3];

        ConvertFromFakeBT709(oRGB, o);
        ConvertFromFakeBT709(hRGB, h);
        ConvertFromFakeBT709(vRGB, v);

        // Twiddling in fake BT.607 is a mess, just round off for now (the precision is pretty good anyway)
        {
            ParallelMath::RoundTowardNearestForScope rtn;

            for (int ch = 0; ch < 3; ch++)
            {
                MFloat fcoeffs[3] = { oRGB[ch], hRGB[ch], vRGB[ch] };

                for (int c = 0; c < 3; c++)
                {
                    MFloat coeff = ParallelMath::Max(ParallelMath::MakeFloatZero(), fcoeffs[c]);
                    if (ch == 1)
                        coeff = ParallelMath::Min(ParallelMath::MakeFloat(127.0f), coeff * (127.0f / 255.0f));
                    else
                        coeff = ParallelMath::Min(ParallelMath::MakeFloat(63.0f), coeff * (63.0f / 255.0f));
                    fcoeffs[c] = coeff;
                }

                for (int c = 0; c < 3; c++)
                    bestCoeffs[ch][c] = ParallelMath::RoundAndConvertToU15(fcoeffs[c], &rtn);
            }
        }

        MUInt15 reconstructed[16][3];
        for (int ch = 0; ch < 3; ch++)
        {
            MUInt15 dO = DecodePlanarCoeff(bestCoeffs[ch][0], ch);
            MUInt15 dH = DecodePlanarCoeff(bestCoeffs[ch][1], ch);
            MUInt15 dV = DecodePlanarCoeff(bestCoeffs[ch][2], ch);

            MSInt16 hMinusO = ParallelMath::LosslessCast<MSInt16>::Cast(dH) - ParallelMath::LosslessCast<MSInt16>::Cast(dO);
            MSInt16 vMinusO = ParallelMath::LosslessCast<MSInt16>::Cast(dV) - ParallelMath::LosslessCast<MSInt16>::Cast(dO);

            MFloat error = ParallelMath::MakeFloatZero();

            MSInt16 addend = ParallelMath::LosslessCast<MSInt16>::Cast(dO << 2) + 2;

            for (int px = 0; px < 16; px++)
            {
                MUInt15 pxv = ParallelMath::MakeUInt15(px);
                MSInt16 x = ParallelMath::LosslessCast<MSInt16>::Cast(pxv & ParallelMath::MakeUInt15(3));
                MSInt16 y = ParallelMath::LosslessCast<MSInt16>::Cast(ParallelMath::RightShift(pxv, 2));

                MSInt16 interpolated = ParallelMath::RightShift(ParallelMath::CompactMultiply(x, hMinusO) + ParallelMath::CompactMultiply(y, vMinusO) + addend, 2);
                MUInt15 clampedLow = ParallelMath::ToUInt15(ParallelMath::Max(ParallelMath::MakeSInt16(0), interpolated));
                reconstructed[px][ch] = ParallelMath::Min(ParallelMath::MakeUInt15(255), clampedLow);
            }
        }

        totalError = ParallelMath::MakeFloatZero();
        for (int px = 0; px < 16; px++)
            totalError = totalError + ComputeErrorFakeBT709(reconstructed[px], preWeightedPixels[px]);
    }
    else
    {
        for (int ch = 0; ch < 3; ch++)
        {
            MFloat fcoeffs[3] = { o[ch], h[ch], v[ch] };
            MUInt15 coeffRanges[3][2];

            for (int c = 0; c < 3; c++)
            {
                MFloat coeff = ParallelMath::Max(ParallelMath::MakeFloatZero(), fcoeffs[c]);
                if (ch == 1)
                    coeff = ParallelMath::Min(ParallelMath::MakeFloat(127.0f), coeff * (127.0f / 255.0f));
                else
                    coeff = ParallelMath::Min(ParallelMath::MakeFloat(63.0f), coeff * (63.0f / 255.0f));
                fcoeffs[c] = coeff;
            }

            {
                ParallelMath::RoundDownForScope rd;
                for (int c = 0; c < 3; c++)
                    coeffRanges[c][0] = ParallelMath::RoundAndConvertToU15(fcoeffs[c], &rd);
            }

            {
                ParallelMath::RoundUpForScope ru;
                for (int c = 0; c < 3; c++)
                    coeffRanges[c][1] = ParallelMath::RoundAndConvertToU15(fcoeffs[c], &ru);
            }

            MFloat bestChannelError = ParallelMath::MakeFloat(FLT_MAX);
            for (int io = 0; io < 2; io++)
            {
                MUInt15 dO = DecodePlanarCoeff(coeffRanges[0][io], ch);

                for (int ih = 0; ih < 2; ih++)
                {
                    MUInt15 dH = DecodePlanarCoeff(coeffRanges[1][ih], ch);
                    MSInt16 hMinusO = ParallelMath::LosslessCast<MSInt16>::Cast(dH) - ParallelMath::LosslessCast<MSInt16>::Cast(dO);

                    for (int iv = 0; iv < 2; iv++)
                    {
                        MUInt15 dV = DecodePlanarCoeff(coeffRanges[2][iv], ch);
                        MSInt16 vMinusO = ParallelMath::LosslessCast<MSInt16>::Cast(dV) - ParallelMath::LosslessCast<MSInt16>::Cast(dO);

                        MFloat error = ParallelMath::MakeFloatZero();

                        MSInt16 addend = ParallelMath::LosslessCast<MSInt16>::Cast(dO << 2) + 2;

                        for (int px = 0; px < 16; px++)
                        {
                            MUInt15 pxv = ParallelMath::MakeUInt15(px);
                            MSInt16 x = ParallelMath::LosslessCast<MSInt16>::Cast(pxv & ParallelMath::MakeUInt15(3));
                            MSInt16 y = ParallelMath::LosslessCast<MSInt16>::Cast(ParallelMath::RightShift(pxv, 2));

                            MSInt16 interpolated = ParallelMath::RightShift(ParallelMath::CompactMultiply(x, hMinusO) + ParallelMath::CompactMultiply(y, vMinusO) + addend, 2);
                            MUInt15 clampedLow = ParallelMath::ToUInt15(ParallelMath::Max(ParallelMath::MakeSInt16(0), interpolated));
                            MUInt15 dec = ParallelMath::Min(ParallelMath::MakeUInt15(255), clampedLow);

                            MSInt16 delta = ParallelMath::LosslessCast<MSInt16>::Cast(pixels[px][ch]) - ParallelMath::LosslessCast<MSInt16>::Cast(dec);

                            MFloat deltaF = ParallelMath::ToFloat(delta);
                            error = error + deltaF * deltaF;
                        }

                        ParallelMath::Int16CompFlag errorBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(error, bestChannelError));
                        if (ParallelMath::AnySet(errorBetter))
                        {
                            bestChannelError = ParallelMath::Min(error, bestChannelError);
                            ParallelMath::ConditionalSet(bestCoeffs[ch][0], errorBetter, coeffRanges[0][io]);
                            ParallelMath::ConditionalSet(bestCoeffs[ch][1], errorBetter, coeffRanges[1][ih]);
                            ParallelMath::ConditionalSet(bestCoeffs[ch][2], errorBetter, coeffRanges[2][iv]);
                        }
                    }
                }
            }

            if (!isUniform)
            {
                switch (ch)
                {
                case 0:
                    bestChannelError = bestChannelError * (options.redWeight * options.redWeight);
                    break;
                case 1:
                    bestChannelError = bestChannelError * (options.greenWeight * options.greenWeight);
                    break;
                case 2:
                    bestChannelError = bestChannelError * (options.blueWeight * options.blueWeight);
                    break;
                default:
                    break;
                }
            }

            totalError = totalError + bestChannelError;
        }
    }

    ParallelMath::Int16CompFlag errorBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(totalError, bestError));
    if (ParallelMath::AnySet(errorBetter))
    {
        bestError = ParallelMath::Min(bestError, totalError);

        for (int block = 0; block < ParallelMath::ParallelSize; block++)
        {
            if (!ParallelMath::Extract(errorBetter, block))
                continue;

            int ro = ParallelMath::Extract(bestCoeffs[0][0], block);
            int rh = ParallelMath::Extract(bestCoeffs[0][1], block);
            int rv = ParallelMath::Extract(bestCoeffs[0][2], block);

            int go = ParallelMath::Extract(bestCoeffs[1][0], block);
            int gh = ParallelMath::Extract(bestCoeffs[1][1], block);
            int gv = ParallelMath::Extract(bestCoeffs[1][2], block);

            int bo = ParallelMath::Extract(bestCoeffs[2][0], block);
            int bh = ParallelMath::Extract(bestCoeffs[2][1], block);
            int bv = ParallelMath::Extract(bestCoeffs[2][2], block);

            int go1 = go >> 6;
            int go2 = go & 63;

            int bo1 = bo >> 5;
            int bo2 = (bo >> 3) & 3;
            int bo3 = bo & 7;

            int rh1 = (rh >> 1);
            int rh2 = rh & 1;

            int fakeR = ro >> 2;
            int fakeDR = go1 | ((ro & 3) << 1);

            int fakeG = (go2 >> 2);
            int fakeDG = ((go2 & 3) << 1) | bo1;

            int fakeB = bo2;
            int fakeDB = bo3 >> 1;

            uint32_t highBits = 0;
            uint32_t lowBits = 0;

            // Avoid overflowing R
            if ((fakeDR & 4) != 0 && fakeR + fakeDR < 8)
                highBits |= 1 << (63 - 32);

            // Avoid overflowing G
            if ((fakeDG & 4) != 0 && fakeG + fakeDG < 8)
                highBits |= 1 << (55 - 32);

            // Overflow B
            if (fakeB + fakeDB < 4)
            {
                // Overflow low
                highBits |= 1 << (42 - 32);
            }
            else
            {
                // Overflow high
                highBits |= 7 << (45 - 32);
            }

            highBits |= ro << (57 - 32);
            highBits |= go1 << (56 - 32);
            highBits |= go2 << (49 - 32);
            highBits |= bo1 << (48 - 32);
            highBits |= bo2 << (43 - 32);
            highBits |= bo3 << (39 - 32);
            highBits |= rh1 << (34 - 32);
            highBits |= 1 << (33 - 32);
            highBits |= rh2 << (32 - 32);

            lowBits |= gh << 25;
            lowBits |= bh << 19;
            lowBits |= rv << 13;
            lowBits |= gv << 6;
            lowBits |= bv << 0;

            for (int i = 0; i < 4; i++)
                outputBuffer[block * 8 + i] = (highBits >> (24 - i * 8)) & 0xff;
            for (int i = 0; i < 4; i++)
                outputBuffer[block * 8 + i + 4] = (lowBits >> (24 - i * 8)) & 0xff;
        }
    }
}

void cvtt::Internal::ETCComputer::CompressETC2Block(uint8_t *outputBuffer, const PixelBlockU8 *pixelBlocks, ETC2CompressionData *compressionData, const Options &options, bool punchthroughAlpha)
{
    ParallelMath::Int16CompFlag pixelIsTransparent[16];
    ParallelMath::Int16CompFlag anyTransparent = ParallelMath::MakeBoolInt16(false);
    ParallelMath::Int16CompFlag allTransparent = ParallelMath::MakeBoolInt16(true);

    if (punchthroughAlpha)
    {
        const float fThreshold = std::max<float>(std::min<float>(1.0f, options.threshold), 0.0f) * 255.0f;

        // +1.0f is intentional, we want to take the next valid integer (even if it's 256) since everything else lower is transparent
        MUInt15 threshold = ParallelMath::MakeUInt15(static_cast<uint16_t>(std::floor(fThreshold + 1.0f)));

        for (int px = 0; px < 16; px++)
        {
            MUInt15 alpha;
            for (int block = 0; block < ParallelMath::ParallelSize; block++)
                ParallelMath::PutUInt15(alpha, block, pixelBlocks[block].m_pixels[px][3]);

            ParallelMath::Int16CompFlag isTransparent = ParallelMath::Less(alpha, threshold);
            anyTransparent = (anyTransparent | isTransparent);
            allTransparent = (allTransparent & isTransparent);
            pixelIsTransparent[px] = isTransparent;
        }
    }
    else
    {
        for (int px = 0; px < 16; px++)
            pixelIsTransparent[px] = ParallelMath::MakeBoolInt16(false);

        allTransparent = anyTransparent = ParallelMath::MakeBoolInt16(false);
    }

    MFloat bestError = ParallelMath::MakeFloat(FLT_MAX);

    ETC2CompressionDataInternal* internalData = static_cast<ETC2CompressionDataInternal*>(compressionData);

    MUInt15 pixels[16][3];
    MFloat preWeightedPixels[16][3];
    ExtractBlocks(pixels, preWeightedPixels, pixelBlocks, options);

    if (ParallelMath::AnySet(anyTransparent))
    {
        for (int px = 0; px < 16; px++)
        {
            ParallelMath::Int16CompFlag flag = pixelIsTransparent[px];
            ParallelMath::FloatCompFlag fflag = ParallelMath::Int16FlagToFloat(flag);

            for (int ch = 0; ch < 3; ch++)
            {
                ParallelMath::ConditionalSet(pixels[px][ch], flag, ParallelMath::MakeUInt15(0));
                ParallelMath::ConditionalSet(preWeightedPixels[px][ch], fflag, ParallelMath::MakeFloat(0.0f));
            }
        }
    }

    if (!ParallelMath::AllSet(allTransparent))
        EncodePlanar(outputBuffer, bestError, pixels, preWeightedPixels, options);

    MFloat chromaDelta[16][2];

    MUInt15 numOpaque = ParallelMath::MakeUInt15(16);
    for (int px = 0; px < 16; px++)
        numOpaque = numOpaque - ParallelMath::SelectOrZero(pixelIsTransparent[px], ParallelMath::MakeUInt15(1));

    if (options.flags & cvtt::Flags::Uniform)
    {
        MSInt16 chromaCoordinates3[16][2];
        for (int px = 0; px < 16; px++)
        {
            chromaCoordinates3[px][0] = ParallelMath::LosslessCast<MSInt16>::Cast(pixels[px][0]) - ParallelMath::LosslessCast<MSInt16>::Cast(pixels[px][2]);
            chromaCoordinates3[px][1] = ParallelMath::LosslessCast<MSInt16>::Cast(pixels[px][0]) - ParallelMath::LosslessCast<MSInt16>::Cast(pixels[px][1] << 1) + ParallelMath::LosslessCast<MSInt16>::Cast(pixels[px][2]);
        }

        MSInt16 chromaCoordinateCentroid[2] = { ParallelMath::MakeSInt16(0), ParallelMath::MakeSInt16(0) };
        for (int px = 0; px < 16; px++)
        {
            for (int ch = 0; ch < 2; ch++)
                chromaCoordinateCentroid[ch] = chromaCoordinateCentroid[ch] + chromaCoordinates3[px][ch];
        }

        if (punchthroughAlpha)
        {
            for (int px = 0; px < 16; px++)
            {
                for (int ch = 0; ch < 2; ch++)
                {
                    MUInt15 chromaCoordinateMultiplied = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::CompactMultiply(chromaCoordinates3[px][ch], numOpaque));
                    MSInt16 delta = ParallelMath::LosslessCast<MSInt16>::Cast(chromaCoordinateMultiplied) - chromaCoordinateCentroid[ch];
                    chromaDelta[px][ch] = ParallelMath::ToFloat(delta);
                }
            }
        }
        else
        {
            for (int px = 0; px < 16; px++)
            {
                for (int ch = 0; ch < 2; ch++)
                    chromaDelta[px][ch] = ParallelMath::ToFloat((chromaCoordinates3[px][ch] << 4) - chromaCoordinateCentroid[ch]);
            }
        }

        const MFloat rcpSqrt3 = ParallelMath::MakeFloat(0.57735026918962576450914878050196f);

        for (int px = 0; px < 16; px++)
            chromaDelta[px][1] = chromaDelta[px][1] * rcpSqrt3;
    }
    else
    {
        const float chromaAxis0[3] = { internalData->m_chromaSideAxis0[0], internalData->m_chromaSideAxis0[1], internalData->m_chromaSideAxis0[2] };
        const float chromaAxis1[3] = { internalData->m_chromaSideAxis1[0], internalData->m_chromaSideAxis1[1], internalData->m_chromaSideAxis1[2] };

        MFloat chromaCoordinates3[16][2];
        for (int px = 0; px < 16; px++)
        {
            const MFloat &px0 = preWeightedPixels[px][0];
            const MFloat &px1 = preWeightedPixels[px][1];
            const MFloat &px2 = preWeightedPixels[px][2];

            chromaCoordinates3[px][0] = px0 * chromaAxis0[0] + px1 * chromaAxis0[1] + px2 * chromaAxis0[2];
            chromaCoordinates3[px][1] = px0 * chromaAxis1[0] + px1 * chromaAxis1[1] + px2 * chromaAxis1[2];
        }

        MFloat chromaCoordinateCentroid[2] = { ParallelMath::MakeFloatZero(), ParallelMath::MakeFloatZero() };
        for (int px = 0; px < 16; px++)
        {
            for (int ch = 0; ch < 2; ch++)
                chromaCoordinateCentroid[ch] = chromaCoordinateCentroid[ch] + chromaCoordinates3[px][ch];
        }

        if (punchthroughAlpha)
        {
            const MFloat numOpaqueF = ParallelMath::ToFloat(numOpaque);
            for (int px = 0; px < 16; px++)
            {
                for (int ch = 0; ch < 2; ch++)
                {
                    MFloat chromaCoordinateMultiplied = chromaCoordinates3[px][ch] * numOpaqueF;
                    MFloat delta = chromaCoordinateMultiplied - chromaCoordinateCentroid[ch];
                    chromaDelta[px][ch] = delta;
                }
            }
        }
        else
        {
            for (int px = 0; px < 16; px++)
            {
                for (int ch = 0; ch < 2; ch++)
                    chromaDelta[px][ch] = chromaCoordinates3[px][ch] * 16.0f - chromaCoordinateCentroid[ch];
            }
        }
    }


    MFloat covXX = ParallelMath::MakeFloatZero();
    MFloat covYY = ParallelMath::MakeFloatZero();
    MFloat covXY = ParallelMath::MakeFloatZero();

    for (int px = 0; px < 16; px++)
    {
        MFloat nx = chromaDelta[px][0];
        MFloat ny = chromaDelta[px][1];

        covXX = covXX + nx * nx;
        covYY = covYY + ny * ny;
        covXY = covXY + nx * ny;
    }

    MFloat halfTrace = (covXX + covYY) * 0.5f;
    MFloat det = covXX * covYY - covXY * covXY;

    MFloat mm = ParallelMath::Sqrt(ParallelMath::Max(ParallelMath::MakeFloatZero(), halfTrace * halfTrace - det));

    MFloat ev = halfTrace + mm;

    MFloat dx = (covYY - ev + covXY);
    MFloat dy = -(covXX - ev + covXY);

    // If evenly distributed, pick an arbitrary plane
    ParallelMath::FloatCompFlag allZero = ParallelMath::Equal(dx, ParallelMath::MakeFloatZero()) & ParallelMath::Equal(dy, ParallelMath::MakeFloatZero());
    ParallelMath::ConditionalSet(dx, allZero, ParallelMath::MakeFloat(1.f));

    ParallelMath::Int16CompFlag sectorAssignments[16];
    for (int px = 0; px < 16; px++)
        sectorAssignments[px] = ParallelMath::FloatFlagToInt16(ParallelMath::Less(chromaDelta[px][0] * dx + chromaDelta[px][1] * dy, ParallelMath::MakeFloatZero()));

    if (!ParallelMath::AllSet(allTransparent))
    {
        EncodeTMode(outputBuffer, bestError, sectorAssignments, pixels, preWeightedPixels, options);

        // Flip sector assignments
        for (int px = 0; px < 16; px++)
            sectorAssignments[px] = ParallelMath::Not(sectorAssignments[px]);

        EncodeTMode(outputBuffer, bestError, sectorAssignments, pixels, preWeightedPixels, options);

        EncodeHMode(outputBuffer, bestError, sectorAssignments, pixels, internalData->m_h, preWeightedPixels, options);

        CompressETC1BlockInternal(bestError, outputBuffer, pixels, preWeightedPixels, internalData->m_drs, options, true);
    }

    if (ParallelMath::AnySet(anyTransparent))
    {
        if (!ParallelMath::AllSet(allTransparent))
        {
            // Flip sector assignments
            for (int px = 0; px < 16; px++)
                sectorAssignments[px] = ParallelMath::Not(sectorAssignments[px]);
        }

        // Reset the error of any transparent blocks to max and retry with punchthrough modes
        ParallelMath::ConditionalSet(bestError, ParallelMath::Int16FlagToFloat(anyTransparent), ParallelMath::MakeFloat(FLT_MAX));

        EncodeVirtualTModePunchthrough(outputBuffer, bestError, sectorAssignments, pixels, preWeightedPixels, pixelIsTransparent, anyTransparent, allTransparent, options);

        // Flip sector assignments
        for (int px = 0; px < 16; px++)
            sectorAssignments[px] = ParallelMath::Not(sectorAssignments[px]);

        EncodeVirtualTModePunchthrough(outputBuffer, bestError, sectorAssignments, pixels, preWeightedPixels, pixelIsTransparent, anyTransparent, allTransparent, options);

        CompressETC1PunchthroughBlockInternal(bestError, outputBuffer, pixels, preWeightedPixels, pixelIsTransparent, static_cast<ETC2CompressionDataInternal*>(compressionData)->m_drs, options);
    }
}

void cvtt::Internal::ETCComputer::CompressETC2AlphaBlock(uint8_t *outputBuffer, const PixelBlockU8 *pixelBlocks, const Options &options)
{
    MUInt15 pixels[16];

    for (int px = 0; px < 16; px++)
    {
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
            ParallelMath::PutUInt15(pixels[px], block, pixelBlocks[block].m_pixels[px][3]);
    }

    CompressETC2AlphaBlockInternal(outputBuffer, pixels, false, false, options);
}

void cvtt::Internal::ETCComputer::CompressETC2AlphaBlockInternal(uint8_t *outputBuffer, const MUInt15 pixels[16], bool is11Bit, bool isSigned, const Options &options)
{
    MUInt15 minAlpha = ParallelMath::MakeUInt15(is11Bit ? 2047 : 255);
    MUInt15 maxAlpha = ParallelMath::MakeUInt15(0);

    for (int px = 0; px < 16; px++)
    {
        minAlpha = ParallelMath::Min(minAlpha, pixels[px]);
        maxAlpha = ParallelMath::Max(maxAlpha, pixels[px]);
    }

    MUInt15 alphaSpan = maxAlpha - minAlpha;
    MUInt15 alphaSpanMidpointTimes2 = maxAlpha + minAlpha;

    MUInt31 bestTotalError = ParallelMath::MakeUInt31(0x7fffffff);
    MUInt15 bestTableIndex = ParallelMath::MakeUInt15(0);
    MUInt15 bestBaseCodeword = ParallelMath::MakeUInt15(0);
    MUInt15 bestMultiplier = ParallelMath::MakeUInt15(0);
    MUInt15 bestIndexes[16];

    for (int px = 0; px < 16; px++)
        bestIndexes[px] = ParallelMath::MakeUInt15(0);

    const int numAlphaRanges = 10;
    for (uint16_t tableIndex = 0; tableIndex < 16; tableIndex++)
    {
        for (int r = 0; r < numAlphaRanges; r++)
        {
            int subrange = r % 3;
            int mainRange = r / 3;

            int16_t maxOffset = Tables::ETC2::g_alphaModifierTablePositive[tableIndex][3 - mainRange - (subrange & 1)];
            int16_t minOffset = -Tables::ETC2::g_alphaModifierTablePositive[tableIndex][3 - mainRange - ((subrange >> 1) & 1)] - 1;
            uint16_t offsetSpan = static_cast<uint16_t>(maxOffset - minOffset);

            MSInt16 vminOffset = ParallelMath::MakeSInt16(minOffset);
            MUInt15 vmaxOffset = ParallelMath::MakeUInt15(maxOffset);
            MUInt15 voffsetSpan = ParallelMath::MakeUInt15(offsetSpan);

            MUInt15 minMultiplier = ParallelMath::MakeUInt15(0);
            for (int block = 0; block < ParallelMath::ParallelSize; block++)
            {
                uint16_t singleAlphaSpan = ParallelMath::Extract(alphaSpan, block);

                uint16_t lowMultiplier = singleAlphaSpan / offsetSpan;
                ParallelMath::PutUInt15(minMultiplier, block, lowMultiplier);
            }

            if (is11Bit)
            {
                // Clamps this to valid multipliers under 15 and rounds down to nearest multiple of 8
                minMultiplier = ParallelMath::Min(minMultiplier, ParallelMath::MakeUInt15(112)) & ParallelMath::MakeUInt15(120);
            }
            else
            {
                // We cap at 1 and 14 so both multipliers are valid and dividable
                // Cases where offset span is 0 should be caught by multiplier 1 of table 13
                minMultiplier = ParallelMath::Max(ParallelMath::Min(minMultiplier, ParallelMath::MakeUInt15(14)), ParallelMath::MakeUInt15(1));
            }

            for (uint16_t multiplierOffset = 0; multiplierOffset < 2; multiplierOffset++)
            {
                MUInt15 multiplier = minMultiplier;

                if (is11Bit)
                {
                    if (multiplierOffset == 1)
                        multiplier = multiplier + ParallelMath::MakeUInt15(8);
                    else
                        multiplier = ParallelMath::Max(multiplier, ParallelMath::MakeUInt15(1));
                }
                else
                {
                    if (multiplierOffset == 1)
                        multiplier = multiplier + ParallelMath::MakeUInt15(1);
                }

                MSInt16 multipliedMinOffset = ParallelMath::CompactMultiply(ParallelMath::LosslessCast<MSInt16>::Cast(multiplier), vminOffset);
                MUInt15 multipliedMaxOffset = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::CompactMultiply(multiplier, vmaxOffset));

                // codeword = (maxOffset + minOffset + minAlpha + maxAlpha) / 2
                MSInt16 unclampedBaseAlphaTimes2 = ParallelMath::LosslessCast<MSInt16>::Cast(alphaSpanMidpointTimes2) - ParallelMath::LosslessCast<MSInt16>::Cast(multipliedMaxOffset) - multipliedMinOffset;

                MUInt15 baseAlpha;
                if (is11Bit)
                {
                    // In unsigned, 4 is added to the unquantized alpha, so compensating for that cancels the 4 we have to add to do rounding.
                    if (isSigned)
                        unclampedBaseAlphaTimes2 = unclampedBaseAlphaTimes2 + ParallelMath::MakeSInt16(8);

                    // -128 is illegal for some reason
                    MSInt16 minBaseAlphaTimes2 = isSigned ? ParallelMath::MakeSInt16(16) : ParallelMath::MakeSInt16(0);

                    MUInt15 clampedBaseAlphaTimes2 = ParallelMath::Min(ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(unclampedBaseAlphaTimes2, minBaseAlphaTimes2)), ParallelMath::MakeUInt15(4095));
                    baseAlpha = ParallelMath::RightShift(clampedBaseAlphaTimes2, 1) & ParallelMath::MakeUInt15(2040);

                    if (!isSigned)
                        baseAlpha = baseAlpha + ParallelMath::MakeUInt15(4);
                }
                else
                {
                    MUInt15 clampedBaseAlphaTimes2 = ParallelMath::Min(ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(unclampedBaseAlphaTimes2, ParallelMath::MakeSInt16(0))), ParallelMath::MakeUInt15(510));
                    baseAlpha = ParallelMath::RightShift(clampedBaseAlphaTimes2 + ParallelMath::MakeUInt15(1), 1);
                }

                MUInt15 indexes[16];
                MUInt31 totalError = ParallelMath::MakeUInt31(0);
                for (int px = 0; px < 16; px++)
                {
                    MUInt15 quantizedValues;
                    QuantizeETC2Alpha(tableIndex, pixels[px], baseAlpha, multiplier, is11Bit, isSigned, indexes[px], quantizedValues);

                    if (is11Bit)
                    {
                        MSInt16 delta = ParallelMath::LosslessCast<MSInt16>::Cast(quantizedValues) - ParallelMath::LosslessCast<MSInt16>::Cast(pixels[px]);
                        MSInt32 deltaSq = ParallelMath::XMultiply(delta, delta);
                        totalError = totalError + ParallelMath::LosslessCast<MUInt31>::Cast(deltaSq);
                    }
                    else
                        totalError = totalError + ParallelMath::ToUInt31(ParallelMath::SqDiffUInt8(quantizedValues, pixels[px]));
                }

                ParallelMath::Int16CompFlag isBetter = ParallelMath::Int32FlagToInt16(ParallelMath::Less(totalError, bestTotalError));
                if (ParallelMath::AnySet(isBetter))
                {
                    ParallelMath::ConditionalSet(bestTotalError, isBetter, totalError);
                    ParallelMath::ConditionalSet(bestTableIndex, isBetter, ParallelMath::MakeUInt15(tableIndex));
                    ParallelMath::ConditionalSet(bestBaseCodeword, isBetter, baseAlpha);
                    ParallelMath::ConditionalSet(bestMultiplier, isBetter, multiplier);

                    for (int px = 0; px < 16; px++)
                        ParallelMath::ConditionalSet(bestIndexes[px], isBetter, indexes[px]);
                }

                // TODO: Do one refine pass
            }
        }
    }

    if (is11Bit)
    {
        bestMultiplier = ParallelMath::RightShift(bestMultiplier, 3);

        if (isSigned)
            bestBaseCodeword = bestBaseCodeword ^ ParallelMath::MakeUInt15(0x80);
    }

    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        uint8_t *output = outputBuffer + block * 8;

        output[0] = static_cast<uint8_t>(ParallelMath::Extract(bestBaseCodeword, block));

        ParallelMath::ScalarUInt16 multiplier = ParallelMath::Extract(bestMultiplier, block);
        ParallelMath::ScalarUInt16 tableIndex = ParallelMath::Extract(bestTableIndex, block);

        output[1] = static_cast<uint8_t>((multiplier << 4) | tableIndex);

        static const int pixelSelectorOrder[16] = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 };

        ParallelMath::ScalarUInt16 indexes[16];
        for (int px = 0; px < 16; px++)
            indexes[pixelSelectorOrder[px]] = ParallelMath::Extract(bestIndexes[px], block);

        int outputOffset = 2;
        int outputBits = 0;
        int numOutputBits = 0;
        for (int s = 0; s < 16; s++)
        {
            outputBits = (outputBits << 3) | indexes[s];
            numOutputBits += 3;

            if (numOutputBits >= 8)
            {
                output[outputOffset++] = static_cast<uint8_t>(outputBits >> (numOutputBits - 8));
                numOutputBits -= 8;

                outputBits &= ((1 << numOutputBits) - 1);
            }
        }

        assert(outputOffset == 8 && numOutputBits == 0);
    }
}

void cvtt::Internal::ETCComputer::CompressEACBlock(uint8_t *outputBuffer, const PixelBlockScalarS16 *inputBlocks, bool isSigned, const Options &options)
{
    MUInt15 pixels[16];
    for (int px = 0; px < 16; px++)
    {
        MSInt16 adjustedPixel;
        for (int block = 0; block < ParallelMath::ParallelSize; block++)
            ParallelMath::PutSInt16(adjustedPixel, block, inputBlocks[block].m_pixels[px]);

        // We use a slightly shifted range here so we can keep the unquantized base color in a UInt15
        // That is, signed range is 1..2047, and unsigned range is 0..2047
        if (isSigned)
        {
            adjustedPixel = ParallelMath::Min(adjustedPixel, ParallelMath::MakeSInt16(1023)) + ParallelMath::MakeSInt16(1024);
            adjustedPixel = ParallelMath::Max(ParallelMath::MakeSInt16(1), adjustedPixel);
        }
        else
        {
            adjustedPixel = ParallelMath::Min(adjustedPixel, ParallelMath::MakeSInt16(2047));
            adjustedPixel = ParallelMath::Max(ParallelMath::MakeSInt16(0), adjustedPixel);
        }


        pixels[px] = ParallelMath::LosslessCast<MUInt15>::Cast(adjustedPixel);
    }

    CompressETC2AlphaBlockInternal(outputBuffer, pixels, true, isSigned, options);
}

void cvtt::Internal::ETCComputer::CompressETC1Block(uint8_t *outputBuffer, const PixelBlockU8 *inputBlocks, ETC1CompressionData *compressionData, const Options &options)
{
    DifferentialResolveStorage &drs = static_cast<ETC1CompressionDataInternal*>(compressionData)->m_drs;
    MFloat bestTotalError = ParallelMath::MakeFloat(FLT_MAX);

    MUInt15 pixels[16][3];
    MFloat preWeightedPixels[16][3];
    ExtractBlocks(pixels, preWeightedPixels, inputBlocks, options);

    CompressETC1BlockInternal(bestTotalError, outputBuffer, pixels, preWeightedPixels, drs, options, false);
}

void cvtt::Internal::ETCComputer::ExtractBlocks(MUInt15 pixels[16][3], MFloat preWeightedPixels[16][3], const PixelBlockU8 *inputBlocks, const Options &options)
{
    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);
    bool isUniform = ((options.flags & cvtt::Flags::Uniform) != 0);

    for (int px = 0; px < 16; px++)
    {
        for (int ch = 0; ch < 3; ch++)
        {
            for (int block = 0; block < ParallelMath::ParallelSize; block++)
                ParallelMath::PutUInt15(pixels[px][ch], block, inputBlocks[block].m_pixels[px][ch]);
        }

        if (isFakeBT709)
            ConvertToFakeBT709(preWeightedPixels[px], pixels[px]);
        else if (isUniform)
        {
            for (int ch = 0; ch < 3; ch++)
                preWeightedPixels[px][ch] = ParallelMath::ToFloat(pixels[px][ch]);
        }
        else
        {
            preWeightedPixels[px][0] = ParallelMath::ToFloat(pixels[px][0]) * options.redWeight;
            preWeightedPixels[px][1] = ParallelMath::ToFloat(pixels[px][1]) * options.greenWeight;
            preWeightedPixels[px][2] = ParallelMath::ToFloat(pixels[px][2]) * options.blueWeight;
        }
    }
}

void cvtt::Internal::ETCComputer::ResolveHalfBlockFakeBT709RoundingAccurate(MUInt15 quantized[3], const MUInt15 sectorCumulative[3], bool isDifferential)
{
    for (int ch = 0; ch < 3; ch++)
    {
        const MUInt15& cu15 = sectorCumulative[ch];

        if (isDifferential)
        {
            //quantized[ch] = (cu * 31 + (cu >> 3)) >> 11;
            quantized[ch] = ParallelMath::ToUInt15(
                ParallelMath::RightShift(
                (ParallelMath::LosslessCast<MUInt16>::Cast(cu15) << 5) - ParallelMath::LosslessCast<MUInt16>::Cast(cu15) + ParallelMath::LosslessCast<MUInt16>::Cast(ParallelMath::RightShift(cu15, 3))
                    , 11)
            );
        }
        else
        {
            //quantized[ch] = (cu * 30 + (cu >> 3)) >> 12;
            quantized[ch] = ParallelMath::ToUInt15(
                ParallelMath::RightShift(
                (ParallelMath::LosslessCast<MUInt16>::Cast(cu15) << 5) - ParallelMath::LosslessCast<MUInt16>::Cast(cu15 << 1) + ParallelMath::LosslessCast<MUInt16>::Cast(ParallelMath::RightShift(cu15, 3))
                    , 12)
            );
        }
    }

    MFloat lowOctantRGBFloat[3];
    MFloat highOctantRGBFloat[3];

    for (int ch = 0; ch < 3; ch++)
    {
        MUInt15 unquantized;
        MUInt15 unquantizedNext;
        if (isDifferential)
        {
            unquantized = (quantized[ch] << 3) | ParallelMath::RightShift(quantized[ch], 2);
            MUInt15 quantizedNext = ParallelMath::Min(ParallelMath::MakeUInt15(31), quantized[ch] + ParallelMath::MakeUInt15(1));
            unquantizedNext = (quantizedNext << 3) | ParallelMath::RightShift(quantizedNext, 2);
        }
        else
        {
            unquantized = (quantized[ch] << 4) | quantized[ch];
            unquantizedNext = ParallelMath::Min(ParallelMath::MakeUInt15(255), unquantized + ParallelMath::MakeUInt15(17));
        }
        lowOctantRGBFloat[ch] = ParallelMath::ToFloat(unquantized << 3);
        highOctantRGBFloat[ch] = ParallelMath::ToFloat(unquantizedNext << 3);
    }

    MFloat bestError = ParallelMath::MakeFloat(FLT_MAX);
    MUInt15 bestOctant = ParallelMath::MakeUInt15(0);

    MFloat cumulativeYUV[3];
    ConvertToFakeBT709(cumulativeYUV, sectorCumulative);

    for (uint16_t octant = 0; octant < 8; octant++)
    {
        const MFloat &r = (octant & 1) ? highOctantRGBFloat[0] : lowOctantRGBFloat[0];
        const MFloat &g = (octant & 2) ? highOctantRGBFloat[1] : lowOctantRGBFloat[1];
        const MFloat &b = (octant & 4) ? highOctantRGBFloat[2] : lowOctantRGBFloat[2];

        MFloat octantYUV[3];
        ConvertToFakeBT709(octantYUV, r, g, b);

        MFloat delta[3];
        for (int ch = 0; ch < 3; ch++)
            delta[ch] = octantYUV[ch] - cumulativeYUV[ch];

        MFloat error = delta[0] * delta[0] + delta[1] + delta[1] + delta[2] * delta[2];
        ParallelMath::Int16CompFlag errorBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(error, bestError));
        ParallelMath::ConditionalSet(bestOctant, errorBetter, ParallelMath::MakeUInt15(octant));
        bestError = ParallelMath::Min(error, bestError);
    }

    for (int ch = 0; ch < 3; ch++)
        quantized[ch] = quantized[ch] + (ParallelMath::RightShift(bestOctant, ch) & ParallelMath::MakeUInt15(1));
}

void cvtt::Internal::ETCComputer::ResolveHalfBlockFakeBT709RoundingFast(MUInt15 quantized[3], const MUInt15 sectorCumulative[3], bool isDifferential)
{
    // sectorCumulative range is 0..2040 (11 bits)
    MUInt15 roundingOffset = ParallelMath::MakeUInt15(0);

    MUInt15 rOffset;
    MUInt15 gOffset;
    MUInt15 bOffset;
    MUInt15 quantizedBase[3];
    MUInt15 upperBound;

    MUInt15 sectorCumulativeFillIn[3];
    for (int ch = 0; ch < 3; ch++)
        sectorCumulativeFillIn[ch] = sectorCumulative[ch] + ParallelMath::RightShift(sectorCumulative[ch], 8);

    if (isDifferential)
    {
        rOffset = (sectorCumulativeFillIn[0] << 6) & ParallelMath::MakeUInt15(0xf00);
        gOffset = (sectorCumulativeFillIn[1] << 4) & ParallelMath::MakeUInt15(0x0f0);
        bOffset = ParallelMath::RightShift(sectorCumulativeFillIn[2], 2) & ParallelMath::MakeUInt15(0x00f);

        for (int ch = 0; ch < 3; ch++)
            quantizedBase[ch] = ParallelMath::RightShift(sectorCumulativeFillIn[ch], 6);

        upperBound = ParallelMath::MakeUInt15(31);
    }
    else
    {
        rOffset = (sectorCumulativeFillIn[0] << 5) & ParallelMath::MakeUInt15(0xf00);
        gOffset = (sectorCumulativeFillIn[1] << 1) & ParallelMath::MakeUInt15(0x0f0);
        bOffset = ParallelMath::RightShift(sectorCumulativeFillIn[2], 3) & ParallelMath::MakeUInt15(0x00f);

        for (int ch = 0; ch < 3; ch++)
            quantizedBase[ch] = ParallelMath::RightShift(sectorCumulativeFillIn[ch], 7);

        upperBound = ParallelMath::MakeUInt15(15);
    }

    MUInt15 lookupIndex = (rOffset | gOffset | bOffset);

    MUInt15 octant;
    for (int block = 0; block < ParallelMath::ParallelSize; block++)
        ParallelMath::PutUInt15(octant, block, Tables::FakeBT709::g_rounding16[ParallelMath::Extract(lookupIndex, block)]);

    quantizedBase[0] = quantizedBase[0] + (octant & ParallelMath::MakeUInt15(1));
    quantizedBase[1] = quantizedBase[1] + (ParallelMath::RightShift(octant, 1) & ParallelMath::MakeUInt15(1));
    quantizedBase[2] = quantizedBase[2] + (ParallelMath::RightShift(octant, 2) & ParallelMath::MakeUInt15(1));

    for (int ch = 0; ch < 3; ch++)
        quantized[ch] = ParallelMath::Min(quantizedBase[ch], upperBound);
}

void cvtt::Internal::ETCComputer::ResolveTHFakeBT709Rounding(MUInt15 quantized[3], const MUInt15 targets[3], const MUInt15 &granularity)
{
    MFloat lowOctantRGBFloat[3];
    MFloat highOctantRGBFloat[3];

    for (int ch = 0; ch < 3; ch++)
    {
        MUInt15 unquantized = (quantized[ch] << 4) | quantized[ch];
        MUInt15 unquantizedNext = ParallelMath::Min(ParallelMath::MakeUInt15(255), unquantized + ParallelMath::MakeUInt15(17));

        lowOctantRGBFloat[ch] = ParallelMath::ToFloat(ParallelMath::CompactMultiply(unquantized, granularity) << 1);
        highOctantRGBFloat[ch] = ParallelMath::ToFloat(ParallelMath::CompactMultiply(unquantizedNext, granularity) << 1);
    }

    MFloat bestError = ParallelMath::MakeFloat(FLT_MAX);
    MUInt15 bestOctant = ParallelMath::MakeUInt15(0);

    MFloat cumulativeYUV[3];
    ConvertToFakeBT709(cumulativeYUV, ParallelMath::ToFloat(targets[0]), ParallelMath::ToFloat(targets[1]), ParallelMath::ToFloat(targets[2]));

    for (uint16_t octant = 0; octant < 8; octant++)
    {
        const MFloat &r = (octant & 1) ? highOctantRGBFloat[0] : lowOctantRGBFloat[0];
        const MFloat &g = (octant & 2) ? highOctantRGBFloat[1] : lowOctantRGBFloat[1];
        const MFloat &b = (octant & 4) ? highOctantRGBFloat[2] : lowOctantRGBFloat[2];

        MFloat octantYUV[3];
        ConvertToFakeBT709(octantYUV, r, g, b);

        MFloat delta[3];
        for (int ch = 0; ch < 3; ch++)
            delta[ch] = octantYUV[ch] - cumulativeYUV[ch];

        MFloat error = delta[0] * delta[0] + delta[1] + delta[1] + delta[2] * delta[2];
        ParallelMath::Int16CompFlag errorBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(error, bestError));
        ParallelMath::ConditionalSet(bestOctant, errorBetter, ParallelMath::MakeUInt15(octant));
        bestError = ParallelMath::Min(error, bestError);
    }

    for (int ch = 0; ch < 3; ch++)
        quantized[ch] = quantized[ch] + (ParallelMath::RightShift(bestOctant, ch) & ParallelMath::MakeUInt15(1));
}

void cvtt::Internal::ETCComputer::ConvertToFakeBT709(MFloat yuv[3], const MUInt15 color[3])
{
    MFloat floatRGB[3];
    for (int ch = 0; ch < 3; ch++)
        floatRGB[ch] = ParallelMath::ToFloat(color[ch]);

    ConvertToFakeBT709(yuv, floatRGB);
}

void cvtt::Internal::ETCComputer::ConvertToFakeBT709(MFloat yuv[3], const MFloat color[3])
{
    ConvertToFakeBT709(yuv, color[0], color[1], color[2]);
}

void cvtt::Internal::ETCComputer::ConvertToFakeBT709(MFloat yuv[3], const MFloat &pr, const MFloat &pg, const MFloat &pb)
{
    MFloat r = pr;
    MFloat g = pg;
    MFloat b = pb;

    yuv[0] = r * 0.368233989135369f + g * 1.23876274963149f + b * 0.125054068802017f;
    yuv[1] = r * 0.5f - g * 0.4541529f - b * 0.04584709f;
    yuv[2] = r * -0.081014709086133f - g * 0.272538676238785f + b * 0.353553390593274f;
}

void cvtt::Internal::ETCComputer::ConvertFromFakeBT709(MFloat rgb[3], const MFloat yuv[3])
{
    MFloat yy = yuv[0] * 0.57735026466774571071f;
    MFloat u = yuv[1];
    MFloat v = yuv[2];

    rgb[0] = yy + u * 1.5748000207960953486f;
    rgb[1] = yy - u * 0.46812425854364753669f - v * 0.26491652528157560861f;
    rgb[2] = yy + v * 2.6242146882856944069f;
}


void cvtt::Internal::ETCComputer::QuantizeETC2Alpha(int tableIndex, const MUInt15& value, const MUInt15& baseValue, const MUInt15& multiplier, bool is11Bit, bool isSigned, MUInt15& outIndexes, MUInt15& outQuantizedValues)
{
    MSInt16 offset = ParallelMath::LosslessCast<MSInt16>::Cast(value) - ParallelMath::LosslessCast<MSInt16>::Cast(baseValue);
    MSInt16 offsetTimes2 = offset + offset;

    // ETC2's offset tables all have a reflect about 0.5*multiplier
    MSInt16 offsetAboutReflectorTimes2 = offsetTimes2 + ParallelMath::LosslessCast<MSInt16>::Cast(multiplier);

    MUInt15 absOffsetAboutReflectorTimes2 = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Abs(offsetAboutReflectorTimes2));
    MUInt15 lookupIndex = ParallelMath::RightShift(absOffsetAboutReflectorTimes2, 1);

    MUInt15 positiveIndex;
    MUInt15 positiveOffsetUnmultiplied;
    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        uint16_t blockLookupIndex = ParallelMath::Extract(lookupIndex, block) / ParallelMath::Extract(multiplier, block);
        if (blockLookupIndex >= Tables::ETC2::g_alphaRoundingTableWidth)
            blockLookupIndex = Tables::ETC2::g_alphaRoundingTableWidth - 1;
        uint16_t index = Tables::ETC2::g_alphaRoundingTables[tableIndex][blockLookupIndex];
        ParallelMath::PutUInt15(positiveIndex, block, index);
        ParallelMath::PutUInt15(positiveOffsetUnmultiplied, block, Tables::ETC2::g_alphaModifierTablePositive[tableIndex][index]);

        // TODO: This is suboptimal when the offset is capped.  We should detect 0 and 255 values and always map them to the maximum offsets.
        // Doing that will also affect refinement though.
    }

    MSInt16 signBits = ParallelMath::RightShift(offsetAboutReflectorTimes2, 15);
    MSInt16 offsetUnmultiplied = ParallelMath::LosslessCast<MSInt16>::Cast(positiveOffsetUnmultiplied) ^ signBits;
    MSInt16 quantizedOffset = ParallelMath::CompactMultiply(offsetUnmultiplied, multiplier);

    MSInt16 offsetValue = ParallelMath::LosslessCast<MSInt16>::Cast(baseValue) + quantizedOffset;

    if (is11Bit)
    {
        if (isSigned)
            outQuantizedValues = ParallelMath::Min(ParallelMath::MakeUInt15(2047), ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(ParallelMath::MakeSInt16(1), offsetValue)));
        else
            outQuantizedValues = ParallelMath::Min(ParallelMath::MakeUInt15(2047), ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(ParallelMath::MakeSInt16(0), offsetValue)));
    }
    else
        outQuantizedValues = ParallelMath::Min(ParallelMath::MakeUInt15(255), ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::Max(ParallelMath::MakeSInt16(0), offsetValue)));

    MUInt15 indexSub = ParallelMath::LosslessCast<MUInt15>::Cast(signBits) & ParallelMath::MakeUInt15(4);

    outIndexes = positiveIndex + ParallelMath::MakeUInt15(4) - indexSub;
}


void cvtt::Internal::ETCComputer::EmitTModeBlock(uint8_t *outputBuffer, const ParallelMath::ScalarUInt16 lineColor[3], const ParallelMath::ScalarUInt16 isolatedColor[3], int32_t packedSelectors, ParallelMath::ScalarUInt16 table, bool opaque)
{
    static const int selectorOrder[] = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 };

    uint32_t lowBits = 0;
    uint32_t highBits = 0;

    int rh = ((isolatedColor[0] >> 2) & 3);
    int rl = (isolatedColor[0] & 3);

    if (rh + rl < 4)
    {
        // Overflow low
        highBits |= 1 << (58 - 32);
    }
    else
    {
        // Overflow high
        highBits |= 7 << (61 - 32);
    }

    highBits |= rh << (59 - 32);
    highBits |= rl << (56 - 32);
    highBits |= isolatedColor[1] << (52 - 32);
    highBits |= isolatedColor[2] << (48 - 32);
    highBits |= lineColor[0] << (44 - 32);
    highBits |= lineColor[1] << (40 - 32);
    highBits |= lineColor[2] << (36 - 32);
    highBits |= ((table >> 1) & 3) << (34 - 32);
    if (opaque)
        highBits |= 1 << (33 - 32);
    highBits |= (table & 1) << (32 - 32);

    for (int px = 0; px < 16; px++)
    {
        int sel = (packedSelectors >> (2 * selectorOrder[px])) & 3;
        if ((sel & 0x1) != 0)
            lowBits |= (1 << px);
        if ((sel & 0x2) != 0)
            lowBits |= (1 << (16 + px));
    }

    for (int i = 0; i < 4; i++)
        outputBuffer[i] = (highBits >> (24 - i * 8)) & 0xff;
    for (int i = 0; i < 4; i++)
        outputBuffer[i + 4] = (lowBits >> (24 - i * 8)) & 0xff;
}

void cvtt::Internal::ETCComputer::EmitHModeBlock(uint8_t *outputBuffer, const ParallelMath::ScalarUInt16 blockColors[2], ParallelMath::ScalarUInt16 sectorBits, ParallelMath::ScalarUInt16 signBits, ParallelMath::ScalarUInt16 table, bool opaque)
{
    if (blockColors[0] == blockColors[1])
    {
        // Base colors are the same.
        // If the table low bit isn't 1, then we can't encode this, because swapping the block colors will have no effect
        // on their order.
        // Instead, we encode this as T mode where all of the indexes are on the line.

        ParallelMath::ScalarUInt16 lineColor[3];
        ParallelMath::ScalarUInt16 isolatedColor[3];

        lineColor[0] = isolatedColor[0] = (blockColors[0] >> 10) & 0x1f;
        lineColor[1] = isolatedColor[1] = (blockColors[0] >> 5) & 0x1f;
        lineColor[2] = isolatedColor[2] = (blockColors[0] >> 0) & 0x1f;

        int32_t packedSelectors = 0x55555555;
        for (int px = 0; px < 16; px++)
            packedSelectors |= ((signBits >> px) & 1) << ((px * 2) + 1);

        EmitTModeBlock(outputBuffer, lineColor, isolatedColor, packedSelectors, table, opaque);
        return;
    }

    static const int selectorOrder[] = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 };

    int16_t colors[2][3];
    for (int sector = 0; sector < 2; sector++)
    {
        for (int ch = 0; ch < 3; ch++)
            colors[sector][ch] = (blockColors[sector] >> ((2 - ch) * 5)) & 15;
    }

    uint32_t lowBits = 0;
    uint32_t highBits = 0;

    if (((table & 1) == 1) != (blockColors[0] > blockColors[1]))
    {
        for (int ch = 0; ch < 3; ch++)
            std::swap(colors[0][ch], colors[1][ch]);
        sectorBits ^= 0xffff;
    }

    int r1 = colors[0][0];
    int g1a = colors[0][1] >> 1;
    int g1b = (colors[0][1] & 1);
    int b1a = colors[0][2] >> 3;
    int b1b = colors[0][2] & 7;
    int r2 = colors[1][0];
    int g2 = colors[1][1];
    int b2 = colors[1][2];

    // Avoid overflowing R
    if ((g1a & 4) != 0 && r1 + g1a < 8)
        highBits |= 1 << (63 - 32);

    int fakeDG = b1b >> 1;
    int fakeG = b1a | (g1b << 1);

    if (fakeG + fakeDG < 4)
    {
        // Overflow low
        highBits |= 1 << (50 - 32);
    }
    else
    {
        // Overflow high
        highBits |= 7 << (53 - 32);
    }

    int da = (table >> 2) & 1;
    int db = (table >> 1) & 1;

    highBits |= r1 << (59 - 32);
    highBits |= g1a << (56 - 32);
    highBits |= g1b << (52 - 32);
    highBits |= b1a << (51 - 32);
    highBits |= b1b << (47 - 32);
    highBits |= r2 << (43 - 32);
    highBits |= g2 << (39 - 32);
    highBits |= b2 << (35 - 32);
    highBits |= da << (34 - 32);
    if (opaque)
        highBits |= 1 << (33 - 32);
    highBits |= db << (32 - 32);

    for (int px = 0; px < 16; px++)
    {
        int sectorBit = (sectorBits >> selectorOrder[px]) & 1;
        int signBit = (signBits >> selectorOrder[px]) & 1;

        lowBits |= (signBit << px);
        lowBits |= (sectorBit << (16 + px));
    }

    uint8_t *output = outputBuffer;

    for (int i = 0; i < 4; i++)
        output[i] = (highBits >> (24 - i * 8)) & 0xff;
    for (int i = 0; i < 4; i++)
        output[i + 4] = (lowBits >> (24 - i * 8)) & 0xff;
}

void cvtt::Internal::ETCComputer::EmitETC1Block(uint8_t *outputBuffer, int blockBestFlip, int blockBestD, const int blockBestColors[2][3], const int blockBestTables[2], const ParallelMath::ScalarUInt16 blockBestSelectors[2], bool transparent)
{
    uint32_t highBits = 0;
    uint32_t lowBits = 0;

    if (blockBestD == 0)
    {
        highBits |= blockBestColors[0][0] << 28;
        highBits |= blockBestColors[1][0] << 24;
        highBits |= blockBestColors[0][1] << 20;
        highBits |= blockBestColors[1][1] << 16;
        highBits |= blockBestColors[0][2] << 12;
        highBits |= blockBestColors[1][2] << 8;
    }
    else
    {
        highBits |= blockBestColors[0][0] << 27;
        highBits |= ((blockBestColors[1][0] - blockBestColors[0][0]) & 7) << 24;
        highBits |= blockBestColors[0][1] << 19;
        highBits |= ((blockBestColors[1][1] - blockBestColors[0][1]) & 7) << 16;
        highBits |= blockBestColors[0][2] << 11;
        highBits |= ((blockBestColors[1][2] - blockBestColors[0][2]) & 7) << 8;
    }

    highBits |= (blockBestTables[0] << 5);
    highBits |= (blockBestTables[1] << 2);
    if (!transparent)
        highBits |= (blockBestD << 1);
    highBits |= blockBestFlip;

    const uint8_t modifierCodes[4] = { 3, 2, 0, 1 };

    uint8_t unpackedSelectors[16];
    uint8_t unpackedSelectorCodes[16];
    for (int sector = 0; sector < 2; sector++)
    {
        int blockSectorBestSelectors = blockBestSelectors[sector];

        for (int px = 0; px < 8; px++)
        {
            int selector = (blockSectorBestSelectors >> (2 * px)) & 3;
            unpackedSelectorCodes[g_flipTables[blockBestFlip][sector][px]] = modifierCodes[selector];
            unpackedSelectors[g_flipTables[blockBestFlip][sector][px]] = selector;
        }
    }

    const int pixelSelectorOrder[16] = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 };

    int lowBitOffset = 0;
    for (int sb = 0; sb < 2; sb++)
        for (int px = 0; px < 16; px++)
            lowBits |= ((unpackedSelectorCodes[pixelSelectorOrder[px]] >> sb) & 1) << (px + sb * 16);

    for (int i = 0; i < 4; i++)
        outputBuffer[i] = (highBits >> (24 - i * 8)) & 0xff;
    for (int i = 0; i < 4; i++)
        outputBuffer[i + 4] = (lowBits >> (24 - i * 8)) & 0xff;
}

void cvtt::Internal::ETCComputer::CompressETC1BlockInternal(MFloat &bestTotalError, uint8_t *outputBuffer, const MUInt15 pixels[16][3], const MFloat preWeightedPixels[16][3], DifferentialResolveStorage &drs, const Options &options, bool punchthrough)
{
	int numTries = 0;

    MUInt15 zeroU15 = ParallelMath::MakeUInt15(0);
    MUInt16 zeroU16 = ParallelMath::MakeUInt16(0);

    MUInt15 bestColors[2] = { zeroU15, zeroU15 };
    MUInt16 bestSelectors[2] = { zeroU16, zeroU16 };
    MUInt15 bestTables[2] = { zeroU15, zeroU15 };
    MUInt15 bestFlip = zeroU15;
    MUInt15 bestD = zeroU15;

    MUInt15 sectorPixels[2][2][8][3];
    MFloat sectorPreWeightedPixels[2][2][8][3];
    MUInt15 sectorCumulative[2][2][3];

    ParallelMath::Int16CompFlag bestIsThisMode = ParallelMath::MakeBoolInt16(false);

    for (int flip = 0; flip < 2; flip++)
	{
		for (int sector = 0; sector < 2; sector++)
		{
			for (int ch = 0; ch < 3; ch++)
				sectorCumulative[flip][sector][ch] = zeroU15;

			for (int px = 0; px < 8; px++)
			{
				for (int ch = 0; ch < 3; ch++)
				{
					MUInt15 pixelChannelValue = pixels[g_flipTables[flip][sector][px]][ch];
					sectorPixels[flip][sector][px][ch] = pixelChannelValue;
                    sectorPreWeightedPixels[flip][sector][px][ch] = preWeightedPixels[g_flipTables[flip][sector][px]][ch];
					sectorCumulative[flip][sector][ch] = sectorCumulative[flip][sector][ch] + pixelChannelValue;
				}
			}
		}
	}

	static const MSInt16 modifierTables[8][4] =
	{
		{ ParallelMath::MakeSInt16(-8), ParallelMath::MakeSInt16(-2), ParallelMath::MakeSInt16(2), ParallelMath::MakeSInt16(8) },
		{ ParallelMath::MakeSInt16(-17), ParallelMath::MakeSInt16(-5), ParallelMath::MakeSInt16(5), ParallelMath::MakeSInt16(17) },
		{ ParallelMath::MakeSInt16(-29), ParallelMath::MakeSInt16(-9), ParallelMath::MakeSInt16(9), ParallelMath::MakeSInt16(29) },
		{ ParallelMath::MakeSInt16(-42), ParallelMath::MakeSInt16(-13), ParallelMath::MakeSInt16(13), ParallelMath::MakeSInt16(42) },
		{ ParallelMath::MakeSInt16(-60), ParallelMath::MakeSInt16(-18), ParallelMath::MakeSInt16(18), ParallelMath::MakeSInt16(60) },
		{ ParallelMath::MakeSInt16(-80), ParallelMath::MakeSInt16(-24), ParallelMath::MakeSInt16(24), ParallelMath::MakeSInt16(80) },
		{ ParallelMath::MakeSInt16(-106), ParallelMath::MakeSInt16(-33), ParallelMath::MakeSInt16(33), ParallelMath::MakeSInt16(106) },
		{ ParallelMath::MakeSInt16(-183), ParallelMath::MakeSInt16(-47), ParallelMath::MakeSInt16(47), ParallelMath::MakeSInt16(183) },
	};

    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);

    int minD = punchthrough ? 1 : 0;

	for (int flip = 0; flip < 2; flip++)
	{
		drs.diffNumAttempts[0] = drs.diffNumAttempts[1] = zeroU15;

		MFloat bestIndError[2] = { ParallelMath::MakeFloat(FLT_MAX), ParallelMath::MakeFloat(FLT_MAX) };
		MUInt16 bestIndSelectors[2] = { ParallelMath::MakeUInt16(0), ParallelMath::MakeUInt16(0) };
		MUInt15 bestIndColors[2] = { zeroU15, zeroU15 };
		MUInt15 bestIndTable[2] = { zeroU15, zeroU15 };

		for (int d = minD; d < 2; d++)
		{
			for (int sector = 0; sector < 2; sector++)
			{
				const int16_t *potentialOffsets = cvtt::Tables::ETC1::g_potentialOffsets4;

				for (int table = 0; table < 8; table++)
				{
					int16_t numOffsets = *potentialOffsets++;

					MUInt15 possibleColors[cvtt::Tables::ETC1::g_maxPotentialOffsets];

                    MUInt15 quantized[3];
                    for (int oi = 0; oi < numOffsets; oi++)
                    {
                        if (!isFakeBT709)
                        {
						    for (int ch = 0; ch < 3; ch++)
						    {
                                // cu is in range 0..2040
                                MUInt15 cu15 = ParallelMath::Min(
                                    ParallelMath::MakeUInt15(2040),
                                    ParallelMath::ToUInt15(
                                        ParallelMath::Max(
                                            ParallelMath::MakeSInt16(0),
                                            ParallelMath::LosslessCast<MSInt16>::Cast(sectorCumulative[flip][sector][ch]) + ParallelMath::MakeSInt16(potentialOffsets[oi])
                                        )
                                    )
                                );

                                if (d == 1)
                                {
                                    //quantized[ch] = (cu * 31 + (cu >> 3) + 1024) >> 11;
                                    quantized[ch] = ParallelMath::ToUInt15(
                                        ParallelMath::RightShift(
                                            (ParallelMath::LosslessCast<MUInt16>::Cast(cu15) << 5) - ParallelMath::LosslessCast<MUInt16>::Cast(cu15) + ParallelMath::LosslessCast<MUInt16>::Cast(ParallelMath::RightShift(cu15, 3)) + ParallelMath::MakeUInt16(1024)
                                            , 11)
                                        );
                                }
                                else
                                {
                                    //quantized[ch] = (cu * 30 + (cu >> 3) + 2048) >> 12;
                                    quantized[ch] = ParallelMath::ToUInt15(
                                        ParallelMath::RightShift(
                                        (ParallelMath::LosslessCast<MUInt16>::Cast(cu15) << 5) - ParallelMath::LosslessCast<MUInt16>::Cast(cu15 << 1) + ParallelMath::LosslessCast<MUInt16>::Cast(ParallelMath::RightShift(cu15, 3)) + ParallelMath::MakeUInt16(2048)
                                            , 12)
                                    );
                                }
						    }
                        }
                        else
                        {
                            MUInt15 offsetCumulative[3];
						    for (int ch = 0; ch < 3; ch++)
						    {
                                // cu is in range 0..2040
                                MUInt15 cu15 = ParallelMath::Min(
                                    ParallelMath::MakeUInt15(2040),
                                    ParallelMath::ToUInt15(
                                        ParallelMath::Max(
                                            ParallelMath::MakeSInt16(0),
                                            ParallelMath::LosslessCast<MSInt16>::Cast(sectorCumulative[flip][sector][ch]) + ParallelMath::MakeSInt16(potentialOffsets[oi])
                                        )
                                    )
                                );

                                offsetCumulative[ch] = cu15;
						    }

                            if ((options.flags & cvtt::Flags::ETC_FakeBT709Accurate) != 0)
                                ResolveHalfBlockFakeBT709RoundingAccurate(quantized, offsetCumulative, d == 1);
                            else
                                ResolveHalfBlockFakeBT709RoundingFast(quantized, offsetCumulative, d == 1);
                        }

						possibleColors[oi] = quantized[0] | (quantized[1] << 5) | (quantized[2] << 10);
					}

					potentialOffsets += numOffsets;

                    ParallelMath::UInt15 numUniqueColors;
                    for (int block = 0; block < ParallelMath::ParallelSize; block++)
                    {
                        uint16_t blockNumUniqueColors = 1;
                        for (int i = 1; i < numOffsets; i++)
                        {
                            uint16_t color = ParallelMath::Extract(possibleColors[i], block);
                            if (color != ParallelMath::Extract(possibleColors[blockNumUniqueColors - 1], block))
                                ParallelMath::PutUInt15(possibleColors[blockNumUniqueColors++], block, color);
                        }

                        ParallelMath::PutUInt15(numUniqueColors, block, blockNumUniqueColors);
                    }

                    int maxUniqueColors = ParallelMath::Extract(numUniqueColors, 0);
                    for (int block = 1; block < ParallelMath::ParallelSize; block++)
                        maxUniqueColors = std::max<int>(maxUniqueColors, ParallelMath::Extract(numUniqueColors, block));

                    for (int block = 0; block < ParallelMath::ParallelSize; block++)
                    {
                        uint16_t fillColor = ParallelMath::Extract(possibleColors[0], block);
                        for (int i = ParallelMath::Extract(numUniqueColors, block); i < maxUniqueColors; i++)
                            ParallelMath::PutUInt15(possibleColors[i], block, fillColor);
                    }

					for (int i = 0; i < maxUniqueColors; i++)
					{
						MFloat error = ParallelMath::MakeFloatZero();
						MUInt16 selectors = ParallelMath::MakeUInt16(0);
                        MUInt15 quantized = possibleColors[i];
						TestHalfBlock(error, selectors, quantized, sectorPixels[flip][sector], sectorPreWeightedPixels[flip][sector], modifierTables[table], d == 1, options);

						if (d == 0)
						{
                            ParallelMath::Int16CompFlag errorBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(error, bestIndError[sector]));
							if (ParallelMath::AnySet(errorBetter))
							{
								bestIndError[sector] = ParallelMath::Min(error, bestIndError[sector]);
								ParallelMath::ConditionalSet(bestIndSelectors[sector], errorBetter, selectors);
                                ParallelMath::ConditionalSet(bestIndColors[sector], errorBetter, quantized);
                                ParallelMath::ConditionalSet(bestIndTable[sector], errorBetter, ParallelMath::MakeUInt15(table));
							}
						}
						else
						{
                            ParallelMath::Int16CompFlag isInBounds = ParallelMath::Less(ParallelMath::MakeUInt15(i), numUniqueColors);

							MUInt15 storageIndexes = drs.diffNumAttempts[sector];
                            drs.diffNumAttempts[sector] = drs.diffNumAttempts[sector] + ParallelMath::SelectOrZero(isInBounds, ParallelMath::MakeUInt15(1));

                            for (int block = 0; block < ParallelMath::ParallelSize; block++)
                            {
                                int storageIndex = ParallelMath::Extract(storageIndexes, block);

                                ParallelMath::PutFloat(drs.diffErrors[sector][storageIndex], block, ParallelMath::Extract(error, block));
                                ParallelMath::PutUInt16(drs.diffSelectors[sector][storageIndex], block, ParallelMath::Extract(selectors, block));
                                ParallelMath::PutUInt15(drs.diffColors[sector][storageIndex], block, ParallelMath::Extract(quantized, block));
                                ParallelMath::PutUInt15(drs.diffTables[sector][storageIndex], block, table);
                            }
						}
					}
				}
			}

			if (d == 0)
			{
				MFloat bestIndErrorTotal = bestIndError[0] + bestIndError[1];
                ParallelMath::Int16CompFlag errorBetter = ParallelMath::FloatFlagToInt16(ParallelMath::Less(bestIndErrorTotal, bestTotalError));
				if (ParallelMath::AnySet(errorBetter))
				{
                    bestIsThisMode = bestIsThisMode | errorBetter;

					bestTotalError = ParallelMath::Min(bestTotalError, bestIndErrorTotal);
					ParallelMath::ConditionalSet(bestFlip, errorBetter, ParallelMath::MakeUInt15(flip));
                    ParallelMath::ConditionalSet(bestD, errorBetter, ParallelMath::MakeUInt15(d));
					for (int sector = 0; sector < 2; sector++)
					{
                        ParallelMath::ConditionalSet(bestColors[sector], errorBetter, bestIndColors[sector]);
                        ParallelMath::ConditionalSet(bestSelectors[sector], errorBetter, bestIndSelectors[sector]);
                        ParallelMath::ConditionalSet(bestTables[sector], errorBetter, bestIndTable[sector]);
					}
				}
			}
			else
			{
                ParallelMath::Int16CompFlag canIgnoreSector[2] = { ParallelMath::MakeBoolInt16(false), ParallelMath::MakeBoolInt16(false) };
                FindBestDifferentialCombination(flip, d, canIgnoreSector, bestIsThisMode, bestTotalError, bestFlip, bestD, bestColors, bestSelectors, bestTables, drs);
			}
		}
	}

    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        if (!ParallelMath::Extract(bestIsThisMode, block))
            continue;

        uint32_t highBits = 0;
        uint32_t lowBits = 0;

        int blockBestFlip = ParallelMath::Extract(bestFlip, block);
        int blockBestD = ParallelMath::Extract(bestD, block);
        int blockBestTables[2] = { ParallelMath::Extract(bestTables[0], block), ParallelMath::Extract(bestTables[1], block) };
        ParallelMath::ScalarUInt16 blockBestSelectors[2] = { ParallelMath::Extract(bestSelectors[0], block), ParallelMath::Extract(bestSelectors[1], block) };

        int colors[2][3];
        for (int sector = 0; sector < 2; sector++)
        {
            int sectorColor = ParallelMath::Extract(bestColors[sector], block);
            for (int ch = 0; ch < 3; ch++)
                colors[sector][ch] = (sectorColor >> (ch * 5)) & 31;
        }

        EmitETC1Block(outputBuffer + block * 8, blockBestFlip, blockBestD, colors, blockBestTables, blockBestSelectors, false);
    }
}


void cvtt::Internal::ETCComputer::CompressETC1PunchthroughBlockInternal(MFloat &bestTotalError, uint8_t *outputBuffer, const MUInt15 pixels[16][3], const MFloat preWeightedPixels[16][3], const ParallelMath::Int16CompFlag isTransparent[16], DifferentialResolveStorage &drs, const Options &options)
{
	int numTries = 0;

    MUInt15 zeroU15 = ParallelMath::MakeUInt15(0);
    MUInt16 zeroU16 = ParallelMath::MakeUInt16(0);

    MUInt15 bestColors[2] = { zeroU15, zeroU15 };
    MUInt16 bestSelectors[2] = { zeroU16, zeroU16 };
    MUInt15 bestTables[2] = { zeroU15, zeroU15 };
    MUInt15 bestFlip = zeroU15;

    MUInt15 sectorPixels[2][2][8][3];
    ParallelMath::Int16CompFlag sectorTransparent[2][2][8];
    MFloat sectorPreWeightedPixels[2][2][8][3];
    MUInt15 sectorCumulative[2][2][3];

    ParallelMath::Int16CompFlag bestIsThisMode = ParallelMath::MakeBoolInt16(false);

    for (int flip = 0; flip < 2; flip++)
	{
		for (int sector = 0; sector < 2; sector++)
		{
			for (int ch = 0; ch < 3; ch++)
				sectorCumulative[flip][sector][ch] = zeroU15;

			for (int px = 0; px < 8; px++)
			{
				for (int ch = 0; ch < 3; ch++)
				{
					MUInt15 pixelChannelValue = pixels[g_flipTables[flip][sector][px]][ch];
					sectorPixels[flip][sector][px][ch] = pixelChannelValue;
                    sectorPreWeightedPixels[flip][sector][px][ch] = preWeightedPixels[g_flipTables[flip][sector][px]][ch];
					sectorCumulative[flip][sector][ch] = sectorCumulative[flip][sector][ch] + pixelChannelValue;
				}

                sectorTransparent[flip][sector][px] = isTransparent[g_flipTables[flip][sector][px]];
			}
		}
	}

	static const MUInt15 modifiers[8] =
	{
		ParallelMath::MakeUInt15(8),
		ParallelMath::MakeUInt15(17),
		ParallelMath::MakeUInt15(29),
		ParallelMath::MakeUInt15(42),
		ParallelMath::MakeUInt15(60),
		ParallelMath::MakeUInt15(80),
		ParallelMath::MakeUInt15(106),
		ParallelMath::MakeUInt15(183),
	};

    bool isFakeBT709 = ((options.flags & cvtt::Flags::ETC_UseFakeBT709) != 0);

    const int maxSectorCumulativeOffsets = 17;

	for (int flip = 0; flip < 2; flip++)
	{
        ParallelMath::Int16CompFlag canIgnoreSector[2] = { ParallelMath::MakeBoolInt16(true), ParallelMath::MakeBoolInt16(false) };

        for (int sector = 0; sector < 2; sector++)
            for (int px = 0; px < 8; px++)
                canIgnoreSector[sector] = canIgnoreSector[sector] & sectorTransparent[flip][sector][px];

		drs.diffNumAttempts[0] = drs.diffNumAttempts[1] = zeroU15;

		for (int sector = 0; sector < 2; sector++)
		{
            MUInt15 sectorNumOpaque = ParallelMath::MakeUInt15(0);
            for (int px = 0; px < 8; px++)
                sectorNumOpaque = sectorNumOpaque + ParallelMath::SelectOrZero(sectorTransparent[flip][sector][px], ParallelMath::MakeUInt15(1));

            int sectorMaxOpaque = 0;
            for (int block = 0; block < ParallelMath::ParallelSize; block++)
                sectorMaxOpaque = std::max<int>(sectorMaxOpaque, ParallelMath::Extract(sectorNumOpaque, block));

            int sectorNumOpaqueMultipliers = sectorMaxOpaque * 2 + 1;

            MUInt15 sectorNumOpaqueDenominator = ParallelMath::Max(ParallelMath::MakeUInt15(1), sectorNumOpaque) << 8;
            MUInt15 sectorNumOpaqueAddend = sectorNumOpaque << 7;

            MSInt16 sectorNumOpaqueSigned = ParallelMath::LosslessCast<MSInt16>::Cast(sectorNumOpaque);
            MSInt16 negSectorNumOpaqueSigned = ParallelMath::MakeSInt16(0) - sectorNumOpaqueSigned;

            MUInt15 sectorCumulativeMax = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::CompactMultiply(ParallelMath::MakeUInt15(255), sectorNumOpaque));

			for (int table = 0; table < 8; table++)
			{
				MUInt15 possibleColors[maxSectorCumulativeOffsets];

                MUInt15 quantized[3];
                for (int om = -sectorMaxOpaque; om <= sectorMaxOpaque; om++)
                {
                    MSInt16 clampedOffsetMult = ParallelMath::Max(ParallelMath::Min(ParallelMath::MakeSInt16(om), sectorNumOpaqueSigned), negSectorNumOpaqueSigned);
                    MSInt16 offset = ParallelMath::CompactMultiply(clampedOffsetMult, modifiers[table]);

                    for (int ch = 0; ch < 3; ch++)
                    {
                        // cu is in range 0..255*numOpaque (at most 0..2040)
                        MUInt15 cu15 = ParallelMath::Min(
                            sectorCumulativeMax,
                            ParallelMath::ToUInt15(
                                ParallelMath::Max(
                                    ParallelMath::MakeSInt16(0),
                                    ParallelMath::LosslessCast<MSInt16>::Cast(sectorCumulative[flip][sector][ch]) + offset
                                )
                            )
                        );

                        //quantized[ch] = (cu * 31 + (cu >> 3) + (numOpaque * 128)) / (numOpaque * 256)
                        MUInt16 cuTimes31 = (ParallelMath::LosslessCast<MUInt16>::Cast(cu15) << 5) - ParallelMath::LosslessCast<MUInt16>::Cast(cu15);
                        MUInt15 cuDiv8 = ParallelMath::RightShift(cu15, 3);
                        MUInt16 numerator = cuTimes31 + ParallelMath::LosslessCast<MUInt16>::Cast(cuDiv8 + sectorNumOpaqueAddend);
                        for (int block = 0; block < ParallelMath::ParallelSize; block++)
                            ParallelMath::PutUInt15(quantized[ch], block, ParallelMath::Extract(numerator, block) / ParallelMath::Extract(sectorNumOpaqueDenominator, block));
                    }

					possibleColors[om + sectorMaxOpaque] = quantized[0] | (quantized[1] << 5) | (quantized[2] << 10);
				}

                ParallelMath::UInt15 numUniqueColors;
                for (int block = 0; block < ParallelMath::ParallelSize; block++)
                {
                    uint16_t blockNumUniqueColors = 1;
                    for (int i = 1; i < sectorNumOpaqueMultipliers; i++)
                    {
                        uint16_t color = ParallelMath::Extract(possibleColors[i], block);
                        if (color != ParallelMath::Extract(possibleColors[blockNumUniqueColors - 1], block))
                            ParallelMath::PutUInt15(possibleColors[blockNumUniqueColors++], block, color);
                    }

                    ParallelMath::PutUInt15(numUniqueColors, block, blockNumUniqueColors);
                }

                int maxUniqueColors = ParallelMath::Extract(numUniqueColors, 0);
                for (int block = 1; block < ParallelMath::ParallelSize; block++)
                    maxUniqueColors = std::max<int>(maxUniqueColors, ParallelMath::Extract(numUniqueColors, block));

                for (int block = 0; block < ParallelMath::ParallelSize; block++)
                {
                    uint16_t fillColor = ParallelMath::Extract(possibleColors[0], block);
                    for (int i = ParallelMath::Extract(numUniqueColors, block); i < maxUniqueColors; i++)
                        ParallelMath::PutUInt15(possibleColors[i], block, fillColor);
                }

				for (int i = 0; i < maxUniqueColors; i++)
				{
					MFloat error = ParallelMath::MakeFloatZero();
					MUInt16 selectors = ParallelMath::MakeUInt16(0);
                    MUInt15 quantized = possibleColors[i];
					TestHalfBlockPunchthrough(error, selectors, quantized, sectorPixels[flip][sector], sectorPreWeightedPixels[flip][sector], sectorTransparent[flip][sector], modifiers[table], options);

                    ParallelMath::Int16CompFlag isInBounds = ParallelMath::Less(ParallelMath::MakeUInt15(i), numUniqueColors);

					MUInt15 storageIndexes = drs.diffNumAttempts[sector];
                    drs.diffNumAttempts[sector] = drs.diffNumAttempts[sector] + ParallelMath::SelectOrZero(isInBounds, ParallelMath::MakeUInt15(1));

                    for (int block = 0; block < ParallelMath::ParallelSize; block++)
                    {
                        int storageIndex = ParallelMath::Extract(storageIndexes, block);

                        ParallelMath::PutFloat(drs.diffErrors[sector][storageIndex], block, ParallelMath::Extract(error, block));
                        ParallelMath::PutUInt16(drs.diffSelectors[sector][storageIndex], block, ParallelMath::Extract(selectors, block));
                        ParallelMath::PutUInt15(drs.diffColors[sector][storageIndex], block, ParallelMath::Extract(quantized, block));
                        ParallelMath::PutUInt15(drs.diffTables[sector][storageIndex], block, table);
                    }
                }
            }
        }

        MUInt15 bestDDummy = ParallelMath::MakeUInt15(0);
        FindBestDifferentialCombination(flip, 1, canIgnoreSector, bestIsThisMode, bestTotalError, bestFlip, bestDDummy, bestColors, bestSelectors, bestTables, drs);
	}

    for (int block = 0; block < ParallelMath::ParallelSize; block++)
    {
        if (!ParallelMath::Extract(bestIsThisMode, block))
            continue;

        int blockBestColors[2][3];
        int blockBestTables[2];
        ParallelMath::ScalarUInt16 blockBestSelectors[2];
        for (int sector = 0; sector < 2; sector++)
        {
            int sectorColor = ParallelMath::Extract(bestColors[sector], block);
            for (int ch = 0; ch < 3; ch++)
                blockBestColors[sector][ch] = (sectorColor >> (ch * 5)) & 31;

            blockBestTables[sector] = ParallelMath::Extract(bestTables[sector], block);
            blockBestSelectors[sector] = ParallelMath::Extract(bestSelectors[sector], block);
        }

        EmitETC1Block(outputBuffer + block * 8, ParallelMath::Extract(bestFlip, block), 1, blockBestColors, blockBestTables, blockBestSelectors, true);
    }
}


cvtt::ETC1CompressionData *cvtt::Internal::ETCComputer::AllocETC1Data(cvtt::Kernels::allocFunc_t allocFunc, void *context)
{
    void *buffer = allocFunc(context, sizeof(cvtt::Internal::ETCComputer::ETC1CompressionDataInternal));
    if (!buffer)
        return NULL;
    new (buffer) cvtt::Internal::ETCComputer::ETC1CompressionDataInternal(context);
    return static_cast<ETC1CompressionData*>(buffer);
}

void cvtt::Internal::ETCComputer::ReleaseETC1Data(ETC1CompressionData *compressionData, cvtt::Kernels::freeFunc_t freeFunc)
{
    cvtt::Internal::ETCComputer::ETC1CompressionDataInternal* internalData = static_cast<cvtt::Internal::ETCComputer::ETC1CompressionDataInternal*>(compressionData);
    void *context = internalData->m_context;
    internalData->~ETC1CompressionDataInternal();
    freeFunc(context, compressionData, sizeof(cvtt::Internal::ETCComputer::ETC1CompressionDataInternal));
}

cvtt::ETC2CompressionData *cvtt::Internal::ETCComputer::AllocETC2Data(cvtt::Kernels::allocFunc_t allocFunc, void *context, const cvtt::Options &options)
{
    void *buffer = allocFunc(context, sizeof(cvtt::Internal::ETCComputer::ETC2CompressionDataInternal));
    if (!buffer)
        return NULL;
    new (buffer) cvtt::Internal::ETCComputer::ETC2CompressionDataInternal(context, options);
    return static_cast<ETC2CompressionData*>(buffer);
}

void cvtt::Internal::ETCComputer::ReleaseETC2Data(ETC2CompressionData *compressionData, cvtt::Kernels::freeFunc_t freeFunc)
{
    cvtt::Internal::ETCComputer::ETC2CompressionDataInternal* internalData = static_cast<cvtt::Internal::ETCComputer::ETC2CompressionDataInternal*>(compressionData);
    void *context = internalData->m_context;
    internalData->~ETC2CompressionDataInternal();
    freeFunc(context, compressionData, sizeof(cvtt::Internal::ETCComputer::ETC2CompressionDataInternal));
}

cvtt::Internal::ETCComputer::ETC2CompressionDataInternal::ETC2CompressionDataInternal(void *context, const cvtt::Options &options)
    : m_context(context)
{
    const float cd[3] = { options.redWeight, options.greenWeight, options.blueWeight };
    const float rotCD[3] = { cd[1], cd[2], cd[0] };

    const float offs = -(rotCD[0] * cd[0] + rotCD[1] * cd[1] + rotCD[2] * cd[2]) / (cd[0] * cd[0] + cd[1] * cd[1] + cd[2] * cd[2]);

    const float chromaAxis0[3] = { rotCD[0] + cd[0] * offs, rotCD[1] + cd[1] * offs, rotCD[2] + cd[2] * offs };

    const float chromaAxis1Unnormalized[3] =
    {
        chromaAxis0[1] * cd[2] - chromaAxis0[2] * cd[1],
        chromaAxis0[2] * cd[0] - chromaAxis0[0] * cd[2],
        chromaAxis0[0] * cd[1] - chromaAxis0[1] * cd[0]
    };

    const float ca0LengthSq = (chromaAxis0[0] * chromaAxis0[0] + chromaAxis0[1] * chromaAxis0[1] + chromaAxis0[2] * chromaAxis0[2]);
    const float ca1UNLengthSq = (chromaAxis1Unnormalized[0] * chromaAxis1Unnormalized[0] + chromaAxis1Unnormalized[1] * chromaAxis1Unnormalized[1] + chromaAxis1Unnormalized[2] * chromaAxis1Unnormalized[2]);
    const float lengthRatio = static_cast<float>(std::sqrt(ca0LengthSq / ca1UNLengthSq));

    const float chromaAxis1[3] = { chromaAxis1Unnormalized[0] * lengthRatio, chromaAxis1Unnormalized[1] * lengthRatio, chromaAxis1Unnormalized[2] * lengthRatio };

    for (int i = 0; i < 3; i++)
    {
        m_chromaSideAxis0[i] = chromaAxis0[i];
        m_chromaSideAxis1[i] = chromaAxis1[i];
    }
}

#endif