 //---------------------------------------------------------------------------------------------
  typedef struct my_error_mgr  {
 struct jpeg_error_mgr pub;
jmp_buf setjmp_buffer;
 } *my_error_ptr;
METHODDEF void my_error_exit (j_common_ptr cinfo) {
my_error_ptr myerr = (my_error_ptr) cinfo->err;
longjmp(myerr->setjmp_buffer, 1);
}
//Number of simultaneous live strings.
//Libtiff uses a large number of strings simultaneously in a dialog, so this method
//was modified so that it iterates through a different number of buffers.
#define TIF_MAX_STRINGS 4
#define TIF_MAX_STRING_SIZE 256
//Declare this function as extern "C" so that the libtiff stuff can hook into it.
extern "C" TCHAR *GetString(int id)
{
static int bufPos=0;
static TCHAR buf[TIF_MAX_STRING_SIZE*TIF_MAX_STRINGS];
TCHAR* ret;
  if( LoadString(NULL, id, buf+bufPos, TIF_MAX_STRING_SIZE) ) {
ret = buf+bufPos;
bufPos += TIF_MAX_STRING_SIZE;
if( bufPos >= TIF_MAX_STRINGS*TIF_MAX_STRING_SIZE ) bufPos = 0;
return ret;
 }
return NULL;
}
//---------------------------------------------------------------------------------------------
void Eclinse::getExt(std::string & name)
{
int pos;
if( (pos = (int) name.find_last_of('.')) != name.npos ) {
int count = (int) name.length() - pos;
if( count > 5 )
count = 5;
name = name.substr( pos, count );
if( name[name.length() - 1] == '\\' )
name = name.substr( 0, name.length() - 1 );
}
}
//---------------------------------------------------------------------------------------------
ImageFile::ImageFile()
{
fp = NULL;
width = 0;
height = 0;
width1 = 0;
height1 = 0;
component = 0;
ypos = 0;
}
//---------------------------------------------------------------------------------------------
ImageFile::~ImageFile()
{
}
//---------------------------------------------------------------------------------------------
int ImageFile::GetWidth() const
{
return width;
}
//---------------------------------------------------------------------------------------------
int ImageFile::GetHeight() const
{
return height;
}
//---------------------------------------------------------------------------------------------
int ImageFile::GetComponent() const
{
return component;
}
//---------------------------------------------------------------------------------------------
RAWImageFile::RAWImageFile()
{
wb = 0;
}
//---------------------------------------------------------------------------------------------
RAWImageFile::~RAWImageFile()
{
Close();
}
//---------------------------------------------------------------------------------------------
bool RAWImageFile::GetInfo(const char *name, int & w, int & h, int & c)
{
Close();
if( (fp = fopen( name, "rb" )) == NULL )
return false;
fread( &w, sizeof(int), 1, fp );
fread( &h, sizeof(int), 1, fp );
fread( &c, sizeof(int), 1, fp );
Close();
return true;
}
//---------------------------------------------------------------------------------------------
bool RAWImageFile::Load(const char *name)
{
Close();
if( (fp = fopen( name, "rb" )) == NULL )
return false;
fread( &width, sizeof(int), 1, fp );
fread( &height, sizeof(int), 1, fp );
fread( &component, sizeof(int), 1, fp );
if( component != 3 && component != 4 )
return false;
width1 = width - 1;
height1 = height - 1;
ypos = 0;
wb = width * component;
return true;
}
//---------------------------------------------------------------------------------------------
void RAWImageFile::Close()
{
if( fp != NULL ) {
fclose( fp );
fp = NULL;
}
}
//---------------------------------------------------------------------------------------------
bool RAWImageFile::MoveToLine(int y)
{
if( fp == NULL || y < 0 || y >= height )
return false;
fseek( fp, y * wb, SEEK_SET );
ypos = y;
return true;
}
//---------------------------------------------------------------------------------------------
bool RAWImageFile::MoveToNextLine()
{
if( fp == NULL || ypos == height1 )
return false;
fseek( fp, wb, SEEK_CUR );
++ ypos;
return true;
}
//---------------------------------------------------------------------------------------------
void RAWImageFile::FormatSubLine(BYTE *BGRbuf, BYTE *Abuf, int x1, int x2)
{
if( fp == NULL )
return;
fseek( fp, x1 * component, SEEK_CUR );
if( component == 3 ) {
fread( BGRbuf, (x2 - x1) * component, 1, fp );
} else if( component == 4 ) {
for(int i = x1; i < x2; ++i) {
fread( BGRbuf, 3, 1, fp );
fread( Abuf, 1, 1, fp );
BGRbuf += 3;
++ Abuf;
}
}
fseek( fp, - x2 * component, SEEK_CUR );
}
//---------------------------------------------------------------------------------------------
BMPImageFile::BMPImageFile()
{
wb = 0;
}
//---------------------------------------------------------------------------------------------
BMPImageFile::~BMPImageFile()
{
Close();
}
//---------------------------------------------------------------------------------------------
bool BMPImageFile::GetInfo(const char *name, int & w, int & h, int & c)
{
Close();
if( (fp = fopen( name, "rb" )) == NULL )
return false;
BITMAPFILEHEADER bfhHeader;
fread( &bfhHeader, sizeof(BITMAPFILEHEADER), 1, fp );
if( bfhHeader.bfType != 0x4d42 ) {
fclose( fp );
return false;
}
UINT uBmpInfoLen = (UINT) bfhHeader.bfOffBits - sizeof(BITMAPFILEHEADER);
LPBITMAPINFOHEADER m_lpBMPHdr = (LPBITMAPINFOHEADER) new BYTE [ uBmpInfoLen ];
fread( m_lpBMPHdr, uBmpInfoLen, 1, fp );
if( m_lpBMPHdr->biSize != sizeof(BITMAPINFOHEADER) ||
m_lpBMPHdr->biBitCount != 24 ||
m_lpBMPHdr->biCompression != BI_RGB ) {
delete [] m_lpBMPHdr;
fclose( fp );
return false;
}
w = m_lpBMPHdr->biWidth;
h = m_lpBMPHdr->biHeight;
c = 4;
delete [] m_lpBMPHdr;
Close();
return true;
}
//---------------------------------------------------------------------------------------------
bool BMPImageFile::Load(const char *name)
{
Close();
if( (fp = fopen( name, "rb" )) == NULL )
return false;
BITMAPFILEHEADER bfhHeader;
fread( &bfhHeader, sizeof(BITMAPFILEHEADER), 1, fp );
if( bfhHeader.bfType != 0x4d42 ) {
fclose( fp );
return false;
}
UINT uBmpInfoLen = (UINT) bfhHeader.bfOffBits - sizeof(BITMAPFILEHEADER);
LPBITMAPINFOHEADER m_lpBMPHdr = (LPBITMAPINFOHEADER) new BYTE [ uBmpInfoLen ];
fread( m_lpBMPHdr, uBmpInfoLen, 1, fp );
if( m_lpBMPHdr->biSize != sizeof(BITMAPINFOHEADER) ||
m_lpBMPHdr->biBitCount != 24 ||
m_lpBMPHdr->biCompression != BI_RGB ) {
delete [] m_lpBMPHdr;
fclose( fp );
return false;
}
width = m_lpBMPHdr->biWidth;
height = m_lpBMPHdr->biHeight;
component = 3;
width1 = width - 1;
height1 = height - 1;
ypos = height1;
wb = (width * 3 + 3) & ~3;
delete [] m_lpBMPHdr;
return true;
}
//---------------------------------------------------------------------------------------------
void BMPImageFile::Close()
{
if( fp != NULL ) {
fclose( fp );
fp = NULL;
}
}
//---------------------------------------------------------------------------------------------
bool BMPImageFile::MoveToLine(int y)
{
if( fp == NULL || y < 0 || y >= height )
return false;
fseek( fp, 0, SEEK_END );
fseek( fp, - wb * (y + 1), SEEK_CUR );
ypos = y;
return true;
}
//---------------------------------------------------------------------------------------------
bool BMPImageFile::MoveToNextLine()
{
if( fp == NULL || ypos == height1 )
return false;
fseek( fp, - wb, SEEK_CUR );
++ ypos;
return true;
}
//---------------------------------------------------------------------------------------------
void BMPImageFile::FormatSubLine(BYTE *BGRbuf, BYTE *Abuf, int x1, int x2)
{
if( fp == NULL )
return;
fseek( fp, x1 * component, SEEK_CUR );
fread( BGRbuf, (x2 - x1) * component, 1, fp );
fseek( fp, - x2 * component, SEEK_CUR );
}
//---------------------------------------------------------------------------------------------
JPGImageFile::JPGImageFile()
{
}
//---------------------------------------------------------------------------------------------
JPGImageFile::~JPGImageFile()
{
Close();
}
//---------------------------------------------------------------------------------------------
bool JPGImageFile::GetInfo(const char *name, int & w, int & h, int & c)
{
Close();
if( (fp = fopen( name, "rb" ) ) == NULL )
return false;
struct jpeg_decompress_struct cinfo;
struct my_error_mgr jerr;
cinfo.err = jpeg_std_error( &jerr.pub );
jerr.pub.error_exit = my_error_exit;
if( setjmp(jerr.setjmp_buffer) ) {
jpeg_destroy_decompress( &cinfo );
return false;
}
jpeg_create_decompress( &cinfo );
jpeg_stdio_src( &cinfo, fp );
jpeg_read_header( &cinfo, TRUE );
jpeg_start_decompress( &cinfo );
if( cinfo.num_components != 3 && cinfo.num_components != 4 )
return false;
w = cinfo.output_width;
h = cinfo.output_height;
c = cinfo.num_components;
jpeg_destroy_decompress( &cinfo );
Close();
return true;
}
//---------------------------------------------------------------------------------------------
bool JPGImageFile::Load(const char *name)
{
Close();
if( (fp = fopen( name, "rb" ) ) == NULL )
return false;
struct jpeg_decompress_struct cinfo;
struct my_error_mgr jerr;
JSAMPARRAY buffer;
int row_stride;
FILE *tmpf = NULL;
cinfo.err = jpeg_std_error( &jerr.pub );
jerr.pub.error_exit = my_error_exit;
if( setjmp(jerr.setjmp_buffer) ) {
jpeg_destroy_decompress( &cinfo );
return false;
}
jpeg_create_decompress( &cinfo );
jpeg_stdio_src( &cinfo, fp );
jpeg_read_header( &cinfo, TRUE );
jpeg_start_decompress( &cinfo );
if( cinfo.num_components != 3 && cinfo.num_components != 4 )
return false;
width = cinfo.output_width;
height = cinfo.output_height;
component = cinfo.num_components;
width1 = width - 1;
height1 = height - 1;
ypos = 0;
row_stride = width * component;
buffer = (*cinfo.mem->alloc_sarray)
((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
tmpnam( tmpf_name );
if( (tmpf = fopen(tmpf_name, "wb")) == NULL ) {
jpeg_destroy_decompress( &cinfo );
return false;
}
fwrite( &width, sizeof(int), 1, tmpf );
fwrite( &height, sizeof(int), 1, tmpf );
fwrite( &component, sizeof(int), 1, tmpf );
while( cinfo.output_scanline < cinfo.output_height ) {
jpeg_read_scanlines( &cinfo, buffer, 1 );
BYTE *ptr = buffer[0];
if( component == 3 ) {
for(int i = 0; i < width; ++i) {
fwrite( ptr + 2, 1, 1, tmpf );
fwrite( ptr + 1, 1, 1, tmpf );
fwrite( ptr + 0, 1, 1, tmpf );
ptr += component;
}
} else if( component == 4 ) {
for(int i = 0; i < width; ++i) {
fwrite( ptr + 2, 1, 1, tmpf );
fwrite( ptr + 1, 1, 1, tmpf );
fwrite( ptr + 0, 1, 1, tmpf );
fwrite( ptr + 3, 1, 1, tmpf );
ptr += component;
}
}
};
fclose( tmpf );
jpeg_finish_decompress( &cinfo );
jpeg_destroy_decompress( &cinfo );
raw.Load( tmpf_name );
return true;
}
//---------------------------------------------------------------------------------------------
void JPGImageFile::Close()
{
if( fp != NULL ) {
fclose( fp );
fp = NULL;
}
raw.Close();
remove( tmpf_name );
}
//---------------------------------------------------------------------------------------------
bool JPGImageFile::MoveToLine(int y)
{
return raw.MoveToLine( y );
}
//---------------------------------------------------------------------------------------------
bool JPGImageFile::MoveToNextLine()
{
return raw.MoveToNextLine();
}
//---------------------------------------------------------------------------------------------
void JPGImageFile::FormatSubLine(BYTE *BGRbuf, BYTE *Abuf, int x1, int x2)
{
raw.FormatSubLine( BGRbuf, Abuf, x1, x2 );
}
//---------------------------------------------------------------------------------------------
TIFImageFile::TIFImageFile()
{
tif = NULL;
td = NULL;
loadbuf = NULL;
}
//---------------------------------------------------------------------------------------------
TIFImageFile::~TIFImageFile()
{
Close();
}
//---------------------------------------------------------------------------------------------
bool TIFImageFile::GetInfo(const char *name, int & w, int & h, int & c)
{
Close();
if( (tif = TIFFOpen( name, _T("r") )) == NULL )
return false;
td = &tif->tif_dir;
if( td->td_photometric != PHOTOMETRIC_RGB ||
(td->td_samplesperpixel != 3 && td->td_samplesperpixel != 4) ||
td->td_bitspersample != 8 )
return false;
w = td->td_imagewidth;
h = td->td_imagelength;
c = td->td_samplesperpixel;
Close();
return true;
}
//---------------------------------------------------------------------------------------------
bool TIFImageFile::Load(const char *name)
{
Close();
if( (tif = TIFFOpen( name, _T("r") )) == NULL )
return false;
td = &tif->tif_dir;
if( td->td_photometric != PHOTOMETRIC_RGB ||
(td->td_samplesperpixel != 3 && td->td_samplesperpixel != 4) ||
td->td_bitspersample != 8 )
return false;
width = td->td_imagewidth;
height = td->td_imagelength;
component = td->td_samplesperpixel;
width1 = width - 1;
height1 = height - 1;
ypos = 0;
loadbuf = new BYTE[ tif->tif_scanlinesize ];
return true;
}
//---------------------------------------------------------------------------------------------
void TIFImageFile::Close()
{
if( tif != NULL ) {
TIFFClose( tif );
tif = NULL;
td = NULL;
}
if( loadbuf != NULL ) {
delete [] loadbuf;
loadbuf = NULL;
}
}
//---------------------------------------------------------------------------------------------
bool TIFImageFile::MoveToLine(int y)
{
if( tif == NULL || y < 0 || y >= height )
return false;
ypos = y;
return true;
}
//---------------------------------------------------------------------------------------------
bool TIFImageFile::MoveToNextLine()
{
if( tif == NULL || ypos == height1 )
return false;
++ ypos;
return true;
}
//---------------------------------------------------------------------------------------------
void TIFImageFile::FormatSubLine(BYTE *BGRbuf, BYTE *Abuf, int x1, int x2)
{
if( tif == NULL )
return;
BYTE *dst, *ptr;
if( td->td_planarconfig == PLANARCONFIG_SEPARATE ) {
for(int i = 0; i < 3; ++i) {
TIFFReadScanline( tif, loadbuf, ypos, 2 - i );
dst = BGRbuf + i,
ptr = loadbuf + x1;
for(int x = x1; x < x2; ++x) {
dst[0] = ptr[0];
dst += 3;
++ ptr;
}
}
if( component == 4 ) {
TIFFReadScanline( tif, loadbuf, ypos, 3 );
dst = Abuf;
ptr = loadbuf + x1;
for(int x = x1; x < x2; ++x) {
dst[0] = ptr[0];
++ dst;
++ ptr;
}
}
} else {
TIFFReadScanline( tif, loadbuf, ypos, 0 );
ptr = loadbuf + x1 * component;
if( component == 3 ) {
for(int i = x1; i < x2; ++i) {
BGRbuf[0] = ptr[2];
BGRbuf[1] = ptr[1];
BGRbuf[2] = ptr[0];
BGRbuf += 3;
ptr += component;
}
} else if( component == 4 ) {
for(int i = x1; i < x2; ++i) {
BGRbuf[0] = ptr[2];
BGRbuf[1] = ptr[1];
BGRbuf[2] = ptr[0];
Abuf[0] = ptr[3];
BGRbuf += 3;
++ Abuf;
ptr += component;
}
}
}
}
//---------------------------------------------------------------------------------------------
|
浙公网安备 33010602011771号