static bool loadImage(nv::Image & image, const char * fileName)
{
if (nv::strCaseDiff(nv::Path::extension(fileName), ".dds") == 0)
{
nv::DirectDrawSurface dds(fileName);
if (!dds.isValid())
{
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", fileName);
return false;
}
dds.mipmap(&image, 0, 0); // get first image
}
else
{
// Regular image.
if (!image.load(fileName))
{
fprintf(stderr, "The file '%s' is not a supported image type.\n", fileName);
return false;
}
}
return true;
}
static int detection_range_tests(super_tone_rx_state_t *super)
{
int16_t amp[SAMPLES_PER_CHUNK];
int i;
int j;
int x;
uint32_t phase;
int32_t phase_inc;
int scale;
printf("Detection range tests\n");
super_tone_rx_tone_callback(super, wakeup, (void *) "test");
phase = 0;
phase_inc = dds_phase_rate(440.0f);
for (level = -80; level < 0; level++)
{
printf("Testing at %ddBm0\n", level);
scale = dds_scaling_dbm0(level);
for (j = 0; j < 100; j++)
{
for (i = 0; i < SAMPLES_PER_CHUNK; i++)
amp[i] = (dds(&phase, phase_inc)*scale) >> 15;
x = super_tone_rx(super, amp, SAMPLES_PER_CHUNK);
}
}
return 0;
}
SPAN_DECLARE(int) swept_tone(swept_tone_state_t *s, int16_t amp[], int max_len)
{
int i;
int len;
int chunk_len;
for (len = 0; len < max_len; )
{
chunk_len = max_len - len;
if (chunk_len > s->duration - s->pos)
chunk_len = s->duration - s->pos;
for (i = len; i < len + chunk_len; i++)
{
amp[i] = (dds(&s->phase, s->current_phase_inc)*s->scale) >> 15;
s->current_phase_inc += s->phase_inc_step;
}
len += chunk_len;
s->pos += chunk_len;
if (s->pos >= s->duration)
{
if (!s->repeating)
break;
s->pos = 0;
s->current_phase_inc = s->starting_phase_inc;
}
}
return len;
}
auto_ptr<char> TIGER::decodePCD9(auto_ptr<char> dataStream, uint32_t &size, string &path, string &name)
{
PCD9_Header *table = (PCD9_Header*)dataStream.get();
switch (table->format)
{
case '1TXD': //DXT1
case '3TXD': //DXT3
case '5TXD': //DXT5
{
string fullpath = path + "\\" + name + ".dds";
if ((currentMode == UNPACK) && (writeDDS))
{
DDS dds(table->type, table->height, table->width, 0, table->mipmap + 1, table->format, (char*)dataStream.get() + sizeof(PCD9_Header), size - sizeof(PCD9_Header));
cout << "Writing \"" << fullpath << "\"\n";
dds.serialization(path + "\\" + name + ".dds");
size = 0;
}
else if (currentMode == PACK)
{
DDS dds;
if (!dds.deserialization(fullpath))
{
cout << "\nError opening dds file.\n";
exit(-1);
}
PCD9_Header tmp = *table;
size = dds.dataSize + sizeof(PCD9_Header);
dataStream.reset(new char[size]);
table = (PCD9_Header*)dataStream.get();
memcpy((char*)table + sizeof(PCD9_Header), dds.data, dds.dataSize);
*table = tmp;
}
return dataStream;
}
break;
case 0x15:
{
string fullpath = path + "\\" + name + ".raw";
if (currentMode == UNPACK)
{
cout << "Writing \"" << fullpath << "\"\n";
fstream rawFile(fullpath, ios_base::binary | ios_base::out);
if (!rawFile.is_open())
exit(errno);
rawFile.write((char*)dataStream.get() + sizeof(PCD9_Header), size - sizeof(PCD9_Header));
rawFile.close();
}
size = 0;
return dataStream;
}
break;
default:
break;
}
cout << "Something went wrong." << __FILE__ << "," << __FUNCTIONW__ << "," << __LINE__ << "\n";
return dataStream;
}
JNIEXPORT jint JNICALL Java_edu_berkeley_bid_CUMATD_dds
(JNIEnv *env, jobject obj, jint nrows, jint nnz,
jobject jA, jobject jB, jobject jCir, jobject jCic, jobject jP)
{
double *A = (double*)getPointer(env, jA);
double *B = (double*)getPointer(env, jB);
double *P = (double*)getPointer(env, jP);
int *Cir = (int*)getPointer(env, jCir);
int *Cic = (int*)getPointer(env, jCic);
return dds(nrows, nnz, A, B, Cir, Cic, P);
}
//
// 8. Full Solid Sphere:
//
// G4Orb(const G4String& pName,
// G4double pRmax)
void
doOrb( const std::string& name, double radius )
{
G4Orb g4(name,radius);
DDI::Orb dd(radius);
DDI::Sphere dds(0.*deg, radius, 0.*deg, 360.*deg, 0., 180.*deg);
DDOrb ddo = DDSolidFactory::orb(name, radius);
dd.stream(std::cout);
std::cout << std::endl;
std::cout << "\tg4 volume = " << g4.GetCubicVolume()/cm3 <<" cm3" << std::endl;
std::cout << "\tdd volume = " << dd.volume()/cm3 << " cm3"<< std::endl;
std::cout << "\tDD Information: " << ddo << " vol= " << ddo.volume() << std::endl;
std::cout << "\tcross check sphere " << std::endl;
dds.stream(std::cout);
std::cout << std::endl;
std::cout << "\tsphere volume = " << dds.volume()/cm3 << " cm3" << std::endl;
}
void createDDS(const std::string& inputFile, const std::string& outputFile, unsigned int format)
{
// Load the image
SDL_Surface* image = IMG_Load(inputFile.c_str());
if (!image)
{
printf("...unable to load image %s\n", inputFile.c_str());
return;
}
CDDSImage dds(image->w, image->h, format);
CompressToDDS(image, format, dds);
// write to a DDS file
dds.WriteFile(outputFile);
SDL_FreeSurface(image);
}
int main(int argc, char *argv[])
{
MyAssertHandler assertHandler;
MyMessageHandler messageHandler;
if (argc != 2)
{
printf("NVIDIA Texture Tools - Copyright NVIDIA Corporation 2007\n\n");
printf("usage: nvddsinfo ddsfile\n\n");
return 1;
}
// Load surface.
nv::DirectDrawSurface dds(argv[1]);
if (!dds.isValid())
{
printf("The file '%s' is not a valid DDS file.\n", argv[1]);
return 1;
}
dds.printInfo();
return 0;
}
struct ImBuf *imb_load_dds(unsigned char *mem, size_t size, int flags)
{
struct ImBuf * ibuf = 0;
DirectDrawSurface dds(mem, size); /* reads header */
unsigned char bits_per_pixel;
unsigned int *rect;
Image img;
unsigned int numpixels = 0;
int col;
unsigned char *cp = (unsigned char *) &col;
Color32 pixel;
Color32 *pixels = 0;
if(!imb_is_a_dds(mem))
return (0);
/* check if DDS is valid and supported */
if (!dds.isValid()) {
/* no need to print error here, just testing if it is a DDS */
if(flags & IB_test)
return (0);
printf("DDS: not valid; header follows\n");
dds.printInfo();
return(0);
}
if (!dds.isSupported()) {
printf("DDS: format not supported\n");
return(0);
}
if ((dds.width() > 65535) || (dds.height() > 65535)) {
printf("DDS: dimensions too large\n");
return(0);
}
/* convert DDS into ImBuf */
// TODO use the image RGB or RGBA tag to determine the bits per pixel
if (dds.hasAlpha()) bits_per_pixel = 32;
else bits_per_pixel = 24;
ibuf = IMB_allocImBuf(dds.width(), dds.height(), bits_per_pixel, 0);
if (ibuf == 0) return(0); /* memory allocation failed */
ibuf->ftype = DDS;
ibuf->profile = IB_PROFILE_SRGB;
if ((flags & IB_test) == 0) {
if (!imb_addrectImBuf(ibuf)) return(ibuf);
if (ibuf->rect == 0) return(ibuf);
rect = ibuf->rect;
dds.mipmap(&img, 0, 0); /* load first face, first mipmap */
pixels = img.pixels();
numpixels = dds.width() * dds.height();
cp[3] = 0xff; /* default alpha if alpha channel is not present */
for (unsigned int i = 0; i < numpixels; i++) {
pixel = pixels[i];
cp[0] = pixel.r; /* set R component of col */
cp[1] = pixel.g; /* set G component of col */
cp[2] = pixel.b; /* set B component of col */
if (bits_per_pixel == 32)
cp[3] = pixel.a; /* set A component of col */
rect[i] = col;
}
IMB_flipy(ibuf);
}
return(ibuf);
}
int main(int argc, char *argv[])
{
MyAssertHandler assertHandler;
MyMessageHandler messageHandler;
bool forcenormal = false;
bool mipmaps = false;
bool faces = false;
bool savePNG = false;
nv::Path input;
nv::Path output;
// Parse arguments.
for (int i = 1; i < argc; i++)
{
if (strcmp("-forcenormal", argv[i]) == 0)
{
forcenormal = true;
}
else if (strcmp("-mipmaps", argv[i]) == 0)
{
mipmaps = true;
}
else if (strcmp("-faces", argv[i]) == 0)
{
faces = true;
}
else if (strcmp("-format", argv[i]) == 0)
{
if (i+1 == argc) break;
i++;
#ifdef HAVE_PNG
if (strcmp("png", argv[i]) == 0) savePNG = true;
else
#endif
if (strcmp("tga", argv[i]) == 0) savePNG = false;
else
{
fprintf(stderr, "Unsupported output format '%s', defaulting to 'tga'.\n", argv[i]);
savePNG = false;
}
}
else if (argv[i][0] != '-')
{
input = argv[i];
if (i+1 < argc && argv[i+1][0] != '-')
{
output = argv[i+1];
}
else
{
output.copy(input.str());
}
break;
}
}
printf("NVIDIA Texture Tools - Copyright NVIDIA Corporation 2007\n\n");
if (input.isNull())
{
printf("usage: nvdecompress [options] infile [outfile]\n\n");
printf("Note: the .tga or .png extension is forced on outfile\n\n");
printf("Input options:\n");
printf(" -forcenormal \tThe input image is a normal map.\n");
printf(" -mipmaps \tDecompress all mipmaps.\n");
printf(" -faces \tDecompress all faces.\n");
printf(" -format <format>\tOutput format ('tga' or 'png').\n");
return 1;
}
// Load surface.
nv::DirectDrawSurface dds(input.str());
if (!dds.isValid())
{
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str());
return 1;
}
if (!dds.isSupported() || dds.isTexture3D())
{
fprintf(stderr, "The file '%s' is not a supported DDS file.\n", input.str());
return 1;
}
uint faceCount;
if (dds.isTexture2D())
{
faceCount = 1;
}
else
{
nvCheck(dds.isTextureCube());
faceCount = 6;
}
uint mipmapCount = dds.mipmapCount();
clock_t start = clock();
// apply arguments
if (forcenormal)
{
dds.setNormalFlag(true);
}
if (!faces)
{
faceCount = 1;
}
if (!mipmaps)
{
mipmapCount = 1;
}
nv::Image mipmap;
nv::Path name;
// strip extension, we force the tga extension
output.stripExtension();
// extract faces and mipmaps
for (uint f = 0; f < faceCount; f++)
{
for (uint m = 0; m < mipmapCount; m++)
{
dds.mipmap(&mipmap, f, m);
// set output filename, if we are doing faces and/or mipmaps
name.copy(output);
if (faces) name.appendFormat("_face%d", f);
if (mipmaps) name.appendFormat("_mipmap%d", m);
name.append(savePNG ? ".png" : ".tga");
nv::StdOutputStream stream(name.str());
if (stream.isError()) {
fprintf(stderr, "Error opening '%s' for writting\n", name.str());
return 1;
}
nv::ImageIO::save(name.str(), stream, &mipmap);
}
}
clock_t end = clock();
printf("\rtime taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
return 0;
}
int main(int argc, char *argv[])
{
MyAssertHandler assertHandler;
MyMessageHandler messageHandler;
bool alpha = false;
bool normal = false;
bool color2normal = false;
bool linear = false;
bool wrapRepeat = false;
bool noMipmaps = false;
bool fast = false;
bool nocuda = false;
bool bc1n = false;
bool luminance = false;
nvtt::Format format = nvtt::Format_BC1;
bool fillHoles = false;
bool countEmptyRows = false;
bool outProvided = false;
bool premultiplyAlpha = false;
nvtt::MipmapFilter mipmapFilter = nvtt::MipmapFilter_Box;
bool loadAsFloat = false;
bool rgbm = false;
bool rangescale = false;
const char * externalCompressor = NULL;
bool silent = false;
bool dds10 = false;
nv::Path input;
nv::Path output;
// Parse arguments.
for (int i = 1; i < argc; i++)
{
// Input options.
if (strcmp("-color", argv[i]) == 0)
{
}
else if (strcmp("-alpha", argv[i]) == 0)
{
alpha = true;
}
else if (strcmp("-normal", argv[i]) == 0)
{
normal = true;
}
else if (strcmp("-tonormal", argv[i]) == 0)
{
color2normal = true;
}
else if (strcmp("-linear", argv[i]) == 0)
{
linear = true;
}
else if (strcmp("-clamp", argv[i]) == 0)
{
}
else if (strcmp("-repeat", argv[i]) == 0)
{
wrapRepeat = true;
}
else if (strcmp("-nomips", argv[i]) == 0)
{
noMipmaps = true;
}
else if (strcmp("-fillholes", argv[i]) == 0)
{
fillHoles = true;
}
else if (strcmp("-countempty", argv[i]) == 0)
{
countEmptyRows = true;
}
else if (strcmp("-premula", argv[i]) == 0)
{
premultiplyAlpha = true;
}
else if (strcmp("-mipfilter", argv[i]) == 0)
{
if (i+1 == argc) break;
i++;
if (strcmp("box", argv[i]) == 0) mipmapFilter = nvtt::MipmapFilter_Box;
else if (strcmp("triangle", argv[i]) == 0) mipmapFilter = nvtt::MipmapFilter_Triangle;
else if (strcmp("kaiser", argv[i]) == 0) mipmapFilter = nvtt::MipmapFilter_Kaiser;
}
else if (strcmp("-float", argv[i]) == 0)
{
loadAsFloat = true;
}
else if (strcmp("-rgbm", argv[i]) == 0)
{
rgbm = true;
}
else if (strcmp("-rangescale", argv[i]) == 0)
{
rangescale = true;
}
// Compression options.
else if (strcmp("-fast", argv[i]) == 0)
{
fast = true;
}
else if (strcmp("-nocuda", argv[i]) == 0)
{
nocuda = true;
}
else if (strcmp("-rgb", argv[i]) == 0)
{
format = nvtt::Format_RGB;
}
else if (strcmp("-lumi", argv[i]) == 0)
{
luminance = true;
format = nvtt::Format_RGB;
}
else if (strcmp("-bc1", argv[i]) == 0)
{
format = nvtt::Format_BC1;
}
else if (strcmp("-bc1n", argv[i]) == 0)
{
format = nvtt::Format_BC1;
bc1n = true;
}
else if (strcmp("-bc1a", argv[i]) == 0)
{
format = nvtt::Format_BC1a;
}
else if (strcmp("-bc2", argv[i]) == 0)
{
format = nvtt::Format_BC2;
}
else if (strcmp("-bc3", argv[i]) == 0)
{
format = nvtt::Format_BC3;
}
else if (strcmp("-bc3n", argv[i]) == 0)
{
format = nvtt::Format_BC3n;
}
else if (strcmp("-bc4", argv[i]) == 0)
{
format = nvtt::Format_BC4;
}
else if (strcmp("-bc5", argv[i]) == 0)
{
format = nvtt::Format_BC5;
}
else if (strcmp("-bc6", argv[i]) == 0)
{
format = nvtt::Format_BC6;
}
else if (strcmp("-bc7", argv[i]) == 0)
{
format = nvtt::Format_BC7;
}
else if (strcmp("-bc3_rgbm", argv[i]) == 0)
{
format = nvtt::Format_BC3_RGBM;
rgbm = true;
}
// Undocumented option. Mainly used for testing.
else if (strcmp("-ext", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
externalCompressor = argv[i+1];
i++;
}
}
else if (strcmp("-pause", argv[i]) == 0)
{
printf("Press ENTER\n"); fflush(stdout);
getchar();
}
// Output options
else if (strcmp("-silent", argv[i]) == 0)
{
silent = true;
}
else if (strcmp("-dds10", argv[i]) == 0)
{
dds10 = true;
}
else if (argv[i][0] != '-')
{
input = argv[i];
if (i+1 < argc && argv[i+1][0] != '-') {
output = argv[i+1];
if(output.endsWith("\\") || output.endsWith("/")) {
//only path specified
output.append(input.fileName());
output.stripExtension();
output.append(".dds");
}
else
outProvided = true;
}
else
{
output.copy(input.str());
output.stripExtension();
output.append(".dds");
}
break;
}
else
{
printf("Warning: unrecognized option \"%s\"\n", argv[i]);
}
}
const uint version = nvtt::version();
const uint major = version / 100 / 100;
const uint minor = (version / 100) % 100;
const uint rev = version % 100;
if (!silent)
{
printf("NVIDIA Texture Tools %u.%u.%u - Copyright NVIDIA Corporation 2007\n\n", major, minor, rev);
}
if (input.isNull())
{
printf("usage: nvcompress [options] infile [outfile.dds]\n\n");
printf("Input options:\n");
printf(" -color The input image is a color map (default).\n");
printf(" -alpha The input image has an alpha channel used for transparency.\n");
printf(" -normal The input image is a normal map.\n");
printf(" -linear The input is in linear color space.\n");
printf(" -tonormal Convert input to normal map.\n");
printf(" -clamp Clamp wrapping mode (default).\n");
printf(" -repeat Repeat wrapping mode.\n");
printf(" -nomips Disable mipmap generation.\n");
printf(" -premula Premultiply alpha into color channel.\n");
printf(" -mipfilter Mipmap filter. One of the following: box, triangle, kaiser.\n");
printf(" -float Load as floating point image.\n\n");
printf(" -rgbm Transform input to RGBM.\n\n");
printf(" -rangescale Scale image to use entire color range.\n\n");
printf(" -fillholes Fill transparent areas with nearby color. Note: adds transparent upper height into output file name in case the outfile was not specified, and infile was in form #.####.xxx.ext\n\n");
printf("Compression options:\n");
printf(" -fast Fast compression.\n");
printf(" -nocuda Do not use cuda compressor.\n");
printf(" -rgb RGBA format\n");
printf(" -lumi LUMINANCE format\n");
printf(" -bc1 BC1 format (DXT1)\n");
printf(" -bc1n BC1 normal map format (DXT1nm)\n");
printf(" -bc1a BC1 format with binary alpha (DXT1a)\n");
printf(" -bc2 BC2 format (DXT3)\n");
printf(" -bc3 BC3 format (DXT5)\n");
printf(" -bc3n BC3 normal map format (DXT5nm)\n");
printf(" -bc4 BC4 format (ATI1)\n");
printf(" -bc5 BC5 format (3Dc/ATI2)\n");
printf(" -bc6 BC6 format\n");
printf(" -bc7 BC7 format\n\n");
printf(" -bc3_rgbm BC3-rgbm format\n\n");
printf("Output options:\n");
printf(" -silent \tDo not output progress messages\n");
printf(" -dds10 \tUse DirectX 10 DDS format (enabled by default for BC6/7)\n\n");
return EXIT_FAILURE;
}
// Make sure input file exists.
if (!nv::FileSystem::exists(input.str()))
{
fprintf(stderr, "The file '%s' does not exist.\n", input.str());
return 1;
}
// Set input options.
nvtt::InputOptions inputOptions;
bool useSurface = false; // @@ use Surface API in all cases!
nvtt::Surface image;
if (format == nvtt::Format_Unknown && nv::strCaseDiff(input.extension(), ".dds") == 0)
{
// Load surface.
nv::DirectDrawSurface dds(input.str());
if (!dds.isValid())
{
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str());
return EXIT_FAILURE;
}
if (!dds.isSupported())
{
fprintf(stderr, "The file '%s' is not a supported DDS file.\n", input.str());
return EXIT_FAILURE;
}
//if format not specified, get from dds
if (dds.isRGB())
format = nvtt::Format_RGB;
else if (dds.isLuminance()) {
luminance = true;
format = nvtt::Format_RGB;
}
else {
uint cc = dds.fourcc();
switch(cc) {
case nv::FOURCC_DXT1: format = nvtt::Format_DXT1; break;
case nv::FOURCC_DXT3: format = nvtt::Format_DXT3; break;
case nv::FOURCC_DXT5: format = nvtt::Format_DXT5; break;
case nv::FOURCC_RXGB: format = nvtt::Format_BC3n; break;
case nv::FOURCC_ATI1: format = nvtt::Format_BC4; break;
case nv::FOURCC_ATI2: format = nvtt::Format_BC5; break;
}
}
alpha = dds.hasAlpha();
}
if (format == nvtt::Format_BC3_RGBM || rgbm) {
useSurface = true;
if (!image.load(input.str())) {
fprintf(stderr, "Error opening input file '%s'.\n", input.str());
return EXIT_FAILURE;
}
if (rangescale) {
// get color range
float min_color[3], max_color[3];
image.range(0, &min_color[0], &max_color[0]);
image.range(1, &min_color[1], &max_color[1]);
image.range(2, &min_color[2], &max_color[2]);
//printf("Color range = %.2f %.2f %.2f\n", max_color[0], max_color[1], max_color[2]);
float color_range = nv::max3(max_color[0], max_color[1], max_color[2]);
const float max_color_range = 16.0f;
if (color_range > max_color_range) {
//Log::print("Clamping color range %f to %f\n", color_range, max_color_range);
color_range = max_color_range;
}
//color_range = max_color_range; // Use a fixed color range for now.
for (int i = 0; i < 3; i++) {
image.scaleBias(i, 1.0f / color_range, 0.0f);
}
image.toneMap(nvtt::ToneMapper_Linear, /*parameters=*/NULL); // Clamp without changing the hue.
// Clamp alpha.
image.clamp(3);
}
if (alpha) {
image.setAlphaMode(nvtt::AlphaMode_Transparency);
}
// To gamma.
image.toGamma(2);
if (format != nvtt::Format_BC3_RGBM) {
image.setAlphaMode(nvtt::AlphaMode_None);
image.toRGBM(1, 0.15f);
}
}
else if (format == nvtt::Format_BC6) {
//format = nvtt::Format_BC1;
//fprintf(stderr, "BLABLABLA.\n");
useSurface = true;
if (!image.load(input.str())) {
fprintf(stderr, "Error opening input file '%s'.\n", input.str());
return EXIT_FAILURE;
}
image.setAlphaMode(nvtt::AlphaMode_Transparency);
}
else {
if (nv::strCaseDiff(input.extension(), ".dds") == 0)
{
// Load surface.
nv::DirectDrawSurface dds(input.str());
if (!dds.isValid())
{
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str());
return EXIT_FAILURE;
}
if (!dds.isSupported())
{
fprintf(stderr, "The file '%s' is not a supported DDS file.\n", input.str());
return EXIT_FAILURE;
}
uint faceCount;
if (dds.isTexture2D())
{
inputOptions.setTextureLayout(nvtt::TextureType_2D, dds.width(), dds.height());
faceCount = 1;
}
else if (dds.isTexture3D())
{
inputOptions.setTextureLayout(nvtt::TextureType_3D, dds.width(), dds.height(), dds.depth());
faceCount = 1;
nvDebugBreak();
}
else if (dds.isTextureCube()) {
inputOptions.setTextureLayout(nvtt::TextureType_Cube, dds.width(), dds.height());
faceCount = 6;
} else {
nvDebugCheck(dds.isTextureArray());
inputOptions.setTextureLayout(nvtt::TextureType_Array, dds.width(), dds.height(), 1, dds.arraySize());
faceCount = dds.arraySize();
dds10 = true;
}
uint mipmapCount = dds.mipmapCount();
nv::Image mipmap;
for (uint f = 0; f < faceCount; f++)
{
for (uint m = 0; m < mipmapCount; m++)
{
dds.mipmap(&mipmap, f, m); // @@ Load as float.
inputOptions.setMipmapData(mipmap.pixels(), mipmap.width(), mipmap.height(), mipmap.depth(), f, m);
}
}
}
else
{
if (nv::strCaseDiff(input.extension(), ".exr") == 0 || nv::strCaseDiff(input.extension(), ".hdr") == 0)
{
loadAsFloat = true;
}
if (loadAsFloat)
{
nv::AutoPtr<nv::FloatImage> image(nv::ImageIO::loadFloat(input.str()));
if (image == NULL)
{
fprintf(stderr, "The file '%s' is not a supported image type.\n", input.str());
return EXIT_FAILURE;
}
inputOptions.setFormat(nvtt::InputFormat_RGBA_32F);
inputOptions.setTextureLayout(nvtt::TextureType_2D, image->width(), image->height());
/*for (uint i = 0; i < image->componentNum(); i++)
{
inputOptions.setMipmapChannelData(image->channel(i), i, image->width(), image->height());
}*/
}
else
{
// Regular image.
nv::Image image;
if (!image.load(input.str()))
{
fprintf(stderr, "The file '%s' is not a supported image type.\n", input.str());
return 1;
}
if(countEmptyRows)
{
//count empty rows & append to the file name
const int w = image.width();
const int h = image.height();
int ytr = 0; //height of the transparent part
if(image.format() == image.Format_ARGB) {
for(int y=0; y<h; ++y) {
for(int x=0; x<w; ++x) {
if(image.pixel(x,y).a >= 128) {
ytr = y;
y = h;
break;
}
}
}
}
//change outfile
output.stripExtension();
output.appendFormat(".%04i.dds", ytr);
}
if(fillHoles) {
nv::FloatImage fimage(&image);
// create feature mask
nv::BitMap bmp(image.width(),image.height());
bmp.clearAll();
const int w=image.width();
const int h=image.height();
int ytr = h; //height of the transparent part
for(int y=0; y<h; ++y)
for(int x=0; x<w; ++x)
if(fimage.pixel(3,x,y,0) >= 0.5f) {
bmp.setBitAt(x,y);
if(y < ytr) ytr = y;
}
// fill holes
nv::fillVoronoi(&fimage,&bmp);
// do blur passes
for(int i=0; i<8; ++i)
nv::fillBlur(&fimage,&bmp);
nv::AutoPtr<nv::Image> img(fimage.createImage(0));
inputOptions.setTextureLayout(nvtt::TextureType_2D, img->width(), img->height());
inputOptions.setMipmapData(img->pixels(), img->width(), img->height());
}
else {
inputOptions.setTextureLayout(nvtt::TextureType_2D, image.width(), image.height());
inputOptions.setMipmapData(image.pixels(), image.width(), image.height());
}
}
}
if (format == nvtt::Format_Unknown)
format = nvtt::Format_BC1;
if (wrapRepeat)
{
inputOptions.setWrapMode(nvtt::WrapMode_Repeat);
}
else
{
inputOptions.setWrapMode(nvtt::WrapMode_Clamp);
}
if (alpha)
{
inputOptions.setAlphaMode(nvtt::AlphaMode_Transparency);
}
else
{
inputOptions.setAlphaMode(nvtt::AlphaMode_None);
}
// Block compressed textures with mipmaps must be powers of two.
if (!noMipmaps && format != nvtt::Format_RGB)
{
//inputOptions.setRoundMode(nvtt::RoundMode_ToPreviousPowerOfTwo);
}
if (linear)
{
setLinearMap(inputOptions);
}
else if (normal)
{
setNormalMap(inputOptions);
}
else if (color2normal)
{
setColorToNormalMap(inputOptions);
}
else
{
setColorMap(inputOptions);
}
if (noMipmaps)
{
inputOptions.setMipmapGeneration(false);
}
/*if (premultiplyAlpha)
{
inputOptions.setPremultiplyAlpha(true);
inputOptions.setAlphaMode(nvtt::AlphaMode_Premultiplied);
}*/
inputOptions.setMipmapFilter(mipmapFilter);
}
nvtt::CompressionOptions compressionOptions;
compressionOptions.setFormat(format);
//compressionOptions.setQuantization(/*color dithering*/true, /*alpha dithering*/false, /*binary alpha*/false);
if (format == nvtt::Format_BC2) {
// Dither alpha when using BC2.
compressionOptions.setQuantization(/*color dithering*/false, /*alpha dithering*/true, /*binary alpha*/false);
}
else if (format == nvtt::Format_BC1a) {
// Binary alpha when using BC1a.
compressionOptions.setQuantization(/*color dithering*/false, /*alpha dithering*/true, /*binary alpha*/true, 127);
}
else if (format == nvtt::Format_RGBA)
{
if (luminance)
{
compressionOptions.setPixelFormat(8, 0xff, 0, 0, 0);
}
else {
// @@ Edit this to choose the desired pixel format:
// compressionOptions.setPixelType(nvtt::PixelType_Float);
// compressionOptions.setPixelFormat(16, 16, 16, 16);
// compressionOptions.setPixelType(nvtt::PixelType_UnsignedNorm);
// compressionOptions.setPixelFormat(16, 0, 0, 0);
//compressionOptions.setQuantization(/*color dithering*/true, /*alpha dithering*/false, /*binary alpha*/false);
//compressionOptions.setPixelType(nvtt::PixelType_UnsignedNorm);
//compressionOptions.setPixelFormat(5, 6, 5, 0);
//compressionOptions.setPixelFormat(8, 8, 8, 8);
// A4R4G4B4
//compressionOptions.setPixelFormat(16, 0xF00, 0xF0, 0xF, 0xF000);
//compressionOptions.setPixelFormat(32, 0xFF0000, 0xFF00, 0xFF, 0xFF000000);
// R10B20G10A2
//compressionOptions.setPixelFormat(10, 10, 10, 2);
// DXGI_FORMAT_R11G11B10_FLOAT
//compressionOptions.setPixelType(nvtt::PixelType_Float);
//compressionOptions.setPixelFormat(11, 11, 10, 0);
}
}
else if (format == nvtt::Format_BC6)
{
compressionOptions.setPixelType(nvtt::PixelType_UnsignedFloat);
}
if (fast)
{
compressionOptions.setQuality(nvtt::Quality_Fastest);
}
else
{
compressionOptions.setQuality(nvtt::Quality_Normal);
//compressionOptions.setQuality(nvtt::Quality_Production);
//compressionOptions.setQuality(nvtt::Quality_Highest);
}
if (bc1n)
{
compressionOptions.setColorWeights(1, 1, 0);
}
//compressionOptions.setColorWeights(0.2126, 0.7152, 0.0722);
//compressionOptions.setColorWeights(0.299, 0.587, 0.114);
//compressionOptions.setColorWeights(3, 4, 2);
if (externalCompressor != NULL)
{
compressionOptions.setExternalCompressor(externalCompressor);
}
MyErrorHandler errorHandler;
MyOutputHandler outputHandler(output.str());
if (outputHandler.stream->isError())
{
fprintf(stderr, "Error opening '%s' for writting\n", output.str());
return EXIT_FAILURE;
}
nvtt::Context context;
context.enableCudaAcceleration(!nocuda);
if (!silent)
{
printf("CUDA acceleration ");
if (context.isCudaAccelerationEnabled())
{
printf("ENABLED\n\n");
}
else
{
printf("DISABLED\n\n");
}
}
int outputSize = 0;
if (useSurface) {
outputSize = context.estimateSize(image, 1, compressionOptions);
}
else {
outputSize = context.estimateSize(inputOptions, compressionOptions);
}
outputHandler.setTotal(outputSize);
outputHandler.setDisplayProgress(!silent);
nvtt::OutputOptions outputOptions;
//outputOptions.setFileName(output);
outputOptions.setOutputHandler(&outputHandler);
outputOptions.setErrorHandler(&errorHandler);
// Automatically use dds10 if compressing to BC6 or BC7
if (format == nvtt::Format_BC6 || format == nvtt::Format_BC7)
{
dds10 = true;
}
if (dds10)
{
outputOptions.setContainer(nvtt::Container_DDS10);
}
// printf("Press ENTER.\n");
// fflush(stdout);
// getchar();
nv::Timer timer;
timer.start();
if (useSurface) {
if (!context.outputHeader(image, 1, compressionOptions, outputOptions)) {
fprintf(stderr, "Error writing file header.\n");
return EXIT_FAILURE;
}
if (!context.compress(image, 0, 0, compressionOptions, outputOptions)) {
fprintf(stderr, "Error compressing file.\n");
return EXIT_FAILURE;
}
}
else {
if (!context.process(inputOptions, compressionOptions, outputOptions)) {
return EXIT_FAILURE;
}
}
timer.stop();
if (!silent) {
printf("\rtime taken: %.3f seconds\n", timer.elapsed());
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
MyAssertHandler assertHandler;
MyMessageHandler messageHandler;
bool forcenormal = false;
bool mipmaps = false;
bool faces = false;
bool savePNG = false;
bool rgbm = false;
bool histogram = false;
nv::Path input;
nv::Path output;
// Parse arguments.
for (int i = 1; i < argc; i++)
{
if (strcmp("-forcenormal", argv[i]) == 0)
{
forcenormal = true;
}
else if (strcmp("-mipmaps", argv[i]) == 0)
{
mipmaps = true;
}
else if (strcmp("-rgbm", argv[i]) == 0)
{
rgbm = true;
}
else if (strcmp("-faces", argv[i]) == 0)
{
faces = true;
}
else if (strcmp("-histogram", argv[i]) == 0)
{
histogram = true;
}
else if (strcmp("-format", argv[i]) == 0)
{
if (i+1 == argc) break;
i++;
// !!!UNDONE: Support at least one HDR output format
#ifdef HAVE_PNG
if (strcmp("png", argv[i]) == 0) savePNG = true;
else
#endif
if (strcmp("tga", argv[i]) == 0) savePNG = false;
else
{
fprintf(stderr, "Unsupported output format '%s', defaulting to 'tga'.\n", argv[i]);
savePNG = false;
}
}
else if (argv[i][0] != '-')
{
input = argv[i];
if (i+1 < argc && argv[i+1][0] != '-')
{
output = argv[i+1];
}
else
{
output.copy(input.str());
}
break;
}
else
{
printf("Warning: unrecognized option \"%s\"\n", argv[i]);
}
}
printf("NVIDIA Texture Tools - Copyright NVIDIA Corporation 2007\n\n");
if (input.isNull())
{
printf("usage: nvdecompress [options] infile.dds [outfile]\n\n");
printf("Note: the .tga or .png extension is forced on outfile\n\n");
printf("Input options:\n");
printf(" -forcenormal The input image is a normal map.\n");
printf(" -mipmaps Decompress all mipmaps.\n");
printf(" -faces Decompress all faces.\n");
printf(" -histogram Output histogram.\n");
printf(" -format <format> Output format ('tga' or 'png').\n");
return 1;
}
if (histogram) {
nvtt::Surface img;
if (!img.load(input.str())) {
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str());
return 1;
}
float exposure = 2.2f;
float scale = 1.0f / exposure;
img.scaleBias(0, scale, 0);
img.scaleBias(1, scale, 0);
img.scaleBias(2, scale, 0);
//img.toneMap(nvtt::ToneMapper_Reindhart, NULL);
//img.toSrgb();
img.toGamma(2.2f);
nvtt::Surface hist = nvtt::histogram(img, 3*512, 128);
// Resize for pretier histograms.
hist.resize(512, 128, 1, nvtt::ResizeFilter_Box);
nv::Path name;
name.copy(output);
name.stripExtension();
name.append(".histogram");
name.append(savePNG ? ".png" : ".tga");
hist.save(name.str());
}
else {
// Load surface.
// !!! DirectDrawSurface API doesn't support float images, so BC6 will be converted to 8-bit on load.
// Should use nvtt::Surface instead.
nv::DirectDrawSurface dds(input.str());
if (!dds.isValid())
{
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str());
return 1;
}
if (!dds.isSupported() || dds.isTexture3D())
{
fprintf(stderr, "The file '%s' is not a supported DDS file.\n", input.str());
return 1;
}
uint faceCount;
if (dds.isTexture2D())
{
faceCount = 1;
}
else
{
nvCheck(dds.isTextureCube());
faceCount = 6;
}
uint mipmapCount = dds.mipmapCount();
clock_t start = clock();
// apply arguments
if (forcenormal)
{
dds.setNormalFlag(true);
}
if (!faces)
{
faceCount = 1;
}
if (!mipmaps)
{
mipmapCount = 1;
}
nv::Image mipmap;
nv::Path name;
// strip extension, we force the tga extension
output.stripExtension();
// extract faces and mipmaps
for (uint f = 0; f < faceCount; f++)
{
for (uint m = 0; m < mipmapCount; m++)
{
dds.mipmap(&mipmap, f, m);
// set output filename, if we are doing faces and/or mipmaps
name.copy(output);
if (faces) name.appendFormat("_face%d", f);
if (mipmaps) name.appendFormat("_mipmap%d", m);
name.append(savePNG ? ".png" : ".tga");
nv::StdOutputStream stream(name.str());
if (stream.isError()) {
fprintf(stderr, "Error opening '%s' for writting\n", name.str());
return 1;
}
nv::ImageIO::save(name.str(), stream, &mipmap);
}
}
clock_t end = clock();
printf("\rtime taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
}
return 0;
}
int main(int argc, char *argv[])
{
MyAssertHandler assertHandler;
MyMessageHandler messageHandler;
bool alpha = false;
bool normal = false;
bool color2normal = false;
bool wrapRepeat = false;
bool noMipmaps = false;
bool fast = false;
bool nocuda = false;
bool silent = false;
bool bc1n = false;
nvtt::Format format = nvtt::Format_BC1;
const char * externalCompressor = NULL;
nv::Path input;
nv::Path output;
// Parse arguments.
for (int i = 1; i < argc; i++)
{
// Input options.
if (strcmp("-color", argv[i]) == 0)
{
}
else if (strcmp("-alpha", argv[i]) == 0)
{
alpha = true;
}
else if (strcmp("-normal", argv[i]) == 0)
{
normal = true;
}
else if (strcmp("-tonormal", argv[i]) == 0)
{
color2normal = true;
}
else if (strcmp("-clamp", argv[i]) == 0)
{
}
else if (strcmp("-repeat", argv[i]) == 0)
{
wrapRepeat = true;
}
else if (strcmp("-nomips", argv[i]) == 0)
{
noMipmaps = true;
}
// Compression options.
else if (strcmp("-fast", argv[i]) == 0)
{
fast = true;
}
else if (strcmp("-nocuda", argv[i]) == 0)
{
nocuda = true;
}
else if (strcmp("-rgb", argv[i]) == 0)
{
format = nvtt::Format_RGB;
}
else if (strcmp("-bc1", argv[i]) == 0)
{
format = nvtt::Format_BC1;
}
else if (strcmp("-bc1n", argv[i]) == 0)
{
format = nvtt::Format_BC1;
bc1n = true;
}
else if (strcmp("-bc1a", argv[i]) == 0)
{
format = nvtt::Format_BC1a;
}
else if (strcmp("-bc2", argv[i]) == 0)
{
format = nvtt::Format_BC2;
}
else if (strcmp("-bc3", argv[i]) == 0)
{
format = nvtt::Format_BC3;
}
else if (strcmp("-bc3n", argv[i]) == 0)
{
format = nvtt::Format_BC3n;
}
else if (strcmp("-bc4", argv[i]) == 0)
{
format = nvtt::Format_BC4;
}
else if (strcmp("-bc5", argv[i]) == 0)
{
format = nvtt::Format_BC5;
}
// Undocumented option. Mainly used for testing.
else if (strcmp("-ext", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
externalCompressor = argv[i+1];
i++;
}
}
// Misc options
else if (strcmp("-silent", argv[i]) == 0)
{
silent = true;
}
else if (argv[i][0] != '-')
{
input = argv[i];
if (i+1 < argc && argv[i+1][0] != '-') {
output = argv[i+1];
}
else
{
output.copy(input.str());
output.stripExtension();
output.append(".dds");
}
break;
}
}
const uint version = nvtt::version();
const uint major = version / 100;
const uint minor = version % 100;
printf("NVIDIA Texture Tools %u.%u - Copyright NVIDIA Corporation 2007\n\n", major, minor);
if (input.isNull())
{
printf("usage: nvcompress [options] infile [outfile]\n\n");
printf("Input options:\n");
printf(" -color \tThe input image is a color map (default).\n");
printf(" -alpha \tThe input image has an alpha channel used for transparency.\n");
printf(" -normal \tThe input image is a normal map.\n");
printf(" -tonormal\tConvert input to normal map.\n");
printf(" -clamp \tClamp wrapping mode (default).\n");
printf(" -repeat \tRepeat wrapping mode.\n");
printf(" -nomips \tDisable mipmap generation.\n\n");
printf("Compression options:\n");
printf(" -fast \tFast compression.\n");
printf(" -nocuda \tDo not use cuda compressor.\n");
printf(" -rgb \tRGBA format\n");
printf(" -bc1 \tBC1 format (DXT1)\n");
printf(" -bc1n \tBC1 normal map format (DXT1nm)\n");
printf(" -bc1a \tBC1 format with binary alpha (DXT1a)\n");
printf(" -bc2 \tBC2 format (DXT3)\n");
printf(" -bc3 \tBC3 format (DXT5)\n");
printf(" -bc3n \tBC3 normal map format (DXT5nm)\n");
printf(" -bc4 \tBC4 format (ATI1)\n");
printf(" -bc5 \tBC5 format (3Dc/ATI2)\n\n");
return EXIT_FAILURE;
}
// @@ Make sure input file exists.
// Set input options.
nvtt::InputOptions inputOptions;
if (nv::strCaseCmp(input.extension(), ".dds") == 0)
{
// Load surface.
nv::DirectDrawSurface dds(input);
if (!dds.isValid())
{
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str());
return EXIT_FAILURE;
}
if (!dds.isSupported() || dds.isTexture3D())
{
fprintf(stderr, "The file '%s' is not a supported DDS file.\n", input.str());
return EXIT_FAILURE;
}
uint faceCount;
if (dds.isTexture2D())
{
inputOptions.setTextureLayout(nvtt::TextureType_2D, dds.width(), dds.height());
faceCount = 1;
}
else
{
nvDebugCheck(dds.isTextureCube());
inputOptions.setTextureLayout(nvtt::TextureType_Cube, dds.width(), dds.height());
faceCount = 6;
}
uint mipmapCount = dds.mipmapCount();
nv::Image mipmap;
for (uint f = 0; f < faceCount; f++)
{
for (uint m = 0; m < mipmapCount; m++)
{
dds.mipmap(&mipmap, f, m);
inputOptions.setMipmapData(mipmap.pixels(), mipmap.width(), mipmap.height(), 1, f, m);
}
}
}
else
{
// Regular image.
nv::Image image;
if (!image.load(input))
{
fprintf(stderr, "The file '%s' is not a supported image type.\n", input.str());
return EXIT_FAILURE;
}
inputOptions.setTextureLayout(nvtt::TextureType_2D, image.width(), image.height());
inputOptions.setMipmapData(image.pixels(), image.width(), image.height());
}
if (wrapRepeat)
{
inputOptions.setWrapMode(nvtt::WrapMode_Repeat);
}
else
{
inputOptions.setWrapMode(nvtt::WrapMode_Clamp);
}
if (alpha)
{
inputOptions.setAlphaMode(nvtt::AlphaMode_Transparency);
}
else
{
inputOptions.setAlphaMode(nvtt::AlphaMode_None);
}
if (normal)
{
setNormalMap(inputOptions);
}
else if (color2normal)
{
setColorToNormalMap(inputOptions);
}
else
{
setColorMap(inputOptions);
}
if (noMipmaps)
{
inputOptions.setMipmapGeneration(false);
}
nvtt::CompressionOptions compressionOptions;
compressionOptions.setFormat(format);
if (fast)
{
compressionOptions.setQuality(nvtt::Quality_Fastest);
}
else
{
compressionOptions.setQuality(nvtt::Quality_Normal);
//compressionOptions.setQuality(nvtt::Quality_Production);
//compressionOptions.setQuality(nvtt::Quality_Highest);
}
if (bc1n)
{
compressionOptions.setColorWeights(1, 1, 0);
}
if (externalCompressor != NULL)
{
compressionOptions.setExternalCompressor(externalCompressor);
}
MyErrorHandler errorHandler;
MyOutputHandler outputHandler(output);
if (outputHandler.stream->isError())
{
fprintf(stderr, "Error opening '%s' for writting\n", output.str());
return EXIT_FAILURE;
}
nvtt::Compressor compressor;
compressor.enableCudaAcceleration(!nocuda);
printf("CUDA acceleration ");
if (compressor.isCudaAccelerationEnabled())
{
printf("ENABLED\n\n");
}
else
{
printf("DISABLED\n\n");
}
outputHandler.setTotal(compressor.estimateSize(inputOptions, compressionOptions));
outputHandler.setDisplayProgress(!silent);
nvtt::OutputOptions outputOptions;
//outputOptions.setFileName(output);
outputOptions.setOutputHandler(&outputHandler);
outputOptions.setErrorHandler(&errorHandler);
// printf("Press ENTER.\n");
// fflush(stdout);
// getchar();
clock_t start = clock();
if (!compressor.process(inputOptions, compressionOptions, outputOptions))
{
return EXIT_FAILURE;
}
clock_t end = clock();
printf("\rtime taken: %.3f seconds\n", float(end-start) / CLOCKS_PER_SEC);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
MyAssertHandler assertHandler;
MyMessageHandler messageHandler;
bool alpha = false;
bool normal = false;
bool color2normal = false;
bool wrapRepeat = false;
bool noMipmaps = false;
bool fast = false;
bool nocuda = false;
bool bc1n = false;
bool luminance = false;
nvtt::Format format = nvtt::Format_BC1;
bool premultiplyAlpha = false;
nvtt::MipmapFilter mipmapFilter = nvtt::MipmapFilter_Box;
bool loadAsFloat = false;
uint bitCount = 0, rmask = 0, gmask = 0, bmask = 0, amask = 0;
bool fmtSet;
const char * externalCompressor = NULL;
bool silent = false;
bool dds10 = false;
nv::Path input;
nv::Path output;
// Parse arguments.
for (int i = 1; i < argc; i++)
{
// Input options.
if (strcmp("-color", argv[i]) == 0)
{
}
else if (strcmp("-alpha", argv[i]) == 0)
{
alpha = true;
}
else if (strcmp("-normal", argv[i]) == 0)
{
normal = true;
}
else if (strcmp("-tonormal", argv[i]) == 0)
{
color2normal = true;
}
else if (strcmp("-clamp", argv[i]) == 0)
{
}
else if (strcmp("-repeat", argv[i]) == 0)
{
wrapRepeat = true;
}
else if (strcmp("-nomips", argv[i]) == 0)
{
noMipmaps = true;
}
else if (strcmp("-premula", argv[i]) == 0)
{
premultiplyAlpha = true;
}
else if (strcmp("-mipfilter", argv[i]) == 0)
{
if (i+1 == argc) break;
i++;
if (strcmp("box", argv[i]) == 0) mipmapFilter = nvtt::MipmapFilter_Box;
else if (strcmp("triangle", argv[i]) == 0) mipmapFilter = nvtt::MipmapFilter_Triangle;
else if (strcmp("kaiser", argv[i]) == 0) mipmapFilter = nvtt::MipmapFilter_Kaiser;
}
else if (strcmp("-float", argv[i]) == 0)
{
loadAsFloat = true;
}
// Compression options.
else if (strcmp("-fast", argv[i]) == 0)
{
fast = true;
}
else if (strcmp("-nocuda", argv[i]) == 0)
{
nocuda = true;
}
else if (strcmp("-rgb", argv[i]) == 0)
{
format = nvtt::Format_RGB;
}
else if (strcmp("-lumi", argv[i]) == 0)
{
luminance = true;
format = nvtt::Format_RGB;
}
else if (strcmp("-bc1", argv[i]) == 0)
{
format = nvtt::Format_BC1;
}
else if (strcmp("-bc1n", argv[i]) == 0)
{
format = nvtt::Format_BC1;
bc1n = true;
}
else if (strcmp("-bc1a", argv[i]) == 0)
{
format = nvtt::Format_BC1a;
}
else if (strcmp("-bc2", argv[i]) == 0)
{
format = nvtt::Format_BC2;
}
else if (strcmp("-bc3", argv[i]) == 0)
{
format = nvtt::Format_BC3;
}
else if (strcmp("-bc3n", argv[i]) == 0)
{
format = nvtt::Format_BC3n;
}
else if (strcmp("-bc4", argv[i]) == 0)
{
format = nvtt::Format_BC4;
}
else if (strcmp("-bc5", argv[i]) == 0)
{
format = nvtt::Format_BC5;
}
else if (strcmp("-fmt", argv[i]) == 0)
{
if (i+1 == argc) break;
i++;
if (strcmp("rgba8", argv[i]) == 0)
{
format = nvtt::Format_RGB;
fmtSet = true;
bitCount = 32;
amask = 0xFF000000;
rmask = 0x00FF0000;
gmask = 0x0000FF00;
bmask = 0x000000FF;
}
else if (strcmp("bgra8", argv[i]) == 0)
{
format = nvtt::Format_RGBA;
fmtSet = true;
bitCount = 32;
amask = 0xFF000000;
rmask = 0x000000FF;
gmask = 0x0000FF00;
bmask = 0x00FF0000;
}
else if (strcmp("rgb8", argv[i]) == 0)
{
format = nvtt::Format_RGB;
fmtSet = true;
bitCount = 24;
amask = 0x00000000;
rmask = 0x00FF0000;
gmask = 0x0000FF00;
bmask = 0x000000FF;
}
else if (strcmp("bgr8", argv[i]) == 0)
{
format = nvtt::Format_RGB;
fmtSet = true;
bitCount = 24;
amask = 0x00000000;
rmask = 0x000000FF;
gmask = 0x0000FF00;
bmask = 0x00FF0000;
}
}
// Undocumented option. Mainly used for testing.
else if (strcmp("-ext", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
externalCompressor = argv[i+1];
i++;
}
}
else if (strcmp("-pause", argv[i]) == 0)
{
printf("Press ENTER\n"); fflush(stdout);
getchar();
}
// Output options
else if (strcmp("-silent", argv[i]) == 0)
{
silent = true;
}
else if (strcmp("-dds10", argv[i]) == 0)
{
dds10 = true;
}
else if (argv[i][0] != '-')
{
input = argv[i];
if (i+1 < argc && argv[i+1][0] != '-') {
output = argv[i+1];
}
else
{
output.copy(input.str());
output.stripExtension();
output.append(".dds");
}
break;
}
}
const uint version = nvtt::version();
const uint major = version / 100 / 100;
const uint minor = (version / 100) % 100;
const uint rev = version % 100;
printf("NVIDIA Texture Tools %u.%u.%u - Copyright NVIDIA Corporation 2007\n\n", major, minor, rev);
if (input.isNull())
{
printf("usage: nvcompress [options] infile [outfile]\n\n");
printf("Input options:\n");
printf(" -color \tThe input image is a color map (default).\n");
printf(" -alpha \tThe input image has an alpha channel used for transparency.\n");
printf(" -normal \tThe input image is a normal map.\n");
printf(" -tonormal \tConvert input to normal map.\n");
printf(" -clamp \tClamp wrapping mode (default).\n");
printf(" -repeat \tRepeat wrapping mode.\n");
printf(" -nomips \tDisable mipmap generation.\n");
printf(" -premula \tPremultiply alpha into color channel.\n");
printf(" -mipfilter \tMipmap filter. One of the following: box, triangle, kaiser.\n");
printf(" -float \tLoad as floating point image.\n\n");
printf("Compression options:\n");
printf(" -fast \tFast compression.\n");
printf(" -nocuda \tDo not use cuda compressor.\n");
printf(" -rgb \tRGBA format\n");
printf(" -lumi \tLUMINANCE format\n");
printf(" -bc1 \tBC1 format (DXT1)\n");
printf(" -bc1n \tBC1 normal map format (DXT1nm)\n");
printf(" -bc1a \tBC1 format with binary alpha (DXT1a)\n");
printf(" -bc2 \tBC2 format (DXT3)\n");
printf(" -bc3 \tBC3 format (DXT5)\n");
printf(" -bc3n \tBC3 normal map format (DXT5nm)\n");
printf(" -bc4 \tBC4 format (ATI1)\n");
printf(" -bc5 \tBC5 format (3Dc/ATI2)\n\n");
printf("Output options:\n");
printf(" -silent \tDo not output progress messages\n");
printf(" -dds10 \tUse DirectX 10 DDS format\n\n");
return EXIT_FAILURE;
}
// Make sure input file exists.
if (!nv::FileSystem::exists(input.str()))
{
fprintf(stderr, "The file '%s' does not exist.\n", input.str());
return 1;
}
// Set input options.
nvtt::InputOptions inputOptions;
if (nv::strCaseCmp(input.extension(), ".dds") == 0)
{
// Load surface.
nv::DirectDrawSurface dds(input.str());
if (!dds.isValid())
{
fprintf(stderr, "The file '%s' is not a valid DDS file.\n", input.str());
return EXIT_FAILURE;
}
if (!dds.isSupported() || dds.isTexture3D())
{
fprintf(stderr, "The file '%s' is not a supported DDS file.\n", input.str());
return EXIT_FAILURE;
}
uint faceCount;
if (dds.isTexture2D())
{
inputOptions.setTextureLayout(nvtt::TextureType_2D, dds.width(), dds.height());
faceCount = 1;
}
else
{
nvDebugCheck(dds.isTextureCube());
inputOptions.setTextureLayout(nvtt::TextureType_Cube, dds.width(), dds.height());
faceCount = 6;
}
uint mipmapCount = dds.mipmapCount();
nv::Image mipmap;
for (uint f = 0; f < faceCount; f++)
{
for (uint m = 0; m < mipmapCount; m++)
{
dds.mipmap(&mipmap, f, m); // @@ Load as float.
inputOptions.setMipmapData(mipmap.pixels(), mipmap.width(), mipmap.height(), 1, f, m);
}
}
}
else
{
if (nv::strCaseCmp(input.extension(), ".exr") == 0 || nv::strCaseCmp(input.extension(), ".hdr") == 0)
{
loadAsFloat = true;
}
if (loadAsFloat)
{
nv::AutoPtr<nv::FloatImage> image(nv::ImageIO::loadFloat(input.str()));
if (image == NULL)
{
fprintf(stderr, "The file '%s' is not a supported image type.\n", input.str());
return EXIT_FAILURE;
}
inputOptions.setFormat(nvtt::InputFormat_RGBA_32F);
inputOptions.setTextureLayout(nvtt::TextureType_2D, image->width(), image->height());
/*for (uint i = 0; i < image->componentNum(); i++)
{
inputOptions.setMipmapChannelData(image->channel(i), i, image->width(), image->height());
}*/
}
else
{
// Regular image.
nv::Image image;
if (!image.load(input.str()))
{
fprintf(stderr, "The file '%s' is not a supported image type.\n", input.str());
return 1;
}
inputOptions.setTextureLayout(nvtt::TextureType_2D, image.width(), image.height());
inputOptions.setMipmapData(image.pixels(), image.width(), image.height());
}
}
if (wrapRepeat)
{
inputOptions.setWrapMode(nvtt::WrapMode_Repeat);
}
else
{
inputOptions.setWrapMode(nvtt::WrapMode_Clamp);
}
if (alpha)
{
inputOptions.setAlphaMode(nvtt::AlphaMode_Transparency);
}
else
{
inputOptions.setAlphaMode(nvtt::AlphaMode_None);
}
// Block compressed textures with mipmaps must be powers of two.
if (!noMipmaps && format != nvtt::Format_RGB)
{
inputOptions.setRoundMode(nvtt::RoundMode_ToPreviousPowerOfTwo);
}
if (normal)
{
setNormalMap(inputOptions);
}
else if (color2normal)
{
setColorToNormalMap(inputOptions);
}
else
{
setColorMap(inputOptions);
}
if (noMipmaps)
{
inputOptions.setMipmapGeneration(false);
}
/*if (premultiplyAlpha)
{
inputOptions.setPremultiplyAlpha(true);
inputOptions.setAlphaMode(nvtt::AlphaMode_Premultiplied);
}*/
inputOptions.setMipmapFilter(mipmapFilter);
nvtt::CompressionOptions compressionOptions;
compressionOptions.setFormat(format);
if (format == nvtt::Format_BC2) {
// Dither alpha when using BC2.
compressionOptions.setQuantization(/*color dithering*/false, /*alpha dithering*/true, /*binary alpha*/false);
}
else if (format == nvtt::Format_BC1a) {
// Binary alpha when using BC1a.
compressionOptions.setQuantization(/*color dithering*/false, /*alpha dithering*/true, /*binary alpha*/true, 127);
}
else if (format == nvtt::Format_RGBA)
{
if (fmtSet)
{
compressionOptions.setPixelFormat(bitCount, rmask, gmask, bmask, amask);
}
else if (luminance)
{
compressionOptions.setPixelFormat(8, 0xff, 0, 0, 0);
}
else {
// @@ Edit this to choose the desired pixel format:
// compressionOptions.setPixelType(nvtt::PixelType_Float);
// compressionOptions.setPixelFormat(16, 16, 16, 16);
// compressionOptions.setPixelType(nvtt::PixelType_UnsignedNorm);
// compressionOptions.setPixelFormat(16, 0, 0, 0);
}
}
if (fast)
{
compressionOptions.setQuality(nvtt::Quality_Fastest);
}
else
{
compressionOptions.setQuality(nvtt::Quality_Normal);
//compressionOptions.setQuality(nvtt::Quality_Production);
//compressionOptions.setQuality(nvtt::Quality_Highest);
}
if (bc1n)
{
compressionOptions.setColorWeights(1, 1, 0);
}
//compressionOptions.setColorWeights(0.2126, 0.7152, 0.0722);
//compressionOptions.setColorWeights(0.299, 0.587, 0.114);
//compressionOptions.setColorWeights(3, 4, 2);
if (externalCompressor != NULL)
{
compressionOptions.setExternalCompressor(externalCompressor);
}
MyErrorHandler errorHandler;
MyOutputHandler outputHandler(output.str());
if (outputHandler.stream->isError())
{
fprintf(stderr, "Error opening '%s' for writting\n", output.str());
return EXIT_FAILURE;
}
nvtt::Context context;
context.enableCudaAcceleration(!nocuda);
printf("CUDA acceleration ");
if (context.isCudaAccelerationEnabled())
{
printf("ENABLED\n\n");
}
else
{
printf("DISABLED\n\n");
}
outputHandler.setTotal(context.estimateSize(inputOptions, compressionOptions));
outputHandler.setDisplayProgress(!silent);
nvtt::OutputOptions outputOptions;
//outputOptions.setFileName(output);
outputOptions.setOutputHandler(&outputHandler);
outputOptions.setErrorHandler(&errorHandler);
if (dds10)
{
outputOptions.setContainer(nvtt::Container_DDS10);
}
// printf("Press ENTER.\n");
// fflush(stdout);
// getchar();
nv::Timer timer;
timer.start();
if (!context.process(inputOptions, compressionOptions, outputOptions))
{
return EXIT_FAILURE;
}
timer.stop();
printf("\rtime taken: %.3f seconds\n", timer.elapsed());
return EXIT_SUCCESS;
}
