You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
299 lines
7.6 KiB
299 lines
7.6 KiB
/* This file is part of ksquirrel-libs (http://ksquirrel.sf.net)
|
|
|
|
Copyright (c) 2004 Dmitry Baryshev <ksquirrel@tut.by>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation;
|
|
either version 2 of the License, or (at your option) any later
|
|
version.
|
|
|
|
This library 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
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
as32 with this library; see the file COPYING. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include <tiffio.h>
|
|
|
|
#include "ksquirrel-libs/fmt_types.h"
|
|
#include "ksquirrel-libs/fmt_utils.h"
|
|
#include "ksquirrel-libs/fileio.h"
|
|
#include "ksquirrel-libs/error.h"
|
|
|
|
#include "fmt_codec_tiff_defs.h"
|
|
#include "fmt_codec_tiff.h"
|
|
|
|
#include "../xpm/codec_tiff.xpm"
|
|
|
|
/*
|
|
*
|
|
* The TIFF specification was originally released in
|
|
* 1986 by Aldus Corporation as a standard method of storing
|
|
* black-and-white images created by scanners and desktop publishing
|
|
* applications. This first public release of TIFF was
|
|
* the third major revision of the TIFF format, and
|
|
* although it was not assigned a specific version number, this release
|
|
* may be thought of as TIFF Revision 3.0. The first
|
|
* widely used revision of TIFF, 4.0, was released in
|
|
* April 1987. TIFF 4.0 added support for uncompressed
|
|
* RGB color images and was quickly followed by the
|
|
* release of TIFF Revision 5.0 in August
|
|
* 1988. TIFF 5.0 was the first revision to add the
|
|
* capability of storing palette color images and support for the
|
|
* LZW compression algorithm. TIFF 6.0 was released in June
|
|
* 1992 and added support for CMYK and YCbCr color
|
|
*
|
|
*/
|
|
|
|
fmt_codec::fmt_codec() : fmt_codec_base()
|
|
{
|
|
compr[COMPRESSION_NONE] = "None";
|
|
compr[COMPRESSION_CCITTRLE] = "CCITTRLE";
|
|
compr[COMPRESSION_CCITTFAX3] = "CCITTFAX3";
|
|
compr[COMPRESSION_CCITT_T4] = "CCITT_T4";
|
|
compr[COMPRESSION_CCITTFAX4] = "CCITTFAX4";
|
|
compr[COMPRESSION_CCITT_T6] = "CCITT_T6";
|
|
compr[COMPRESSION_LZW] = "LZW";
|
|
compr[COMPRESSION_OJPEG] = "OJPEG";
|
|
compr[COMPRESSION_JPEG] = "JPEG";
|
|
compr[COMPRESSION_NEXT] = "NEXT";
|
|
compr[COMPRESSION_CCITTRLEW] = "CCITTRLEW";
|
|
compr[COMPRESSION_PACKBITS] = "PACKBITS";
|
|
compr[COMPRESSION_THUNDERSCAN] = "THUNDERSCAN";
|
|
compr[COMPRESSION_IT8CTPAD] = "IT8CTPAD";
|
|
compr[COMPRESSION_IT8LW] = "IT8LW";
|
|
compr[COMPRESSION_IT8MP] = "IT8MP";
|
|
compr[COMPRESSION_IT8BL] = "IT8BL";
|
|
compr[COMPRESSION_PIXARFILM] = "PIXARFILM";
|
|
compr[COMPRESSION_PIXARLOG] = "PIXARLOG";
|
|
compr[COMPRESSION_DEFLATE] = "DEFLATE";
|
|
compr[COMPRESSION_ADOBE_DEFLATE] = "Adobe DEFLATE";
|
|
compr[COMPRESSION_DCS] = "DCS";
|
|
compr[COMPRESSION_JBIG] = "JBIG";
|
|
compr[COMPRESSION_SGILOG] = "SGILOG";
|
|
compr[COMPRESSION_SGILOG24] = "SGILOG24";
|
|
compr[COMPRESSION_JP2000] = "JP2000";
|
|
}
|
|
|
|
fmt_codec::~fmt_codec()
|
|
{}
|
|
|
|
void fmt_codec::options(codec_options *o)
|
|
{
|
|
o->version = "1.0.1";
|
|
o->name = "Tagged Image File Format";
|
|
o->filter = "*.tif *.tiff ";
|
|
o->config = std::string(TIFF_UI);
|
|
o->mime = "";
|
|
o->mimetype = "image/tiff";
|
|
o->pixmap = codec_tiff;
|
|
o->readable = true;
|
|
o->canbemultiple = true;
|
|
o->writestatic = true;
|
|
o->writeanimated = false;
|
|
o->needtempfile = false;
|
|
}
|
|
|
|
void fmt_codec::fill_default_settings()
|
|
{
|
|
settings_value val;
|
|
|
|
val.type = settings_value::v_int;
|
|
val.iVal = 1;
|
|
|
|
m_settings["pages"] = val;
|
|
}
|
|
|
|
s32 fmt_codec::read_init(const std::string &file)
|
|
{
|
|
currentImage = -1;
|
|
|
|
if((ftiff = TIFFOpen(file.c_str(), "r")) == NULL)
|
|
return SQE_R_BADFILE;
|
|
|
|
TIFFSetWarningHandler(NULL);
|
|
TIFFSetErrorHandler(NULL);
|
|
|
|
finfo.animated = false;
|
|
|
|
fmt_settings::iterator it = m_settings.find("pages");
|
|
|
|
pages = (it == m_settings.end() || (*it).second.type != settings_value::v_int) ?
|
|
1 : (*it).second.iVal;
|
|
|
|
if(pages < 1 || pages > 1000)
|
|
pages = 1;
|
|
|
|
dircount = 0;
|
|
|
|
while(TIFFReadDirectory(ftiff))
|
|
dircount++;
|
|
|
|
TIFFSetDirectory(ftiff, 0);
|
|
|
|
return SQE_OK;
|
|
}
|
|
|
|
s32 fmt_codec::read_next()
|
|
{
|
|
currentImage++;
|
|
|
|
if(currentImage == pages)
|
|
return SQE_NOTOK;
|
|
|
|
if(dircount)
|
|
{
|
|
if(currentImage == dircount)
|
|
return SQE_NOTOK;
|
|
}
|
|
else
|
|
if(currentImage)
|
|
return SQE_NOTOK;
|
|
|
|
if(dircount != 1 && dircount != 0)
|
|
if(!TIFFReadDirectory(ftiff))
|
|
return SQE_R_BADFILE;
|
|
|
|
if(currentImage)
|
|
TIFFRGBAImageEnd(&img);
|
|
|
|
fmt_image image;
|
|
|
|
s32 bps, spp;
|
|
|
|
TIFFGetField(ftiff, TIFFTAG_IMAGEWIDTH, &image.w);
|
|
TIFFGetField(ftiff, TIFFTAG_IMAGELENGTH, &image.h);
|
|
|
|
memset(&img, 0, sizeof(TIFFRGBAImage));
|
|
|
|
TIFFRGBAImageBegin(&img, ftiff, 1, 0);
|
|
|
|
bps = img.bitspersample;
|
|
spp = img.samplesperpixel;
|
|
|
|
s16 cmp;
|
|
TIFFGetField(ftiff, TIFFTAG_COMPRESSION, &cmp);
|
|
std::map<s32, std::string>::iterator it = compr.find(cmp);
|
|
|
|
image.bpp = bps * spp;
|
|
image.compression = (it == compr.end() ? "Unknown" : (*it).second);
|
|
image.hasalpha = true;
|
|
image.colorspace = fmt_utils::colorSpaceByBpp(image.bpp);
|
|
|
|
finfo.image.push_back(image);
|
|
|
|
return SQE_OK;
|
|
}
|
|
|
|
s32 fmt_codec::read_next_pass()
|
|
{
|
|
return SQE_OK;
|
|
}
|
|
|
|
s32 fmt_codec::read_scanline(RGBA *scan)
|
|
{
|
|
fmt_image *im = image(currentImage);
|
|
const s32 W = im->w * sizeof(RGBA);
|
|
|
|
uint32 buf[W];
|
|
|
|
TIFFRGBAImageGet(&img, buf, im->w, 1);
|
|
|
|
memcpy(scan, buf, W);
|
|
|
|
img.row_offset++;
|
|
|
|
return SQE_OK;
|
|
}
|
|
|
|
void fmt_codec::read_close()
|
|
{
|
|
TIFFRGBAImageEnd(&img);
|
|
TIFFClose(ftiff);
|
|
|
|
finfo.meta.clear();
|
|
finfo.image.clear();
|
|
}
|
|
|
|
void fmt_codec::getwriteoptions(fmt_writeoptionsabs *opt)
|
|
{
|
|
opt->interlaced = false;
|
|
opt->compression_scheme = CompressionRLE;
|
|
opt->compression_min = 0;
|
|
opt->compression_max = 0;
|
|
opt->compression_def = 0;
|
|
opt->passes = 1;
|
|
opt->needflip = false;
|
|
opt->palette_flags = 0 | fmt_image::pure32;
|
|
}
|
|
|
|
s32 fmt_codec::write_init(const std::string &file, const fmt_image &image, const fmt_writeoptions &opt)
|
|
{
|
|
if(!image.w || !image.h || file.empty())
|
|
return SQE_W_WRONGPARAMS;
|
|
|
|
writeimage = image;
|
|
writeopt = opt;
|
|
|
|
out = TIFFOpen(file.c_str(), "w");
|
|
|
|
if(!out)
|
|
return SQE_W_NOFILE;
|
|
|
|
return SQE_OK;
|
|
}
|
|
|
|
s32 fmt_codec::write_next()
|
|
{
|
|
TIFFSetField(out, TIFFTAG_IMAGEWIDTH, writeimage.w);
|
|
TIFFSetField(out, TIFFTAG_IMAGELENGTH, writeimage.h);
|
|
TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
|
|
TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 4);
|
|
TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
|
|
TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
|
|
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
|
|
TIFFSetField(out, TIFFTAG_COMPRESSION, (writeopt.compression_scheme == CompressionRLE ? COMPRESSION_PACKBITS : COMPRESSION_NONE));
|
|
TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(out, (uint32) -1));
|
|
|
|
line = -1;
|
|
|
|
return SQE_OK;
|
|
}
|
|
|
|
s32 fmt_codec::write_next_pass()
|
|
{
|
|
return SQE_OK;
|
|
}
|
|
|
|
s32 fmt_codec::write_scanline(RGBA *scan)
|
|
{
|
|
++line;
|
|
|
|
if(TIFFWriteScanline(out, (u8 *)scan, line, 0) < 0)
|
|
return SQE_W_ERROR;
|
|
|
|
return SQE_OK;
|
|
}
|
|
|
|
void fmt_codec::write_close()
|
|
{
|
|
TIFFClose(out);
|
|
}
|
|
|
|
std::string fmt_codec::extension(const s32 /*bpp*/)
|
|
{
|
|
return std::string("tiff");
|
|
}
|
|
|
|
#include "fmt_codec_cd_func.h"
|