summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bimg/tools/texturec/texturec.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bimg/tools/texturec/texturec.cpp')
-rw-r--r--3rdparty/bimg/tools/texturec/texturec.cpp913
1 files changed, 913 insertions, 0 deletions
diff --git a/3rdparty/bimg/tools/texturec/texturec.cpp b/3rdparty/bimg/tools/texturec/texturec.cpp
new file mode 100644
index 00000000000..8b6d27dfc1b
--- /dev/null
+++ b/3rdparty/bimg/tools/texturec/texturec.cpp
@@ -0,0 +1,913 @@
+/*
+ * Copyright 2011-2017 Branimir Karadzic. All rights reserved.
+ * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause
+ */
+
+#include <stdio.h>
+#include <bx/allocator.h>
+#include <bx/readerwriter.h>
+#include <bx/endian.h>
+#include <bx/math.h>
+
+#include <bimg/decode.h>
+#include <bimg/encode.h>
+
+#if 0
+# define DBG(_format, ...) fprintf(stderr, "" _format "\n", ##__VA_ARGS__)
+#else
+# define DBG(...) BX_NOOP()
+#endif // DEBUG
+
+#include <bx/bx.h>
+#include <bx/commandline.h>
+#include <bx/file.h>
+#include <bx/uint32_t.h>
+
+#include <string>
+
+#define BIMG_TEXTUREC_VERSION_MAJOR 1
+#define BIMG_TEXTUREC_VERSION_MINOR 10
+
+struct Options
+{
+ Options()
+ : maxSize(UINT32_MAX)
+ , edge(0.0f)
+ , format(bimg::TextureFormat::Count)
+ , quality(bimg::Quality::Default)
+ , mips(false)
+ , normalMap(false)
+ , iqa(false)
+ , sdf(false)
+ , alphaTest(false)
+ {
+ }
+
+ void dump()
+ {
+ DBG("Options:\n"
+ "\t maxSize: %d\n"
+ "\t edge: %f\n"
+ "\t format: %s\n"
+ "\t mips: %s\n"
+ "\tnormalMap: %s\n"
+ "\t iqa: %s\n"
+ "\t sdf: %s\n"
+ , maxSize
+ , edge
+ , bimg::getName(format)
+ , mips ? "true" : "false"
+ , normalMap ? "true" : "false"
+ , iqa ? "true" : "false"
+ , sdf ? "true" : "false"
+ );
+ }
+
+ uint32_t maxSize;
+ float edge;
+ bimg::TextureFormat::Enum format;
+ bimg::Quality::Enum quality;
+ bool mips;
+ bool normalMap;
+ bool iqa;
+ bool sdf;
+ bool alphaTest;
+};
+
+void imageRgba32fNormalize(void* _dst, uint32_t _width, uint32_t _height, uint32_t _srcPitch, const void* _src)
+{
+ const uint8_t* src = (const uint8_t*)_src;
+ uint8_t* dst = (uint8_t*)_dst;
+
+ for (uint32_t yy = 0, ystep = _srcPitch; yy < _height; ++yy, src += ystep)
+ {
+ const float* rgba = (const float*)&src[0];
+ for (uint32_t xx = 0; xx < _width; ++xx, rgba += 4, dst += 16)
+ {
+ float xyz[3];
+
+ xyz[0] = rgba[0];
+ xyz[1] = rgba[1];
+ xyz[2] = rgba[2];
+ bx::vec3Norm( (float*)dst, xyz);
+ }
+ }
+}
+
+bimg::ImageContainer* convert(bx::AllocatorI* _allocator, const void* _inputData, uint32_t _inputSize, const Options& _options, bx::Error* _err)
+{
+ BX_ERROR_SCOPE(_err);
+
+ const uint8_t* inputData = (uint8_t*)_inputData;
+
+ bimg::ImageContainer* output = NULL;
+ bimg::ImageContainer* input = bimg::imageParse(_allocator, inputData, _inputSize, bimg::TextureFormat::Count, _err);
+
+ if (!_err->isOk() )
+ {
+ return NULL;
+ }
+
+ if (NULL != input)
+ {
+ const bimg::TextureFormat::Enum inputFormat = input->m_format;
+ bimg::TextureFormat::Enum outputFormat = input->m_format;
+
+ if (bimg::TextureFormat::Count != _options.format)
+ {
+ outputFormat = _options.format;
+ }
+
+ if (_options.sdf)
+ {
+ outputFormat = bimg::TextureFormat::R8;
+ }
+
+ const bimg::ImageBlockInfo& inputBlockInfo = bimg::getBlockInfo(inputFormat);
+ const bimg::ImageBlockInfo& outputBlockInfo = bimg::getBlockInfo(outputFormat);
+ const uint32_t blockWidth = outputBlockInfo.blockWidth;
+ const uint32_t blockHeight = outputBlockInfo.blockHeight;
+ const uint32_t minBlockX = outputBlockInfo.minBlockX;
+ const uint32_t minBlockY = outputBlockInfo.minBlockY;
+ uint32_t outputWidth = bx::uint32_max(blockWidth * minBlockX, ( (input->m_width + blockWidth - 1) / blockWidth )*blockWidth);
+ uint32_t outputHeight = bx::uint32_max(blockHeight * minBlockY, ( (input->m_height + blockHeight - 1) / blockHeight)*blockHeight);
+
+ if (outputWidth > _options.maxSize
+ || outputHeight > _options.maxSize)
+ {
+ if (outputWidth > outputHeight)
+ {
+ outputHeight = outputHeight * _options.maxSize / outputWidth;
+ outputWidth = _options.maxSize;
+ }
+ else
+ {
+ outputWidth = outputWidth * _options.maxSize / outputHeight;
+ outputHeight = _options.maxSize;
+ }
+ }
+
+ const bool needResize = false
+ || input->m_width != outputWidth
+ || input->m_height != outputHeight
+ ;
+
+ const bool passThru = true
+ && !needResize
+ && (1 < input->m_numMips) == _options.mips
+ && !_options.sdf
+ && !_options.alphaTest
+ && !_options.normalMap
+ && !_options.iqa
+ ;
+
+ if (needResize)
+ {
+ bimg::ImageContainer* src = bimg::imageConvert(_allocator, bimg::TextureFormat::RGBA32F, *input);
+
+ bimg::ImageContainer* dst = bimg::imageAlloc(
+ _allocator
+ , bimg::TextureFormat::RGBA32F
+ , uint16_t(outputWidth)
+ , uint16_t(outputHeight)
+ , 1
+ , input->m_numLayers
+ , input->m_cubeMap
+ , false
+ );
+
+ bimg::imageResizeRgba32fLinear(dst, src);
+
+ bimg::imageFree(src);
+ bimg::imageFree(input);
+
+ input = bimg::imageConvert(_allocator, inputFormat, *dst);
+ bimg::imageFree(dst);
+ }
+
+ if (passThru)
+ {
+ if (inputFormat != outputFormat
+ && bimg::isCompressed(outputFormat) )
+ {
+ output = bimg::imageEncode(_allocator, outputFormat, _options.quality, *input);
+ }
+ else
+ {
+ output = bimg::imageConvert(_allocator, outputFormat, *input);
+ }
+
+ bimg::imageFree(input);
+ return output;
+ }
+
+ output = bimg::imageAlloc(
+ _allocator
+ , outputFormat
+ , uint16_t(input->m_width)
+ , uint16_t(input->m_height)
+ , uint16_t(input->m_depth)
+ , input->m_numLayers
+ , input->m_cubeMap
+ , _options.mips
+ );
+
+ const uint8_t numMips = output->m_numMips;
+ const uint16_t numSides = output->m_numLayers * (output->m_cubeMap ? 6 : 1);
+
+ for (uint16_t side = 0; side < numSides && _err->isOk(); ++side)
+ {
+ bimg::ImageMip mip;
+ if (bimg::imageGetRawData(*input, side, 0, input->m_data, input->m_size, mip) )
+ {
+ bimg::ImageMip dstMip;
+ bimg::imageGetRawData(*output, side, 0, output->m_data, output->m_size, dstMip);
+ uint8_t* dstData = const_cast<uint8_t*>(dstMip.m_data);
+
+ void* temp = NULL;
+
+ if (_options.normalMap)
+ {
+ uint32_t size = bimg::imageGetSize(
+ NULL
+ , uint16_t(dstMip.m_width)
+ , uint16_t(dstMip.m_height)
+ , 0
+ , false
+ , false
+ , 1
+ , bimg::TextureFormat::RGBA32F
+ );
+ temp = BX_ALLOC(_allocator, size);
+ float* rgba = (float*)temp;
+ float* rgbaDst = (float*)BX_ALLOC(_allocator, size);
+
+ bimg::imageDecodeToRgba32f(_allocator
+ , rgba
+ , mip.m_data
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , dstMip.m_width*16
+ , mip.m_format
+ );
+
+ if (bimg::TextureFormat::BC5 != mip.m_format)
+ {
+ for (uint32_t yy = 0; yy < mip.m_height; ++yy)
+ {
+ for (uint32_t xx = 0; xx < mip.m_width; ++xx)
+ {
+ const uint32_t offset = (yy*mip.m_width + xx) * 4;
+ float* inout = &rgba[offset];
+ inout[0] = inout[0] * 2.0f - 1.0f;
+ inout[1] = inout[1] * 2.0f - 1.0f;
+ inout[2] = inout[2] * 2.0f - 1.0f;
+ inout[3] = inout[3] * 2.0f - 1.0f;
+ }
+ }
+ }
+
+ imageRgba32fNormalize(rgba
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_width*16
+ , rgba
+ );
+
+ bimg::imageRgba32f11to01(rgbaDst
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , dstMip.m_width*16
+ , rgba
+ );
+
+ bimg::imageEncodeFromRgba32f(_allocator
+ , dstData
+ , rgbaDst
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , outputFormat
+ , _options.quality
+ , _err
+ );
+
+ for (uint8_t lod = 1; lod < numMips && _err->isOk(); ++lod)
+ {
+ bimg::imageRgba32fDownsample2x2NormalMap(rgba
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_width*16
+ , rgba
+ );
+
+ bimg::imageRgba32f11to01(rgbaDst
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , dstMip.m_width*16
+ , rgba
+ );
+
+ bimg::imageGetRawData(*output, side, lod, output->m_data, output->m_size, dstMip);
+ dstData = const_cast<uint8_t*>(dstMip.m_data);
+
+ bimg::imageEncodeFromRgba32f(_allocator
+ , dstData
+ , rgbaDst
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , outputFormat
+ , _options.quality
+ , _err
+ );
+ }
+
+ BX_FREE(_allocator, rgbaDst);
+ }
+ else if ( (!bimg::isCompressed(input->m_format) && 8 != inputBlockInfo.rBits)
+ || outputFormat == bimg::TextureFormat::BC6H
+ || outputFormat == bimg::TextureFormat::BC7
+ )
+ {
+ uint32_t size = bimg::imageGetSize(
+ NULL
+ , uint16_t(dstMip.m_width)
+ , uint16_t(dstMip.m_height)
+ , uint16_t(dstMip.m_depth)
+ , false
+ , false
+ , 1
+ , bimg::TextureFormat::RGBA32F
+ );
+ temp = BX_ALLOC(_allocator, size);
+ float* rgba32f = (float*)temp;
+ float* rgbaDst = (float*)BX_ALLOC(_allocator, size);
+
+ bimg::imageDecodeToRgba32f(_allocator
+ , rgba32f
+ , mip.m_data
+ , mip.m_width
+ , mip.m_height
+ , mip.m_depth
+ , mip.m_width*16
+ , mip.m_format
+ );
+
+ bimg::imageEncodeFromRgba32f(_allocator
+ , dstData
+ , rgba32f
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , outputFormat
+ , _options.quality
+ , _err
+ );
+
+ if (1 < numMips
+ && _err->isOk() )
+ {
+ bimg::imageRgba32fToLinear(rgba32f
+ , mip.m_width
+ , mip.m_height
+ , mip.m_depth
+ , mip.m_width*16
+ , rgba32f
+ );
+
+ for (uint8_t lod = 1; lod < numMips && _err->isOk(); ++lod)
+ {
+ bimg::imageRgba32fLinearDownsample2x2(rgba32f
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , dstMip.m_width*16
+ , rgba32f
+ );
+
+ bimg::imageGetRawData(*output, side, lod, output->m_data, output->m_size, dstMip);
+ dstData = const_cast<uint8_t*>(dstMip.m_data);
+
+ bimg::imageRgba32fToGamma(rgbaDst
+ , mip.m_width
+ , mip.m_height
+ , mip.m_depth
+ , mip.m_width*16
+ , rgba32f
+ );
+
+ bimg::imageEncodeFromRgba32f(_allocator
+ , dstData
+ , rgbaDst
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , outputFormat
+ , _options.quality
+ , _err
+ );
+ }
+ }
+
+ BX_FREE(_allocator, rgbaDst);
+ }
+ else if (_options.sdf)
+ {
+ uint32_t size = bimg::imageGetSize(
+ NULL
+ , uint16_t(dstMip.m_width)
+ , uint16_t(dstMip.m_height)
+ , uint16_t(dstMip.m_depth)
+ , false
+ , false
+ , 1
+ , bimg::TextureFormat::R8
+ );
+ temp = BX_ALLOC(_allocator, size);
+ uint8_t* rgba = (uint8_t*)temp;
+
+ bimg::imageDecodeToR8(_allocator
+ , rgba
+ , mip.m_data
+ , mip.m_width
+ , mip.m_height
+ , mip.m_depth
+ , mip.m_width
+ , mip.m_format
+ );
+
+ bimg::imageGetRawData(*output, side, 0, output->m_data, output->m_size, dstMip);
+ dstData = const_cast<uint8_t*>(dstMip.m_data);
+
+ bimg::imageMakeDist(_allocator
+ , dstData
+ , mip.m_width
+ , mip.m_height
+ , mip.m_width
+ , _options.edge
+ , rgba
+ );
+ }
+ else
+ {
+ uint32_t size = bimg::imageGetSize(
+ NULL
+ , uint16_t(dstMip.m_width)
+ , uint16_t(dstMip.m_height)
+ , uint16_t(dstMip.m_depth)
+ , false
+ , false
+ , 1
+ , bimg::TextureFormat::RGBA8
+ );
+ temp = BX_ALLOC(_allocator, size);
+ uint8_t* rgba = (uint8_t*)temp;
+
+ bimg::imageDecodeToRgba8(rgba
+ , mip.m_data
+ , mip.m_width
+ , mip.m_height
+ , mip.m_width*4
+ , mip.m_format
+ );
+
+ float coverage = 0.0f;
+ if (_options.alphaTest)
+ {
+ coverage = bimg::imageAlphaTestCoverage(bimg::TextureFormat::RGBA8
+ , mip.m_width
+ , mip.m_height
+ , mip.m_width*4
+ , rgba
+ , _options.edge
+ );
+ }
+
+ void* ref = NULL;
+ if (_options.iqa)
+ {
+ ref = BX_ALLOC(_allocator, size);
+ bx::memCopy(ref, rgba, size);
+ }
+
+ bimg::imageGetRawData(*output, side, 0, output->m_data, output->m_size, dstMip);
+ dstData = const_cast<uint8_t*>(dstMip.m_data);
+ bimg::imageEncodeFromRgba8(dstData
+ , rgba
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , outputFormat
+ , _options.quality
+ , _err
+ );
+
+ for (uint8_t lod = 1; lod < numMips && _err->isOk(); ++lod)
+ {
+ bimg::imageRgba8Downsample2x2(rgba
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , dstMip.m_width*4
+ , rgba
+ );
+
+ if (_options.alphaTest)
+ {
+ bimg::imageScaleAlphaToCoverage(bimg::TextureFormat::RGBA8
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_width*4
+ , rgba
+ , coverage
+ , _options.edge
+ );
+ }
+
+ bimg::imageGetRawData(*output, side, lod, output->m_data, output->m_size, dstMip);
+ dstData = const_cast<uint8_t*>(dstMip.m_data);
+
+ bimg::imageEncodeFromRgba8(dstData
+ , rgba
+ , dstMip.m_width
+ , dstMip.m_height
+ , dstMip.m_depth
+ , outputFormat
+ , _options.quality
+ , _err
+ );
+ }
+
+ if (NULL != ref)
+ {
+ bimg::imageDecodeToRgba8(rgba
+ , output->m_data
+ , mip.m_width
+ , mip.m_height
+ , mip.m_width*mip.m_bpp/8
+ , outputFormat
+ );
+
+ float result = bimg::imageQualityRgba8(
+ ref
+ , rgba
+ , uint16_t(mip.m_width)
+ , uint16_t(mip.m_height)
+ );
+
+ printf("%f\n", result);
+
+ BX_FREE(_allocator, ref);
+ }
+ }
+
+ BX_FREE(_allocator, temp);
+ }
+ }
+
+ bimg::imageFree(input);
+ }
+
+ if (!_err->isOk()
+ && NULL != output)
+ {
+ bimg::imageFree(output);
+ output = NULL;
+ }
+
+ return output;
+}
+
+void help(const char* _error = NULL, bool _showHelp = true)
+{
+ if (NULL != _error)
+ {
+ fprintf(stderr, "Error:\n%s\n\n", _error);
+
+ if (!_showHelp)
+ {
+ return;
+ }
+ }
+
+ fprintf(stderr
+ , "texturec, bgfx texture compiler tool, version %d.%d.%d.\n"
+ "Copyright 2011-2017 Branimir Karadzic. All rights reserved.\n"
+ "License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause\n\n"
+ , BIMG_TEXTUREC_VERSION_MAJOR
+ , BIMG_TEXTUREC_VERSION_MINOR
+ , BIMG_API_VERSION
+ );
+
+ fprintf(stderr
+ , "Usage: texturec -f <in> -o <out> [-t <texture format>]\n"
+
+ "\n"
+ "Supported file formats:\n"
+ " *.bmp (input) Windows Bitmap.\n"
+ " *.dds (input, output) Direct Draw Surface.\n"
+ " *.exr (input) OpenEXR.\n"
+ " *.gif (input) Graphics Interchange Format.\n"
+ " *.jpg (input) JPEG Interchange Format.\n"
+ " *.hdr (input) Radiance RGBE.\n"
+ " *.ktx (input, output) Khronos Texture.\n"
+ " *.png (input) Portable Network Graphics.\n"
+ " *.psd (input) Photoshop Document.\n"
+ " *.pvr (input) PowerVR.\n"
+ " *.tga (input) Targa.\n"
+
+ "\n"
+ "Options:\n"
+ " -h, --help Help.\n"
+ " -v, --version Version information only.\n"
+ " -f <file path> Input file path.\n"
+ " -o <file path> Output file path.\n"
+ " -t <format> Output format type (BC1/2/3/4/5, ETC1, PVR14, etc.).\n"
+ " -q <quality> Encoding quality (default, fastest, highest).\n"
+ " -m, --mips Generate mip-maps.\n"
+ " -n, --normalmap Input texture is normal map.\n"
+ " --sdf <edge> Compute SDF texture.\n"
+ " --ref <alpha> Alpha reference value.\n"
+ " --iqa Image Quality Assessment\n"
+ " --max <max size> Maximum width/height (image will be scaled down and\n"
+ " aspect ratio will be preserved.\n"
+ " --as <extension> Save as.\n"
+ " --validate *DEBUG* Validate that output image produced matches after loading.\n"
+
+ "\n"
+ "For additional information, see https://github.com/bkaradzic/bgfx\n"
+ );
+}
+
+void help(const char* _str, const bx::Error& _err)
+{
+ std::string str;
+ if (_str != NULL)
+ {
+ str.append(_str);
+ str.append(" ");
+ }
+
+ const bx::StringView& sv = _err.getMessage();
+ str.append(sv.getPtr(), sv.getTerm() - sv.getPtr() );
+
+ help(str.c_str(), false);
+}
+
+int main(int _argc, const char* _argv[])
+{
+ bx::CommandLine cmdLine(_argc, _argv);
+
+ if (cmdLine.hasArg('v', "version") )
+ {
+ fprintf(stderr
+ , "texturec, bgfx texture compiler tool, version %d.%d.%d.\n"
+ , BIMG_TEXTUREC_VERSION_MAJOR
+ , BIMG_TEXTUREC_VERSION_MINOR
+ , BIMG_API_VERSION
+ );
+ return bx::kExitSuccess;
+ }
+
+ if (cmdLine.hasArg('h', "help") )
+ {
+ help();
+ return bx::kExitFailure;
+ }
+
+ const char* inputFileName = cmdLine.findOption('f');
+ if (NULL == inputFileName)
+ {
+ help("Input file must be specified.");
+ return bx::kExitFailure;
+ }
+
+ const char* outputFileName = cmdLine.findOption('o');
+ if (NULL == outputFileName)
+ {
+ help("Output file must be specified.");
+ return bx::kExitFailure;
+ }
+
+ const char* saveAs = cmdLine.findOption("as");
+ saveAs = NULL == saveAs ? bx::strFindI(outputFileName, ".ktx") : saveAs;
+ saveAs = NULL == saveAs ? bx::strFindI(outputFileName, ".dds") : saveAs;
+ if (NULL == saveAs)
+ {
+ help("Output file format must be specified.");
+ return bx::kExitFailure;
+ }
+
+ Options options;
+
+ const char* edgeOpt = cmdLine.findOption("sdf");
+ if (NULL != edgeOpt)
+ {
+ options.sdf = true;
+ if (!bx::fromString(&options.edge, edgeOpt) )
+ {
+ options.edge = 255.0f;
+ }
+ }
+ else
+ {
+ const char* alphaRef = cmdLine.findOption("ref");
+ if (NULL != alphaRef)
+ {
+ options.alphaTest = true;
+ if (!bx::fromString(&options.edge, alphaRef))
+ {
+ options.edge = 0.5f;
+ }
+ }
+ }
+
+ options.mips = cmdLine.hasArg('m', "mips");
+ options.normalMap = cmdLine.hasArg('n', "normalmap");
+ options.iqa = cmdLine.hasArg('\0', "iqa");
+
+ const char* maxSize = cmdLine.findOption("max");
+ if (NULL != maxSize)
+ {
+ options.maxSize = atoi(maxSize);
+ }
+
+ options.format = bimg::TextureFormat::Count;
+ const char* type = cmdLine.findOption('t');
+ if (NULL != type)
+ {
+ options.format = bimg::getFormat(type);
+
+ if (!bimg::isValid(options.format) )
+ {
+ help("Invalid format specified.");
+ return bx::kExitFailure;
+ }
+ }
+
+ const char* quality = cmdLine.findOption('q');
+ if (NULL != quality)
+ {
+ switch (bx::toLower(quality[0]) )
+ {
+ case 'h': options.quality = bimg::Quality::Highest; break;
+ case 'f': options.quality = bimg::Quality::Fastest; break;
+ case 'd': options.quality = bimg::Quality::Default; break;
+ default:
+ help("Invalid quality specified.");
+ return bx::kExitFailure;
+ }
+ }
+
+ const bool validate = cmdLine.hasArg("validate");
+
+ bx::Error err;
+ bx::FileReader reader;
+ if (!bx::open(&reader, inputFileName, &err) )
+ {
+ help("Failed to open input file.", err);
+ return bx::kExitFailure;
+ }
+
+ uint32_t inputSize = (uint32_t)bx::getSize(&reader);
+ if (0 == inputSize)
+ {
+ help("Failed to read input file.", err);
+ return bx::kExitFailure;
+ }
+
+ bx::DefaultAllocator allocator;
+ uint8_t* inputData = (uint8_t*)BX_ALLOC(&allocator, inputSize);
+
+ bx::read(&reader, inputData, inputSize, &err);
+ bx::close(&reader);
+
+ if (!err.isOk() )
+ {
+ help("Failed to read input file.", err);
+ return bx::kExitFailure;
+ }
+
+ bimg::ImageContainer* output = convert(&allocator, inputData, inputSize, options, &err);
+
+ BX_FREE(&allocator, inputData);
+
+ if (NULL != output)
+ {
+ bx::FileWriter writer;
+ if (bx::open(&writer, outputFileName, false, &err) )
+ {
+ if (NULL != bx::strFindI(saveAs, "ktx") )
+ {
+ bimg::imageWriteKtx(&writer, *output, output->m_data, output->m_size, &err);
+ }
+ else if (NULL != bx::strFindI(saveAs, "dds") )
+ {
+ bimg::imageWriteDds(&writer, *output, output->m_data, output->m_size, &err);
+ }
+
+ bx::close(&writer);
+
+ if (!err.isOk() )
+ {
+ help(NULL, err);
+ return bx::kExitFailure;
+ }
+ }
+ else
+ {
+ help("Failed to open output file.", err);
+ return bx::kExitFailure;
+ }
+
+ if (validate)
+ {
+ if (!bx::open(&reader, outputFileName, &err) )
+ {
+ help("Failed to validate file.", err);
+ return bx::kExitFailure;
+ }
+
+ inputSize = (uint32_t)bx::getSize(&reader);
+ if (0 == inputSize)
+ {
+ help("Failed to validate file.", err);
+ return bx::kExitFailure;
+ }
+
+ inputData = (uint8_t*)BX_ALLOC(&allocator, inputSize);
+ bx::read(&reader, inputData, inputSize, &err);
+ bx::close(&reader);
+
+ bimg::ImageContainer* input = bimg::imageParse(&allocator, inputData, inputSize, bimg::TextureFormat::Count, &err);
+ if (!err.isOk() )
+ {
+ help("Failed to validate file.", err);
+ return bx::kExitFailure;
+ }
+
+ if (false
+ || input->m_format != output->m_format
+ || input->m_size != output->m_size
+ || input->m_width != output->m_width
+ || input->m_height != output->m_height
+ || input->m_depth != output->m_depth
+ || input->m_numLayers != output->m_numLayers
+ || input->m_numMips != output->m_numMips
+ || input->m_hasAlpha != output->m_hasAlpha
+ || input->m_cubeMap != output->m_cubeMap
+ )
+ {
+ help("Validation failed, image headers are different.");
+ return bx::kExitFailure;
+ }
+
+ {
+ const uint8_t numMips = output->m_numMips;
+ const uint16_t numSides = output->m_numLayers * (output->m_cubeMap ? 6 : 1);
+
+ for (uint8_t lod = 0; lod < numMips; ++lod)
+ {
+ for (uint16_t side = 0; side < numSides; ++side)
+ {
+ bimg::ImageMip srcMip;
+ bool hasSrc = bimg::imageGetRawData(*input, side, lod, input->m_data, input->m_size, srcMip);
+
+ bimg::ImageMip dstMip;
+ bool hasDst = bimg::imageGetRawData(*output, side, lod, output->m_data, output->m_size, dstMip);
+
+ if (false
+ || hasSrc != hasDst
+ || srcMip.m_size != dstMip.m_size
+ )
+ {
+ help("Validation failed, image mip/layer/side are different.");
+ return bx::kExitFailure;
+ }
+
+ if (0 != bx::memCmp(srcMip.m_data, dstMip.m_data, srcMip.m_size) )
+ {
+ help("Validation failed, image content are different.");
+ return bx::kExitFailure;
+ }
+ }
+ }
+ }
+
+ BX_FREE(&allocator, inputData);
+ }
+
+ bimg::imageFree(output);
+ }
+ else
+ {
+ help(NULL, err);
+ return bx::kExitFailure;
+ }
+
+ return bx::kExitSuccess;
+}