407 lines
14 KiB
C++
407 lines
14 KiB
C++
// -*- tab-width: 4; -*-
|
|
// vi: set sw=2 ts=4 sts=4 expandtab:
|
|
|
|
// Copyright 2019-2020 Mark Callow
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#include "scapp.h"
|
|
|
|
#include <cstdlib>
|
|
#include <errno.h>
|
|
#include <filesystem>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <thread>
|
|
#include <vector>
|
|
#include <ktx.h>
|
|
|
|
#include "argparser.h"
|
|
#include "version.h"
|
|
|
|
#if defined(_MSC_VER)
|
|
#define strncasecmp _strnicmp
|
|
#define fileno _fileno
|
|
#define mktemp _mkstemp
|
|
#define isatty _isatty
|
|
#endif
|
|
|
|
#if defined(_MSC_VER)
|
|
#undef min
|
|
#undef max
|
|
#endif
|
|
|
|
using namespace std;
|
|
|
|
/** @page ktxsc ktxsc
|
|
@~English
|
|
|
|
Supercompress the images in a KTX2 file.
|
|
|
|
@section ktxsc_synopsis SYNOPSIS
|
|
ktxsc [options] [@e infile ...]
|
|
|
|
@section ktxsc_description DESCRIPTION
|
|
@b ktxsc can encode and supercompress the images in Khronos texture
|
|
format version 2 files (KTX2). Uncompressed files, i.e those whose vkFormat
|
|
name does not end in @c _BLOCK can be encoded to ASTC, Basis Universal
|
|
(encoded to ETC1S then supercompressed with an integrated LZ step)
|
|
or UASTC and optionally supercompressed with Zstandard (zstd). Any image
|
|
format, except Basis Universal, can be supercompressed with zstd. For best
|
|
results with UASTC, the data should be conditioned for zstd by using the
|
|
@e --uastc_rdo_q and, optionally, @e --uastc_rdo_d options.
|
|
|
|
@b ktxsc reads each named @e infile and compresses it in place. When
|
|
@e infile is not specified, a single file will be read from @e stdin and the
|
|
output written to @e stdout. When one or more files is specified each will
|
|
be compressed in place.
|
|
|
|
The following options are available:
|
|
<dl>
|
|
<dt>-o outfile, --output=outfile</dt>
|
|
<dd>Write the output to @e outfile. If @e outfile is 'stdout', output will
|
|
be written to stdout. Parent directories will be created, if
|
|
necessary. If there is more than 1 @e infile the command prints its
|
|
usage message and exits.</dd>
|
|
<dt>-f, \--force</dt>
|
|
<dd>If the destination file cannot be opened, remove it and create a
|
|
new file, without prompting for confirmation regardless of its
|
|
permissions.</dd>
|
|
<dt>\--t2</dt>
|
|
<dd>Output a KTX version2 file. Always true.</dd>
|
|
</dl>
|
|
@snippet{doc} scapp.h scApp options
|
|
|
|
@section ktxsc_exitstatus EXIT STATUS
|
|
@b ktxsc exits 0 on success, 1 on command line errors and 2 on
|
|
functional errors.
|
|
|
|
@section ktxsc_history HISTORY
|
|
|
|
@par Version 4.0
|
|
- Initial version.
|
|
|
|
@section ktxsc_author AUTHOR
|
|
Mark Callow, github.com/MarkCallow
|
|
*/
|
|
|
|
#define QUOTE(x) #x
|
|
#define STR(x) QUOTE(x)
|
|
|
|
std::string myversion(STR(KTXSC_VERSION));
|
|
std::string mydefversion(STR(KTXSC_DEFAULT_VERSION));
|
|
|
|
class ktxSupercompressor : public scApp {
|
|
public:
|
|
ktxSupercompressor();
|
|
|
|
virtual int main(int argc, char* argv[]);
|
|
virtual void usage();
|
|
|
|
protected:
|
|
virtual bool processOption(argparser& parser, int opt);
|
|
void validateOptions();
|
|
|
|
struct commandOptions : public scApp::commandOptions {
|
|
bool useStdout;
|
|
bool force;
|
|
|
|
commandOptions() {
|
|
force = false;
|
|
useStdout = false;
|
|
}
|
|
} options;
|
|
};
|
|
|
|
ktxSupercompressor::ktxSupercompressor() : scApp(myversion, mydefversion, options)
|
|
{
|
|
argparser::option my_option_list[] = {
|
|
{ "force", argparser::option::no_argument, NULL, 'f' },
|
|
{ "outfile", argparser::option::required_argument, NULL, 'o' },
|
|
};
|
|
const int lastOptionIndex = sizeof(my_option_list)
|
|
/ sizeof(argparser::option);
|
|
option_list.insert(option_list.begin(), my_option_list,
|
|
my_option_list + lastOptionIndex);
|
|
short_opts += "fo:";
|
|
}
|
|
|
|
void
|
|
ktxSupercompressor::usage()
|
|
{
|
|
cerr <<
|
|
"Usage: " << name << " [options] [<infile> ...]\n"
|
|
"\n"
|
|
" infile The ktx2 file(s) to supercompress. The output is written to a\n"
|
|
" file of the same name. If infile not specified input will be read\n"
|
|
" from stdin and the compressed texture written to stdout.\n"
|
|
"\n"
|
|
" Options are:\n"
|
|
"\n"
|
|
" -o outfile, --output=outfile\n"
|
|
" Writes the output to outfile. If outfile is 'stdout', output\n"
|
|
" will be written to stdout. Parent directories will be\n"
|
|
" created if necessary. If there is more than 1 input file\n"
|
|
" the command prints its usage message and exits.\n"
|
|
" -f, --force If the output file cannot be opened, remove it and create a\n"
|
|
" new file, without prompting for confirmation regardless of\n"
|
|
" its permissions.\n";
|
|
scApp::usage();
|
|
}
|
|
|
|
|
|
static string dir_name(const string& path)
|
|
{
|
|
// Supports both Unix-style and Windows-style.
|
|
size_t last_separator = path.find_last_of("/\\");
|
|
if (last_separator != string::npos) {
|
|
return path.substr(0, last_separator + 1);
|
|
} else {
|
|
return std::basic_string<char>();
|
|
}
|
|
}
|
|
|
|
static ktxSupercompressor ktxsc;
|
|
ktxApp& theApp = ktxsc;
|
|
|
|
int
|
|
ktxSupercompressor::main(int argc, char* argv[])
|
|
{
|
|
FILE *inf, *outf = nullptr;
|
|
KTX_error_code result;
|
|
ktxTexture2* texture = 0;
|
|
int exitCode = 0;
|
|
string tmpfile;
|
|
|
|
processCommandLine(argc, argv, eAllowStdin);
|
|
validateOptions();
|
|
|
|
std::vector<string>::const_iterator it;
|
|
for (it = options.infiles.begin(); it < options.infiles.end(); it++) {
|
|
string infile = *it;
|
|
|
|
if (infile.compare("-") == 0) {
|
|
inf = stdin;
|
|
#if defined(_WIN32)
|
|
/* Set "stdin" to have binary mode */
|
|
(void)_setmode( _fileno( stdin ), _O_BINARY );
|
|
#endif
|
|
} else {
|
|
inf = fopenUTF8(infile, "rb");
|
|
}
|
|
|
|
if (inf) {
|
|
if (options.useStdout) {
|
|
outf = stdout;
|
|
#if defined(_WIN32)
|
|
/* Set "stdout" to have binary mode */
|
|
(void)_setmode( _fileno( stdout ), _O_BINARY );
|
|
#endif
|
|
} else if (options.outfile.length()) {
|
|
const auto outputPath = filesystem::path(DecodeUTF8Path(options.outfile));
|
|
if (outputPath.has_parent_path())
|
|
filesystem::create_directories(outputPath.parent_path());
|
|
outf = fopen_write_if_not_exists(options.outfile);
|
|
} else {
|
|
// Make a temporary file in the same directory as the source
|
|
// file to avoid cross-device rename issues later.
|
|
tmpfile = dir_name(infile) + "ktxsc.tmp.XXXXXX";
|
|
#if defined(_WIN32)
|
|
// Despite receiving size() the debug CRT version of mktemp_s
|
|
// asserts that the string template is NUL terminated.
|
|
tmpfile.push_back('\0');
|
|
if (_wmktemp_s(&DecodeUTF8Path(tmpfile)[0], tmpfile.size()) == 0)
|
|
outf = fopenUTF8(tmpfile, "wb");
|
|
#else
|
|
int fd_tmp = mkstemp(&tmpfile[0]);
|
|
outf = fdopen(fd_tmp, "wb");
|
|
#endif
|
|
}
|
|
|
|
if (!outf && errno == EEXIST) {
|
|
bool force = options.force;
|
|
if (!force) {
|
|
if (isatty(fileno(stdin))) {
|
|
char answer;
|
|
cout << "Output file " << options.outfile
|
|
<< " exists. Overwrite? [Y or n] ";
|
|
cin >> answer;
|
|
if (answer == 'Y') {
|
|
force = true;
|
|
}
|
|
}
|
|
}
|
|
if (force) {
|
|
outf = fopenUTF8(options.outfile, "wb");
|
|
}
|
|
}
|
|
|
|
if (outf) {
|
|
result = ktxTexture2_CreateFromStdioStream(inf,
|
|
KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
|
|
&texture);
|
|
if (result == KTX_UNKNOWN_FILE_FORMAT) {
|
|
cerr << infile << " is not a KTX v2 file." << endl;
|
|
exitCode = 2;
|
|
goto cleanup;
|
|
} else if (result != KTX_SUCCESS) {
|
|
cerr << name
|
|
<< " failed to create ktxTexture from " << infile
|
|
<< ": " << ktxErrorString(result) << endl;
|
|
exitCode = 2;
|
|
goto cleanup;
|
|
}
|
|
(void)fclose(inf);
|
|
|
|
if (texture->classId != ktxTexture2_c) {
|
|
cerr << name << ": "
|
|
<< "Only KTX texture version 2 files can be supercompressed."
|
|
<< endl;
|
|
exitCode = 1;
|
|
goto cleanup;
|
|
}
|
|
if (texture->supercompressionScheme != KTX_SS_NONE) {
|
|
cerr << name << ": "
|
|
<< "Cannot supercompress already supercompressed files."
|
|
<< endl;
|
|
exitCode = 1;
|
|
goto cleanup;
|
|
}
|
|
if ((options.astc || options.etc1s || options.bopts.uastc) && texture->isCompressed) {
|
|
cerr << name << ": "
|
|
<< "Cannot encode already block-compressed textures "
|
|
<< "to ASTC, Basis Universal or UASTC."
|
|
<< endl;
|
|
exitCode = 1;
|
|
goto cleanup;
|
|
}
|
|
|
|
// Modify the writer metadata.
|
|
stringstream writer;
|
|
writeId(writer, true);
|
|
ktxHashList_DeleteKVPair(&texture->kvDataHead, KTX_WRITER_KEY);
|
|
ktxHashList_AddKVPair(&texture->kvDataHead, KTX_WRITER_KEY,
|
|
(ktx_uint32_t)writer.str().length() + 1,
|
|
writer.str().c_str());
|
|
|
|
exitCode = encode(texture, options.inputSwizzle, infile);
|
|
if (exitCode)
|
|
goto cleanup;
|
|
result = ktxTexture_WriteToStdioStream(ktxTexture(texture), outf);
|
|
if (result != KTX_SUCCESS) {
|
|
cerr << name
|
|
<< " failed to write KTX file; "
|
|
<< ktxErrorString(result) << endl;
|
|
exitCode = 2;
|
|
goto cleanup;
|
|
}
|
|
(void)fclose(outf);
|
|
if (!options.outfile.length() && !options.useStdout) {
|
|
// Move the new file over the original.
|
|
assert(tmpfile.size() > 0 && infile.length());
|
|
#if defined(_WIN32)
|
|
// Windows' rename() fails if the destination file exists!
|
|
if (!MoveFileExW(DecodeUTF8Path(tmpfile).c_str(), DecodeUTF8Path(infile).c_str(),
|
|
MOVEFILE_REPLACE_EXISTING))
|
|
#else
|
|
if (rename(tmpfile.c_str(), infile.c_str()))
|
|
#endif
|
|
{
|
|
cerr << name
|
|
<< ": rename of \"" << tmpfile << "\" to \""
|
|
<< infile << "\" failed: "
|
|
<< strerror(errno) << endl;
|
|
exitCode = 2;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
} else {
|
|
cerr << name
|
|
<< " could not open output file \""
|
|
<< (options.useStdout ? "stdout" : options.outfile) << "\". "
|
|
<< strerror(errno) << endl;
|
|
exitCode = 2;
|
|
goto cleanup;
|
|
}
|
|
} else {
|
|
cerr << name
|
|
<< " could not open input file \""
|
|
<< (infile.compare("-") == 0 ? "stdin" : infile) << "\". "
|
|
<< strerror(errno) << endl;
|
|
exitCode = 2;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
cleanup:
|
|
if (outf) { // Windows debug CRT fclose asserts that outf != nullptr...
|
|
(void)fclose(outf); // N.B Windows refuses to unlink an open file.
|
|
}
|
|
if (tmpfile.size() > 0) (void)unlinkUTF8(tmpfile);
|
|
if (options.outfile.length()) (void)unlinkUTF8(options.outfile);
|
|
return exitCode;
|
|
}
|
|
|
|
|
|
void
|
|
ktxSupercompressor::validateOptions()
|
|
{
|
|
scApp::validateOptions();
|
|
|
|
if (options.infiles.size() > 1 && options.outfile.length()) {
|
|
cerr << "Can't use -o when there are multiple infiles." << endl;
|
|
usage();
|
|
exit(1);
|
|
}
|
|
if (options.etc1s && options.zcmp) {
|
|
cerr << "Can't encode to etc1s and supercompress with zstd." << endl;
|
|
usage();
|
|
exit(1);
|
|
}
|
|
if (!options.astc && !options.etc1s && !options.zcmp && !options.bopts.uastc) {
|
|
cerr << "Must specify one of --zcmp, --etc1s (deprecated --bcmp) or --uastc." << endl;
|
|
usage();
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* @brief process a command line option
|
|
*
|
|
* @return true of option processed.
|
|
*
|
|
* @param[in] parser, an @c argparser holding the options to process.
|
|
*/
|
|
bool
|
|
ktxSupercompressor::processOption(argparser& parser, int opt)
|
|
{
|
|
switch (opt) {
|
|
case 'f':
|
|
options.force = true;
|
|
break;
|
|
case 'o':
|
|
options.outfile = parser.optarg;
|
|
if (!options.outfile.compare("stdout")) {
|
|
options.useStdout = true;
|
|
} else {
|
|
size_t dot;
|
|
size_t slash;
|
|
dot = options.outfile.find_last_of('.');
|
|
slash = options.outfile.find_last_of('/');
|
|
if (slash == string::npos) {
|
|
slash = options.outfile.find_last_of('\\');
|
|
}
|
|
// dot < slash means there's a dot but it is not prefixing
|
|
// a file extension.
|
|
if (dot == string::npos
|
|
|| (slash != string::npos && dot < slash)) {
|
|
options.outfile += ".ktx2";
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
return scApp::processOption(parser, opt);
|
|
}
|
|
return true;
|
|
}
|