khanat-code-old/code/nel/tools/3d/tga_2_dds/tga2dds.cpp

692 lines
16 KiB
C++
Raw Normal View History

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <iostream>
#include "nel/misc/file.h"
#include "nel/misc/bitmap.h"
#include "nel/misc/path.h"
#include "nel/misc/debug.h"
2016-01-23 09:27:34 +00:00
#include "nel/misc/cmd_args.h"
#include <math.h>
#include "../s3tc_compressor_lib/s3tc_compressor.h"
using namespace NLMISC;
using namespace std;
#define TGA8 8
#define TGA16 16
#define PNG8 108
#define PNG16 116
#define NOT_DEFINED 0xff
bool sameType(const std::string &sFileNameDest, uint8 algo);
bool dataCheck(const std::string &sFileNameSrc, const std::string &FileNameDest, uint8 algo);
std::string getOutputFileName(const std::string &inputFileName);
uint8 getType(const std::string &sFileNameDest)
{
uint32 dds;
FILE *f = fopen(sFileNameDest.c_str(),"rb");
if(f==NULL)
{
return NOT_DEFINED;
}
CS3TCCompressor::DDS_HEADER h;
if (fread(&dds,1,4,f) != 4)
{
fclose(f);
return NOT_DEFINED;
}
#ifdef NL_BIG_ENDIAN
NLMISC_BSWAP32(dds);
#endif
if (fread(&h,sizeof(CS3TCCompressor::DDS_HEADER),1,f) != 1)
{
fclose(f);
return NOT_DEFINED;
}
if(fclose(f))
{
cerr<<sFileNameDest<< "is not closed"<<endl;
}
if(h.ddpf.dwFourCC==MAKEFOURCC('D','X', 'T', '1')
&& h.ddpf.dwRGBBitCount==0)
{
return DXT1;
}
if(h.ddpf.dwFourCC==MAKEFOURCC('D','X', 'T', '1')
&& h.ddpf.dwRGBBitCount>0)
{
return DXT1A;
}
if(h.ddpf.dwFourCC==MAKEFOURCC('D','X', 'T', '3'))
{
return DXT3;
}
if(h.ddpf.dwFourCC==MAKEFOURCC('D','X', 'T', '5'))
{
return DXT5;
}
return NOT_DEFINED;
}
bool sameType(const std::string &sFileNameDest, uint8 &algo, bool wantMipMap)
{
uint32 dds;
FILE *f = fopen(sFileNameDest.c_str(),"rb");
if(f==NULL)
{
return false;
}
CS3TCCompressor::DDS_HEADER h;
if (fread(&dds,1,4,f) != 4)
{
fclose(f);
return false;
}
if (fread(&h,sizeof(::DDS_HEADER),1,f) != 1)
{
fclose(f);
return false;
}
if(fclose(f))
{
cerr<<sFileNameDest<< "is not closed"<<endl;
}
bool algoOk= false;
switch(algo)
{
case DXT1:
if(h.ddpf.dwFourCC==MAKEFOURCC('D','X', 'T', '1')
&& h.ddpf.dwRGBBitCount==0)
algoOk=true;
break;
case DXT1A:
if(h.ddpf.dwFourCC==MAKEFOURCC('D','X', 'T', '1')
&& h.ddpf.dwRGBBitCount>0)
algoOk=true;
break;
case DXT3:
if(h.ddpf.dwFourCC==MAKEFOURCC('D','X', 'T', '3'))
algoOk=true;
break;
case DXT5:
if(h.ddpf.dwFourCC==MAKEFOURCC('D','X', 'T', '5'))
algoOk=true;
break;
}
if(!algoOk)
return false;
// Test Mipmap.
bool fileHasMipMap= (h.dwFlags&DDSD_MIPMAPCOUNT) && (h.dwMipMapCount>1);
if(fileHasMipMap==wantMipMap)
return true;
return false;
}
bool dataCheck(const std::string &sFileNameSrc, const std::string &sFileNameDest, uint8& algo, bool wantMipMap)
{
if (!CFile::fileExists(sFileNameSrc))
{
cerr << "Can't open file " << sFileNameSrc << endl;
return false;
}
if (!CFile::fileExists(sFileNameDest))
{
return false; // destination file doesn't exist yet
}
uint32 lastWriteTime1 = CFile::getFileModificationDate(sFileNameSrc);
uint32 lastWriteTime2 = CFile::getFileModificationDate(sFileNameDest);
if(lastWriteTime1 > lastWriteTime2)
{
return false;
}
if (lastWriteTime1 < lastWriteTime2)
{
if(!sameType(sFileNameDest, algo, wantMipMap))
{
return false; // file exists but a new compression type is required
}
}
return true;
}
std::string getOutputFileName(const std::string &inputFileName)
{
std::string::size_type pos = inputFileName.rfind(".");
if(pos == std::string::npos)
{
// name whithout extension
return inputFileName + ".dds";
}
else
{
return inputFileName.substr(0,pos) + ".dds";
}
}
// ***************************************************************************
void dividSize (CBitmap &bitmap)
{
// Must be RGBA
nlassert (bitmap.getPixelFormat () == CBitmap::RGBA);
// Copy the bitmap
CBitmap temp = bitmap;
// Resize the destination
const uint width = temp.getWidth ();
const uint height = temp.getHeight ();
const uint newWidth = temp.getWidth ()/2;
const uint newHeight = temp.getHeight ()/2;
bitmap.resize (newWidth, newHeight, CBitmap::RGBA);
// Pointers
uint8 *pixelSrc = &(temp.getPixels ()[0]);
uint8 *pixelDest = &(bitmap.getPixels ()[0]);
// Resample
uint x, y;
for (y=0; y<newHeight; y++)
for (x=0; x<newWidth; x++)
{
const uint offsetSrc = ((y*2)*width+x*2)*4;
const uint offsetDest = (y*newWidth+x)*4;
uint i;
for (i=0; i<4; i++)
{
pixelDest[offsetDest+i] = ((uint)pixelSrc[offsetSrc+i] + (uint)pixelSrc[offsetSrc+4+i] +
(uint)pixelSrc[offsetSrc+4*width+i] + (uint)pixelSrc[offsetSrc+4*width+4+i])>>2;
}
}
}
const int bayerDiv8R[4][4] = {
{ 7, 3, 6, 2 },
{ 1, 5, 0, 4 },
{ 6, 2, 7, 3 },
{ 0, 4, 1, 5 }
};
const int bayerDiv8G[4][4] = {
{ 0, 4, 1, 5 },
{ 6, 2, 7, 3 },
{ 1, 5, 0, 4 },
{ 7, 3, 6, 2 }
};
const int bayerDiv8B[4][4] = {
2016-01-23 09:27:34 +00:00
{ 5, 1, 4, 0 },
{ 3, 7, 2, 6 },
{ 4, 0, 5, 1 },
{ 2, 6, 3, 7 }
};
// ***************************************************************************
int main(int argc, char **argv)
{
CApplicationContext applicationContext;
// Parse Command Line.
//====================
2016-01-23 09:27:34 +00:00
NLMISC::CCmdArgs args;
args.setDescription(
"Convert TGA or PNG image file to DDS compressed file using DXTC compression (DXTC1, DXTC1 with alpha, DXTC3, or DXTC5).\n"
" The program looks for possible user color files and load them automatically, a user color file must have the same name that the original tga file, plus the extension \"_usercolor\"\n"
"Eg.: pic.tga, the associated user color file must be: pic_usercolor.tga\n"
);
args.addArg("o", "output", "output.dds", "Output DDS filename or directory");
args.addArg("a", "algo", "algo", "Conversion algorithm to use\n"
" 1 for DXTC1 (no alpha)\n"
" 1A for DXTC1 with alpha\n"
" 3 for DXTC3\n"
" 5 for DXTC5\n"
" tga16 for 16 bits TGA\n"
" tga8 for 8 bits TGA\n"
" png16 for 16 bits PNG\n"
" png8 for 8 bits PNG\n"
"\n"
" default : DXTC1 if 24 bits, DXTC5 if 32 bits."
);
args.addArg("m", "mipmap", "", "Create MipMap");
2016-01-23 11:28:40 +00:00
args.addArg("r", "reduce", "FACTOR", "Reduce the bitmap size before compressing\n FACTOR is 0, 1, 2, 3, 4, 5, 6, 7 or 8");
2016-01-23 09:27:34 +00:00
args.addAdditionalArg("input", "PNG or TGA files to convert", false);
if (!args.parse(argc, argv)) return 1;
string OptOutputFileName;
uint8 OptAlgo = NOT_DEFINED;
bool OptMipMap = false;
uint Reduce = 0;
if (args.haveArg("o"))
OptOutputFileName = args.getArg("o").front();
if (args.haveArg("a"))
{
std::string strAlgo = args.getArg("a").front();
if (strAlgo == "1") OptAlgo = DXT1;
else if (toLower(strAlgo) == "1a") OptAlgo = DXT1A;
else if (strAlgo == "3") OptAlgo = DXT3;
else if (strAlgo == "5") OptAlgo = DXT5;
else if (strAlgo == "tga8") OptAlgo = TGA8;
else if (strAlgo == "tga16") OptAlgo = TGA16;
else if (strAlgo == "png8") OptAlgo = PNG8;
else if (strAlgo == "png16") OptAlgo = PNG16;
else
{
cerr << "Unknown algorithm: " << strAlgo << endl;
return 1;
}
}
2016-01-23 09:27:34 +00:00
if (args.haveArg("r"))
{
2016-01-23 09:27:34 +00:00
std::string strReduce = args.getArg("r").front();
// Reduce size of the bitmap
if (fromString(strReduce, Reduce))
{
if (Reduce > 8) Reduce = 8;
}
}
2016-01-23 09:27:34 +00:00
std::vector<std::string> inputFileNames = args.getAdditionalArg("input");
2016-01-23 09:27:34 +00:00
for(uint i = 0; i < inputFileNames.size(); ++i)
{
2016-01-23 09:27:34 +00:00
uint8 algo;
2016-01-23 09:27:34 +00:00
// Reading TGA or PNG and converting to RGBA
//====================================
CBitmap picTga;
CBitmap picTga2;
CBitmap picSrc;
2016-01-23 09:27:34 +00:00
std::string inputFileName = inputFileNames[i];
2016-01-23 09:27:34 +00:00
if(inputFileName.find("_usercolor")<inputFileName.length())
{
return 0;
}
NLMISC::CIFile input;
if(!input.open(inputFileName))
{
cerr<<"Can't open input file " << inputFileName << endl;
return 1;
}
uint8 imageDepth = picTga.load(input);
if(imageDepth==0)
{
cerr<<"Can't load file: "<<inputFileName<<endl;
return 1;
}
if(imageDepth!=16 && imageDepth!=24 && imageDepth!=32 && imageDepth!=8)
{
cerr<<"Image not supported: "<<imageDepth<<endl;
return 1;
}
input.close();
uint32 height = picTga.getHeight();
uint32 width= picTga.getWidth();
picTga.convertToType (CBitmap::RGBA);
2016-01-23 09:27:34 +00:00
// Output file name and algo.
//===========================
std::string outputFileName;
if (!OptOutputFileName.empty())
{
// if OptOutputFileName is a directory, append the original filename
if (CFile::isDirectory(OptOutputFileName))
{
outputFileName = CPath::standardizePath(OptOutputFileName) + CFile::getFilename(getOutputFileName(inputFileName));
2016-01-23 09:27:34 +00:00
}
else
{
outputFileName = OptOutputFileName;
if (inputFileNames.size() > 1)
{
cerr<<"WARNING! Several files to convert to the same output filename! Use an output directory instead."<<endl;
return 1;
}
}
}
else
2016-01-23 09:27:34 +00:00
{
outputFileName = getOutputFileName(inputFileName);
}
2016-01-23 09:27:34 +00:00
// Check dest algo
if (OptAlgo==NOT_DEFINED)
OptAlgo = getType (outputFileName);
2016-01-23 09:27:34 +00:00
// Choose Algo.
if(OptAlgo!=NOT_DEFINED)
{
algo= OptAlgo;
}
else
{
// TODO: if alpha channel is 0, use DXTC1a instead DXTC1
if(imageDepth==24)
algo = DXT1;
else
algo = DXT5;
}
2016-01-23 09:27:34 +00:00
// Data check
//===========
if(dataCheck(inputFileName,outputFileName, OptAlgo, OptMipMap))
{
cout<<outputFileName<<" : a recent dds file already exists"<<endl;
return 0;
}
2016-01-23 09:27:34 +00:00
// Vectors for RGBA data
CObjectVector<uint8> RGBASrc = picTga.getPixels();
CObjectVector<uint8> RGBASrc2;
CObjectVector<uint8> RGBADest;
RGBADest.resize(height*width*4);
uint dstRGBADestId= 0;
// UserColor
//===========
/*
// Checking if option "usercolor" has been used
std::string userColorFileName;
if(argc>4)
{
2016-01-23 09:27:34 +00:00
if(strcmp("-usercolor",argv[4])==0)
{
if(argc!=6)
{
writeInstructions();
return;
}
userColorFileName = argv[5];
}
else
{
writeInstructions();
return;
}
2016-01-23 09:27:34 +00:00
}
*/
// Checking if associate usercolor file exists
std::string userColorFileName;
std::string::size_type pos = inputFileName.rfind(".");
if (pos == std::string::npos)
{
// name without extension
userColorFileName = inputFileName + "_usercolor";
}
else
{
2016-01-23 09:27:34 +00:00
// append input filename extension
userColorFileName = inputFileName.substr(0,pos) + "_usercolor" + inputFileName.substr(pos);
}
2016-01-23 09:27:34 +00:00
// Reading second Tga for user color, don't complain if _usercolor is missing
NLMISC::CIFile input2;
if (CPath::exists(userColorFileName) && input2.open(userColorFileName))
{
2016-01-23 09:27:34 +00:00
picTga2.load(input2);
uint32 height2 = picTga2.getHeight();
uint32 width2 = picTga2.getWidth();
nlassert(width2==width);
nlassert(height2==height);
picTga2.convertToType (CBitmap::RGBA);
RGBASrc2 = picTga2.getPixels();
NLMISC::CRGBA *pRGBASrc = (NLMISC::CRGBA*)&RGBASrc[0];
NLMISC::CRGBA *pRGBASrc2 = (NLMISC::CRGBA*)&RGBASrc2[0];
for(uint32 i = 0; i<width*height; i++)
{
2016-01-23 09:27:34 +00:00
// If no UserColor, must take same RGB, and keep same Alpha from src1 !!! So texture can have both alpha
// userColor and other alpha usage.
if(pRGBASrc2[i].A==255)
{
2016-01-23 09:27:34 +00:00
RGBADest[dstRGBADestId++]= pRGBASrc[i].R;
RGBADest[dstRGBADestId++]= pRGBASrc[i].G;
RGBADest[dstRGBADestId++]= pRGBASrc[i].B;
RGBADest[dstRGBADestId++]= pRGBASrc[i].A;
}
else
{
2016-01-23 09:27:34 +00:00
// Old code.
/*uint8 F = (uint8) ((float)pRGBASrc[i].R*0.3 + (float)pRGBASrc[i].G*0.56 + (float)pRGBASrc[i].B*0.14);
uint8 Frgb;
if((F*pRGBASrc2[i].A/255)==255)
Frgb = 0;
else
Frgb = (255-pRGBASrc2[i].A)/(255-F*pRGBASrc2[i].A/255);
RGBADest[dstRGBADestId++]= Frgb*pRGBASrc[i].R/255;
RGBADest[dstRGBADestId++]= Frgb*pRGBASrc[i].G/255;
RGBADest[dstRGBADestId++]= Frgb*pRGBASrc[i].B/255;
RGBADest[dstRGBADestId++]= F*pRGBASrc[i].A/255;*/
// New code: use new restrictions from IDriver.
float Rt, Gt, Bt, At;
float Lt;
float Rtm, Gtm, Btm, Atm;
// read 0-1 RGB pixel.
Rt= (float)pRGBASrc[i].R/255;
Gt= (float)pRGBASrc[i].G/255;
Bt= (float)pRGBASrc[i].B/255;
Lt= Rt*0.3f + Gt*0.56f + Bt*0.14f;
// take Alpha from userColor src.
At= (float)pRGBASrc2[i].A/255;
Atm= 1-Lt*(1-At);
// If normal case.
if(Atm>0)
{
Rtm= Rt*At / Atm;
Gtm= Gt*At / Atm;
Btm= Bt*At / Atm;
}
// Else special case: At==0, and Lt==1.
else
{
Rtm= Gtm= Btm= 0;
}
// copy to buffer.
sint r,g,b,a;
r= (sint)floor(Rtm*255+0.5f);
g= (sint)floor(Gtm*255+0.5f);
b= (sint)floor(Btm*255+0.5f);
a= (sint)floor(Atm*255+0.5f);
clamp(r, 0,255);
clamp(g, 0,255);
clamp(b, 0,255);
clamp(a, 0,255);
RGBADest[dstRGBADestId++]= r;
RGBADest[dstRGBADestId++]= g;
RGBADest[dstRGBADestId++]= b;
RGBADest[dstRGBADestId++]= a;
}
}
}
2016-01-23 09:27:34 +00:00
else
RGBADest = RGBASrc;
2016-01-23 09:27:34 +00:00
// Copy to the dest bitmap.
picSrc.resize(width, height, CBitmap::RGBA);
picSrc.getPixels(0)= RGBADest;
2016-01-23 09:27:34 +00:00
// Resize the destination bitmap ?
while (Reduce != 0)
{
2016-01-23 09:27:34 +00:00
dividSize (picSrc);
Reduce--;
}
2016-01-23 09:27:34 +00:00
if (algo == TGA16)
{
2016-01-23 09:27:34 +00:00
// Apply bayer dither
CObjectVector<uint8> &rgba = picSrc.getPixels(0);
const uint32 w = picSrc.getWidth(0);
uint32 x = 0;
uint32 y = 0;
for (uint32 i = 0; i < rgba.size(); i += 4)
{
2016-01-23 09:27:34 +00:00
NLMISC::CRGBA &c = reinterpret_cast<NLMISC::CRGBA &>(rgba[i]);
c.R = (uint8)std::min(255, (int)c.R + bayerDiv8R[x % 4][y % 4]);
c.G = (uint8)std::min(255, (int)c.G + bayerDiv8G[x % 4][y % 4]);
c.B = (uint8)std::min(255, (int)c.B + bayerDiv8B[x % 4][y % 4]);
++x;
x %= w;
if (x == 0)
++y;
}
2016-01-23 09:27:34 +00:00
}
// 8 or 16 bits TGA or PNG ?
if ((algo == TGA16) || (algo == TGA8) || (algo == PNG16) || (algo == PNG8))
{
// Saving TGA or PNG file
//=================
NLMISC::COFile output;
if(!output.open(outputFileName))
{
2016-01-23 09:27:34 +00:00
cerr<<"Can't open output file "<<outputFileName<<endl;
return 1;
}
2016-01-23 09:27:34 +00:00
try
{
2016-01-23 09:27:34 +00:00
if (algo == TGA16)
{
picSrc.writeTGA (output, 16);
}
else if (algo == TGA8)
{
picSrc.convertToType(CBitmap::Luminance);
picSrc.writeTGA (output, 8);
}
else if (algo == PNG16)
{
picSrc.writePNG (output, 16);
}
else if (algo == PNG8)
{
picSrc.convertToType(CBitmap::Luminance);
picSrc.writePNG (output, 8);
}
}
2016-01-23 09:27:34 +00:00
catch(const NLMISC::EWriteError &e)
{
2016-01-23 09:27:34 +00:00
cerr<<e.what()<<endl;
return 1;
}
2016-01-23 09:27:34 +00:00
output.close();
}
2016-01-23 09:27:34 +00:00
else
{
2016-01-23 09:27:34 +00:00
// Compress
//===========
2016-01-23 09:27:34 +00:00
// log.
std::string algostr;
switch(algo)
{
case DXT1:
algostr = "DXTC1";
break;
case DXT1A:
algostr = "DXTC1A";
break;
case DXT3:
algostr = "DXTC3";
break;
case DXT5:
algostr = "DXTC5";
break;
}
cout<<"compressing ("<<algostr<<") "<<inputFileName<<" to "<<outputFileName<<endl;
2016-01-23 09:27:34 +00:00
// Saving compressed DDS file
// =================
NLMISC::COFile output;
if(!output.open(outputFileName))
{
cerr<<"Can't open output file "<<outputFileName<<endl;
return 1;
}
try
{
CS3TCCompressor comp;
comp.compress(picSrc, OptMipMap, algo, output);
}
catch(const NLMISC::EWriteError &e)
{
cerr<<e.what()<<endl;
return 1;
}
2016-01-23 09:27:34 +00:00
output.close();
}
}
return 0;
2016-01-23 09:27:34 +00:00
}