1054 lines
39 KiB
C++
1054 lines
39 KiB
C++
/*
|
|
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_S3TC.h"
|
|
|
|
#include "ConvectionKernels_AggregatedError.h"
|
|
#include "ConvectionKernels_BCCommon.h"
|
|
#include "ConvectionKernels_EndpointRefiner.h"
|
|
#include "ConvectionKernels_EndpointSelector.h"
|
|
#include "ConvectionKernels_IndexSelector.h"
|
|
#include "ConvectionKernels_UnfinishedEndpoints.h"
|
|
#include "ConvectionKernels_S3TC_SingleColor.h"
|
|
|
|
void cvtt::Internal::S3TCComputer::Init(MFloat& error)
|
|
{
|
|
error = ParallelMath::MakeFloat(FLT_MAX);
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::QuantizeTo6Bits(MUInt15& v)
|
|
{
|
|
MUInt15 reduced = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::RightShift(ParallelMath::CompactMultiply(v, ParallelMath::MakeUInt15(253)) + ParallelMath::MakeUInt16(512), 10));
|
|
v = (reduced << 2) | ParallelMath::RightShift(reduced, 4);
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::QuantizeTo5Bits(MUInt15& v)
|
|
{
|
|
MUInt15 reduced = ParallelMath::LosslessCast<MUInt15>::Cast(ParallelMath::RightShift(ParallelMath::CompactMultiply(v, ParallelMath::MakeUInt15(249)) + ParallelMath::MakeUInt16(1024), 11));
|
|
v = (reduced << 3) | ParallelMath::RightShift(reduced, 2);
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::QuantizeTo565(MUInt15 endPoint[3])
|
|
{
|
|
QuantizeTo5Bits(endPoint[0]);
|
|
QuantizeTo6Bits(endPoint[1]);
|
|
QuantizeTo5Bits(endPoint[2]);
|
|
}
|
|
|
|
cvtt::ParallelMath::Float cvtt::Internal::S3TCComputer::ParanoidFactorForSpan(const MSInt16& span)
|
|
{
|
|
return ParallelMath::Abs(ParallelMath::ToFloat(span)) * 0.03f;
|
|
}
|
|
|
|
cvtt::ParallelMath::Float cvtt::Internal::S3TCComputer::ParanoidDiff(const MUInt15& a, const MUInt15& b, const MFloat& d)
|
|
{
|
|
MFloat absDiff = ParallelMath::Abs(ParallelMath::ToFloat(ParallelMath::LosslessCast<MSInt16>::Cast(a) - ParallelMath::LosslessCast<MSInt16>::Cast(b)));
|
|
absDiff = absDiff + d;
|
|
return absDiff * absDiff;
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::TestSingleColor(uint32_t flags, const MUInt15 pixels[16][4], const MFloat floatPixels[16][4], int range, const float* channelWeights,
|
|
MFloat &bestError, MUInt15 bestEndpoints[2][3], MUInt15 bestIndexes[16], MUInt15 &bestRange, const ParallelMath::RoundTowardNearestForScope *rtn)
|
|
{
|
|
float channelWeightsSq[3];
|
|
|
|
for (int ch = 0; ch < 3; ch++)
|
|
channelWeightsSq[ch] = channelWeights[ch] * channelWeights[ch];
|
|
|
|
MUInt15 totals[3] = { ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(0) };
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
for (int ch = 0; ch < 3; ch++)
|
|
totals[ch] = totals[ch] + pixels[px][ch];
|
|
}
|
|
|
|
MUInt15 average[3];
|
|
for (int ch = 0; ch < 3; ch++)
|
|
average[ch] = ParallelMath::RightShift(totals[ch] + ParallelMath::MakeUInt15(8), 4);
|
|
|
|
const Tables::S3TCSC::TableEntry* rbTable = NULL;
|
|
const Tables::S3TCSC::TableEntry* gTable = NULL;
|
|
if (flags & cvtt::Flags::S3TC_Paranoid)
|
|
{
|
|
if (range == 4)
|
|
{
|
|
rbTable = Tables::S3TCSC::g_singleColor5_3_p;
|
|
gTable = Tables::S3TCSC::g_singleColor6_3_p;
|
|
}
|
|
else
|
|
{
|
|
assert(range == 3);
|
|
rbTable = Tables::S3TCSC::g_singleColor5_2_p;
|
|
gTable = Tables::S3TCSC::g_singleColor6_2_p;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (range == 4)
|
|
{
|
|
rbTable = Tables::S3TCSC::g_singleColor5_3;
|
|
gTable = Tables::S3TCSC::g_singleColor6_3;
|
|
}
|
|
else
|
|
{
|
|
assert(range == 3);
|
|
rbTable = Tables::S3TCSC::g_singleColor5_2;
|
|
gTable = Tables::S3TCSC::g_singleColor6_2;
|
|
}
|
|
}
|
|
|
|
MUInt15 interpolated[3];
|
|
MUInt15 eps[2][3];
|
|
MSInt16 spans[3];
|
|
for (int i = 0; i < ParallelMath::ParallelSize; i++)
|
|
{
|
|
for (int ch = 0; ch < 3; ch++)
|
|
{
|
|
uint16_t avg = ParallelMath::Extract(average[ch], i);
|
|
const Tables::S3TCSC::TableEntry& tableEntry = ((ch == 1) ? gTable[avg] : rbTable[avg]);
|
|
ParallelMath::PutUInt15(eps[0][ch], i, tableEntry.m_min);
|
|
ParallelMath::PutUInt15(eps[1][ch], i, tableEntry.m_max);
|
|
ParallelMath::PutUInt15(interpolated[ch], i, tableEntry.m_actualColor);
|
|
ParallelMath::PutSInt16(spans[ch], i, tableEntry.m_span);
|
|
}
|
|
}
|
|
|
|
MFloat error = ParallelMath::MakeFloatZero();
|
|
if (flags & cvtt::Flags::S3TC_Paranoid)
|
|
{
|
|
MFloat spanParanoidFactors[3];
|
|
for (int ch = 0; ch < 3; ch++)
|
|
spanParanoidFactors[ch] = ParanoidFactorForSpan(spans[ch]);
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
for (int ch = 0; ch < 3; ch++)
|
|
error = error + ParanoidDiff(interpolated[ch], pixels[px][ch], spanParanoidFactors[ch]) * channelWeightsSq[ch];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
for (int ch = 0; ch < 3; ch++)
|
|
error = error + ParallelMath::ToFloat(ParallelMath::SqDiffUInt8(interpolated[ch], pixels[px][ch])) * channelWeightsSq[ch];
|
|
}
|
|
}
|
|
|
|
ParallelMath::FloatCompFlag better = ParallelMath::Less(error, bestError);
|
|
ParallelMath::Int16CompFlag better16 = ParallelMath::FloatFlagToInt16(better);
|
|
|
|
if (ParallelMath::AnySet(better16))
|
|
{
|
|
bestError = ParallelMath::Min(bestError, error);
|
|
for (int epi = 0; epi < 2; epi++)
|
|
for (int ch = 0; ch < 3; ch++)
|
|
ParallelMath::ConditionalSet(bestEndpoints[epi][ch], better16, eps[epi][ch]);
|
|
|
|
MUInt15 vindexes = ParallelMath::MakeUInt15(1);
|
|
for (int px = 0; px < 16; px++)
|
|
ParallelMath::ConditionalSet(bestIndexes[px], better16, vindexes);
|
|
|
|
ParallelMath::ConditionalSet(bestRange, better16, ParallelMath::MakeUInt15(range));
|
|
}
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::TestEndpoints(uint32_t flags, const MUInt15 pixels[16][4], const MFloat floatPixels[16][4], const MFloat preWeightedPixels[16][4], const MUInt15 unquantizedEndPoints[2][3], int range, const float* channelWeights,
|
|
MFloat &bestError, MUInt15 bestEndpoints[2][3], MUInt15 bestIndexes[16], MUInt15 &bestRange, EndpointRefiner<3> *refiner, const ParallelMath::RoundTowardNearestForScope *rtn)
|
|
{
|
|
float channelWeightsSq[3];
|
|
|
|
for (int ch = 0; ch < 3; ch++)
|
|
channelWeightsSq[ch] = channelWeights[ch] * channelWeights[ch];
|
|
|
|
MUInt15 endPoints[2][3];
|
|
|
|
for (int ep = 0; ep < 2; ep++)
|
|
for (int ch = 0; ch < 3; ch++)
|
|
endPoints[ep][ch] = unquantizedEndPoints[ep][ch];
|
|
|
|
QuantizeTo565(endPoints[0]);
|
|
QuantizeTo565(endPoints[1]);
|
|
|
|
IndexSelector<3> selector;
|
|
selector.Init<false>(channelWeights, endPoints, range);
|
|
|
|
MUInt15 indexes[16];
|
|
|
|
MFloat paranoidFactors[3];
|
|
for (int ch = 0; ch < 3; ch++)
|
|
paranoidFactors[ch] = ParanoidFactorForSpan(ParallelMath::LosslessCast<MSInt16>::Cast(endPoints[0][ch]) - ParallelMath::LosslessCast<MSInt16>::Cast(endPoints[1][ch]));
|
|
|
|
MFloat error = ParallelMath::MakeFloatZero();
|
|
AggregatedError<3> aggError;
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
MUInt15 index = selector.SelectIndexLDR(floatPixels[px], rtn);
|
|
indexes[px] = index;
|
|
|
|
if (refiner)
|
|
refiner->ContributeUnweightedPW(preWeightedPixels[px], index);
|
|
|
|
MUInt15 reconstructed[3];
|
|
selector.ReconstructLDRPrecise(index, reconstructed);
|
|
|
|
if (flags & Flags::S3TC_Paranoid)
|
|
{
|
|
for (int ch = 0; ch < 3; ch++)
|
|
error = error + ParanoidDiff(reconstructed[ch], pixels[px][ch], paranoidFactors[ch]) * channelWeightsSq[ch];
|
|
}
|
|
else
|
|
BCCommon::ComputeErrorLDR<3>(flags, reconstructed, pixels[px], aggError);
|
|
}
|
|
|
|
if (!(flags & Flags::S3TC_Paranoid))
|
|
error = aggError.Finalize(flags, channelWeightsSq);
|
|
|
|
ParallelMath::FloatCompFlag better = ParallelMath::Less(error, bestError);
|
|
|
|
if (ParallelMath::AnySet(better))
|
|
{
|
|
ParallelMath::Int16CompFlag betterInt16 = ParallelMath::FloatFlagToInt16(better);
|
|
|
|
ParallelMath::ConditionalSet(bestError, better, error);
|
|
|
|
for (int ep = 0; ep < 2; ep++)
|
|
for (int ch = 0; ch < 3; ch++)
|
|
ParallelMath::ConditionalSet(bestEndpoints[ep][ch], betterInt16, endPoints[ep][ch]);
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
ParallelMath::ConditionalSet(bestIndexes[px], betterInt16, indexes[px]);
|
|
|
|
ParallelMath::ConditionalSet(bestRange, betterInt16, ParallelMath::MakeUInt15(static_cast<uint16_t>(range)));
|
|
}
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::TestCounts(uint32_t flags, const int *counts, int nCounts, const MUInt15 &numElements, const MUInt15 pixels[16][4], const MFloat floatPixels[16][4], const MFloat preWeightedPixels[16][4], bool alphaTest,
|
|
const MFloat floatSortedInputs[16][4], const MFloat preWeightedFloatSortedInputs[16][4], const float *channelWeights, MFloat &bestError, MUInt15 bestEndpoints[2][3], MUInt15 bestIndexes[16], MUInt15 &bestRange,
|
|
const ParallelMath::RoundTowardNearestForScope* rtn)
|
|
{
|
|
UNREFERENCED_PARAMETER(alphaTest);
|
|
UNREFERENCED_PARAMETER(flags);
|
|
|
|
EndpointRefiner<3> refiner;
|
|
|
|
refiner.Init(nCounts, channelWeights);
|
|
|
|
bool escape = false;
|
|
int e = 0;
|
|
for (int i = 0; i < nCounts; i++)
|
|
{
|
|
for (int n = 0; n < counts[i]; n++)
|
|
{
|
|
ParallelMath::Int16CompFlag valid = ParallelMath::Less(ParallelMath::MakeUInt15(static_cast<uint16_t>(n)), numElements);
|
|
if (!ParallelMath::AnySet(valid))
|
|
{
|
|
escape = true;
|
|
break;
|
|
}
|
|
|
|
if (ParallelMath::AllSet(valid))
|
|
refiner.ContributeUnweightedPW(preWeightedFloatSortedInputs[e++], ParallelMath::MakeUInt15(static_cast<uint16_t>(i)));
|
|
else
|
|
{
|
|
MFloat weight = ParallelMath::Select(ParallelMath::Int16FlagToFloat(valid), ParallelMath::MakeFloat(1.0f), ParallelMath::MakeFloat(0.0f));
|
|
refiner.ContributePW(preWeightedFloatSortedInputs[e++], ParallelMath::MakeUInt15(static_cast<uint16_t>(i)), weight);
|
|
}
|
|
}
|
|
|
|
if (escape)
|
|
break;
|
|
}
|
|
|
|
MUInt15 endPoints[2][3];
|
|
refiner.GetRefinedEndpointsLDR(endPoints, rtn);
|
|
|
|
TestEndpoints(flags, pixels, floatPixels, preWeightedPixels, endPoints, nCounts, channelWeights, bestError, bestEndpoints, bestIndexes, bestRange, NULL, rtn);
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::PackExplicitAlpha(uint32_t flags, const PixelBlockU8* inputs, int inputChannel, uint8_t* packedBlocks, size_t packedBlockStride)
|
|
{
|
|
UNREFERENCED_PARAMETER(flags);
|
|
ParallelMath::RoundTowardNearestForScope rtn;
|
|
|
|
float weights[1] = { 1.0f };
|
|
|
|
MUInt15 pixels[16];
|
|
MFloat floatPixels[16];
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
ParallelMath::ConvertLDRInputs(inputs, px, inputChannel, pixels[px]);
|
|
floatPixels[px] = ParallelMath::ToFloat(pixels[px]);
|
|
}
|
|
|
|
MUInt15 ep[2][1] = { { ParallelMath::MakeUInt15(0) },{ ParallelMath::MakeUInt15(255) } };
|
|
|
|
IndexSelector<1> selector;
|
|
selector.Init<false>(weights, ep, 16);
|
|
|
|
MUInt15 indexes[16];
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
indexes[px] = selector.SelectIndexLDR(&floatPixels[px], &rtn);
|
|
|
|
for (int block = 0; block < ParallelMath::ParallelSize; block++)
|
|
{
|
|
for (int px = 0; px < 16; px += 2)
|
|
{
|
|
int index0 = ParallelMath::Extract(indexes[px], block);
|
|
int index1 = ParallelMath::Extract(indexes[px + 1], block);
|
|
|
|
packedBlocks[px / 2] = static_cast<uint8_t>(index0 | (index1 << 4));
|
|
}
|
|
|
|
packedBlocks += packedBlockStride;
|
|
}
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::PackInterpolatedAlpha(uint32_t flags, const PixelBlockU8* inputs, int inputChannel, uint8_t* packedBlocks, size_t packedBlockStride, bool isSigned, int maxTweakRounds, int numRefineRounds)
|
|
{
|
|
if (maxTweakRounds < 1)
|
|
maxTweakRounds = 1;
|
|
|
|
if (numRefineRounds < 1)
|
|
numRefineRounds = 1;
|
|
|
|
ParallelMath::RoundTowardNearestForScope rtn;
|
|
|
|
float oneWeight[1] = { 1.0f };
|
|
|
|
MUInt15 pixels[16];
|
|
MFloat floatPixels[16];
|
|
|
|
MUInt15 highTerminal = isSigned ? ParallelMath::MakeUInt15(254) : ParallelMath::MakeUInt15(255);
|
|
MUInt15 highTerminalMinusOne = highTerminal - ParallelMath::MakeUInt15(1);
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
ParallelMath::ConvertLDRInputs(inputs, px, inputChannel, pixels[px]);
|
|
|
|
if (isSigned)
|
|
pixels[px] = ParallelMath::Min(pixels[px], highTerminal);
|
|
|
|
floatPixels[px] = ParallelMath::ToFloat(pixels[px]);
|
|
}
|
|
|
|
MUInt15 sortedPixels[16];
|
|
for (int px = 0; px < 16; px++)
|
|
sortedPixels[px] = pixels[px];
|
|
|
|
for (int sortEnd = 15; sortEnd > 0; sortEnd--)
|
|
{
|
|
for (int sortOffset = 0; sortOffset < sortEnd; sortOffset++)
|
|
{
|
|
MUInt15 a = sortedPixels[sortOffset];
|
|
MUInt15 b = sortedPixels[sortOffset + 1];
|
|
|
|
sortedPixels[sortOffset] = ParallelMath::Min(a, b);
|
|
sortedPixels[sortOffset + 1] = ParallelMath::Max(a, b);
|
|
}
|
|
}
|
|
|
|
MUInt15 zero = ParallelMath::MakeUInt15(0);
|
|
MUInt15 one = ParallelMath::MakeUInt15(1);
|
|
|
|
MUInt15 bestIsFullRange = zero;
|
|
MFloat bestError = ParallelMath::MakeFloat(FLT_MAX);
|
|
MUInt15 bestEP[2] = { zero, zero };
|
|
MUInt15 bestIndexes[16] = {
|
|
zero, zero, zero, zero,
|
|
zero, zero, zero, zero,
|
|
zero, zero, zero, zero,
|
|
zero, zero, zero, zero
|
|
};
|
|
|
|
// Full-precision
|
|
{
|
|
MUInt15 minEP = sortedPixels[0];
|
|
MUInt15 maxEP = sortedPixels[15];
|
|
|
|
MFloat base[1] = { ParallelMath::ToFloat(minEP) };
|
|
MFloat offset[1] = { ParallelMath::ToFloat(maxEP - minEP) };
|
|
|
|
UnfinishedEndpoints<1> ufep = UnfinishedEndpoints<1>(base, offset);
|
|
|
|
int numTweakRounds = BCCommon::TweakRoundsForRange(8);
|
|
if (numTweakRounds > maxTweakRounds)
|
|
numTweakRounds = maxTweakRounds;
|
|
|
|
for (int tweak = 0; tweak < numTweakRounds; tweak++)
|
|
{
|
|
MUInt15 ep[2][1];
|
|
|
|
ufep.FinishLDR(tweak, 8, ep[0], ep[1]);
|
|
|
|
for (int refinePass = 0; refinePass < numRefineRounds; refinePass++)
|
|
{
|
|
EndpointRefiner<1> refiner;
|
|
refiner.Init(8, oneWeight);
|
|
|
|
if (isSigned)
|
|
for (int epi = 0; epi < 2; epi++)
|
|
ep[epi][0] = ParallelMath::Min(ep[epi][0], highTerminal);
|
|
|
|
IndexSelector<1> indexSelector;
|
|
indexSelector.Init<false>(oneWeight, ep, 8);
|
|
|
|
MUInt15 indexes[16];
|
|
|
|
AggregatedError<1> aggError;
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
MUInt15 index = indexSelector.SelectIndexLDR(&floatPixels[px], &rtn);
|
|
|
|
MUInt15 reconstructedPixel;
|
|
|
|
indexSelector.ReconstructLDRPrecise(index, &reconstructedPixel);
|
|
BCCommon::ComputeErrorLDR<1>(flags, &reconstructedPixel, &pixels[px], aggError);
|
|
|
|
if (refinePass != numRefineRounds - 1)
|
|
refiner.ContributeUnweightedPW(&floatPixels[px], index);
|
|
|
|
indexes[px] = index;
|
|
}
|
|
MFloat error = aggError.Finalize(flags | Flags::Uniform, oneWeight);
|
|
|
|
ParallelMath::FloatCompFlag errorBetter = ParallelMath::Less(error, bestError);
|
|
ParallelMath::Int16CompFlag errorBetter16 = ParallelMath::FloatFlagToInt16(errorBetter);
|
|
|
|
if (ParallelMath::AnySet(errorBetter16))
|
|
{
|
|
bestError = ParallelMath::Min(error, bestError);
|
|
ParallelMath::ConditionalSet(bestIsFullRange, errorBetter16, one);
|
|
for (int px = 0; px < 16; px++)
|
|
ParallelMath::ConditionalSet(bestIndexes[px], errorBetter16, indexes[px]);
|
|
|
|
for (int epi = 0; epi < 2; epi++)
|
|
ParallelMath::ConditionalSet(bestEP[epi], errorBetter16, ep[epi][0]);
|
|
}
|
|
|
|
if (refinePass != numRefineRounds - 1)
|
|
refiner.GetRefinedEndpointsLDR(ep, &rtn);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Reduced precision with special endpoints
|
|
{
|
|
MUInt15 bestHeuristicMin = sortedPixels[0];
|
|
MUInt15 bestHeuristicMax = sortedPixels[15];
|
|
|
|
ParallelMath::Int16CompFlag canTryClipping;
|
|
|
|
// In reduced precision, we want try putting endpoints at the reserved indexes at the ends.
|
|
// The heuristic we use is to assign indexes to the end as long as they aren't off by more than half of the index range.
|
|
// This will usually not find anything, but it's cheap to check.
|
|
|
|
{
|
|
MUInt15 largestPossibleRange = bestHeuristicMax - bestHeuristicMin; // Max: 255
|
|
MUInt15 lowestPossibleClearance = ParallelMath::Min(bestHeuristicMin, static_cast<MUInt15>(highTerminal - bestHeuristicMax));
|
|
|
|
MUInt15 lowestPossibleClearanceTimes10 = (lowestPossibleClearance << 2) + (lowestPossibleClearance << 4);
|
|
canTryClipping = ParallelMath::LessOrEqual(lowestPossibleClearanceTimes10, largestPossibleRange);
|
|
}
|
|
|
|
if (ParallelMath::AnySet(canTryClipping))
|
|
{
|
|
MUInt15 lowClearances[16];
|
|
MUInt15 highClearances[16];
|
|
MUInt15 bestSkipCount = ParallelMath::MakeUInt15(0);
|
|
|
|
lowClearances[0] = highClearances[0] = ParallelMath::MakeUInt15(0);
|
|
|
|
for (int px = 1; px < 16; px++)
|
|
{
|
|
lowClearances[px] = sortedPixels[px - 1];
|
|
highClearances[px] = highTerminal - sortedPixels[16 - px];
|
|
}
|
|
|
|
for (uint16_t firstIndex = 0; firstIndex < 16; firstIndex++)
|
|
{
|
|
uint16_t numSkippedLow = firstIndex;
|
|
|
|
MUInt15 lowClearance = lowClearances[firstIndex];
|
|
|
|
for (uint16_t lastIndex = firstIndex; lastIndex < 16; lastIndex++)
|
|
{
|
|
uint16_t numSkippedHigh = 15 - lastIndex;
|
|
uint16_t numSkipped = numSkippedLow + numSkippedHigh;
|
|
|
|
MUInt15 numSkippedV = ParallelMath::MakeUInt15(numSkipped);
|
|
|
|
ParallelMath::Int16CompFlag areMoreSkipped = ParallelMath::Less(bestSkipCount, numSkippedV);
|
|
|
|
if (!ParallelMath::AnySet(areMoreSkipped))
|
|
continue;
|
|
|
|
MUInt15 clearance = ParallelMath::Max(highClearances[numSkippedHigh], lowClearance);
|
|
MUInt15 clearanceTimes10 = (clearance << 2) + (clearance << 4);
|
|
|
|
MUInt15 range = sortedPixels[lastIndex] - sortedPixels[firstIndex];
|
|
|
|
ParallelMath::Int16CompFlag isBetter = (areMoreSkipped & ParallelMath::LessOrEqual(clearanceTimes10, range));
|
|
ParallelMath::ConditionalSet(bestHeuristicMin, isBetter, sortedPixels[firstIndex]);
|
|
ParallelMath::ConditionalSet(bestHeuristicMax, isBetter, sortedPixels[lastIndex]);
|
|
}
|
|
}
|
|
}
|
|
|
|
MUInt15 bestSimpleMin = one;
|
|
MUInt15 bestSimpleMax = highTerminalMinusOne;
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
ParallelMath::ConditionalSet(bestSimpleMin, ParallelMath::Less(zero, sortedPixels[15 - px]), sortedPixels[15 - px]);
|
|
ParallelMath::ConditionalSet(bestSimpleMax, ParallelMath::Less(sortedPixels[px], highTerminal), sortedPixels[px]);
|
|
}
|
|
|
|
MUInt15 minEPs[2] = { bestSimpleMin, bestHeuristicMin };
|
|
MUInt15 maxEPs[2] = { bestSimpleMax, bestHeuristicMax };
|
|
|
|
int minEPRange = 2;
|
|
if (ParallelMath::AllSet(ParallelMath::Equal(minEPs[0], minEPs[1])))
|
|
minEPRange = 1;
|
|
|
|
int maxEPRange = 2;
|
|
if (ParallelMath::AllSet(ParallelMath::Equal(maxEPs[0], maxEPs[1])))
|
|
maxEPRange = 1;
|
|
|
|
for (int minEPIndex = 0; minEPIndex < minEPRange; minEPIndex++)
|
|
{
|
|
for (int maxEPIndex = 0; maxEPIndex < maxEPRange; maxEPIndex++)
|
|
{
|
|
MFloat base[1] = { ParallelMath::ToFloat(minEPs[minEPIndex]) };
|
|
MFloat offset[1] = { ParallelMath::ToFloat(maxEPs[maxEPIndex] - minEPs[minEPIndex]) };
|
|
|
|
UnfinishedEndpoints<1> ufep = UnfinishedEndpoints<1>(base, offset);
|
|
|
|
int numTweakRounds = BCCommon::TweakRoundsForRange(6);
|
|
if (numTweakRounds > maxTweakRounds)
|
|
numTweakRounds = maxTweakRounds;
|
|
|
|
for (int tweak = 0; tweak < numTweakRounds; tweak++)
|
|
{
|
|
MUInt15 ep[2][1];
|
|
|
|
ufep.FinishLDR(tweak, 8, ep[0], ep[1]);
|
|
|
|
for (int refinePass = 0; refinePass < numRefineRounds; refinePass++)
|
|
{
|
|
EndpointRefiner<1> refiner;
|
|
refiner.Init(6, oneWeight);
|
|
|
|
if (isSigned)
|
|
for (int epi = 0; epi < 2; epi++)
|
|
ep[epi][0] = ParallelMath::Min(ep[epi][0], highTerminal);
|
|
|
|
IndexSelector<1> indexSelector;
|
|
indexSelector.Init<false>(oneWeight, ep, 6);
|
|
|
|
MUInt15 indexes[16];
|
|
MFloat error = ParallelMath::MakeFloatZero();
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
MUInt15 selectedIndex = indexSelector.SelectIndexLDR(&floatPixels[px], &rtn);
|
|
|
|
MUInt15 reconstructedPixel;
|
|
|
|
indexSelector.ReconstructLDRPrecise(selectedIndex, &reconstructedPixel);
|
|
|
|
MFloat zeroError = BCCommon::ComputeErrorLDRSimple<1>(flags | Flags::Uniform, &zero, &pixels[px], 1, oneWeight);
|
|
MFloat highTerminalError = BCCommon::ComputeErrorLDRSimple<1>(flags | Flags::Uniform, &highTerminal, &pixels[px], 1, oneWeight);
|
|
MFloat selectedIndexError = BCCommon::ComputeErrorLDRSimple<1>(flags | Flags::Uniform, &reconstructedPixel, &pixels[px], 1, oneWeight);
|
|
|
|
MFloat bestPixelError = zeroError;
|
|
MUInt15 index = ParallelMath::MakeUInt15(6);
|
|
|
|
ParallelMath::ConditionalSet(index, ParallelMath::FloatFlagToInt16(ParallelMath::Less(highTerminalError, bestPixelError)), ParallelMath::MakeUInt15(7));
|
|
bestPixelError = ParallelMath::Min(bestPixelError, highTerminalError);
|
|
|
|
ParallelMath::FloatCompFlag selectedIndexBetter = ParallelMath::Less(selectedIndexError, bestPixelError);
|
|
|
|
if (ParallelMath::AllSet(selectedIndexBetter))
|
|
{
|
|
if (refinePass != numRefineRounds - 1)
|
|
refiner.ContributeUnweightedPW(&floatPixels[px], selectedIndex);
|
|
}
|
|
else
|
|
{
|
|
MFloat refineWeight = ParallelMath::Select(selectedIndexBetter, ParallelMath::MakeFloat(1.0f), ParallelMath::MakeFloatZero());
|
|
|
|
if (refinePass != numRefineRounds - 1)
|
|
refiner.ContributePW(&floatPixels[px], selectedIndex, refineWeight);
|
|
}
|
|
|
|
ParallelMath::ConditionalSet(index, ParallelMath::FloatFlagToInt16(selectedIndexBetter), selectedIndex);
|
|
bestPixelError = ParallelMath::Min(bestPixelError, selectedIndexError);
|
|
|
|
error = error + bestPixelError;
|
|
|
|
indexes[px] = index;
|
|
}
|
|
|
|
ParallelMath::FloatCompFlag errorBetter = ParallelMath::Less(error, bestError);
|
|
ParallelMath::Int16CompFlag errorBetter16 = ParallelMath::FloatFlagToInt16(errorBetter);
|
|
|
|
if (ParallelMath::AnySet(errorBetter16))
|
|
{
|
|
bestError = ParallelMath::Min(error, bestError);
|
|
ParallelMath::ConditionalSet(bestIsFullRange, errorBetter16, zero);
|
|
for (int px = 0; px < 16; px++)
|
|
ParallelMath::ConditionalSet(bestIndexes[px], errorBetter16, indexes[px]);
|
|
|
|
for (int epi = 0; epi < 2; epi++)
|
|
ParallelMath::ConditionalSet(bestEP[epi], errorBetter16, ep[epi][0]);
|
|
}
|
|
|
|
if (refinePass != numRefineRounds - 1)
|
|
refiner.GetRefinedEndpointsLDR(ep, &rtn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int block = 0; block < ParallelMath::ParallelSize; block++)
|
|
{
|
|
int ep0 = ParallelMath::Extract(bestEP[0], block);
|
|
int ep1 = ParallelMath::Extract(bestEP[1], block);
|
|
int isFullRange = ParallelMath::Extract(bestIsFullRange, block);
|
|
|
|
if (isSigned)
|
|
{
|
|
ep0 -= 127;
|
|
ep1 -= 127;
|
|
|
|
assert(ep0 >= -127 && ep0 <= 127);
|
|
assert(ep1 >= -127 && ep1 <= 127);
|
|
}
|
|
|
|
|
|
bool swapEndpoints = (isFullRange != 0) != (ep0 > ep1);
|
|
|
|
if (swapEndpoints)
|
|
std::swap(ep0, ep1);
|
|
|
|
uint16_t dumpBits = 0;
|
|
int dumpBitsOffset = 0;
|
|
int dumpByteOffset = 2;
|
|
packedBlocks[0] = static_cast<uint8_t>(ep0 & 0xff);
|
|
packedBlocks[1] = static_cast<uint8_t>(ep1 & 0xff);
|
|
|
|
int maxValue = (isFullRange != 0) ? 7 : 5;
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
int index = ParallelMath::Extract(bestIndexes[px], block);
|
|
|
|
if (swapEndpoints && index <= maxValue)
|
|
index = maxValue - index;
|
|
|
|
if (index != 0)
|
|
{
|
|
if (index == maxValue)
|
|
index = 1;
|
|
else if (index < maxValue)
|
|
index++;
|
|
}
|
|
|
|
assert(index >= 0 && index < 8);
|
|
|
|
dumpBits |= static_cast<uint16_t>(index << dumpBitsOffset);
|
|
dumpBitsOffset += 3;
|
|
|
|
if (dumpBitsOffset >= 8)
|
|
{
|
|
assert(dumpByteOffset < 8);
|
|
packedBlocks[dumpByteOffset] = static_cast<uint8_t>(dumpBits & 0xff);
|
|
dumpBits >>= 8;
|
|
dumpBitsOffset -= 8;
|
|
dumpByteOffset++;
|
|
}
|
|
}
|
|
|
|
assert(dumpBitsOffset == 0);
|
|
assert(dumpByteOffset == 8);
|
|
|
|
packedBlocks += packedBlockStride;
|
|
}
|
|
}
|
|
|
|
void cvtt::Internal::S3TCComputer::PackRGB(uint32_t flags, const PixelBlockU8* inputs, uint8_t* packedBlocks, size_t packedBlockStride, const float channelWeights[4], bool alphaTest, float alphaThreshold, bool exhaustive, int maxTweakRounds, int numRefineRounds)
|
|
{
|
|
ParallelMath::RoundTowardNearestForScope rtn;
|
|
|
|
if (numRefineRounds < 1)
|
|
numRefineRounds = 1;
|
|
|
|
if (maxTweakRounds < 1)
|
|
maxTweakRounds = 1;
|
|
|
|
EndpointSelector<3, 8> endpointSelector;
|
|
|
|
MUInt15 pixels[16][4];
|
|
MFloat floatPixels[16][4];
|
|
|
|
MFloat preWeightedPixels[16][4];
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
for (int ch = 0; ch < 4; ch++)
|
|
ParallelMath::ConvertLDRInputs(inputs, px, ch, pixels[px][ch]);
|
|
}
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
for (int ch = 0; ch < 4; ch++)
|
|
floatPixels[px][ch] = ParallelMath::ToFloat(pixels[px][ch]);
|
|
}
|
|
|
|
if (alphaTest)
|
|
{
|
|
MUInt15 threshold = ParallelMath::MakeUInt15(static_cast<uint16_t>(floor(alphaThreshold * 255.0f + 0.5f)));
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
ParallelMath::Int16CompFlag belowThreshold = ParallelMath::Less(pixels[px][3], threshold);
|
|
pixels[px][3] = ParallelMath::Select(belowThreshold, ParallelMath::MakeUInt15(0), ParallelMath::MakeUInt15(255));
|
|
}
|
|
}
|
|
|
|
BCCommon::PreWeightPixelsLDR<4>(preWeightedPixels, pixels, channelWeights);
|
|
|
|
MUInt15 minAlpha = ParallelMath::MakeUInt15(255);
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
minAlpha = ParallelMath::Min(minAlpha, pixels[px][3]);
|
|
|
|
MFloat pixelWeights[16];
|
|
for (int px = 0; px < 16; px++)
|
|
{
|
|
pixelWeights[px] = ParallelMath::MakeFloat(1.0f);
|
|
if (alphaTest)
|
|
{
|
|
ParallelMath::Int16CompFlag isTransparent = ParallelMath::Less(pixels[px][3], ParallelMath::MakeUInt15(255));
|
|
|
|
ParallelMath::ConditionalSet(pixelWeights[px], ParallelMath::Int16FlagToFloat(isTransparent), ParallelMath::MakeFloatZero());
|
|
}
|
|
}
|
|
|
|
for (int pass = 0; pass < NumEndpointSelectorPasses; pass++)
|
|
{
|
|
for (int px = 0; px < 16; px++)
|
|
endpointSelector.ContributePass(preWeightedPixels[px], pass, pixelWeights[px]);
|
|
|
|
endpointSelector.FinishPass(pass);
|
|
}
|
|
|
|
UnfinishedEndpoints<3> ufep = endpointSelector.GetEndpoints(channelWeights);
|
|
|
|
MUInt15 bestEndpoints[2][3];
|
|
MUInt15 bestIndexes[16];
|
|
MUInt15 bestRange = ParallelMath::MakeUInt15(0);
|
|
MFloat bestError = ParallelMath::MakeFloat(FLT_MAX);
|
|
|
|
for (int px = 0; px < 16; px++)
|
|
bestIndexes[px] = ParallelMath::MakeUInt15(0);
|
|
|
|
for (int ep = 0; ep < 2; ep++)
|
|
for (int ch = 0; ch < 3; ch++)
|
|
bestEndpoints[ep][ch] = ParallelMath::MakeUInt15(0);
|
|
|
|
if (exhaustive)
|
|
{
|
|
MSInt16 sortBins[16];
|
|
|
|
{
|
|
// Compute an 11-bit index, change it to signed, stuff it in the high bits of the sort bins,
|
|
// and pack the original indexes into the low bits.
|
|
|
|
MUInt15 sortEP[2][3];
|
|
ufep.FinishLDR(0, 11, sortEP[0], sortEP[1]);
|
|
|
|
IndexSelector<3> sortSelector;
|
|
sortSelector.Init<false>(channelWeights, sortEP, 1 << 11);
|
|
|
|
for (int16_t px = 0; px < 16; px++)
|
|
{
|
|
MSInt16 sortBin = ParallelMath::LosslessCast<MSInt16>::Cast(sortSelector.SelectIndexLDR(floatPixels[px], &rtn) << 4);
|
|
|
|
if (alphaTest)
|
|
{
|
|
ParallelMath::Int16CompFlag isTransparent = ParallelMath::Less(pixels[px][3], ParallelMath::MakeUInt15(255));
|
|
|
|
ParallelMath::ConditionalSet(sortBin, isTransparent, ParallelMath::MakeSInt16(-16)); // 0xfff0
|
|
}
|
|
|
|
sortBin = sortBin + ParallelMath::MakeSInt16(px);
|
|
|
|
sortBins[px] = sortBin;
|
|
}
|
|
}
|
|
|
|
// Sort bins
|
|
for (int sortEnd = 1; sortEnd < 16; sortEnd++)
|
|
{
|
|
for (int sortLoc = sortEnd; sortLoc > 0; sortLoc--)
|
|
{
|
|
MSInt16 a = sortBins[sortLoc];
|
|
MSInt16 b = sortBins[sortLoc - 1];
|
|
|
|
sortBins[sortLoc] = ParallelMath::Max(a, b);
|
|
sortBins[sortLoc - 1] = ParallelMath::Min(a, b);
|
|
}
|
|
}
|
|
|
|
MUInt15 firstElement = ParallelMath::MakeUInt15(0);
|
|
for (uint16_t e = 0; e < 16; e++)
|
|
{
|
|
ParallelMath::Int16CompFlag isInvalid = ParallelMath::Less(sortBins[e], ParallelMath::MakeSInt16(0));
|
|
ParallelMath::ConditionalSet(firstElement, isInvalid, ParallelMath::MakeUInt15(e + 1));
|
|
if (!ParallelMath::AnySet(isInvalid))
|
|
break;
|
|
}
|
|
|
|
MUInt15 numElements = ParallelMath::MakeUInt15(16) - firstElement;
|
|
|
|
MUInt15 sortedInputs[16][4];
|
|
MFloat floatSortedInputs[16][4];
|
|
MFloat pwFloatSortedInputs[16][4];
|
|
|
|
for (int e = 0; e < 16; e++)
|
|
{
|
|
for (int ch = 0; ch < 4; ch++)
|
|
sortedInputs[e][ch] = ParallelMath::MakeUInt15(0);
|
|
}
|
|
|
|
for (int block = 0; block < ParallelMath::ParallelSize; block++)
|
|
{
|
|
for (int e = ParallelMath::Extract(firstElement, block); e < 16; e++)
|
|
{
|
|
ParallelMath::ScalarUInt16 sortBin = ParallelMath::Extract(sortBins[e], block);
|
|
int originalIndex = (sortBin & 15);
|
|
|
|
for (int ch = 0; ch < 4; ch++)
|
|
ParallelMath::PutUInt15(sortedInputs[15 - e][ch], block, ParallelMath::Extract(pixels[originalIndex][ch], block));
|
|
}
|
|
}
|
|
|
|
for (int e = 0; e < 16; e++)
|
|
{
|
|
for (int ch = 0; ch < 4; ch++)
|
|
{
|
|
MFloat f = ParallelMath::ToFloat(sortedInputs[e][ch]);
|
|
floatSortedInputs[e][ch] = f;
|
|
pwFloatSortedInputs[e][ch] = f * channelWeights[ch];
|
|
}
|
|
}
|
|
|
|
for (int n0 = 0; n0 <= 15; n0++)
|
|
{
|
|
int remainingFor1 = 16 - n0;
|
|
if (remainingFor1 == 16)
|
|
remainingFor1 = 15;
|
|
|
|
for (int n1 = 0; n1 <= remainingFor1; n1++)
|
|
{
|
|
int remainingFor2 = 16 - n1 - n0;
|
|
if (remainingFor2 == 16)
|
|
remainingFor2 = 15;
|
|
|
|
for (int n2 = 0; n2 <= remainingFor2; n2++)
|
|
{
|
|
int n3 = 16 - n2 - n1 - n0;
|
|
|
|
if (n3 == 16)
|
|
continue;
|
|
|
|
int counts[4] = { n0, n1, n2, n3 };
|
|
|
|
TestCounts(flags, counts, 4, numElements, pixels, floatPixels, preWeightedPixels, alphaTest, floatSortedInputs, pwFloatSortedInputs, channelWeights, bestError, bestEndpoints, bestIndexes, bestRange, &rtn);
|
|
}
|
|
}
|
|
}
|
|
|
|
TestSingleColor(flags, pixels, floatPixels, 4, channelWeights, bestError, bestEndpoints, bestIndexes, bestRange, &rtn);
|
|
|
|
if (alphaTest)
|
|
{
|
|
for (int n0 = 0; n0 <= 15; n0++)
|
|
{
|
|
int remainingFor1 = 16 - n0;
|
|
if (remainingFor1 == 16)
|
|
remainingFor1 = 15;
|
|
|
|
for (int n1 = 0; n1 <= remainingFor1; n1++)
|
|
{
|
|
int n2 = 16 - n1 - n0;
|
|
|
|
if (n2 == 16)
|
|
continue;
|
|
|
|
int counts[3] = { n0, n1, n2 };
|
|
|
|
TestCounts(flags, counts, 3, numElements, pixels, floatPixels, preWeightedPixels, alphaTest, floatSortedInputs, pwFloatSortedInputs, channelWeights, bestError, bestEndpoints, bestIndexes, bestRange, &rtn);
|
|
}
|
|
}
|
|
|
|
TestSingleColor(flags, pixels, floatPixels, 3, channelWeights, bestError, bestEndpoints, bestIndexes, bestRange, &rtn);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int minRange = alphaTest ? 3 : 4;
|
|
|
|
for (int range = minRange; range <= 4; range++)
|
|
{
|
|
int tweakRounds = BCCommon::TweakRoundsForRange(range);
|
|
if (tweakRounds > maxTweakRounds)
|
|
tweakRounds = maxTweakRounds;
|
|
|
|
for (int tweak = 0; tweak < tweakRounds; tweak++)
|
|
{
|
|
MUInt15 endPoints[2][3];
|
|
|
|
ufep.FinishLDR(tweak, range, endPoints[0], endPoints[1]);
|
|
|
|
for (int refine = 0; refine < numRefineRounds; refine++)
|
|
{
|
|
EndpointRefiner<3> refiner;
|
|
refiner.Init(range, channelWeights);
|
|
|
|
TestEndpoints(flags, pixels, floatPixels, preWeightedPixels, endPoints, range, channelWeights, bestError, bestEndpoints, bestIndexes, bestRange, &refiner, &rtn);
|
|
|
|
if (refine != numRefineRounds - 1)
|
|
refiner.GetRefinedEndpointsLDR(endPoints, &rtn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int block = 0; block < ParallelMath::ParallelSize; block++)
|
|
{
|
|
ParallelMath::ScalarUInt16 range = ParallelMath::Extract(bestRange, block);
|
|
assert(range == 3 || range == 4);
|
|
|
|
ParallelMath::ScalarUInt16 compressedEP[2];
|
|
for (int ep = 0; ep < 2; ep++)
|
|
{
|
|
ParallelMath::ScalarUInt16 endPoint[3];
|
|
for (int ch = 0; ch < 3; ch++)
|
|
endPoint[ch] = ParallelMath::Extract(bestEndpoints[ep][ch], block);
|
|
|
|
int compressed = (endPoint[0] & 0xf8) << 8;
|
|
compressed |= (endPoint[1] & 0xfc) << 3;
|
|
compressed |= (endPoint[2] & 0xf8) >> 3;
|
|
|
|
compressedEP[ep] = static_cast<ParallelMath::ScalarUInt16>(compressed);
|
|
}
|
|
|
|
int indexOrder[4];
|
|
|
|
if (range == 4)
|
|
{
|
|
if (compressedEP[0] == compressedEP[1])
|
|
{
|
|
indexOrder[0] = 0;
|
|
indexOrder[1] = 0;
|
|
indexOrder[2] = 0;
|
|
indexOrder[3] = 0;
|
|
}
|
|
else if (compressedEP[0] < compressedEP[1])
|
|
{
|
|
std::swap(compressedEP[0], compressedEP[1]);
|
|
indexOrder[0] = 1;
|
|
indexOrder[1] = 3;
|
|
indexOrder[2] = 2;
|
|
indexOrder[3] = 0;
|
|
}
|
|
else
|
|
{
|
|
indexOrder[0] = 0;
|
|
indexOrder[1] = 2;
|
|
indexOrder[2] = 3;
|
|
indexOrder[3] = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
assert(range == 3);
|
|
|
|
if (compressedEP[0] > compressedEP[1])
|
|
{
|
|
std::swap(compressedEP[0], compressedEP[1]);
|
|
indexOrder[0] = 1;
|
|
indexOrder[1] = 2;
|
|
indexOrder[2] = 0;
|
|
}
|
|
else
|
|
{
|
|
indexOrder[0] = 0;
|
|
indexOrder[1] = 2;
|
|
indexOrder[2] = 1;
|
|
}
|
|
indexOrder[3] = 3;
|
|
}
|
|
|
|
packedBlocks[0] = static_cast<uint8_t>(compressedEP[0] & 0xff);
|
|
packedBlocks[1] = static_cast<uint8_t>((compressedEP[0] >> 8) & 0xff);
|
|
packedBlocks[2] = static_cast<uint8_t>(compressedEP[1] & 0xff);
|
|
packedBlocks[3] = static_cast<uint8_t>((compressedEP[1] >> 8) & 0xff);
|
|
|
|
for (int i = 0; i < 16; i += 4)
|
|
{
|
|
int packedIndexes = 0;
|
|
for (int subi = 0; subi < 4; subi++)
|
|
{
|
|
ParallelMath::ScalarUInt16 index = ParallelMath::Extract(bestIndexes[i + subi], block);
|
|
packedIndexes |= (indexOrder[index] << (subi * 2));
|
|
}
|
|
|
|
packedBlocks[4 + i / 4] = static_cast<uint8_t>(packedIndexes);
|
|
}
|
|
|
|
packedBlocks += packedBlockStride;
|
|
}
|
|
}
|
|
|
|
#endif
|