jessikitty/crunch
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v1.03 prerelease - Full Linux port of crnlib/crunch, in progress - still more testing to do, and some cmd line options (such as -timestamp) don't work under linux yet, but the core stuff (compression/decompression/transcoding) should work fine and performance under Linux is comparable to Windows. The 3 examples haven't been ported yet.

Browse Source
This commit is contained in:
richgel99@gmail.com
2012-04-26 07:14:21 +00:00
parent fffd983ffa
commit f63e26aee6
89 changed files with 3547 additions and 3829 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crnlib/crn_arealist.cpp
+1 -2
View File
@@ -3,7 +3,6 @@
// Ported from the PowerView DOS image viewer, a product I wrote back in 1993. Not currently used in the open source release of crnlib.
#include "crn_core.h"
#include "crn_arealist.h"
#include <stdio.h>
#define RECT_DEBUG
@@ -20,7 +19,7 @@ namespace crnlib
#ifdef _MSC_VER
_vsnprintf_s(buf, sizeof(buf), pMsg, args);
#else
_vsnprintf(buf, sizeof(buf), pMsg, args);
vsnprintf(buf, sizeof(buf), pMsg, args);
#endif
va_end(args);
crnlib/crn_assert.cpp
+8 -16
View File
@@ -1,8 +1,9 @@
// File: crn_assert.cpp
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#if CRNLIB_USE_WIN32_API
#include "crn_winhdr.h"
#include <stdio.h>
#endif
static bool g_fail_exceptions;
static bool g_exit_on_failure = true;
@@ -16,15 +17,11 @@ void crnlib_assert(const char* pExp, const char* pFile, unsigned line)
{
char buf[512];
#if defined(WIN32) && defined(_MSC_VER)
sprintf_s(buf, sizeof(buf), "%s(%u): Assertion failed: \"%s\"\n", pFile, line, pExp);
#else
sprintf(buf, "%s(%u): Assertion failed: \"%s\"\n", pFile, line, pExp);
#endif
crnlib_output_debug_string(buf);
printf(buf);
fputs(buf, stderr);
if (crnlib_is_debugger_present())
crnlib_debug_break();
@@ -34,22 +31,21 @@ void crnlib_fail(const char* pExp, const char* pFile, unsigned line)
{
char buf[512];
#if defined(WIN32) && defined(_MSC_VER)
sprintf_s(buf, sizeof(buf), "%s(%u): Failure: \"%s\"\n", pFile, line, pExp);
#else
sprintf(buf, "%s(%u): Failure: \"%s\"\n", pFile, line, pExp);
#endif
crnlib_output_debug_string(buf);
printf(buf);
fputs(buf, stderr);
if (crnlib_is_debugger_present())
crnlib_debug_break();
#if CRNLIB_USE_WIN32_API
if (g_fail_exceptions)
RaiseException(CRNLIB_FAIL_EXCEPTION_CODE, 0, 0, NULL);
else if (g_exit_on_failure)
else
#endif
if (g_exit_on_failure)
exit(EXIT_FAILURE);
}
@@ -58,11 +54,7 @@ void trace(const char* pFmt, va_list args)
if (crnlib_is_debugger_present())
{
char buf[512];
#if defined(WIN32) && defined(_MSC_VER)
vsprintf_s(buf, sizeof(buf), pFmt, args);
#else
vsprintf(buf, pFmt, args);
#endif
crnlib_output_debug_string(buf);
}
crnlib/crn_cfile_stream.h
+16 -21
View File
@@ -2,7 +2,6 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#pragma once
#include "crn_data_stream.h"
#include <stdio.h>
namespace crnlib
{
@@ -13,13 +12,13 @@ namespace crnlib
{
}
cfile_stream(FILE* pFile, const wchar_t* pFilename, uint attribs, bool has_ownership) :
cfile_stream(FILE* pFile, const char* pFilename, uint attribs, bool has_ownership) :
data_stream(), m_pFile(NULL), m_size(0), m_ofs(0), m_has_ownership(false)
{
open(pFile, pFilename, attribs, has_ownership);
}
cfile_stream(const wchar_t* pFilename, uint attribs = cDataStreamReadable | cDataStreamSeekable, bool open_existing = false) :
cfile_stream(const char* pFilename, uint attribs = cDataStreamReadable | cDataStreamSeekable, bool open_existing = false) :
data_stream(), m_pFile(NULL), m_size(0), m_ofs(0), m_has_ownership(false)
{
open(pFilename, attribs, open_existing);
@@ -55,7 +54,7 @@ namespace crnlib
return false;
}
bool open(FILE* pFile, const wchar_t* pFilename, uint attribs, bool has_ownership)
bool open(FILE* pFile, const char* pFilename, uint attribs, bool has_ownership)
{
CRNLIB_ASSERT(pFile);
CRNLIB_ASSERT(pFilename);
@@ -67,17 +66,17 @@ namespace crnlib
m_has_ownership = has_ownership;
m_attribs = static_cast<uint16>(attribs);
m_ofs = _ftelli64(m_pFile);
_fseeki64(m_pFile, 0, SEEK_END);
m_size = _ftelli64(m_pFile);
_fseeki64(m_pFile, m_ofs, SEEK_SET);
m_ofs = crn_ftell(m_pFile);
crn_fseek(m_pFile, 0, SEEK_END);
m_size = crn_ftell(m_pFile);
crn_fseek(m_pFile, m_ofs, SEEK_SET);
m_opened = true;
return true;
}
bool open(const wchar_t* pFilename, uint attribs = cDataStreamReadable | cDataStreamSeekable, bool open_existing = false)
bool open(const char* pFilename, uint attribs = cDataStreamReadable | cDataStreamSeekable, bool open_existing = false)
{
CRNLIB_ASSERT(pFilename);
@@ -85,13 +84,13 @@ namespace crnlib
m_attribs = static_cast<uint16>(attribs);
const wchar_t* pMode;
const char* pMode;
if ((is_readable()) && (is_writable()))
pMode = open_existing ? L"r+b" : L"w+b";
pMode = open_existing ? "r+b" : "w+b";
else if (is_writable())
pMode = open_existing ? L"ab" : L"wb";
pMode = open_existing ? "ab" : "wb";
else if (is_readable())
pMode = L"rb";
pMode = "rb";
else
{
set_error();
@@ -99,11 +98,7 @@ namespace crnlib
}
FILE* pFile = NULL;
#ifdef _MSC_VER
_wfopen_s(&pFile, pFilename, pMode);
#else
pFile = _wfopen(pFilename, pMode);
#endif
crn_fopen(&pFile, pFilename, pMode);
m_has_ownership = true;
if (!pFile)
@@ -209,7 +204,7 @@ namespace crnlib
if (static_cast<uint64>(new_ofs) != m_ofs)
{
if (_fseeki64(m_pFile, new_ofs, SEEK_SET) != 0)
if (crn_fseek(m_pFile, new_ofs, SEEK_SET) != 0)
{
set_error();
return false;
@@ -221,7 +216,7 @@ namespace crnlib
return true;
}
static bool read_file_into_array(const wchar_t* pFilename, vector<uint8>& buf)
static bool read_file_into_array(const char* pFilename, vector<uint8>& buf)
{
cfile_stream in_stream(pFilename);
if (!in_stream.is_opened())
@@ -229,7 +224,7 @@ namespace crnlib
return in_stream.read_array(buf);
}
static bool write_array_to_file(const wchar_t* pFilename, const vector<uint8>& buf)
static bool write_array_to_file(const char* pFilename, const vector<uint8>& buf)
{
cfile_stream out_stream(pFilename, cDataStreamWritable|cDataStreamSeekable);
if (!out_stream.is_opened())
crnlib/crn_clusterizer.h
+5 -5
View File
@@ -140,7 +140,7 @@ namespace crnlib
inline uint get_num_training_vecs() const { return m_training_vecs.size(); }
const VectorType& get_training_vec(uint index) const { return m_training_vecs[index].first; }
const uint get_training_vec_weight(uint index) const { return m_training_vecs[index].second; }
uint get_training_vec_weight(uint index) const { return m_training_vecs[index].second; }
typedef crnlib::vector< std::pair<VectorType, uint> > training_vec_array;
@@ -170,7 +170,7 @@ namespace crnlib
return m_codebook;
}
const uint find_best_codebook_entry(const VectorType& v) const
uint find_best_codebook_entry(const VectorType& v) const
{
uint cur_node_index = 0;
@@ -218,7 +218,7 @@ namespace crnlib
}
}
const uint find_best_codebook_entry_fs(const VectorType& v) const
uint find_best_codebook_entry_fs(const VectorType& v) const
{
float best_dist = math::cNearlyInfinite;
uint best_index = 0;
@@ -362,7 +362,7 @@ namespace crnlib
void compute_split_estimate(VectorType& left_child_res, VectorType& right_child_res, const vq_node& parent_node)
{
VectorType furthest;
VectorType furthest(0);
double furthest_dist = -1.0f;
for (uint i = 0; i < parent_node.m_vectors.size(); i++)
@@ -377,7 +377,7 @@ namespace crnlib
}
}
VectorType opposite;
VectorType opposite(0);
double opposite_dist = -1.0f;
for (uint i = 0; i < parent_node.m_vectors.size(); i++)
crnlib/crn_color.h
+14 -14
View File
@@ -11,8 +11,8 @@ namespace crnlib
{
cSigned = false,
cFloat = false,
cMin = UINT8_MIN,
cMax = UINT8_MAX
cMin = cUINT8_MIN,
cMax = cUINT8_MAX
};
};
@@ -22,8 +22,8 @@ namespace crnlib
{
cSigned = true,
cFloat = false,
cMin = INT16_MIN,
cMax = INT16_MAX
cMin = cINT16_MIN,
cMax = cINT16_MAX
};
};
@@ -33,8 +33,8 @@ namespace crnlib
{
cSigned = false,
cFloat = false,
cMin = UINT16_MIN,
cMax = UINT16_MAX
cMin = cUINT16_MIN,
cMax = cUINT16_MAX
};
};
@@ -44,8 +44,8 @@ namespace crnlib
{
cSigned = true,
cFloat = false,
cMin = INT32_MIN,
cMax = INT32_MAX
cMin = cINT32_MIN,
cMax = cINT32_MAX
};
};
@@ -55,8 +55,8 @@ namespace crnlib
{
cSigned = false,
cFloat = false,
cMin = UINT32_MIN,
cMax = UINT32_MAX
cMin = cUINT32_MIN,
cMax = cUINT32_MAX
};
};
@@ -66,8 +66,8 @@ namespace crnlib
{
cSigned = false,
cFloat = true,
cMin = INT32_MIN,
cMax = INT32_MAX
cMin = cINT32_MIN,
cMax = cINT32_MAX
};
};
@@ -77,8 +77,8 @@ namespace crnlib
{
cSigned = false,
cFloat = true,
cMin = INT32_MIN,
cMax = INT32_MAX
cMin = cINT32_MIN,
cMax = cINT32_MAX
};
};
crnlib/crn_command_line_params.cpp
+88 -55
View File
@@ -5,8 +5,34 @@
#include "crn_console.h"
#include "crn_cfile_stream.h"
#ifdef WIN32
#define CRNLIB_CMD_LINE_ALLOW_SLASH_PARAMS 1
#endif
#if CRNLIB_USE_WIN32_API
#include "crn_winhdr.h"
#endif
namespace crnlib
{
void get_command_line(dynamic_string& cmd_line, int argc, char *argv[])
{
argc, argv;
#if CRNLIB_USE_WIN32_API
cmd_line.set(GetCommandLineA());
#else
cmd_line.clear();
for (int i = 0; i < argc; i++)
{
dynamic_string tmp(argv[i]);
if ((tmp.front() != '"') && (tmp.front() != '-') && (tmp.front() != '@'))
tmp = "\"" + tmp + "\"";
if (cmd_line.get_len())
cmd_line += " ";
cmd_line += tmp;
}
#endif
}
command_line_params::command_line_params()
{
}
@@ -18,28 +44,28 @@ namespace crnlib
m_param_map.clear();
}
bool command_line_params::split_params(const wchar_t* p, dynamic_wstring_array& params)
bool command_line_params::split_params(const char* p, dynamic_string_array& params)
{
bool within_param = false;
bool within_quote = false;
uint ofs = 0;
dynamic_wstring str;
dynamic_string str;
while (p[ofs])
{
const wchar_t c = p[ofs];
const char c = p[ofs];
if (within_param)
{
if (within_quote)
{
if (c == L'"')
if (c == '"')
within_quote = false;
str.append_char(c);
}
else if ((c == L' ') || (c == L'\t'))
else if ((c == ' ') || (c == '\t'))
{
if (!str.is_empty())
{
@@ -50,17 +76,17 @@ namespace crnlib
}
else
{
if (c == L'"')
if (c == '"')
within_quote = true;
str.append_char(c);
}
}
else if ((c != L' ') && (c != L'\t'))
else if ((c != ' ') && (c != '\t'))
{
within_param = true;
if (c == L'"')
if (c == '"')
within_quote = true;
str.append_char(c);
@@ -71,7 +97,7 @@ namespace crnlib
if (within_quote)
{
console::error(L"Unmatched quote in command line \"%s\"", p);
console::error("Unmatched quote in command line \"%s\"", p);
return false;
}
@@ -81,12 +107,12 @@ namespace crnlib
return true;
}
bool command_line_params::load_string_file(const wchar_t* pFilename, dynamic_wstring_array& strings)
bool command_line_params::load_string_file(const char* pFilename, dynamic_string_array& strings)
{
cfile_stream in_stream;
if (!in_stream.open(pFilename, cDataStreamReadable | cDataStreamSeekable))
{
console::error(L"Unable to open file \"%s\" for reading!", pFilename);
console::error("Unable to open file \"%s\" for reading!", pFilename);
return false;
}
@@ -101,13 +127,13 @@ namespace crnlib
if (ansi_str.is_empty())
continue;
strings.push_back(dynamic_wstring(ansi_str.get_ptr()));
strings.push_back(dynamic_string(ansi_str.get_ptr()));
}
return true;
}
bool command_line_params::parse(const dynamic_wstring_array& params, uint n, const param_desc* pParam_desc)
bool command_line_params::parse(const dynamic_string_array& params, uint n, const param_desc* pParam_desc)
{
CRNLIB_ASSERT(n && pParam_desc);
@@ -117,28 +143,31 @@ namespace crnlib
while (arg_index < params.size())
{
const uint cur_arg_index = arg_index;
const dynamic_wstring& src_param = params[arg_index++];
const dynamic_string& src_param = params[arg_index++];
if (src_param.is_empty())
continue;
if ((src_param[0] == L'/') || (src_param[0] == L'-'))
#if CRNLIB_CMD_LINE_ALLOW_SLASH_PARAMS
if ((src_param[0] == '/') || (src_param[0] == '-'))
#else
if (src_param[0] == '-')
#endif
{
if (src_param.get_len() < 2)
{
console::error(L"Invalid command line parameter: \"%s\"", src_param.get_ptr());
console::error("Invalid command line parameter: \"%s\"", src_param.get_ptr());
return false;
}
dynamic_wstring key_str(src_param);
dynamic_string key_str(src_param);
key_str.right(1);
int modifier = 0;
wchar_t c = key_str[key_str.get_len() - 1];
if (c == L'+')
char c = key_str[key_str.get_len() - 1];
if (c == '+')
modifier = 1;
else if (c == L'-')
else if (c == '-')
modifier = -1;
if (modifier)
@@ -151,14 +180,14 @@ namespace crnlib
if (param_index == n)
{
console::error(L"Unrecognized command line parameter: \"%s\"", src_param.get_ptr());
console::error("Unrecognized command line parameter: \"%s\"", src_param.get_ptr());
return false;
}
const param_desc& desc = pParam_desc[param_index];
const uint cMaxValues = 16;
dynamic_wstring val_str[cMaxValues];
dynamic_string val_str[cMaxValues];
uint num_val_strs = 0;
if (desc.m_num_values)
{
@@ -166,7 +195,7 @@ namespace crnlib
if ((arg_index + desc.m_num_values) > params.size())
{
console::error(L"Expected %u value(s) after command line parameter: \"%s\"", desc.m_num_values, src_param.get_ptr());
console::error("Expected %u value(s) after command line parameter: \"%s\"", desc.m_num_values, src_param.get_ptr());
return false;
}
@@ -174,17 +203,17 @@ namespace crnlib
val_str[num_val_strs++] = params[arg_index++];
}
dynamic_wstring_array strings;
dynamic_string_array strings;
if ((desc.m_support_listing_file) && (val_str[0].get_len() >= 2) && (val_str[0][0] == L'@'))
if ((desc.m_support_listing_file) && (val_str[0].get_len() >= 2) && (val_str[0][0] == '@'))
{
dynamic_wstring filename(val_str[0]);
dynamic_string filename(val_str[0]);
filename.right(1);
filename.unquote();
if (!load_string_file(filename.get_ptr(), strings))
{
console::error(L"Failed loading listing file \"%s\"!", filename.get_ptr());
console::error("Failed loading listing file \"%s\"!", filename.get_ptr());
return false;
}
}
@@ -209,18 +238,18 @@ namespace crnlib
pv.m_values.push_back(src_param);
pv.m_values.back().unquote();
pv.m_index = cur_arg_index;
m_param_map.insert(std::make_pair(g_empty_dynamic_wstring, pv));
m_param_map.insert(std::make_pair(g_empty_dynamic_string, pv));
}
}
return true;
}
bool command_line_params::parse(const wchar_t* pCmd_line, uint n, const param_desc* pParam_desc, bool skip_first_param)
bool command_line_params::parse(const char* pCmd_line, uint n, const param_desc* pParam_desc, bool skip_first_param)
{
CRNLIB_ASSERT(n && pParam_desc);
dynamic_wstring_array p;
dynamic_string_array p;
if (!split_params(pCmd_line, p))
return 0;
@@ -239,14 +268,18 @@ namespace crnlib
if (index >= m_params.size())
return false;
const dynamic_wstring& w = m_params[index];
const dynamic_string& w = m_params[index];
if (w.is_empty())
return false;
return (w.get_len() >= 2) && ((w[0] == L'-') || (w[0] == L'/'));
#if CRNLIB_CMD_LINE_ALLOW_SLASH_PARAMS
return (w.get_len() >= 2) && ((w[0] == '-') || (w[0] == '/'));
#else
return (w.get_len() >= 2) && (w[0] == '-');
#endif
}
uint command_line_params::find(uint num_keys, const wchar_t** ppKeys, crnlib::vector<param_map_const_iterator>* pIterators, crnlib::vector<uint>* pUnmatched_indices) const
uint command_line_params::find(uint num_keys, const char** ppKeys, crnlib::vector<param_map_const_iterator>* pIterators, crnlib::vector<uint>* pUnmatched_indices) const
{
CRNLIB_ASSERT(ppKeys);
@@ -260,7 +293,7 @@ namespace crnlib
uint n = 0;
for (uint i = 0; i < num_keys; i++)
{
const wchar_t* pKey = ppKeys[i];
const char* pKey = ppKeys[i];
param_map_const_iterator begin, end;
find(pKey, begin, end);
@@ -285,14 +318,14 @@ namespace crnlib
return n;
}
void command_line_params::find(const wchar_t* pKey, param_map_const_iterator& begin, param_map_const_iterator& end) const
void command_line_params::find(const char* pKey, param_map_const_iterator& begin, param_map_const_iterator& end) const
{
dynamic_wstring key(pKey);
dynamic_string key(pKey);
begin = m_param_map.lower_bound(key);
end = m_param_map.upper_bound(key);
}
uint command_line_params::get_count(const wchar_t* pKey) const
uint command_line_params::get_count(const char* pKey) const
{
param_map_const_iterator begin, end;
find(pKey, begin, end);
@@ -308,7 +341,7 @@ namespace crnlib
return n;
}
command_line_params::param_map_const_iterator command_line_params::get_param(const wchar_t* pKey, uint index) const
command_line_params::param_map_const_iterator command_line_params::get_param(const char* pKey, uint index) const
{
param_map_const_iterator begin, end;
find(pKey, begin, end);
@@ -330,12 +363,12 @@ namespace crnlib
return begin;
}
bool command_line_params::has_value(const wchar_t* pKey, uint index) const
bool command_line_params::has_value(const char* pKey, uint index) const
{
return get_num_values(pKey, index) != 0;
}
uint command_line_params::get_num_values(const wchar_t* pKey, uint index) const
uint command_line_params::get_num_values(const char* pKey, uint index) const
{
param_map_const_iterator it = get_param(pKey, index);
@@ -345,7 +378,7 @@ namespace crnlib
return it->second.m_values.size();
}
bool command_line_params::get_value_as_bool(const wchar_t* pKey, uint index, bool def) const
bool command_line_params::get_value_as_bool(const char* pKey, uint index, bool def) const
{
param_map_const_iterator it = get_param(pKey, index);
if (it == end())
@@ -357,63 +390,63 @@ namespace crnlib
return true;
}
int command_line_params::get_value_as_int(const wchar_t* pKey, uint index, int def, int l, int h, uint value_index) const
int command_line_params::get_value_as_int(const char* pKey, uint index, int def, int l, int h, uint value_index) const
{
param_map_const_iterator it = get_param(pKey, index);
if ((it == end()) || (value_index >= it->second.m_values.size()))
return def;
int val;
const wchar_t* p = it->second.m_values[value_index].get_ptr();
const char* p = it->second.m_values[value_index].get_ptr();
if (!string_to_int(p, val))
{
crnlib::console::warning(L"Invalid value specified for parameter \"%s\", using default value of %i", pKey, def);
crnlib::console::warning("Invalid value specified for parameter \"%s\", using default value of %i", pKey, def);
return def;
}
if (val < l)
{
crnlib::console::warning(L"Value %i for parameter \"%s\" is out of range, clamping to %i", val, pKey, l);
crnlib::console::warning("Value %i for parameter \"%s\" is out of range, clamping to %i", val, pKey, l);
val = l;
}
else if (val > h)
{
crnlib::console::warning(L"Value %i for parameter \"%s\" is out of range, clamping to %i", val, pKey, h);
crnlib::console::warning("Value %i for parameter \"%s\" is out of range, clamping to %i", val, pKey, h);
val = h;
}
return val;
}
float command_line_params::get_value_as_float(const wchar_t* pKey, uint index, float def, float l, float h, uint value_index) const
float command_line_params::get_value_as_float(const char* pKey, uint index, float def, float l, float h, uint value_index) const
{
param_map_const_iterator it = get_param(pKey, index);
if ((it == end()) || (value_index >= it->second.m_values.size()))
return def;
float val;
const wchar_t* p = it->second.m_values[value_index].get_ptr();
const char* p = it->second.m_values[value_index].get_ptr();
if (!string_to_float(p, val))
{
crnlib::console::warning(L"Invalid value specified for float parameter \"%s\", using default value of %f", pKey, def);
crnlib::console::warning("Invalid value specified for float parameter \"%s\", using default value of %f", pKey, def);
return def;
}
if (val < l)
{
crnlib::console::warning(L"Value %f for parameter \"%s\" is out of range, clamping to %f", val, pKey, l);
crnlib::console::warning("Value %f for parameter \"%s\" is out of range, clamping to %f", val, pKey, l);
val = l;
}
else if (val > h)
{
crnlib::console::warning(L"Value %f for parameter \"%s\" is out of range, clamping to %f", val, pKey, h);
crnlib::console::warning("Value %f for parameter \"%s\" is out of range, clamping to %f", val, pKey, h);
val = h;
}
return val;
}
bool command_line_params::get_value_as_string(const wchar_t* pKey, uint index, dynamic_wstring& value, uint value_index) const
bool command_line_params::get_value_as_string(const char* pKey, uint index, dynamic_string& value, uint value_index) const
{
param_map_const_iterator it = get_param(pKey, index);
if ((it == end()) || (value_index >= it->second.m_values.size()))
@@ -426,11 +459,11 @@ namespace crnlib
return true;
}
const dynamic_wstring& command_line_params::get_value_as_string_or_empty(const wchar_t* pKey, uint index, uint value_index) const
const dynamic_string& command_line_params::get_value_as_string_or_empty(const char* pKey, uint index, uint value_index) const
{
param_map_const_iterator it = get_param(pKey, index);
if ((it == end()) || (value_index >= it->second.m_values.size()))
return g_empty_dynamic_wstring;
return g_empty_dynamic_string;
return it->second.m_values[value_index];
}
crnlib/crn_command_line_params.h
+24 -22
View File
@@ -6,19 +6,21 @@
namespace crnlib
{
void get_command_line(dynamic_string& cmd_line, int argc, char *argv[]);
class command_line_params
{
public:
struct param_value
{
param_value() : m_index(0), m_modifier(0) { }
inline param_value() : m_index(0), m_modifier(0) { }
dynamic_wstring_array m_values;
dynamic_string_array m_values;
uint m_index;
int8 m_modifier;
};
typedef std::multimap<dynamic_wstring, param_value> param_map;
typedef std::multimap<dynamic_string, param_value> param_map;
typedef param_map::const_iterator param_map_const_iterator;
typedef param_map::iterator param_map_iterator;
@@ -26,19 +28,19 @@ namespace crnlib
void clear();
static bool split_params(const wchar_t* p, dynamic_wstring_array& params);
static bool split_params(const char* p, dynamic_string_array& params);
struct param_desc
{
const wchar_t* m_pName;
const char* m_pName;
uint m_num_values;
bool m_support_listing_file;
};
bool parse(const dynamic_wstring_array& params, uint n, const param_desc* pParam_desc);
bool parse(const wchar_t* pCmd_line, uint n, const param_desc* pParam_desc, bool skip_first_param = true);
bool parse(const dynamic_string_array& params, uint n, const param_desc* pParam_desc);
bool parse(const char* pCmd_line, uint n, const param_desc* pParam_desc, bool skip_first_param = true);
const dynamic_wstring_array& get_array() const { return m_params; }
const dynamic_string_array& get_array() const { return m_params; }
bool is_param(uint index) const;
@@ -49,34 +51,34 @@ namespace crnlib
param_map_const_iterator begin() const { return m_param_map.begin(); }
param_map_const_iterator end() const { return m_param_map.end(); }
uint find(uint num_keys, const wchar_t** ppKeys, crnlib::vector<param_map_const_iterator>* pIterators, crnlib::vector<uint>* pUnmatched_indices) const;
uint find(uint num_keys, const char** ppKeys, crnlib::vector<param_map_const_iterator>* pIterators, crnlib::vector<uint>* pUnmatched_indices) const;
void find(const wchar_t* pKey, param_map_const_iterator& begin, param_map_const_iterator& end) const;
void find(const char* pKey, param_map_const_iterator& begin, param_map_const_iterator& end) const;
uint get_count(const wchar_t* pKey) const;
uint get_count(const char* pKey) const;
// Returns end() if param cannot be found, or index is out of range.
param_map_const_iterator get_param(const wchar_t* pKey, uint index) const;
param_map_const_iterator get_param(const char* pKey, uint index) const;
bool has_key(const wchar_t* pKey) const { return get_param(pKey, 0) != end(); }
bool has_key(const char* pKey) const { return get_param(pKey, 0) != end(); }
bool has_value(const wchar_t* pKey, uint index) const;
uint get_num_values(const wchar_t* pKey, uint index) const;
bool has_value(const char* pKey, uint index) const;
uint get_num_values(const char* pKey, uint index) const;
bool get_value_as_bool(const wchar_t* pKey, uint index = 0, bool def = false) const;
bool get_value_as_bool(const char* pKey, uint index = 0, bool def = false) const;
int get_value_as_int(const wchar_t* pKey, uint index, int def, int l = INT_MIN, int h = INT_MAX, uint value_index = 0) const;
float get_value_as_float(const wchar_t* pKey, uint index, float def = 0.0f, float l = -math::cNearlyInfinite, float h = math::cNearlyInfinite, uint value_index = 0) const;
int get_value_as_int(const char* pKey, uint index, int def, int l = INT_MIN, int h = INT_MAX, uint value_index = 0) const;
float get_value_as_float(const char* pKey, uint index, float def = 0.0f, float l = -math::cNearlyInfinite, float h = math::cNearlyInfinite, uint value_index = 0) const;
bool get_value_as_string(const wchar_t* pKey, uint index, dynamic_wstring& value, uint value_index = 0) const;
const dynamic_wstring& get_value_as_string_or_empty(const wchar_t* pKey, uint index = 0, uint value_index = 0) const;
bool get_value_as_string(const char* pKey, uint index, dynamic_string& value, uint value_index = 0) const;
const dynamic_string& get_value_as_string_or_empty(const char* pKey, uint index = 0, uint value_index = 0) const;
private:
dynamic_wstring_array m_params;
dynamic_string_array m_params;
param_map m_param_map;
static bool load_string_file(const wchar_t* pFilename, dynamic_wstring_array& strings);
static bool load_string_file(const char* pFilename, dynamic_string_array& strings);
};
} // namespace crnlib
crnlib/crn_comp.cpp
+48 -48
View File
@@ -196,7 +196,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"pack_color_endpoints: %u", trial_index);
console::debug("pack_color_endpoints: %u", trial_index);
#endif
crnlib::vector<uint> remapped_endpoints(m_hvq.get_color_endpoint_codebook_size());
@@ -263,7 +263,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total endpoint residuals: %i", total_residuals);
console::debug("Total endpoint residuals: %i", total_residuals);
#endif
if (endpoint_indices.size() > 1)
@@ -280,13 +280,13 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total endpoint index delta: %I64i", total_delta);
console::debug("Total endpoint index delta: " CRNLIB_INT64_FORMAT_SPECIFIER, total_delta);
#endif
}
#if CRNLIB_CREATE_DEBUG_IMAGES
image_utils::save_to_file(dynamic_wstring(cVarArg, L"color_endpoint_residuals_%u.tga", trial_index).get_ptr(), endpoint_residual_image);
image_utils::save_to_file(dynamic_wstring(cVarArg, L"color_endpoints_%u.tga", trial_index).get_ptr(), endpoint_image);
image_utils::save_to_file(dynamic_string(cVarArg, "color_endpoint_residuals_%u.tga", trial_index).get_ptr(), endpoint_residual_image);
image_utils::save_to_file(dynamic_string(cVarArg, "color_endpoints_%u.tga", trial_index).get_ptr(), endpoint_image);
#endif
static_huffman_data_model residual_dm[2];
@@ -306,7 +306,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Wrote %u bits for color endpoint residual Huffman tables", codec.encode_get_total_bits_written());
console::debug("Wrote %u bits for color endpoint residual Huffman tables", codec.encode_get_total_bits_written());
#endif
uint start_bits = codec.encode_get_total_bits_written();
@@ -321,7 +321,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Wrote %u bits for color endpoint residuals", codec.encode_get_total_bits_written() - start_bits);
console::debug("Wrote %u bits for color endpoint residuals", codec.encode_get_total_bits_written() - start_bits);
#endif
codec.stop_encoding(false);
@@ -331,9 +331,9 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
console::debug(L"Wrote a total of %u bits for color endpoint codebook", codec.encode_get_total_bits_written());
console::debug("Wrote a total of %u bits for color endpoint codebook", codec.encode_get_total_bits_written());
console::debug(L"Wrote %f bits per each color endpoint", data.size() * 8.0f / m_hvq.get_color_endpoint_codebook_size());
console::debug("Wrote %f bits per each color endpoint", data.size() * 8.0f / m_hvq.get_color_endpoint_codebook_size());
}
#endif
@@ -351,7 +351,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"pack_alpha_endpoints: %u", trial_index);
console::debug("pack_alpha_endpoints: %u", trial_index);
#endif
crnlib::vector<uint> remapped_endpoints(m_hvq.get_alpha_endpoint_codebook_size());
@@ -410,7 +410,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total endpoint residuals: %i", total_residuals);
console::debug("Total endpoint residuals: %i", total_residuals);
#endif
if (endpoint_indices.size() > 1)
@@ -427,13 +427,13 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total endpoint index delta: %I64i", total_delta);
console::debug("Total endpoint index delta: " CRNLIB_INT64_FORMAT_SPECIFIER, total_delta);
#endif
}
#if CRNLIB_CREATE_DEBUG_IMAGES
image_utils::save_to_file(dynamic_wstring(cVarArg, L"alpha_endpoint_residuals_%u.tga", trial_index).get_ptr(), endpoint_residual_image);
image_utils::save_to_file(dynamic_wstring(cVarArg, L"alpha_endpoints_%u.tga", trial_index).get_ptr(), endpoint_image);
image_utils::save_to_file(dynamic_string(cVarArg, "alpha_endpoint_residuals_%u.tga", trial_index).get_ptr(), endpoint_residual_image);
image_utils::save_to_file(dynamic_string(cVarArg, "alpha_endpoints_%u.tga", trial_index).get_ptr(), endpoint_image);
#endif
static_huffman_data_model residual_dm;
@@ -450,7 +450,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Wrote %u bits for alpha endpoint residual Huffman tables", codec.encode_get_total_bits_written());
console::debug("Wrote %u bits for alpha endpoint residual Huffman tables", codec.encode_get_total_bits_written());
#endif
uint start_bits = codec.encode_get_total_bits_written();
@@ -464,7 +464,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Wrote %u bits for alpha endpoint residuals", codec.encode_get_total_bits_written() - start_bits);
console::debug("Wrote %u bits for alpha endpoint residuals", codec.encode_get_total_bits_written() - start_bits);
#endif
codec.stop_encoding(false);
@@ -474,9 +474,9 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
console::debug(L"Wrote a total of %u bits for alpha endpoint codebook", codec.encode_get_total_bits_written());
console::debug("Wrote a total of %u bits for alpha endpoint codebook", codec.encode_get_total_bits_written());
console::debug(L"Wrote %f bits per each alpha endpoint", data.size() * 8.0f / m_hvq.get_alpha_endpoint_codebook_size());
console::debug("Wrote %f bits per each alpha endpoint", data.size() * 8.0f / m_hvq.get_alpha_endpoint_codebook_size());
}
#endif
@@ -606,7 +606,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"pack_selectors: %u", trial_index);
console::debug("pack_selectors: %u", trial_index);
#endif
crnlib::vector<dxt_hc::selectors> remapped_selectors(selectors.size());
@@ -664,7 +664,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total selector endpoint residuals: %u", total_residuals);
console::debug("Total selector endpoint residuals: %u", total_residuals);
#endif
if (selector_indices.size() > 1)
@@ -681,13 +681,13 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total selector index delta: %I64i", total_delta);
console::debug("Total selector index delta: " CRNLIB_INT64_FORMAT_SPECIFIER, total_delta);
#endif
}
#if CRNLIB_CREATE_DEBUG_IMAGES
image_utils::save_to_file(dynamic_wstring(cVarArg, L"selectors_%u_%u.tga", trial_index, max_selector_value).get_ptr(), selector_image);
image_utils::save_to_file(dynamic_wstring(cVarArg, L"selector_residuals_%u_%u.tga", trial_index, max_selector_value).get_ptr(), residual_image);
image_utils::save_to_file(dynamic_string(cVarArg, "selectors_%u_%u.tga", trial_index, max_selector_value).get_ptr(), selector_image);
image_utils::save_to_file(dynamic_string(cVarArg, "selector_residuals_%u_%u.tga", trial_index, max_selector_value).get_ptr(), residual_image);
#endif
static_huffman_data_model residual_dm;
@@ -704,7 +704,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Wrote %u bits for selector residual Huffman tables", codec.encode_get_total_bits_written());
console::debug("Wrote %u bits for selector residual Huffman tables", codec.encode_get_total_bits_written());
#endif
uint start_bits = codec.encode_get_total_bits_written();
@@ -718,7 +718,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Wrote %u bits for selector residuals", codec.encode_get_total_bits_written() - start_bits);
console::debug("Wrote %u bits for selector residuals", codec.encode_get_total_bits_written() - start_bits);
#endif
codec.stop_encoding(false);
@@ -728,9 +728,9 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
console::debug(L"Wrote a total of %u bits for selector codebook", codec.encode_get_total_bits_written());
console::debug("Wrote a total of %u bits for selector codebook", codec.encode_get_total_bits_written());
console::debug(L"Wrote %f bits per each selector codebook entry", packed_data.size() * 8.0f / selectors.size());
console::debug("Wrote %f bits per each selector codebook entry", packed_data.size() * 8.0f / selectors.size());
}
#endif
@@ -1258,10 +1258,10 @@ namespace crnlib
if (m_pParams->m_flags & cCRNCompFlagDebugging)
{
console::debug(L"Color endpoints: %u", params.m_color_endpoint_codebook_size);
console::debug(L"Color selectors: %u", params.m_color_selector_codebook_size);
console::debug(L"Alpha endpoints: %u", params.m_alpha_endpoint_codebook_size);
console::debug(L"Alpha selectors: %u", params.m_alpha_selector_codebook_size);
console::debug("Color endpoints: %u", params.m_color_endpoint_codebook_size);
console::debug("Color selectors: %u", params.m_color_selector_codebook_size);
console::debug("Alpha endpoints: %u", params.m_alpha_endpoint_codebook_size);
console::debug("Alpha selectors: %u", params.m_alpha_selector_codebook_size);
}
params.m_hierarchical = (m_pParams->m_flags & cCRNCompFlagHierarchical) != 0;
@@ -1366,7 +1366,7 @@ namespace crnlib
image_u8 img;
dxt_hc::create_debug_image_from_chunks((m_pParams->m_width+7)>>3, (m_pParams->m_height+7)>>3, pixel_chunks, &m_hvq.get_chunk_encoding_vec(), img, true, -1);
image_utils::save_to_file(L"quantized_chunks.tga", img);
image_utils::save_to_file("quantized_chunks.tga", img);
}
#endif
@@ -1465,7 +1465,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"----- Begin optimization of color endpoint codebook");
console::debug("----- Begin optimization of color endpoint codebook");
#endif
crnlib::vector<uint> trial_color_endpoint_remaps[cMaxEndpointRemapIters + 1];
@@ -1499,14 +1499,14 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Pack chunks simulation: %u bits", total_packed_chunk_bits);
console::debug("Pack chunks simulation: %u bits", total_packed_chunk_bits);
#endif
uint total_bits = packed_data.size() * 8 + total_packed_chunk_bits;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total bits: %u", total_bits);
console::debug("Total bits: %u", total_bits);
#endif
if (total_bits < best_bits)
@@ -1519,7 +1519,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"End optimization of color endpoint codebook");
console::debug("End optimization of color endpoint codebook");
#endif
return true;
@@ -1585,7 +1585,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"----- Begin optimization of color selector codebook");
console::debug("----- Begin optimization of color selector codebook");
#endif
crnlib::vector<uint> trial_color_selector_remaps[cMaxSelectorRemapIters + 1];
@@ -1627,14 +1627,14 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Pack chunks simulation: %u bits", total_packed_chunk_bits);
console::debug("Pack chunks simulation: %u bits", total_packed_chunk_bits);
#endif
uint total_bits = packed_data.size() * 8 + total_packed_chunk_bits;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total bits: %u", total_bits);
console::debug("Total bits: %u", total_bits);
#endif
if (total_bits < best_bits)
{
@@ -1646,7 +1646,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"End optimization of color selector codebook");
console::debug("End optimization of color selector codebook");
#endif
return true;
@@ -1712,7 +1712,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"----- Begin optimization of alpha endpoint codebook");
console::debug("----- Begin optimization of alpha endpoint codebook");
#endif
crnlib::vector<uint> trial_alpha_endpoint_remaps[cMaxEndpointRemapIters + 1];
@@ -1747,14 +1747,14 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Pack chunks simulation: %u bits", total_packed_chunk_bits);
console::debug("Pack chunks simulation: %u bits", total_packed_chunk_bits);
#endif
uint total_bits = packed_data.size() * 8 + total_packed_chunk_bits;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total bits: %u", total_bits);
console::debug("Total bits: %u", total_bits);
#endif
if (total_bits < best_bits)
@@ -1767,7 +1767,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"End optimization of alpha endpoint codebook");
console::debug("End optimization of alpha endpoint codebook");
#endif
return true;
@@ -1839,7 +1839,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"----- Begin optimization of alpha selector codebook");
console::debug("----- Begin optimization of alpha selector codebook");
#endif
crnlib::vector<uint> trial_alpha_selector_remaps[cMaxSelectorRemapIters + 1];
@@ -1882,14 +1882,14 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Pack chunks simulation: %u bits", total_packed_chunk_bits);
console::debug("Pack chunks simulation: %u bits", total_packed_chunk_bits);
#endif
uint total_bits = packed_data.size() * 8 + total_packed_chunk_bits;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"Total bits: %u", total_bits);
console::debug("Total bits: %u", total_bits);
#endif
if (total_bits < best_bits)
{
@@ -1902,7 +1902,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_pParams->m_flags & cCRNCompFlagDebugging)
console::debug(L"End optimization of alpha selector codebook");
console::debug("End optimization of alpha selector codebook");
#endif
return true;
crnlib/crn_comp.h
+2 -2
View File
@@ -23,7 +23,7 @@ namespace crnlib
crn_comp();
virtual ~crn_comp();
virtual const wchar_t *get_ext() const { return L"CRN"; }
virtual const char *get_ext() const { return "CRN"; }
virtual bool compress_init(const crn_comp_params& params);
virtual bool compress_pass(const crn_comp_params& params, float *pEffective_bitrate);
@@ -41,7 +41,7 @@ namespace crnlib
image_u8 m_images[cCRNMaxFaces][cCRNMaxLevels];
struct
struct level_tag
{
uint m_width, m_height;
uint m_chunk_width, m_chunk_height;
crnlib/crn_console.cpp
+22 -35
View File
@@ -3,6 +3,7 @@
#include "crn_core.h"
#include "crn_console.h"
#include "crn_data_stream.h"
#include "crn_threading.h"
namespace crnlib
{
@@ -48,7 +49,7 @@ namespace crnlib
m_crlf = true;
}
void console::vprintf(eConsoleMessageType type, const wchar_t* p, va_list args)
void console::vprintf(eConsoleMessageType type, const char* p, va_list args)
{
init();
@@ -56,12 +57,8 @@ namespace crnlib
m_num_messages[type]++;
wchar_t buf[cConsoleBufSize];
#ifdef _MSC_VER
vswprintf_s(buf, cConsoleBufSize, p, args);
#else
vswprintf(buf, p, args);
#endif
char buf[cConsoleBufSize];
vsprintf_s(buf, cConsoleBufSize, p, args);
bool handled = false;
@@ -72,48 +69,38 @@ namespace crnlib
handled = true;
}
const wchar_t* pPrefix = NULL;
const char* pPrefix = NULL;
if (m_prefixes)
{
switch (type)
{
case cDebugConsoleMessage: pPrefix = L"Debug: "; break;
case cWarningConsoleMessage: pPrefix = L"Warning: "; break;
case cErrorConsoleMessage: pPrefix = L"Error: "; break;
case cDebugConsoleMessage: pPrefix = "Debug: "; break;
case cWarningConsoleMessage: pPrefix = "Warning: "; break;
case cErrorConsoleMessage: pPrefix = "Error: "; break;
default: break;
}
}
if ((!m_output_disabled) && (!handled))
{
#ifdef _XBOX
if (pPrefix)
OutputDebugStringW(pPrefix);
OutputDebugStringW(buf);
if (m_crlf)
OutputDebugStringW(L"\n");
#else
if (pPrefix)
::wprintf(pPrefix);
::wprintf(m_crlf ? L"%s\n" : L"%s", buf);
#endif
::printf("%s", pPrefix);
::printf(m_crlf ? "%s\n" : "%s", buf);
}
if ((type != cProgressConsoleMessage) && (m_pLog_stream))
{
// Yes this is bad.
dynamic_wstring utf16_buf(buf);
dynamic_string tmp_buf(buf);
dynamic_string ansi_buf;
utf16_buf.as_ansi(ansi_buf);
ansi_buf.translate_lf_to_crlf();
tmp_buf.translate_lf_to_crlf();
m_pLog_stream->printf(m_crlf ? "%s\r\n" : "%s", ansi_buf.get_ptr());
m_pLog_stream->printf(m_crlf ? "%s\r\n" : "%s", tmp_buf.get_ptr());
m_pLog_stream->flush();
}
}
void console::printf(eConsoleMessageType type, const wchar_t* p, ...)
void console::printf(eConsoleMessageType type, const char* p, ...)
{
va_list args;
va_start(args, p);
@@ -121,7 +108,7 @@ namespace crnlib
va_end(args);
}
void console::printf(const wchar_t* p, ...)
void console::printf(const char* p, ...)
{
va_list args;
va_start(args, p);
@@ -172,7 +159,7 @@ namespace crnlib
}
}
void console::progress(const wchar_t* p, ...)
void console::progress(const char* p, ...)
{
va_list args;
va_start(args, p);
@@ -180,7 +167,7 @@ namespace crnlib
va_end(args);
}
void console::info(const wchar_t* p, ...)
void console::info(const char* p, ...)
{
va_list args;
va_start(args, p);
@@ -188,7 +175,7 @@ namespace crnlib
va_end(args);
}
void console::message(const wchar_t* p, ...)
void console::message(const char* p, ...)
{
va_list args;
va_start(args, p);
@@ -196,7 +183,7 @@ namespace crnlib
va_end(args);
}
void console::cons(const wchar_t* p, ...)
void console::cons(const char* p, ...)
{
va_list args;
va_start(args, p);
@@ -204,7 +191,7 @@ namespace crnlib
va_end(args);
}
void console::debug(const wchar_t* p, ...)
void console::debug(const char* p, ...)
{
va_list args;
va_start(args, p);
@@ -212,7 +199,7 @@ namespace crnlib
va_end(args);
}
void console::warning(const wchar_t* p, ...)
void console::warning(const char* p, ...)
{
va_list args;
va_start(args, p);
@@ -220,7 +207,7 @@ namespace crnlib
va_end(args);
}
void console::error(const wchar_t* p, ...)
void console::error(const char* p, ...)
{
va_list args;
va_start(args, p);
crnlib/crn_console.h
+42 -11
View File
@@ -3,6 +3,10 @@
#pragma once
#include "crn_dynamic_string.h"
#ifdef WIN32
#include <tchar.h>
#include <conio.h>
#endif
namespace crnlib
{
class dynamic_string;
@@ -22,7 +26,7 @@ namespace crnlib
cCMTTotal
};
typedef bool (*console_output_func)(eConsoleMessageType type, const wchar_t* pMsg, void* pData);
typedef bool (*console_output_func)(eConsoleMessageType type, const char* pMsg, void* pData);
class console
{
@@ -38,18 +42,18 @@ namespace crnlib
static void add_console_output_func(console_output_func pFunc, void* pData);
static void remove_console_output_func(console_output_func pFunc);
static void printf(const wchar_t* p, ...);
static void printf(const char* p, ...);
static void vprintf(eConsoleMessageType type, const wchar_t* p, va_list args);
static void printf(eConsoleMessageType type, const wchar_t* p, ...);
static void vprintf(eConsoleMessageType type, const char* p, va_list args);
static void printf(eConsoleMessageType type, const char* p, ...);
static void cons(const wchar_t* p, ...);
static void debug(const wchar_t* p, ...);
static void progress(const wchar_t* p, ...);
static void info(const wchar_t* p, ...);
static void message(const wchar_t* p, ...);
static void warning(const wchar_t* p, ...);
static void error(const wchar_t* p, ...);
static void cons(const char* p, ...);
static void debug(const char* p, ...);
static void progress(const char* p, ...);
static void info(const char* p, ...);
static void message(const char* p, ...);
static void warning(const char* p, ...);
static void error(const char* p, ...);
// FIXME: All console state is currently global!
static void disable_prefixes();
@@ -90,5 +94,32 @@ namespace crnlib
static uint m_num_messages[cCMTTotal];
};
#if defined(WIN32)
inline int crn_getch()
{
return _getch();
}
#elif defined(__GNUC__)
#include <termios.h>
#include <unistd.h>
inline int crn_getch()
{
struct termios oldt, newt;
int ch;
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
ch = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
return ch;
}
#else
inline int crn_getch()
{
printf("crn_getch: Unimplemented");
return 0;
}
#endif
} // namespace crnlib
crnlib/crn_core.cpp
+10 -3
View File
@@ -1,7 +1,14 @@
// File: crn_core.cpp
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "crn_winhdr.h"
char *g_copyright_str = "Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC";
char *g_sig_str = "C8cfRlaorj0wLtnMSxrBJxTC85rho2L9hUZKHcBL";
#if CRNLIB_USE_WIN32_API
#include "crn_winhdr.h"
#endif
namespace crnlib
{
const char *g_copyright_str = "Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC";
const char *g_sig_str = "C8cfRlaorj0wLtnMSxrBJxTC85rho2L9hUZKHcBL";
} // namespace crnlib
crnlib/crn_core.h
+104 -29
View File
@@ -6,38 +6,34 @@
#pragma warning (disable: 4201) // nonstandard extension used : nameless struct/union
#pragma warning (disable: 4127) // conditional expression is constant
#pragma warning (disable: 4793) // function compiled as native
#pragma warning (disable: 4324) // structure was padded due to __declspec(align())
#endif
#if defined(WIN32)
#if 0
#if defined(WIN32) && !defined(CRNLIB_ANSI_CPLUSPLUS)
// MSVC or MinGW, x86 or x64, Win32 API's for threading and Win32 Interlocked API's or GCC built-ins for atomic ops.
#ifdef NDEBUG
// Ensure checked iterators are disabled.
#define _SECURE_SCL 0
#define _HAS_ITERATOR_DEBUGGING 0
#endif
#ifndef _DLL
// If we're using the DLL form of the run-time libs, we're also going to be enabling exceptions because we'll be building CLR apps.
// Otherwise, we disable exceptions for a small (up to 5%) speed boost.
// Otherwise, we disable exceptions for a small speed boost.
#define _HAS_EXCEPTIONS 0
#endif
#endif
//#define _CRT_SECURE_NO_WARNINGS
#define NOMINMAX
#define CRNLIB_PLATFORM_PC 1
#ifdef _WIN64
#define CRNLIB_PLATFORM_PC_X64 1
#else
#define CRNLIB_PLATFORM_PC_X86 1
#endif
#define CRNLIB_USE_WIN32_API 1
#ifdef _WIN64
#if defined(__MINGW32__) || defined(__MINGW64__)
#define CRNLIB_USE_GCC_ATOMIC_BUILTINS 1
#else
#define CRNLIB_USE_WIN32_ATOMIC_FUNCTIONS 1
#endif
#define CRNLIB_PLATFORM_PC 1
#if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__)
#define CRNLIB_PLATFORM_PC_X64 1
#define CRNLIB_64BIT_POINTERS 1
#define CRNLIB_CPU_HAS_64BIT_REGISTERS 1
@@ -48,15 +44,99 @@
#define CRNLIB_CPU_HAS_64BIT_REGISTERS 0
#define CRNLIB_LITTLE_ENDIAN_CPU 1
#endif
#define CRNLIB_USE_UNALIGNED_INT_LOADS 1
#define CRNLIB_RESTRICT __restrict
#define CRNLIB_FORCE_INLINE __forceinline
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
#define CRNLIB_USE_MSVC_INTRINSICS 1
#endif
#define CRNLIB_INT64_FORMAT_SPECIFIER "%I64i"
#define CRNLIB_UINT64_FORMAT_SPECIFIER "%I64u"
#define CRNLIB_STDCALL __stdcall
#define CRNLIB_MEMORY_IMPORT_BARRIER
#define CRNLIB_MEMORY_EXPORT_BARRIER
#elif defined(__GNUC__) && !defined(CRNLIB_ANSI_CPLUSPLUS)
// GCC x86 or x64, pthreads for threading and GCC built-ins for atomic ops.
#define CRNLIB_PLATFORM_PC 1
#if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__)
#define CRNLIB_PLATFORM_PC_X64 1
#define CRNLIB_64BIT_POINTERS 1
#define CRNLIB_CPU_HAS_64BIT_REGISTERS 1
#else
#define CRNLIB_PLATFORM_PC_X86 1
#define CRNLIB_64BIT_POINTERS 0
#define CRNLIB_CPU_HAS_64BIT_REGISTERS 0
#endif
#define CRNLIB_USE_UNALIGNED_INT_LOADS 1
#define CRNLIB_LITTLE_ENDIAN_CPU 1
#define CRNLIB_USE_PTHREADS_API 1
#define CRNLIB_USE_GCC_ATOMIC_BUILTINS 1
#define CRNLIB_RESTRICT
#define CRNLIB_FORCE_INLINE inline __attribute__((__always_inline__,__gnu_inline__))
#define CRNLIB_INT64_FORMAT_SPECIFIER "%lli"
#define CRNLIB_UINT64_FORMAT_SPECIFIER "%llu"
#define CRNLIB_STDCALL
#define CRNLIB_MEMORY_IMPORT_BARRIER
#define CRNLIB_MEMORY_EXPORT_BARRIER
#else
// Vanilla ANSI-C/C++
// No threading support, unaligned loads are NOT okay.
#if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__)
#define CRNLIB_64BIT_POINTERS 1
#define CRNLIB_CPU_HAS_64BIT_REGISTERS 1
#else
#define CRNLIB_64BIT_POINTERS 0
#define CRNLIB_CPU_HAS_64BIT_REGISTERS 0
#endif
#define CRNLIB_USE_UNALIGNED_INT_LOADS 0
#if __BIG_ENDIAN__
#define CRNLIB_BIG_ENDIAN_CPU 1
#else
#define CRNLIB_LITTLE_ENDIAN_CPU 1
#endif
#define CRNLIB_USE_GCC_ATOMIC_BUILTINS 0
#define CRNLIB_USE_WIN32_ATOMIC_FUNCTIONS 0
#define CRNLIB_RESTRICT
#define CRNLIB_FORCE_INLINE inline
#define CRNLIB_INT64_FORMAT_SPECIFIER "%I64i"
#define CRNLIB_UINT64_FORMAT_SPECIFIER "%I64u"
#define CRNLIB_STDCALL
#define CRNLIB_MEMORY_IMPORT_BARRIER
#define CRNLIB_MEMORY_EXPORT_BARRIER
#endif
#define CRNLIB_SLOW_STRING_LEN_CHECKS 1
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <math.h>
#include <stdarg.h>
#include <string.h>
#include <algorithm>
#include <locale>
#include <memory.h>
#include <limits.h>
#include <algorithm>
#include <errno.h>
#ifdef min
#undef min
@@ -78,16 +158,15 @@
#ifndef NDEBUG
#define NDEBUG
#endif
#ifdef DEBUG
#error DEBUG cannot be defined in CRNLIB_BUILD_RELEASE
#endif
#endif
#include "crn_platform.h"
#if defined(WIN32)
#include "crn_mutex.h"
#endif
#include "crn_assert.h"
#include "crn_types.h"
#include "crn_assert.h"
#include "crn_platform.h"
#include "crn_helpers.h"
#include "crn_traits.h"
#include "crn_mem.h"
@@ -95,9 +174,5 @@
#include "crn_utils.h"
#include "crn_hash.h"
#include "crn_vector.h"
#include "crn_win32_timer.h"
#include "crn_win32_threading.h"
#include "crn_timer.h"
#include "crn_dynamic_string.h"
#include "crn_dynamic_wstring.h"
crnlib/crn_data_stream.cpp
+3 -29
View File
@@ -2,7 +2,6 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "crn_data_stream.h"
#include <stdio.h>
namespace crnlib
{
@@ -12,7 +11,7 @@ namespace crnlib
{
}
data_stream::data_stream(const wchar_t* pName, uint attribs) :
data_stream::data_stream(const char* pName, uint attribs) :
m_name(pName),
m_attribs(static_cast<uint16>(attribs)),
m_opened(false), m_error(false), m_got_cr(false)
@@ -85,28 +84,11 @@ namespace crnlib
va_list args;
va_start(args, p);
char buf[4096];
#ifdef _MSC_VER
int l = vsprintf_s(buf, sizeof(buf), p, args);
#else
int l = vsprintf(buf, p, args);
#endif
va_end(args);
if (l < 0)
return false;
return write(buf, l) == static_cast<uint>(l);
}
bool data_stream::printf(const wchar_t* p, ...)
{
va_list args;
va_start(args, p);
dynamic_wstring buf;
dynamic_string buf;
buf.format_args(p, args);
va_end(args);
return write(buf.get_ptr(), buf.get_len() * sizeof(wchar_t)) == buf.get_len() * sizeof(wchar_t);
return write(buf.get_ptr(), buf.get_len() * sizeof(char)) == buf.get_len() * sizeof(char);
}
bool data_stream::write_line(const dynamic_string& str)
@@ -117,14 +99,6 @@ namespace crnlib
return true;
}
bool data_stream::write_line(const dynamic_wstring& str)
{
if (!str.is_empty())
return write(str.get_ptr(), str.get_len() * sizeof(wchar_t)) == str.get_len() * sizeof(wchar_t);
return true;
}
bool data_stream::read_array(vector<uint8>& buf)
{
if (buf.size() < get_remaining())
crnlib/crn_data_stream.h
+6 -8
View File
@@ -11,8 +11,8 @@ namespace crnlib
cDataStreamSeekable = 4
};
const int64 DATA_STREAM_SIZE_UNKNOWN = INT64_MAX;
const int64 DATA_STREAM_SIZE_INFINITE = UINT64_MAX;
const int64 DATA_STREAM_SIZE_UNKNOWN = cINT64_MAX;
const int64 DATA_STREAM_SIZE_INFINITE = cUINT64_MAX;
class data_stream
{
@@ -21,7 +21,7 @@ namespace crnlib
public:
data_stream();
data_stream(const wchar_t* pName, uint attribs);
data_stream(const char* pName, uint attribs);
virtual ~data_stream() { }
@@ -40,8 +40,8 @@ namespace crnlib
inline bool get_error() const { return m_error; }
inline const dynamic_wstring& get_name() const { return m_name; }
inline void set_name(const wchar_t* pName) { m_name.set(pName); }
inline const dynamic_string& get_name() const { return m_name; }
inline void set_name(const char* pName) { m_name.set(pName); }
virtual uint read(void* pBuf, uint len) = 0;
virtual uint64 skip(uint64 len);
@@ -65,16 +65,14 @@ namespace crnlib
bool read_line(dynamic_string& str);
bool printf(const char* p, ...);
bool printf(const wchar_t* p, ...);
bool write_line(const dynamic_string& str);
bool write_line(const dynamic_wstring& str);
bool write_bom() { uint16 bom = 0xFEFF; return write(&bom, sizeof(bom)) == sizeof(bom); }
bool read_array(vector<uint8>& buf);
bool write_array(const vector<uint8>& buf);
protected:
dynamic_wstring m_name;
dynamic_string m_name;
attribs_t m_attribs;
bool m_opened : 1;
crnlib/crn_dds_comp.h
+1 -1
View File
@@ -15,7 +15,7 @@ namespace crnlib
dds_comp();
virtual ~dds_comp();
virtual const wchar_t *get_ext() const { return L"DDS"; }
virtual const char *get_ext() const { return "DDS"; }
virtual bool compress_init(const crn_comp_params& params);
virtual bool compress_pass(const crn_comp_params& params, float *pEffective_bitrate);
crnlib/crn_dds_texture.cpp
+70 -70
View File
@@ -380,7 +380,7 @@ namespace crnlib
return *this;
}
bool dds_texture::write_dds(const wchar_t* pFilename) const
bool dds_texture::write_dds(const char* pFilename) const
{
cfile_stream out_stream(pFilename, cDataStreamWritable | cDataStreamSeekable);
if (!out_stream.is_opened())
@@ -390,7 +390,7 @@ namespace crnlib
return write_dds(out_serializer);
}
bool dds_texture::read_dds(const wchar_t* pFilename)
bool dds_texture::read_dds(const char* pFilename)
{
cfile_stream in_stream(pFilename);
if (!in_stream.is_opened())
@@ -417,7 +417,7 @@ namespace crnlib
clear();
set_last_error(L"Not a DDS file");
set_last_error("Not a DDS file");
uint8 hdr[4];
if (!serializer.read(hdr, sizeof(hdr)))
@@ -460,7 +460,7 @@ namespace crnlib
const uint all_faces_mask = DDSCAPS2_CUBEMAP_POSITIVEX|DDSCAPS2_CUBEMAP_NEGATIVEX|DDSCAPS2_CUBEMAP_POSITIVEY|DDSCAPS2_CUBEMAP_NEGATIVEY|DDSCAPS2_CUBEMAP_POSITIVEZ|DDSCAPS2_CUBEMAP_NEGATIVEZ;
if ((desc.ddsCaps.dwCaps2 & all_faces_mask) != all_faces_mask)
{
set_last_error(L"Incomplete cubemaps unsupported");
set_last_error("Incomplete cubemaps unsupported");
return false;
}
@@ -468,7 +468,7 @@ namespace crnlib
}
else if (desc.ddsCaps.dwCaps2 & DDSCAPS2_VOLUME)
{
set_last_error(L"Volume textures unsupported");
set_last_error("Volume textures unsupported");
return false;
}
}
@@ -479,7 +479,7 @@ namespace crnlib
// nvdxt just hangs
// dxtex.exe just makes all-white textures
// So screw it.
set_last_error(L"Palettized textures unsupported");
set_last_error("Palettized textures unsupported");
return false;
}
@@ -555,7 +555,7 @@ namespace crnlib
}
default:
{
dynamic_wstring err_msg(cVarArg, L"Unsupported DDS FOURCC format: 0x%08X", desc.ddpfPixelFormat.dwFourCC);
dynamic_string err_msg(cVarArg, "Unsupported DDS FOURCC format: 0x%08X", desc.ddpfPixelFormat.dwFourCC);
set_last_error(err_msg.get_ptr());
return false;
}
@@ -563,7 +563,7 @@ namespace crnlib
}
else if ((desc.ddpfPixelFormat.dwRGBBitCount < 8) || (desc.ddpfPixelFormat.dwRGBBitCount > 32) || (desc.ddpfPixelFormat.dwRGBBitCount & 7))
{
set_last_error(L"Unsupported bit count");
set_last_error("Unsupported bit count");
return false;
}
else if (desc.ddpfPixelFormat.dwFlags & DDPF_RGB)
@@ -597,7 +597,7 @@ namespace crnlib
}
else
{
set_last_error(L"Unsupported format");
set_last_error("Unsupported format");
return false;
}
@@ -609,7 +609,7 @@ namespace crnlib
//bits_per_pixel = ((m_format == PIXEL_FMT_DXT1) || (m_format == PIXEL_FMT_DXT5A)) ? 4 : 8;
bits_per_pixel = pixel_format_helpers::get_bpp(m_format);
set_last_error(L"Load failed");
set_last_error("Load failed");
uint default_pitch;
if (desc.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
@@ -626,13 +626,13 @@ namespace crnlib
// MS's DDS docs say the pitch must be DWORD aligned - but this isn't always the case.
// ATI Compressonator writes images with non-DWORD aligned pitches, and the DDSWithoutD3DX sample from MS doesn't compute the proper DWORD aligned pitch when reading DDS
// files, so the docs must be wrong/outdated.
console::warning(L"DDS file's pitch is not divisible by 4 - trying to load anyway.");
console::warning("DDS file's pitch is not divisible by 4 - trying to load anyway.");
}
#endif
// Check for obviously wacky source pitches (probably a corrupted/invalid file).
else if (pitch > default_pitch * 8)
{
set_last_error(L"Invalid pitch");
set_last_error("Invalid pitch");
return false;
}
@@ -869,11 +869,11 @@ namespace crnlib
{
if (!m_width)
{
set_last_error(L"Nothing to write");
set_last_error("Nothing to write");
return false;
}
set_last_error(L"Write_dds() failed");
set_last_error("Write_dds() failed");
if (!serializer.write("DDS ", sizeof(uint32)))
return false;
@@ -1257,7 +1257,7 @@ namespace crnlib
CRNLIB_ASSERT(check());
}
void dds_texture::init(uint width, uint height, uint levels, uint faces, pixel_format fmt, const wchar_t* pName)
void dds_texture::init(uint width, uint height, uint levels, uint faces, pixel_format fmt, const char* pName)
{
clear();
@@ -2099,7 +2099,7 @@ namespace crnlib
return true;
}
bool dds_texture::load_from_file(const wchar_t* pFilename, texture_file_types::format file_format)
bool dds_texture::load_from_file(const char* pFilename, texture_file_types::format file_format)
{
clear();
@@ -2108,11 +2108,11 @@ namespace crnlib
if (file_format == texture_file_types::cFormatInvalid)
{
set_last_error(L"Unrecognized image format extension");
set_last_error("Unrecognized image format extension");
return false;
}
set_last_error(L"Image file load failed");
set_last_error("Image file load failed");
bool success = false;
switch (file_format)
@@ -2143,7 +2143,7 @@ namespace crnlib
return success;
}
bool dds_texture::load_regular(const wchar_t* pFilename, texture_file_types::format file_format)
bool dds_texture::load_regular(const char* pFilename, texture_file_types::format file_format)
{
file_format;
@@ -2153,7 +2153,7 @@ namespace crnlib
{
crnlib_delete(pImg);
set_last_error(L"Failed loading image file");
set_last_error("Failed loading image file");
return false;
}
@@ -2166,12 +2166,12 @@ namespace crnlib
return true;
}
bool dds_texture::load_dds(const wchar_t* pFilename)
bool dds_texture::load_dds(const char* pFilename)
{
cfile_stream in_stream;
if (!in_stream.open(pFilename))
{
set_last_error(L"Failed opening file");
set_last_error("Failed opening file");
return false;
}
@@ -2188,11 +2188,11 @@ namespace crnlib
return true;
}
bool dds_texture::load_crn_from_memory(const wchar_t* pFilename, const void *pData, uint data_size)
bool dds_texture::load_crn_from_memory(const char* pFilename, const void *pData, uint data_size)
{
clear();
set_last_error(L"Image file load failed");
set_last_error("Image file load failed");
if ((!pData) || (data_size < 1)) return false;
@@ -2200,14 +2200,14 @@ namespace crnlib
tex_info.m_struct_size = sizeof(crnd::crn_texture_info);
if (!crnd_get_texture_info(pData, data_size, &tex_info))
{
set_last_error(L"crnd_get_texture_info() failed");
set_last_error("crnd_get_texture_info() failed");
return false;
}
const pixel_format dds_fmt = (pixel_format)crnd::crnd_crn_format_to_fourcc(tex_info.m_format);
if (dds_fmt == PIXEL_FMT_INVALID)
{
set_last_error(L"Unsupported DXT format");
set_last_error("Unsupported DXT format");
return false;
}
@@ -2229,7 +2229,7 @@ namespace crnlib
// Create temp buffer big enough to hold the largest mip level, and all faces if it's a cubemap.
dxt_data.resize(tex_info.m_bytes_per_block * tex_num_blocks_x * tex_num_blocks_y * tex_info.m_faces);
set_last_error(L"CRN unpack failed");
set_last_error("CRN unpack failed");
timer t;
double total_time = 0.0f;
@@ -2305,7 +2305,7 @@ namespace crnlib
#if 0
if (total_pixels)
{
console::info(L"load_crn: Total pixels: %u, ms: %3.3fms, megapixels/sec: %3.3f",
console::info("load_crn: Total pixels: %u, ms: %3.3fms, megapixels/sec: %3.3f",
total_pixels, total_time * 1000.0f, total_pixels / total_time);
}
#endif
@@ -2321,19 +2321,19 @@ namespace crnlib
return true;
}
bool dds_texture::load_crn(const wchar_t* pFilename)
bool dds_texture::load_crn(const char* pFilename)
{
cfile_stream in_stream;
if (!in_stream.open(pFilename))
{
set_last_error(L"Failed opening CRN file");
set_last_error("Failed opening CRN file");
return false;
}
crnlib::vector<uint8> crn_data;
if (!in_stream.read_array(crn_data))
{
set_last_error(L"Failed reading CRN file");
set_last_error("Failed reading CRN file");
return false;
}
@@ -2343,7 +2343,7 @@ namespace crnlib
}
bool dds_texture::write_to_file(
const wchar_t* pFilename,
const char* pFilename,
texture_file_types::format file_format,
crn_comp_params* pCRN_comp_params,
uint32 *pActual_quality_level, float *pActual_bitrate)
@@ -2353,7 +2353,7 @@ namespace crnlib
if (!is_valid())
{
set_last_error(L"Unable to save empty texture");
set_last_error("Unable to save empty texture");
return false;
}
@@ -2386,26 +2386,26 @@ namespace crnlib
return success;
}
bool dds_texture::save_regular(const wchar_t* pFilename)
bool dds_texture::save_regular(const char* pFilename)
{
image_u8 tmp;
image_u8* pLevel_image = get_level_image(0, 0, tmp);
if (!image_utils::save_to_file(pFilename, *pLevel_image, 0))
{
set_last_error(L"File write failed");
set_last_error("File write failed");
return false;
}
return true;
}
bool dds_texture::save_dds(const wchar_t* pFilename)
bool dds_texture::save_dds(const char* pFilename)
{
cfile_stream out_stream;
if (!out_stream.open(pFilename, cDataStreamWritable | cDataStreamSeekable))
{
set_last_error(L"Unable to open file");
set_last_error("Unable to open file");
return false;
}
@@ -2413,7 +2413,7 @@ namespace crnlib
if (!write_dds(serializer))
{
set_last_error(L"File write failed");
set_last_error("File write failed");
return false;
}
@@ -2422,34 +2422,34 @@ namespace crnlib
void dds_texture::print_crn_comp_params(const crn_comp_params& p)
{
console::debug(L"CRN compression params:");
console::debug(L" File Type: %s", crn_get_file_type_ext(p.m_file_type));
console::debug(L" Quality level: %u", p.m_quality_level);
console::debug(L" Target Bitrate: %f", p.m_target_bitrate);
console::debug(L" Faces: %u", p.m_faces);
console::debug(L" Width: %u", p.m_width);
console::debug(L" Height: %u", p.m_height);
console::debug(L" Levels: %u", p.m_levels);
console::debug(L" Pixel Format: %s", crn_get_format_string(p.m_format));
console::debug(L"Use manual CRN palette sizes: %u", p.get_flag(cCRNCompFlagManualPaletteSizes));
console::debug(L"Color endpoints: %u", p.m_crn_color_endpoint_palette_size);
console::debug(L"Color selectors: %u", p.m_crn_color_selector_palette_size);
console::debug(L"Alpha endpoints: %u", p.m_crn_alpha_endpoint_palette_size);
console::debug(L"Alpha selectors: %u", p.m_crn_alpha_selector_palette_size);
console::debug(L"Flags:");
console::debug(L" Perceptual: %u", p.get_flag(cCRNCompFlagPerceptual));
console::debug(L" Hierarchical: %u", p.get_flag(cCRNCompFlagHierarchical));
console::debug(L" UseBothBlockTypes: %u", p.get_flag(cCRNCompFlagUseBothBlockTypes));
console::debug(L" UseTransparentIndicesForBlack: %u", p.get_flag(cCRNCompFlagUseTransparentIndicesForBlack));
console::debug(L" DisableEndpointCaching: %u", p.get_flag(cCRNCompFlagDisableEndpointCaching));
console::debug(L"GrayscaleSampling: %u", p.get_flag(cCRNCompFlagGrayscaleSampling));
console::debug(L" UseDXT1ATransparency: %u", p.get_flag(cCRNCompFlagDXT1AForTransparency));
console::debug(L"AdaptiveTileColorPSNRDerating: %2.2fdB", p.m_crn_adaptive_tile_color_psnr_derating);
console::debug(L"AdaptiveTileAlphaPSNRDerating: %2.2fdB", p.m_crn_adaptive_tile_alpha_psnr_derating);
console::debug(L"NumHelperThreads: %u", p.m_num_helper_threads);
console::debug("CRN compression params:");
console::debug(" File Type: %s", crn_get_file_type_ext(p.m_file_type));
console::debug(" Quality level: %u", p.m_quality_level);
console::debug(" Target Bitrate: %f", p.m_target_bitrate);
console::debug(" Faces: %u", p.m_faces);
console::debug(" Width: %u", p.m_width);
console::debug(" Height: %u", p.m_height);
console::debug(" Levels: %u", p.m_levels);
console::debug(" Pixel Format: %s", crn_get_format_string(p.m_format));
console::debug("Use manual CRN palette sizes: %u", p.get_flag(cCRNCompFlagManualPaletteSizes));
console::debug("Color endpoints: %u", p.m_crn_color_endpoint_palette_size);
console::debug("Color selectors: %u", p.m_crn_color_selector_palette_size);
console::debug("Alpha endpoints: %u", p.m_crn_alpha_endpoint_palette_size);
console::debug("Alpha selectors: %u", p.m_crn_alpha_selector_palette_size);
console::debug("Flags:");
console::debug(" Perceptual: %u", p.get_flag(cCRNCompFlagPerceptual));
console::debug(" Hierarchical: %u", p.get_flag(cCRNCompFlagHierarchical));
console::debug(" UseBothBlockTypes: %u", p.get_flag(cCRNCompFlagUseBothBlockTypes));
console::debug(" UseTransparentIndicesForBlack: %u", p.get_flag(cCRNCompFlagUseTransparentIndicesForBlack));
console::debug(" DisableEndpointCaching: %u", p.get_flag(cCRNCompFlagDisableEndpointCaching));
console::debug("GrayscaleSampling: %u", p.get_flag(cCRNCompFlagGrayscaleSampling));
console::debug(" UseDXT1ATransparency: %u", p.get_flag(cCRNCompFlagDXT1AForTransparency));
console::debug("AdaptiveTileColorPSNRDerating: %2.2fdB", p.m_crn_adaptive_tile_color_psnr_derating);
console::debug("AdaptiveTileAlphaPSNRDerating: %2.2fdB", p.m_crn_adaptive_tile_alpha_psnr_derating);
console::debug("NumHelperThreads: %u", p.m_num_helper_threads);
}
bool dds_texture::save_comp_texture(const wchar_t* pFilename, const crn_comp_params &orig_comp_params, uint32 *pActual_quality_level, float *pActual_bitrate)
bool dds_texture::save_comp_texture(const char* pFilename, const crn_comp_params &orig_comp_params, uint32 *pActual_quality_level, float *pActual_bitrate)
{
crn_comp_params comp_params(orig_comp_params);
@@ -2458,7 +2458,7 @@ namespace crnlib
if (math::maximum(get_height(), get_width()) > cCRNMaxLevelResolution)
{
set_last_error(L"Texture resolution is too big!");
set_last_error("Texture resolution is too big!");
return false;
}
@@ -2487,32 +2487,32 @@ namespace crnlib
crnlib::vector<uint8> comp_data;
if (!create_compressed_texture(comp_params, comp_data, pActual_quality_level, pActual_bitrate))
{
set_last_error(L"CRN compression failed");
set_last_error("CRN compression failed");
return false;
}
double total_time = t.get_elapsed_secs();
if (comp_params.get_flag(cCRNCompFlagDebugging))
{
console::debug(L"\nTotal compression time: %3.3fs", total_time);
console::debug("\nTotal compression time: %3.3fs", total_time);
}
cfile_stream out_stream;
if (!out_stream.open(pFilename, cDataStreamWritable | cDataStreamSeekable))
{
set_last_error(L"Failed opening file");
set_last_error("Failed opening file");
return false;
}
if (out_stream.write(comp_data.get_ptr(), comp_data.size()) != comp_data.size())
{
set_last_error(L"Failed writing to file");
set_last_error("Failed writing to file");
return false;
}
if (!out_stream.close())
{
set_last_error(L"Failed writing to file");
set_last_error("Failed writing to file");
return false;
}
crnlib/crn_dds_texture.h
+19 -19
View File
@@ -94,7 +94,7 @@ namespace crnlib
void clear();
void init(uint width, uint height, uint levels, uint faces, pixel_format fmt, const wchar_t* pName);
void init(uint width, uint height, uint levels, uint faces, pixel_format fmt, const char* pName);
// Assumes ownership.
void assign(face_vec& faces);
@@ -109,10 +109,10 @@ namespace crnlib
inline bool is_valid() const { return m_faces.size() > 0; }
const dynamic_wstring& get_name() const { return m_name; }
void set_name(const dynamic_wstring& name) { m_name = name; }
const dynamic_string& get_name() const { return m_name; }
void set_name(const dynamic_string& name) { m_name = name; }
const dynamic_wstring& get_source_filename() const { return get_name(); }
const dynamic_string& get_source_filename() const { return get_name(); }
texture_file_types::format get_source_file_type() const { return m_source_file_type; }
inline uint get_width() const { return m_width; }
@@ -140,23 +140,23 @@ namespace crnlib
bool is_packed() const;
texture_type determine_texture_type() const;
const dynamic_wstring& get_last_error() const { return m_last_error; }
const dynamic_string& get_last_error() const { return m_last_error; }
void clear_last_error() { m_last_error.clear(); }
// Loading/saving
bool read_dds(const wchar_t* pFilename);
bool read_dds(const char* pFilename);
bool read_dds(data_stream_serializer& serializer);
bool write_dds(const wchar_t* pFilename) const;
bool write_dds(const char* pFilename) const;
bool write_dds(data_stream_serializer& serializer) const;
bool load_crn_from_memory(const wchar_t* pFilename, const void *pData, uint data_size);
bool load_crn_from_memory(const char* pFilename, const void *pData, uint data_size);
// If file_format is texture_file_types::cFormatInvalid, the format will be determined from the filename's extension.
bool load_from_file(const wchar_t* pFilename, texture_file_types::format file_format);
bool load_from_file(const char* pFilename, texture_file_types::format file_format);
bool write_to_file(
const wchar_t* pFilename,
const char* pFilename,
texture_file_types::format file_format,
crn_comp_params* pCRN_comp_params,
uint32 *pActual_quality_level, float *pActual_bitrate);
@@ -256,7 +256,7 @@ namespace crnlib
bool check() const;
private:
dynamic_wstring m_name;
dynamic_string m_name;
uint m_width;
uint m_height;
@@ -268,20 +268,20 @@ namespace crnlib
texture_file_types::format m_source_file_type;
mutable dynamic_wstring m_last_error;
mutable dynamic_string m_last_error;
inline void clear_last_error() const { m_last_error.clear(); }
inline void set_last_error(const wchar_t* p) const { m_last_error = p; }
inline void set_last_error(const char* p) const { m_last_error = p; }
void free_all_mips();
bool read_dds_internal(data_stream_serializer& serializer);
bool load_regular(const wchar_t* pFilename, texture_file_types::format file_format);
bool load_dds(const wchar_t* pFilename);
bool load_crn(const wchar_t* pFilename);
bool load_regular(const char* pFilename, texture_file_types::format file_format);
bool load_dds(const char* pFilename);
bool load_crn(const char* pFilename);
void print_crn_comp_params(const crn_comp_params& p);
bool save_regular(const wchar_t* pFilename);
bool save_dds(const wchar_t* pFilename);
bool save_comp_texture(const wchar_t* pFilename, const crn_comp_params &comp_params, uint32 *pActual_quality_level, float *pActual_bitrate);
bool save_regular(const char* pFilename);
bool save_dds(const char* pFilename);
bool save_comp_texture(const char* pFilename, const crn_comp_params &comp_params, uint32 *pActual_quality_level, float *pActual_bitrate);
};
inline void swap(dds_texture& a, dds_texture& b)
crnlib/crn_dxt.cpp
+17 -14
View File
@@ -20,34 +20,37 @@ namespace crnlib
const uint8 g_six_alpha_invert_table[cDXT5SelectorValues] = { 1, 0, 5, 4, 3, 2, 6, 7 };
const uint8 g_eight_alpha_invert_table[cDXT5SelectorValues] = { 1, 0, 7, 6, 5, 4, 3, 2 };
const wchar_t* get_dxt_format_string(dxt_format fmt)
const char* get_dxt_format_string(dxt_format fmt)
{
switch (fmt)
{
case cDXT1: return L"DXT1";
case cDXT1A: return L"DXT1A";
case cDXT3: return L"DXT3";
case cDXT5: return L"DXT5";
case cDXT5A: return L"DXT5A";
case cDXN_XY: return L"DXN_XY";
case cDXN_YX: return L"DXN_YX";
case cDXT1: return "DXT1";
case cDXT1A: return "DXT1A";
case cDXT3: return "DXT3";
case cDXT5: return "DXT5";
case cDXT5A: return "DXT5A";
case cDXN_XY: return "DXN_XY";
case cDXN_YX: return "DXN_YX";
default: break;
}
CRNLIB_ASSERT(false);
return L"?";
return "?";
}
const wchar_t* get_dxt_compressor_name(crn_dxt_compressor_type c)
const char* get_dxt_compressor_name(crn_dxt_compressor_type c)
{
switch (c)
{
case cCRNDXTCompressorCRN: return L"CRN";
case cCRNDXTCompressorCRNF: return L"CRNF";
case cCRNDXTCompressorRYG: return L"RYG";
case cCRNDXTCompressorCRN: return "CRN";
case cCRNDXTCompressorCRNF: return "CRNF";
case cCRNDXTCompressorRYG: return "RYG";
#if CRNLIB_SUPPORT_ATI_COMPRESS
case cCRNDXTCompressorATI: return "ATI";
#endif
default: break;
}
CRNLIB_ASSERT(false);
return L"?";
return "?";
}
uint get_dxt_format_bits_per_pixel(dxt_format fmt)
crnlib/crn_dxt.h
+5 -5
View File
@@ -69,13 +69,13 @@ namespace crnlib
extern const uint8 g_six_alpha_invert_table[cDXT5SelectorValues];
extern const uint8 g_eight_alpha_invert_table[cDXT5SelectorValues];
const wchar_t* get_dxt_format_string(dxt_format fmt);
const char* get_dxt_format_string(dxt_format fmt);
uint get_dxt_format_bits_per_pixel(dxt_format fmt);
bool get_dxt_format_has_alpha(dxt_format fmt);
const wchar_t* get_dxt_quality_string(crn_dxt_quality q);
const char* get_dxt_quality_string(crn_dxt_quality q);
const wchar_t* get_dxt_compressor_name(crn_dxt_compressor_type c);
const char* get_dxt_compressor_name(crn_dxt_compressor_type c);
struct dxt1_block
{
@@ -191,13 +191,13 @@ namespace crnlib
inline void set_low_alpha(uint i)
{
CRNLIB_ASSERT(i <= UINT8_MAX);
CRNLIB_ASSERT(i <= cUINT8_MAX);
m_endpoints[0] = static_cast<uint8>(i);
}
inline void set_high_alpha(uint i)
{
CRNLIB_ASSERT(i <= UINT8_MAX);
CRNLIB_ASSERT(i <= cUINT8_MAX);
m_endpoints[1] = static_cast<uint8>(i);
}
crnlib/crn_dxt1.cpp
+3 -3
View File
@@ -13,8 +13,8 @@ namespace crnlib
m_pParams(NULL),
m_pResults(NULL),
m_pSolutions(NULL),
m_has_color_weighting(false),
m_perceptual(false),
m_has_color_weighting(false),
m_all_pixels_grayscale(false)
{
m_low_coords.reserve(512);
@@ -1507,7 +1507,7 @@ namespace crnlib
if ((pBest_solution) && (early_out))
solution.m_error = pBest_solution->m_error;
else
solution.m_error = UINT64_MAX;
solution.m_error = cUINT64_MAX;
solution.m_alpha_block = false;
solution.m_valid = false;
@@ -1686,7 +1686,7 @@ namespace crnlib
if ((pBest_solution) && (early_out))
solution.m_error = pBest_solution->m_error;
else
solution.m_error = UINT64_MAX;
solution.m_error = cUINT64_MAX;
solution.m_alpha_block = false;
solution.m_valid = false;
crnlib/crn_dxt1.h
+2 -2
View File
@@ -258,7 +258,7 @@ namespace crnlib
struct potential_solution
{
potential_solution() : m_coords(), m_error(UINT64_MAX), m_alpha_block(false), m_valid(false)
potential_solution() : m_coords(), m_error(cUINT64_MAX), m_alpha_block(false), m_valid(false)
{
}
@@ -272,7 +272,7 @@ namespace crnlib
{
m_coords.clear();
m_selectors.resize(0);
m_error = UINT64_MAX;
m_error = cUINT64_MAX;
m_alpha_block = false;
m_valid = false;
}
crnlib/crn_dxt5a.cpp
+1 -1
View File
@@ -62,7 +62,7 @@ namespace crnlib
m_trial_selectors.resize(m_unique_values.size());
m_best_selectors.resize(m_unique_values.size());
r.m_error = UINT64_MAX;
r.m_error = cUINT64_MAX;
for (uint i = 0; i < m_unique_values.size() - 1; i++)
{
crnlib/crn_dxt_endpoint_refiner.cpp
+1 -1
View File
@@ -20,7 +20,7 @@ namespace crnlib
m_pParams = &p;
m_pResults = &r;
r.m_error = UINT64_MAX;
r.m_error = cUINT64_MAX;
r.m_low_color = 0;
r.m_high_color = 0;
crnlib/crn_dxt_endpoint_refiner.h
+1 -1
View File
@@ -19,7 +19,7 @@ namespace crnlib
m_num_pixels(0),
m_pSelectors(NULL),
m_alpha_comp_index(0),
m_error_to_beat(UINT64_MAX),
m_error_to_beat(cUINT64_MAX),
m_dxt1_selectors(true),
m_perceptual(true),
m_highest_quality(true)
crnlib/crn_dxt_fast.cpp
+2 -2
View File
@@ -507,7 +507,7 @@ namespace crnlib
static void refine_endpoints2(uint n, const color_quad_u8* pBlock, uint& low16, uint& high16, uint8* pSelectors, float axis[3])
{
uint64 orig_error = determine_error(n, pBlock, low16, high16, UINT64_MAX);
uint64 orig_error = determine_error(n, pBlock, low16, high16, cUINT64_MAX);
if (!orig_error)
return;
@@ -623,7 +623,7 @@ namespace crnlib
{
improved = true;
uint64 cur_error = determine_error(n, pBlock, low16, high16, UINT64_MAX);
uint64 cur_error = determine_error(n, pBlock, low16, high16, cUINT64_MAX);
if (!cur_error)
return;
}
crnlib/crn_dxt_hc.cpp
+40 -40
View File
@@ -33,7 +33,7 @@ namespace crnlib
m_has_color_blocks(false),
m_has_alpha0_blocks(false),
m_has_alpha1_blocks(false),
m_main_thread_id(get_current_thread_id()),
m_main_thread_id(crn_get_current_thread_id()),
m_canceled(false),
m_pTask_pool(NULL),
m_prev_phase_index(-1),
@@ -104,7 +104,7 @@ namespace crnlib
bool dxt_hc::compress(const params& p, uint num_chunks, const pixel_chunk* pChunks, task_pool& task_pool)
{
m_pTask_pool = &task_pool;
m_main_thread_id = get_current_thread_id();
m_main_thread_id = crn_get_current_thread_id();
bool result = compress_internal(p, num_chunks, pChunks);
@@ -335,7 +335,7 @@ namespace crnlib
if (m_canceled)
return;
if ((get_current_thread_id() == m_main_thread_id) && ((chunk_index & 511) == 0))
if ((crn_get_current_thread_id() == m_main_thread_id) && ((chunk_index & 511) == 0))
{
if (!update_progress(0, chunk_index, m_num_chunks))
return;
@@ -550,9 +550,9 @@ namespace crnlib
}
}
interlocked_increment32(&m_encoding_hist[best_encoding]);
atomic_increment32(&m_encoding_hist[best_encoding]);
interlocked_exchange_add32(&m_total_tiles, g_chunk_encodings[best_encoding].m_num_tiles);
atomic_exchange_add32(&m_total_tiles, g_chunk_encodings[best_encoding].m_num_tiles);
for (uint q = 0; q < cNumCompressedChunkVecs; q++)
{
@@ -664,15 +664,15 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
{
console::info(L"Total Pixels: %u, Chunks: %u, Blocks: %u, Adapted Tiles: %u", m_num_chunks * cChunkPixelWidth * cChunkPixelHeight, m_num_chunks, m_num_chunks * cChunkBlockWidth * cChunkBlockHeight, m_total_tiles);
console::info("Total Pixels: %u, Chunks: %u, Blocks: %u, Adapted Tiles: %u", m_num_chunks * cChunkPixelWidth * cChunkPixelHeight, m_num_chunks, m_num_chunks * cChunkBlockWidth * cChunkBlockHeight, m_total_tiles);
console::info(L"Chunk encoding type symbol_histogram: ");
console::info("Chunk encoding type symbol_histogram: ");
for (uint e = 0; e < cNumChunkEncodings; e++)
console::info(L"%u ", m_encoding_hist[e]);
console::info("%u ", m_encoding_hist[e]);
console::info(L"Blocks per chunk encoding type: ");
console::info("Blocks per chunk encoding type: ");
for (uint e = 0; e < cNumChunkEncodings; e++)
console::info(L"%u ", m_encoding_hist[e] * cChunkBlockWidth * cChunkBlockHeight);
console::info("%u ", m_encoding_hist[e] * cChunkBlockWidth * cChunkBlockHeight);
}
#endif
@@ -689,7 +689,7 @@ namespace crnlib
if (m_canceled)
return;
if ((get_current_thread_id() == m_main_thread_id) && ((chunk_index & 63) == 0))
if ((crn_get_current_thread_id() == m_main_thread_id) && ((chunk_index & 63) == 0))
{
if (!update_progress(2, chunk_index, m_num_chunks))
return;
@@ -719,7 +719,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Generating color training vectors");
console::info("Generating color training vectors");
#endif
const float r_scale = .5f;
@@ -804,7 +804,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Begin color cluster analysis");
console::info("Begin color cluster analysis");
timer t;
t.start();
#endif
@@ -816,7 +816,7 @@ namespace crnlib
if (m_params.m_debugging)
{
double total_time = t.get_elapsed_secs();
console::info(L"Codebook gen time: %3.3fs, Total color clusters: %u", total_time, vq.get_codebook_size());
console::info("Codebook gen time: %3.3fs, Total color clusters: %u", total_time, vq.get_codebook_size());
}
#endif
@@ -824,7 +824,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Begin color cluster assignment");
console::info("Begin color cluster assignment");
#endif
assign_color_endpoint_clusters_state state(vq, training_vecs);
@@ -850,7 +850,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Completed color cluster assignment");
console::info("Completed color cluster assignment");
#endif
return true;
@@ -868,7 +868,7 @@ namespace crnlib
if (m_canceled)
return;
if ((get_current_thread_id() == m_main_thread_id) && ((chunk_index & 63) == 0))
if ((crn_get_current_thread_id() == m_main_thread_id) && ((chunk_index & 63) == 0))
{
if (!update_progress(7, m_num_chunks * a + chunk_index, m_num_chunks * m_num_alpha_blocks))
return;
@@ -899,7 +899,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Generating alpha training vectors");
console::info("Generating alpha training vectors");
#endif
determine_alpha_endpoint_clusters_state state;
@@ -966,7 +966,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Begin alpha cluster analysis");
console::info("Begin alpha cluster analysis");
timer t;
t.start();
#endif
@@ -978,7 +978,7 @@ namespace crnlib
if (m_params.m_debugging)
{
double total_time = t.get_elapsed_secs();
console::info(L"Codebook gen time: %3.3fs, Total alpha clusters: %u", total_time, state.m_vq.get_codebook_size());
console::info("Codebook gen time: %3.3fs, Total alpha clusters: %u", total_time, state.m_vq.get_codebook_size());
}
#endif
@@ -986,7 +986,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Begin alpha cluster assignment");
console::info("Begin alpha cluster assignment");
#endif
for (uint i = 0; i <= m_pTask_pool->get_num_threads(); i++)
@@ -1013,7 +1013,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Completed alpha cluster assignment");
console::info("Completed alpha cluster assignment");
#endif
return true;
@@ -1040,7 +1040,7 @@ namespace crnlib
if (m_canceled)
return;
if ((get_current_thread_id() == m_main_thread_id) && ((cluster_index & 63) == 0))
if ((crn_get_current_thread_id() == m_main_thread_id) && ((cluster_index & 63) == 0))
{
if (!update_progress(3, cluster_index, m_color_clusters.size()))
return;
@@ -1151,7 +1151,7 @@ namespace crnlib
if (m_params.m_debugging)
{
if (total_empty_clusters)
console::warning(L"Total empty color clusters: %u", total_empty_clusters);
console::warning("Total empty color clusters: %u", total_empty_clusters);
}
#endif
}
@@ -1163,7 +1163,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Computing optimal color cluster endpoints");
console::info("Computing optimal color cluster endpoints");
#endif
for (uint i = 0; i <= m_pTask_pool->get_num_threads(); i++)
@@ -1192,7 +1192,7 @@ namespace crnlib
if (m_canceled)
return;
if ((get_current_thread_id() == m_main_thread_id) && ((cluster_index & 63) == 0))
if ((crn_get_current_thread_id() == m_main_thread_id) && ((cluster_index & 63) == 0))
{
if (!update_progress(8, cluster_index, m_alpha_clusters.size()))
return;
@@ -1311,7 +1311,7 @@ namespace crnlib
if (m_params.m_debugging)
{
if (total_empty_clusters)
console::warning(L"Total empty alpha clusters: %u", total_empty_clusters);
console::warning("Total empty alpha clusters: %u", total_empty_clusters);
}
#endif
}
@@ -1323,7 +1323,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Computing optimal alpha cluster endpoints");
console::info("Computing optimal alpha cluster endpoints");
#endif
for (uint i = 0; i <= m_pTask_pool->get_num_threads(); i++)
@@ -1461,7 +1461,7 @@ namespace crnlib
if (m_canceled)
return;
if ((get_current_thread_id() == m_main_thread_id) && ((chunk_index & 127) == 0))
if ((crn_get_current_thread_id() == m_main_thread_id) && ((chunk_index & 127) == 0))
{
if (!update_progress(12 + comp_chunk_index, chunk_index, m_num_chunks))
return;
@@ -1632,7 +1632,7 @@ namespace crnlib
{
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Computing selector training vectors");
console::info("Computing selector training vectors");
#endif
const uint cColorDistToWeight = 2000;
@@ -1775,7 +1775,7 @@ namespace crnlib
if (m_params.m_debugging)
{
double total_time = t.get_elapsed_secs();
console::info(L"Codebook gen time: %3.3fs, Selector codebook size: %u", total_time, selector_vq.get_codebook_size());
console::info("Codebook gen time: %3.3fs, Selector codebook size: %u", total_time, selector_vq.get_codebook_size());
}
#endif
@@ -1827,7 +1827,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Refining quantized color selectors");
console::info("Refining quantized color selectors");
#endif
uint total_refined_selectors = 0;
@@ -1917,7 +1917,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Total refined pixels: %u, selectors: %u out of %u", total_refined_pixels, total_refined_selectors, total_selectors);
console::info("Total refined pixels: %u, selectors: %u out of %u", total_refined_pixels, total_refined_selectors, total_selectors);
#endif
return true;
@@ -1930,7 +1930,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Refining quantized alpha selectors");
console::info("Refining quantized alpha selectors");
#endif
uint total_refined_selectors = 0;
@@ -2021,7 +2021,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Total refined pixels: %u, selectors: %u out of %u", total_refined_pixels, total_refined_selectors, total_selectors);
console::info("Total refined pixels: %u, selectors: %u out of %u", total_refined_pixels, total_refined_selectors, total_selectors);
#endif
return true;
@@ -2037,7 +2037,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Refining quantized color endpoints");
console::info("Refining quantized color endpoints");
#endif
for (uint cluster_index = 0; cluster_index < m_color_clusters.size(); cluster_index++)
@@ -2138,7 +2138,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Total refined pixels: %u, endpoints: %u out of %u", total_refined_pixels, total_refined_tiles, m_color_clusters.size());
console::info("Total refined pixels: %u, endpoints: %u out of %u", total_refined_pixels, total_refined_tiles, m_color_clusters.size());
#endif
return true;
@@ -2153,7 +2153,7 @@ namespace crnlib
uint total_refined_pixels = 0;
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Refining quantized alpha endpoints");
console::info("Refining quantized alpha endpoints");
#endif
for (uint cluster_index = 0; cluster_index < m_alpha_clusters.size(); cluster_index++)
@@ -2257,7 +2257,7 @@ namespace crnlib
#if CRNLIB_ENABLE_DEBUG_MESSAGES
if (m_params.m_debugging)
console::info(L"Total refined pixels: %u, endpoints: %u out of %u", total_refined_pixels, total_refined_tiles, m_alpha_clusters.size());
console::info("Total refined pixels: %u, endpoints: %u out of %u", total_refined_pixels, total_refined_tiles, m_alpha_clusters.size());
#endif
return true;
@@ -2515,7 +2515,7 @@ namespace crnlib
bool dxt_hc::update_progress(uint phase_index, uint subphase_index, uint subphase_total)
{
CRNLIB_ASSERT(get_current_thread_id() == m_main_thread_id);
CRNLIB_ASSERT(crn_get_current_thread_id() == m_main_thread_id);
if (!m_params.m_pProgress_func)
return true;
crnlib/crn_dxt_hc.h
+6 -7
View File
@@ -9,8 +9,7 @@
#include "crn_image.h"
#include "crn_dxt_hc_common.h"
#include "crn_tree_clusterizer.h"
#include "crn_task_pool.h"
#include "crn_spinlock.h"
#include "crn_threading.h"
#define CRN_NO_FUNCTION_DEFINITIONS
#include "../inc/crnlib.h"
@@ -163,8 +162,8 @@ namespace crnlib
uint8 m_selectors[cBlockPixelHeight][cBlockPixelWidth];
uint8 get_by_index(uint i) const { CRNLIB_ASSERT(i < (cBlockPixelWidth * cBlockPixelHeight)); return *(&m_selectors[0][0] + i); }
void set_by_index(uint i, uint v) { CRNLIB_ASSERT(i < (cBlockPixelWidth * cBlockPixelHeight)); *(&m_selectors[0][0] + i) = static_cast<uint8>(v); }
uint8 get_by_index(uint i) const { CRNLIB_ASSERT(i < (cBlockPixelWidth * cBlockPixelHeight)); const uint8* p = (const uint8*)m_selectors; return *(p + i); }
void set_by_index(uint i, uint v) { CRNLIB_ASSERT(i < (cBlockPixelWidth * cBlockPixelHeight)); uint8* p = (uint8*)m_selectors; *(p + i) = static_cast<uint8>(v); }
};
typedef crnlib::vector<selectors> selectors_vec;
@@ -272,9 +271,9 @@ namespace crnlib
};
compressed_chunk_vec m_compressed_chunks[cNumCompressedChunkVecs];
int32 m_encoding_hist[cNumChunkEncodings];
volatile atomic32_t m_encoding_hist[cNumChunkEncodings];
int32 m_total_tiles;
atomic32_t m_total_tiles;
void compress_dxt1_block(
dxt1_endpoint_optimizer::results& results,
@@ -350,7 +349,7 @@ namespace crnlib
pixel_chunk_vec m_dbg_chunk_pixels_final;
uint32 m_main_thread_id;
crn_thread_id_t m_main_thread_id;
bool m_canceled;
task_pool* m_pTask_pool;
crnlib/crn_dxt_image.cpp
+9 -9
View File
@@ -7,8 +7,8 @@
#endif
#include "crn_ryg_dxt.hpp"
#include "crn_dxt_fast.h"
#include "crn_task_pool.h"
#include "crn_console.h"
#include "crn_threading.h"
#if CRNLIB_SUPPORT_ATI_COMPRESS
#ifdef _DLL
@@ -216,8 +216,8 @@ namespace crnlib
dxt_format m_fmt;
const image_u8* m_pImg;
const dxt_image::pack_params* m_pParams;
uint32 m_main_thread;
int32 m_canceled;
crn_thread_id_t m_main_thread;
atomic32_t m_canceled;
};
void dxt_image::init_task(uint64 data, void* pData_ptr)
@@ -227,7 +227,7 @@ namespace crnlib
const image_u8& img = *pInit_params->m_pImg;
const pack_params& p = *pInit_params->m_pParams;
const bool is_main_thread = (get_current_thread_id() == pInit_params->m_main_thread);
const bool is_main_thread = (crn_get_current_thread_id() == pInit_params->m_main_thread);
uint block_index = 0;
@@ -252,7 +252,7 @@ namespace crnlib
prev_progress_percentage = progress_percentage;
if (!(p.m_pProgress_callback)(progress_percentage, p.m_pProgress_callback_user_data_ptr))
{
interlocked_exchange32(&pInit_params->m_canceled, CRNLIB_TRUE);
atomic_exchange32(&pInit_params->m_canceled, CRNLIB_TRUE);
return;
}
}
@@ -351,7 +351,7 @@ namespace crnlib
if (fmt == cDXT1A)
{
options.bDXT1UseAlpha = TRUE;
options.bDXT1UseAlpha = true;
options.nAlphaThreshold = (ATI_TC_BYTE)p.m_dxt1a_alpha_threshold;
}
options.bDisableMultiThreading = (p.m_num_helper_threads == 0);
@@ -370,7 +370,7 @@ namespace crnlib
if (p.m_perceptual)
{
options.bUseChannelWeighting = TRUE;
options.bUseChannelWeighting = true;
options.fWeightingRed = .212671f;
options.fWeightingGreen = .715160f;
options.fWeightingBlue = .072169f;
@@ -405,7 +405,7 @@ namespace crnlib
init_params.m_fmt = fmt;
init_params.m_pImg = &img;
init_params.m_pParams = &p;
init_params.m_main_thread = get_current_thread_id();
init_params.m_main_thread = crn_get_current_thread_id();
init_params.m_canceled = false;
for (uint i = 0; i <= p.m_num_helper_threads; i++)
@@ -1135,7 +1135,7 @@ namespace crnlib
int dxt_image::get_block_endpoints(uint block_x, uint block_y, uint element_index, color_quad_u8& low_endpoint, color_quad_u8& high_endpoint, bool scaled) const
{
uint l, h;
uint l = 0, h = 0;
get_block_endpoints(block_x, block_y, element_index, l, h);
switch (m_element_type[element_index])
crnlib/crn_dxt_image.h
+2 -2
View File
@@ -61,8 +61,8 @@ namespace crnlib
uint get_le_word(uint index) const { CRNLIB_ASSERT(index < 4); return m_bytes[index*2] | (m_bytes[index * 2 + 1] << 8); }
uint get_be_word(uint index) const { CRNLIB_ASSERT(index < 4); return m_bytes[index*2 + 1] | (m_bytes[index * 2] << 8); }
void set_le_word(uint index, uint val) { CRNLIB_ASSERT((index < 4) && (val <= UINT16_MAX)); m_bytes[index*2] = static_cast<uint8>(val & 0xFF); m_bytes[index * 2 + 1] = static_cast<uint8>((val >> 8) & 0xFF); }
void set_be_word(uint index, uint val) { CRNLIB_ASSERT((index < 4) && (val <= UINT16_MAX)); m_bytes[index*2+1] = static_cast<uint8>(val & 0xFF); m_bytes[index * 2] = static_cast<uint8>((val >> 8) & 0xFF); }
void set_le_word(uint index, uint val) { CRNLIB_ASSERT((index < 4) && (val <= cUINT16_MAX)); m_bytes[index*2] = static_cast<uint8>(val & 0xFF); m_bytes[index * 2 + 1] = static_cast<uint8>((val >> 8) & 0xFF); }
void set_be_word(uint index, uint val) { CRNLIB_ASSERT((index < 4) && (val <= cUINT16_MAX)); m_bytes[index*2+1] = static_cast<uint8>(val & 0xFF); m_bytes[index * 2] = static_cast<uint8>((val >> 8) & 0xFF); }
void clear()
{
crnlib/crn_dynamic_stream.h
+8 -8
View File
@@ -8,14 +8,14 @@ namespace crnlib
class dynamic_stream : public data_stream
{
public:
dynamic_stream(uint initial_size, const wchar_t* pName = L"dynamic_stream", uint attribs = cDataStreamSeekable | cDataStreamWritable | cDataStreamReadable) :
dynamic_stream(uint initial_size, const char* pName = "dynamic_stream", uint attribs = cDataStreamSeekable | cDataStreamWritable | cDataStreamReadable) :
data_stream(pName, attribs),
m_ofs(0)
{
open(initial_size, pName, attribs);
}
dynamic_stream(const void* pBuf, uint size, const wchar_t* pName = L"dynamic_stream", uint attribs = cDataStreamSeekable | cDataStreamWritable | cDataStreamReadable) :
dynamic_stream(const void* pBuf, uint size, const char* pName = "dynamic_stream", uint attribs = cDataStreamSeekable | cDataStreamWritable | cDataStreamReadable) :
data_stream(pName, attribs),
m_ofs(0)
{
@@ -33,7 +33,7 @@ namespace crnlib
{
}
bool open(uint initial_size = 0, const wchar_t* pName = L"dynamic_stream", uint attribs = cDataStreamSeekable | cDataStreamWritable | cDataStreamReadable)
bool open(uint initial_size = 0, const char* pName = "dynamic_stream", uint attribs = cDataStreamSeekable | cDataStreamWritable | cDataStreamReadable)
{
close();
@@ -41,24 +41,24 @@ namespace crnlib
m_buf.clear();
m_buf.resize(initial_size);
m_ofs = 0;
m_name.set(pName ? pName : L"dynamic_stream");
m_name.set(pName ? pName : "dynamic_stream");
m_attribs = static_cast<attribs_t>(attribs);
return true;
}
bool reopen(const wchar_t* pName, uint attribs)
bool reopen(const char* pName, uint attribs)
{
if (!m_opened)
{
return open(0, pName, attribs);
}
m_name.set(pName ? pName : L"dynamic_stream");
m_name.set(pName ? pName : "dynamic_stream");
m_attribs = static_cast<attribs_t>(attribs);
return true;
}
bool open(const void* pBuf, uint size, const wchar_t* pName = L"dynamic_stream", uint attribs = cDataStreamSeekable | cDataStreamWritable | cDataStreamReadable)
bool open(const void* pBuf, uint size, const char* pName = "dynamic_stream", uint attribs = cDataStreamSeekable | cDataStreamWritable | cDataStreamReadable)
{
if (!m_opened)
{
@@ -70,7 +70,7 @@ namespace crnlib
memcpy(&m_buf[0], pBuf, size);
}
m_ofs = 0;
m_name.set(pName ? pName : L"dynamic_stream");
m_name.set(pName ? pName : "dynamic_stream");
m_attribs = static_cast<attribs_t>(attribs);
return true;
}
crnlib/crn_dynamic_string.cpp
+38 -65
View File
@@ -1,10 +1,7 @@
// File: crn_dynamic_string.cpp
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "crn_dynamic_string.h"
#include "crn_dynamic_wstring.h"
#include "crn_winhdr.h"
#include <stdio.h>
#include "crn_strutils.h"
namespace crnlib
{
@@ -43,51 +40,6 @@ namespace crnlib
set(other);
}
dynamic_string::dynamic_string(const wchar_t* pStr) :
m_buf_size(0), m_len(0), m_pStr(NULL)
{
set(pStr);
}
dynamic_string& dynamic_string::set(const wchar_t *pStr)
{
uint len = static_cast<uint>(wcslen(pStr));
if (!len)
{
clear();
return *this;
}
const uint num_needed = WideCharToMultiByte(CP_ACP, 0, pStr, len, NULL, 0, NULL, NULL);
if (num_needed <= 0)
{
clear();
return *this;
}
if (!ensure_buf(num_needed, false))
{
clear();
return *this;
}
const uint num_written = WideCharToMultiByte(CP_ACP, 0, pStr, len, get_ptr_raw(), num_needed, NULL, NULL);
CRNLIB_ASSERT(num_written == num_needed);
get_ptr_raw()[num_written] = 0;
m_len = static_cast<uint16>(num_written);
check();
return *this;
}
dynamic_wstring& dynamic_string::as_utf16(dynamic_wstring &buf)
{
buf.set(get_ptr());
return buf;
}
void dynamic_string::clear()
{
check();
@@ -133,7 +85,7 @@ namespace crnlib
{
CRNLIB_ASSERT(p);
const int result = (case_sensitive ? strcmp : _stricmp)(get_ptr_priv(), p);
const int result = (case_sensitive ? strcmp : crn_stricmp)(get_ptr_priv(), p);
if (result < 0)
return -1;
@@ -153,9 +105,9 @@ namespace crnlib
CRNLIB_ASSERT(p);
const uint len = math::minimum<uint>(max_len, static_cast<uint>(strlen(p)));
CRNLIB_ASSERT(len < UINT16_MAX);
CRNLIB_ASSERT(len < cUINT16_MAX);
if ((!len) || (len >= UINT16_MAX))
if ((!len) || (len >= cUINT16_MAX))
clear();
else if ((m_pStr) && (p >= m_pStr) && (p < (m_pStr + m_buf_size)))
{
@@ -206,8 +158,11 @@ namespace crnlib
bool dynamic_string::set_len(uint new_len, char fill_char)
{
if ((new_len >= UINT16_MAX) || (!fill_char))
if ((new_len >= cUINT16_MAX) || (!fill_char))
{
CRNLIB_ASSERT(0);
return false;
}
uint cur_len = m_len;
@@ -226,22 +181,41 @@ namespace crnlib
return true;
}
dynamic_string& dynamic_string::set_from_raw_buf_and_assume_ownership(char *pBuf, uint buf_size_in_chars, uint len_in_chars)
{
CRNLIB_ASSERT(buf_size_in_chars <= cUINT16_MAX);
CRNLIB_ASSERT(math::is_power_of_2(buf_size_in_chars) || (buf_size_in_chars == cUINT16_MAX));
CRNLIB_ASSERT((len_in_chars + 1) <= buf_size_in_chars);
clear();
m_pStr = pBuf;
m_buf_size = static_cast<uint16>(buf_size_in_chars);
m_len = static_cast<uint16>(len_in_chars);
check();
return *this;
}
dynamic_string& dynamic_string::set_from_buf(const void* pBuf, uint buf_size)
{
CRNLIB_ASSERT(pBuf);
if (buf_size >= UINT16_MAX)
if (buf_size >= cUINT16_MAX)
{
clear();
return *this;
}
#ifdef CRNLIB_BUILD_DEBUG
if ((buf_size) && (memchr(pBuf, 0, buf_size) != NULL))
{
CRNLIB_ASSERT(0);
clear();
return *this;
}
#endif
if (ensure_buf(buf_size, false))
{
@@ -569,9 +543,12 @@ namespace crnlib
else
{
CRNLIB_ASSERT(m_buf_size);
CRNLIB_ASSERT((m_buf_size == UINT16_MAX) || math::is_power_of_2((uint32)m_buf_size));
CRNLIB_ASSERT((m_buf_size == cUINT16_MAX) || math::is_power_of_2((uint32)m_buf_size));
CRNLIB_ASSERT(m_len < m_buf_size);
CRNLIB_ASSERT(!m_pStr[m_len]);
#if CRNLIB_SLOW_STRING_LEN_CHECKS
CRNLIB_ASSERT(strlen(m_pStr) == m_len);
#endif
}
}
#endif
@@ -580,9 +557,9 @@ namespace crnlib
{
uint buf_size_needed = len + 1;
CRNLIB_ASSERT(buf_size_needed <= UINT16_MAX);
CRNLIB_ASSERT(buf_size_needed <= cUINT16_MAX);
if (buf_size_needed <= UINT16_MAX)
if (buf_size_needed <= cUINT16_MAX)
{
if (buf_size_needed > m_buf_size)
expand_buf(buf_size_needed, preserve_contents);
@@ -593,7 +570,7 @@ namespace crnlib
bool dynamic_string::expand_buf(uint new_buf_size, bool preserve_contents)
{
new_buf_size = math::minimum<uint>(UINT16_MAX, math::next_pow2(math::maximum<uint>(m_buf_size, new_buf_size)));
new_buf_size = math::minimum<uint>(cUINT16_MAX, math::next_pow2(math::maximum<uint>(m_buf_size, new_buf_size)));
if (new_buf_size != m_buf_size)
{
@@ -625,8 +602,9 @@ namespace crnlib
{
uint buf_left = buf_size;
if (m_len > UINT16_MAX)
return -1;
//if (m_len > cUINT16_MAX)
// return -1;
CRNLIB_ASSUME(sizeof(m_len) == sizeof(uint16));
if (!utils::write_val((uint16)m_len, pBuf, buf_left, little_endian))
return -1;
@@ -687,9 +665,4 @@ namespace crnlib
swap(tmp);
}
dynamic_string& dynamic_string::operator= (const dynamic_wstring& rhs)
{
return set(rhs.get_ptr());
}
} // namespace crnlib
crnlib/crn_dynamic_string.h
+19 -9
View File
@@ -4,12 +4,9 @@
namespace crnlib
{
class dynamic_wstring;
enum { cMaxDynamicStringLen = cUINT16_MAX - 1 };
class dynamic_string
{
friend class dynamic_wstring;
public:
inline dynamic_string() : m_buf_size(0), m_len(0), m_pStr(NULL) { }
dynamic_string(eVarArg dummy, const char* p, ...);
@@ -19,25 +16,26 @@ namespace crnlib
inline ~dynamic_string() { if (m_pStr) crnlib_delete_array(m_pStr); }
explicit dynamic_string(const wchar_t* pStr);
dynamic_string& set(const wchar_t *pStr);
dynamic_wstring& as_utf16(dynamic_wstring &buf);
// Truncates the string to 0 chars and frees the buffer.
void clear();
void optimize();
// Truncates the string to 0 chars, but does not free the buffer.
void empty();
inline const char *assume_ownership() { const char *p = m_pStr; m_pStr = NULL; m_len = 0; m_buf_size = 0; return p; }
inline uint get_len() const { return m_len; }
inline bool is_empty() const { return !m_len; }
inline const char* get_ptr() const { return m_pStr ? m_pStr : ""; }
inline const char* c_str() const { return get_ptr(); }
inline const char* get_ptr_raw() const { return m_pStr; }
inline char* get_ptr_raw() { return m_pStr; }
inline char front() const { return m_len ? m_pStr[0] : '\0'; }
inline char back() const { return m_len ? m_pStr[m_len - 1] : '\0'; }
inline char operator[] (uint i) const { CRNLIB_ASSERT(i <= m_len); return get_ptr()[i]; }
inline operator size_t() const { return fast_hash(get_ptr(), m_len) ^ fast_hash(&m_len, sizeof(m_len)); }
@@ -74,7 +72,6 @@ namespace crnlib
dynamic_string& set_from_buf(const void* pBuf, uint buf_size);
dynamic_string& operator= (const dynamic_string& rhs) { return set(rhs); }
dynamic_string& operator= (const dynamic_wstring& rhs);
dynamic_string& operator= (const char* p) { return set(p); }
dynamic_string& set_char(uint index, char c);
@@ -130,6 +127,9 @@ namespace crnlib
void translate_lf_to_crlf();
static inline char *create_raw_buffer(uint& buf_size_in_chars);
static inline void free_raw_buffer(char *p) { crnlib_delete_array(p); }
dynamic_string& set_from_raw_buf_and_assume_ownership(char *pBuf, uint buf_size_in_chars, uint len_in_chars);
private:
uint16 m_buf_size;
uint16 m_len;
@@ -160,4 +160,14 @@ namespace crnlib
a.swap(b);
}
inline char *dynamic_string::create_raw_buffer(uint& buf_size_in_chars)
{
if (buf_size_in_chars > cUINT16_MAX)
{
CRNLIB_ASSERT(0);
return NULL;
}
buf_size_in_chars = math::minimum<uint>(cUINT16_MAX, math::next_pow2(buf_size_in_chars));
return crnlib_new_array<char>(buf_size_in_chars);
}
} // namespace crnlib
crnlib/crn_helpers.h
+2 -2
View File
@@ -30,7 +30,7 @@ namespace crnlib
}
template <typename T>
void construct_array(T* p, uint n)
inline void construct_array(T* p, uint n)
{
T* q = p + n;
for ( ; p != q; ++p)
@@ -38,7 +38,7 @@ namespace crnlib
}
template <typename T, typename U>
void construct_array(T* p, uint n, const U& init)
inline void construct_array(T* p, uint n, const U& init)
{
T* q = p + n;
for ( ; p != q; ++p)
crnlib/crn_huffman_codes.cpp
+3 -3
View File
@@ -228,7 +228,7 @@ namespace crnlib
sym_freq& sf = state.syms0[num_used_syms];
sf.m_left = (uint16)i;
sf.m_right = UINT16_MAX;
sf.m_right = cUINT16_MAX;
sf.m_freq = freq;
num_used_syms++;
}
@@ -263,8 +263,8 @@ namespace crnlib
#else
// Dummy node
sym_freq& sf = state.syms0[num_used_syms];
sf.m_left = UINT16_MAX;
sf.m_right = UINT16_MAX;
sf.m_left = cUINT16_MAX;
sf.m_right = cUINT16_MAX;
sf.m_freq = UINT_MAX;
uint next_internal_node = num_used_syms + 1;
crnlib/crn_image_utils.cpp
+39 -35
View File
@@ -6,6 +6,8 @@
#include "crn_resampler.h"
#include "crn_threaded_resampler.h"
#include "crn_strutils.h"
#include "crn_file_utils.h"
#include "crn_threading.h"
#define STBI_HEADER_FILE_ONLY
#include "crn_stb_image.cpp"
@@ -18,10 +20,10 @@ namespace crnlib
namespace image_utils
{
bool load_from_file_stb(const wchar_t* pFilename, image_u8& img)
bool load_from_file_stb(const char* pFilename, image_u8& img)
{
int x = 0, y = 0, n = 0;
unsigned char* pData = stbi_load_w(pFilename, &x, &y, &n, 4);
unsigned char* pData = stbi_load(pFilename, &x, &y, &n, 4);
if (!pData)
return false;
@@ -66,20 +68,20 @@ namespace crnlib
return true;
}
bool save_to_file_stb(const wchar_t* pFilename, const image_u8& img, uint save_flags, int comp_index)
bool save_to_file_stb(const char* pFilename, const image_u8& img, uint save_flags, int comp_index)
{
if (!img.get_width())
return false;
bool bSaveBMP = false;
dynamic_wstring ext(pFilename);
if (get_extension(ext))
dynamic_string ext(pFilename);
if (file_utils::get_extension(ext))
{
if (ext == L"bmp")
if (ext == "bmp")
bSaveBMP = true;
else if (ext != L"tga")
else if (ext != "tga")
{
console::error(L"crnlib::image_utils::save_to_file_stb: Can only write .BMP or .TGA files!\n");
console::error("crnlib::image_utils::save_to_file_stb: Can only write .BMP or .TGA files!\n");
return false;
}
}
@@ -114,7 +116,7 @@ namespace crnlib
}
}
return (bSaveBMP ? stbi_write_bmp_w : stbi_write_tga_w)(pFilename, img.get_width(), img.get_height(), 1, &temp[0]) == CRNLIB_TRUE;
return (bSaveBMP ? stbi_write_bmp : stbi_write_tga)(pFilename, img.get_width(), img.get_height(), 1, &temp[0]) == CRNLIB_TRUE;
}
else if ((!img.is_component_valid(3)) || (save_flags & cSaveIgnoreAlpha))
{
@@ -138,27 +140,27 @@ namespace crnlib
}
}
return (bSaveBMP ? stbi_write_bmp_w : stbi_write_tga_w)(pFilename, img.get_width(), img.get_height(), 3, &temp[0]) == CRNLIB_TRUE;
return (bSaveBMP ? stbi_write_bmp : stbi_write_tga)(pFilename, img.get_width(), img.get_height(), 3, &temp[0]) == CRNLIB_TRUE;
}
else
{
return (bSaveBMP ? stbi_write_bmp_w : stbi_write_tga_w)(pFilename, img.get_width(), img.get_height(), 4, img.get_ptr()) == CRNLIB_TRUE;
return (bSaveBMP ? stbi_write_bmp : stbi_write_tga)(pFilename, img.get_width(), img.get_height(), 4, img.get_ptr()) == CRNLIB_TRUE;
}
}
bool load_from_file(image_u8& dest, const wchar_t* pFilename, int flags)
bool load_from_file(image_u8& dest, const char* pFilename, int flags)
{
flags;
return image_utils::load_from_file_stb(pFilename, dest);
}
bool save_to_grayscale_file(const wchar_t* pFilename, const image_u8& src, int component, int flags)
bool save_to_grayscale_file(const char* pFilename, const image_u8& src, int component, int flags)
{
flags;
return image_utils::save_to_file_stb(pFilename, src, image_utils::cSaveGrayscale, component);
}
bool save_to_file(const wchar_t* pFilename, const image_u8& src, int flags, bool ignore_alpha)
bool save_to_file(const char* pFilename, const image_u8& src, int flags, bool ignore_alpha)
{
if (src.is_grayscale())
return save_to_grayscale_file(pFilename, src, cSaveLuma, flags);
@@ -220,7 +222,7 @@ namespace crnlib
}
}
bool is_normal_map(const image_u8& img, const wchar_t* pFilename)
bool is_normal_map(const image_u8& img, const char* pFilename)
{
float score = 0.0f;
@@ -259,13 +261,13 @@ namespace crnlib
if (pFilename)
{
dynamic_wstring str(pFilename);
dynamic_string str(pFilename);
str.tolower();
if (str.contains(L"normal") || str.contains(L"local") || str.contains(L"nmap"))
if (str.contains("normal") || str.contains("local") || str.contains("nmap"))
score += 1.0f;
if (str.contains(L"diffuse") || str.contains(L"spec") || str.contains(L"gloss"))
if (str.contains("diffuse") || str.contains("spec") || str.contains("gloss"))
score -= 1.0f;
}
@@ -712,32 +714,34 @@ namespace crnlib
if (!total_blocks)
return 0.0f;
//save_to_file_stb(L"ssim.tga", yimg, cSaveGrayscale);
//save_to_file_stb("ssim.tga", yimg, cSaveGrayscale);
return total_ssim / total_blocks;
}
void print_ssim(const image_u8& src_img, const image_u8& dst_img)
{
double y_ssim = compute_ssim(src_img, dst_img, -1);
console::printf(L"Luma MSSIM: %f, Scaled: %f", y_ssim, (y_ssim - .8f) / .2f);
src_img;
dst_img;
//double y_ssim = compute_ssim(src_img, dst_img, -1);
//console::printf("Luma MSSIM: %f, Scaled: %f", y_ssim, (y_ssim - .8f) / .2f);
//double r_ssim = compute_ssim(src_img, dst_img, 0);
//console::printf(L" R MSSIM: %f", r_ssim);
//console::printf(" R MSSIM: %f", r_ssim);
//double g_ssim = compute_ssim(src_img, dst_img, 1);
//console::printf(L" G MSSIM: %f", g_ssim);
//console::printf(" G MSSIM: %f", g_ssim);
//double b_ssim = compute_ssim(src_img, dst_img, 2);
//console::printf(L" B MSSIM: %f", b_ssim);
//console::printf(" B MSSIM: %f", b_ssim);
}
void error_metrics::print(const wchar_t* pName) const
void error_metrics::print(const char* pName) const
{
if (mPeakSNR >= cInfinitePSNR)
console::printf(L"%s Error: Max: %3u, Mean: %3.3f, RMS: %3.3f, PSNR: Infinite", pName, mMax, mMean, mRootMeanSquared);
console::printf("%s Error: Max: %3u, Mean: %3.3f, MSE: %3.3f, RMS: %3.3f, PSNR: Infinite", pName, mMax, mMean, mMeanSquared, mRootMeanSquared);
else
console::printf(L"%s Error: Max: %3u, Mean: %3.3f, RMS: %3.3f, PSNR: %3.3f", pName, mMax, mMean, mRootMeanSquared, mPeakSNR);
console::printf("%s Error: Max: %3u, Mean: %3.3f, MSE: %3.3f, RMS: %3.3f, PSNR: %3.3f", pName, mMax, mMean, mMeanSquared, mRootMeanSquared, mPeakSNR);
}
bool error_metrics::compute(const image_u8& a, const image_u8& b, uint first_channel, uint num_channels, bool average_component_error)
@@ -808,35 +812,35 @@ namespace crnlib
void print_image_metrics(const image_u8& src_img, const image_u8& dst_img)
{
if ( (!src_img.get_width()) || (!dst_img.get_height()) || (src_img.get_width() != dst_img.get_width()) || (src_img.get_height() != dst_img.get_height()) )
console::printf(L"print_image_metrics: Image resolutions don't match exactly (%ux%u) vs. (%ux%u)", src_img.get_width(), src_img.get_height(), dst_img.get_width(), dst_img.get_height());
console::printf("print_image_metrics: Image resolutions don't match exactly (%ux%u) vs. (%ux%u)", src_img.get_width(), src_img.get_height(), dst_img.get_width(), dst_img.get_height());
image_utils::error_metrics error_metrics;
if (src_img.has_rgb() || dst_img.has_rgb())
{
error_metrics.compute(src_img, dst_img, 0, 3, false);
error_metrics.print(L"RGB Total ");
error_metrics.print("RGB Total ");
error_metrics.compute(src_img, dst_img, 0, 3, true);
error_metrics.print(L"RGB Average");
error_metrics.print("RGB Average");
error_metrics.compute(src_img, dst_img, 0, 0);
error_metrics.print(L"Luma ");
error_metrics.print("Luma ");
error_metrics.compute(src_img, dst_img, 0, 1);
error_metrics.print(L"Red ");
error_metrics.print("Red ");
error_metrics.compute(src_img, dst_img, 1, 1);
error_metrics.print(L"Green ");
error_metrics.print("Green ");
error_metrics.compute(src_img, dst_img, 2, 1);
error_metrics.print(L"Blue ");
error_metrics.print("Blue ");
}
if (src_img.has_alpha() || dst_img.has_alpha())
{
error_metrics.compute(src_img, dst_img, 3, 1);
error_metrics.print(L"Alpha ");
error_metrics.print("Alpha ");
}
}
crnlib/crn_image_utils.h
+7 -7
View File
@@ -9,7 +9,7 @@ namespace crnlib
namespace image_utils
{
bool load_from_file_stb(const wchar_t* pFilename, image_u8& img);
bool load_from_file_stb(const char* pFilename, image_u8& img);
enum
{
@@ -19,16 +19,16 @@ namespace crnlib
const int cSaveLuma = -1;
bool save_to_file_stb(const wchar_t* pFilename, const image_u8& img, uint save_flags = 0, int comp_index = cSaveLuma);
bool save_to_file_stb(const char* pFilename, const image_u8& img, uint save_flags = 0, int comp_index = cSaveLuma);
bool load_from_file(image_u8& dest, const wchar_t* pFilename, int flags = 0);
bool load_from_file(image_u8& dest, const char* pFilename, int flags = 0);
bool save_to_grayscale_file(const wchar_t* pFilename, const image_u8& src, int component, int flags = 0);
bool save_to_grayscale_file(const char* pFilename, const image_u8& src, int component, int flags = 0);
bool save_to_file(const wchar_t* pFilename, const image_u8& src, int flags = 0, bool ignore_alpha = false);
bool save_to_file(const char* pFilename, const image_u8& src, int flags = 0, bool ignore_alpha = false);
bool has_alpha(const image_u8& img);
bool is_normal_map(const image_u8& img, const wchar_t* pFilename = NULL);
bool is_normal_map(const image_u8& img, const char* pFilename = NULL);
void renorm_normal_map(image_u8& img);
struct resample_params
@@ -70,7 +70,7 @@ namespace crnlib
public:
error_metrics() { utils::zero_this(this); }
void print(const wchar_t* pName) const;
void print(const char* pName) const;
// If num_channels==0, luma error is computed.
// If pHist != NULL, it must point to a 256 entry array.
crnlib/crn_lzma_codec.cpp
+6 -1
View File
@@ -4,7 +4,8 @@
#include "crn_lzma_codec.h"
#include "crn_strutils.h"
#include "crn_checksum.h"
#include "lzma_lzmalib.h"
#include "lzma_LzmaLib.h"
#include "crn_threading.h"
namespace crnlib
{
@@ -54,7 +55,11 @@ namespace crnlib
-1, /* 0 <= lp <= 4, default = 0 */
-1, /* 0 <= pb <= 4, default = 2 */
-1, /* 5 <= fb <= 273, default = 32 */
#ifdef WIN32
(g_number_of_processors > 1) ? 2 : 1
#else
1
#endif
);
if (status != SZ_ERROR_OUTPUT_EOF)
crnlib/crn_lzma_codec.h
+3 -3
View File
@@ -12,14 +12,14 @@ namespace crnlib
~lzma_codec();
// Always available, because we're statically linking in lzmalib now vs. dynamically loading the DLL.
const bool is_initialized() const { return true; }
bool is_initialized() const { return true; }
bool pack(const void* p, uint n, crnlib::vector<uint8>& buf);
bool unpack(const void* p, uint n, crnlib::vector<uint8>& buf);
private:
typedef int (__stdcall *LzmaCompressFuncPtr)(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
typedef int (CRNLIB_STDCALL *LzmaCompressFuncPtr)(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
unsigned char *outProps, size_t *outPropsSize, /* *outPropsSize must be = 5 */
int level, /* 0 <= level <= 9, default = 5 */
unsigned dictSize, /* default = (1 << 24) */
@@ -30,7 +30,7 @@ namespace crnlib
int numThreads /* 1 or 2, default = 2 */
);
typedef int (__stdcall *LzmaUncompressFuncPtr)(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,
typedef int (CRNLIB_STDCALL *LzmaUncompressFuncPtr)(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,
const unsigned char *props, size_t propsSize);
LzmaCompressFuncPtr m_pCompress;
crnlib/crn_math.h
+8
View File
@@ -216,6 +216,14 @@ namespace crnlib
void compute_lower_pow2_dim(int& width, int& height);
void compute_upper_pow2_dim(int& width, int& height);
inline bool equal_tol(float a, float b, float t)
{
return fabs(a - b) < ((maximum(fabs(a), fabs(b)) + 1.0f) * t);
}
inline bool equal_tol(double a, double b, double t)
{
return fabs(a - b) < ((maximum(fabs(a), fabs(b)) + 1.0f) * t);
}
}
} // namespace crnlib
crnlib/crn_mem.cpp
+87 -6
View File
@@ -1,15 +1,16 @@
// File: crn_mem.cpp
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "crn_spinlock.h"
#include "crn_console.h"
#include "../inc/crnlib.h"
#include <malloc.h>
#if CRNLIB_USE_WIN32_API
#include "crn_winhdr.h"
#endif
#define CRNLIB_MEM_STATS 0
#ifndef CRNLIB_USE_WIN32_API
#if !CRNLIB_USE_WIN32_API
#define _msize malloc_usable_size
#endif
@@ -88,7 +89,6 @@ namespace crnlib
#ifdef WIN32
p_new = ::_expand(p, size);
#else
p_new = NULL;
#endif
@@ -121,14 +121,95 @@ namespace crnlib
return p ? _msize(p) : 0;
}
#if 0
static __declspec(thread) void *g_pBuf;
static __declspec(thread) size_t g_buf_size;
static __declspec(thread) size_t g_buf_ofs;
static size_t crnlib_nofree_msize(void* p, void* pUser_data)
{
pUser_data;
return p ? ((const size_t*)p)[-1] : 0;
}
static void* crnlib_nofree_realloc(void* p, size_t size, size_t* pActual_size, bool movable, void* pUser_data)
{
pUser_data;
void* p_new;
if (!p)
{
size = math::align_up_value(size, CRNLIB_MIN_ALLOC_ALIGNMENT);
size_t actual_size = sizeof(size_t)*2 + size;
size_t num_remaining = g_buf_size - g_buf_ofs;
if (num_remaining < actual_size)
{
g_buf_size = CRNLIB_MAX(actual_size, 32*1024*1024);
g_buf_ofs = 0;
g_pBuf = malloc(g_buf_size);
if (!g_pBuf)
return NULL;
}
p_new = (uint8*)g_pBuf + g_buf_ofs;
((size_t*)p_new)[1] = size;
p_new = (size_t*)p_new + 2;
g_buf_ofs += actual_size;
if (pActual_size)
*pActual_size = size;
CRNLIB_ASSERT(crnlib_nofree_msize(p_new, NULL) == size);
}
else if (!size)
{
if (pActual_size)
*pActual_size = 0;
p_new = NULL;
}
else
{
size_t cur_size = crnlib_nofree_msize(p, NULL);
p_new = p;
if (!movable)
return NULL;
if (size > cur_size)
{
p_new = crnlib_nofree_realloc(NULL, size, NULL, true, NULL);
if (!p_new)
return NULL;
memcpy(p_new, p, cur_size);
cur_size = size;
}
if (pActual_size)
*pActual_size = cur_size;
}
return p_new;
}
static crn_realloc_func g_pRealloc = crnlib_nofree_realloc;
static crn_msize_func g_pMSize = crnlib_nofree_msize;
#else
static crn_realloc_func g_pRealloc = crnlib_default_realloc;
static crn_msize_func g_pMSize = crnlib_default_msize;
#endif
static void* g_pUser_data;
void crnlib_mem_error(const char* p_msg)
{
crnlib_assert(p_msg, __FILE__, __LINE__);
}
void* crnlib_malloc(size_t size)
{
return crnlib_malloc(size, NULL);
}
void* crnlib_malloc(size_t size, size_t* pActual_size)
{
@@ -259,13 +340,13 @@ namespace crnlib
#if CRNLIB_MEM_STATS
if (console::is_initialized())
{
console::debug(L"crnlib_print_mem_stats:");
console::debug(L"Current blocks: %u, allocated: %I64u, max ever allocated: %I64i", g_total_blocks, (int64)g_total_allocated, (int64)g_max_allocated);
console::debug("crnlib_print_mem_stats:");
console::debug("Current blocks: %u, allocated: " CRNLIB_INT64_FORMAT_SPECIFIER ", max ever allocated: " CRNLIB_INT64_FORMAT_SPECIFIER, g_total_blocks, (int64)g_total_allocated, (int64)g_max_allocated);
}
else
{
printf("crnlib_print_mem_stats:\n");
printf("Current blocks: %u, allocated: %I64u, max ever allocated: %I64i\n", g_total_blocks, (int64)g_total_allocated, (int64)g_max_allocated);
printf("Current blocks: %u, allocated: " CRNLIB_INT64_FORMAT_SPECIFIER ", max ever allocated: " CRNLIB_INT64_FORMAT_SPECIFIER "\n", g_total_blocks, (int64)g_total_allocated, (int64)g_max_allocated);
}
#endif
}
crnlib/crn_mem.h
+25 -1
View File
@@ -14,7 +14,8 @@ namespace crnlib
const uint32 CRNLIB_MAX_POSSIBLE_BLOCK_SIZE = 0x7FFF0000U;
#endif
void* crnlib_malloc(size_t size, size_t* pActual_size = NULL);
void* crnlib_malloc(size_t size);
void* crnlib_malloc(size_t size, size_t* pActual_size);
void* crnlib_realloc(void* p, size_t size, size_t* pActual_size = NULL, bool movable = true);
void* crnlib_calloc(size_t count, size_t size, size_t* pActual_size = NULL);
void crnlib_free(void* p);
@@ -183,3 +184,26 @@ namespace crnlib
}
} // namespace crnlib
#define CRNLIB_DEFINE_NEW_DELETE \
void* operator new (size_t size) \
{ \
void* p = crnlib::crnlib_malloc(size); \
if (!p) \
crnlib_fail("new: Out of memory!", __FILE__, __LINE__); \
return p; \
} \
void* operator new[] (size_t size) \
{ \
void* p = crnlib::crnlib_malloc(size); \
if (!p) \
crnlib_fail("new[]: Out of memory!", __FILE__, __LINE__); \
return p; \
} \
void operator delete (void* p_block) \
{ \
crnlib::crnlib_free(p_block); \
} \
void operator delete[] (void* p_block) \
{ \
crnlib::crnlib_free(p_block); \
}
crnlib/crn_pixel_format.cpp
+2 -51
View File
@@ -41,36 +41,7 @@ namespace crnlib
return g_all_pixel_formats[index];
}
const wchar_t* get_pixel_format_string(pixel_format fmt)
{
switch (fmt)
{
case PIXEL_FMT_INVALID: return L"INVALID";
case PIXEL_FMT_DXT1: return L"DXT1";
case PIXEL_FMT_DXT1A: return L"DXT1A";
case PIXEL_FMT_DXT2: return L"DXT2";
case PIXEL_FMT_DXT3: return L"DXT3";
case PIXEL_FMT_DXT4: return L"DXT4";
case PIXEL_FMT_DXT5: return L"DXT5";
case PIXEL_FMT_3DC: return L"3DC";
case PIXEL_FMT_DXN: return L"DXN";
case PIXEL_FMT_DXT5A: return L"DXT5A";
case PIXEL_FMT_DXT5_CCxY: return L"DXT5_CCxY";
case PIXEL_FMT_DXT5_xGxR: return L"DXT5_xGxR";
case PIXEL_FMT_DXT5_xGBR: return L"DXT5_xGBR";
case PIXEL_FMT_DXT5_AGBR: return L"DXT5_AGBR";
case PIXEL_FMT_R8G8B8: return L"R8G8B8";
case PIXEL_FMT_A8R8G8B8: return L"A8R8G8B8";
case PIXEL_FMT_A8: return L"A8";
case PIXEL_FMT_L8: return L"L8";
case PIXEL_FMT_A8L8: return L"A8L8";
default: break;
}
CRNLIB_ASSERT(false);
return L"?";
}
const char* get_pixel_format_stringa(pixel_format fmt)
const char* get_pixel_format_string(pixel_format fmt)
{
switch (fmt)
{
@@ -99,27 +70,7 @@ namespace crnlib
return "?";
}
const wchar_t* get_crn_format_string(crn_format fmt)
{
switch (fmt)
{
case cCRNFmtDXT1: return L"DXT1";
case cCRNFmtDXT3: return L"DXT3";
case cCRNFmtDXT5: return L"DXT5";
case cCRNFmtDXT5_CCxY: return L"DXT5_CCxY";
case cCRNFmtDXT5_xGBR: return L"DXT5_xGBR";
case cCRNFmtDXT5_AGBR: return L"DXT5_AGBR";
case cCRNFmtDXT5_xGxR: return L"DXT5_xGxR";
case cCRNFmtDXN_XY: return L"DXN_XY";
case cCRNFmtDXN_YX: return L"DXN_YX";
case cCRNFmtDXT5A: return L"DXT5A";
default: break;
}
CRNLIB_ASSERT(false);
return L"?";
}
const char* get_crn_format_stringa(crn_format fmt)
const char* get_crn_format_string(crn_format fmt)
{
switch (fmt)
{
crnlib/crn_pixel_format.h
+2 -4
View File
@@ -12,11 +12,9 @@ namespace crnlib
uint get_num_formats();
pixel_format get_pixel_format_by_index(uint index);
const wchar_t* get_pixel_format_string(pixel_format fmt);
const char* get_pixel_format_stringa(pixel_format fmt);
const char* get_pixel_format_string(pixel_format fmt);
const wchar_t* get_crn_format_string(crn_format fmt);
const char* get_crn_format_stringa(crn_format fmt);
const char* get_crn_format_string(crn_format fmt);
inline bool is_grayscale(pixel_format fmt)
{
crnlib/crn_platform.cpp
+78 -5
View File
@@ -1,6 +1,73 @@
// File: crn_platform.cpp
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#if CRNLIB_USE_WIN32_API
#include "crn_winhdr.h"
#endif
#ifndef _MSC_VER
int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...)
{
if (!sizeOfBuffer)
return 0;
va_list args;
va_start(args, format);
int c = vsnprintf(buffer, sizeOfBuffer, format, args);
va_end(args);
buffer[sizeOfBuffer - 1] = '\0';
if (c < 0)
return sizeOfBuffer - 1;
return CRNLIB_MIN(c, (int)sizeOfBuffer - 1);
}
int vsprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, va_list args)
{
if (!sizeOfBuffer)
return 0;
int c = vsnprintf(buffer, sizeOfBuffer, format, args);
buffer[sizeOfBuffer - 1] = '\0';
if (c < 0)
return sizeOfBuffer - 1;
return CRNLIB_MIN(c, (int)sizeOfBuffer - 1);
}
char* strlwr(char* p)
{
char *q = p;
while (*q)
{
char c = *q;
*q++ = tolower(c);
}
return p;
}
char* strupr(char *p)
{
char *q = p;
while (*q)
{
char c = *q;
*q++ = toupper(c);
}
return p;
}
#endif // __GNUC__
void crnlib_debug_break(void)
{
CRNLIB_BREAKPOINT
}
#if CRNLIB_USE_WIN32_API
#include "crn_winhdr.h"
bool crnlib_is_debugger_present(void)
@@ -8,12 +75,18 @@ bool crnlib_is_debugger_present(void)
return IsDebuggerPresent() != 0;
}
void crnlib_debug_break(void)
{
DebugBreak();
}
void crnlib_output_debug_string(const char* p)
{
OutputDebugStringA(p);
}
#else
bool crnlib_is_debugger_present(void)
{
return false;
}
void crnlib_output_debug_string(const char* p)
{
puts(p);
}
#endif // CRNLIB_USE_WIN32_API
crnlib/crn_platform.h
+53 -9
View File
@@ -2,7 +2,15 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#pragma once
#ifdef CRNLIB_PLATFORM_PC
bool crnlib_is_debugger_present(void);
void crnlib_debug_break(void);
void crnlib_output_debug_string(const char* p);
// actually in crnlib_assert.cpp
void crnlib_assert(const char* pExp, const char* pFile, unsigned line);
void crnlib_fail(const char* pExp, const char* pFile, unsigned line);
#if CRNLIB_LITTLE_ENDIAN_CPU
const bool c_crnlib_little_endian_platform = true;
#else
const bool c_crnlib_little_endian_platform = false;
@@ -10,6 +18,50 @@
const bool c_crnlib_big_endian_platform = !c_crnlib_little_endian_platform;
#ifdef __GNUC__
#define crn_fopen(pDstFile, f, m) *(pDstFile) = fopen64(f, m)
#define crn_fseek fseeko64
#define crn_ftell ftello64
#elif defined( _MSC_VER )
#define crn_fopen(pDstFile, f, m) fopen_s(pDstFile, f, m)
#define crn_fseek _fseeki64
#define crn_ftell _ftelli64
#else
#define crn_fopen(pDstFile, f, m) *(pDstFile) = fopen(f, m)
#define crn_fseek(s, o, w) fseek(s, static_cast<long>(o), w)
#define crn_ftell ftell
#endif
#if CRNLIB_USE_WIN32_API
#define CRNLIB_BREAKPOINT DebugBreak();
#define CRNLIB_BUILTIN_EXPECT(c, v) c
#elif defined(__GNUC__)
#define CRNLIB_BREAKPOINT asm("int $3");
#define CRNLIB_BUILTIN_EXPECT(c, v) __builtin_expect(c, v)
#else
#define CRNLIB_BREAKPOINT
#define CRNLIB_BUILTIN_EXPECT(c, v) c
#endif
#if defined(__GNUC__)
#define CRNLIB_ALIGNED(x) __attribute__((aligned(x)))
#elif defined(_MSC_VER)
#define CRNLIB_ALIGNED(x) __declspec(align(x))
#else
#define CRNLIB_ALIGNED(x)
#endif
#define CRNLIB_GET_ALIGNMENT(v) ((!sizeof(v)) ? 1 : (__alignof(v) ? __alignof(v) : sizeof(uint32)))
#ifndef _MSC_VER
int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...);
int vsprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, va_list args);
char* strlwr(char* p);
char* strupr(char *p);
#define _stricmp strcasecmp
#define _strnicmp strncasecmp
#endif
inline bool crnlib_is_little_endian() { return c_crnlib_little_endian_platform; }
inline bool crnlib_is_big_endian() { return c_crnlib_big_endian_platform; }
@@ -39,11 +91,3 @@ inline bool crnlib_is_x64()
return false;
#endif
}
bool crnlib_is_debugger_present(void);
void crnlib_debug_break(void);
void crnlib_output_debug_string(const char* p);
// actually in crnlib_assert.cpp
void crnlib_assert(const char* pExp, const char* pFile, unsigned line);
void crnlib_fail(const char* pExp, const char* pFile, unsigned line);
crnlib/crn_prefix_coding.cpp
+2 -2
View File
@@ -156,7 +156,7 @@ namespace crnlib
uint c = pCodesizes[i];
if (c)
{
CRNLIB_ASSERT(next_code[c] <= UINT16_MAX);
CRNLIB_ASSERT(next_code[c] <= cUINT16_MAX);
pCodes[i] = static_cast<uint16>(next_code[c]++);
CRNLIB_ASSERT(math::total_bits(pCodes[i]) <= pCodesizes[i]);
@@ -300,7 +300,7 @@ namespace crnlib
CRNLIB_ASSERT(t < (1U << table_bits));
CRNLIB_ASSERT(pTables->m_lookup[t] == UINT32_MAX);
CRNLIB_ASSERT(pTables->m_lookup[t] == cUINT32_MAX);
pTables->m_lookup[t] = sym_index | (codesize << 16U);
}
crnlib/crn_qdxt1.cpp
+13 -12
View File
@@ -61,7 +61,7 @@ namespace crnlib
CRNLIB_ASSERT(n && pBlocks);
m_main_thread_id = get_current_thread_id();
m_main_thread_id = crn_get_current_thread_id();
m_num_blocks = n;
m_pBlocks = pBlocks;
@@ -99,6 +99,11 @@ namespace crnlib
if (debugging)
debug_img.resize(num_chunks_x * cChunkPixelWidth, num_chunks_y * cChunkPixelHeight);
float adaptive_tile_color_psnr_derating = 1.5f; // was 2.4f
if ((level) && (adaptive_tile_color_psnr_derating > .25f))
{
adaptive_tile_color_psnr_derating = math::maximum(.25f, adaptive_tile_color_psnr_derating / powf(3.1f, static_cast<float>(level))); // was 3.0f
}
for (uint chunk_y = 0; chunk_y < num_chunks_y; chunk_y++)
{
for (uint chunk_x = 0; chunk_x < num_chunks_x; chunk_x++)
@@ -197,13 +202,8 @@ namespace crnlib
if (mean_squared)
peak_snr = math::clamp<double>(log10(255.0f / root_mean_squared) * 20.0f, 0.0f, 500.0f);
float adaptive_tile_color_psnr_derating = 2.4f;
//if (level)
// adaptive_tile_color_psnr_derating = math::lerp(adaptive_tile_color_psnr_derating * .5f, .3f, math::maximum((level - 1) / float(m_params.m_num_mips - 2), 1.0f));
if ((level) && (adaptive_tile_color_psnr_derating > .25f))
{
adaptive_tile_color_psnr_derating = math::maximum(.25f, adaptive_tile_color_psnr_derating / powf(3.0f, static_cast<float>(level)));
}
float color_derating = math::lerp( 0.0f, adaptive_tile_color_psnr_derating, (g_chunk_encodings[e].m_num_tiles - 1) / 3.0f );
peak_snr = peak_snr - color_derating;
@@ -306,7 +306,7 @@ namespace crnlib
#if GENERATE_DEBUG_IMAGES
if (debugging)
image_utils::save_to_file_stb(dynamic_wstring(cVarArg, L"debug_%u.tga", level).get_ptr(), debug_img, image_utils::cSaveIgnoreAlpha);
image_utils::save_to_file_stb(dynamic_string(cVarArg, "debug_%u.tga", level).get_ptr(), debug_img, image_utils::cSaveIgnoreAlpha);
#endif
} // level
@@ -440,7 +440,7 @@ namespace crnlib
if ((cluster_index & cluster_index_progress_mask) == 0)
{
if (get_current_thread_id() == m_main_thread_id)
if (crn_get_current_thread_id() == m_main_thread_id)
{
if (!update_progress(cluster_index, m_endpoint_cluster_indices.size() - 1))
return;
@@ -547,7 +547,8 @@ namespace crnlib
{
const uint block_index = indices[block_iter];
const color_quad_u8* pSrc_pixels = &m_pBlocks[block_index].m_pixels[0][0];
//const color_quad_u8* pSrc_pixels = &m_pBlocks[block_index].m_pixels[0][0];
const color_quad_u8* pSrc_pixels = (const color_quad_u8*)m_pBlocks[block_index].m_pixels;
for (uint i = 0; i < cDXTBlockSize * cDXTBlockSize; i++)
{
@@ -646,7 +647,7 @@ namespace crnlib
if ((cluster_index & 255) == 0)
{
if (get_current_thread_id() == m_main_thread_id)
if (crn_get_current_thread_id() == m_main_thread_id)
{
if (!update_progress(cluster_index, task_params.m_selector_cluster_indices.size() - 1))
return;
@@ -681,7 +682,7 @@ namespace crnlib
if (m_params.m_dxt1a_alpha_threshold > 0)
{
const color_quad_u8* pSrc_pixels = &m_pBlocks[block_index].m_pixels[0][0];
const color_quad_u8* pSrc_pixels = (const color_quad_u8*)m_pBlocks[block_index].m_pixels;
for (uint i = 0; i < cDXTBlockSize * cDXTBlockSize; i++)
{
@@ -809,7 +810,7 @@ namespace crnlib
{
CRNLIB_ASSERT(m_num_blocks);
m_main_thread_id = get_current_thread_id();
m_main_thread_id = crn_get_current_thread_id();
m_canceled = false;
m_pDst_elements = pDst_elements;
crnlib/crn_qdxt1.h
+1 -3
View File
@@ -2,8 +2,6 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#pragma once
#include "crn_dxt.h"
#include "crn_task_pool.h"
#include "crn_spinlock.h"
#include "crn_hash_map.h"
#include "crn_clusterizer.h"
#include "crn_hash.h"
@@ -91,7 +89,7 @@ namespace crnlib
private:
task_pool* m_pTask_pool;
uint32 m_main_thread_id;
crn_thread_id_t m_main_thread_id;
bool m_canceled;
uint m_progress_start;
crnlib/crn_qdxt5.cpp
+7 -6
View File
@@ -62,7 +62,7 @@ namespace crnlib
CRNLIB_ASSERT(n && pBlocks);
m_main_thread_id = get_current_thread_id();
m_main_thread_id = crn_get_current_thread_id();
m_num_blocks = n;
m_pBlocks = pBlocks;
@@ -286,7 +286,7 @@ namespace crnlib
#if QDXT5_DEBUGGING
if (debugging)
image_utils::save_to_file_stb(dynamic_wstring(cVarArg, L"debug_%u.tga", level).get_ptr(), debug_img, image_utils::cSaveIgnoreAlpha);
image_utils::save_to_file_stb(dynamic_wstring(cVarArg, "debug_%u.tga", level).get_ptr(), debug_img, image_utils::cSaveIgnoreAlpha);
#endif
} // level
@@ -419,7 +419,7 @@ namespace crnlib
if ((cluster_index & cluster_index_progress_mask) == 0)
{
if (get_current_thread_id() == m_main_thread_id)
if (crn_get_current_thread_id() == m_main_thread_id)
{
if (!update_progress(cluster_index, m_endpoint_cluster_indices.size() - 1))
return;
@@ -444,7 +444,8 @@ namespace crnlib
{
const uint block_index = cluster_indices[block_iter];
const color_quad_u8* pSrc_pixels = &m_pBlocks[block_index].m_pixels[0][0];
//const color_quad_u8* pSrc_pixels = &m_pBlocks[block_index].m_pixels[0][0];
const color_quad_u8* pSrc_pixels = (const color_quad_u8*)m_pBlocks[block_index].m_pixels;
for (uint i = 0; i < cDXTBlockSize * cDXTBlockSize; i++)
{
@@ -521,7 +522,7 @@ namespace crnlib
if ((cluster_index & 255) == 0)
{
if (get_current_thread_id() == m_main_thread_id)
if (crn_get_current_thread_id() == m_main_thread_id)
{
if (!update_progress(cluster_index, task_params.m_selector_cluster_indices.size() - 1))
return;
@@ -735,7 +736,7 @@ namespace crnlib
{
CRNLIB_ASSERT(m_num_blocks);
m_main_thread_id = get_current_thread_id();
m_main_thread_id = crn_get_current_thread_id();
m_canceled = false;
m_pDst_elements = pDst_elements;
crnlib/crn_qdxt5.h
+1 -3
View File
@@ -1,8 +1,6 @@
// File: crn_qdxt5.h
// See Copyright Notice and license at the end of inc/crnlib.h
#pragma once
#include "crn_task_pool.h"
#include "crn_spinlock.h"
#include "crn_hash_map.h"
#include "crn_clusterizer.h"
#include "crn_hash.h"
@@ -92,7 +90,7 @@ namespace crnlib
private:
task_pool* m_pTask_pool;
uint32 m_main_thread_id;
crn_thread_id_t m_main_thread_id;
bool m_canceled;
uint m_progress_start;
crnlib/crn_rand.cpp
+14
View File
@@ -174,6 +174,13 @@ namespace crnlib
return m_kiss99.next() ^ (m_ranctx.next() + m_well512.next());
}
uint64 random::urand64()
{
uint64 result = urand32();
result <<= 32ULL;
result |= urand32();
return result;
}
uint32 random::fast_urand32()
{
return m_well512.next();
@@ -317,6 +324,13 @@ namespace crnlib
return SHR3 ^ CONG;
}
uint64 fast_random::urand64()
{
uint64 result = urand32();
result <<= 32ULL;
result |= urand32();
return result;
}
int fast_random::irand(int l, int h)
{
CRNLIB_ASSERT(l < h);
crnlib/crn_rand.h
+2
View File
@@ -63,6 +63,7 @@ namespace crnlib
void seed(uint32 i1, uint32 i2, uint32 i3);
uint32 urand32();
uint64 urand64();
// "Fast" variant uses no multiplies.
uint32 fast_urand32();
@@ -99,6 +100,7 @@ namespace crnlib
void seed(uint32 i);
uint32 urand32();
uint64 urand64();
int irand(int l, int h);
crnlib/crn_stb_image.cpp
+43 -16
View File
@@ -193,17 +193,23 @@ typedef unsigned char stbi_uc;
// (you must include the appropriate extension in the filename).
// returns TRUE on success, FALSE if couldn't open file, error writing file
extern int stbi_write_bmp (char const *filename, int x, int y, int comp, const void *data);
#ifdef _MSC_VER
extern int stbi_write_bmp_w (wchar_t const *filename, int x, int y, int comp, const void *data);
#endif
extern int stbi_write_tga (char const *filename, int x, int y, int comp, const void *data);
#ifdef _MSC_VER
extern int stbi_write_tga_w (wchar_t const *filename, int x, int y, int comp, const void *data);
#endif
#endif
// PRIMARY API - works on images of any type
// load image by filename, open file, or memory buffer
#ifndef STBI_NO_STDIO
extern stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp);
#ifdef _MSC_VER
extern stbi_uc *stbi_load_w (wchar_t const *filename, int *x, int *y, int *comp, int req_comp);
#endif
extern stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
extern int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);
#endif
@@ -227,7 +233,7 @@ extern void stbi_ldr_to_hdr_scale(float scale);
// get a VERY brief reason for failure
// NOT THREADSAFE
extern char *stbi_failure_reason (void);
extern const char *stbi_failure_reason (void);
// free the loaded image -- this is just stb_free()
extern void stbi_image_free (void *retval_from_stbi_load);
@@ -418,14 +424,14 @@ typedef unsigned char validate_uint32[sizeof(uint32)==4];
//
// this is not threadsafe
static char *failure_reason;
static const char *failure_reason;
char *stbi_failure_reason(void)
const char *stbi_failure_reason(void)
{
return failure_reason;
}
static int e(char *str)
static int e(const char *str)
{
failure_reason = str;
return 0;
@@ -485,6 +491,7 @@ unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int re
return result;
}
#ifdef _MSC_VER
unsigned char *stbi_load_w(wchar_t const *filename, int *x, int *y, int *comp, int req_comp)
{
FILE *f = _wfopen(filename, L"rb");
@@ -494,6 +501,7 @@ unsigned char *stbi_load_w(wchar_t const *filename, int *x, int *y, int *comp, i
fclose(f);
return result;
}
#endif
unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
@@ -748,7 +756,7 @@ static void getn(stbi *s, stbi_uc *buffer, int n)
{
#ifndef STBI_NO_STDIO
if (s->img_file) {
fread(buffer, 1, n, s->img_file);
size_t nr = fread(buffer, 1, n, s->img_file); nr;
return;
}
#endif
@@ -1615,11 +1623,13 @@ typedef uint8 *(*resample_row_func)(uint8 *out, uint8 *in0, uint8 *in1,
static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
{
out, in_far, w, hs;
return in_near;
}
static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
{
hs;
// need to generate two samples vertically for every one in input
int i;
for (i=0; i < w; ++i)
@@ -1629,6 +1639,7 @@ static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w,
static uint8* resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
{
hs, in_far;
// need to generate two samples horizontally for every one in input
int i;
uint8 *input = in_near;
@@ -1654,6 +1665,7 @@ static uint8* resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w
static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
{
hs;
// need to generate 2x2 samples for every one in input
int i,t0,t1;
if (w == 1) {
@@ -1675,6 +1687,7 @@ static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w
static uint8 *resample_row_generic(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
{
in_far;
// resample with nearest-neighbor
int i,j;
for (i=0; i < w; ++i)
@@ -2395,11 +2408,15 @@ static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, u
a->out = (uint8 *) stb_malloc(x * y * out_n);
if (!a->out) return e("outofmem", "Out of memory");
if (!stbi_png_partial) {
if (s->img_x == x && s->img_y == y)
if ((s->img_x == x) && (s->img_y == y))
{
if (raw_len != (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
}
else // interlaced:
{
if (raw_len < (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
}
}
for (j=0; j < y; ++j) {
uint8 *cur = a->out + stride*j;
uint8 *prior = cur - stride;
@@ -2528,6 +2545,7 @@ static int compute_transparency(png *z, uint8 tc[3], int out_n)
static int expand_palette(png *a, uint8 *palette, int len, int pal_img_n)
{
len;
uint32 i, pixel_count = a->s.img_x * a->s.img_y;
uint8 *p, *temp_out, *orig = a->out;
@@ -3164,7 +3182,7 @@ static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
unsigned char *tga_palette = NULL;
int i, j;
unsigned char raw_data[4];
unsigned char trans_data[4];
unsigned char trans_data[4] = { 0, 0, 0, 0 };
int RLE_count = 0;
int RLE_repeating = 0;
int read_next_pixel = 1;
@@ -3402,6 +3420,7 @@ int stbi_psd_test_file(FILE *f)
{
stbi s;
int r,n = ftell(f);
memset(&s, 0, sizeof(s));
start_file(&s, f);
r = psd_test(&s);
fseek(f,n,SEEK_SET);
@@ -3608,7 +3627,7 @@ stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int
#ifndef STBI_NO_HDR
static int hdr_test(stbi *s)
{
char *signature = "#?RADIANCE\n";
const char *signature = "#?RADIANCE\n";
int i;
for (i=0; signature[i]; ++i)
if (get8(s) != signature[i])
@@ -3628,6 +3647,7 @@ int stbi_hdr_test_file(FILE *f)
{
stbi s;
int r,n = ftell(f);
memset(&s, 0, sizeof(s));
start_file(&s, f);
r = hdr_test(&s);
fseek(f,n,SEEK_SET);
@@ -3639,7 +3659,8 @@ int stbi_hdr_test_file(FILE *f)
static char *hdr_gettoken(stbi *z, char *buffer)
{
int len=0;
char *s = buffer, c = '\0';
//char *s = buffer;
char c = '\0';
c = get8(z);
@@ -3859,18 +3880,18 @@ static void write_pixels(FILE *f, int rgb_dir, int vdir, int x, int y, int comp,
fwrite(&d[comp-1], 1, 1, f);
switch (comp) {
case 1:
case 2: writef(f, "111", d[0],d[0],d[0]);
case 2: writef(f, (char*)"111", d[0],d[0],d[0]);
break;
case 4:
if (!write_alpha) {
for (k=0; k < 3; ++k)
px[k] = bg[k] + ((d[k] - bg[k]) * d[3])/255;
writef(f, "111", px[1-rgb_dir],px[1],px[1+rgb_dir]);
writef(f, (char*)"111", px[1-rgb_dir],px[1],px[1+rgb_dir]);
break;
}
/* FALLTHROUGH */
case 3:
writef(f, "111", d[1-rgb_dir],d[1],d[1+rgb_dir]);
writef(f, (char*)"111", d[1-rgb_dir],d[1],d[1+rgb_dir]);
break;
}
if (write_alpha > 0)
@@ -3894,6 +3915,7 @@ static int outfile(char const *filename, int rgb_dir, int vdir, int x, int y, in
return f != NULL;
}
#ifdef _MSC_VER
static int outfile_w(wchar_t const *filename, int rgb_dir, int vdir, int x, int y, int comp, const void *data, int alpha, int pad, char *fmt, ...)
{
FILE *f = _wfopen(filename, L"wb");
@@ -3907,38 +3929,43 @@ static int outfile_w(wchar_t const *filename, int rgb_dir, int vdir, int x, int
}
return f != NULL;
}
#endif
int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
int pad = (-x*3) & 3;
return outfile(filename,-1,-1,x,y,comp,data,0,pad,
"11 4 22 4" "4 44 22 444444",
(char*)"11 4 22 4" "4 44 22 444444",
'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header
40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header
}
#ifdef _MSC_VER
int stbi_write_bmp_w(wchar_t const *filename, int x, int y, int comp, const void *data)
{
int pad = (-x*3) & 3;
return outfile_w(filename,-1,-1,x,y,comp,data,0,pad,
"11 4 22 4" "4 44 22 444444",
(char*)"11 4 22 4" "4 44 22 444444",
'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header
40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header
}
#endif
int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
int has_alpha = !(comp & 1);
return outfile(filename, -1,-1, x, y, comp, data, has_alpha, 0,
"111 221 2222 11", 0,0,2, 0,0,0, 0,0,x,y, 24+8*has_alpha, 8*has_alpha);
(char*)"111 221 2222 11", 0,0,2, 0,0,0, 0,0,x,y, 24+8*has_alpha, 8*has_alpha);
}
#ifdef _MSC_VER
int stbi_write_tga_w(wchar_t const *filename, int x, int y, int comp, const void *data)
{
int has_alpha = !(comp & 1);
return outfile_w(filename, -1,-1, x, y, comp, data, has_alpha, 0,
"111 221 2222 11", 0,0,2, 0,0,0, 0,0,x,y, 24+8*has_alpha, 8*has_alpha);
(char*)"111 221 2222 11", 0,0,2, 0,0,0, 0,0,x,y, 24+8*has_alpha, 8*has_alpha);
}
#endif
// any other image formats that do interleaved rgb data?
// PNG: requires adler32,crc32 -- significant amount of code
crnlib/crn_strutils.cpp
+64 -711
View File
@@ -2,10 +2,27 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "crn_strutils.h"
#include <direct.h>
namespace crnlib
{
char* crn_strdup(const char* pStr)
{
if (!pStr)
pStr = "";
size_t l = strlen(pStr) + 1;
char *p = (char *)crnlib_malloc(l);
if (p)
memcpy(p, pStr, l);
return p;
}
int crn_stricmp(const char *p, const char *q)
{
return _stricmp(p, q);
}
char* strcpy_safe(char* pDst, uint dst_len, const char* pSrc)
{
CRNLIB_ASSERT(pDst && pSrc && dst_len);
@@ -164,76 +181,6 @@ namespace crnlib
return true;
}
bool string_to_int(const wchar_t*& pBuf, int& value)
{
value = 0;
CRNLIB_ASSERT(pBuf);
const wchar_t* p = pBuf;
while (*p && isspace(*p))
p++;
uint result = 0;
bool negative = false;
if (!iswdigit(*p))
{
if (p[0] == '-')
{
negative = true;
p++;
}
else
return false;
}
while (*p && iswdigit(*p))
{
if (result & 0xE0000000U)
return false;
const uint result8 = result << 3U;
const uint result2 = result << 1U;
if (result2 > (0xFFFFFFFFU - result8))
return false;
result = result8 + result2;
uint c = p[0] - L'0';
if (c > (0xFFFFFFFFU - result))
return false;
result += c;
p++;
}
if (negative)
{
if (result > 0x80000000U)
{
value = 0;
return false;
}
value = -static_cast<int>(result);
}
else
{
if (result > 0x7FFFFFFFU)
{
value = 0;
return false;
}
value = static_cast<int>(result);
}
pBuf = p;
return true;
}
bool string_to_int64(const char*& pBuf, int64& value)
{
value = 0;
@@ -348,50 +295,6 @@ namespace crnlib
return true;
}
bool string_to_uint(const wchar_t*& pBuf, uint& value)
{
value = 0;
CRNLIB_ASSERT(pBuf);
const wchar_t* p = pBuf;
while (*p && iswspace(*p))
p++;
uint result = 0;
if (!iswdigit(*p))
return false;
while (*p && iswdigit(*p))
{
if (result & 0xE0000000U)
return false;
const uint result8 = result << 3U;
const uint result2 = result << 1U;
if (result2 > (0xFFFFFFFFU - result8))
return false;
result = result8 + result2;
uint c = p[0] - L'0';
if (c > (0xFFFFFFFFU - result))
return false;
result += c;
p++;
}
value = result;
pBuf = p;
return true;
}
bool string_to_uint64(const char*& pBuf, uint64& value)
{
value = 0;
@@ -467,77 +370,66 @@ namespace crnlib
return false;
}
bool string_to_bool(const wchar_t* p, bool& value)
{
CRNLIB_ASSERT(p);
value = false;
if (_wcsicmp(p, L"false") == 0)
return true;
if (_wcsicmp(p, L"true") == 0)
{
value = true;
return true;
}
const wchar_t* q = p;
uint v;
if (string_to_uint(q, v))
{
if (!v)
return true;
else if (v == 1)
{
value = true;
return true;
}
}
return false;
}
bool string_to_float(const char*& p, float& value, uint round_digit)
{
double d;
if (!string_to_double(p, d, round_digit))
{
value = 0;
return false;
}
value = static_cast<float>(d);
return true;
}
bool string_to_double(const char*& p, double& value, uint round_digit)
{
return string_to_double(p, p + 128, value, round_digit);
}
// I wrote this approx. 20 years ago in C/assembly using a limited FP emulator package, so it's a bit crude.
bool string_to_double(const char*& p, const char *pEnd, double& value, uint round_digit)
{
CRNLIB_ASSERT(p);
value = 0;
enum { AF_BLANK = 1, AF_SIGN = 2, AF_DPOINT = 3, AF_BADCHAR = 4, AF_OVRFLOW = 5, AF_EXPONENT = 6, AF_NODIGITS = 7 };
int status = 0;
const char* buf = p;
int status = 0;
int got_sign_flag = 0, got_dp_flag = 0, got_num_flag = 0;
int got_e_flag = 0, got_e_sign_flag = 0, e_sign = 0;
uint whole_count = 0, frac_count = 0;
if (round_digit > 10)
round_digit = 10;
double whole = 0, frac = 0, scale = 1, exponent = 1;
int got_sign_flag = 0;
int got_dp_flag = 0;
int got_num_flag = 0;
int got_e_flag = 0;
int got_e_sign_flag = 0;
int e_sign = 0;
uint whole_count = 0;
uint frac_count = 0;
float whole = 0;
float frac = 0;
float scale = 1;
float exponent = 1;
if (p >= pEnd)
{
status = AF_NODIGITS;
goto af_exit;
}
while (*buf)
{
if (!isspace(*buf))
break;
buf++;
if (++buf >= pEnd)
{
status = AF_NODIGITS;
goto af_exit;
}
}
p = buf;
while (*buf)
{
p = buf;
if (buf >= pEnd)
break;
int i = *buf++;
switch (i)
@@ -616,7 +508,7 @@ namespace crnlib
whole_count++;
if (whole > 1e+30f)
if (whole > 1e+100)
{
status = AF_OVRFLOW;
goto af_exit;
@@ -646,6 +538,10 @@ namespace crnlib
while (*buf)
{
p = buf;
if (buf >= pEnd)
break;
int i = *buf++;
if (i == '+')
@@ -674,7 +570,7 @@ namespace crnlib
{
got_num_flag = 1;
if ((e = (e * 10) + (i - 48)) > 16)
if ((e = (e * 10) + (i - 48)) > 100)
{
status = AF_EXPONENT;
goto af_exit;
@@ -709,552 +605,9 @@ namespace crnlib
whole = -whole;
value = whole;
p = buf;
af_exit:
return (status == 0);
}
bool string_to_float(const wchar_t*& p, float& value, uint round_digit)
{
CRNLIB_ASSERT(p);
value = 0;
enum { AF_BLANK = 1, AF_SIGN = 2, AF_DPOINT = 3, AF_BADCHAR = 4, AF_OVRFLOW = 5, AF_EXPONENT = 6, AF_NODIGITS = 7 };
const wchar_t* buf = p;
int status = 0;
if (round_digit > 10)
round_digit = 10;
int got_sign_flag = 0;
int got_dp_flag = 0;
int got_num_flag = 0;
int got_e_flag = 0;
int got_e_sign_flag = 0;
int e_sign = 0;
uint whole_count = 0;
uint frac_count = 0;
float whole = 0;
float frac = 0;
float scale = 1;
float exponent = 1;
while (*buf)
{
if (!iswspace(*buf))
break;
buf++;
}
while (*buf)
{
int i = *buf++;
switch (i)
{
case L'e':
case L'E':
{
got_e_flag = 1;
goto exit_while;
}
case L'+':
{
if ((got_num_flag) || (got_sign_flag))
{
status = AF_SIGN;
goto af_exit;
}
got_sign_flag = 1;
break;
}
case L'-':
{
if ((got_num_flag) || (got_sign_flag))
{
status = AF_SIGN;
goto af_exit;
}
got_sign_flag = -1;
break;
}
case L'.':
{
if (got_dp_flag)
{
status = AF_DPOINT;
goto af_exit;
}
got_dp_flag = 1;
break;
}
default:
{
if ((i < L'0') || (i > L'9'))
goto exit_while;
else
{
i -= L'0';
got_num_flag = 1;
if (got_dp_flag)
{
if (frac_count < round_digit)
{
frac = frac * 10.0f + i;
scale = scale * 10.0f;
}
else if (frac_count == round_digit)
{
if (i >= 5) /* check for round */
frac = frac + 1.0f;
}
frac_count++;
}
else
{
whole = whole * 10.0f + i;
whole_count++;
if (whole > 1e+30f)
{
status = AF_OVRFLOW;
goto af_exit;
}
}
}
break;
}
}
}
exit_while:
if (got_e_flag)
{
if ((got_num_flag == 0) && (got_dp_flag))
{
status = AF_EXPONENT;
goto af_exit;
}
int e = 0;
e_sign = 1;
got_num_flag = 0;
got_e_sign_flag = 0;
while (*buf)
{
int i = *buf++;
if (i == L'+')
{
if ((got_num_flag) || (got_e_sign_flag))
{
status = AF_EXPONENT;
goto af_exit;
}
e_sign = 1;
got_e_sign_flag = 1;
}
else if (i == L'-')
{
if ((got_num_flag) || (got_e_sign_flag))
{
status = AF_EXPONENT;
goto af_exit;
}
e_sign = -1;
got_e_sign_flag = 1;
}
else if ((i >= L'0') && (i <= L'9'))
{
got_num_flag = 1;
if ((e = (e * 10) + (i - 48)) > 16)
{
status = AF_EXPONENT;
goto af_exit;
}
}
else
break;
}
for (int i = 1; i <= e; i++) /* compute 10^e */
exponent = exponent * 10.0f;
}
if (((whole_count + frac_count) == 0) && (got_e_flag == 0))
{
status = AF_NODIGITS;
goto af_exit;
}
if (frac)
whole = whole + (frac / scale);
if (got_e_flag)
{
if (e_sign > 0)
whole = whole * exponent;
else
whole = whole / exponent;
}
if (got_sign_flag < 0)
whole = -whole;
value = whole;
p = buf;
af_exit:
return (status == 0);
}
bool split_path(const char* p, dynamic_string* pDrive, dynamic_string* pDir, dynamic_string* pFilename, dynamic_string* pExt)
{
CRNLIB_ASSERT(p);
char drive_buf[_MAX_DRIVE];
char dir_buf[_MAX_DIR];
char fname_buf[_MAX_FNAME];
char ext_buf[_MAX_EXT];
#ifdef _MSC_VER
errno_t error = _splitpath_s(p,
pDrive ? drive_buf : NULL, pDrive ? _MAX_DRIVE : 0,
pDir ? dir_buf : NULL, pDir ? _MAX_DIR : 0,
pFilename ? fname_buf : NULL, pFilename ? _MAX_FNAME : 0,
pExt ? ext_buf : NULL, pExt ? _MAX_EXT : 0);
if (error != 0)
return false;
#else
_splitpath(p,
pDrive ? drive_buf : NULL,
pDir ? dir_buf : NULL,
pFilename ? fname_buf : NULL,
pExt ? ext_buf : NULL);
#endif
if (pDrive) *pDrive = drive_buf;
if (pDir) *pDir = dir_buf;
if (pFilename) *pFilename = fname_buf;
if (pExt) *pExt = ext_buf;
return true;
}
bool split_path(const wchar_t* p, dynamic_wstring* pDrive, dynamic_wstring* pDir, dynamic_wstring* pFilename, dynamic_wstring* pExt)
{
CRNLIB_ASSERT(p);
wchar_t drive_buf[_MAX_DRIVE];
wchar_t dir_buf[_MAX_DIR];
wchar_t fname_buf[_MAX_FNAME];
wchar_t ext_buf[_MAX_EXT];
#ifdef _MSC_VER
errno_t error = _wsplitpath_s(p,
pDrive ? drive_buf : NULL, pDrive ? _MAX_DRIVE : 0,
pDir ? dir_buf : NULL, pDir ? _MAX_DIR : 0,
pFilename ? fname_buf : NULL, pFilename ? _MAX_FNAME : 0,
pExt ? ext_buf : NULL, pExt ? _MAX_EXT : 0);
if (error != 0)
return false;
#else
_wsplitpath(p,
pDrive ? drive_buf : NULL,
pDir ? dir_buf : NULL,
pFilename ? fname_buf : NULL,
pExt ? ext_buf : NULL);
#endif
if (pDrive) *pDrive = drive_buf;
if (pDir) *pDir = dir_buf;
if (pFilename) *pFilename = fname_buf;
if (pExt) *pExt = ext_buf;
return true;
}
bool split_path(const char* p, dynamic_string& path, dynamic_string& filename)
{
dynamic_string temp_drive, temp_path, temp_ext;
if (!split_path(p, &temp_drive, &temp_path, &filename, &temp_ext))
return false;
filename += temp_ext;
combine_path(path, temp_drive.get_ptr(), temp_path.get_ptr());
return true;
}
bool split_path(const wchar_t* p, dynamic_wstring& path, dynamic_wstring& filename)
{
dynamic_wstring temp_drive, temp_path, temp_ext;
if (!split_path(p, &temp_drive, &temp_path, &filename, &temp_ext))
return false;
filename += temp_ext;
combine_path(path, temp_drive.get_ptr(), temp_path.get_ptr());
return true;
}
bool get_pathname(const char* p, dynamic_string& path)
{
dynamic_string temp_drive, temp_path;
if (!split_path(p, &temp_drive, &temp_path, NULL, NULL))
return false;
combine_path(path, temp_drive.get_ptr(), temp_path.get_ptr());
return true;
}
bool get_pathname(const wchar_t* p, dynamic_wstring& path)
{
dynamic_wstring temp_drive, temp_path;
if (!split_path(p, &temp_drive, &temp_path, NULL, NULL))
return false;
combine_path(path, temp_drive.get_ptr(), temp_path.get_ptr());
return true;
}
bool get_filename(const char* p, dynamic_string& filename)
{
dynamic_string temp_ext;
if (!split_path(p, NULL, NULL, &filename, &temp_ext))
return false;
filename += temp_ext;
return true;
}
bool get_filename(const wchar_t* p, dynamic_wstring& filename)
{
dynamic_wstring temp_ext;
if (!split_path(p, NULL, NULL, &filename, &temp_ext))
return false;
filename += temp_ext;
return true;
}
void combine_path(dynamic_string& dst, const char* pA, const char* pB)
{
dynamic_string temp;
temp = pA;
if ((!temp.is_empty()) && (pB[0] != '\\') && (pB[0] != '/'))
{
char c = temp[temp.get_len() - 1];
if ((c != '\\') && (c != '/'))
{
temp.append_char('\\');
}
}
temp += pB;
dst.swap(temp);
}
void combine_path(dynamic_wstring& dst, const wchar_t* pA, const wchar_t* pB)
{
dynamic_wstring temp;
temp = pA;
if ((!temp.is_empty()) && (pB[0] != L'\\') && (pB[0] != L'/'))
{
wchar_t c = temp[temp.get_len() - 1];
if ((c != L'\\') && (c != L'/'))
{
temp.append_char(L'\\');
}
}
temp += pB;
dst.swap(temp);
}
void combine_path(dynamic_string& dst, const char* pA, const char* pB, const char* pC)
{
combine_path(dst, pA, pB);
combine_path(dst, dst.get_ptr(), pC);
}
void combine_path(dynamic_wstring& dst, const wchar_t* pA, const wchar_t* pB, const wchar_t* pC)
{
combine_path(dst, pA, pB);
combine_path(dst, dst.get_ptr(), pC);
}
void combine_path(dynamic_wstring& dst, const wchar_t* pA, const wchar_t* pB, const wchar_t* pC, const wchar_t *pD)
{
combine_path(dst, pA, pB);
combine_path(dst, dst.get_ptr(), pC);
combine_path(dst, dst.get_ptr(), pD);
}
bool full_path(dynamic_string& path)
{
#ifndef _XBOX
char buf[CRNLIB_MAX_PATH];
char* p = _fullpath(buf, path.get_ptr(), CRNLIB_MAX_PATH);
if (!p)
return false;
path.set(buf);
#endif
return true;
}
bool full_path(dynamic_wstring& path)
{
#ifndef _XBOX
wchar_t buf[CRNLIB_MAX_PATH];
wchar_t* p = _wfullpath(buf, path.get_ptr(), CRNLIB_MAX_PATH);
if (!p)
return false;
path.set(buf);
#endif
return true;
}
bool get_extension(dynamic_string& filename)
{
int sep = filename.find_right('\\');
if (sep < 0)
sep = filename.find_right('/');
int dot = filename.find_right('.');
if (dot < sep)
{
filename.clear();
return false;
}
filename.right(dot + 1);
return true;
}
bool get_extension(dynamic_wstring& filename)
{
int sep = filename.find_right(L'\\');
if (sep < 0)
sep = filename.find_right(L'/');
int dot = filename.find_right(L'.');
if (dot < sep)
{
filename.clear();
return false;
}
filename.right(dot + 1);
return true;
}
bool remove_extension(dynamic_string& filename)
{
int sep = filename.find_right('\\');
if (sep < 0)
sep = filename.find_right('/');
int dot = filename.find_right('.');
if (dot < sep)
return false;
filename.left(dot);
return true;
}
bool remove_extension(dynamic_wstring& filename)
{
int sep = filename.find_right(L'\\');
if (sep < 0)
sep = filename.find_right(L'/');
int dot = filename.find_right(L'.');
if (dot < sep)
return false;
filename.left(dot);
return true;
}
bool create_path(const dynamic_wstring& path)
{
bool unc = false;
dynamic_wstring cur_path;
const int l = path.get_len();
int n = 0;
while (n < l)
{
const wchar_t c = path.get_ptr()[n];
const bool sep = (c == L'/') || (c == L'\\');
if ((sep) || (n == (l - 1)))
{
if ((n == (l - 1)) && (!sep))
cur_path.append_char(c);
bool valid = false;
if ((cur_path.get_len() > 3) && (cur_path.get_ptr()[1] == L':'))
valid = true;
else if (cur_path.get_len() > 2)
{
if (unc)
valid = true;
unc = true;
}
if (valid)
_wmkdir(cur_path.get_ptr());
}
cur_path.append_char(c);
n++;
}
return true;
}
void trim_trailing_seperator(dynamic_wstring& path)
{
if ( (path.get_len()) && ( (path[path.get_len() - 1] == L'\\') || (path[path.get_len() - 1] == L'/') ) )
path.truncate(path.get_len() - 1);
}
} // namespace crnlib
crnlib/crn_strutils.h
+12 -36
View File
@@ -2,58 +2,34 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#pragma once
#ifdef WIN32
#define CRNLIB_PATH_SEPERATOR_CHAR '\\'
#else
#define CRNLIB_PATH_SEPERATOR_CHAR '/'
#endif
namespace crnlib
{
char* crn_strdup(const char* pStr);
int crn_stricmp(const char *p, const char *q);
char* strcpy_safe(char* pDst, uint dst_len, const char* pSrc);
bool int_to_string(int value, char* pDst, uint len);
bool uint_to_string(uint value, char* pDst, uint len);
bool string_to_int(const char*& pBuf, int& value);
bool string_to_int(const wchar_t*& pBuf, int& value);
bool string_to_uint(const char*& pBuf, uint& value);
bool string_to_uint(const wchar_t*& pBuf, uint& value);
bool string_to_int64(const char*& pBuf, int64& value);
bool string_to_uint64(const char*& pBuf, uint64& value);
bool string_to_bool(const char* p, bool& value);
bool string_to_bool(const wchar_t* p, bool& value);
bool string_to_float(const char*& p, float& value, uint round_digit = 10U);
bool string_to_float(const wchar_t*& p, float& value, uint round_digit = 10U);
bool string_to_float(const char*& p, float& value, uint round_digit = 512U);
bool split_path(const char* p, dynamic_string* pDrive, dynamic_string* pDir, dynamic_string* pFilename, dynamic_string* pExt);
bool split_path(const wchar_t* p, dynamic_wstring* pDrive, dynamic_wstring* pDir, dynamic_wstring* pFilename, dynamic_wstring* pExt);
bool split_path(const char* p, dynamic_string& path, dynamic_string& filename);
bool split_path(const wchar_t* p, dynamic_wstring& path, dynamic_wstring& filename);
bool get_pathname(const char* p, dynamic_string& path);
bool get_pathname(const wchar_t* p, dynamic_wstring& path);
bool get_filename(const char* p, dynamic_string& filename);
bool get_filename(const wchar_t* p, dynamic_wstring& filename);
void combine_path(dynamic_string& dst, const char* pA, const char* pB);
void combine_path(dynamic_wstring& dst, const wchar_t* pA, const wchar_t* pB);
void combine_path(dynamic_string& dst, const char* pA, const char* pB, const char* pC);
void combine_path(dynamic_wstring& dst, const wchar_t* pA, const wchar_t* pB, const wchar_t* pC);
void combine_path(dynamic_wstring& dst, const wchar_t* pA, const wchar_t* pB, const wchar_t* pC, const wchar_t *pD);
bool full_path(dynamic_string& path);
bool full_path(dynamic_wstring& path);
bool get_extension(dynamic_string& filename);
bool get_extension(dynamic_wstring& filename);
bool remove_extension(dynamic_string& filename);
bool remove_extension(dynamic_wstring& filename);
bool create_path(const dynamic_wstring& path);
void trim_trailing_seperator(dynamic_wstring& path);
bool string_to_double(const char*& p, double& value, uint round_digit = 512U);
bool string_to_double(const char*& p, const char *pEnd, double& value, uint round_digit = 512U);
} // namespace crnlib
crnlib/crn_symbol_codec.cpp
+8 -8
View File
@@ -361,7 +361,7 @@ namespace crnlib
if (!max_freq)
return false;
if (max_freq <= UINT16_MAX)
if (max_freq <= cUINT16_MAX)
{
for (uint i = 0; i < total_syms; i++)
sym_freq16[i] = static_cast<uint16>(pSym_freq[i]);
@@ -381,7 +381,7 @@ namespace crnlib
if (fl < 1)
fl = 1;
CRNLIB_ASSERT(fl <= UINT16_MAX);
CRNLIB_ASSERT(fl <= cUINT16_MAX);
sym_freq16[i] = static_cast<uint16>(fl);
}
@@ -917,7 +917,7 @@ namespace crnlib
freq++;
model.m_sym_freq[sym] = static_cast<uint16>(freq);
if (freq == UINT16_MAX)
if (freq == cUINT16_MAX)
model.rescale();
if (--model.m_symbols_until_update == 0)
@@ -1426,8 +1426,8 @@ namespace crnlib
{
uint32 t = pTables->m_lookup[m_bit_buf >> (cBitBufSize - pTables->m_table_bits)];
CRNLIB_ASSERT(t != UINT32_MAX);
sym = t & UINT16_MAX;
CRNLIB_ASSERT(t != cUINT32_MAX);
sym = t & cUINT16_MAX;
len = t >> 16;
CRNLIB_ASSERT(model.m_code_sizes[sym] == len);
@@ -1462,7 +1462,7 @@ namespace crnlib
freq++;
model.m_sym_freq[sym] = static_cast<uint16>(freq);
if (freq == UINT16_MAX)
if (freq == cUINT16_MAX)
model.rescale();
if (--model.m_symbols_until_update == 0)
@@ -1614,8 +1614,8 @@ namespace crnlib
{
uint32 t = pTables->m_lookup[m_bit_buf >> (cBitBufSize - pTables->m_table_bits)];
CRNLIB_ASSERT(t != UINT32_MAX);
sym = t & UINT16_MAX;
CRNLIB_ASSERT(t != cUINT32_MAX);
sym = t & cUINT16_MAX;
len = t >> 16;
CRNLIB_ASSERT(model.m_code_sizes[sym] == len);
crnlib/crn_texture_comp.cpp
+30 -18
View File
@@ -26,7 +26,7 @@ namespace crnlib
{
if (local_params.get_flag(cCRNCompFlagPerceptual))
{
//console::warning(L"Output pixel format is swizzled or not RGB, disabling perceptual color metrics");
console::info("Output pixel format is swizzled or not RGB, disabling perceptual color metrics");
// Destination compressed pixel format is swizzled or not RGB at all, so be sure perceptual colorspace metrics are disabled.
local_params.set_flag(cCRNCompFlagPerceptual, false);
@@ -53,6 +53,18 @@ namespace crnlib
((local_params.m_file_type == cCRNFileTypeCRN) && ((local_params.m_flags & cCRNCompFlagManualPaletteSizes) != 0))
)
{
if ( (local_params.m_file_type == cCRNFileTypeCRN) ||
((local_params.m_file_type == cCRNFileTypeDDS) && (local_params.m_quality_level < cCRNMaxQualityLevel)) )
{
console::info("Compressing using quality level %i", local_params.m_quality_level);
}
if (local_params.m_format == cCRNFmtDXT3)
{
if (local_params.m_file_type == cCRNFileTypeCRN)
console::warning("CRN format doesn't support DXT3");
else if ((local_params.m_file_type == cCRNFileTypeDDS) && (local_params.m_quality_level < cCRNMaxQualityLevel))
console::warning("Clustered DDS compressor doesn't support DXT3");
}
if (!pTexture_comp->compress_pass(local_params, pActual_bitrate))
{
crnlib_delete(pTexture_comp);
@@ -95,7 +107,7 @@ namespace crnlib
{
if (params.m_flags & cCRNCompFlagDebugging)
{
console::debug(L"Quality level bracket: [%u, %u]", low_quality, high_quality);
console::debug("Quality level bracket: [%u, %u]", low_quality, high_quality);
}
int trial_quality = (low_quality + high_quality) / 2;
@@ -137,7 +149,7 @@ namespace crnlib
}
}
console::info(L"Compressing to quality level %u", trial_quality);
console::info("Compressing to quality level %u", trial_quality);
float bitrate = 0.0f;
@@ -153,7 +165,7 @@ namespace crnlib
highest_bitrate = math::maximum(highest_bitrate, bitrate);
console::info(L"\nTried quality level %u, bpp: %3.3f", trial_quality, bitrate);
console::info("\nTried quality level %u, bpp: %3.3f", trial_quality, bitrate);
if ( (best_quality_level < 0) ||
((bitrate <= local_params.m_target_bitrate) && (best_bitrate > local_params.m_target_bitrate)) ||
@@ -165,7 +177,7 @@ namespace crnlib
best_quality_level = trial_quality;
if (params.m_flags & cCRNCompFlagDebugging)
{
console::debug(L"Choose new best quality level");
console::debug("Choose new best quality level");
}
if ((best_bitrate <= local_params.m_target_bitrate) && (fabs(best_bitrate - local_params.m_target_bitrate) < .005f))
@@ -188,7 +200,7 @@ namespace crnlib
(highest_bitrate < local_params.m_target_bitrate) &&
(fabs(best_bitrate - local_params.m_target_bitrate) >= .005f))
{
console::info(L"Unable to achieve desired bitrate - disabling adaptive block sizes and retrying search.");
console::info("Unable to achieve desired bitrate - disabling adaptive block sizes and retrying search.");
local_params.m_flags &= ~cCRNCompFlagHierarchical;
@@ -214,7 +226,7 @@ namespace crnlib
if (pActual_quality_level) *pActual_quality_level = best_quality_level;
if (pActual_bitrate) *pActual_bitrate = best_bitrate;
console::printf(L"Selected quality level %u bpp: %f", best_quality_level, best_bitrate);
console::printf("Selected quality level %u bpp: %f", best_quality_level, best_bitrate);
return true;
}
@@ -310,14 +322,14 @@ namespace crnlib
{
if (work_tex.get_num_faces() > 1)
{
console::warning(L"Can't crop cubemap textures");
console::warning("Can't crop cubemap textures");
}
else
{
console::info(L"Cropping input texture from window (%ux%u)-(%ux%u)", window_rect.get_left(), window_rect.get_top(), window_rect.get_right(), window_rect.get_bottom());
console::info("Cropping input texture from window (%ux%u)-(%ux%u)", window_rect.get_left(), window_rect.get_top(), window_rect.get_right(), window_rect.get_bottom());
if (!work_tex.crop(window_rect.get_left(), window_rect.get_top(), window_rect.get_width(), window_rect.get_height()))
console::warning(L"Failed cropping window rect");
console::warning("Failed cropping window rect");
}
}
@@ -332,13 +344,13 @@ namespace crnlib
{
if (work_tex.get_num_faces() > 1)
{
console::warning(L"Can't crop cubemap textures");
console::warning("Can't crop cubemap textures");
}
else
{
new_width = math::minimum<uint>(mipmap_params.m_clamp_width, new_width);
new_height = math::minimum<uint>(mipmap_params.m_clamp_height, new_height);
console::info(L"Clamping input texture to %ux%u", new_width, new_height);
console::info("Clamping input texture to %ux%u", new_width, new_height);
work_tex.crop(0, 0, new_width, new_height);
}
}
@@ -420,7 +432,7 @@ namespace crnlib
if ((new_width != (int)work_tex.get_width()) || (new_height != (int)work_tex.get_height()))
{
console::info(L"Resampling input texture to %ux%u", new_width, new_height);
console::info("Resampling input texture to %ux%u", new_width, new_height);
const char* pFilter = crn_get_mip_filter_name(mipmap_params.m_filter);
@@ -439,7 +451,7 @@ namespace crnlib
if (!work_tex.resize(new_width, new_height, res_params))
{
console::error(L"Failed resizing texture!");
console::error("Failed resizing texture!");
return false;
}
}
@@ -461,18 +473,18 @@ namespace crnlib
gen_params.m_max_mips = mipmap_params.m_max_levels;
gen_params.m_min_mip_size = mipmap_params.m_min_mip_size;
console::info(L"Generating mipmaps using filter \"%S\"", pFilter);
console::info("Generating mipmaps using filter \"%s\"", pFilter);
timer tm;
tm.start();
if (!work_tex.generate_mipmaps(gen_params, true))
{
console::error(L"Failed generating mipmaps!");
console::error("Failed generating mipmaps!");
return false;
}
double t = tm.get_elapsed_secs();
console::info(L"Generated %u mipmap levels in %3.3fs", work_tex.get_num_levels() - 1, t);
console::info("Generated %u mipmap levels in %3.3fs", work_tex.get_num_levels() - 1, t);
}
return true;
@@ -487,7 +499,7 @@ namespace crnlib
dds_texture work_tex;
if (!create_dds_tex(params, work_tex))
{
console::error(L"Failed creating DDS texture from crn_comp_params!");
console::error("Failed creating DDS texture from crn_comp_params!");
return false;
}
crnlib/crn_texture_comp.h
+1 -1
View File
@@ -16,7 +16,7 @@ namespace crnlib
itexture_comp() { }
virtual ~itexture_comp() { }
virtual const wchar_t *get_ext() const = 0;
virtual const char *get_ext() const = 0;
virtual bool compress_init(const crn_comp_params& params) = 0;
virtual bool compress_pass(const crn_comp_params& params, float *pEffective_bitrate) = 0;
crnlib/crn_texture_conversion.cpp
+99 -91
View File
@@ -3,7 +3,7 @@
#include "crn_core.h"
#include "crn_texture_conversion.h"
#include "crn_console.h"
#include "crn_win32_file_utils.h"
#include "crn_file_utils.h"
#include "crn_cfile_stream.h"
#include "crn_image_utils.h"
#include "crn_texture_comp.h"
@@ -26,8 +26,8 @@ namespace crnlib
}
bool convert_stats::init(
const wchar_t* pSrc_filename,
const wchar_t* pDst_filename,
const char* pSrc_filename,
const char* pDst_filename,
dds_texture& src_tex,
texture_file_types::format dst_file_type,
bool lzma_stats)
@@ -38,8 +38,8 @@ namespace crnlib
m_pInput_tex = &src_tex;
win32_file_utils::get_file_size(pSrc_filename, m_input_file_size);
win32_file_utils::get_file_size(pDst_filename, m_output_file_size);
file_utils::get_file_size(pSrc_filename, m_input_file_size);
file_utils::get_file_size(pDst_filename, m_output_file_size);
m_total_input_pixels = 0;
for (uint i = 0; i < src_tex.get_num_levels(); i++)
@@ -58,12 +58,12 @@ namespace crnlib
vector<uint8> dst_tex_bytes;
if (!cfile_stream::read_file_into_array(pDst_filename, dst_tex_bytes))
{
console::error(L"Failed loading output file: %s", pDst_filename);
console::error("Failed loading output file: %s", pDst_filename);
return false;
}
if (!dst_tex_bytes.size())
{
console::error(L"Output file is empty: %s", pDst_filename);
console::error("Output file is empty: %s", pDst_filename);
return false;
}
vector<uint8> cmp_tex_bytes;
@@ -76,7 +76,7 @@ namespace crnlib
if (!m_output_tex.load_from_file(pDst_filename, m_dst_file_type))
{
console::error(L"Failed loading output file: %s", pDst_filename);
console::error("Failed loading output file: %s", pDst_filename);
return false;
}
@@ -91,12 +91,12 @@ namespace crnlib
return true;
}
bool convert_stats::print(bool psnr_metrics, bool mip_stats, bool grayscale_sampling, const wchar_t *pCSVStatsFile) const
bool convert_stats::print(bool psnr_metrics, bool mip_stats, bool grayscale_sampling, const char *pCSVStatsFile) const
{
if (!m_pInput_tex)
return false;
console::info(L"Input texture: %ux%u, Levels: %u, Faces: %u, Format: %s",
console::info("Input texture: %ux%u, Levels: %u, Faces: %u, Format: %s",
m_pInput_tex->get_width(),
m_pInput_tex->get_height(),
m_pInput_tex->get_num_levels(),
@@ -104,29 +104,29 @@ namespace crnlib
pixel_format_helpers::get_pixel_format_string(m_pInput_tex->get_format()));
// Just casting the uint64's filesizes to uint32 here to work around gcc issues - it's not even possible to have files that large anyway.
console::info(L"Input pixels: %u, Input file size: %u, Input bits/pixel: %1.3f",
console::info("Input pixels: %u, Input file size: %u, Input bits/pixel: %1.3f",
m_total_input_pixels, (uint32)m_input_file_size, (m_input_file_size * 8.0f) / m_total_input_pixels);
console::info(L"Output texture: %ux%u, Levels: %u, Faces: %u, Format: %s",
console::info("Output texture: %ux%u, Levels: %u, Faces: %u, Format: %s",
m_output_tex.get_width(),
m_output_tex.get_height(),
m_output_tex.get_num_levels(),
m_output_tex.get_num_faces(),
pixel_format_helpers::get_pixel_format_string(m_output_tex.get_format()));
console::info(L"Output pixels: %u, Output file size: %u, Output bits/pixel: %1.3f",
console::info("Output pixels: %u, Output file size: %u, Output bits/pixel: %1.3f",
m_total_output_pixels, (uint32)m_output_file_size, (m_output_file_size * 8.0f) / m_total_output_pixels);
if (m_output_comp_file_size)
{
console::info(L"LZMA compressed output file size: %u bytes, %1.3f bits/pixel",
console::info("LZMA compressed output file size: %u bytes, %1.3f bits/pixel",
(uint32)m_output_comp_file_size, (m_output_comp_file_size * 8.0f) / m_total_output_pixels);
}
if (psnr_metrics)
{
if ( (m_pInput_tex->get_width() != m_output_tex.get_width()) || (m_pInput_tex->get_height() != m_output_tex.get_height()) || (m_pInput_tex->get_num_faces() != m_output_tex.get_num_faces()) )
{
console::warning(L"Unable to compute image statistics - input/output texture dimensions are different.");
console::warning("Unable to compute image statistics - input/output texture dimensions are different.");
}
else
{
@@ -155,7 +155,7 @@ namespace crnlib
pB = &grayscale_b;
}
console::info(L"Mipmap level %u statistics:", level);
console::info("Mipmap level %u statistics:", level);
image_utils::print_image_metrics(*pA, *pB);
if ((pA->has_rgb()) || (pB->has_rgb()))
@@ -187,23 +187,22 @@ namespace crnlib
image_utils::error_metrics luma_error;
if (rgb_error.compute(*pA, *pB, 0, 3, false) && luma_error.compute(*pA, *pB, 0, 0, true))
{
FILE *pFile = NULL;
#ifdef _MSC_VER
_wfopen_s(&pFile, pCSVStatsFile, L"a");
#else
pFile = _wfopen(pCSVStatsFile, L"a");
#endif
bool bCSVStatsFileExists = file_utils::does_file_exist(pCSVStatsFile);
FILE* pFile;
crn_fopen(&pFile, pCSVStatsFile, "a");
if (!pFile)
console::warning(L"Unable to append to CSV stats file: %s\n", pCSVStatsFile);
console::warning("Unable to append to CSV stats file: %s\n", pCSVStatsFile);
else
{
dynamic_wstring filename;
split_path(m_src_filename.get_ptr(), NULL, NULL, &filename, NULL);
dynamic_string filenamea;
if (!bCSVStatsFileExists)
fprintf(pFile, "name,width,height,miplevels,rgb_rms,luma_rms,effective_output_size,effective_bitrate\n");
dynamic_string filename;
file_utils::split_path(m_src_filename.get_ptr(), NULL, NULL, &filename, NULL);
uint64 effective_output_size = m_output_comp_file_size ? m_output_comp_file_size : m_output_file_size;
float bitrate = (effective_output_size * 8.0f) / m_total_output_pixels;
fprintf(pFile, "%s,%u,%u,%u,%f,%f,%u,%f\n",
filename.as_ansi(filenamea).get_ptr(),
filename.get_ptr(),
pB->get_width(), pB->get_height(), m_output_tex.get_num_levels(),
rgb_error.mRootMeanSquared, luma_error.mRootMeanSquared,
(uint32)effective_output_size, bitrate);
@@ -283,12 +282,12 @@ namespace crnlib
return true;
}
static bool convert_error(const convert_params& params, const wchar_t* pError_msg)
static bool convert_error(const convert_params& params, const char* pError_msg)
{
params.m_status = false;
params.m_error_message = pError_msg;
_wremove(params.m_dst_filename.get_ptr());
remove(params.m_dst_filename.get_ptr());
return false;
}
@@ -369,55 +368,55 @@ namespace crnlib
static void print_comp_params(const crn_comp_params &comp_params)
{
console::debug(L"\nTexture conversion compression parameters:");
console::debug(L" Desired bitrate: %3.3f", comp_params.m_target_bitrate);
console::debug(L" CRN Quality: %i", comp_params.m_quality_level);
console::debug(L"CRN C endpoints/selectors: %u %u", comp_params.m_crn_color_endpoint_palette_size, comp_params.m_crn_color_selector_palette_size);
console::debug(L"CRN A endpoints/selectors: %u %u", comp_params.m_crn_alpha_endpoint_palette_size, comp_params.m_crn_alpha_selector_palette_size);
console::debug(L" DXT both block types: %u, Alpha threshold: %u", comp_params.get_flag(cCRNCompFlagUseBothBlockTypes), comp_params.m_dxt1a_alpha_threshold);
console::debug(L" DXT compression quality: %s", crn_get_dxt_quality_string(comp_params.m_dxt_quality));
console::debug(L" Perceptual: %u, Large Blocks: %u", comp_params.get_flag(cCRNCompFlagPerceptual), comp_params.get_flag(cCRNCompFlagHierarchical));
console::debug(L" Compressor: %s", get_dxt_compressor_name(comp_params.m_dxt_compressor_type));
console::debug(L" Disable endpoint caching: %u", comp_params.get_flag(cCRNCompFlagDisableEndpointCaching));
console::debug(L" Grayscale sampling: %u", comp_params.get_flag(cCRNCompFlagGrayscaleSampling));
console::debug(L" Max helper threads: %u", comp_params.m_num_helper_threads);
console::debug(L"");
console::debug("\nTexture conversion compression parameters:");
console::debug(" Desired bitrate: %3.3f", comp_params.m_target_bitrate);
console::debug(" CRN Quality: %i", comp_params.m_quality_level);
console::debug("CRN C endpoints/selectors: %u %u", comp_params.m_crn_color_endpoint_palette_size, comp_params.m_crn_color_selector_palette_size);
console::debug("CRN A endpoints/selectors: %u %u", comp_params.m_crn_alpha_endpoint_palette_size, comp_params.m_crn_alpha_selector_palette_size);
console::debug(" DXT both block types: %u, Alpha threshold: %u", comp_params.get_flag(cCRNCompFlagUseBothBlockTypes), comp_params.m_dxt1a_alpha_threshold);
console::debug(" DXT compression quality: %s", crn_get_dxt_quality_string(comp_params.m_dxt_quality));
console::debug(" Perceptual: %u, Large Blocks: %u", comp_params.get_flag(cCRNCompFlagPerceptual), comp_params.get_flag(cCRNCompFlagHierarchical));
console::debug(" Compressor: %s", get_dxt_compressor_name(comp_params.m_dxt_compressor_type));
console::debug(" Disable endpoint caching: %u", comp_params.get_flag(cCRNCompFlagDisableEndpointCaching));
console::debug(" Grayscale sampling: %u", comp_params.get_flag(cCRNCompFlagGrayscaleSampling));
console::debug(" Max helper threads: %u", comp_params.m_num_helper_threads);
console::debug("");
}
static void print_mipmap_params(const crn_mipmap_params &mipmap_params)
{
console::debug(L"\nTexture conversion MIP-map parameters:");
console::debug(L" Mode: %s", crn_get_mip_mode_name(mipmap_params.m_mode));
console::debug(L" Filter: %S", crn_get_mip_filter_name(mipmap_params.m_filter));
console::debug(L"Gamma filtering: %u, Gamma: %2.2f", mipmap_params.m_gamma_filtering, mipmap_params.m_gamma);
console::debug(L" Blurriness: %2.2f", mipmap_params.m_blurriness);
console::debug(L" Renormalize: %u", mipmap_params.m_renormalize);
console::debug(L" Tiled: %u", mipmap_params.m_tiled);
console::debug(L" Max Levels: %u", mipmap_params.m_max_levels);
console::debug(L" Min level size: %u", mipmap_params.m_min_mip_size);
console::debug(L" window: %u %u %u %u", mipmap_params.m_window_left, mipmap_params.m_window_top, mipmap_params.m_window_right, mipmap_params.m_window_bottom);
console::debug(L" scale mode: %s", crn_get_scale_mode_desc(mipmap_params.m_scale_mode));
console::debug(L" scale: %f %f", mipmap_params.m_scale_x, mipmap_params.m_scale_y);
console::debug(L" clamp: %u %u, clamp_scale: %u", mipmap_params.m_clamp_width, mipmap_params.m_clamp_height, mipmap_params.m_clamp_scale);
console::debug(L"");
console::debug("\nTexture conversion MIP-map parameters:");
console::debug(" Mode: %s", crn_get_mip_mode_name(mipmap_params.m_mode));
console::debug(" Filter: %s", crn_get_mip_filter_name(mipmap_params.m_filter));
console::debug("Gamma filtering: %u, Gamma: %2.2f", mipmap_params.m_gamma_filtering, mipmap_params.m_gamma);
console::debug(" Blurriness: %2.2f", mipmap_params.m_blurriness);
console::debug(" Renormalize: %u", mipmap_params.m_renormalize);
console::debug(" Tiled: %u", mipmap_params.m_tiled);
console::debug(" Max Levels: %u", mipmap_params.m_max_levels);
console::debug(" Min level size: %u", mipmap_params.m_min_mip_size);
console::debug(" window: %u %u %u %u", mipmap_params.m_window_left, mipmap_params.m_window_top, mipmap_params.m_window_right, mipmap_params.m_window_bottom);
console::debug(" scale mode: %s", crn_get_scale_mode_desc(mipmap_params.m_scale_mode));
console::debug(" scale: %f %f", mipmap_params.m_scale_x, mipmap_params.m_scale_y);
console::debug(" clamp: %u %u, clamp_scale: %u", mipmap_params.m_clamp_width, mipmap_params.m_clamp_height, mipmap_params.m_clamp_scale);
console::debug("");
}
void convert_params::print()
{
console::debug(L"\nTexture conversion parameters:");
console::debug(L" Resolution: %ux%u, Faces: %u, Levels: %u, Format: %s",
console::debug("\nTexture conversion parameters:");
console::debug(" Resolution: %ux%u, Faces: %u, Levels: %u, Format: %s",
m_pInput_texture->get_width(),
m_pInput_texture->get_height(),
m_pInput_texture->get_num_faces(),
m_pInput_texture->get_num_levels(),
pixel_format_helpers::get_pixel_format_string(m_pInput_texture->get_format()));
console::debug(L" texture_type: %s", get_texture_type_desc(m_texture_type));
console::debug(L" dst_filename: %s", m_dst_filename.get_ptr());
console::debug(L" dst_file_type: %s", texture_file_types::get_extension(m_dst_file_type));
console::debug(L" dst_format: %s", pixel_format_helpers::get_pixel_format_string(m_dst_format));
console::debug(L" quick: %u", m_quick);
console::debug(L" use_source_format: %u", m_use_source_format);
console::debug(" texture_type: %s", get_texture_type_desc(m_texture_type));
console::debug(" dst_filename: %s", m_dst_filename.get_ptr());
console::debug(" dst_file_type: %s", texture_file_types::get_extension(m_dst_file_type));
console::debug(" dst_format: %s", pixel_format_helpers::get_pixel_format_string(m_dst_format));
console::debug(" quick: %u", m_quick);
console::debug(" use_source_format: %u", m_use_source_format);
}
static bool write_compressed_texture(
@@ -432,19 +431,19 @@ namespace crnlib
crn_format crn_fmt = pixel_format_helpers::convert_pixel_format_to_best_crn_format(dst_format);
comp_params.m_format = crn_fmt;
console::message(L"Writing %s texture to file: \"%s\"", crn_get_format_string(crn_fmt), params.m_dst_filename.get_ptr());
console::message("Writing %s texture to file: \"%s\"", crn_get_format_string(crn_fmt), params.m_dst_filename.get_ptr());
uint32 actual_quality_level;
float actual_bitrate;
bool status = work_tex.write_to_file(params.m_dst_filename.get_ptr(), params.m_dst_file_type, &comp_params, &actual_quality_level, &actual_bitrate);
if (!status)
return convert_error(params, L"Failed writing output file!");
return convert_error(params, "Failed writing output file!");
if (!params.m_no_stats)
{
if (!stats.init(params.m_pInput_texture->get_source_filename().get_ptr(), params.m_dst_filename.get_ptr(), *params.m_pIntermediate_texture, params.m_dst_file_type, params.m_lzma_stats))
{
console::warning(L"Unable to compute output statistics for file: %s", params.m_pInput_texture->get_source_filename().get_ptr());
console::warning("Unable to compute output statistics for file: %s", params.m_pInput_texture->get_source_filename().get_ptr());
}
}
@@ -471,7 +470,7 @@ namespace crnlib
pack_params.m_num_helper_threads = comp_params.m_num_helper_threads;
pack_params.m_use_transparent_indices_for_black = comp_params.get_flag(cCRNCompFlagUseTransparentIndicesForBlack);
console::info(L"Converting texture format from %s to %s", pixel_format_helpers::get_pixel_format_string(work_tex.get_format()), pixel_format_helpers::get_pixel_format_string(dst_format));
console::info("Converting texture format from %s to %s", pixel_format_helpers::get_pixel_format_string(work_tex.get_format()), pixel_format_helpers::get_pixel_format_string(dst_format));
timer tm;
tm.start();
@@ -480,7 +479,7 @@ namespace crnlib
double t = tm.get_elapsed_secs();
console::info(L"");
console::info("");
if (!status)
{
@@ -491,11 +490,11 @@ namespace crnlib
}
else
{
return convert_error(params, L"Failed converting texture to output format!");
return convert_error(params, "Failed converting texture to output format!");
}
}
console::info(L"Texture format conversion took %3.3fs", t);
console::info("Texture format conversion took %3.3fs", t);
}
if (params.m_write_mipmaps_to_multiple_files)
@@ -504,13 +503,13 @@ namespace crnlib
{
for (uint l = 0; l < work_tex.get_num_levels(); l++)
{
dynamic_wstring filename(params.m_dst_filename.get_ptr());
dynamic_string filename(params.m_dst_filename.get_ptr());
dynamic_wstring drv, dir, fn, ext;
if (!split_path(params.m_dst_filename.get_ptr(), &drv, &dir, &fn, &ext))
dynamic_string drv, dir, fn, ext;
if (!file_utils::split_path(params.m_dst_filename.get_ptr(), &drv, &dir, &fn, &ext))
return false;
fn += dynamic_wstring(cVarArg, L"_face%u_mip%u", f, l).get_ptr();
fn += dynamic_string(cVarArg, "_face%u_mip%u", f, l).get_ptr();
filename = drv + dir + fn + ext;
mip_level *pLevel = work_tex.get_level(f, l);
@@ -521,25 +520,25 @@ namespace crnlib
dds_texture new_tex;
new_tex.assign(face);
console::info(L"Writing texture face %u mip level %u to file %s", f, l, filename.get_ptr());
console::info("Writing texture face %u mip level %u to file %s", f, l, filename.get_ptr());
if (!new_tex.write_to_file(filename.get_ptr(), params.m_dst_file_type, NULL, NULL, NULL))
return convert_error(params, L"Failed writing output file!");
return convert_error(params, "Failed writing output file!");
}
}
}
else
{
console::message(L"Writing texture to file: \"%s\"", params.m_dst_filename.get_ptr());
console::message("Writing texture to file: \"%s\"", params.m_dst_filename.get_ptr());
if (!work_tex.write_to_file(params.m_dst_filename.get_ptr(), params.m_dst_file_type, NULL, NULL, NULL))
return convert_error(params, L"Failed writing output file!");
return convert_error(params, "Failed writing output file!");
if (!params.m_no_stats)
{
if (!stats.init(params.m_pInput_texture->get_source_filename().get_ptr(), params.m_dst_filename.get_ptr(), *params.m_pIntermediate_texture, params.m_dst_file_type, params.m_lzma_stats))
{
console::warning(L"Unable to compute output statistics for file: %s", params.m_pInput_texture->get_source_filename().get_ptr());
console::warning("Unable to compute output statistics for file: %s", params.m_pInput_texture->get_source_filename().get_ptr());
}
}
}
@@ -576,7 +575,7 @@ namespace crnlib
{
if ((work_tex.get_comp_flags() & pixel_format_helpers::cCompFlagAValid) == 0)
{
console::warning(L"Output format is alpha-only, but input doesn't have alpha, so setting alpha to luminance.");
console::warning("Output format is alpha-only, but input doesn't have alpha, so setting alpha to luminance.");
work_tex.convert(PIXEL_FMT_A8, crnlib::dxt_image::pack_params());
@@ -586,6 +585,15 @@ namespace crnlib
}
pixel_format dst_format = params.m_dst_format;
if (pixel_format_helpers::is_dxt(dst_format))
{
if ((params.m_dst_file_type != texture_file_types::cFormatCRN) &&
(params.m_dst_file_type != texture_file_types::cFormatDDS))
{
console::warning("Output file format does not support DXT - automatically choosing pixel format.");
dst_format = PIXEL_FMT_INVALID;
}
}
if (dst_format == PIXEL_FMT_INVALID)
{
@@ -611,15 +619,15 @@ namespace crnlib
{
if (perceptual)
{
//console::warning(L"Output pixel format is swizzled or not RGB, disabling perceptual color metrics");
console::message("Output pixel format is swizzled or not RGB, disabling perceptual color metrics");
perceptual = false;
}
}
if (pixel_format_helpers::is_normal_map(dst_format))
{
//if (perceptual)
//console::warning(L"Output pixel format is intended for normal maps, disabling perceptual color metrics");
if (perceptual)
console::message("Output pixel format is intended for normal maps, disabling perceptual color metrics");
perceptual = false;
}
@@ -639,7 +647,7 @@ namespace crnlib
}
if (!create_texture_mipmaps(work_tex, comp_params, mipmap_params, generate_mipmaps))
return convert_error(params, L"Failed creating texture mipmaps!");
return convert_error(params, "Failed creating texture mipmaps!");
bool formats_differ = work_tex.get_format() != dst_format;
if (formats_differ)
@@ -666,7 +674,7 @@ namespace crnlib
status = convert_and_write_normal_texture(work_tex, params, comp_params, dst_format, progress_state, formats_differ, perceptual, stats);
}
console::progress(L"");
console::progress("");
if (progress_state.m_canceled)
{
@@ -679,18 +687,18 @@ namespace crnlib
if (status)
{
if (params.m_param_debugging)
console::info(L"Work texture format: %s, desired destination format: %s", pixel_format_helpers::get_pixel_format_string(work_tex.get_format()), pixel_format_helpers::get_pixel_format_string(dst_format));
console::info("Work texture format: %s, desired destination format: %s", pixel_format_helpers::get_pixel_format_string(work_tex.get_format()), pixel_format_helpers::get_pixel_format_string(dst_format));
console::message(L"Texture successfully written in %3.3fs", total_write_time);
console::message("Texture successfully written in %3.3fs", total_write_time);
}
else
{
dynamic_wstring str;
dynamic_string str;
if (work_tex.get_last_error().is_empty())
str.format(L"Failed writing texture to file \"%s\"", params.m_dst_filename.get_ptr());
str.format("Failed writing texture to file \"%s\"", params.m_dst_filename.get_ptr());
else
str.format(L"Failed writing texture to file \"%s\", Reason: %s", params.m_dst_filename.get_ptr(), work_tex.get_last_error().get_ptr());
str.format("Failed writing texture to file \"%s\", Reason: %s", params.m_dst_filename.get_ptr(), work_tex.get_last_error().get_ptr());
return convert_error(params, str.get_ptr());
}
crnlib/crn_texture_conversion.h
+9 -9
View File
@@ -16,18 +16,18 @@ namespace crnlib
convert_stats();
bool init(
const wchar_t* pSrc_filename,
const wchar_t* pDst_filename,
const char* pSrc_filename,
const char* pDst_filename,
dds_texture& src_tex,
texture_file_types::format dst_file_type,
bool lzma_stats);
bool print(bool psnr_metrics, bool mip_stats, bool grayscale_sampling, const wchar_t *pCSVStatsFile = NULL) const;
bool print(bool psnr_metrics, bool mip_stats, bool grayscale_sampling, const char *pCSVStatsFile = NULL) const;
void clear();
dynamic_wstring m_src_filename;
dynamic_wstring m_dst_filename;
dynamic_string m_src_filename;
dynamic_string m_dst_filename;
texture_file_types::format m_dst_file_type;
dds_texture* m_pInput_tex;
@@ -58,10 +58,10 @@ namespace crnlib
m_debugging(false),
m_param_debugging(false),
m_no_stats(false),
m_use_source_format(false),
m_lzma_stats(false),
m_status(false),
m_canceled(false),
m_use_source_format(false)
m_canceled(false)
{
}
@@ -77,7 +77,7 @@ namespace crnlib
texture_type m_texture_type;
dynamic_wstring m_dst_filename;
dynamic_string m_dst_filename;
texture_file_types::format m_dst_file_type;
pixel_format m_dst_format;
@@ -90,7 +90,7 @@ namespace crnlib
// Return parameters
dds_texture* m_pIntermediate_texture;
mutable dynamic_wstring m_error_message;
mutable dynamic_string m_error_message;
bool m_write_mipmaps_to_multiple_files;
bool m_quick;
crnlib/crn_texture_file_types.cpp
+30 -30
View File
@@ -2,48 +2,48 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "crn_texture_file_types.h"
#include "crn_strutils.h"
#include "crn_file_utils.h"
namespace crnlib
{
const wchar_t* texture_file_types::get_extension(format fmt)
const char* texture_file_types::get_extension(format fmt)
{
CRNLIB_ASSERT(fmt < cNumFileFormats);
if (fmt >= cNumFileFormats)
return NULL;
static const wchar_t* extensions[cNumFileFormats] =
static const char* extensions[cNumFileFormats] =
{
L"tga",
L"png",
L"jpg",
L"jpeg",
L"bmp",
L"gif",
L"tif",
L"tiff",
L"ppm",
L"pgm",
L"dds",
L"psd",
L"jp2",
L"crn",
L"<clipboard>",
L"<dragdrop>"
"tga",
"png",
"jpg",
"jpeg",
"bmp",
"gif",
"tif",
"tiff",
"ppm",
"pgm",
"dds",
"psd",
"jp2",
"crn",
"<clipboard>",
"<dragdrop>"
};
return extensions[fmt];
}
texture_file_types::format texture_file_types::determine_file_format(const wchar_t* pFilename)
texture_file_types::format texture_file_types::determine_file_format(const char* pFilename)
{
dynamic_wstring ext;
if (!split_path(pFilename, NULL, NULL, NULL, &ext))
dynamic_string ext;
if (!file_utils::split_path(pFilename, NULL, NULL, NULL, &ext))
return cFormatInvalid;
if (ext.is_empty())
return cFormatInvalid;
if (ext[0] == L'.')
if (ext[0] == '.')
ext.right(1);
for (uint i = 0; i < cNumFileFormats; i++)
@@ -81,21 +81,21 @@ namespace crnlib
return true;
}
const wchar_t* get_texture_type_desc(texture_type t)
const char* get_texture_type_desc(texture_type t)
{
switch (t)
{
case cTextureTypeUnknown: return L"Unknown";
case cTextureTypeRegularMap: return L"2D map";
case cTextureTypeNormalMap: return L"Normal map";
case cTextureTypeVerticalCrossCubemap: return L"Vertical Cross Cubemap";
case cTextureTypeCubemap: return L"Cubemap";
case cTextureTypeUnknown: return "Unknown";
case cTextureTypeRegularMap: return "2D map";
case cTextureTypeNormalMap: return "Normal map";
case cTextureTypeVerticalCrossCubemap: return "Vertical Cross Cubemap";
case cTextureTypeCubemap: return "Cubemap";
default: break;
}
CRNLIB_ASSERT(false);
return L"?";
return "?";
}
} // namespace crnlib
crnlib/crn_texture_file_types.h
+3 -3
View File
@@ -37,9 +37,9 @@ namespace crnlib
cNumFileFormats
};
static const wchar_t* get_extension(format fmt);
static const char* get_extension(format fmt);
static format determine_file_format(const wchar_t* pFilename);
static format determine_file_format(const char* pFilename);
static bool supports_mipmaps(format fmt);
static bool supports_alpha(format fmt);
@@ -56,7 +56,7 @@ namespace crnlib
cNumTextureTypes
};
const wchar_t* get_texture_type_desc(texture_type t);
const char* get_texture_type_desc(texture_type t);
} // namespace crnlib
crnlib/crn_threaded_clusterizer.h
+4 -3
View File
@@ -2,6 +2,7 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#pragma once
#include "crn_clusterizer.h"
#include "crn_threading.h"
namespace crnlib
{
@@ -43,7 +44,7 @@ namespace crnlib
progress_callback_func pProgress_callback,
void* pProgress_callback_data)
{
m_main_thread_id = get_current_thread_id();
m_main_thread_id = crn_get_current_thread_id();
m_canceled = false;
m_pProgress_callback = pProgress_callback;
m_pProgress_callback_data = pProgress_callback_data;
@@ -136,7 +137,7 @@ namespace crnlib
private:
task_pool* m_pTask_pool;
uint32 m_main_thread_id;
crn_thread_id_t m_main_thread_id;
struct create_clusters_task_state
{
@@ -328,7 +329,7 @@ namespace crnlib
if (m_canceled)
return;
const bool is_main_thread = (get_current_thread_id() == m_main_thread_id);
const bool is_main_thread = (crn_get_current_thread_id() == m_main_thread_id);
const bool quick = false;
m_clusterizers[partition_index].generate_codebook(
crnlib/crn_threaded_resampler.cpp
+1
View File
@@ -3,6 +3,7 @@
#include "crn_core.h"
#include "crn_threaded_resampler.h"
#include "crn_resample_filters.h"
#include "crn_threading.h"
namespace crnlib
{
crnlib/crn_threaded_resampler.h
+1 -1
View File
@@ -3,10 +3,10 @@
#pragma once
#include "crn_resampler.h"
#include "crn_vec.h"
#include "crn_task_pool.h"
namespace crnlib
{
class task_pool;
class threaded_resampler
{
CRNLIB_NO_COPY_OR_ASSIGNMENT_OP(threaded_resampler);
crnlib/crn_traits.h
+15 -1
View File
@@ -4,6 +4,15 @@
namespace crnlib
{
template<typename T> struct int_traits { enum { cMin = crnlib::cINT32_MIN, cMax = crnlib::cINT32_MAX, cSigned = true }; };
template<> struct int_traits<int8> { enum { cMin = crnlib::cINT8_MIN, cMax = crnlib::cINT8_MAX, cSigned = true }; };
template<> struct int_traits<int16> { enum { cMin = crnlib::cINT16_MIN, cMax = crnlib::cINT16_MAX, cSigned = true }; };
template<> struct int_traits<int32> { enum { cMin = crnlib::cINT32_MIN, cMax = crnlib::cINT32_MAX, cSigned = true }; };
template<> struct int_traits<uint8> { enum { cMin = 0, cMax = crnlib::cUINT8_MAX, cSigned = false }; };
template<> struct int_traits<uint16> { enum { cMin = 0, cMax = crnlib::cUINT16_MAX, cSigned = false }; };
template<> struct int_traits<uint32> { enum { cMin = 0, cMax = crnlib::cUINT32_MAX, cSigned = false }; };
template<typename T>
struct scalar_type
{
@@ -43,8 +52,13 @@ namespace crnlib
CRNLIB_DEFINE_BUILT_IN_TYPE(unsigned int)
CRNLIB_DEFINE_BUILT_IN_TYPE(long)
CRNLIB_DEFINE_BUILT_IN_TYPE(unsigned long)
#ifdef __GNUC__
CRNLIB_DEFINE_BUILT_IN_TYPE(long long)
CRNLIB_DEFINE_BUILT_IN_TYPE(unsigned long long)
#else
CRNLIB_DEFINE_BUILT_IN_TYPE(__int64)
CRNLIB_DEFINE_BUILT_IN_TYPE(unsigned __int64)
#endif
CRNLIB_DEFINE_BUILT_IN_TYPE(float)
CRNLIB_DEFINE_BUILT_IN_TYPE(double)
CRNLIB_DEFINE_BUILT_IN_TYPE(long double)
@@ -69,7 +83,7 @@ namespace crnlib
#define CRNLIB_IS_SCALAR_TYPE(T) (scalar_type<T>::cFlag)
#define CRNLIB_IS_BITWISE_COPYABLE(T) ((scalar_type<T>::cFlag) || (bitwise_copyable<T>::cFlag) || CRNLIB_IS_POD(T))
#define CRNLIB_IS_BITWISE_COPYABLE(T) (CRNLIB_IS_SCALAR_TYPE(T) || CRNLIB_IS_POD(T) || (bitwise_copyable<T>::cFlag))
#define CRNLIB_IS_BITWISE_MOVABLE(T) (CRNLIB_IS_BITWISE_COPYABLE(T) || (bitwise_movable<T>::cFlag))
crnlib/crn_tree_clusterizer.h
+8 -4
View File
@@ -137,7 +137,7 @@ namespace crnlib
return m_codebook;
}
const uint find_best_codebook_entry(const VectorType& v) const
uint find_best_codebook_entry(const VectorType& v) const
{
uint cur_node_index = 0;
@@ -161,7 +161,7 @@ namespace crnlib
}
}
const uint find_best_codebook_entry_fs(const VectorType& v) const
uint find_best_codebook_entry_fs(const VectorType& v) const
{
float best_dist = math::cNearlyInfinite;
uint best_index = 0;
@@ -222,7 +222,7 @@ namespace crnlib
if (parent_node.m_vectors.size() == 1)
return;
VectorType furthest;
VectorType furthest(0);
double furthest_dist = -1.0f;
for (uint i = 0; i < parent_node.m_vectors.size(); i++)
@@ -272,9 +272,13 @@ namespace crnlib
covar[x][y] = covar[x][y] + v[x] * w[y];
}
for (uint x = 0; x < N - 1; x++)
if (N > 1)
{
//for (uint x = 0; x < (N - 1); x++)
for (uint x = 0; x != (N - 1); x++)
for (uint y = x + 1; y < N; y++)
covar[y][x] = covar[x][y];
}
covar /= float(parent_node.m_total_weight);
crnlib/crn_types.h
+25 -20
View File
@@ -12,31 +12,36 @@ namespace crnlib
typedef uint32 uint;
typedef signed int int32;
#ifdef __GNUC__
typedef unsigned long long uint64;
typedef long long int64;
#else
typedef unsigned __int64 uint64;
typedef signed __int64 int64;
#endif
const uint8 UINT8_MIN = 0;
const uint8 UINT8_MAX = 0xFFU;
const uint16 UINT16_MIN = 0;
const uint16 UINT16_MAX = 0xFFFFU;
const uint32 UINT32_MIN = 0;
const uint32 UINT32_MAX = 0xFFFFFFFFU;
const uint64 UINT64_MIN = 0;
const uint64 UINT64_MAX = 0xFFFFFFFFFFFFFFFFULL; //0xFFFFFFFFFFFFFFFFui64;
const uint8 cUINT8_MIN = 0;
const uint8 cUINT8_MAX = 0xFFU;
const uint16 cUINT16_MIN = 0;
const uint16 cUINT16_MAX = 0xFFFFU;
const uint32 cUINT32_MIN = 0;
const uint32 cUINT32_MAX = 0xFFFFFFFFU;
const uint64 cUINT64_MIN = 0;
const uint64 cUINT64_MAX = 0xFFFFFFFFFFFFFFFFULL; //0xFFFFFFFFFFFFFFFFui64;
const int8 INT8_MIN = -128;
const int8 INT8_MAX = 127;
const int16 INT16_MIN = -32768;
const int16 INT16_MAX = 32767;
const int32 INT32_MIN = (-2147483647 - 1);
const int32 INT32_MAX = 2147483647;
const int64 INT64_MIN = (int64)0x8000000000000000ULL; //(-9223372036854775807i64 - 1);
const int64 INT64_MAX = (int64)0x7FFFFFFFFFFFFFFFULL; // 9223372036854775807i64;
const int8 cINT8_MIN = -128;
const int8 cINT8_MAX = 127;
const int16 cINT16_MIN = -32768;
const int16 cINT16_MAX = 32767;
const int32 cINT32_MIN = (-2147483647 - 1);
const int32 cINT32_MAX = 2147483647;
const int64 cINT64_MIN = (int64)0x8000000000000000ULL; //(-9223372036854775807i64 - 1);
const int64 cINT64_MAX = (int64)0x7FFFFFFFFFFFFFFFULL; // 9223372036854775807i64;
#ifdef CRNLIB_PLATFORM_PC_X64
typedef unsigned __int64 uint_ptr;
typedef unsigned __int64 uint32_ptr;
typedef signed __int64 signed_size_t;
#if CRNLIB_64BIT_POINTERS
typedef uint64 uint_ptr;
typedef uint64 uint32_ptr;
typedef int64 signed_size_t;
typedef uint64 ptr_bits_t;
#else
typedef unsigned int uint_ptr;
crnlib/crn_utils.cpp
+12
View File
@@ -38,6 +38,18 @@ namespace crnlib
}
}
void copy_dwords(uint32* pDst, const uint32* pSrc, uint num, bool endian_switch)
{
if (!endian_switch)
memcpy(pDst, pSrc, num << 2U);
else
{
uint32* pDst_end = pDst + num;
while (pDst != pDst_end)
*pDst++ = swap32(*pSrc++);
}
}
uint compute_max_mips(uint width, uint height)
{
if ((width | height) == 0)
crnlib/crn_utils.h
+9 -5
View File
@@ -8,6 +8,7 @@
#define CRNLIB_ARRAYSIZE(x) (sizeof(x)/sizeof(x[0]))
#ifdef _MSC_VER
// Need to explictly extern these with MSVC, but not MinGW.
extern "C" unsigned long __cdecl _lrotl(unsigned long, int);
#pragma intrinsic(_lrotl)
@@ -15,11 +16,13 @@ extern "C" unsigned long __cdecl _lrotr(unsigned long, int);
#pragma intrinsic(_lrotr)
#endif
//#define CRNLIB_ROTATE_LEFT(x, k) (((x) << (k)) | ((x) >> (32-(k))))
#ifdef WIN32
#define CRNLIB_ROTATE_LEFT(x, k) _lrotl(x, k)
//#define CRNLIB_ROTATE_RIGHT(x, k) (((x) >> (k)) | ((x) << (32-(k))))
#define CRNLIB_ROTATE_RIGHT(x, k) _lrotr(x, k)
#else
#define CRNLIB_ROTATE_LEFT(x, k) (((x) << (k)) | ((x) >> (32-(k))))
#define CRNLIB_ROTATE_RIGHT(x, k) (((x) >> (k)) | ((x) << (32-(k))))
#endif
template<class T, size_t N> T decay_array_to_subtype(T (&a)[N]);
#define CRNLIB_ARRAY_SIZE(X) (sizeof(X) / sizeof(decay_array_to_subtype(X)))
@@ -39,12 +42,12 @@ namespace crnlib
template<typename T> inline void zero_object(T& obj)
{
memset(&obj, 0, sizeof(obj));
memset((void*)&obj, 0, sizeof(obj));
}
template<typename T> inline void zero_this(T* pObj)
{
memset(pObj, 0, sizeof(*pObj));
memset((void*)pObj, 0, sizeof(*pObj));
}
inline bool is_bit_set(uint bits, uint mask)
@@ -225,6 +228,7 @@ namespace crnlib
void endian_switch_words(uint16* p, uint num);
void endian_switch_dwords(uint32* p, uint num);
void copy_words(uint16* pDst, const uint16* pSrc, uint num, bool endian_switch);
void copy_dwords(uint32* pDst, const uint32* pSrc, uint num, bool endian_switch);
uint compute_max_mips(uint width, uint height);
crnlib/crn_value.cpp
+9 -9
View File
@@ -5,16 +5,16 @@
namespace crnlib
{
const wchar_t* gValueDataTypeStrings[cDTTotal + 1] =
const char* gValueDataTypeStrings[cDTTotal + 1] =
{
L"invalid",
L"string",
L"bool",
L"int",
L"uint",
L"float",
L"vec3f",
L"vec3i",
"invalid",
"string",
"bool",
"int",
"uint",
"float",
"vec3f",
"vec3i",
NULL,
};
crnlib/crn_value.h
+40 -40
View File
@@ -2,7 +2,7 @@
// See Copyright Notice and license at the end of inc/crnlib.h
#pragma once
#include "crn_strutils.h"
#include "crn_dynamic_wstring.h"
#include "crn_dynamic_string.h"
#include "crn_vec.h"
namespace crnlib
@@ -21,7 +21,7 @@ namespace crnlib
cDTTotal
};
extern const wchar_t* gValueDataTypeStrings[cDTTotal + 1];
extern const char* gValueDataTypeStrings[cDTTotal + 1];
class value
{
@@ -31,13 +31,13 @@ namespace crnlib
{
}
value(const wchar_t* pStr) :
m_pStr(crnlib_new<dynamic_wstring>(pStr)), m_type(cDTString)
value(const char* pStr) :
m_pStr(crnlib_new<dynamic_string>(pStr)), m_type(cDTString)
{
}
value(const dynamic_wstring& str) :
m_pStr(crnlib_new<dynamic_wstring>(str)), m_type(cDTString)
value(const dynamic_string& str) :
m_pStr(crnlib_new<dynamic_string>(str)), m_type(cDTString)
{
}
@@ -125,7 +125,7 @@ namespace crnlib
m_type = cDTInvalid;
}
void set_string(const wchar_t* pStr)
void set_string(const char* pStr)
{
set_str(pStr);
}
@@ -170,7 +170,7 @@ namespace crnlib
m_pVec3I->set(v);
}
bool parse(const wchar_t* p)
bool parse(const char* p)
{
if ((!p) || (!p[0]))
{
@@ -178,12 +178,12 @@ namespace crnlib
return false;
}
if (_wcsicmp(p, L"false") == 0)
if (_stricmp(p, "false") == 0)
{
set_bool(false);
return true;
}
else if (_wcsicmp(p, L"true") == 0)
else if (_stricmp(p, "true") == 0)
{
set_bool(true);
return true;
@@ -191,7 +191,7 @@ namespace crnlib
if (p[0] == '\"')
{
dynamic_wstring str;
dynamic_string str;
str = p + 1;
if (!str.is_empty())
{
@@ -205,21 +205,21 @@ namespace crnlib
}
}
if (wcschr(p, L',') != NULL)
if (strchr(p, ',') != NULL)
{
float fx = 0, fy = 0, fz = 0;
#ifdef _MSC_VER
if (swscanf_s(p, L"%f,%f,%f", &fx, &fy, &fz) == 3)
if (sscanf_s(p, "%f,%f,%f", &fx, &fy, &fz) == 3)
#else
if (swscanf(p, L"%f,%f,%f", &fx, &fy, &fz) == 3)
if (sscanf(p, "%f,%f,%f", &fx, &fy, &fz) == 3)
#endif
{
bool as_float = true;
int ix = 0, iy = 0, iz = 0;
#ifdef _MSC_VER
if (swscanf_s(p, L"%i,%i,%i", &ix, &iy, &iz) == 3)
if (sscanf_s(p, "%i,%i,%i", &ix, &iy, &iz) == 3)
#else
if (swscanf(p, L"%i,%i,%i", &ix, &iy, &iz) == 3)
if (sscanf(p, "%i,%i,%i", &ix, &iy, &iz) == 3)
#endif
{
if ((ix == fx) && (iy == fy) && (iz == fz))
@@ -235,7 +235,7 @@ namespace crnlib
}
}
const wchar_t* q = p;
const char* q = p;
bool success = string_to_uint(q, m_uint);
if ((success) && (*q == 0))
{
@@ -264,18 +264,18 @@ namespace crnlib
return true;
}
dynamic_wstring& get_as_string(dynamic_wstring& dst) const
dynamic_string& get_as_string(dynamic_string& dst) const
{
switch (m_type)
{
case cDTInvalid: dst.clear(); break;
case cDTString: dst = *m_pStr; break;
case cDTBool: dst = m_bool ? L"TRUE" : L"FALSE"; break;
case cDTInt: dst.format(L"%i", m_int); break;
case cDTUInt: dst.format(L"%u", m_uint); break;
case cDTFloat: dst.format(L"%f", m_float); break;
case cDTVec3F: dst.format(L"%f,%f,%f", (*m_pVec3F)[0], (*m_pVec3F)[1], (*m_pVec3F)[2]); break;
case cDTVec3I: dst.format(L"%i,%i,%i", (*m_pVec3I)[0], (*m_pVec3I)[1], (*m_pVec3I)[2]); break;
case cDTBool: dst = m_bool ? "TRUE" : "FALSE"; break;
case cDTInt: dst.format("%i", m_int); break;
case cDTUInt: dst.format("%u", m_uint); break;
case cDTFloat: dst.format("%f", m_float); break;
case cDTVec3F: dst.format("%f,%f,%f", (*m_pVec3F)[0], (*m_pVec3F)[1], (*m_pVec3F)[2]); break;
case cDTVec3I: dst.format("%i,%i,%i", (*m_pVec3I)[0], (*m_pVec3I)[1], (*m_pVec3I)[2]); break;
default: break;
}
@@ -293,7 +293,7 @@ namespace crnlib
}
case cDTString:
{
const wchar_t* p = m_pStr->get_ptr();
const char* p = m_pStr->get_ptr();
return string_to_int(p, val);
}
case cDTBool: val = m_bool; break;
@@ -359,7 +359,7 @@ namespace crnlib
}
case cDTString:
{
const wchar_t* p = m_pStr->get_ptr();
const char* p = m_pStr->get_ptr();
return string_to_uint(p, val);
}
case cDTBool:
@@ -438,7 +438,7 @@ namespace crnlib
}
case cDTString:
{
const wchar_t* p = m_pStr->get_ptr();
const char* p = m_pStr->get_ptr();
return string_to_bool(p, val);
}
case cDTBool:
@@ -497,7 +497,7 @@ namespace crnlib
}
case cDTString:
{
const wchar_t* p = m_pStr->get_ptr();
const char* p = m_pStr->get_ptr();
return string_to_float(p, val);
}
case cDTBool:
@@ -556,12 +556,12 @@ namespace crnlib
}
case cDTString:
{
const wchar_t* p = m_pStr->get_ptr();
const char* p = m_pStr->get_ptr();
float x = 0, y = 0, z = 0;
#ifdef _MSC_VER
if (wscanf_s(p, L"%f,%f,%f", &x, &y, &z) == 3)
if (sscanf_s(p, "%f,%f,%f", &x, &y, &z) == 3)
#else
if (wscanf(p, L"%f,%f,%f", &x, &y, &z) == 3)
if (sscanf(p, "%f,%f,%f", &x, &y, &z) == 3)
#endif
{
val.set(x, y, z);
@@ -619,12 +619,12 @@ namespace crnlib
}
case cDTString:
{
const wchar_t* p = m_pStr->get_ptr();
const char* p = m_pStr->get_ptr();
float x = 0, y = 0, z = 0;
#ifdef _MSC_VER
if (wscanf_s(p, L"%f,%f,%f", &x, &y, &z) == 3)
if (sscanf_s(p, "%f,%f,%f", &x, &y, &z) == 3)
#else
if (wscanf(p, L"%f,%f,%f", &x, &y, &z) == 3)
if (sscanf(p, "%f,%f,%f", &x, &y, &z) == 3)
#endif
{
if ((x < INT_MIN) || (x > INT_MAX) || (y < INT_MIN) || (y > INT_MAX) || (z < INT_MIN) || (z > INT_MAX))
@@ -963,7 +963,7 @@ namespace crnlib
switch (m_type)
{
case cDTString:
m_pStr = crnlib_new<dynamic_wstring>();
m_pStr = crnlib_new<dynamic_string>();
break;
case cDTVec3F:
m_pVec3F = crnlib_new<vec3F>();
@@ -976,7 +976,7 @@ namespace crnlib
}
}
void set_str(const dynamic_wstring& s)
void set_str(const dynamic_string& s)
{
if (m_type == cDTString)
m_pStr->set(s);
@@ -985,11 +985,11 @@ namespace crnlib
clear_dynamic();
m_type = cDTString;
m_pStr = crnlib_new<dynamic_wstring>(s);
m_pStr = crnlib_new<dynamic_string>(s);
}
}
void set_str(const wchar_t* p)
void set_str(const char* p)
{
if (m_type == cDTString)
m_pStr->set(p);
@@ -998,7 +998,7 @@ namespace crnlib
clear_dynamic();
m_type = cDTString;
m_pStr = crnlib_new<dynamic_wstring>(p);
m_pStr = crnlib_new<dynamic_string>(p);
}
}
@@ -1013,7 +1013,7 @@ namespace crnlib
vec3F* m_pVec3F;
vec3I* m_pVec3I;
dynamic_wstring* m_pStr;
dynamic_string* m_pStr;
uint m_union[cUnionSize];
};
crnlib/crn_vector.cpp
+1 -2
View File
@@ -6,14 +6,13 @@
#include "crn_color.h"
#include "crn_vec.h"
#include <stdio.h>
namespace crnlib
{
bool elemental_vector::increase_capacity(uint min_new_capacity, bool grow_hint, uint element_size, object_mover pMover, bool nofail)
{
CRNLIB_ASSERT(m_size <= m_capacity);
#ifdef CRNLIB_PLATFORM_PC_X64
#ifdef CRNLIB_64BIT_POINTERS
CRNLIB_ASSERT(min_new_capacity < (0x400000000ULL / element_size));
#else
CRNLIB_ASSERT(min_new_capacity < (0x7FFF0000U / element_size));
crnlib/crn_vector.h
+24 -4
View File
@@ -296,7 +296,10 @@ namespace crnlib
const uint num_to_move = orig_size - index;
if (CRNLIB_IS_BITWISE_COPYABLE(T))
{
// This overwrites the destination object bits, but bitwise copyable means we don't need to worry about destruction.
memmove(m_p + index + n, m_p + index, sizeof(T) * num_to_move);
}
else
{
const T* pSrc = m_p + orig_size - 1;
@@ -312,7 +315,10 @@ namespace crnlib
T* pDst = m_p + index;
if (CRNLIB_IS_BITWISE_COPYABLE(T))
{
// This copies in the new bits, overwriting the existing objects, which is OK for copyable types that don't need destruction.
memcpy(pDst, p, sizeof(T) * n);
}
else
{
for (uint i = 0; i < n; i++)
@@ -358,12 +364,26 @@ namespace crnlib
const T* pSrc = m_p + start + n;
if (CRNLIB_IS_BITWISE_COPYABLE(T))
if ((CRNLIB_IS_BITWISE_COPYABLE(T)) && (!CRNLIB_IS_BITWISE_MOVABLE(T)))
{
// Type is bitwise copyable, so there's no need to destruct the overwritten objects.
// Copy "down" the objects to preserve, filling in the empty slots.
memmove(pDst, pSrc, num_to_move * sizeof(T));
}
else if (CRNLIB_IS_BITWISE_MOVABLE(T))
{
// Type is bitwise movable, which means we can move them around but they still may need to be destructed.
// First destroy the erased objects.
scalar_type<T>::destruct_array(pDst, n);
// Copy "down" the objects to preserve, filling in the empty slots.
memmove(pDst, pSrc, num_to_move * sizeof(T));
}
else
{
// Type is not bitwise copyable or movable.
// Move them down one at a time by using the equals operator, and destroying anything that's left over at the end.
T* pDst_end = pDst + num_to_move;
while (pDst != pDst_end)
*pDst++ = *pSrc++;
@@ -609,8 +629,8 @@ namespace crnlib
// placement new
new (static_cast<void*>(pDst)) T(*pSrc);
pSrc->~T();
pSrc++;
pDst++;
++pSrc;
++pDst;
}
}
crnlib/crn_winhdr.h
+4
View File
@@ -1,5 +1,9 @@
#pragma once
#ifndef WIN32
#error Should not get here
#endif
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x500
#endif
crnlib/crnlib.2008.vcproj
+51 -79
View File
@@ -586,6 +586,10 @@
RelativePath=".\crn_assert.h"
>
</File>
<File
RelativePath=".\crn_atomics.h"
>
</File>
<File
RelativePath=".\crn_core.cpp"
>
@@ -978,13 +982,6 @@
<File
RelativePath=".\crn_lzma_codec.cpp"
>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\crn_lzma_codec.h"
@@ -1062,14 +1059,6 @@
RelativePath=".\crn_dynamic_string.h"
>
</File>
<File
RelativePath=".\crn_dynamic_wstring.cpp"
>
</File>
<File
RelativePath=".\crn_dynamic_wstring.h"
>
</File>
<File
RelativePath=".\crn_strutils.cpp"
>
@@ -1079,50 +1068,6 @@
>
</File>
</Filter>
<Filter
Name="win32"
>
<File
RelativePath=".\crn_win32_console.cpp"
>
</File>
<File
RelativePath=".\crn_win32_console.h"
>
</File>
<File
RelativePath=".\crn_win32_file_utils.cpp"
>
</File>
<File
RelativePath=".\crn_win32_file_utils.h"
>
</File>
<File
RelativePath=".\crn_win32_find_files.cpp"
>
</File>
<File
RelativePath=".\crn_win32_find_files.h"
>
</File>
<File
RelativePath=".\crn_win32_threading.cpp"
>
</File>
<File
RelativePath=".\crn_win32_threading.h"
>
</File>
<File
RelativePath=".\crn_win32_timer.cpp"
>
</File>
<File
RelativePath=".\crn_win32_timer.h"
>
</File>
</Filter>
<Filter
Name="utils"
>
@@ -1166,6 +1111,14 @@
RelativePath=".\crn_packed_uint.h"
>
</File>
<File
RelativePath=".\crn_timer.cpp"
>
</File>
<File
RelativePath=".\crn_timer.h"
>
</File>
<File
RelativePath=".\crn_traits.h"
>
@@ -1210,6 +1163,14 @@
<Filter
Name="console"
>
<File
RelativePath=".\crn_colorized_console.cpp"
>
</File>
<File
RelativePath=".\crn_colorized_console.h"
>
</File>
<File
RelativePath=".\crn_console.cpp"
>
@@ -1223,35 +1184,26 @@
Name="threading"
>
<File
RelativePath=".\crn_condition_var.cpp"
RelativePath=".\crn_threading.h"
>
</File>
<File
RelativePath=".\crn_condition_var.h"
RelativePath=".\crn_threading_null.h"
>
</File>
<File
RelativePath=".\crn_event.h"
RelativePath=".\crn_threading_win32.cpp"
>
<FileConfiguration
Name="Release|x64"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\crn_mutex.h"
>
</File>
<File
RelativePath=".\crn_semaphore.h"
>
</File>
<File
RelativePath=".\crn_spinlock.h"
>
</File>
<File
RelativePath=".\crn_task_pool.cpp"
>
</File>
<File
RelativePath=".\crn_task_pool.h"
RelativePath=".\crn_threading_win32.h"
>
</File>
</Filter>
@@ -1475,6 +1427,26 @@
>
</File>
</Filter>
<Filter
Name="file"
>
<File
RelativePath=".\crn_file_utils.cpp"
>
</File>
<File
RelativePath=".\crn_file_utils.h"
>
</File>
<File
RelativePath=".\crn_find_files.cpp"
>
</File>
<File
RelativePath=".\crn_find_files.h"
>
</File>
</Filter>
</Filter>
</Files>
<Globals>
crnlib/crnlib.cbp
+24 -20
View File
@@ -14,6 +14,7 @@
<Option compiler="gcc" />
<Option createDefFile="1" />
<Compiler>
<Add option="-Wextra" />
<Add option="-Wall" />
<Add option="-g" />
</Compiler>
@@ -26,8 +27,11 @@
<Option compiler="gcc" />
<Option createDefFile="1" />
<Compiler>
<Add option="-fomit-frame-pointer" />
<Add option="-fexpensive-optimizations" />
<Add option="-O3" />
<Add option="-Wextra" />
<Add option="-Wall" />
<Add option="-O2" />
</Compiler>
<Linker>
<Add option="-s" />
@@ -35,6 +39,8 @@
</Target>
</Build>
<Compiler>
<Add option="-Wextra" />
<Add option="-Wall" />
<Add option="-Wno-unused-value" />
<Add option="-Wno-unused" />
</Compiler>
@@ -48,11 +54,12 @@
<Unit filename="crn_checksum.h" />
<Unit filename="crn_clusterizer.h" />
<Unit filename="crn_color.h" />
<Unit filename="crn_colorized_console.cpp" />
<Unit filename="crn_colorized_console.h" />
<Unit filename="crn_command_line_params.cpp" />
<Unit filename="crn_command_line_params.h" />
<Unit filename="crn_comp.cpp" />
<Unit filename="crn_comp.h" />
<Unit filename="crn_condition_var.cpp" />
<Unit filename="crn_condition_var.h" />
<Unit filename="crn_console.cpp" />
<Unit filename="crn_console.h" />
@@ -85,9 +92,10 @@
<Unit filename="crn_dynamic_stream.h" />
<Unit filename="crn_dynamic_string.cpp" />
<Unit filename="crn_dynamic_string.h" />
<Unit filename="crn_dynamic_wstring.cpp" />
<Unit filename="crn_dynamic_wstring.h" />
<Unit filename="crn_event.h" />
<Unit filename="crn_file_utils.cpp" />
<Unit filename="crn_file_utils.h" />
<Unit filename="crn_find_files.cpp" />
<Unit filename="crn_find_files.h" />
<Unit filename="crn_fixed_array.h" />
<Unit filename="crn_hash.cpp" />
<Unit filename="crn_hash.h" />
@@ -130,18 +138,14 @@
<Unit filename="crn_ryg_dxt.cpp" />
<Unit filename="crn_ryg_dxt.hpp" />
<Unit filename="crn_ryg_types.hpp" />
<Unit filename="crn_semaphore.h" />
<Unit filename="crn_sparse_array.h" />
<Unit filename="crn_sparse_bit_array.cpp" />
<Unit filename="crn_sparse_bit_array.h" />
<Unit filename="crn_spinlock.h" />
<Unit filename="crn_stb_image.cpp" />
<Unit filename="crn_strutils.cpp" />
<Unit filename="crn_strutils.h" />
<Unit filename="crn_symbol_codec.cpp" />
<Unit filename="crn_symbol_codec.h" />
<Unit filename="crn_task_pool.cpp" />
<Unit filename="crn_task_pool.h" />
<Unit filename="crn_texture_comp.cpp" />
<Unit filename="crn_texture_comp.h" />
<Unit filename="crn_texture_conversion.cpp" />
@@ -151,6 +155,13 @@
<Unit filename="crn_threaded_clusterizer.h" />
<Unit filename="crn_threaded_resampler.cpp" />
<Unit filename="crn_threaded_resampler.h" />
<Unit filename="crn_threading.h" />
<Unit filename="crn_threading_null.h" />
<Unit filename="crn_threading_pthreads.h" />
<Unit filename="crn_threading_win32.cpp" />
<Unit filename="crn_threading_win32.h" />
<Unit filename="crn_timer.cpp" />
<Unit filename="crn_timer.h" />
<Unit filename="crn_traits.h" />
<Unit filename="crn_tree_clusterizer.h" />
<Unit filename="crn_types.h" />
@@ -162,16 +173,6 @@
<Unit filename="crn_vec_interval.h" />
<Unit filename="crn_vector.cpp" />
<Unit filename="crn_vector.h" />
<Unit filename="crn_win32_console.cpp" />
<Unit filename="crn_win32_console.h" />
<Unit filename="crn_win32_file_utils.cpp" />
<Unit filename="crn_win32_file_utils.h" />
<Unit filename="crn_win32_find_files.cpp" />
<Unit filename="crn_win32_find_files.h" />
<Unit filename="crn_win32_threading.cpp" />
<Unit filename="crn_win32_threading.h" />
<Unit filename="crn_win32_timer.cpp" />
<Unit filename="crn_win32_timer.h" />
<Unit filename="crn_winhdr.h" />
<Unit filename="crn_zeng.cpp" />
<Unit filename="crn_zeng.h" />
@@ -180,7 +181,6 @@
<Unit filename="lzma_7zBuf.cpp" />
<Unit filename="lzma_7zBuf.h" />
<Unit filename="lzma_7zBuf2.cpp" />
<Unit filename="lzma_7zCrc.cpp" />
<Unit filename="lzma_7zCrc.h" />
<Unit filename="lzma_7zFile.cpp" />
<Unit filename="lzma_7zFile.h" />
@@ -210,9 +210,13 @@
<Unit filename="lzma_Threads.cpp" />
<Unit filename="lzma_Threads.h" />
<Unit filename="lzma_Types.h" />
<Unit filename="..\inc\crn_decomp.h" />
<Unit filename="..\inc\crnlib.h" />
<Unit filename="..\inc\dds_defs.h" />
<Extensions>
<code_completion />
<debugger />
<envvars />
</Extensions>
</Project>
</CodeBlocks_project_file>
crnlib/crnlib.cpp
+31 -69
View File
@@ -8,8 +8,6 @@
#include "crn_buffer_stream.h"
#include "crn_ryg_dxt.hpp"
#include "crn_winhdr.h"
#define CRND_HEADER_FILE_ONLY
#include "../inc/crn_decomp.h"
@@ -32,15 +30,10 @@ namespace crnlib
public:
crnlib_global_initializer()
{
crn_threading_init();
ryg_dxt::sInitDXT();
#ifdef CRNLIB_PLATFORM_PC
SYSTEM_INFO g_system_info;
GetSystemInfo(&g_system_info);
g_number_of_processors = math::maximum<uint>(1U, g_system_info.dwNumberOfProcessors);
#endif
crnlib_enable_fail_exceptions(true);
// Redirect crn_decomp.h's memory allocations into crnlib, which may be further redirected by the outside caller.
@@ -49,16 +42,11 @@ namespace crnlib
};
crnlib_global_initializer g_crnlib_initializer;
}
} // namespace crnlib
using namespace crnlib;
const char* crn_get_format_stringa(crn_format fmt)
{
return pixel_format_helpers::get_crn_format_stringa(fmt);
}
const wchar_t* crn_get_format_string(crn_format fmt)
const char* crn_get_format_string(crn_format fmt)
{
return pixel_format_helpers::get_crn_format_string(fmt);
}
@@ -83,18 +71,7 @@ crn_format crn_get_fundamental_dxt_format(crn_format fmt)
return crnd::crnd_get_fundamental_dxt_format(fmt);
}
const wchar_t* crn_get_file_type_ext(crn_file_type file_type)
{
switch (file_type)
{
case cCRNFileTypeDDS: return L"dds";
case cCRNFileTypeCRN: return L"crn";
default: break;
}
return L"?";
}
const char* crn_get_file_type_exta(crn_file_type file_type)
const char* crn_get_file_type_ext(crn_file_type file_type)
{
switch (file_type)
{
@@ -105,30 +82,30 @@ const char* crn_get_file_type_exta(crn_file_type file_type)
return "?";
}
const wchar_t* crn_get_mip_mode_desc(crn_mip_mode m)
const char* crn_get_mip_mode_desc(crn_mip_mode m)
{
switch (m)
{
case cCRNMipModeUseSourceOrGenerateMips: return L"Use source/generate if none";
case cCRNMipModeUseSourceMips: return L"Only use source MIP maps (if any)";
case cCRNMipModeGenerateMips: return L"Always generate new MIP maps";
case cCRNMipModeNoMips: return L"No MIP maps";
case cCRNMipModeUseSourceOrGenerateMips: return "Use source/generate if none";
case cCRNMipModeUseSourceMips: return "Only use source MIP maps (if any)";
case cCRNMipModeGenerateMips: return "Always generate new MIP maps";
case cCRNMipModeNoMips: return "No MIP maps";
default: break;
}
return L"?";
return "?";
}
const wchar_t* crn_get_mip_mode_name(crn_mip_mode m)
const char* crn_get_mip_mode_name(crn_mip_mode m)
{
switch (m)
{
case cCRNMipModeUseSourceOrGenerateMips: return L"UseSourceOrGenerate";
case cCRNMipModeUseSourceMips: return L"UseSource";
case cCRNMipModeGenerateMips: return L"Generate";
case cCRNMipModeNoMips: return L"None";
case cCRNMipModeUseSourceOrGenerateMips: return "UseSourceOrGenerate";
case cCRNMipModeUseSourceMips: return "UseSource";
case cCRNMipModeGenerateMips: return "Generate";
case cCRNMipModeNoMips: return "None";
default: break;
}
return L"?";
return "?";
}
const char* crn_get_mip_filter_name(crn_mip_filter f)
@@ -145,37 +122,22 @@ const char* crn_get_mip_filter_name(crn_mip_filter f)
return "?";
}
const wchar_t* crn_get_scale_mode_desc(crn_scale_mode sm)
const char* crn_get_scale_mode_desc(crn_scale_mode sm)
{
switch (sm)
{
case cCRNSMDisabled: return L"disabled";
case cCRNSMAbsolute: return L"absolute";
case cCRNSMRelative: return L"relative";
case cCRNSMLowerPow2: return L"lowerpow2";
case cCRNSMNearestPow2: return L"nearestpow2";
case cCRNSMNextPow2: return L"nextpow2";
case cCRNSMDisabled: return "disabled";
case cCRNSMAbsolute: return "absolute";
case cCRNSMRelative: return "relative";
case cCRNSMLowerPow2: return "lowerpow2";
case cCRNSMNearestPow2: return "nearestpow2";
case cCRNSMNextPow2: return "nextpow2";
default: break;
}
return L"?";
return "?";
}
const wchar_t* crn_get_dxt_quality_string(crn_dxt_quality q)
{
switch (q)
{
case cCRNDXTQualitySuperFast: return L"SuperFast";
case cCRNDXTQualityFast: return L"Fast";
case cCRNDXTQualityNormal: return L"Normal";
case cCRNDXTQualityBetter: return L"Better";
case cCRNDXTQualityUber: return L"Uber";
default: break;
}
CRNLIB_ASSERT(false);
return L"?";
}
const char* crn_get_dxt_quality_stringa(crn_dxt_quality q)
const char* crn_get_dxt_quality_string(crn_dxt_quality q)
{
switch (q)
{
@@ -233,7 +195,7 @@ void *crn_compress(const crn_comp_params &comp_params, const crn_mipmap_params &
void *crn_decompress_crn_to_dds(const void *pCRN_file_data, crn_uint32 &file_size)
{
dds_texture tex;
if (!tex.load_crn_from_memory(L"from_memory.crn", pCRN_file_data, file_size))
if (!tex.load_crn_from_memory("from_memory.crn", pCRN_file_data, file_size))
{
file_size = 0;
return NULL;
@@ -277,9 +239,9 @@ bool crn_decompress_dds_to_images(const void *pDDS_file_data, crn_uint32 dds_fil
tex_desc.m_levels = tex.get_num_levels();
tex_desc.m_fmt_fourcc = (crn_uint32)tex.get_format();
for (uint f = 0; f < tex.get_num_faces(); f++)
for (uint32 f = 0; f < tex.get_num_faces(); f++)
{
for (uint l = 0; l < tex.get_num_levels(); l++)
for (uint32 l = 0; l < tex.get_num_levels(); l++)
{
mip_level *pLevel = tex.get_level(f, l);
image_u8 *pImg = pLevel->get_image();
@@ -292,8 +254,8 @@ bool crn_decompress_dds_to_images(const void *pDDS_file_data, crn_uint32 dds_fil
void crn_free_all_images(crn_uint32 **ppImages, const crn_texture_desc &desc)
{
for (uint f = 0; f < desc.m_faces; f++)
for (uint l = 0; l < desc.m_levels; l++)
for (uint32 f = 0; f < desc.m_faces; f++)
for (uint32 l = 0; l < desc.m_levels; l++)
crn_free_block(ppImages[l + desc.m_levels * f]);
}
crnlib/lzma_Bra.cpp
+2 -2
View File
@@ -106,8 +106,8 @@ SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
size -= 4;
for (i = 0; i <= size; i += 4)
{
if (data[i] == 0x40 && (data[i + 1] & 0xC0) == 0x00 ||
data[i] == 0x7F && (data[i + 1] & 0xC0) == 0xC0)
if ( ((data[i] == 0x40) && ((data[i + 1] & 0xC0) == 0x00)) ||
((data[i] == 0x7F) && ((data[i + 1] & 0xC0) == 0xC0)) )
{
UInt32 src =
((UInt32)data[i + 0] << 24) |
crnlib/lzma_LzmaEnc.cpp
+5 -2
View File
@@ -411,8 +411,11 @@ SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
CLzmaEncProps props = *props2;
LzmaEncProps_Normalize(&props);
if (props.lc > LZMA_LC_MAX || props.lp > LZMA_LP_MAX || props.pb > LZMA_PB_MAX ||
props.dictSize > (1 << kDicLogSizeMaxCompress) || props.dictSize > (1 << 30))
if (props.lc > LZMA_LC_MAX ||
props.lp > LZMA_LP_MAX ||
props.pb > LZMA_PB_MAX ||
props.dictSize > (1U << kDicLogSizeMaxCompress) ||
props.dictSize > (1 << 30))
return SZ_ERROR_PARAM;
p->dictSize = props.dictSize;
p->matchFinderCycles = props.mc;
crnlib/lzma_Types.h
+2 -7
View File
@@ -4,16 +4,11 @@
#ifndef __7Z_TYPES_H
#define __7Z_TYPES_H
#define COMPRESS_MF_MT
#include <stddef.h>
#ifdef _XBOX
#include <xtl.h>
#elif defined( _WIN32 )
#if defined( _WIN32 )
#include <windows.h>
#else
#error Unknown platform
#define COMPRESS_MF_MT
#endif
namespace crnlib {
crunch/crunch.cbp
+4 -1
View File
@@ -24,7 +24,9 @@
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
<Add option="-fomit-frame-pointer" />
<Add option="-fexpensive-optimizations" />
<Add option="-O3" />
</Compiler>
<Linker>
<Add option="-s" />
@@ -33,6 +35,7 @@
</Target>
</Build>
<Compiler>
<Add option="-Wextra" />
<Add option="-Wall" />
<Add option="-fexceptions" />
<Add option="-Wno-unused-value" />
crunch/crunch.cpp
+440 -448
View File
File diff suppressed because it is too large Load Diff
example1/example1.cpp
+2 -2
View File
@@ -275,7 +275,7 @@ int main(int argc, char *argv[])
uint f;
for (f = 0; f < cCRNFmtTotal; f++)
{
if (!_stricmp(argv[i], crn_get_format_stringa(static_cast<crn_format>(f))))
if (!_stricmp(argv[i], crn_get_format_string(static_cast<crn_format>(f))))
{
fmt = static_cast<crn_format>(f);
break;
@@ -456,7 +456,7 @@ int main(int argc, char *argv[])
float actual_bitrate;
crn_uint32 output_file_size;
printf("Compressing to %s\n", crn_get_format_stringa(comp_params.m_format));
printf("Compressing to %s\n", crn_get_format_string(comp_params.m_format));
// Now compress to DDS or CRN.
void *pOutput_file_data = crn_compress(comp_params, mip_params, output_file_size, &actual_quality_level, &actual_bitrate);
example3/example3.cpp
+3 -3
View File
@@ -99,7 +99,7 @@ int main(int argc, char *argv[])
for (f = 0; f < cCRNFmtTotal; f++)
{
crn_format actual_fmt = crn_get_fundamental_dxt_format(static_cast<crn_format>(f));
if (!_stricmp(argv[i], crn_get_format_stringa(actual_fmt)))
if (!_stricmp(argv[i], crn_get_format_string(actual_fmt)))
{
fmt = actual_fmt;
break;
@@ -116,7 +116,7 @@ int main(int argc, char *argv[])
uint q;
for (q = 0; q < cCRNDXTQualityTotal; q++)
{
if (!_stricmp(argv[i], crn_get_dxt_quality_stringa(static_cast<crn_dxt_quality>(q))))
if (!_stricmp(argv[i], crn_get_dxt_quality_string(static_cast<crn_dxt_quality>(q))))
{
dxt_quality = static_cast<crn_dxt_quality>(q);
break;
@@ -192,7 +192,7 @@ int main(int argc, char *argv[])
crn_block_compressor_context_t pContext = crn_create_block_compressor(comp_params);
printf("Compressing to %s: ", crn_get_format_stringa(fmt));
printf("Compressing to %s: ", crn_get_format_string(fmt));
int prev_percentage_complete = -1;
for (crn_uint32 block_y = 0; block_y < num_blocks_y; block_y++)
inc/crn_decomp.h
+87 -105
View File
@@ -1,5 +1,6 @@
// File: crn_decomp.h - CRN texture decompressor v1.01
// File: crn_decomp.h - Fast CRN->DXTc texture transcoder header file library
// Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC
// See Copyright Notice and license at the end of this file.
//
// This single header file contains *all* of the code necessary to unpack .CRN files to raw DXTn bits.
// It does NOT depend on the crn compression library.
@@ -8,17 +9,14 @@
// If CRND_INCLUDE_CRND_H is NOT defined, the header is included.
// If CRND_HEADER_FILE_ONLY is NOT defined, the implementation is included.
// Define PLATFORM_NACL if compiling under native client.
//#define PLATFORM_NACL
#ifndef CRND_INCLUDE_CRND_H
#define CRND_INCLUDE_CRND_H
// Include crnlib header - only to bring in some basic some CRN-related types.
// Include crnlib.h (only to bring in some basic CRN-related types).
#include "crnlib.h"
#define CRND_LIB_VERSION 101
#define CRND_VERSION_STRING "01.01"
#define CRND_LIB_VERSION 103
#define CRND_VERSION_STRING "01.03"
#ifdef _DEBUG
#define CRND_BUILD_DEBUG
@@ -37,7 +35,10 @@ namespace crnd
typedef uint32 uint32;
typedef unsigned int uint;
typedef signed int int32;
#ifndef PLATFORM_NACL
#ifdef __GNUC__
typedef unsigned long long uint64;
typedef long long int64;
#else
typedef unsigned __int64 uint64;
typedef signed __int64 int64;
#endif
@@ -129,29 +130,32 @@ namespace crnd
// The crn_file_info.m_struct_size field must be set before calling this function.
bool crnd_validate_file(const void* pData, uint32 data_size, crn_file_info* pFile_info);
// Retrieves texture information from the CRN file.
// The crn_texture_info.m_struct_size field must be set before calling this function.
bool crnd_get_texture_info(const void* pData, uint32 data_size, crn_texture_info* pTexture_info);
// Retrieves mipmap level specific information from the CRN file.
// The crn_level_info.m_struct_size field must be set before calling this function.
bool crnd_get_level_info(const void* pData, uint32 data_size, uint32 level_index, crn_level_info* pLevel_info);
// Transcode/unpack context handle.
typedef void* crnd_unpack_context;
// crnd_unpack_begin() - Decompresses the texture's decoder tables and endpoint/selector palettes.
// Once you call this function, you may call crnd_unpack_level() to unpack one or more mip levels.
// Don't call this once per mip level (unless you absolutely must)!
// This function allocated enough memory to hold: Huffman decompression tables, and the endpoint/selector palettes (color and/or alpha).
// This function allocates enough memory to hold: Huffman decompression tables, and the endpoint/selector palettes (color and/or alpha).
// Worst case allocation is approx. 200k, assuming all palettes contain 8192 entries.
// pData must point to a buffer holding all of the compressed data.
// pData must point to a buffer holding all of the compressed .CRN file data.
// This buffer must be stable until crnd_unpack_end() is called.
// Returns NULL on out of memory or if any of the input parameters are invalid.
// Returns NULL if out of memory, or if any of the input parameters are invalid.
crnd_unpack_context crnd_unpack_begin(const void* pData, uint32 data_size);
// Returns the compressed data associated with a context.
// Returns a pointer to the compressed .CRN data associated with a crnd_unpack_context.
// Returns false if any of the input parameters are invalid.
bool crnd_get_data(crnd_unpack_context pContext, const void** ppData, uint32* pData_size);
// crnd_unpack_level() - Unpacks the specified mipmap level to a destination buffer in cached or write combined memory.
// crnd_unpack_level() - Transcodes the specified mipmap level to a destination buffer in cached or write combined memory.
// pContext - Context created by a call to crnd_unpack_begin().
// ppDst - A pointer to an array of 1 or 6 destination buffer pointers. Cubemaps require an array of 6 pointers, 2D textures require an array of 1 pointer.
// dst_size_in_bytes - Optional size of each destination buffer. Only used for debugging - OK to set to UINT32_MAX.
@@ -166,14 +170,14 @@ namespace crnd
// crnd_unpack_level_segmented() - Unpacks the specified mipmap level from a "segmented" CRN file.
// See the crnd_create_segmented_file() API below.
// Segmented files allow the user to control where the compressed mipmaps are stored.
// Segmented files allow the user to control where the compressed mipmap data is stored.
bool crnd_unpack_level_segmented(
crnd_unpack_context pContext,
const void* pSrc, uint32 src_size_in_bytes,
void** ppDst, uint32 dst_size_in_bytes, uint32 row_pitch_in_bytes,
uint32 level_index);
// crnd_unpack_end() - Frees the decompress tables and unpacked palettes associated with the specified context.
// crnd_unpack_end() - Frees the decompress tables and unpacked palettes associated with the specified unpack context.
// Returns false if the context is NULL, or if it points to an invalid context.
// This function frees all memory associated with the context.
bool crnd_unpack_end(crnd_unpack_context pContext);
@@ -189,7 +193,7 @@ namespace crnd
// Returns the compressed size of the texture's header and compression tables (but no levels).
uint32 crnd_get_segmented_file_size(const void* pData, uint32 data_size);
// Creates a "segmented" CRN texture. The new texture will be created at pBase_data, and will be crnd_get_base_data_size() bytes long.
// Creates a "segmented" CRN texture from a normal CRN texture. The new texture will be created at pBase_data, and will be crnd_get_base_data_size() bytes long.
// base_data_size must be >= crnd_get_base_data_size().
// The base data will contain the CRN header and compression tables, but no mipmap data.
bool crnd_create_segmented_file(const void* pData, uint32 data_size, void* pBase_data, uint base_data_size);
@@ -310,11 +314,10 @@ namespace crnd
#include <stdlib.h>
#include <stdio.h>
#ifndef PLATFORM_NACL
#ifdef WIN32
#include <memory.h>
#else
#include <malloc.h>
#include <process.h>
#endif
#include <stdarg.h>
#include <new> // needed for placement new, _msize, _expand
@@ -531,10 +534,8 @@ namespace crnd
CRND_DEFINE_BUILT_IN_TYPE(unsigned int)
CRND_DEFINE_BUILT_IN_TYPE(long)
CRND_DEFINE_BUILT_IN_TYPE(unsigned long)
#ifndef PLATFORM_NACL
CRND_DEFINE_BUILT_IN_TYPE(__int64)
CRND_DEFINE_BUILT_IN_TYPE(unsigned __int64)
#endif
CRND_DEFINE_BUILT_IN_TYPE(int64)
CRND_DEFINE_BUILT_IN_TYPE(uint64)
CRND_DEFINE_BUILT_IN_TYPE(float)
CRND_DEFINE_BUILT_IN_TYPE(double)
CRND_DEFINE_BUILT_IN_TYPE(long double)
@@ -1275,32 +1276,32 @@ namespace crnd
component_type c[cNumComps];
};
color_quad()
inline color_quad()
{
}
color_quad(eClear) :
inline color_quad(eClear) :
r(0), g(0), b(0), a(0)
{
}
color_quad(const color_quad& other) :
inline color_quad(const color_quad& other) :
r(other.r), g(other.g), b(other.b), a(other.a)
{
}
color_quad(parameter_type y, parameter_type alpha = component_traits::cMax)
inline color_quad(parameter_type y, parameter_type alpha = component_traits::cMax)
{
set(y, alpha);
}
color_quad(parameter_type red, parameter_type green, parameter_type blue, parameter_type alpha = component_traits::cMax)
inline color_quad(parameter_type red, parameter_type green, parameter_type blue, parameter_type alpha = component_traits::cMax)
{
set(red, green, blue, alpha);
}
template<typename other_component_type, typename other_parameter_type>
color_quad(const color_quad<other_component_type, other_parameter_type>& other) :
inline color_quad(const color_quad<other_component_type, other_parameter_type>& other) :
r(clamp(other.r)), g(clamp(other.g)), b(clamp(other.b)), a(clamp(other.a))
{
}
@@ -1313,7 +1314,7 @@ namespace crnd
a = 0;
}
color_quad& operator= (const color_quad& other)
inline color_quad& operator= (const color_quad& other)
{
r = other.r;
g = other.g;
@@ -1323,7 +1324,7 @@ namespace crnd
}
template<typename other_component_type, typename other_parameter_type>
color_quad& operator=(const color_quad<other_component_type, other_parameter_type>& other)
inline color_quad& operator=(const color_quad<other_component_type, other_parameter_type>& other)
{
r = clamp(other.r);
g = clamp(other.g);
@@ -1332,7 +1333,7 @@ namespace crnd
return *this;
}
color_quad& set(parameter_type y, parameter_type alpha = component_traits::cMax)
inline color_quad& set(parameter_type y, parameter_type alpha = component_traits::cMax)
{
y = clamp(y);
r = static_cast<component_type>(y);
@@ -1342,7 +1343,7 @@ namespace crnd
return *this;
}
color_quad& set(parameter_type red, parameter_type green, parameter_type blue, parameter_type alpha = component_traits::cMax)
inline color_quad& set(parameter_type red, parameter_type green, parameter_type blue, parameter_type alpha = component_traits::cMax)
{
r = static_cast<component_type>(clamp(red));
g = static_cast<component_type>(clamp(green));
@@ -1351,7 +1352,7 @@ namespace crnd
return *this;
}
color_quad& set_noclamp_rgba(parameter_type red, parameter_type green, parameter_type blue, parameter_type alpha)
inline color_quad& set_noclamp_rgba(parameter_type red, parameter_type green, parameter_type blue, parameter_type alpha)
{
r = static_cast<component_type>(red);
g = static_cast<component_type>(green);
@@ -1360,7 +1361,7 @@ namespace crnd
return *this;
}
color_quad& set_noclamp_rgb(parameter_type red, parameter_type green, parameter_type blue)
inline color_quad& set_noclamp_rgb(parameter_type red, parameter_type green, parameter_type blue)
{
r = static_cast<component_type>(red);
g = static_cast<component_type>(green);
@@ -1368,14 +1369,14 @@ namespace crnd
return *this;
}
static parameter_type get_min_comp() { return component_traits::cMin; }
static parameter_type get_max_comp() { return component_traits::cMax; }
static bool get_comps_are_signed() { return component_traits::cSigned; }
static inline parameter_type get_min_comp() { return component_traits::cMin; }
static inline parameter_type get_max_comp() { return component_traits::cMax; }
static inline bool get_comps_are_signed() { return component_traits::cSigned; }
component_type operator[] (uint32 i) const { CRND_ASSERT(i < cNumComps); return c[i]; }
component_type& operator[] (uint32 i) { CRND_ASSERT(i < cNumComps); return c[i]; }
inline component_type operator[] (uint32 i) const { CRND_ASSERT(i < cNumComps); return c[i]; }
inline component_type& operator[] (uint32 i) { CRND_ASSERT(i < cNumComps); return c[i]; }
color_quad& set_component(uint32 i, parameter_type f)
inline color_quad& set_component(uint32 i, parameter_type f)
{
CRND_ASSERT(i < cNumComps);
@@ -1384,14 +1385,14 @@ namespace crnd
return *this;
}
color_quad& clamp(const color_quad& l, const color_quad& h)
inline color_quad& clamp(const color_quad& l, const color_quad& h)
{
for (uint32 i = 0; i < cNumComps; i++)
c[i] = static_cast<component_type>(math::clamp<parameter_type>(c[i], l[i], h[i]));
return *this;
}
color_quad& clamp(parameter_type l, parameter_type h)
inline color_quad& clamp(parameter_type l, parameter_type h)
{
for (uint32 i = 0; i < cNumComps; i++)
c[i] = static_cast<component_type>(math::clamp<parameter_type>(c[i], l, h));
@@ -1410,22 +1411,22 @@ namespace crnd
return static_cast<parameter_type>((13938U * r + 46869U * g + 4729U * b + 32768U) >> 16U);
}
uint32 squared_distance(const color_quad& c, bool alpha = true) const
inline uint32 squared_distance(const color_quad& c, bool alpha = true) const
{
return math::square(r - c.r) + math::square(g - c.g) + math::square(b - c.b) + (alpha ? math::square(a - c.a) : 0);
}
bool rgb_equals(const color_quad& rhs) const
inline bool rgb_equals(const color_quad& rhs) const
{
return (r == rhs.r) && (g == rhs.g) && (b == rhs.b);
}
bool operator== (const color_quad& rhs) const
inline bool operator== (const color_quad& rhs) const
{
return (r == rhs.r) && (g == rhs.g) && (b == rhs.b) && (a == rhs.a);
}
bool operator< (const color_quad& rhs) const
inline bool operator< (const color_quad& rhs) const
{
for (uint32 i = 0; i < cNumComps; i++)
{
@@ -1437,76 +1438,76 @@ namespace crnd
return false;
}
color_quad& operator+= (const color_quad& other)
inline color_quad& operator+= (const color_quad& other)
{
for (uint32 i = 0; i < 4; i++)
c[i] = static_cast<component_type>(clamp(c[i] + other.c[i]));
return *this;
}
color_quad& operator-= (const color_quad& other)
inline color_quad& operator-= (const color_quad& other)
{
for (uint32 i = 0; i < 4; i++)
c[i] = static_cast<component_type>(clamp(c[i] - other.c[i]));
return *this;
}
color_quad& operator*= (parameter_type v)
inline color_quad& operator*= (parameter_type v)
{
for (uint32 i = 0; i < 4; i++)
c[i] = static_cast<component_type>(clamp(c[i] * v));
return *this;
}
color_quad& operator/= (parameter_type v)
inline color_quad& operator/= (parameter_type v)
{
for (uint32 i = 0; i < 4; i++)
c[i] = static_cast<component_type>(c[i] / v);
return *this;
}
color_quad get_swizzled(uint32 x, uint32 y, uint32 z, uint32 w) const
inline color_quad get_swizzled(uint32 x, uint32 y, uint32 z, uint32 w) const
{
CRND_ASSERT((x | y | z | w) < 4);
return color_quad(c[x], c[y], c[z], c[w]);
}
friend color_quad operator+ (const color_quad& lhs, const color_quad& rhs)
inline friend color_quad operator+ (const color_quad& lhs, const color_quad& rhs)
{
color_quad result(lhs);
result += rhs;
return result;
}
friend color_quad operator- (const color_quad& lhs, const color_quad& rhs)
inline friend color_quad operator- (const color_quad& lhs, const color_quad& rhs)
{
color_quad result(lhs);
result -= rhs;
return result;
}
friend color_quad operator* (const color_quad& lhs, parameter_type v)
inline friend color_quad operator* (const color_quad& lhs, parameter_type v)
{
color_quad result(lhs);
result *= v;
return result;
}
friend color_quad operator/ (const color_quad& lhs, parameter_type v)
friend inline color_quad operator/ (const color_quad& lhs, parameter_type v)
{
color_quad result(lhs);
result /= v;
return result;
}
friend color_quad operator* (parameter_type v, const color_quad& rhs)
friend inline color_quad operator* (parameter_type v, const color_quad& rhs)
{
color_quad result(rhs);
result *= v;
return result;
}
uint32 get_min_component_index(bool alpha = true) const
inline uint32 get_min_component_index(bool alpha = true) const
{
uint32 index = 0;
uint32 limit = alpha ? cNumComps : (cNumComps - 1);
@@ -1516,7 +1517,7 @@ namespace crnd
return index;
}
uint32 get_max_component_index(bool alpha = true) const
inline uint32 get_max_component_index(bool alpha = true) const
{
uint32 index = 0;
uint32 limit = alpha ? cNumComps : (cNumComps - 1);
@@ -1526,24 +1527,24 @@ namespace crnd
return index;
}
void get_float4(float* pDst)
inline void get_float4(float* pDst)
{
for (uint32 i = 0; i < 4; i++)
pDst[i] = ((*this)[i] - component_traits::cMin) / float(component_traits::cMax - component_traits::cMin);
}
void get_float3(float* pDst)
inline void get_float3(float* pDst)
{
for (uint32 i = 0; i < 3; i++)
pDst[i] = ((*this)[i] - component_traits::cMin) / float(component_traits::cMax - component_traits::cMin);
}
static color_quad make_black()
static inline color_quad make_black()
{
return color_quad(0, 0, 0, component_traits::cMax);
}
static color_quad make_white()
static inline color_quad make_white()
{
return color_quad(component_traits::cMax, component_traits::cMax, component_traits::cMax, component_traits::cMax);
}
@@ -2009,11 +2010,7 @@ namespace crnd
uint32 decode_bits(uint32 num_bits);
uint32 decode(const static_huffman_data_model& model);
#ifdef PLATFORM_NACL
uint32 stop_decoding();
#else
uint64 stop_decoding();
#endif
public:
const uint8* m_pDecode_buf;
@@ -2052,7 +2049,7 @@ namespace crnd
crnd_output_debug_string(buf);
printf(buf);
puts(buf);
if (crnd_is_debugger_present())
crnd_debug_break();
@@ -2421,12 +2418,14 @@ namespace crnd
p_new = ::malloc(size);
if (pActual_size)
#ifdef PLATFORM_NACL
*pActual_size = p_new ? malloc_usable_size(p_new) : 0;
#else
{
#ifdef WIN32
*pActual_size = p_new ? ::_msize(p_new) : 0;
#else
*pActual_size = p_new ? malloc_usable_size(p_new) : 0;
#endif
}
}
else if (!size)
{
::free(p);
@@ -2438,10 +2437,10 @@ namespace crnd
else
{
void* p_final_block = p;
#ifdef PLATFORM_NACL
p_new = ::realloc(p, size);
#else
#ifdef WIN32
p_new = ::_expand(p, size);
#else
p_new = NULL;
#endif
if (p_new)
@@ -2455,12 +2454,14 @@ namespace crnd
}
if (pActual_size)
#ifdef PLATFORM_NACL
*pActual_size = ::malloc_usable_size(p_final_block);
#else
{
#ifdef WIN32
*pActual_size = ::_msize(p_final_block);
#else
*pActual_size = ::malloc_usable_size(p_final_block);
#endif
}
}
return p_new;
}
@@ -2468,10 +2469,10 @@ namespace crnd
static size_t crnd_default_msize(void* p, void* pUser_data)
{
pUser_data;
#ifdef PLATFORM_NACL
return p ? malloc_usable_size(p) : 0;
#else
#ifdef WIN32
return p ? _msize(p) : 0;
#else
return p ? malloc_usable_size(p) : 0;
#endif
}
@@ -2722,7 +2723,7 @@ namespace crnd
return false;
if ((pHeader->m_levels < 1) || (pHeader->m_levels > utils::compute_max_mips(pHeader->m_width, pHeader->m_height)))
return false;
if ((pHeader->m_format < cCRNFmtDXT1) || (pHeader->m_format >= cCRNFmtTotal))
if (((int)pHeader->m_format < cCRNFmtDXT1) || ((int)pHeader->m_format >= cCRNFmtTotal))
return false;
if (pFile_info)
@@ -3277,24 +3278,6 @@ uint32 symbol_codec::decode(const static_huffman_data_model& model)
return sym;
}
#ifdef PLATFORM_NACL
uint32 symbol_codec::stop_decoding()
{
#if 0
uint32 i = get_bits(4);
uint32 k = get_bits(3);
i, k;
CRND_ASSERT((i == 15) && (k == 3));
#endif
uint32 n = m_pDecode_buf_next - m_pDecode_buf;
return n;
}
#else
uint64 symbol_codec::stop_decoding()
{
#if 0
@@ -3304,11 +3287,11 @@ uint32 symbol_codec::decode(const static_huffman_data_model& model)
CRND_ASSERT((i == 15) && (k == 3));
#endif
uint64 n = m_pDecode_buf_next - m_pDecode_buf;
uint64 n = static_cast<uint64>(m_pDecode_buf_next - m_pDecode_buf);
return n;
}
#endif
} // namespace crnd
// File: crnd_dxt_hc_common.cpp
@@ -3591,10 +3574,9 @@ namespace crnd
namespace crnd
{
#if CRND_CREATE_BYTE_STREAMS
static void write_array_to_file(const wchar_t* pFilename, const vector<uint8>& buf)
static void write_array_to_file(const char* pFilename, const vector<uint8>& buf)
{
FILE* pFile;
_wfopen_s(&pFile, pFilename, L"wb");
FILE* pFile = fopen(pFilename, "wb");
fwrite(&buf[0], buf.size(), 1, pFile);
fclose(pFile);
}
@@ -3659,7 +3641,7 @@ namespace crnd
class crn_unpacker
{
public:
crn_unpacker() :
inline crn_unpacker() :
m_magic(cMagicValue),
m_pData(NULL),
m_data_size(0),
@@ -3667,7 +3649,7 @@ namespace crnd
{
}
~crn_unpacker()
inline ~crn_unpacker()
{
m_magic = 0;
}
inc/crnlib.h
+105 -28
View File
@@ -2,8 +2,8 @@
// Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC
// See copyright notice and license at the end of this file.
//
// This header file contains the public crnlib declarations for DXTn and
// clustered DXTn compression/decompression.
// This header file contains the public crnlib declarations for DXTn,
// clustered DXTn, and CRN compression/decompression.
//
// Note: This library does NOT need to be linked into your game executable if
// all you want to do is transcode .CRN files to raw DXTn bits at run-time.
@@ -13,7 +13,14 @@
#ifndef CRNLIB_H
#define CRNLIB_H
#define CRNLIB_VERSION 101
#ifdef _MSC_VER
#pragma warning (disable: 4127) // conditional expression is constant
#endif
#define CRNLIB_VERSION 103
#define CRNLIB_SUPPORT_ATI_COMPRESS 0
#define CRNLIB_SUPPORT_SQUISH 0
typedef unsigned char crn_uint8;
typedef unsigned short crn_uint16;
@@ -72,7 +79,7 @@ enum crn_format
// Various library/file format limits.
enum crn_limits
{
// Max. mipmap level resolution on any axis (will be doubled to 8k in next release).
// Max. mipmap level resolution on any axis.
cCRNMaxLevelResolution = 4096,
cCRNMinPaletteSize = 8,
@@ -158,19 +165,27 @@ enum crn_dxt_quality
cCRNDXTQualityForceDWORD = 0xFFFFFFFF
};
// Which DXTn compressor to use when compressing to .DDS.
// Which DXTn compressor to use when compressing to plain (non-clustered) .DDS.
enum crn_dxt_compressor_type
{
cCRNDXTCompressorCRN,
cCRNDXTCompressorCRNF,
cCRNDXTCompressorRYG,
cCRNDXTCompressorCRN, // Use crnlib's DXTc block compressor (default, highest quality, comparable or better than ati_compress or squish)
cCRNDXTCompressorCRNF, // Use crnlib's "fast" DXTc block compressor
cCRNDXTCompressorRYG, // Use RYG's DXTc block compressor (low quality, but very fast)
#if CRNLIB_SUPPORT_ATI_COMPRESS
cCRNDXTCompressorATI,
#endif
#if CRNLIB_SUPPORT_SQUISH
cCRNDXTCompressorSquish,
#endif
cCRNTotalDXTCompressors,
cCRNDXTCompressorForceDWORD = 0xFFFFFFFF
};
// Compression will stop prematurely (and fail) if the callback returns false.
// Progress callback function.
// Processing will stop prematurely (and fail) if the callback returns false.
// phase_index, total_phases - high level progress
// subphase_index, total_subphases - progress within current phase
typedef crn_bool (*crn_progress_callback_func)(crn_uint32 phase_index, crn_uint32 total_phases, crn_uint32 subphase_index, crn_uint32 total_subphases, void* pUser_data_ptr);
@@ -180,6 +195,7 @@ struct crn_comp_params
{
inline crn_comp_params() { clear(); }
// Clear struct to default parameters.
inline void clear()
{
m_size_of_obj = sizeof(*this);
@@ -216,6 +232,43 @@ struct crn_comp_params
m_pProgress_func_data = NULL;
}
inline bool operator== (const crn_comp_params& rhs) const
{
#define CRNLIB_COMP(x) do { if ((x) != (rhs.x)) return false; } while(0)
CRNLIB_COMP(m_size_of_obj);
CRNLIB_COMP(m_file_type);
CRNLIB_COMP(m_faces);
CRNLIB_COMP(m_width);
CRNLIB_COMP(m_height);
CRNLIB_COMP(m_levels);
CRNLIB_COMP(m_format);
CRNLIB_COMP(m_flags);
CRNLIB_COMP(m_target_bitrate);
CRNLIB_COMP(m_quality_level);
CRNLIB_COMP(m_dxt1a_alpha_threshold);
CRNLIB_COMP(m_dxt_quality);
CRNLIB_COMP(m_dxt_compressor_type);
CRNLIB_COMP(m_alpha_component);
CRNLIB_COMP(m_crn_adaptive_tile_color_psnr_derating);
CRNLIB_COMP(m_crn_adaptive_tile_alpha_psnr_derating);
CRNLIB_COMP(m_crn_color_endpoint_palette_size);
CRNLIB_COMP(m_crn_color_selector_palette_size);
CRNLIB_COMP(m_crn_alpha_endpoint_palette_size);
CRNLIB_COMP(m_crn_alpha_selector_palette_size);
CRNLIB_COMP(m_num_helper_threads);
CRNLIB_COMP(m_userdata0);
CRNLIB_COMP(m_userdata1);
CRNLIB_COMP(m_pProgress_func);
CRNLIB_COMP(m_pProgress_func_data);
for (crn_uint32 f = 0; f < cCRNMaxFaces; f++)
for (crn_uint32 l = 0; l < cCRNMaxLevels; l++)
CRNLIB_COMP(m_pImages[f][l]);
#undef CRNLIB_COMP
return true;
}
// Returns true if the input parameters are reasonable.
inline bool check() const
{
@@ -263,7 +316,7 @@ struct crn_comp_params
// Target bitrate - if non-zero, the compressor will use an interpolative search to find the
// highest quality level that is <= the target bitrate. If it fails to find a bitrate high enough, it'll
// disabling adaptive block sizes (cCRNCompFlagHierarchical flag) and try again. This process can be pretty slow.
// try disabling adaptive block sizes (cCRNCompFlagHierarchical flag) and redo the search. This process can be pretty slow.
float m_target_bitrate;
// Desired quality level.
@@ -288,7 +341,7 @@ struct crn_comp_params
crn_uint32 m_crn_alpha_endpoint_palette_size; // [cCRNMinPaletteSize,cCRNMaxPaletteSize]
crn_uint32 m_crn_alpha_selector_palette_size; // [cCRNMinPaletteSize,cCRNMaxPaletteSize]
// Number of helper threads to create to assist the compressor. 0=no threading.
// Number of helper threads to create during compression. 0=no threading.
crn_uint32 m_num_helper_threads;
// CRN userdata0 and userdata1 members, which are written directly to the header of the output file.
@@ -303,18 +356,18 @@ struct crn_comp_params
// Mipmap generator's mode.
enum crn_mip_mode
{
cCRNMipModeUseSourceOrGenerateMips,
cCRNMipModeUseSourceMips,
cCRNMipModeGenerateMips,
cCRNMipModeNoMips,
cCRNMipModeUseSourceOrGenerateMips, // Use source texture's mipmaps if it has any, otherwise generate new mipmaps
cCRNMipModeUseSourceMips, // Use source texture's mipmaps if it has any, otherwise the output has no mipmaps
cCRNMipModeGenerateMips, // Always generate new mipmaps
cCRNMipModeNoMips, // Output texture has no mipmaps
cCRNMipModeTotal,
cCRNModeForceDWORD = 0xFFFFFFFF
};
const wchar_t* crn_get_mip_mode_desc(crn_mip_mode m);
const wchar_t* crn_get_mip_mode_name(crn_mip_mode m);
const char* crn_get_mip_mode_desc(crn_mip_mode m);
const char* crn_get_mip_mode_name(crn_mip_mode m);
// Mipmap generator's filter kernel.
enum crn_mip_filter
@@ -323,7 +376,7 @@ enum crn_mip_filter
cCRNMipFilterTent,
cCRNMipFilterLanczos4,
cCRNMipFilterMitchell,
cCRNMipFilterKaiser,
cCRNMipFilterKaiser, // Kaiser=default mipmap filter
cCRNMipFilterTotal,
@@ -347,7 +400,7 @@ enum crn_scale_mode
cCRNSMForceDWORD = 0xFFFFFFFF
};
const wchar_t* crn_get_scale_mode_desc(crn_scale_mode sm);
const char* crn_get_scale_mode_desc(crn_scale_mode sm);
// Mipmap generator parameters.
struct crn_mipmap_params
@@ -361,6 +414,7 @@ struct crn_mipmap_params
m_filter = cCRNMipFilterKaiser;
m_gamma_filtering = true;
m_gamma = 2.2f;
// Default "blurriness" factor of .9 actually sharpens the output a little.
m_blurriness = .9f;
m_renormalize = false;
m_tiled = false;
@@ -383,6 +437,32 @@ struct crn_mipmap_params
inline bool check() const { return true; }
inline bool operator== (const crn_mipmap_params& rhs) const
{
#define CRNLIB_COMP(x) do { if ((x) != (rhs.x)) return false; } while(0)
CRNLIB_COMP(m_size_of_obj);
CRNLIB_COMP(m_mode);
CRNLIB_COMP(m_filter);
CRNLIB_COMP(m_gamma_filtering);
CRNLIB_COMP(m_gamma);
CRNLIB_COMP(m_blurriness);
CRNLIB_COMP(m_renormalize);
CRNLIB_COMP(m_tiled);
CRNLIB_COMP(m_max_levels);
CRNLIB_COMP(m_min_mip_size);
CRNLIB_COMP(m_scale_mode);
CRNLIB_COMP(m_scale_x);
CRNLIB_COMP(m_scale_y);
CRNLIB_COMP(m_window_left);
CRNLIB_COMP(m_window_top);
CRNLIB_COMP(m_window_right);
CRNLIB_COMP(m_window_bottom);
CRNLIB_COMP(m_clamp_scale);
CRNLIB_COMP(m_clamp_width);
CRNLIB_COMP(m_clamp_height);
return true;
#undef CRNLIB_COMP
}
crn_uint32 m_size_of_obj;
crn_mip_mode m_mode;
@@ -444,7 +524,7 @@ void crn_free_block(void *pBlock);
// The output file is a standard DX9 format DDS file, except the compressor assumes you will be later losslessly compressing the DDS output file using the LZMA algorithm.
// A texture is defined as an array of 1 or 6 "faces" (6 faces=cubemap), where each "face" consists of between [1,cCRNMaxLevels] mipmap levels.
// Mipmap levels are simple 32-bit 2D images with a pitch of width*sizeof(uint32), arranged in the usual raster order (top scanline first).
// The image pixels may be grayscale (YYYX), grayscale/alpha (YYYA), 24-bit RGBX, or 32-bit RGBA colors (where "X"=don't care).
// The image pixels may be grayscale (YYYX bytes in memory), grayscale/alpha (YYYA in memory), 24-bit (RGBX in memory), or 32-bit (RGBA) colors (where "X"=don't care).
// RGB color data is generally assumed to be in the sRGB colorspace. If not, be sure to clear the "cCRNCompFlagPerceptual" in the crn_comp_params struct!
void *crn_compress(const crn_comp_params &comp_params, crn_uint32 &compressed_size, crn_uint32 *pActual_quality_level = NULL, float *pActual_bitrate = NULL);
@@ -460,8 +540,8 @@ void *crn_compress(const crn_comp_params &comp_params, const crn_mipmap_params &
void *crn_decompress_crn_to_dds(const void *pCRN_file_data, crn_uint32 &file_size);
// Decompresses an entire DDS file in any supported format to uncompressed 32-bit/pixel image(s).
// See the crnlib::pixel_format in inc/dds_defs.h for a list of the supported DDS formats.
// You are responsible for freeing each image, either by calling crn_free_all_images() or manually calling crn_free_block() on each image pointer.
// See the crnlib::pixel_format enum in inc/dds_defs.h for a list of the supported DDS formats.
// You are responsible for freeing each image block, either by calling crn_free_all_images() or manually calling crn_free_block() on each image pointer.
struct crn_texture_desc
{
crn_uint32 m_faces;
@@ -493,16 +573,13 @@ crn_format crn_get_fundamental_dxt_format(crn_format fmt);
// -------- String helpers.
// Converts a crn_file_type to a string.
const wchar_t* crn_get_file_type_ext(crn_file_type file_type);
const char* crn_get_file_type_exta(crn_file_type file_type);
const char* crn_get_file_type_ext(crn_file_type file_type);
// Converts a crn_format to a string.
const char* crn_get_format_stringa(crn_format fmt);
const wchar_t* crn_get_format_string(crn_format fmt);
const char* crn_get_format_string(crn_format fmt);
// Converts a crn_dxt_quality to a string.
const wchar_t* crn_get_dxt_quality_string(crn_dxt_quality q);
const char* crn_get_dxt_quality_stringa(crn_dxt_quality q);
const char* crn_get_dxt_quality_string(crn_dxt_quality q);
// -------- Low-level DXTn 4x4 block compressor API
readme.txt
+9 -1
View File
@@ -1,4 +1,4 @@
crunch/crnlib v1.01 - Advanced DXTn texture compression library
crunch/crnlib v1.03 PRERELEASE - Advanced DXTn texture compression library
Copyright (C) 2010-2012 Rich Geldreich and Tenacious Software LLC
For bugs or support contact Rich Geldreich <richgel99@gmail.com>.
@@ -12,6 +12,14 @@ originally written by Igor Pavlov (LZMA) and RYG (crn_ryg_dxt*).
If you use this software in a product, an acknowledgment in the product
documentation would be highly appreciated but is not required.
New for v1.03 [4/26/12]: crnlib more portable, Linux Port
------------------------------------------------
v1.03 has been ported to Linux. It's still a work in progress. A few features
of the command line tool don't work under Linux yet (such as -timestamp),
but the core functionality (compression/decompression/transcoding) should work
OK. I'm currently testing crnlib/crunch with Codeblocks 10.05 under Ubuntu x86.
Overview
--------