i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial check in for TIFFTranslator - libtiff (http://www.libtiff.org/) version. Old non-lib based TIFFTranslator remains, but is no longer part of build process. This translator provides the same TIFF reading capability as Be's version (as far as I can tell) with the addition of support for multi-page TIFF files.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@4016 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Matthew Wilber
2003-07-19 16:40:33 +00:00
parent 67ae0ccc24
commit 78c02e525a
51 changed files with 22264 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/translators/libtifftranslator/Jamfile
+41
View File
@@ -0,0 +1,41 @@
SubDir OBOS_TOP src add-ons translators libtifftranslator ;
Translator TIFFTranslator :
tif_aux.c
tif_close.c
tif_codec.c
tif_compress.c
tif_dir.c
tif_dirinfo.c
tif_dirread.c
tif_dirwrite.c
tif_dumpmode.c
tif_error.c
tif_extension.c
tif_fax3.c
tif_fax3sm.c
tif_flush.c
tif_getimage.c
tif_luv.c
tif_lzw.c
tif_next.c
tif_open.c
tif_packbits.c
tif_predict.c
tif_print.c
tif_read.c
tif_strip.c
tif_swab.c
tif_thunder.c
tif_tile.c
tif_unix.c
tif_version.c
tif_warning.c
tif_write.c
tif_zip.c
TIFFMain.cpp
TIFFTranslator.cpp
TIFFView.cpp
TIFFWindow.cpp ;
LinkSharedOSLibs TIFFTranslator : be translation ;
src/add-ons/translators/libtifftranslator/TIFFMain.cpp
+103
View File
@@ -0,0 +1,103 @@
/*****************************************************************************/
// TIFFTranslator
// Written by Michael Wilber, OBOS Translation Kit Team
//
// Version:
//
// This translator opens and writes TIFF images.
//
//
// This application and all source files used in its construction, except
// where noted, are licensed under the MIT License, and have been written
// and are:
//
// Copyright (c) 2003 OpenBeOS Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#include <Application.h>
#include <Screen.h>
#include <Alert.h>
#include "TIFFTranslator.h"
#include "TIFFWindow.h"
#include "TIFFView.h"
// ---------------------------------------------------------------
// main
//
// Creates a BWindow for displaying info about the TIFFTranslator
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
int
main()
{
BApplication app("application/x-vnd.obos-tiff-translator");
TIFFTranslator *ptranslator = new TIFFTranslator;
BView *view = NULL;
BRect rect(0, 0, 225, 175);
if (ptranslator->MakeConfigurationView(NULL, &view, &rect)) {
BAlert *err = new BAlert("Error",
"Unable to create the TIFFTranslator view.", "OK");
err->Go();
return 1;
}
// release the translator even though I never really used it anyway
ptranslator->Release();
ptranslator = NULL;
TIFFWindow *wnd = new TIFFWindow(rect);
view->ResizeTo(rect.Width(), rect.Height());
wnd->AddChild(view);
BPoint wndpt = B_ORIGIN;
{
BScreen scrn;
BRect frame = scrn.Frame();
frame.InsetBy(10, 23);
// if the point is outside of the screen frame,
// use the mouse location to find a better point
if (!frame.Contains(wndpt)) {
uint32 dummy;
view->GetMouse(&wndpt, &dummy, false);
wndpt.x -= rect.Width() / 2;
wndpt.y -= rect.Height() / 2;
// clamp location to screen
if (wndpt.x < frame.left)
wndpt.x = frame.left;
if (wndpt.y < frame.top)
wndpt.y = frame.top;
if (wndpt.x > frame.right)
wndpt.x = frame.right;
if (wndpt.y > frame.bottom)
wndpt.y = frame.bottom;
}
}
wnd->MoveTo(wndpt);
wnd->Show();
app.Run();
return 0;
}
src/add-ons/translators/libtifftranslator/TIFFTranslator.cpp
+809
View File
@@ -0,0 +1,809 @@
/*****************************************************************************/
// TIFFTranslator
// Written by Michael Wilber, OBOS Translation Kit Team
//
// TIFFTranslator.cpp
//
// This BTranslator based object is for opening and writing
// TIFF images.
//
//
// Copyright (c) 2003 OpenBeOS Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#include <stdio.h>
#include <string.h>
#include "tiffio.h"
#include "TIFFTranslator.h"
#include "TIFFView.h"
// The input formats that this translator supports.
translation_format gInputFormats[] = {
{
B_TRANSLATOR_BITMAP,
B_TRANSLATOR_BITMAP,
BBT_IN_QUALITY,
BBT_IN_CAPABILITY,
"image/x-be-bitmap",
"Be Bitmap Format (TIFFTranslator)"
},
{
B_TIFF_FORMAT,
B_TRANSLATOR_BITMAP,
TIFF_IN_QUALITY,
TIFF_IN_CAPABILITY,
"image/tiff",
"TIFF image"
}
};
// The output formats that this translator supports.
translation_format gOutputFormats[] = {
{
B_TRANSLATOR_BITMAP,
B_TRANSLATOR_BITMAP,
BBT_OUT_QUALITY,
BBT_OUT_CAPABILITY,
"image/x-be-bitmap",
"Be Bitmap Format (TIFFTranslator)"
}
};
// ---------------------------------------------------------------
// make_nth_translator
//
// Creates a TIFFTranslator object to be used by BTranslatorRoster
//
// Preconditions:
//
// Parameters: n, The translator to return. Since
// TIFFTranslator only publishes one
// translator, it only returns a
// TIFFTranslator if n == 0
//
// you, The image_id of the add-on that
// contains code (not used).
//
// flags, Has no meaning yet, should be 0.
//
// Postconditions:
//
// Returns: NULL if n is not zero,
// a new TIFFTranslator if n is zero
// ---------------------------------------------------------------
BTranslator *
make_nth_translator(int32 n, image_id you, uint32 flags, ...)
{
if (!n)
return new TIFFTranslator();
else
return NULL;
}
//// libtiff Callback functions!
BPositionIO *
tiff_get_pio(thandle_t stream)
{
BPositionIO *pio = NULL;
pio = static_cast<BPositionIO *>(stream);
if (!pio)
debugger("pio is NULL");
return pio;
}
tsize_t
tiff_read_proc(thandle_t stream, tdata_t buf, tsize_t size)
{
return tiff_get_pio(stream)->Read(buf, size);
}
tsize_t
tiff_write_proc(thandle_t stream, tdata_t buf, tsize_t size)
{
return tiff_get_pio(stream)->Write(buf, size);
}
toff_t
tiff_seek_proc(thandle_t stream, toff_t off, int whence)
{
return tiff_get_pio(stream)->Seek(off, whence);
}
int
tiff_close_proc(thandle_t stream)
{
tiff_get_pio(stream)->Seek(0, SEEK_SET);
return 0;
}
toff_t
tiff_size_proc(thandle_t stream)
{
BPositionIO *pio = tiff_get_pio(stream);
off_t cur, end;
cur = pio->Position();
end = pio->Seek(0, SEEK_END);
pio->Seek(cur, SEEK_SET);
return end;
}
int
tiff_map_file_proc(thandle_t stream, tdata_t *pbase, toff_t *psize)
{
// BeOS doesn't support mmap() so just return 0
return 0;
}
void
tiff_unmap_file_proc(thandle_t stream, tdata_t base, toff_t size)
{
return;
}
// ---------------------------------------------------------------
// Constructor
//
// Sets up the version info and the name of the translator so that
// these values can be returned when they are requested.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
TIFFTranslator::TIFFTranslator()
: BTranslator()
{
strcpy(fName, "TIFF Images");
sprintf(fInfo, "TIFF image translator v%d.%d.%d %s",
TIFF_TRANSLATOR_VERSION / 100, (TIFF_TRANSLATOR_VERSION / 10) % 10,
TIFF_TRANSLATOR_VERSION % 10, __DATE__);
}
// ---------------------------------------------------------------
// Destructor
//
// Does nothing
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
TIFFTranslator::~TIFFTranslator()
{
}
// ---------------------------------------------------------------
// TranslatorName
//
// Returns the short name of the translator.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns: a const char * to the short name of the translator
// ---------------------------------------------------------------
const char *
TIFFTranslator::TranslatorName() const
{
return fName;
}
// ---------------------------------------------------------------
// TranslatorInfo
//
// Returns a more verbose name for the translator than the one
// TranslatorName() returns. This usually includes version info.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns: a const char * to the verbose name of the translator
// ---------------------------------------------------------------
const char *
TIFFTranslator::TranslatorInfo() const
{
return fInfo;
}
// ---------------------------------------------------------------
// TranslatorVersion
//
// Returns the integer representation of the current version of
// this translator.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
int32
TIFFTranslator::TranslatorVersion() const
{
return TIFF_TRANSLATOR_VERSION;
}
// ---------------------------------------------------------------
// InputFormats
//
// Returns a list of input formats supported by this translator.
//
// Preconditions:
//
// Parameters: out_count, The number of input formats
// support is returned here.
//
// Postconditions:
//
// Returns: the list of input formats and the number of input
// formats through the out_count parameter, if out_count is NULL,
// NULL is returned
// ---------------------------------------------------------------
const translation_format *
TIFFTranslator::InputFormats(int32 *out_count) const
{
if (out_count) {
*out_count = sizeof(gInputFormats) /
sizeof(translation_format);
return gInputFormats;
} else
return NULL;
}
// ---------------------------------------------------------------
// OutputFormats
//
// Returns a list of output formats supported by this translator.
//
// Preconditions:
//
// Parameters: out_count, The number of output formats
// support is returned here.
//
// Postconditions:
//
// Returns: the list of output formats and the number of output
// formats through the out_count parameter, if out_count is NULL,
// NULL is returned
// ---------------------------------------------------------------
const translation_format *
TIFFTranslator::OutputFormats(int32 *out_count) const
{
if (out_count) {
*out_count = sizeof(gOutputFormats) /
sizeof(translation_format);
return gOutputFormats;
} else
return NULL;
}
// ---------------------------------------------------------------
// identify_bits_header
//
// Determines if the data in inSource is in the
// B_TRANSLATOR_BITMAP ('bits') format. If it is, it returns
// info about the data in inSource to outInfo and pheader.
//
// Preconditions:
//
// Parameters: inSource, The source of the image data
//
// outInfo, Information about the translator
// is copied here
//
// amtread, Amount of data read from inSource
// before this function was called
//
// read, Pointer to the data that was read
// in before this function was called
//
// pheader, The bits header is copied here after
// it is read in from inSource
//
// Postconditions:
//
// Returns: B_NO_TRANSLATOR, if the data does not look like
// bits format data
//
// B_ERROR, if the header data could not be converted to host
// format
//
// B_OK, if the data looks like bits data and no errors were
// encountered
// ---------------------------------------------------------------
status_t
identify_bits_header(BPositionIO *inSource, translator_info *outInfo,
ssize_t amtread, uint8 *read, TranslatorBitmap *pheader = NULL)
{
TranslatorBitmap header;
memcpy(&header, read, amtread);
// copy portion of header already read in
// read in the rest of the header
ssize_t size = sizeof(TranslatorBitmap) - amtread;
if (inSource->Read(
(reinterpret_cast<uint8 *> (&header)) + amtread, size) != size)
return B_NO_TRANSLATOR;
// convert to host byte order
if (swap_data(B_UINT32_TYPE, &header, sizeof(TranslatorBitmap),
B_SWAP_BENDIAN_TO_HOST) != B_OK)
return B_ERROR;
// check if header values are reasonable
if (header.colors != B_RGB32 &&
header.colors != B_RGB32_BIG &&
header.colors != B_RGBA32 &&
header.colors != B_RGBA32_BIG &&
header.colors != B_RGB24 &&
header.colors != B_RGB24_BIG &&
header.colors != B_RGB16 &&
header.colors != B_RGB16_BIG &&
header.colors != B_RGB15 &&
header.colors != B_RGB15_BIG &&
header.colors != B_RGBA15 &&
header.colors != B_RGBA15_BIG &&
header.colors != B_CMAP8 &&
header.colors != B_GRAY8 &&
header.colors != B_GRAY1 &&
header.colors != B_CMYK32 &&
header.colors != B_CMY32 &&
header.colors != B_CMYA32 &&
header.colors != B_CMY24)
return B_NO_TRANSLATOR;
if (header.rowBytes * (header.bounds.Height() + 1) != header.dataSize)
return B_NO_TRANSLATOR;
if (outInfo) {
outInfo->type = B_TRANSLATOR_BITMAP;
outInfo->group = B_TRANSLATOR_BITMAP;
outInfo->quality = BBT_IN_QUALITY;
outInfo->capability = BBT_IN_CAPABILITY;
strcpy(outInfo->name, "Be Bitmap Format (TIFFTranslator)");
strcpy(outInfo->MIME, "image/x-be-bitmap");
}
if (pheader) {
pheader->magic = header.magic;
pheader->bounds = header.bounds;
pheader->rowBytes = header.rowBytes;
pheader->colors = header.colors;
pheader->dataSize = header.dataSize;
}
return B_OK;
}
status_t
identify_tiff_header(BPositionIO *inSource, BMessage *ioExtension,
translator_info *outInfo, uint32 outType, TIFF **poutTIFF = NULL)
{
// Can only output to bits for now
if (outType != B_TRANSLATOR_BITMAP)
return B_NO_TRANSLATOR;
// reset pos to start
inSource->Seek(0, SEEK_SET);
// get TIFF handle
TIFF* tif = TIFFClientOpen("TIFFTranslator", "r", inSource,
tiff_read_proc, tiff_write_proc, tiff_seek_proc, tiff_close_proc,
tiff_size_proc, tiff_map_file_proc, tiff_unmap_file_proc);
if (!tif)
return B_NO_TRANSLATOR;
// count number of documents
int32 document_count = 0, document_index = 1;
do {
document_count++;
} while (TIFFReadDirectory(tif));
if (ioExtension) {
// add page count to ioExtension
ioExtension->RemoveName(DOCUMENT_COUNT);
ioExtension->AddInt32(DOCUMENT_COUNT, document_count);
// Check if a document index has been specified
ioExtension->FindInt32(DOCUMENT_INDEX, &document_index);
if (document_index < 1 || document_index > document_count)
return B_NO_TRANSLATOR;
}
// identify the document the user specified or the first document
// if the user did not specify which document they wanted to identify
if (document_index != 1 && !TIFFSetDirectory(tif, document_index - 1))
return B_NO_TRANSLATOR;
if (outInfo) {
outInfo->type = B_TIFF_FORMAT;
outInfo->group = B_TRANSLATOR_BITMAP;
outInfo->quality = TIFF_IN_QUALITY;
outInfo->capability = TIFF_IN_CAPABILITY;
strcpy(outInfo->MIME, "image/tiff");
strcpy(outInfo->name, "TIFF image");
}
if (!poutTIFF)
// close TIFF if caller is not interested in TIFF handle
TIFFClose(tif);
else
// leave TIFF open and return handle if caller needs it
*poutTIFF = tif;
return B_OK;
}
// ---------------------------------------------------------------
// Identify
//
// Examines the data from inSource and determines if it is in a
// format that this translator knows how to work with.
//
// Preconditions:
//
// Parameters: inSource, where the data to examine is
//
// inFormat, a hint about the data in inSource,
// it is ignored since it is only a hint
//
// ioExtension, configuration settings for the
// translator (not used)
//
// outInfo, information about what data is in
// inSource and how well this translator
// can handle that data is stored here
//
// outType, The format that the user wants
// the data in inSource to be
// converted to
//
// Postconditions:
//
// Returns: B_NO_TRANSLATOR, if this translator can't handle
// the data in inSource
//
// B_ERROR, if there was an error converting the data to the host
// format
//
// B_BAD_VALUE, if the settings in ioExtension are bad
//
// B_OK, if this translator understood the data and there were
// no errors found
//
// Other errors if BPositionIO::Read() returned an error value
// ---------------------------------------------------------------
status_t
TIFFTranslator::Identify(BPositionIO *inSource,
const translation_format *inFormat, BMessage *ioExtension,
translator_info *outInfo, uint32 outType)
{
if (!outType)
outType = B_TRANSLATOR_BITMAP;
if (outType != B_TRANSLATOR_BITMAP && outType != B_TIFF_FORMAT)
return B_NO_TRANSLATOR;
// Convert the magic numbers to the various byte orders so that
// I won't have to convert the data read in to see whether or not
// it is a supported type
uint32 nbits = B_TRANSLATOR_BITMAP;
if (swap_data(B_UINT32_TYPE, &nbits, sizeof(uint32),
B_SWAP_HOST_TO_BENDIAN) != B_OK)
return B_ERROR;
// Read in the magic number and determine if it
// is a supported type
uint8 ch[4];
if (inSource->Read(ch, 4) != 4)
return B_NO_TRANSLATOR;
// Read settings from ioExtension
bool bheaderonly = false, bdataonly = false;
if (ioExtension) {
if (ioExtension->FindBool(B_TRANSLATOR_EXT_HEADER_ONLY, &bheaderonly))
// if failed, make sure bool is default value
bheaderonly = false;
if (ioExtension->FindBool(B_TRANSLATOR_EXT_DATA_ONLY, &bdataonly))
// if failed, make sure bool is default value
bdataonly = false;
if (bheaderonly && bdataonly)
// can't both "only write the header" and "only write the data"
// at the same time
return B_BAD_VALUE;
}
uint32 n32ch;
memcpy(&n32ch, ch, sizeof(uint32));
// if B_TRANSLATOR_BITMAP type
if (n32ch == nbits)
return identify_bits_header(inSource, outInfo, 4, ch);
// Might be TIFF image
else {
// TIFF Byte Order / Magic
const uint8 kleSig[] = { 0x49, 0x49, 0x2a, 0x00 };
const uint8 kbeSig[] = { 0x4d, 0x4d, 0x00, 0x2a };
if (memcmp(ch, kleSig, 4) != 0 && memcmp(ch, kbeSig, 4) != 0)
// If not a TIFF or a Be Bitmap image
// (invalid byte order value)
return B_NO_TRANSLATOR;
return identify_tiff_header(inSource, ioExtension, outInfo, outType);
}
}
status_t
translate_from_tiff(BPositionIO *inSource, BMessage *ioExtension,
uint32 outType, BPositionIO *outDestination, bool bheaderonly,
bool bdataonly)
{
status_t result = B_NO_TRANSLATOR;
// variables needing cleanup
TIFF *ptif = NULL;
uint32 *praster = NULL;
status_t ret;
ret = identify_tiff_header(inSource, ioExtension, NULL, outType, &ptif);
while (ret == B_OK && ptif) {
// use while / break not for looping, but for
// cleaner goto like capability
ret = B_ERROR;
// make certain there is no looping
uint32 width = 0, height = 0;
if (!TIFFGetField(ptif, TIFFTAG_IMAGEWIDTH, &width)) {
result = B_NO_TRANSLATOR;
break;
}
if (!TIFFGetField(ptif, TIFFTAG_IMAGELENGTH, &height)) {
result = B_NO_TRANSLATOR;
break;
}
size_t npixels = 0;
npixels = width * height;
praster = static_cast<uint32 *>(_TIFFmalloc(npixels * 4));
if (praster && TIFFReadRGBAImage(ptif, width, height, praster, 0)) {
if (!bdataonly) {
// Construct and write Be bitmap header
TranslatorBitmap bitsHeader;
bitsHeader.magic = B_TRANSLATOR_BITMAP;
bitsHeader.bounds.left = 0;
bitsHeader.bounds.top = 0;
bitsHeader.bounds.right = width - 1;
bitsHeader.bounds.bottom = height - 1;
bitsHeader.rowBytes = 4 * width;
bitsHeader.colors = B_RGBA32;
bitsHeader.dataSize = bitsHeader.rowBytes * height;
if (swap_data(B_UINT32_TYPE, &bitsHeader,
sizeof(TranslatorBitmap), B_SWAP_HOST_TO_BENDIAN) != B_OK) {
result = B_ERROR;
break;
}
outDestination->Write(&bitsHeader, sizeof(TranslatorBitmap));
}
if (!bheaderonly) {
// Convert raw RGBA data to B_RGBA32 colorspace
// and write out the results
uint8 *pbitsrow = new uint8[width * 4];
if (!pbitsrow) {
result = B_NO_MEMORY;
break;
}
uint8 *pras8 = reinterpret_cast<uint8 *>(praster);
for (uint32 i = 0; i < height; i++) {
uint8 *pbits, *prgba;
pbits = pbitsrow;
prgba = pras8 + ((height - (i + 1)) * width * 4);
for (uint32 k = 0; k < width; k++) {
pbits[0] = prgba[2];
pbits[1] = prgba[1];
pbits[2] = prgba[0];
pbits[3] = prgba[3];
pbits += 4;
prgba += 4;
}
outDestination->Write(pbitsrow, width * 4);
}
delete[] pbitsrow;
pbitsrow = NULL;
}
result = B_OK;
break;
} // if (praster && TIFFReadRGBAImage(ptif, width, height, praster, 0))
} // while (ret == B_OK && ptif)
if (praster) {
_TIFFfree(praster);
praster = NULL;
}
if (ptif) {
TIFFClose(ptif);
ptif = NULL;
}
return result;
}
// ---------------------------------------------------------------
// Translate
//
// Translates the data in inSource to the type outType and stores
// the translated data in outDestination.
//
// Preconditions:
//
// Parameters: inSource, the data to be translated
//
// inInfo, hint about the data in inSource (not used)
//
// ioExtension, configuration options for the
// translator
//
// outType, the type to convert inSource to
//
// outDestination, where the translated data is
// put
//
// Postconditions:
//
// Returns: B_BAD_VALUE, if the options in ioExtension are bad
//
// B_NO_TRANSLATOR, if this translator doesn't understand the data
//
// B_ERROR, if there was an error allocating memory or converting
// data
//
// B_OK, if all went well
// ---------------------------------------------------------------
status_t
TIFFTranslator::Translate(BPositionIO *inSource,
const translator_info *inInfo, BMessage *ioExtension,
uint32 outType, BPositionIO *outDestination)
{
if (!outType)
outType = B_TRANSLATOR_BITMAP;
if (outType != B_TRANSLATOR_BITMAP && outType != B_TIFF_FORMAT)
return B_NO_TRANSLATOR;
// Convert the magic numbers to the various byte orders so that
// I won't have to convert the data read in to see whether or not
// it is a supported type
uint32 nbits = B_TRANSLATOR_BITMAP;
if (swap_data(B_UINT32_TYPE, &nbits, sizeof(uint32),
B_SWAP_HOST_TO_BENDIAN) != B_OK)
return B_ERROR;
// Read in the magic number and determine if it
// is a supported type
uint8 ch[4];
inSource->Seek(0, SEEK_SET);
if (inSource->Read(ch, 4) != 4)
return B_NO_TRANSLATOR;
// Read settings from ioExtension
bool bheaderonly = false, bdataonly = false;
if (ioExtension) {
if (ioExtension->FindBool(B_TRANSLATOR_EXT_HEADER_ONLY, &bheaderonly))
// if failed, make sure bool is default value
bheaderonly = false;
if (ioExtension->FindBool(B_TRANSLATOR_EXT_DATA_ONLY, &bdataonly))
// if failed, make sure bool is default value
bdataonly = false;
if (bheaderonly && bdataonly)
// can't both "only write the header" and "only write the data"
// at the same time
return B_BAD_VALUE;
}
uint32 n32ch;
memcpy(&n32ch, ch, sizeof(uint32));
if (n32ch == nbits) {
// B_TRANSLATOR_BITMAP type
inSource->Seek(0, SEEK_SET);
const size_t kbufsize = 2048;
uint8 buffer[kbufsize];
ssize_t ret = inSource->Read(buffer, kbufsize);
while (ret > 0) {
outDestination->Write(buffer, ret);
ret = inSource->Read(buffer, kbufsize);
}
return B_OK;
} else
// Might be TIFF image
return translate_from_tiff(inSource, ioExtension, outType,
outDestination, bheaderonly, bdataonly);
}
// ---------------------------------------------------------------
// MakeConfigurationView
//
// Makes a BView object for configuring / displaying info about
// this translator.
//
// Preconditions:
//
// Parameters: ioExtension, configuration options for the
// translator
//
// outView, the view to configure the
// translator is stored here
//
// outExtent, the bounds of the view are
// stored here
//
// Postconditions:
//
// Returns: B_BAD_VALUE if outView or outExtent is NULL,
// B_NO_MEMORY if the view couldn't be allocated,
// B_OK if no errors
// ---------------------------------------------------------------
status_t
TIFFTranslator::MakeConfigurationView(BMessage *ioExtension, BView **outView,
BRect *outExtent)
{
if (!outView || !outExtent)
return B_BAD_VALUE;
TIFFView *view = new TIFFView(BRect(0, 0, 225, 175),
"TIFFTranslator Settings", B_FOLLOW_ALL, B_WILL_DRAW);
if (!view)
return B_NO_MEMORY;
*outView = view;
*outExtent = view->Bounds();
return B_OK;
}
src/add-ons/translators/libtifftranslator/TIFFTranslator.h
+112
View File
@@ -0,0 +1,112 @@
/*****************************************************************************/
// TIFFTranslator
// Written by Michael Wilber, OBOS Translation Kit Team
//
// TIFFTranslator.h
//
// This BTranslator based object is for opening and writing
// TIFF images.
//
//
// Copyright (c) 2003 OpenBeOS Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#ifndef TIFF_TRANSLATOR_H
#define TIFF_TRANSLATOR_H
#include <Translator.h>
#include <TranslatorFormats.h>
#include <TranslationDefs.h>
#include <GraphicsDefs.h>
#include <InterfaceDefs.h>
#include <DataIO.h>
#include <File.h>
#include <ByteOrder.h>
#include <fs_attr.h>
// IO Extension Names:
#define DOCUMENT_COUNT "/documentCount"
#define DOCUMENT_INDEX "/documentIndex"
#define TIFF_TRANSLATOR_VERSION 100
#define TIFF_IN_QUALITY 0.5
#define TIFF_IN_CAPABILITY 0.6
#define BBT_IN_QUALITY 0.4
#define BBT_IN_CAPABILITY 0.6
#define BBT_OUT_QUALITY 0.4
#define BBT_OUT_CAPABILITY 0.6
class TIFFTranslator : public BTranslator {
public:
TIFFTranslator();
virtual const char *TranslatorName() const;
// returns the short name of the translator
virtual const char *TranslatorInfo() const;
// returns a verbose name/description for the translator
virtual int32 TranslatorVersion() const;
// returns the version of the translator
virtual const translation_format *InputFormats(int32 *out_count)
const;
// returns the input formats and the count of input formats
// that this translator supports
virtual const translation_format *OutputFormats(int32 *out_count)
const;
// returns the output formats and the count of output formats
// that this translator supports
virtual status_t Identify(BPositionIO *inSource,
const translation_format *inFormat, BMessage *ioExtension,
translator_info *outInfo, uint32 outType);
// determines whether or not this translator can convert the
// data in inSource to the type outType
virtual status_t Translate(BPositionIO *inSource,
const translator_info *inInfo, BMessage *ioExtension,
uint32 outType, BPositionIO *outDestination);
// this function is the whole point of the Translation Kit,
// it translates the data in inSource to outDestination
// using the format outType
virtual status_t MakeConfigurationView(BMessage *ioExtension,
BView **outView, BRect *outExtent);
// creates and returns the view for displaying information
// about this translator
protected:
virtual ~TIFFTranslator();
// this is protected because the object is deleted by the
// Release() function instead of being deleted directly by
// the user
private:
char fName[30];
char fInfo[100];
};
#endif // #ifndef TIFF_TRANSLATOR_H
src/add-ons/translators/libtifftranslator/TIFFView.cpp
+123
View File
@@ -0,0 +1,123 @@
/*****************************************************************************/
// TIFFView
// Written by Michael Wilber, OBOS Translation Kit Team
//
// TIFFView.cpp
//
// This BView based object displays information about the TIFFTranslator.
//
//
// Copyright (c) 2003 OpenBeOS Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#include <stdio.h>
#include <string.h>
#include "TIFFView.h"
#include "TIFFTranslator.h"
#include "tiffvers.h"
// ---------------------------------------------------------------
// Constructor
//
// Sets up the view settings
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
TIFFView::TIFFView(const BRect &frame, const char *name,
uint32 resize, uint32 flags)
: BView(frame, name, resize, flags)
{
SetViewColor(220,220,220,0);
}
// ---------------------------------------------------------------
// Destructor
//
// Does nothing
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
TIFFView::~TIFFView()
{
}
// ---------------------------------------------------------------
// Draw
//
// Draws information about the TIFFTranslator to this view.
//
// Preconditions:
//
// Parameters: area, not used
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
void
TIFFView::Draw(BRect area)
{
SetFont(be_bold_font);
font_height fh;
GetFontHeight(&fh);
float xbold, ybold;
xbold = fh.descent + 1;
ybold = fh.ascent + fh.descent * 2 + fh.leading;
char title[] = "OpenBeOS TIFF Image Translator";
DrawString(title, BPoint(xbold, ybold));
SetFont(be_plain_font);
font_height plainh;
GetFontHeight(&plainh);
float yplain;
yplain = plainh.ascent + plainh.descent * 2 + plainh.leading;
char detail[100];
sprintf(detail, "Version %d.%d.%d %s",
TIFF_TRANSLATOR_VERSION / 100, (TIFF_TRANSLATOR_VERSION / 10) % 10,
TIFF_TRANSLATOR_VERSION % 10, __DATE__);
DrawString(detail, BPoint(xbold, yplain + ybold));
int32 lineno = 4;
DrawString("TIFF Library:", BPoint(xbold, yplain * lineno + ybold));
lineno += 2;
char libtiff[] = TIFFLIB_VERSION_STR;
char *tok = strtok(libtiff, "\n");
while (tok) {
DrawString(tok, BPoint(xbold, yplain * lineno + ybold));
lineno++;
tok = strtok(NULL, "\n");
}
}
src/add-ons/translators/libtifftranslator/TIFFView.h
+51
View File
@@ -0,0 +1,51 @@
/*****************************************************************************/
// TIFFView
// Written by Michael Wilber, OBOS Translation Kit Team
//
// TIFFView.h
//
// This BView based object displays information about the TIFFTranslator.
//
//
// Copyright (c) 2003 OpenBeOS Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#ifndef TIFFVIEW_H
#define TIFFVIEW_H
#include <View.h>
#include <MenuField.h>
#include <MenuItem.h>
class TIFFView : public BView {
public:
TIFFView(const BRect &frame, const char *name, uint32 resize,
uint32 flags);
// sets up the view
~TIFFView();
// does nothing
virtual void Draw(BRect area);
// draws information about the TIFFTranslator
};
#endif // #ifndef TIFFVIEW_H
src/add-ons/translators/libtifftranslator/TIFFWindow.cpp
+69
View File
@@ -0,0 +1,69 @@
/*****************************************************************************/
// TIFFWindow
// Written by Michael Wilber, OBOS Translation Kit Team
//
// TIFFWindow.cpp
//
// This BWindow based object is used to hold the TIFFView object when the
// user runs the TIFFTranslator as an application.
//
//
// Copyright (c) 2003 OpenBeOS Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#include "TIFFWindow.h"
// ---------------------------------------------------------------
// Constructor
//
// Sets up the BWindow for holding a TIFFView
//
// Preconditions:
//
// Parameters: area, The bounds of the window
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
TIFFWindow::TIFFWindow(BRect area)
: BWindow(area, "TIFFTranslator", B_TITLED_WINDOW,
B_NOT_RESIZABLE | B_NOT_ZOOMABLE)
{
}
// ---------------------------------------------------------------
// Destructor
//
// Posts a quit message so that the application is close properly
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
TIFFWindow::~TIFFWindow()
{
be_app->PostMessage(B_QUIT_REQUESTED);
}
src/add-ons/translators/libtifftranslator/TIFFWindow.h
+48
View File
@@ -0,0 +1,48 @@
/*****************************************************************************/
// TIFFWindow
// Written by Michael Wilber, OBOS Translation Kit Team
//
// TIFFWindow.h
//
// This BWindow based object is used to hold the TIFFView object when the
// user runs the TIFFTranslator as an application.
//
//
// Copyright (c) 2003 OpenBeOS Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#ifndef TIFFWINDOW_H
#define TIFFWINDOW_H
#include <Application.h>
#include <Window.h>
#include <View.h>
class TIFFWindow : public BWindow {
public:
TIFFWindow(BRect area);
// Sets up a BWindow with bounds area
~TIFFWindow();
// Posts a quit message so that the application closes properly
};
#endif // #define TIFFWINDOW_H
src/add-ons/translators/libtifftranslator/t4.h
+285
View File
@@ -0,0 +1,285 @@
/* $Id: t4.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _T4_
#define _T4_
/*
* CCITT T.4 1D Huffman runlength codes and
* related definitions. Given the small sizes
* of these tables it does not seem
* worthwhile to make code & length 8 bits.
*/
typedef struct tableentry {
unsigned short length; /* bit length of g3 code */
unsigned short code; /* g3 code */
short runlen; /* run length in bits */
} tableentry;
#define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */
/* status values returned instead of a run length */
#define G3CODE_EOL -1 /* NB: ACT_EOL - ACT_WRUNT */
#define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */
#define G3CODE_EOF -3 /* end of input data */
#define G3CODE_INCOMP -4 /* incomplete run code */
/*
* Note that these tables are ordered such that the
* index into the table is known to be either the
* run length, or (run length / 64) + a fixed offset.
*
* NB: The G3CODE_INVALID entries are only used
* during state generation (see mkg3states.c).
*/
#ifdef G3CODES
const tableentry TIFFFaxWhiteCodes[] = {
{ 8, 0x35, 0 }, /* 0011 0101 */
{ 6, 0x7, 1 }, /* 0001 11 */
{ 4, 0x7, 2 }, /* 0111 */
{ 4, 0x8, 3 }, /* 1000 */
{ 4, 0xB, 4 }, /* 1011 */
{ 4, 0xC, 5 }, /* 1100 */
{ 4, 0xE, 6 }, /* 1110 */
{ 4, 0xF, 7 }, /* 1111 */
{ 5, 0x13, 8 }, /* 1001 1 */
{ 5, 0x14, 9 }, /* 1010 0 */
{ 5, 0x7, 10 }, /* 0011 1 */
{ 5, 0x8, 11 }, /* 0100 0 */
{ 6, 0x8, 12 }, /* 0010 00 */
{ 6, 0x3, 13 }, /* 0000 11 */
{ 6, 0x34, 14 }, /* 1101 00 */
{ 6, 0x35, 15 }, /* 1101 01 */
{ 6, 0x2A, 16 }, /* 1010 10 */
{ 6, 0x2B, 17 }, /* 1010 11 */
{ 7, 0x27, 18 }, /* 0100 111 */
{ 7, 0xC, 19 }, /* 0001 100 */
{ 7, 0x8, 20 }, /* 0001 000 */
{ 7, 0x17, 21 }, /* 0010 111 */
{ 7, 0x3, 22 }, /* 0000 011 */
{ 7, 0x4, 23 }, /* 0000 100 */
{ 7, 0x28, 24 }, /* 0101 000 */
{ 7, 0x2B, 25 }, /* 0101 011 */
{ 7, 0x13, 26 }, /* 0010 011 */
{ 7, 0x24, 27 }, /* 0100 100 */
{ 7, 0x18, 28 }, /* 0011 000 */
{ 8, 0x2, 29 }, /* 0000 0010 */
{ 8, 0x3, 30 }, /* 0000 0011 */
{ 8, 0x1A, 31 }, /* 0001 1010 */
{ 8, 0x1B, 32 }, /* 0001 1011 */
{ 8, 0x12, 33 }, /* 0001 0010 */
{ 8, 0x13, 34 }, /* 0001 0011 */
{ 8, 0x14, 35 }, /* 0001 0100 */
{ 8, 0x15, 36 }, /* 0001 0101 */
{ 8, 0x16, 37 }, /* 0001 0110 */
{ 8, 0x17, 38 }, /* 0001 0111 */
{ 8, 0x28, 39 }, /* 0010 1000 */
{ 8, 0x29, 40 }, /* 0010 1001 */
{ 8, 0x2A, 41 }, /* 0010 1010 */
{ 8, 0x2B, 42 }, /* 0010 1011 */
{ 8, 0x2C, 43 }, /* 0010 1100 */
{ 8, 0x2D, 44 }, /* 0010 1101 */
{ 8, 0x4, 45 }, /* 0000 0100 */
{ 8, 0x5, 46 }, /* 0000 0101 */
{ 8, 0xA, 47 }, /* 0000 1010 */
{ 8, 0xB, 48 }, /* 0000 1011 */
{ 8, 0x52, 49 }, /* 0101 0010 */
{ 8, 0x53, 50 }, /* 0101 0011 */
{ 8, 0x54, 51 }, /* 0101 0100 */
{ 8, 0x55, 52 }, /* 0101 0101 */
{ 8, 0x24, 53 }, /* 0010 0100 */
{ 8, 0x25, 54 }, /* 0010 0101 */
{ 8, 0x58, 55 }, /* 0101 1000 */
{ 8, 0x59, 56 }, /* 0101 1001 */
{ 8, 0x5A, 57 }, /* 0101 1010 */
{ 8, 0x5B, 58 }, /* 0101 1011 */
{ 8, 0x4A, 59 }, /* 0100 1010 */
{ 8, 0x4B, 60 }, /* 0100 1011 */
{ 8, 0x32, 61 }, /* 0011 0010 */
{ 8, 0x33, 62 }, /* 0011 0011 */
{ 8, 0x34, 63 }, /* 0011 0100 */
{ 5, 0x1B, 64 }, /* 1101 1 */
{ 5, 0x12, 128 }, /* 1001 0 */
{ 6, 0x17, 192 }, /* 0101 11 */
{ 7, 0x37, 256 }, /* 0110 111 */
{ 8, 0x36, 320 }, /* 0011 0110 */
{ 8, 0x37, 384 }, /* 0011 0111 */
{ 8, 0x64, 448 }, /* 0110 0100 */
{ 8, 0x65, 512 }, /* 0110 0101 */
{ 8, 0x68, 576 }, /* 0110 1000 */
{ 8, 0x67, 640 }, /* 0110 0111 */
{ 9, 0xCC, 704 }, /* 0110 0110 0 */
{ 9, 0xCD, 768 }, /* 0110 0110 1 */
{ 9, 0xD2, 832 }, /* 0110 1001 0 */
{ 9, 0xD3, 896 }, /* 0110 1001 1 */
{ 9, 0xD4, 960 }, /* 0110 1010 0 */
{ 9, 0xD5, 1024 }, /* 0110 1010 1 */
{ 9, 0xD6, 1088 }, /* 0110 1011 0 */
{ 9, 0xD7, 1152 }, /* 0110 1011 1 */
{ 9, 0xD8, 1216 }, /* 0110 1100 0 */
{ 9, 0xD9, 1280 }, /* 0110 1100 1 */
{ 9, 0xDA, 1344 }, /* 0110 1101 0 */
{ 9, 0xDB, 1408 }, /* 0110 1101 1 */
{ 9, 0x98, 1472 }, /* 0100 1100 0 */
{ 9, 0x99, 1536 }, /* 0100 1100 1 */
{ 9, 0x9A, 1600 }, /* 0100 1101 0 */
{ 6, 0x18, 1664 }, /* 0110 00 */
{ 9, 0x9B, 1728 }, /* 0100 1101 1 */
{ 11, 0x8, 1792 }, /* 0000 0001 000 */
{ 11, 0xC, 1856 }, /* 0000 0001 100 */
{ 11, 0xD, 1920 }, /* 0000 0001 101 */
{ 12, 0x12, 1984 }, /* 0000 0001 0010 */
{ 12, 0x13, 2048 }, /* 0000 0001 0011 */
{ 12, 0x14, 2112 }, /* 0000 0001 0100 */
{ 12, 0x15, 2176 }, /* 0000 0001 0101 */
{ 12, 0x16, 2240 }, /* 0000 0001 0110 */
{ 12, 0x17, 2304 }, /* 0000 0001 0111 */
{ 12, 0x1C, 2368 }, /* 0000 0001 1100 */
{ 12, 0x1D, 2432 }, /* 0000 0001 1101 */
{ 12, 0x1E, 2496 }, /* 0000 0001 1110 */
{ 12, 0x1F, 2560 }, /* 0000 0001 1111 */
{ 12, 0x1, G3CODE_EOL }, /* 0000 0000 0001 */
{ 9, 0x1, G3CODE_INVALID }, /* 0000 0000 1 */
{ 10, 0x1, G3CODE_INVALID }, /* 0000 0000 01 */
{ 11, 0x1, G3CODE_INVALID }, /* 0000 0000 001 */
{ 12, 0x0, G3CODE_INVALID }, /* 0000 0000 0000 */
};
const tableentry TIFFFaxBlackCodes[] = {
{ 10, 0x37, 0 }, /* 0000 1101 11 */
{ 3, 0x2, 1 }, /* 010 */
{ 2, 0x3, 2 }, /* 11 */
{ 2, 0x2, 3 }, /* 10 */
{ 3, 0x3, 4 }, /* 011 */
{ 4, 0x3, 5 }, /* 0011 */
{ 4, 0x2, 6 }, /* 0010 */
{ 5, 0x3, 7 }, /* 0001 1 */
{ 6, 0x5, 8 }, /* 0001 01 */
{ 6, 0x4, 9 }, /* 0001 00 */
{ 7, 0x4, 10 }, /* 0000 100 */
{ 7, 0x5, 11 }, /* 0000 101 */
{ 7, 0x7, 12 }, /* 0000 111 */
{ 8, 0x4, 13 }, /* 0000 0100 */
{ 8, 0x7, 14 }, /* 0000 0111 */
{ 9, 0x18, 15 }, /* 0000 1100 0 */
{ 10, 0x17, 16 }, /* 0000 0101 11 */
{ 10, 0x18, 17 }, /* 0000 0110 00 */
{ 10, 0x8, 18 }, /* 0000 0010 00 */
{ 11, 0x67, 19 }, /* 0000 1100 111 */
{ 11, 0x68, 20 }, /* 0000 1101 000 */
{ 11, 0x6C, 21 }, /* 0000 1101 100 */
{ 11, 0x37, 22 }, /* 0000 0110 111 */
{ 11, 0x28, 23 }, /* 0000 0101 000 */
{ 11, 0x17, 24 }, /* 0000 0010 111 */
{ 11, 0x18, 25 }, /* 0000 0011 000 */
{ 12, 0xCA, 26 }, /* 0000 1100 1010 */
{ 12, 0xCB, 27 }, /* 0000 1100 1011 */
{ 12, 0xCC, 28 }, /* 0000 1100 1100 */
{ 12, 0xCD, 29 }, /* 0000 1100 1101 */
{ 12, 0x68, 30 }, /* 0000 0110 1000 */
{ 12, 0x69, 31 }, /* 0000 0110 1001 */
{ 12, 0x6A, 32 }, /* 0000 0110 1010 */
{ 12, 0x6B, 33 }, /* 0000 0110 1011 */
{ 12, 0xD2, 34 }, /* 0000 1101 0010 */
{ 12, 0xD3, 35 }, /* 0000 1101 0011 */
{ 12, 0xD4, 36 }, /* 0000 1101 0100 */
{ 12, 0xD5, 37 }, /* 0000 1101 0101 */
{ 12, 0xD6, 38 }, /* 0000 1101 0110 */
{ 12, 0xD7, 39 }, /* 0000 1101 0111 */
{ 12, 0x6C, 40 }, /* 0000 0110 1100 */
{ 12, 0x6D, 41 }, /* 0000 0110 1101 */
{ 12, 0xDA, 42 }, /* 0000 1101 1010 */
{ 12, 0xDB, 43 }, /* 0000 1101 1011 */
{ 12, 0x54, 44 }, /* 0000 0101 0100 */
{ 12, 0x55, 45 }, /* 0000 0101 0101 */
{ 12, 0x56, 46 }, /* 0000 0101 0110 */
{ 12, 0x57, 47 }, /* 0000 0101 0111 */
{ 12, 0x64, 48 }, /* 0000 0110 0100 */
{ 12, 0x65, 49 }, /* 0000 0110 0101 */
{ 12, 0x52, 50 }, /* 0000 0101 0010 */
{ 12, 0x53, 51 }, /* 0000 0101 0011 */
{ 12, 0x24, 52 }, /* 0000 0010 0100 */
{ 12, 0x37, 53 }, /* 0000 0011 0111 */
{ 12, 0x38, 54 }, /* 0000 0011 1000 */
{ 12, 0x27, 55 }, /* 0000 0010 0111 */
{ 12, 0x28, 56 }, /* 0000 0010 1000 */
{ 12, 0x58, 57 }, /* 0000 0101 1000 */
{ 12, 0x59, 58 }, /* 0000 0101 1001 */
{ 12, 0x2B, 59 }, /* 0000 0010 1011 */
{ 12, 0x2C, 60 }, /* 0000 0010 1100 */
{ 12, 0x5A, 61 }, /* 0000 0101 1010 */
{ 12, 0x66, 62 }, /* 0000 0110 0110 */
{ 12, 0x67, 63 }, /* 0000 0110 0111 */
{ 10, 0xF, 64 }, /* 0000 0011 11 */
{ 12, 0xC8, 128 }, /* 0000 1100 1000 */
{ 12, 0xC9, 192 }, /* 0000 1100 1001 */
{ 12, 0x5B, 256 }, /* 0000 0101 1011 */
{ 12, 0x33, 320 }, /* 0000 0011 0011 */
{ 12, 0x34, 384 }, /* 0000 0011 0100 */
{ 12, 0x35, 448 }, /* 0000 0011 0101 */
{ 13, 0x6C, 512 }, /* 0000 0011 0110 0 */
{ 13, 0x6D, 576 }, /* 0000 0011 0110 1 */
{ 13, 0x4A, 640 }, /* 0000 0010 0101 0 */
{ 13, 0x4B, 704 }, /* 0000 0010 0101 1 */
{ 13, 0x4C, 768 }, /* 0000 0010 0110 0 */
{ 13, 0x4D, 832 }, /* 0000 0010 0110 1 */
{ 13, 0x72, 896 }, /* 0000 0011 1001 0 */
{ 13, 0x73, 960 }, /* 0000 0011 1001 1 */
{ 13, 0x74, 1024 }, /* 0000 0011 1010 0 */
{ 13, 0x75, 1088 }, /* 0000 0011 1010 1 */
{ 13, 0x76, 1152 }, /* 0000 0011 1011 0 */
{ 13, 0x77, 1216 }, /* 0000 0011 1011 1 */
{ 13, 0x52, 1280 }, /* 0000 0010 1001 0 */
{ 13, 0x53, 1344 }, /* 0000 0010 1001 1 */
{ 13, 0x54, 1408 }, /* 0000 0010 1010 0 */
{ 13, 0x55, 1472 }, /* 0000 0010 1010 1 */
{ 13, 0x5A, 1536 }, /* 0000 0010 1101 0 */
{ 13, 0x5B, 1600 }, /* 0000 0010 1101 1 */
{ 13, 0x64, 1664 }, /* 0000 0011 0010 0 */
{ 13, 0x65, 1728 }, /* 0000 0011 0010 1 */
{ 11, 0x8, 1792 }, /* 0000 0001 000 */
{ 11, 0xC, 1856 }, /* 0000 0001 100 */
{ 11, 0xD, 1920 }, /* 0000 0001 101 */
{ 12, 0x12, 1984 }, /* 0000 0001 0010 */
{ 12, 0x13, 2048 }, /* 0000 0001 0011 */
{ 12, 0x14, 2112 }, /* 0000 0001 0100 */
{ 12, 0x15, 2176 }, /* 0000 0001 0101 */
{ 12, 0x16, 2240 }, /* 0000 0001 0110 */
{ 12, 0x17, 2304 }, /* 0000 0001 0111 */
{ 12, 0x1C, 2368 }, /* 0000 0001 1100 */
{ 12, 0x1D, 2432 }, /* 0000 0001 1101 */
{ 12, 0x1E, 2496 }, /* 0000 0001 1110 */
{ 12, 0x1F, 2560 }, /* 0000 0001 1111 */
{ 12, 0x1, G3CODE_EOL }, /* 0000 0000 0001 */
{ 9, 0x1, G3CODE_INVALID }, /* 0000 0000 1 */
{ 10, 0x1, G3CODE_INVALID }, /* 0000 0000 01 */
{ 11, 0x1, G3CODE_INVALID }, /* 0000 0000 001 */
{ 12, 0x0, G3CODE_INVALID }, /* 0000 0000 0000 */
};
#else
extern const tableentry TIFFFaxWhiteCodes[];
extern const tableentry TIFFFaxBlackCodes[];
#endif
#endif /* _T4_ */
src/add-ons/translators/libtifftranslator/tif_aux.c
+213
View File
@@ -0,0 +1,213 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_aux.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* Auxiliary Support Routines.
*/
#include "tiffiop.h"
#include "tif_predict.h"
#ifdef COLORIMETRY_SUPPORT
#include <math.h>
static void
TIFFDefaultTransferFunction(TIFFDirectory* td)
{
uint16 **tf = td->td_transferfunction;
long i, n = 1<<td->td_bitspersample;
tf[0] = (uint16 *)_TIFFmalloc(n * sizeof (uint16));
tf[0][0] = 0;
for (i = 1; i < n; i++) {
double t = (double)i/((double) n-1.);
tf[0][i] = (uint16)floor(65535.*pow(t, 2.2) + .5);
}
if (td->td_samplesperpixel - td->td_extrasamples > 1) {
tf[1] = (uint16 *)_TIFFmalloc(n * sizeof (uint16));
_TIFFmemcpy(tf[1], tf[0], n * sizeof (uint16));
tf[2] = (uint16 *)_TIFFmalloc(n * sizeof (uint16));
_TIFFmemcpy(tf[2], tf[0], n * sizeof (uint16));
}
}
static void
TIFFDefaultRefBlackWhite(TIFFDirectory* td)
{
int i;
td->td_refblackwhite = (float *)_TIFFmalloc(6*sizeof (float));
for (i = 0; i < 3; i++) {
td->td_refblackwhite[2*i+0] = 0;
td->td_refblackwhite[2*i+1] = (float)((1L<<td->td_bitspersample)-1L);
}
}
#endif
/*
* Like TIFFGetField, but return any default
* value if the tag is not present in the directory.
*
* NB: We use the value in the directory, rather than
* explcit values so that defaults exist only one
* place in the library -- in TIFFDefaultDirectory.
*/
int
TIFFVGetFieldDefaulted(TIFF* tif, ttag_t tag, va_list ap)
{
TIFFDirectory *td = &tif->tif_dir;
if (TIFFVGetField(tif, tag, ap))
return (1);
switch (tag) {
case TIFFTAG_SUBFILETYPE:
*va_arg(ap, uint32 *) = td->td_subfiletype;
return (1);
case TIFFTAG_BITSPERSAMPLE:
*va_arg(ap, uint16 *) = td->td_bitspersample;
return (1);
case TIFFTAG_THRESHHOLDING:
*va_arg(ap, uint16 *) = td->td_threshholding;
return (1);
case TIFFTAG_FILLORDER:
*va_arg(ap, uint16 *) = td->td_fillorder;
return (1);
case TIFFTAG_ORIENTATION:
*va_arg(ap, uint16 *) = td->td_orientation;
return (1);
case TIFFTAG_SAMPLESPERPIXEL:
*va_arg(ap, uint16 *) = td->td_samplesperpixel;
return (1);
case TIFFTAG_ROWSPERSTRIP:
*va_arg(ap, uint32 *) = td->td_rowsperstrip;
return (1);
case TIFFTAG_MINSAMPLEVALUE:
*va_arg(ap, uint16 *) = td->td_minsamplevalue;
return (1);
case TIFFTAG_MAXSAMPLEVALUE:
*va_arg(ap, uint16 *) = td->td_maxsamplevalue;
return (1);
case TIFFTAG_PLANARCONFIG:
*va_arg(ap, uint16 *) = td->td_planarconfig;
return (1);
case TIFFTAG_RESOLUTIONUNIT:
*va_arg(ap, uint16 *) = td->td_resolutionunit;
return (1);
case TIFFTAG_PREDICTOR:
{
TIFFPredictorState* sp = (TIFFPredictorState*) tif->tif_data;
*va_arg(ap, uint16*) = sp->predictor;
return (1);
}
#ifdef CMYK_SUPPORT
case TIFFTAG_DOTRANGE:
*va_arg(ap, uint16 *) = 0;
*va_arg(ap, uint16 *) = (1<<td->td_bitspersample)-1;
return (1);
case TIFFTAG_INKSET:
*va_arg(ap, uint16 *) = td->td_inkset;
return (1);
case TIFFTAG_NUMBEROFINKS:
*va_arg(ap, uint16 *) = td->td_ninks;
return (1);
#endif
case TIFFTAG_EXTRASAMPLES:
*va_arg(ap, uint16 *) = td->td_extrasamples;
*va_arg(ap, uint16 **) = td->td_sampleinfo;
return (1);
case TIFFTAG_MATTEING:
*va_arg(ap, uint16 *) =
(td->td_extrasamples == 1 &&
td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
return (1);
case TIFFTAG_TILEDEPTH:
*va_arg(ap, uint32 *) = td->td_tiledepth;
return (1);
case TIFFTAG_DATATYPE:
*va_arg(ap, uint16 *) = td->td_sampleformat-1;
return (1);
case TIFFTAG_SAMPLEFORMAT:
*va_arg(ap, uint16 *) = td->td_sampleformat;
return(1);
case TIFFTAG_IMAGEDEPTH:
*va_arg(ap, uint32 *) = td->td_imagedepth;
return (1);
#ifdef YCBCR_SUPPORT
case TIFFTAG_YCBCRCOEFFICIENTS:
if (!td->td_ycbcrcoeffs) {
td->td_ycbcrcoeffs = (float *)
_TIFFmalloc(3*sizeof (float));
/* defaults are from CCIR Recommendation 601-1 */
td->td_ycbcrcoeffs[0] = 0.299f;
td->td_ycbcrcoeffs[1] = 0.587f;
td->td_ycbcrcoeffs[2] = 0.114f;
}
*va_arg(ap, float **) = td->td_ycbcrcoeffs;
return (1);
case TIFFTAG_YCBCRSUBSAMPLING:
*va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[0];
*va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[1];
return (1);
case TIFFTAG_YCBCRPOSITIONING:
*va_arg(ap, uint16 *) = td->td_ycbcrpositioning;
return (1);
#endif
#ifdef COLORIMETRY_SUPPORT
case TIFFTAG_TRANSFERFUNCTION:
if (!td->td_transferfunction[0])
TIFFDefaultTransferFunction(td);
*va_arg(ap, uint16 **) = td->td_transferfunction[0];
if (td->td_samplesperpixel - td->td_extrasamples > 1) {
*va_arg(ap, uint16 **) = td->td_transferfunction[1];
*va_arg(ap, uint16 **) = td->td_transferfunction[2];
}
return (1);
case TIFFTAG_REFERENCEBLACKWHITE:
if (!td->td_refblackwhite)
TIFFDefaultRefBlackWhite(td);
*va_arg(ap, float **) = td->td_refblackwhite;
return (1);
#endif
}
return (0);
}
/*
* Like TIFFGetField, but return any default
* value if the tag is not present in the directory.
*/
int
TIFFGetFieldDefaulted(TIFF* tif, ttag_t tag, ...)
{
int ok;
va_list ap;
va_start(ap, tag);
ok = TIFFVGetFieldDefaulted(tif, tag, ap);
va_end(ap);
return (ok);
}
src/add-ons/translators/libtifftranslator/tif_close.c
+77
View File
@@ -0,0 +1,77 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_close.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*/
#include "tiffiop.h"
void
TIFFClose(TIFF* tif)
{
if (tif->tif_mode != O_RDONLY)
/*
* Flush buffered data and directory (if dirty).
*/
TIFFFlush(tif);
(*tif->tif_cleanup)(tif);
TIFFFreeDirectory(tif);
/* Clean up client info links */
while( tif->tif_clientinfo )
{
TIFFClientInfoLink *link = tif->tif_clientinfo;
tif->tif_clientinfo = link->next;
_TIFFfree( link->name );
_TIFFfree( link );
}
if (tif->tif_rawdata && (tif->tif_flags&TIFF_MYBUFFER))
_TIFFfree(tif->tif_rawdata);
if (isMapped(tif))
TIFFUnmapFileContents(tif, tif->tif_base, tif->tif_size);
(void) TIFFCloseFile(tif);
if (tif->tif_nfields > 0)
{
int i;
for (i = 0; i < tif->tif_nfields; i++)
{
TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
if (fld->field_bit == FIELD_CUSTOM &&
strncmp("Tag ", fld->field_name, 4) == 0)
{
_TIFFfree(fld->field_name);
_TIFFfree(fld);
}
}
_TIFFfree(tif->tif_fieldinfo);
}
_TIFFfree(tif);
}
src/add-ons/translators/libtifftranslator/tif_codec.c
+119
View File
@@ -0,0 +1,119 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_codec.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library
*
* Builtin Compression Scheme Configuration Support.
*/
#include "tiffiop.h"
static int NotConfigured(TIFF*, int);
#ifndef LZW_SUPPORT
#define TIFFInitLZW NotConfigured
#endif
#ifndef PACKBITS_SUPPORT
#define TIFFInitPackbits NotConfigured
#endif
#ifndef THUNDER_SUPPORT
#define TIFFInitThunderScan NotConfigured
#endif
#ifndef NEXT_SUPPORT
#define TIFFInitNeXT NotConfigured
#endif
#ifndef JPEG_SUPPORT
#define TIFFInitJPEG NotConfigured
#endif
#ifndef OJPEG_SUPPORT
#define TIFFInitOJPEG NotConfigured
#endif
#ifndef CCITT_SUPPORT
#define TIFFInitCCITTRLE NotConfigured
#define TIFFInitCCITTRLEW NotConfigured
#define TIFFInitCCITTFax3 NotConfigured
#define TIFFInitCCITTFax4 NotConfigured
#endif
#ifndef JBIG_SUPPORT
#define TIFFInitJBIG NotConfigured
#endif
#ifndef ZIP_SUPPORT
#define TIFFInitZIP NotConfigured
#endif
#ifndef PIXARLOG_SUPPORT
#define TIFFInitPixarLog NotConfigured
#endif
#ifndef LOGLUV_SUPPORT
#define TIFFInitSGILog NotConfigured
#endif
/*
* Compression schemes statically built into the library.
*/
#ifdef VMS
const TIFFCodec _TIFFBuiltinCODECS[] = {
#else
TIFFCodec _TIFFBuiltinCODECS[] = {
#endif
{ "None", COMPRESSION_NONE, TIFFInitDumpMode },
{ "LZW", COMPRESSION_LZW, TIFFInitLZW },
{ "PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits },
{ "ThunderScan", COMPRESSION_THUNDERSCAN,TIFFInitThunderScan },
{ "NeXT", COMPRESSION_NEXT, TIFFInitNeXT },
{ "JPEG", COMPRESSION_JPEG, TIFFInitJPEG },
{ "Old-style JPEG", COMPRESSION_OJPEG, TIFFInitOJPEG },
{ "CCITT RLE", COMPRESSION_CCITTRLE, TIFFInitCCITTRLE },
{ "CCITT RLE/W", COMPRESSION_CCITTRLEW, TIFFInitCCITTRLEW },
{ "CCITT Group 3", COMPRESSION_CCITTFAX3, TIFFInitCCITTFax3 },
{ "CCITT Group 4", COMPRESSION_CCITTFAX4, TIFFInitCCITTFax4 },
{ "ISO JBIG", COMPRESSION_JBIG, TIFFInitJBIG },
{ "Deflate", COMPRESSION_DEFLATE, TIFFInitZIP },
{ "AdobeDeflate", COMPRESSION_ADOBE_DEFLATE , TIFFInitZIP },
{ "PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog },
{ "SGILog", COMPRESSION_SGILOG, TIFFInitSGILog },
{ "SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog },
{ NULL }
};
static int
_notConfigured(TIFF* tif)
{
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
TIFFError(tif->tif_name,
"%s compression support is not configured", c->name);
return (0);
}
static int
NotConfigured(TIFF* tif, int scheme)
{
tif->tif_decodestatus = FALSE;
tif->tif_setupdecode = _notConfigured;
tif->tif_encodestatus = FALSE;
tif->tif_setupencode = _notConfigured;
return (1);
}
src/add-ons/translators/libtifftranslator/tif_compress.c
+233
View File
@@ -0,0 +1,233 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_compress.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library
*
* Compression Scheme Configuration Support.
*/
#include "tiffiop.h"
static int
TIFFNoEncode(TIFF* tif, char* method)
{
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c) {
if (! strncmp(c->name, "LZW", 3) ){
TIFFError(tif->tif_name,
"%s %s encoding is no longer implemented due to Unisys patent enforcement",
c->name, method);
} else {
TIFFError(tif->tif_name, "%s %s encoding is not implemented",
c->name, method);
}
}
else {
TIFFError(tif->tif_name,
"Compression scheme %u %s encoding is not implemented",
tif->tif_dir.td_compression, method);
}
return (-1);
}
int
_TIFFNoRowEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoEncode(tif, "scanline"));
}
int
_TIFFNoStripEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoEncode(tif, "strip"));
}
int
_TIFFNoTileEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoEncode(tif, "tile"));
}
static int
TIFFNoDecode(TIFF* tif, char* method)
{
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c)
TIFFError(tif->tif_name, "%s %s decoding is not implemented",
c->name, method);
else
TIFFError(tif->tif_name,
"Compression scheme %u %s decoding is not implemented",
tif->tif_dir.td_compression, method);
return (-1);
}
int
_TIFFNoRowDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoDecode(tif, "scanline"));
}
int
_TIFFNoStripDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoDecode(tif, "strip"));
}
int
_TIFFNoTileDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoDecode(tif, "tile"));
}
int
_TIFFNoSeek(TIFF* tif, uint32 off)
{
(void) off;
TIFFError(tif->tif_name,
"Compression algorithm does not support random access");
return (0);
}
int
_TIFFNoPreCode(TIFF* tif, tsample_t s)
{
(void) tif; (void) s;
return (1);
}
static int _TIFFtrue(TIFF* tif) { (void) tif; return (1); }
static void _TIFFvoid(TIFF* tif) { (void) tif; }
void
_TIFFSetDefaultCompressionState(TIFF* tif)
{
tif->tif_decodestatus = TRUE;
tif->tif_setupdecode = _TIFFtrue;
tif->tif_predecode = _TIFFNoPreCode;
tif->tif_decoderow = _TIFFNoRowDecode;
tif->tif_decodestrip = _TIFFNoStripDecode;
tif->tif_decodetile = _TIFFNoTileDecode;
tif->tif_encodestatus = TRUE;
tif->tif_setupencode = _TIFFtrue;
tif->tif_preencode = _TIFFNoPreCode;
tif->tif_postencode = _TIFFtrue;
tif->tif_encoderow = _TIFFNoRowEncode;
tif->tif_encodestrip = _TIFFNoStripEncode;
tif->tif_encodetile = _TIFFNoTileEncode;
tif->tif_close = _TIFFvoid;
tif->tif_seek = _TIFFNoSeek;
tif->tif_cleanup = _TIFFvoid;
tif->tif_defstripsize = _TIFFDefaultStripSize;
tif->tif_deftilesize = _TIFFDefaultTileSize;
tif->tif_flags &= ~TIFF_NOBITREV;
}
int
TIFFSetCompressionScheme(TIFF* tif, int scheme)
{
const TIFFCodec *c = TIFFFindCODEC((uint16) scheme);
_TIFFSetDefaultCompressionState(tif);
/*
* Don't treat an unknown compression scheme as an error.
* This permits applications to open files with data that
* the library does not have builtin support for, but which
* may still be meaningful.
*/
return (c ? (*c->init)(tif, scheme) : 1);
}
/*
* Other compression schemes may be registered. Registered
* schemes can also override the builtin versions provided
* by this library.
*/
typedef struct _codec {
struct _codec* next;
TIFFCodec* info;
} codec_t;
static codec_t* registeredCODECS = NULL;
const TIFFCodec*
TIFFFindCODEC(uint16 scheme)
{
const TIFFCodec* c;
codec_t* cd;
for (cd = registeredCODECS; cd; cd = cd->next)
if (cd->info->scheme == scheme)
return ((const TIFFCodec*) cd->info);
for (c = _TIFFBuiltinCODECS; c->name; c++)
if (c->scheme == scheme)
return (c);
return ((const TIFFCodec*) 0);
}
TIFFCodec*
TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init)
{
codec_t* cd = (codec_t*)
_TIFFmalloc(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1);
if (cd != NULL) {
cd->info = (TIFFCodec*) ((tidata_t) cd + sizeof (codec_t));
cd->info->name = (char*)
((tidata_t) cd->info + sizeof (TIFFCodec));
strcpy(cd->info->name, name);
cd->info->scheme = scheme;
cd->info->init = init;
cd->next = registeredCODECS;
registeredCODECS = cd;
} else
TIFFError("TIFFRegisterCODEC",
"No space to register compression scheme %s", name);
return (cd->info);
}
void
TIFFUnRegisterCODEC(TIFFCodec* c)
{
codec_t* cd;
codec_t** pcd;
for (pcd = &registeredCODECS; (cd = *pcd); pcd = &cd->next)
if (cd->info == c) {
*pcd = cd->next;
_TIFFfree(cd);
return;
}
TIFFError("TIFFUnRegisterCODEC",
"Cannot remove compression scheme %s; not registered", c->name);
}
src/add-ons/translators/libtifftranslator/tif_dir.c
+1447
View File
File diff suppressed because it is too large Load Diff
src/add-ons/translators/libtifftranslator/tif_dir.h
+266
View File
@@ -0,0 +1,266 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_dir.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _TIFFDIR_
#define _TIFFDIR_
/*
* ``Library-private'' Directory-related Definitions.
*/
/*
* Internal format of a TIFF directory entry.
*/
typedef struct {
#define FIELD_SETLONGS 4
/* bit vector of fields that are set */
u_long td_fieldsset[FIELD_SETLONGS];
uint32 td_imagewidth, td_imagelength, td_imagedepth;
uint32 td_tilewidth, td_tilelength, td_tiledepth;
uint32 td_subfiletype;
uint16 td_bitspersample;
uint16 td_sampleformat;
uint16 td_compression;
uint16 td_photometric;
uint16 td_threshholding;
uint16 td_fillorder;
uint16 td_orientation;
uint16 td_samplesperpixel;
uint32 td_rowsperstrip;
uint16 td_minsamplevalue, td_maxsamplevalue;
double td_sminsamplevalue, td_smaxsamplevalue;
float td_xresolution, td_yresolution;
uint16 td_resolutionunit;
uint16 td_planarconfig;
float td_xposition, td_yposition;
uint16 td_pagenumber[2];
uint16* td_colormap[3];
uint16 td_halftonehints[2];
uint16 td_extrasamples;
uint16* td_sampleinfo;
double td_stonits;
char* td_documentname;
char* td_artist;
char* td_datetime;
char* td_hostcomputer;
char* td_imagedescription;
char* td_make;
char* td_model;
char* td_copyright;
char* td_pagename;
tstrip_t td_stripsperimage;
tstrip_t td_nstrips; /* size of offset & bytecount arrays */
uint32* td_stripoffset;
uint32* td_stripbytecount;
#if SUBIFD_SUPPORT
uint16 td_nsubifd;
uint32* td_subifd;
#endif
#ifdef YCBCR_SUPPORT
float* td_ycbcrcoeffs;
uint16 td_ycbcrsubsampling[2];
uint16 td_ycbcrpositioning;
#endif
#ifdef COLORIMETRY_SUPPORT
float* td_whitepoint;
float* td_primarychromas;
float* td_refblackwhite;
uint16* td_transferfunction[3];
#endif
#ifdef CMYK_SUPPORT
uint16 td_inkset;
uint16 td_ninks;
uint16 td_dotrange[2];
int td_inknameslen;
char* td_inknames;
char* td_targetprinter;
#endif
#ifdef ICC_SUPPORT
uint32 td_profileLength;
void *td_profileData;
#endif
#ifdef PHOTOSHOP_SUPPORT
uint32 td_photoshopLength;
void *td_photoshopData;
#endif
#ifdef IPTC_SUPPORT
uint32 td_richtiffiptcLength;
void *td_richtiffiptcData;
#endif
/* Begin Pixar Tag values. */
uint32 td_imagefullwidth, td_imagefulllength;
char* td_textureformat;
char* td_wrapmodes;
float td_fovcot;
float* td_matrixWorldToScreen;
float* td_matrixWorldToCamera;
/* End Pixar Tag Values. */
uint32 td_xmlpacketLength;
void *td_xmlpacketData;
int td_customValueCount;
TIFFTagValue *td_customValues;
} TIFFDirectory;
/*
* Field flags used to indicate fields that have
* been set in a directory, and to reference fields
* when manipulating a directory.
*/
/*
* FIELD_IGNORE is used to signify tags that are to
* be processed but otherwise ignored. This permits
* antiquated tags to be quietly read and discarded.
* Note that a bit *is* allocated for ignored tags;
* this is understood by the directory reading logic
* which uses this fact to avoid special-case handling
*/
#define FIELD_IGNORE 0
/* multi-item fields */
#define FIELD_IMAGEDIMENSIONS 1
#define FIELD_TILEDIMENSIONS 2
#define FIELD_RESOLUTION 3
#define FIELD_POSITION 4
/* single-item fields */
#define FIELD_SUBFILETYPE 5
#define FIELD_BITSPERSAMPLE 6
#define FIELD_COMPRESSION 7
#define FIELD_PHOTOMETRIC 8
#define FIELD_THRESHHOLDING 9
#define FIELD_FILLORDER 10
#define FIELD_DOCUMENTNAME 11
#define FIELD_IMAGEDESCRIPTION 12
#define FIELD_MAKE 13
#define FIELD_MODEL 14
#define FIELD_ORIENTATION 15
#define FIELD_SAMPLESPERPIXEL 16
#define FIELD_ROWSPERSTRIP 17
#define FIELD_MINSAMPLEVALUE 18
#define FIELD_MAXSAMPLEVALUE 19
#define FIELD_PLANARCONFIG 20
#define FIELD_PAGENAME 21
#define FIELD_RESOLUTIONUNIT 22
#define FIELD_PAGENUMBER 23
#define FIELD_STRIPBYTECOUNTS 24
#define FIELD_STRIPOFFSETS 25
#define FIELD_COLORMAP 26
#define FIELD_ARTIST 27
#define FIELD_DATETIME 28
#define FIELD_HOSTCOMPUTER 29
/* unused - was FIELD_SOFTWARE 30 */
#define FIELD_EXTRASAMPLES 31
#define FIELD_SAMPLEFORMAT 32
#define FIELD_SMINSAMPLEVALUE 33
#define FIELD_SMAXSAMPLEVALUE 34
#define FIELD_IMAGEDEPTH 35
#define FIELD_TILEDEPTH 36
#define FIELD_HALFTONEHINTS 37
#define FIELD_YCBCRCOEFFICIENTS 38
#define FIELD_YCBCRSUBSAMPLING 39
#define FIELD_YCBCRPOSITIONING 40
#define FIELD_REFBLACKWHITE 41
#define FIELD_WHITEPOINT 42
#define FIELD_PRIMARYCHROMAS 43
#define FIELD_TRANSFERFUNCTION 44
#define FIELD_INKSET 45
#define FIELD_INKNAMES 46
#define FIELD_DOTRANGE 47
#define FIELD_TARGETPRINTER 48
#define FIELD_SUBIFD 49
#define FIELD_NUMBEROFINKS 50
#define FIELD_ICCPROFILE 51
#define FIELD_PHOTOSHOP 52
#define FIELD_RICHTIFFIPTC 53
#define FIELD_STONITS 54
/* Begin PIXAR */
#define FIELD_IMAGEFULLWIDTH 55
#define FIELD_IMAGEFULLLENGTH 56
#define FIELD_TEXTUREFORMAT 57
#define FIELD_WRAPMODES 58
#define FIELD_FOVCOT 59
#define FIELD_MATRIX_WORLDTOSCREEN 60
#define FIELD_MATRIX_WORLDTOCAMERA 61
#define FIELD_COPYRIGHT 62
#define FIELD_XMLPACKET 63
/* FIELD_CUSTOM (see tiffio.h) 65 */
/* end of support for well-known tags; codec-private tags follow */
#define FIELD_CODEC 66 /* base of codec-private tags */
/*
* Pseudo-tags don't normally need field bits since they
* are not written to an output file (by definition).
* The library also has express logic to always query a
* codec for a pseudo-tag so allocating a field bit for
* one is a waste. If codec wants to promote the notion
* of a pseudo-tag being ``set'' or ``unset'' then it can
* do using internal state flags without polluting the
* field bit space defined for real tags.
*/
#define FIELD_PSEUDO 0
#define FIELD_LAST (32*FIELD_SETLONGS-1)
#define TIFFExtractData(tif, type, v) \
((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \
((v) >> (tif)->tif_typeshift[type]) & (tif)->tif_typemask[type] : \
(v) & (tif)->tif_typemask[type]))
#define TIFFInsertData(tif, type, v) \
((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \
((v) & (tif)->tif_typemask[type]) << (tif)->tif_typeshift[type] : \
(v) & (tif)->tif_typemask[type]))
#define BITn(n) (((u_long)1L)<<((n)&0x1f))
#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n)/32])
#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field))
#define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field))
#define TIFFClrFieldBit(tif, field) (BITFIELDn(tif, field) &= ~BITn(field))
#define FieldSet(fields, f) (fields[(f)/32] & BITn(f))
#define ResetFieldBit(fields, f) (fields[(f)/32] &= ~BITn(f))
#if defined(__cplusplus)
extern "C" {
#endif
extern void _TIFFSetupFieldInfo(TIFF*);
extern void _TIFFPrintFieldInfo(TIFF*, FILE*);
extern TIFFDataType _TIFFSampleToTagType(TIFF*);
extern const TIFFFieldInfo* _TIFFFindOrRegisterInfo( TIFF *tif, ttag_t tag,
TIFFDataType dt );
extern TIFFFieldInfo* _TIFFCreateAnonFieldInfo( TIFF *tif, ttag_t tag,
TIFFDataType dt );
#define _TIFFMergeFieldInfo TIFFMergeFieldInfo
#define _TIFFFindFieldInfo TIFFFindFieldInfo
#define _TIFFFieldWithTag TIFFFieldWithTag
#if defined(__cplusplus)
}
#endif
#endif /* _TIFFDIR_ */
src/add-ons/translators/libtifftranslator/tif_dirinfo.c
+486
View File
@@ -0,0 +1,486 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_dirinfo.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* Core Directory Tag Support.
*/
#include "tiffiop.h"
#include <stdlib.h>
/*
* NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
* If a tag can have both LONG and SHORT types
* then the LONG must be placed before the SHORT for
* writing to work properly.
*
* NOTE: The second field (field_readcount) and third field (field_writecount)
* sometimes use the values TIFF_VARIABLE (-1), TIFF_VARIABLE2 (-3)
* and TIFFTAG_SPP (-2). The macros should be used but would throw off
* the formatting of the code, so please interprete the -1, -2 and -3
* values accordingly.
*/
#ifndef VMS
static
#endif
const TIFFFieldInfo tiffFieldInfo[] = {
{ TIFFTAG_SUBFILETYPE, 1, 1, TIFF_LONG, FIELD_SUBFILETYPE,
TRUE, FALSE, "SubfileType" },
/* XXX SHORT for compatibility w/ old versions of the library */
{ TIFFTAG_SUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE,
TRUE, FALSE, "SubfileType" },
{ TIFFTAG_OSUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE,
TRUE, FALSE, "OldSubfileType" },
{ TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS,
FALSE, FALSE, "ImageWidth" },
{ TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
FALSE, FALSE, "ImageWidth" },
{ TIFFTAG_IMAGELENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS,
TRUE, FALSE, "ImageLength" },
{ TIFFTAG_IMAGELENGTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
TRUE, FALSE, "ImageLength" },
/* XXX LONG for compatibility with some broken TIFF writers */
{ TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_LONG, FIELD_BITSPERSAMPLE,
FALSE, FALSE, "BitsPerSample" },
{ TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_SHORT, FIELD_BITSPERSAMPLE,
FALSE, FALSE, "BitsPerSample" },
/* XXX LONG for compatibility with some broken TIFF writers */
{ TIFFTAG_COMPRESSION, -1, 1, TIFF_LONG, FIELD_COMPRESSION,
FALSE, FALSE, "Compression" },
{ TIFFTAG_COMPRESSION, -1, 1, TIFF_SHORT, FIELD_COMPRESSION,
FALSE, FALSE, "Compression" },
/* XXX LONG for compatibility with some broken TIFF writers */
{ TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_LONG, FIELD_PHOTOMETRIC,
FALSE, FALSE, "PhotometricInterpretation" },
{ TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_SHORT, FIELD_PHOTOMETRIC,
FALSE, FALSE, "PhotometricInterpretation" },
{ TIFFTAG_THRESHHOLDING, 1, 1, TIFF_SHORT, FIELD_THRESHHOLDING,
TRUE, FALSE, "Threshholding" },
{ TIFFTAG_CELLWIDTH, 1, 1, TIFF_SHORT, FIELD_IGNORE,
TRUE, FALSE, "CellWidth" },
{ TIFFTAG_CELLLENGTH, 1, 1, TIFF_SHORT, FIELD_IGNORE,
TRUE, FALSE, "CellLength" },
{ TIFFTAG_FILLORDER, 1, 1, TIFF_SHORT, FIELD_FILLORDER,
FALSE, FALSE, "FillOrder" },
{ TIFFTAG_DOCUMENTNAME, -1,-1, TIFF_ASCII, FIELD_DOCUMENTNAME,
TRUE, FALSE, "DocumentName" },
{ TIFFTAG_IMAGEDESCRIPTION, -1,-1, TIFF_ASCII, FIELD_IMAGEDESCRIPTION,
TRUE, FALSE, "ImageDescription" },
{ TIFFTAG_MAKE, -1,-1, TIFF_ASCII, FIELD_MAKE,
TRUE, FALSE, "Make" },
{ TIFFTAG_MODEL, -1,-1, TIFF_ASCII, FIELD_MODEL,
TRUE, FALSE, "Model" },
{ TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_LONG, FIELD_STRIPOFFSETS,
FALSE, FALSE, "StripOffsets" },
{ TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_SHORT, FIELD_STRIPOFFSETS,
FALSE, FALSE, "StripOffsets" },
{ TIFFTAG_ORIENTATION, 1, 1, TIFF_SHORT, FIELD_ORIENTATION,
FALSE, FALSE, "Orientation" },
{ TIFFTAG_SAMPLESPERPIXEL, 1, 1, TIFF_SHORT, FIELD_SAMPLESPERPIXEL,
FALSE, FALSE, "SamplesPerPixel" },
{ TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_LONG, FIELD_ROWSPERSTRIP,
FALSE, FALSE, "RowsPerStrip" },
{ TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_SHORT, FIELD_ROWSPERSTRIP,
FALSE, FALSE, "RowsPerStrip" },
{ TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_STRIPBYTECOUNTS,
FALSE, FALSE, "StripByteCounts" },
{ TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
FALSE, FALSE, "StripByteCounts" },
{ TIFFTAG_MINSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MINSAMPLEVALUE,
TRUE, FALSE, "MinSampleValue" },
{ TIFFTAG_MAXSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MAXSAMPLEVALUE,
TRUE, FALSE, "MaxSampleValue" },
{ TIFFTAG_XRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION,
FALSE, FALSE, "XResolution" },
{ TIFFTAG_YRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION,
FALSE, FALSE, "YResolution" },
{ TIFFTAG_PLANARCONFIG, 1, 1, TIFF_SHORT, FIELD_PLANARCONFIG,
FALSE, FALSE, "PlanarConfiguration" },
{ TIFFTAG_PAGENAME, -1,-1, TIFF_ASCII, FIELD_PAGENAME,
TRUE, FALSE, "PageName" },
{ TIFFTAG_XPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION,
TRUE, FALSE, "XPosition" },
{ TIFFTAG_YPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION,
TRUE, FALSE, "YPosition" },
{ TIFFTAG_FREEOFFSETS, -1,-1, TIFF_LONG, FIELD_IGNORE,
FALSE, FALSE, "FreeOffsets" },
{ TIFFTAG_FREEBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_IGNORE,
FALSE, FALSE, "FreeByteCounts" },
{ TIFFTAG_GRAYRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE,
TRUE, FALSE, "GrayResponseUnit" },
{ TIFFTAG_GRAYRESPONSECURVE,-1,-1, TIFF_SHORT, FIELD_IGNORE,
TRUE, FALSE, "GrayResponseCurve" },
{ TIFFTAG_RESOLUTIONUNIT, 1, 1, TIFF_SHORT, FIELD_RESOLUTIONUNIT,
FALSE, FALSE, "ResolutionUnit" },
{ TIFFTAG_PAGENUMBER, 2, 2, TIFF_SHORT, FIELD_PAGENUMBER,
TRUE, FALSE, "PageNumber" },
{ TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE,
TRUE, FALSE, "ColorResponseUnit" },
#ifdef COLORIMETRY_SUPPORT
{ TIFFTAG_TRANSFERFUNCTION, -1,-1, TIFF_SHORT, FIELD_TRANSFERFUNCTION,
TRUE, FALSE, "TransferFunction" },
#endif
{ TIFFTAG_SOFTWARE, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
TRUE, FALSE, "Software" },
{ TIFFTAG_DATETIME, 20,20, TIFF_ASCII, FIELD_DATETIME,
TRUE, FALSE, "DateTime" },
{ TIFFTAG_ARTIST, -1,-1, TIFF_ASCII, FIELD_ARTIST,
TRUE, FALSE, "Artist" },
{ TIFFTAG_HOSTCOMPUTER, -1,-1, TIFF_ASCII, FIELD_HOSTCOMPUTER,
TRUE, FALSE, "HostComputer" },
#ifdef COLORIMETRY_SUPPORT
{ TIFFTAG_WHITEPOINT, 2, 2, TIFF_RATIONAL,FIELD_WHITEPOINT,
TRUE, FALSE, "WhitePoint" },
{ TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL,FIELD_PRIMARYCHROMAS,
TRUE, FALSE, "PrimaryChromaticities" },
#endif
{ TIFFTAG_COLORMAP, -1,-1, TIFF_SHORT, FIELD_COLORMAP,
TRUE, FALSE, "ColorMap" },
{ TIFFTAG_HALFTONEHINTS, 2, 2, TIFF_SHORT, FIELD_HALFTONEHINTS,
TRUE, FALSE, "HalftoneHints" },
{ TIFFTAG_TILEWIDTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS,
FALSE, FALSE, "TileWidth" },
{ TIFFTAG_TILEWIDTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS,
FALSE, FALSE, "TileWidth" },
{ TIFFTAG_TILELENGTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS,
FALSE, FALSE, "TileLength" },
{ TIFFTAG_TILELENGTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS,
FALSE, FALSE, "TileLength" },
{ TIFFTAG_TILEOFFSETS, -1, 1, TIFF_LONG, FIELD_STRIPOFFSETS,
FALSE, FALSE, "TileOffsets" },
{ TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_LONG, FIELD_STRIPBYTECOUNTS,
FALSE, FALSE, "TileByteCounts" },
{ TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
FALSE, FALSE, "TileByteCounts" },
#ifdef TIFFTAG_SUBIFD
{ TIFFTAG_SUBIFD, -1,-1, TIFF_LONG, FIELD_SUBIFD,
TRUE, TRUE, "SubIFD" },
#endif
#ifdef CMYK_SUPPORT /* 6.0 CMYK tags */
{ TIFFTAG_INKSET, 1, 1, TIFF_SHORT, FIELD_INKSET,
FALSE, FALSE, "InkSet" },
{ TIFFTAG_INKNAMES, -1,-1, TIFF_ASCII, FIELD_INKNAMES,
TRUE, TRUE, "InkNames" },
{ TIFFTAG_NUMBEROFINKS, 1, 1, TIFF_SHORT, FIELD_NUMBEROFINKS,
TRUE, FALSE, "NumberOfInks" },
{ TIFFTAG_DOTRANGE, 2, 2, TIFF_SHORT, FIELD_DOTRANGE,
FALSE, FALSE, "DotRange" },
{ TIFFTAG_DOTRANGE, 2, 2, TIFF_BYTE, FIELD_DOTRANGE,
FALSE, FALSE, "DotRange" },
{ TIFFTAG_TARGETPRINTER, -1,-1, TIFF_ASCII, FIELD_TARGETPRINTER,
TRUE, FALSE, "TargetPrinter" },
#endif
{ TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_SHORT, FIELD_EXTRASAMPLES,
FALSE, FALSE, "ExtraSamples" },
/* XXX for bogus Adobe Photoshop v2.5 files */
{ TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_BYTE, FIELD_EXTRASAMPLES,
FALSE, FALSE, "ExtraSamples" },
{ TIFFTAG_SAMPLEFORMAT, -1,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT,
FALSE, FALSE, "SampleFormat" },
{ TIFFTAG_SMINSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMINSAMPLEVALUE,
TRUE, FALSE, "SMinSampleValue" },
{ TIFFTAG_SMAXSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMAXSAMPLEVALUE,
TRUE, FALSE, "SMaxSampleValue" },
#ifdef YCBCR_SUPPORT /* 6.0 YCbCr tags */
{ TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL, FIELD_YCBCRCOEFFICIENTS,
FALSE, FALSE, "YCbCrCoefficients" },
{ TIFFTAG_YCBCRSUBSAMPLING, 2, 2, TIFF_SHORT, FIELD_YCBCRSUBSAMPLING,
FALSE, FALSE, "YCbCrSubsampling" },
{ TIFFTAG_YCBCRPOSITIONING, 1, 1, TIFF_SHORT, FIELD_YCBCRPOSITIONING,
FALSE, FALSE, "YCbCrPositioning" },
#endif
#ifdef COLORIMETRY_SUPPORT
{ TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_RATIONAL, FIELD_REFBLACKWHITE,
TRUE, FALSE, "ReferenceBlackWhite" },
/* XXX temporarily accept LONG for backwards compatibility */
{ TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_LONG, FIELD_REFBLACKWHITE,
TRUE, FALSE, "ReferenceBlackWhite" },
#endif
{ TIFFTAG_XMLPACKET, -1,-3, TIFF_UNDEFINED, FIELD_XMLPACKET,
FALSE, TRUE, "XMLPacket" },
/* begin SGI tags */
{ TIFFTAG_MATTEING, 1, 1, TIFF_SHORT, FIELD_EXTRASAMPLES,
FALSE, FALSE, "Matteing" },
{ TIFFTAG_DATATYPE, -2,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT,
FALSE, FALSE, "DataType" },
{ TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_LONG, FIELD_IMAGEDEPTH,
FALSE, FALSE, "ImageDepth" },
{ TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDEPTH,
FALSE, FALSE, "ImageDepth" },
{ TIFFTAG_TILEDEPTH, 1, 1, TIFF_LONG, FIELD_TILEDEPTH,
FALSE, FALSE, "TileDepth" },
{ TIFFTAG_TILEDEPTH, 1, 1, TIFF_SHORT, FIELD_TILEDEPTH,
FALSE, FALSE, "TileDepth" },
/* end SGI tags */
/* begin Pixar tags */
{ TIFFTAG_PIXAR_IMAGEFULLWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEFULLWIDTH,
TRUE, FALSE, "ImageFullWidth" },
{ TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEFULLLENGTH,
TRUE, FALSE, "ImageFullLength" },
{ TIFFTAG_PIXAR_TEXTUREFORMAT, -1,-1, TIFF_ASCII, FIELD_TEXTUREFORMAT,
TRUE, FALSE, "TextureFormat" },
{ TIFFTAG_PIXAR_WRAPMODES, -1,-1, TIFF_ASCII, FIELD_WRAPMODES,
TRUE, FALSE, "TextureWrapModes" },
{ TIFFTAG_PIXAR_FOVCOT, 1, 1, TIFF_FLOAT, FIELD_FOVCOT,
TRUE, FALSE, "FieldOfViewCotan" },
{ TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16,16, TIFF_FLOAT,
FIELD_MATRIX_WORLDTOSCREEN, TRUE, FALSE, "MatrixWorldToScreen" },
{ TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16,16, TIFF_FLOAT,
FIELD_MATRIX_WORLDTOCAMERA, TRUE, FALSE, "MatrixWorldToCamera" },
{ TIFFTAG_COPYRIGHT, -1,-1, TIFF_ASCII, FIELD_COPYRIGHT,
TRUE, FALSE, "Copyright" },
/* end Pixar tags */
#ifdef IPTC_SUPPORT
#ifdef PHOTOSHOP_SUPPORT
{ TIFFTAG_RICHTIFFIPTC, -1,-1, TIFF_LONG, FIELD_RICHTIFFIPTC,
FALSE, TRUE, "RichTIFFIPTC" },
#else
{ TIFFTAG_RICHTIFFIPTC, -1,-3, TIFF_UNDEFINED, FIELD_RICHTIFFIPTC,
FALSE, TRUE, "RichTIFFIPTC" },
#endif
#endif
#ifdef PHOTOSHOP_SUPPORT
{ TIFFTAG_PHOTOSHOP, -1,-3, TIFF_BYTE, FIELD_PHOTOSHOP,
FALSE, TRUE, "Photoshop" },
#endif
#ifdef ICC_SUPPORT
{ TIFFTAG_ICCPROFILE, -1,-3, TIFF_UNDEFINED, FIELD_ICCPROFILE,
FALSE, TRUE, "ICC Profile" },
#endif
{ TIFFTAG_STONITS, 1, 1, TIFF_DOUBLE, FIELD_STONITS,
FALSE, FALSE, "StoNits" },
};
#define N(a) (sizeof (a) / sizeof (a[0]))
void
_TIFFSetupFieldInfo(TIFF* tif)
{
if (tif->tif_fieldinfo) {
int i;
for (i = 0; i < tif->tif_nfields; i++)
{
TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
if (fld->field_bit == FIELD_CUSTOM &&
strncmp("Tag ", fld->field_name, 4) == 0)
{
_TIFFfree(fld->field_name);
_TIFFfree(fld);
}
}
_TIFFfree(tif->tif_fieldinfo);
tif->tif_nfields = 0;
}
_TIFFMergeFieldInfo(tif, tiffFieldInfo, N(tiffFieldInfo));
}
static int
tagCompare(const void* a, const void* b)
{
const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
/* NB: be careful of return values for 16-bit platforms */
if (ta->field_tag != tb->field_tag)
return (ta->field_tag < tb->field_tag ? -1 : 1);
else
return (tb->field_type < ta->field_type ? -1 : 1);
}
void
_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
{
TIFFFieldInfo** tp;
int i;
if (tif->tif_nfields > 0) {
tif->tif_fieldinfo = (TIFFFieldInfo**)
_TIFFrealloc(tif->tif_fieldinfo,
(tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
} else {
tif->tif_fieldinfo = (TIFFFieldInfo**)
_TIFFmalloc(n * sizeof (TIFFFieldInfo*));
}
tp = &tif->tif_fieldinfo[tif->tif_nfields];
for (i = 0; i < n; i++)
tp[i] = (TIFFFieldInfo*) &info[i]; /* XXX */
/* Sort the field info by tag number */
qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n),
sizeof (TIFFFieldInfo*), tagCompare);
}
void
_TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
{
int i;
fprintf(fd, "%s: \n", tif->tif_name);
for (i = 0; i < tif->tif_nfields; i++) {
const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
, i
, (unsigned long) fip->field_tag
, fip->field_readcount, fip->field_writecount
, fip->field_type
, fip->field_bit
, fip->field_oktochange ? "TRUE" : "FALSE"
, fip->field_passcount ? "TRUE" : "FALSE"
, fip->field_name
);
}
}
/*
* Return size of TIFFDataType in bytes
*/
int
TIFFDataWidth(TIFFDataType type)
{
switch(type)
{
case 0: /* nothing */
case 1: /* TIFF_BYTE */
case 2: /* TIFF_ASCII */
case 6: /* TIFF_SBYTE */
case 7: /* TIFF_UNDEFINED */
return 1;
case 3: /* TIFF_SHORT */
case 8: /* TIFF_SSHORT */
return 2;
case 4: /* TIFF_LONG */
case 9: /* TIFF_SLONG */
case 11: /* TIFF_FLOAT */
return 4;
case 5: /* TIFF_RATIONAL */
case 10: /* TIFF_SRATIONAL */
case 12: /* TIFF_DOUBLE */
return 8;
default:
return 1; /* will return safe value for unknown types */
}
}
/*
* Return nearest TIFFDataType to the sample type of an image.
*/
TIFFDataType
_TIFFSampleToTagType(TIFF* tif)
{
int bps = (int) TIFFhowmany(tif->tif_dir.td_bitspersample, 8);
switch (tif->tif_dir.td_sampleformat) {
case SAMPLEFORMAT_IEEEFP:
return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
case SAMPLEFORMAT_INT:
return (bps <= 1 ? TIFF_SBYTE :
bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
case SAMPLEFORMAT_UINT:
return (bps <= 1 ? TIFF_BYTE :
bps <= 2 ? TIFF_SHORT : TIFF_LONG);
case SAMPLEFORMAT_VOID:
return (TIFF_UNDEFINED);
}
/*NOTREACHED*/
return (TIFF_UNDEFINED);
}
const TIFFFieldInfo*
_TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
{
static const TIFFFieldInfo *last = NULL;
int i, n;
if (last && last->field_tag == tag &&
(dt == TIFF_ANY || dt == last->field_type))
return (last);
/* NB: if table gets big, use sorted search (e.g. binary search) */
for (i = 0, n = tif->tif_nfields; i < n; i++) {
const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
if (fip->field_tag == tag &&
(dt == TIFF_ANY || fip->field_type == dt))
return (last = fip);
}
return ((const TIFFFieldInfo *)0);
}
#include <assert.h>
#include <stdio.h>
const TIFFFieldInfo*
_TIFFFieldWithTag(TIFF* tif, ttag_t tag)
{
const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
if (!fip) {
TIFFError("TIFFFieldWithTag",
"Internal error, unknown tag 0x%x", (u_int) tag);
assert(fip != NULL);
/*NOTREACHED*/
}
return (fip);
}
const TIFFFieldInfo*
_TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt )
{
const TIFFFieldInfo *fld;
fld = _TIFFFindFieldInfo( tif, tag, dt );
if( fld == NULL )
{
fld = _TIFFCreateAnonFieldInfo( tif, tag, dt );
_TIFFMergeFieldInfo( tif, fld, 1 );
}
return fld;
}
TIFFFieldInfo*
_TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
{
TIFFFieldInfo *fld;
fld = _TIFFmalloc(sizeof (TIFFFieldInfo));
_TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) );
fld->field_tag = tag;
fld->field_readcount = TIFF_VARIABLE;
fld->field_writecount = TIFF_VARIABLE;
fld->field_type = field_type;
fld->field_bit = FIELD_CUSTOM;
fld->field_oktochange = TRUE;
fld->field_passcount = TRUE;
fld->field_name = (char *) _TIFFmalloc(32);
/* note that this name is a special sign to TIFFClose() and
* _TIFFSetupFieldInfo() to free the field
*/
sprintf(fld->field_name, "Tag %d", (int) tag);
return fld;
}
src/add-ons/translators/libtifftranslator/tif_dirread.c
+1460
View File
File diff suppressed because it is too large Load Diff
src/add-ons/translators/libtifftranslator/tif_dirwrite.c
+1178
View File
File diff suppressed because it is too large Load Diff
src/add-ons/translators/libtifftranslator/tif_dumpmode.c
+118
View File
@@ -0,0 +1,118 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_dumpmode.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* "Null" Compression Algorithm Support.
*/
#include "tiffiop.h"
#include <assert.h>
/*
* Encode a hunk of pixels.
*/
static int
DumpModeEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
{
(void) s;
while (cc > 0) {
tsize_t n;
n = cc;
if (tif->tif_rawcc + n > tif->tif_rawdatasize)
n = tif->tif_rawdatasize - tif->tif_rawcc;
assert( n > 0 );
/*
* Avoid copy if client has setup raw
* data buffer to avoid extra copy.
*/
if (tif->tif_rawcp != pp)
_TIFFmemcpy(tif->tif_rawcp, pp, n);
tif->tif_rawcp += n;
tif->tif_rawcc += n;
pp += n;
cc -= n;
if (tif->tif_rawcc >= tif->tif_rawdatasize &&
!TIFFFlushData1(tif))
return (-1);
}
return (1);
}
/*
* Decode a hunk of pixels.
*/
static int
DumpModeDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
{
(void) s;
if (tif->tif_rawcc < cc) {
TIFFError(tif->tif_name,
"DumpModeDecode: Not enough data for scanline %d",
tif->tif_row);
return (0);
}
/*
* Avoid copy if client has setup raw
* data buffer to avoid extra copy.
*/
if (tif->tif_rawcp != buf)
_TIFFmemcpy(buf, tif->tif_rawcp, cc);
tif->tif_rawcp += cc;
tif->tif_rawcc -= cc;
return (1);
}
/*
* Seek forwards nrows in the current strip.
*/
static int
DumpModeSeek(TIFF* tif, uint32 nrows)
{
tif->tif_rawcp += nrows * tif->tif_scanlinesize;
tif->tif_rawcc -= nrows * tif->tif_scanlinesize;
return (1);
}
/*
* Initialize dump mode.
*/
int
TIFFInitDumpMode(TIFF* tif, int scheme)
{
(void) scheme;
tif->tif_decoderow = DumpModeDecode;
tif->tif_decodestrip = DumpModeDecode;
tif->tif_decodetile = DumpModeDecode;
tif->tif_encoderow = DumpModeEncode;
tif->tif_encodestrip = DumpModeEncode;
tif->tif_encodetile = DumpModeEncode;
tif->tif_seek = DumpModeSeek;
return (1);
}
src/add-ons/translators/libtifftranslator/tif_error.c
+49
View File
@@ -0,0 +1,49 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_error.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*/
#include "tiffiop.h"
TIFFErrorHandler
TIFFSetErrorHandler(TIFFErrorHandler handler)
{
TIFFErrorHandler prev = _TIFFerrorHandler;
_TIFFerrorHandler = handler;
return (prev);
}
void
TIFFError(const char* module, const char* fmt, ...)
{
if (_TIFFerrorHandler) {
va_list ap;
va_start(ap, fmt);
(*_TIFFerrorHandler)(module, fmt, ap);
va_end(ap);
}
}
src/add-ons/translators/libtifftranslator/tif_extension.c
+109
View File
@@ -0,0 +1,109 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_extension.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* Various routines support external extension of the tag set, and other
* application extension capabilities.
*/
#include "tiffiop.h"
int TIFFGetTagListCount( TIFF *tif )
{
TIFFDirectory* td = &tif->tif_dir;
return td->td_customValueCount;
}
ttag_t TIFFGetTagListEntry( TIFF *tif, int tag_index )
{
TIFFDirectory* td = &tif->tif_dir;
if( tag_index < 0 || tag_index >= td->td_customValueCount )
return -1;
else
return td->td_customValues[tag_index].info->field_tag;
}
/*
** This provides read/write access to the TIFFTagMethods within the TIFF
** structure to application code without giving access to the private
** TIFF structure.
*/
TIFFTagMethods *TIFFAccessTagMethods( TIFF *tif )
{
return &(tif->tif_tagmethods);
}
void *TIFFGetClientInfo( TIFF *tif, const char *name )
{
TIFFClientInfoLink *link = tif->tif_clientinfo;
while( link != NULL && strcmp(link->name,name) != 0 )
link = link->next;
if( link != NULL )
return link->data;
else
return NULL;
}
void TIFFSetClientInfo( TIFF *tif, void *data, const char *name )
{
TIFFClientInfoLink *link = tif->tif_clientinfo;
/*
** Do we have an existing link with this name? If so, just
** set it.
*/
while( link != NULL && strcmp(link->name,name) != 0 )
link = link->next;
if( link != NULL )
{
link->data = data;
return;
}
/*
** Create a new link.
*/
link = _TIFFmalloc(sizeof(TIFFClientInfoLink));
link->next = tif->tif_clientinfo;
link->name = _TIFFmalloc(strlen(name)+1);
strcpy( link->name, name );
link->data = data;
tif->tif_clientinfo = link;
}
src/add-ons/translators/libtifftranslator/tif_fax3.c
+1538
View File
File diff suppressed because it is too large Load Diff
src/add-ons/translators/libtifftranslator/tif_fax3.h
+525
View File
@@ -0,0 +1,525 @@
/* $Id: tif_fax3.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1990-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _FAX3_
#define _FAX3_
/*
* TIFF Library.
*
* CCITT Group 3 (T.4) and Group 4 (T.6) Decompression Support.
*
* Decoder support is derived, with permission, from the code
* in Frank Cringle's viewfax program;
* Copyright (C) 1990, 1995 Frank D. Cringle.
*/
#include "tiff.h"
/*
* To override the default routine used to image decoded
* spans one can use the pseduo tag TIFFTAG_FAXFILLFUNC.
* The routine must have the type signature given below;
* for example:
*
* fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx)
*
* where buf is place to set the bits, runs is the array of b&w run
* lengths (white then black), erun is the last run in the array, and
* lastx is the width of the row in pixels. Fill routines can assume
* the run array has room for at least lastx runs and can overwrite
* data in the run array as needed (e.g. to append zero runs to bring
* the count up to a nice multiple).
*/
typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32);
/*
* The default run filler; made external for other decoders.
*/
#if defined(__cplusplus)
extern "C" {
#endif
extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32);
#if defined(__cplusplus)
}
#endif
/* finite state machine codes */
#define S_Null 0
#define S_Pass 1
#define S_Horiz 2
#define S_V0 3
#define S_VR 4
#define S_VL 5
#define S_Ext 6
#define S_TermW 7
#define S_TermB 8
#define S_MakeUpW 9
#define S_MakeUpB 10
#define S_MakeUp 11
#define S_EOL 12
typedef struct { /* state table entry */
unsigned char State; /* see above */
unsigned char Width; /* width of code in bits */
uint32 Param; /* unsigned 32-bit run length in bits */
} TIFFFaxTabEnt;
extern const TIFFFaxTabEnt TIFFFaxMainTable[];
extern const TIFFFaxTabEnt TIFFFaxWhiteTable[];
extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
/*
* The following macros define the majority of the G3/G4 decoder
* algorithm using the state tables defined elsewhere. To build
* a decoder you need some setup code and some glue code. Note
* that you may also need/want to change the way the NeedBits*
* macros get input data if, for example, you know the data to be
* decoded is properly aligned and oriented (doing so before running
* the decoder can be a big performance win).
*
* Consult the decoder in the TIFF library for an idea of what you
* need to define and setup to make use of these definitions.
*
* NB: to enable a debugging version of these macros define FAX3_DEBUG
* before including this file. Trace output goes to stdout.
*/
#ifndef EndOfData
#define EndOfData() (cp >= ep)
#endif
/*
* Need <=8 or <=16 bits of input data. Unlike viewfax we
* cannot use/assume a word-aligned, properly bit swizzled
* input data set because data may come from an arbitrarily
* aligned, read-only source such as a memory-mapped file.
* Note also that the viewfax decoder does not check for
* running off the end of the input data buffer. This is
* possible for G3-encoded data because it prescans the input
* data to count EOL markers, but can cause problems for G4
* data. In any event, we don't prescan and must watch for
* running out of data since we can't permit the library to
* scan past the end of the input data buffer.
*
* Finally, note that we must handle remaindered data at the end
* of a strip specially. The coder asks for a fixed number of
* bits when scanning for the next code. This may be more bits
* than are actually present in the data stream. If we appear
* to run out of data but still have some number of valid bits
* remaining then we makeup the requested amount with zeros and
* return successfully. If the returned data is incorrect then
* we should be called again and get a premature EOF error;
* otherwise we should get the right answer.
*/
#ifndef NeedBits8
#define NeedBits8(n,eoflab) do { \
if (BitsAvail < (n)) { \
if (EndOfData()) { \
if (BitsAvail == 0) /* no valid bits */ \
goto eoflab; \
BitsAvail = (n); /* pad with zeros */ \
} else { \
BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail; \
BitsAvail += 8; \
} \
} \
} while (0)
#endif
#ifndef NeedBits16
#define NeedBits16(n,eoflab) do { \
if (BitsAvail < (n)) { \
if (EndOfData()) { \
if (BitsAvail == 0) /* no valid bits */ \
goto eoflab; \
BitsAvail = (n); /* pad with zeros */ \
} else { \
BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail; \
if ((BitsAvail += 8) < (n)) { \
if (EndOfData()) { \
/* NB: we know BitsAvail is non-zero here */ \
BitsAvail = (n); /* pad with zeros */ \
} else { \
BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail; \
BitsAvail += 8; \
} \
} \
} \
} \
} while (0)
#endif
#define GetBits(n) (BitAcc & ((1<<(n))-1))
#define ClrBits(n) do { \
BitsAvail -= (n); \
BitAcc >>= (n); \
} while (0)
#ifdef FAX3_DEBUG
static const char* StateNames[] = {
"Null ",
"Pass ",
"Horiz ",
"V0 ",
"VR ",
"VL ",
"Ext ",
"TermW ",
"TermB ",
"MakeUpW",
"MakeUpB",
"MakeUp ",
"EOL ",
};
#define DEBUG_SHOW putchar(BitAcc & (1 << t) ? '1' : '0')
#define LOOKUP8(wid,tab,eoflab) do { \
int t; \
NeedBits8(wid,eoflab); \
TabEnt = tab + GetBits(wid); \
printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail, \
StateNames[TabEnt->State], TabEnt->Param); \
for (t = 0; t < TabEnt->Width; t++) \
DEBUG_SHOW; \
putchar('\n'); \
fflush(stdout); \
ClrBits(TabEnt->Width); \
} while (0)
#define LOOKUP16(wid,tab,eoflab) do { \
int t; \
NeedBits16(wid,eoflab); \
TabEnt = tab + GetBits(wid); \
printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail, \
StateNames[TabEnt->State], TabEnt->Param); \
for (t = 0; t < TabEnt->Width; t++) \
DEBUG_SHOW; \
putchar('\n'); \
fflush(stdout); \
ClrBits(TabEnt->Width); \
} while (0)
#define SETVAL(x) do { \
*pa++ = RunLength + (x); \
printf("SETVAL: %d\t%d\n", RunLength + (x), a0); \
a0 += x; \
RunLength = 0; \
} while (0)
#else
#define LOOKUP8(wid,tab,eoflab) do { \
NeedBits8(wid,eoflab); \
TabEnt = tab + GetBits(wid); \
ClrBits(TabEnt->Width); \
} while (0)
#define LOOKUP16(wid,tab,eoflab) do { \
NeedBits16(wid,eoflab); \
TabEnt = tab + GetBits(wid); \
ClrBits(TabEnt->Width); \
} while (0)
/*
* Append a run to the run length array for the
* current row and reset decoding state.
*/
#define SETVAL(x) do { \
*pa++ = RunLength + (x); \
a0 += (x); \
RunLength = 0; \
} while (0)
#endif
/*
* Synchronize input decoding at the start of each
* row by scanning for an EOL (if appropriate) and
* skipping any trash data that might be present
* after a decoding error. Note that the decoding
* done elsewhere that recognizes an EOL only consumes
* 11 consecutive zero bits. This means that if EOLcnt
* is non-zero then we still need to scan for the final flag
* bit that is part of the EOL code.
*/
#define SYNC_EOL(eoflab) do { \
if (EOLcnt == 0) { \
for (;;) { \
NeedBits16(11,eoflab); \
if (GetBits(11) == 0) \
break; \
ClrBits(1); \
} \
} \
for (;;) { \
NeedBits8(8,eoflab); \
if (GetBits(8)) \
break; \
ClrBits(8); \
} \
while (GetBits(1) == 0) \
ClrBits(1); \
ClrBits(1); /* EOL bit */ \
EOLcnt = 0; /* reset EOL counter/flag */ \
} while (0)
/*
* Cleanup the array of runs after decoding a row.
* We adjust final runs to insure the user buffer is not
* overwritten and/or undecoded area is white filled.
*/
#define CLEANUP_RUNS() do { \
if (RunLength) \
SETVAL(0); \
if (a0 != lastx) { \
badlength(a0, lastx); \
while (a0 > lastx && pa > thisrun) \
a0 -= *--pa; \
if (a0 < lastx) { \
if (a0 < 0) \
a0 = 0; \
if ((pa-thisrun)&1) \
SETVAL(0); \
SETVAL(lastx - a0); \
} else if (a0 > lastx) { \
SETVAL(lastx); \
SETVAL(0); \
} \
} \
} while (0)
/*
* Decode a line of 1D-encoded data.
*
* The line expanders are written as macros so that they can be reused
* but still have direct access to the local variables of the "calling"
* function.
*
* Note that unlike the original version we have to explicitly test for
* a0 >= lastx after each black/white run is decoded. This is because
* the original code depended on the input data being zero-padded to
* insure the decoder recognized an EOL before running out of data.
*/
#define EXPAND1D(eoflab) do { \
for (;;) { \
for (;;) { \
LOOKUP16(12, TIFFFaxWhiteTable, eof1d); \
switch (TabEnt->State) { \
case S_EOL: \
EOLcnt = 1; \
goto done1d; \
case S_TermW: \
SETVAL(TabEnt->Param); \
goto doneWhite1d; \
case S_MakeUpW: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
break; \
default: \
unexpected("WhiteTable", a0); \
goto done1d; \
} \
} \
doneWhite1d: \
if (a0 >= lastx) \
goto done1d; \
for (;;) { \
LOOKUP16(13, TIFFFaxBlackTable, eof1d); \
switch (TabEnt->State) { \
case S_EOL: \
EOLcnt = 1; \
goto done1d; \
case S_TermB: \
SETVAL(TabEnt->Param); \
goto doneBlack1d; \
case S_MakeUpB: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
break; \
default: \
unexpected("BlackTable", a0); \
goto done1d; \
} \
} \
doneBlack1d: \
if (a0 >= lastx) \
goto done1d; \
if( *(pa-1) == 0 && *(pa-2) == 0 ) \
pa -= 2; \
} \
eof1d: \
prematureEOF(a0); \
CLEANUP_RUNS(); \
goto eoflab; \
done1d: \
CLEANUP_RUNS(); \
} while (0)
/*
* Update the value of b1 using the array
* of runs for the reference line.
*/
#define CHECK_b1 do { \
if (pa != thisrun) while (b1 <= a0 && b1 < lastx) { \
b1 += pb[0] + pb[1]; \
pb += 2; \
} \
} while (0)
/*
* Expand a row of 2D-encoded data.
*/
#define EXPAND2D(eoflab) do { \
while (a0 < lastx) { \
LOOKUP8(7, TIFFFaxMainTable, eof2d); \
switch (TabEnt->State) { \
case S_Pass: \
CHECK_b1; \
b1 += *pb++; \
RunLength += b1 - a0; \
a0 = b1; \
b1 += *pb++; \
break; \
case S_Horiz: \
if ((pa-thisrun)&1) { \
for (;;) { /* black first */ \
LOOKUP16(13, TIFFFaxBlackTable, eof2d); \
switch (TabEnt->State) { \
case S_TermB: \
SETVAL(TabEnt->Param); \
goto doneWhite2da; \
case S_MakeUpB: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
break; \
default: \
goto badBlack2d; \
} \
} \
doneWhite2da:; \
for (;;) { /* then white */ \
LOOKUP16(12, TIFFFaxWhiteTable, eof2d); \
switch (TabEnt->State) { \
case S_TermW: \
SETVAL(TabEnt->Param); \
goto doneBlack2da; \
case S_MakeUpW: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
break; \
default: \
goto badWhite2d; \
} \
} \
doneBlack2da:; \
} else { \
for (;;) { /* white first */ \
LOOKUP16(12, TIFFFaxWhiteTable, eof2d); \
switch (TabEnt->State) { \
case S_TermW: \
SETVAL(TabEnt->Param); \
goto doneWhite2db; \
case S_MakeUpW: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
break; \
default: \
goto badWhite2d; \
} \
} \
doneWhite2db:; \
for (;;) { /* then black */ \
LOOKUP16(13, TIFFFaxBlackTable, eof2d); \
switch (TabEnt->State) { \
case S_TermB: \
SETVAL(TabEnt->Param); \
goto doneBlack2db; \
case S_MakeUpB: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
break; \
default: \
goto badBlack2d; \
} \
} \
doneBlack2db:; \
} \
CHECK_b1; \
break; \
case S_V0: \
CHECK_b1; \
SETVAL(b1 - a0); \
b1 += *pb++; \
break; \
case S_VR: \
CHECK_b1; \
SETVAL(b1 - a0 + TabEnt->Param); \
b1 += *pb++; \
break; \
case S_VL: \
CHECK_b1; \
SETVAL(b1 - a0 - TabEnt->Param); \
b1 -= *--pb; \
break; \
case S_Ext: \
*pa++ = lastx - a0; \
extension(a0); \
goto eol2d; \
case S_EOL: \
*pa++ = lastx - a0; \
NeedBits8(4,eof2d); \
if (GetBits(4)) \
unexpected("EOL", a0); \
ClrBits(4); \
EOLcnt = 1; \
goto eol2d; \
default: \
badMain2d: \
unexpected("MainTable", a0); \
goto eol2d; \
badBlack2d: \
unexpected("BlackTable", a0); \
goto eol2d; \
badWhite2d: \
unexpected("WhiteTable", a0); \
goto eol2d; \
eof2d: \
prematureEOF(a0); \
CLEANUP_RUNS(); \
goto eoflab; \
} \
} \
if (RunLength) { \
if (RunLength + a0 < lastx) { \
/* expect a final V0 */ \
NeedBits8(1,eof2d); \
if (!GetBits(1)) \
goto badMain2d; \
ClrBits(1); \
} \
SETVAL(0); \
} \
eol2d: \
CLEANUP_RUNS(); \
} while (0)
#endif /* _FAX3_ */
src/add-ons/translators/libtifftranslator/tif_fax3sm.c
+1046
View File
File diff suppressed because it is too large Load Diff
src/add-ons/translators/libtifftranslator/tif_flush.c
+67
View File
@@ -0,0 +1,67 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_flush.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*/
#include "tiffiop.h"
int
TIFFFlush(TIFF* tif)
{
if (tif->tif_mode != O_RDONLY) {
if (!TIFFFlushData(tif))
return (0);
if ((tif->tif_flags & TIFF_DIRTYDIRECT) &&
!TIFFWriteDirectory(tif))
return (0);
}
return (1);
}
/*
* Flush buffered data to the file.
*
* Frank Warmerdam'2000: I modified this to return 1 if TIFF_BEENWRITING
* is not set, so that TIFFFlush() will proceed to write out the directory.
* The documentation says returning 1 is an error indicator, but not having
* been writing isn't exactly a an error. Hopefully this doesn't cause
* problems for other people.
*/
int
TIFFFlushData(TIFF* tif)
{
if ((tif->tif_flags & TIFF_BEENWRITING) == 0)
return (0);
if (tif->tif_flags & TIFF_POSTENCODE) {
tif->tif_flags &= ~TIFF_POSTENCODE;
if (!(*tif->tif_postencode)(tif))
return (0);
}
return (TIFFFlushData1(tif));
}
src/add-ons/translators/libtifftranslator/tif_getimage.c
+2446
View File
File diff suppressed because it is too large Load Diff
src/add-ons/translators/libtifftranslator/tif_luv.c
+1586
View File
File diff suppressed because it is too large Load Diff
src/add-ons/translators/libtifftranslator/tif_lzw.c
+1086
View File
File diff suppressed because it is too large Load Diff
src/add-ons/translators/libtifftranslator/tif_next.c
+142
View File
@@ -0,0 +1,142 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_next.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include "tiffiop.h"
#ifdef NEXT_SUPPORT
/*
* TIFF Library.
*
* NeXT 2-bit Grey Scale Compression Algorithm Support
*/
#define SETPIXEL(op, v) { \
switch (npixels++ & 3) { \
case 0: op[0] = (v) << 6; break; \
case 1: op[0] |= (v) << 4; break; \
case 2: op[0] |= (v) << 2; break; \
case 3: *op++ |= (v); break; \
} \
}
#define LITERALROW 0x00
#define LITERALSPAN 0x40
#define WHITE ((1<<2)-1)
static int
NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
{
register u_char *bp, *op;
register tsize_t cc;
register int n;
tidata_t row;
tsize_t scanline;
(void) s;
/*
* Each scanline is assumed to start off as all
* white (we assume a PhotometricInterpretation
* of ``min-is-black'').
*/
for (op = buf, cc = occ; cc-- > 0;)
*op++ = 0xff;
bp = (u_char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
scanline = tif->tif_scanlinesize;
for (row = buf; (long)occ > 0; occ -= scanline, row += scanline) {
n = *bp++, cc--;
switch (n) {
case LITERALROW:
/*
* The entire scanline is given as literal values.
*/
if (cc < scanline)
goto bad;
_TIFFmemcpy(row, bp, scanline);
bp += scanline;
cc -= scanline;
break;
case LITERALSPAN: {
int off;
/*
* The scanline has a literal span
* that begins at some offset.
*/
off = (bp[0] * 256) + bp[1];
n = (bp[2] * 256) + bp[3];
if (cc < 4+n)
goto bad;
_TIFFmemcpy(row+off, bp+4, n);
bp += 4+n;
cc -= 4+n;
break;
}
default: {
register int npixels = 0, grey;
u_long imagewidth = tif->tif_dir.td_imagewidth;
/*
* The scanline is composed of a sequence
* of constant color ``runs''. We shift
* into ``run mode'' and interpret bytes
* as codes of the form <color><npixels>
* until we've filled the scanline.
*/
op = row;
for (;;) {
grey = (n>>6) & 0x3;
n &= 0x3f;
while (n-- > 0)
SETPIXEL(op, grey);
if (npixels >= (int) imagewidth)
break;
if (cc == 0)
goto bad;
n = *bp++, cc--;
}
break;
}
}
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcc = cc;
return (1);
bad:
TIFFError(tif->tif_name, "NeXTDecode: Not enough data for scanline %ld",
(long) tif->tif_row);
return (0);
}
int
TIFFInitNeXT(TIFF* tif, int scheme)
{
(void) scheme;
tif->tif_decoderow = NeXTDecode;
tif->tif_decodestrip = NeXTDecode;
tif->tif_decodetile = NeXTDecode;
return (1);
}
#endif /* NEXT_SUPPORT */
src/add-ons/translators/libtifftranslator/tif_open.c
+493
View File
@@ -0,0 +1,493 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_open.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*/
#include "tiffiop.h"
void _TIFFSetDefaultCompressionState(TIFF* tif);
static const long typemask[13] = {
0L, /* TIFF_NOTYPE */
0x000000ffL, /* TIFF_BYTE */
0xffffffffL, /* TIFF_ASCII */
0x0000ffffL, /* TIFF_SHORT */
0xffffffffL, /* TIFF_LONG */
0xffffffffL, /* TIFF_RATIONAL */
0x000000ffL, /* TIFF_SBYTE */
0x000000ffL, /* TIFF_UNDEFINED */
0x0000ffffL, /* TIFF_SSHORT */
0xffffffffL, /* TIFF_SLONG */
0xffffffffL, /* TIFF_SRATIONAL */
0xffffffffL, /* TIFF_FLOAT */
0xffffffffL, /* TIFF_DOUBLE */
};
static const int bigTypeshift[13] = {
0, /* TIFF_NOTYPE */
24, /* TIFF_BYTE */
0, /* TIFF_ASCII */
16, /* TIFF_SHORT */
0, /* TIFF_LONG */
0, /* TIFF_RATIONAL */
24, /* TIFF_SBYTE */
24, /* TIFF_UNDEFINED */
16, /* TIFF_SSHORT */
0, /* TIFF_SLONG */
0, /* TIFF_SRATIONAL */
0, /* TIFF_FLOAT */
0, /* TIFF_DOUBLE */
};
static const int litTypeshift[13] = {
0, /* TIFF_NOTYPE */
0, /* TIFF_BYTE */
0, /* TIFF_ASCII */
0, /* TIFF_SHORT */
0, /* TIFF_LONG */
0, /* TIFF_RATIONAL */
0, /* TIFF_SBYTE */
0, /* TIFF_UNDEFINED */
0, /* TIFF_SSHORT */
0, /* TIFF_SLONG */
0, /* TIFF_SRATIONAL */
0, /* TIFF_FLOAT */
0, /* TIFF_DOUBLE */
};
/*
* Initialize the shift & mask tables, and the
* byte swapping state according to the file
* contents and the machine architecture.
*/
static void
TIFFInitOrder(TIFF* tif, int magic, int bigendian)
{
tif->tif_typemask = typemask;
if (magic == TIFF_BIGENDIAN) {
tif->tif_typeshift = bigTypeshift;
if (!bigendian)
tif->tif_flags |= TIFF_SWAB;
} else {
tif->tif_typeshift = litTypeshift;
if (bigendian)
tif->tif_flags |= TIFF_SWAB;
}
}
int
_TIFFgetMode(const char* mode, const char* module)
{
int m = -1;
switch (mode[0]) {
case 'r':
m = O_RDONLY;
if (mode[1] == '+')
m = O_RDWR;
break;
case 'w':
case 'a':
m = O_RDWR|O_CREAT;
if (mode[0] == 'w')
m |= O_TRUNC;
break;
default:
TIFFError(module, "\"%s\": Bad mode", mode);
break;
}
return (m);
}
TIFF*
TIFFClientOpen(
const char* name, const char* mode,
thandle_t clientdata,
TIFFReadWriteProc readproc,
TIFFReadWriteProc writeproc,
TIFFSeekProc seekproc,
TIFFCloseProc closeproc,
TIFFSizeProc sizeproc,
TIFFMapFileProc mapproc,
TIFFUnmapFileProc unmapproc
)
{
static const char module[] = "TIFFClientOpen";
TIFF *tif;
int m, bigendian;
const char* cp;
m = _TIFFgetMode(mode, module);
if (m == -1)
goto bad2;
tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);
if (tif == NULL) {
TIFFError(module, "%s: Out of memory (TIFF structure)", name);
goto bad2;
}
_TIFFmemset(tif, 0, sizeof (*tif));
tif->tif_name = (char *)tif + sizeof (TIFF);
strcpy(tif->tif_name, name);
tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
tif->tif_curdir = (tdir_t) -1; /* non-existent directory */
tif->tif_curoff = 0;
tif->tif_curstrip = (tstrip_t) -1; /* invalid strip */
tif->tif_row = (uint32) -1; /* read/write pre-increment */
tif->tif_clientdata = clientdata;
if (!readproc || !writeproc || !seekproc || !closeproc
|| !sizeproc || !mapproc || !unmapproc) {
TIFFError(module, "One of the client procedures are NULL pointer");
goto bad3;
}
tif->tif_readproc = readproc;
tif->tif_writeproc = writeproc;
tif->tif_seekproc = seekproc;
tif->tif_closeproc = closeproc;
tif->tif_sizeproc = sizeproc;
tif->tif_mapproc = mapproc;
tif->tif_unmapproc = unmapproc;
_TIFFSetDefaultCompressionState(tif); /* setup default state */
/*
* Default is to return data MSB2LSB and enable the
* use of memory-mapped files and strip chopping when
* a file is opened read-only.
*/
tif->tif_flags = FILLORDER_MSB2LSB;
if (m == O_RDONLY )
tif->tif_flags |= TIFF_MAPPED;
#ifdef STRIPCHOP_DEFAULT
if (m == O_RDONLY || m == O_RDWR)
tif->tif_flags |= STRIPCHOP_DEFAULT;
#endif
{ union { int32 i; char c[4]; } u; u.i = 1; bigendian = u.c[0] == 0; }
/*
* Process library-specific flags in the open mode string.
* The following flags may be used to control intrinsic library
* behaviour that may or may not be desirable (usually for
* compatibility with some application that claims to support
* TIFF but only supports some braindead idea of what the
* vendor thinks TIFF is):
*
* 'l' use little-endian byte order for creating a file
* 'b' use big-endian byte order for creating a file
* 'L' read/write information using LSB2MSB bit order
* 'B' read/write information using MSB2LSB bit order
* 'H' read/write information using host bit order
* 'M' enable use of memory-mapped files when supported
* 'm' disable use of memory-mapped files
* 'C' enable strip chopping support when reading
* 'c' disable strip chopping support
*
* The use of the 'l' and 'b' flags is strongly discouraged.
* These flags are provided solely because numerous vendors,
* typically on the PC, do not correctly support TIFF; they
* only support the Intel little-endian byte order. This
* support is not configured by default because it supports
* the violation of the TIFF spec that says that readers *MUST*
* support both byte orders. It is strongly recommended that
* you not use this feature except to deal with busted apps
* that write invalid TIFF. And even in those cases you should
* bang on the vendors to fix their software.
*
* The 'L', 'B', and 'H' flags are intended for applications
* that can optimize operations on data by using a particular
* bit order. By default the library returns data in MSB2LSB
* bit order for compatibiltiy with older versions of this
* library. Returning data in the bit order of the native cpu
* makes the most sense but also requires applications to check
* the value of the FillOrder tag; something they probabyl do
* not do right now.
*
* The 'M' and 'm' flags are provided because some virtual memory
* systems exhibit poor behaviour when large images are mapped.
* These options permit clients to control the use of memory-mapped
* files on a per-file basis.
*
* The 'C' and 'c' flags are provided because the library support
* for chopping up large strips into multiple smaller strips is not
* application-transparent and as such can cause problems. The 'c'
* option permits applications that only want to look at the tags,
* for example, to get the unadulterated TIFF tag information.
*/
for (cp = mode; *cp; cp++)
switch (*cp) {
case 'b':
if ((m&O_CREAT) && !bigendian)
tif->tif_flags |= TIFF_SWAB;
break;
case 'l':
if ((m&O_CREAT) && bigendian)
tif->tif_flags |= TIFF_SWAB;
break;
case 'B':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_MSB2LSB;
break;
case 'L':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_LSB2MSB;
break;
case 'H':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
HOST_FILLORDER;
break;
case 'M':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_MAPPED;
break;
case 'm':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_MAPPED;
break;
case 'C':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_STRIPCHOP;
break;
case 'c':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_STRIPCHOP;
break;
}
/*
* Read in TIFF header.
*/
if (!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
if (tif->tif_mode == O_RDONLY) {
TIFFError(name, "Cannot read TIFF header");
goto bad;
}
/*
* Setup header and write.
*/
tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
? (bigendian ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN)
: (bigendian ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN);
tif->tif_header.tiff_version = TIFF_VERSION;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&tif->tif_header.tiff_version);
tif->tif_header.tiff_diroff = 0; /* filled in later */
/*
* This seek shouldn't be necessary, but I have had some
* crazy problems with a failed fseek() on Solaris leaving
* the current file pointer out of whack when an fwrite()
* is done.
*/
TIFFSeekFile( tif, 0, SEEK_SET );
if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
TIFFError(name, "Error writing TIFF header");
goto bad;
}
/*
* Setup the byte order handling.
*/
TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
/*
* Setup default directory.
*/
if (!TIFFDefaultDirectory(tif))
goto bad;
tif->tif_diroff = 0;
return (tif);
}
/*
* Setup the byte order handling.
*/
if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN) {
TIFFError(name, "Not a TIFF file, bad magic number %d (0x%x)",
tif->tif_header.tiff_magic,
tif->tif_header.tiff_magic);
goto bad;
}
TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
/*
* Swap header if required.
*/
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabShort(&tif->tif_header.tiff_version);
TIFFSwabLong(&tif->tif_header.tiff_diroff);
}
/*
* Now check version (if needed, it's been byte-swapped).
* Note that this isn't actually a version number, it's a
* magic number that doesn't change (stupid).
*/
if (tif->tif_header.tiff_version != TIFF_VERSION) {
TIFFError(name,
"Not a TIFF file, bad version number %d (0x%x)",
tif->tif_header.tiff_version,
tif->tif_header.tiff_version);
goto bad;
}
tif->tif_flags |= TIFF_MYBUFFER;
tif->tif_rawcp = tif->tif_rawdata = 0;
tif->tif_rawdatasize = 0;
/*
* Setup initial directory.
*/
switch (mode[0]) {
case 'r':
tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
/*
* Try to use a memory-mapped file if the client
* has not explicitly suppressed usage with the
* 'm' flag in the open mode (see above).
*/
if ((tif->tif_flags & TIFF_MAPPED) &&
!TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size))
tif->tif_flags &= ~TIFF_MAPPED;
if (TIFFReadDirectory(tif)) {
tif->tif_rawcc = -1;
tif->tif_flags |= TIFF_BUFFERSETUP;
return (tif);
}
break;
case 'a':
/*
* New directories are automatically append
* to the end of the directory chain when they
* are written out (see TIFFWriteDirectory).
*/
if (!TIFFDefaultDirectory(tif))
goto bad;
return (tif);
}
bad:
tif->tif_mode = O_RDONLY; /* XXX avoid flush */
TIFFClose(tif);
return ((TIFF*)0);
bad2:
(void) (*closeproc)(clientdata);
bad3:
return ((TIFF*)0);
}
/*
* Query functions to access private data.
*/
/*
* Return open file's name.
*/
const char *
TIFFFileName(TIFF* tif)
{
return (tif->tif_name);
}
/*
* Return open file's I/O descriptor.
*/
int
TIFFFileno(TIFF* tif)
{
return (tif->tif_fd);
}
/*
* Return read/write mode.
*/
int
TIFFGetMode(TIFF* tif)
{
return (tif->tif_mode);
}
/*
* Return nonzero if file is organized in
* tiles; zero if organized as strips.
*/
int
TIFFIsTiled(TIFF* tif)
{
return (isTiled(tif));
}
/*
* Return current row being read/written.
*/
uint32
TIFFCurrentRow(TIFF* tif)
{
return (tif->tif_row);
}
/*
* Return index of the current directory.
*/
tdir_t
TIFFCurrentDirectory(TIFF* tif)
{
return (tif->tif_curdir);
}
/*
* Return current strip.
*/
tstrip_t
TIFFCurrentStrip(TIFF* tif)
{
return (tif->tif_curstrip);
}
/*
* Return current tile.
*/
ttile_t
TIFFCurrentTile(TIFF* tif)
{
return (tif->tif_curtile);
}
/*
* Return nonzero if the file has byte-swapped data.
*/
int
TIFFIsByteSwapped(TIFF* tif)
{
return ((tif->tif_flags & TIFF_SWAB) != 0);
}
/*
* Return nonzero if the data is returned up-sampled.
*/
int
TIFFIsUpSampled(TIFF* tif)
{
return (isUpSampled(tif));
}
/*
* Return nonzero if the data is returned in MSB-to-LSB bit order.
*/
int
TIFFIsMSB2LSB(TIFF* tif)
{
return (isFillOrder(tif, FILLORDER_MSB2LSB));
}
src/add-ons/translators/libtifftranslator/tif_packbits.c
+291
View File
@@ -0,0 +1,291 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_packbits.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include "tiffiop.h"
#ifdef PACKBITS_SUPPORT
/*
* TIFF Library.
*
* PackBits Compression Algorithm Support
*/
#include <assert.h>
#include <stdio.h>
static int
PackBitsPreEncode(TIFF* tif, tsample_t s)
{
(void) s;
/*
* Calculate the scanline/tile-width size in bytes.
*/
if (isTiled(tif))
tif->tif_data = (tidata_t) TIFFTileRowSize(tif);
else
tif->tif_data = (tidata_t) TIFFScanlineSize(tif);
return (1);
}
/*
* NB: tidata is the type representing *(tidata_t);
* if tidata_t is made signed then this type must
* be adjusted accordingly.
*/
typedef unsigned char tidata;
/*
* Encode a run of pixels.
*/
static int
PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
{
u_char* bp = (u_char*) buf;
tidata_t op, ep, lastliteral;
long n, slop;
int b;
enum { BASE, LITERAL, RUN, LITERAL_RUN } state;
(void) s;
op = tif->tif_rawcp;
ep = tif->tif_rawdata + tif->tif_rawdatasize;
state = BASE;
lastliteral = 0;
while (cc > 0) {
/*
* Find the longest string of identical bytes.
*/
b = *bp++, cc--, n = 1;
for (; cc > 0 && b == *bp; cc--, bp++)
n++;
again:
if (op + 2 >= ep) { /* insure space for new data */
/*
* Be careful about writing the last
* literal. Must write up to that point
* and then copy the remainder to the
* front of the buffer.
*/
if (state == LITERAL || state == LITERAL_RUN) {
slop = op - lastliteral;
tif->tif_rawcc += lastliteral - tif->tif_rawcp;
if (!TIFFFlushData1(tif))
return (-1);
op = tif->tif_rawcp;
while (slop-- > 0)
*op++ = *lastliteral++;
lastliteral = tif->tif_rawcp;
} else {
tif->tif_rawcc += op - tif->tif_rawcp;
if (!TIFFFlushData1(tif))
return (-1);
op = tif->tif_rawcp;
}
}
switch (state) {
case BASE: /* initial state, set run/literal */
if (n > 1) {
state = RUN;
if (n > 128) {
*op++ = (tidata) -127;
*op++ = b;
n -= 128;
goto again;
}
*op++ = (tidataval_t)(-(n-1));
*op++ = b;
} else {
lastliteral = op;
*op++ = 0;
*op++ = b;
state = LITERAL;
}
break;
case LITERAL: /* last object was literal string */
if (n > 1) {
state = LITERAL_RUN;
if (n > 128) {
*op++ = (tidata) -127;
*op++ = b;
n -= 128;
goto again;
}
*op++ = (tidataval_t)(-(n-1)); /* encode run */
*op++ = b;
} else { /* extend literal */
if (++(*lastliteral) == 127)
state = BASE;
*op++ = b;
}
break;
case RUN: /* last object was run */
if (n > 1) {
if (n > 128) {
*op++ = (tidata) -127;
*op++ = b;
n -= 128;
goto again;
}
*op++ = (tidataval_t)(-(n-1));
*op++ = b;
} else {
lastliteral = op;
*op++ = 0;
*op++ = b;
state = LITERAL;
}
break;
case LITERAL_RUN: /* literal followed by a run */
/*
* Check to see if previous run should
* be converted to a literal, in which
* case we convert literal-run-literal
* to a single literal.
*/
if (n == 1 && op[-2] == (tidata) -1 &&
*lastliteral < 126) {
state = (((*lastliteral) += 2) == 127 ?
BASE : LITERAL);
op[-2] = op[-1]; /* replicate */
} else
state = RUN;
goto again;
}
}
tif->tif_rawcc += op - tif->tif_rawcp;
tif->tif_rawcp = op;
return (1);
}
/*
* Encode a rectangular chunk of pixels. We break it up
* into row-sized pieces to insure that encoded runs do
* not span rows. Otherwise, there can be problems with
* the decoder if data is read, for example, by scanlines
* when it was encoded by strips.
*/
static int
PackBitsEncodeChunk(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
{
tsize_t rowsize = (tsize_t) tif->tif_data;
assert(rowsize > 0);
#ifdef YCBCR_SUPPORT
/*
* YCBCR data isn't really separable into rows, so we
* might as well encode the whole tile/strip as one chunk.
*/
if( tif->tif_dir.td_photometric == PHOTOMETRIC_YCBCR )
rowsize = (tsize_t) tif->tif_data;
#endif
while ((long)cc > 0) {
int chunk = rowsize;
if( cc < chunk )
chunk = cc;
if (PackBitsEncode(tif, bp, chunk, s) < 0)
return (-1);
bp += chunk;
cc -= chunk;
}
return (1);
}
static int
PackBitsDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
{
char *bp;
tsize_t cc;
long n;
int b;
(void) s;
bp = (char*) tif->tif_rawcp;
cc = tif->tif_rawcc;
while (cc > 0 && (long)occ > 0) {
n = (long) *bp++, cc--;
/*
* Watch out for compilers that
* don't sign extend chars...
*/
if (n >= 128)
n -= 256;
if (n < 0) { /* replicate next byte -n+1 times */
if (n == -128) /* nop */
continue;
n = -n + 1;
if( occ < n )
{
TIFFWarning(tif->tif_name,
"PackBitsDecode: discarding %d bytes "
"to avoid buffer overrun",
n - occ);
n = occ;
}
occ -= n;
b = *bp++, cc--;
while (n-- > 0)
*op++ = b;
} else { /* copy next n+1 bytes literally */
if (occ < n + 1)
{
TIFFWarning(tif->tif_name,
"PackBitsDecode: discarding %d bytes "
"to avoid buffer overrun",
n - occ + 1);
n = occ - 1;
}
_TIFFmemcpy(op, bp, ++n);
op += n; occ -= n;
bp += n; cc -= n;
}
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcc = cc;
if (occ > 0) {
TIFFError(tif->tif_name,
"PackBitsDecode: Not enough data for scanline %ld",
(long) tif->tif_row);
return (0);
}
return (1);
}
int
TIFFInitPackBits(TIFF* tif, int scheme)
{
(void) scheme;
tif->tif_decoderow = PackBitsDecode;
tif->tif_decodestrip = PackBitsDecode;
tif->tif_decodetile = PackBitsDecode;
tif->tif_preencode = PackBitsPreEncode;
tif->tif_encoderow = PackBitsEncode;
tif->tif_encodestrip = PackBitsEncodeChunk;
tif->tif_encodetile = PackBitsEncodeChunk;
return (1);
}
#endif /* PACKBITS_SUPPORT */
src/add-ons/translators/libtifftranslator/tif_predict.c
+464
View File
@@ -0,0 +1,464 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_predict.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* Predictor Tag Support (used by multiple codecs).
*/
#include "tiffiop.h"
#include "tif_predict.h"
#include <assert.h>
#define PredictorState(tif) ((TIFFPredictorState*) (tif)->tif_data)
static void horAcc8(TIFF*, tidata_t, tsize_t);
static void horAcc16(TIFF*, tidata_t, tsize_t);
static void swabHorAcc16(TIFF*, tidata_t, tsize_t);
static void horDiff8(TIFF*, tidata_t, tsize_t);
static void horDiff16(TIFF*, tidata_t, tsize_t);
static int PredictorDecodeRow(TIFF*, tidata_t, tsize_t, tsample_t);
static int PredictorDecodeTile(TIFF*, tidata_t, tsize_t, tsample_t);
static int PredictorEncodeRow(TIFF*, tidata_t, tsize_t, tsample_t);
static int PredictorEncodeTile(TIFF*, tidata_t, tsize_t, tsample_t);
static int
PredictorSetup(TIFF* tif)
{
TIFFPredictorState* sp = PredictorState(tif);
TIFFDirectory* td = &tif->tif_dir;
if (sp->predictor == 1) /* no differencing */
return (1);
if (sp->predictor != 2) {
TIFFError(tif->tif_name, "\"Predictor\" value %d not supported",
sp->predictor);
return (0);
}
if (td->td_bitspersample != 8 && td->td_bitspersample != 16) {
TIFFError(tif->tif_name,
"Horizontal differencing \"Predictor\" not supported with %d-bit samples",
td->td_bitspersample);
return (0);
}
sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ?
td->td_samplesperpixel : 1);
/*
* Calculate the scanline/tile-width size in bytes.
*/
if (isTiled(tif))
sp->rowsize = TIFFTileRowSize(tif);
else
sp->rowsize = TIFFScanlineSize(tif);
return (1);
}
static int
PredictorSetupDecode(TIFF* tif)
{
TIFFPredictorState* sp = PredictorState(tif);
TIFFDirectory* td = &tif->tif_dir;
if (!(*sp->setupdecode)(tif) || !PredictorSetup(tif))
return (0);
if (sp->predictor == 2) {
switch (td->td_bitspersample) {
case 8: sp->pfunc = horAcc8; break;
case 16: sp->pfunc = horAcc16; break;
}
/*
* Override default decoding method with
* one that does the predictor stuff.
*/
sp->coderow = tif->tif_decoderow;
tif->tif_decoderow = PredictorDecodeRow;
sp->codestrip = tif->tif_decodestrip;
tif->tif_decodestrip = PredictorDecodeTile;
sp->codetile = tif->tif_decodetile;
tif->tif_decodetile = PredictorDecodeTile;
/*
* If the data is horizontally differenced
* 16-bit data that requires byte-swapping,
* then it must be byte swapped before the
* accumulation step. We do this with a
* special-purpose routine and override the
* normal post decoding logic that the library
* setup when the directory was read.
*/
if (tif->tif_flags&TIFF_SWAB) {
if (sp->pfunc == horAcc16) {
sp->pfunc = swabHorAcc16;
tif->tif_postdecode = _TIFFNoPostDecode;
} /* else handle 32-bit case... */
}
}
return (1);
}
static int
PredictorSetupEncode(TIFF* tif)
{
TIFFPredictorState* sp = PredictorState(tif);
TIFFDirectory* td = &tif->tif_dir;
if (!(*sp->setupencode)(tif) || !PredictorSetup(tif))
return (0);
if (sp->predictor == 2) {
switch (td->td_bitspersample) {
case 8: sp->pfunc = horDiff8; break;
case 16: sp->pfunc = horDiff16; break;
}
/*
* Override default encoding method with
* one that does the predictor stuff.
*/
sp->coderow = tif->tif_encoderow;
tif->tif_encoderow = PredictorEncodeRow;
sp->codestrip = tif->tif_encodestrip;
tif->tif_encodestrip = PredictorEncodeTile;
sp->codetile = tif->tif_encodetile;
tif->tif_encodetile = PredictorEncodeTile;
}
return (1);
}
#define REPEAT4(n, op) \
switch (n) { \
default: { int i; for (i = n-4; i > 0; i--) { op; } } \
case 4: op; \
case 3: op; \
case 2: op; \
case 1: op; \
case 0: ; \
}
static void
horAcc8(TIFF* tif, tidata_t cp0, tsize_t cc)
{
TIFFPredictorState* sp = PredictorState(tif);
tsize_t stride = sp->stride;
char* cp = (char*) cp0;
if (cc > stride) {
cc -= stride;
/*
* Pipeline the most common cases.
*/
if (stride == 3) {
u_int cr = cp[0];
u_int cg = cp[1];
u_int cb = cp[2];
do {
cc -= 3, cp += 3;
cp[0] = (cr += cp[0]);
cp[1] = (cg += cp[1]);
cp[2] = (cb += cp[2]);
} while ((int32) cc > 0);
} else if (stride == 4) {
u_int cr = cp[0];
u_int cg = cp[1];
u_int cb = cp[2];
u_int ca = cp[3];
do {
cc -= 4, cp += 4;
cp[0] = (cr += cp[0]);
cp[1] = (cg += cp[1]);
cp[2] = (cb += cp[2]);
cp[3] = (ca += cp[3]);
} while ((int32) cc > 0);
} else {
do {
REPEAT4(stride, cp[stride] += *cp; cp++)
cc -= stride;
} while ((int32) cc > 0);
}
}
}
static void
swabHorAcc16(TIFF* tif, tidata_t cp0, tsize_t cc)
{
TIFFPredictorState* sp = PredictorState(tif);
tsize_t stride = sp->stride;
uint16* wp = (uint16*) cp0;
tsize_t wc = cc / 2;
if (wc > stride) {
TIFFSwabArrayOfShort(wp, wc);
wc -= stride;
do {
REPEAT4(stride, wp[stride] += wp[0]; wp++)
wc -= stride;
} while ((int32) wc > 0);
}
}
static void
horAcc16(TIFF* tif, tidata_t cp0, tsize_t cc)
{
tsize_t stride = PredictorState(tif)->stride;
uint16* wp = (uint16*) cp0;
tsize_t wc = cc / 2;
if (wc > stride) {
wc -= stride;
do {
REPEAT4(stride, wp[stride] += wp[0]; wp++)
wc -= stride;
} while ((int32) wc > 0);
}
}
/*
* Decode a scanline and apply the predictor routine.
*/
static int
PredictorDecodeRow(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
{
TIFFPredictorState *sp = PredictorState(tif);
assert(sp != NULL);
assert(sp->coderow != NULL);
assert(sp->pfunc != NULL);
if ((*sp->coderow)(tif, op0, occ0, s)) {
(*sp->pfunc)(tif, op0, occ0);
return (1);
} else
return (0);
}
/*
* Decode a tile/strip and apply the predictor routine.
* Note that horizontal differencing must be done on a
* row-by-row basis. The width of a "row" has already
* been calculated at pre-decode time according to the
* strip/tile dimensions.
*/
static int
PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
{
TIFFPredictorState *sp = PredictorState(tif);
assert(sp != NULL);
assert(sp->codetile != NULL);
if ((*sp->codetile)(tif, op0, occ0, s)) {
tsize_t rowsize = sp->rowsize;
assert(rowsize > 0);
assert(sp->pfunc != NULL);
while ((long)occ0 > 0) {
(*sp->pfunc)(tif, op0, (tsize_t) rowsize);
occ0 -= rowsize;
op0 += rowsize;
}
return (1);
} else
return (0);
}
static void
horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc)
{
TIFFPredictorState* sp = PredictorState(tif);
tsize_t stride = sp->stride;
char* cp = (char*) cp0;
if (cc > stride) {
cc -= stride;
/*
* Pipeline the most common cases.
*/
if (stride == 3) {
int r1, g1, b1;
int r2 = cp[0];
int g2 = cp[1];
int b2 = cp[2];
do {
r1 = cp[3]; cp[3] = r1-r2; r2 = r1;
g1 = cp[4]; cp[4] = g1-g2; g2 = g1;
b1 = cp[5]; cp[5] = b1-b2; b2 = b1;
cp += 3;
} while ((int32)(cc -= 3) > 0);
} else if (stride == 4) {
int r1, g1, b1, a1;
int r2 = cp[0];
int g2 = cp[1];
int b2 = cp[2];
int a2 = cp[3];
do {
r1 = cp[4]; cp[4] = r1-r2; r2 = r1;
g1 = cp[5]; cp[5] = g1-g2; g2 = g1;
b1 = cp[6]; cp[6] = b1-b2; b2 = b1;
a1 = cp[7]; cp[7] = a1-a2; a2 = a1;
cp += 4;
} while ((int32)(cc -= 4) > 0);
} else {
cp += cc - 1;
do {
REPEAT4(stride, cp[stride] -= cp[0]; cp--)
} while ((int32)(cc -= stride) > 0);
}
}
}
static void
horDiff16(TIFF* tif, tidata_t cp0, tsize_t cc)
{
TIFFPredictorState* sp = PredictorState(tif);
tsize_t stride = sp->stride;
int16 *wp = (int16*) cp0;
tsize_t wc = cc/2;
if (wc > stride) {
wc -= stride;
wp += wc - 1;
do {
REPEAT4(stride, wp[stride] -= wp[0]; wp--)
wc -= stride;
} while ((int32) wc > 0);
}
}
static int
PredictorEncodeRow(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
{
TIFFPredictorState *sp = PredictorState(tif);
assert(sp != NULL);
assert(sp->pfunc != NULL);
assert(sp->coderow != NULL);
/* XXX horizontal differencing alters user's data XXX */
(*sp->pfunc)(tif, bp, cc);
return ((*sp->coderow)(tif, bp, cc, s));
}
static int
PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s)
{
TIFFPredictorState *sp = PredictorState(tif);
tsize_t cc = cc0, rowsize;
u_char* bp = bp0;
assert(sp != NULL);
assert(sp->pfunc != NULL);
assert(sp->codetile != NULL);
rowsize = sp->rowsize;
assert(rowsize > 0);
while ((long)cc > 0) {
(*sp->pfunc)(tif, bp, (tsize_t) rowsize);
cc -= rowsize;
bp += rowsize;
}
return ((*sp->codetile)(tif, bp0, cc0, s));
}
#define FIELD_PREDICTOR (FIELD_CODEC+0) /* XXX */
static const TIFFFieldInfo predictFieldInfo[] = {
{ TIFFTAG_PREDICTOR, 1, 1, TIFF_SHORT, FIELD_PREDICTOR,
FALSE, FALSE, "Predictor" },
};
#define N(a) (sizeof (a) / sizeof (a[0]))
static int
PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap)
{
TIFFPredictorState *sp = PredictorState(tif);
switch (tag) {
case TIFFTAG_PREDICTOR:
sp->predictor = (uint16) va_arg(ap, int);
TIFFSetFieldBit(tif, FIELD_PREDICTOR);
break;
default:
return (*sp->vsetparent)(tif, tag, ap);
}
tif->tif_flags |= TIFF_DIRTYDIRECT;
return (1);
}
static int
PredictorVGetField(TIFF* tif, ttag_t tag, va_list ap)
{
TIFFPredictorState *sp = PredictorState(tif);
switch (tag) {
case TIFFTAG_PREDICTOR:
*va_arg(ap, uint16*) = sp->predictor;
break;
default:
return (*sp->vgetparent)(tif, tag, ap);
}
return (1);
}
static void
PredictorPrintDir(TIFF* tif, FILE* fd, long flags)
{
TIFFPredictorState* sp = PredictorState(tif);
(void) flags;
if (TIFFFieldSet(tif,FIELD_PREDICTOR)) {
fprintf(fd, " Predictor: ");
switch (sp->predictor) {
case 1: fprintf(fd, "none "); break;
case 2: fprintf(fd, "horizontal differencing "); break;
}
fprintf(fd, "%u (0x%x)\n", sp->predictor, sp->predictor);
}
if (sp->printdir)
(*sp->printdir)(tif, fd, flags);
}
int
TIFFPredictorInit(TIFF* tif)
{
TIFFPredictorState* sp = PredictorState(tif);
/*
* Merge codec-specific tag information and
* override parent get/set field methods.
*/
_TIFFMergeFieldInfo(tif, predictFieldInfo, N(predictFieldInfo));
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield =
PredictorVGetField;/* hook for predictor tag */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield =
PredictorVSetField;/* hook for predictor tag */
sp->printdir = tif->tif_tagmethods.printdir;
tif->tif_tagmethods.printdir =
PredictorPrintDir; /* hook for predictor tag */
sp->setupdecode = tif->tif_setupdecode;
tif->tif_setupdecode = PredictorSetupDecode;
sp->setupencode = tif->tif_setupencode;
tif->tif_setupencode = PredictorSetupEncode;
sp->predictor = 1; /* default value */
sp->pfunc = NULL; /* no predictor routine */
return (1);
}
src/add-ons/translators/libtifftranslator/tif_predict.h
+61
View File
@@ -0,0 +1,61 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_predict.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1995-1997 Sam Leffler
* Copyright (c) 1995-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _TIFFPREDICT_
#define _TIFFPREDICT_
/*
* ``Library-private'' Support for the Predictor Tag
*/
/*
* Codecs that want to support the Predictor tag must place
* this structure first in their private state block so that
* the predictor code can cast tif_data to find its state.
*/
typedef struct {
int predictor; /* predictor tag value */
int stride; /* sample stride over data */
tsize_t rowsize; /* tile/strip row size */
TIFFPostMethod pfunc; /* horizontal differencer/accumulator */
TIFFCodeMethod coderow; /* parent codec encode/decode row */
TIFFCodeMethod codestrip; /* parent codec encode/decode strip */
TIFFCodeMethod codetile; /* parent codec encode/decode tile */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFPrintMethod printdir; /* super-class method */
TIFFBoolMethod setupdecode; /* super-class method */
TIFFBoolMethod setupencode; /* super-class method */
} TIFFPredictorState;
#if defined(__cplusplus)
extern "C" {
#endif
extern int TIFFPredictorInit(TIFF*);
#if defined(__cplusplus)
}
#endif
#endif /* _TIFFPREDICT_ */
src/add-ons/translators/libtifftranslator/tif_print.c
+605
View File
@@ -0,0 +1,605 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_print.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* Directory Printing Support
*/
#include "tiffiop.h"
#include <stdio.h>
#include <ctype.h>
static const char *photoNames[] = {
"min-is-white", /* PHOTOMETRIC_MINISWHITE */
"min-is-black", /* PHOTOMETRIC_MINISBLACK */
"RGB color", /* PHOTOMETRIC_RGB */
"palette color (RGB from colormap)", /* PHOTOMETRIC_PALETTE */
"transparency mask", /* PHOTOMETRIC_MASK */
"separated", /* PHOTOMETRIC_SEPARATED */
"YCbCr", /* PHOTOMETRIC_YCBCR */
"7 (0x7)",
"CIE L*a*b*", /* PHOTOMETRIC_CIELAB */
};
#define NPHOTONAMES (sizeof (photoNames) / sizeof (photoNames[0]))
static const char *orientNames[] = {
"0 (0x0)",
"row 0 top, col 0 lhs", /* ORIENTATION_TOPLEFT */
"row 0 top, col 0 rhs", /* ORIENTATION_TOPRIGHT */
"row 0 bottom, col 0 rhs", /* ORIENTATION_BOTRIGHT */
"row 0 bottom, col 0 lhs", /* ORIENTATION_BOTLEFT */
"row 0 lhs, col 0 top", /* ORIENTATION_LEFTTOP */
"row 0 rhs, col 0 top", /* ORIENTATION_RIGHTTOP */
"row 0 rhs, col 0 bottom", /* ORIENTATION_RIGHTBOT */
"row 0 lhs, col 0 bottom", /* ORIENTATION_LEFTBOT */
};
#define NORIENTNAMES (sizeof (orientNames) / sizeof (orientNames[0]))
/*
* Print the contents of the current directory
* to the specified stdio file stream.
*/
void
TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
{
register TIFFDirectory *td;
char *sep;
uint16 i;
long l, n;
fprintf(fd, "TIFF Directory at offset 0x%lx\n", tif->tif_diroff);
td = &tif->tif_dir;
if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) {
fprintf(fd, " Subfile Type:");
sep = " ";
if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) {
fprintf(fd, "%sreduced-resolution image", sep);
sep = "/";
}
if (td->td_subfiletype & FILETYPE_PAGE) {
fprintf(fd, "%smulti-page document", sep);
sep = "/";
}
if (td->td_subfiletype & FILETYPE_MASK)
fprintf(fd, "%stransparency mask", sep);
fprintf(fd, " (%lu = 0x%lx)\n",
(long) td->td_subfiletype, (long) td->td_subfiletype);
}
if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) {
fprintf(fd, " Image Width: %lu Image Length: %lu",
(u_long) td->td_imagewidth, (u_long) td->td_imagelength);
if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))
fprintf(fd, " Image Depth: %lu",
(u_long) td->td_imagedepth);
fprintf(fd, "\n");
}
/* Begin Pixar */
if (TIFFFieldSet(tif,FIELD_IMAGEFULLWIDTH) ||
TIFFFieldSet(tif,FIELD_IMAGEFULLLENGTH)) {
fprintf(fd, " Pixar Full Image Width: %lu Full Image Length: %lu\n",
(u_long) td->td_imagefullwidth,
(u_long) td->td_imagefulllength);
}
if (TIFFFieldSet(tif,FIELD_TEXTUREFORMAT))
_TIFFprintAsciiTag(fd, "Texture Format", td->td_textureformat);
if (TIFFFieldSet(tif,FIELD_WRAPMODES))
_TIFFprintAsciiTag(fd, "Texture Wrap Modes", td->td_wrapmodes);
if (TIFFFieldSet(tif,FIELD_FOVCOT))
fprintf(fd, " Field of View Cotangent: %g\n", td->td_fovcot);
if (TIFFFieldSet(tif,FIELD_MATRIX_WORLDTOSCREEN)) {
typedef float Matrix[4][4];
Matrix* m = (Matrix*)td->td_matrixWorldToScreen;
fprintf(fd, " Matrix NP:\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n",
(*m)[0][0], (*m)[0][1], (*m)[0][2], (*m)[0][3],
(*m)[1][0], (*m)[1][1], (*m)[1][2], (*m)[1][3],
(*m)[2][0], (*m)[2][1], (*m)[2][2], (*m)[2][3],
(*m)[3][0], (*m)[3][1], (*m)[3][2], (*m)[3][3]);
}
if (TIFFFieldSet(tif,FIELD_MATRIX_WORLDTOCAMERA)) {
typedef float Matrix[4][4];
Matrix* m = (Matrix*)td->td_matrixWorldToCamera;
fprintf(fd, " Matrix Nl:\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n",
(*m)[0][0], (*m)[0][1], (*m)[0][2], (*m)[0][3],
(*m)[1][0], (*m)[1][1], (*m)[1][2], (*m)[1][3],
(*m)[2][0], (*m)[2][1], (*m)[2][2], (*m)[2][3],
(*m)[3][0], (*m)[3][1], (*m)[3][2], (*m)[3][3]);
}
/* End Pixar */
if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) {
fprintf(fd, " Tile Width: %lu Tile Length: %lu",
(u_long) td->td_tilewidth, (u_long) td->td_tilelength);
if (TIFFFieldSet(tif,FIELD_TILEDEPTH))
fprintf(fd, " Tile Depth: %lu",
(u_long) td->td_tiledepth);
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_RESOLUTION)) {
fprintf(fd, " Resolution: %g, %g",
td->td_xresolution, td->td_yresolution);
if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) {
switch (td->td_resolutionunit) {
case RESUNIT_NONE:
fprintf(fd, " (unitless)");
break;
case RESUNIT_INCH:
fprintf(fd, " pixels/inch");
break;
case RESUNIT_CENTIMETER:
fprintf(fd, " pixels/cm");
break;
default:
fprintf(fd, " (unit %u = 0x%x)",
td->td_resolutionunit,
td->td_resolutionunit);
break;
}
}
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_POSITION))
fprintf(fd, " Position: %g, %g\n",
td->td_xposition, td->td_yposition);
if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
fprintf(fd, " Bits/Sample: %u\n", td->td_bitspersample);
if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) {
fprintf(fd, " Sample Format: ");
switch (td->td_sampleformat) {
case SAMPLEFORMAT_VOID:
fprintf(fd, "void\n");
break;
case SAMPLEFORMAT_INT:
fprintf(fd, "signed integer\n");
break;
case SAMPLEFORMAT_UINT:
fprintf(fd, "unsigned integer\n");
break;
case SAMPLEFORMAT_IEEEFP:
fprintf(fd, "IEEE floating point\n");
break;
case SAMPLEFORMAT_COMPLEXINT:
fprintf(fd, "complex signed integer\n");
break;
case SAMPLEFORMAT_COMPLEXIEEEFP:
fprintf(fd, "complex IEEE floating point\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_sampleformat, td->td_sampleformat);
break;
}
}
if (TIFFFieldSet(tif,FIELD_COMPRESSION)) {
const TIFFCodec* c = TIFFFindCODEC(td->td_compression);
fprintf(fd, " Compression Scheme: ");
if (c)
fprintf(fd, "%s\n", c->name);
else
fprintf(fd, "%u (0x%x)\n",
td->td_compression, td->td_compression);
}
if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) {
fprintf(fd, " Photometric Interpretation: ");
if (td->td_photometric < NPHOTONAMES)
fprintf(fd, "%s\n", photoNames[td->td_photometric]);
else {
switch (td->td_photometric) {
case PHOTOMETRIC_LOGL:
fprintf(fd, "CIE Log2(L)\n");
break;
case PHOTOMETRIC_LOGLUV:
fprintf(fd, "CIE Log2(L) (u',v')\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_photometric, td->td_photometric);
break;
}
}
}
if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) {
fprintf(fd, " Extra Samples: %u<", td->td_extrasamples);
sep = "";
for (i = 0; i < td->td_extrasamples; i++) {
switch (td->td_sampleinfo[i]) {
case EXTRASAMPLE_UNSPECIFIED:
fprintf(fd, "%sunspecified", sep);
break;
case EXTRASAMPLE_ASSOCALPHA:
fprintf(fd, "%sassoc-alpha", sep);
break;
case EXTRASAMPLE_UNASSALPHA:
fprintf(fd, "%sunassoc-alpha", sep);
break;
default:
fprintf(fd, "%s%u (0x%x)", sep,
td->td_sampleinfo[i], td->td_sampleinfo[i]);
break;
}
sep = ", ";
}
fprintf(fd, ">\n");
}
if (TIFFFieldSet(tif,FIELD_STONITS)) {
fprintf(fd, " Sample to Nits conversion factor: %.4e\n",
td->td_stonits);
}
#ifdef CMYK_SUPPORT
if (TIFFFieldSet(tif,FIELD_INKSET)) {
fprintf(fd, " Ink Set: ");
switch (td->td_inkset) {
case INKSET_CMYK:
fprintf(fd, "CMYK\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_inkset, td->td_inkset);
break;
}
}
if (TIFFFieldSet(tif,FIELD_INKNAMES)) {
char* cp;
fprintf(fd, " Ink Names: ");
i = td->td_samplesperpixel;
sep = "";
for (cp = td->td_inknames; i > 0; cp = strchr(cp,'\0')+1, i--) {
fprintf(fd, "%s", sep);
_TIFFprintAscii(fd, cp);
sep = ", ";
}
}
if (TIFFFieldSet(tif,FIELD_NUMBEROFINKS))
fprintf(fd, " Number of Inks: %u\n", td->td_ninks);
if (TIFFFieldSet(tif,FIELD_DOTRANGE))
fprintf(fd, " Dot Range: %u-%u\n",
td->td_dotrange[0], td->td_dotrange[1]);
if (TIFFFieldSet(tif,FIELD_TARGETPRINTER))
_TIFFprintAsciiTag(fd, "Target Printer", td->td_targetprinter);
#endif
if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) {
fprintf(fd, " Thresholding: ");
switch (td->td_threshholding) {
case THRESHHOLD_BILEVEL:
fprintf(fd, "bilevel art scan\n");
break;
case THRESHHOLD_HALFTONE:
fprintf(fd, "halftone or dithered scan\n");
break;
case THRESHHOLD_ERRORDIFFUSE:
fprintf(fd, "error diffused\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_threshholding, td->td_threshholding);
break;
}
}
if (TIFFFieldSet(tif,FIELD_FILLORDER)) {
fprintf(fd, " FillOrder: ");
switch (td->td_fillorder) {
case FILLORDER_MSB2LSB:
fprintf(fd, "msb-to-lsb\n");
break;
case FILLORDER_LSB2MSB:
fprintf(fd, "lsb-to-msb\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_fillorder, td->td_fillorder);
break;
}
}
#ifdef YCBCR_SUPPORT
if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))
{
/*
* For hacky reasons (see tif_jpeg.c - JPEGFixupTestSubsampling),
* we need to fetch this rather than trust what is in our
* structures.
*/
uint16 subsampling[2];
TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
subsampling + 0, subsampling + 1 );
fprintf(fd, " YCbCr Subsampling: %u, %u\n",
subsampling[0], subsampling[1] );
}
if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) {
fprintf(fd, " YCbCr Positioning: ");
switch (td->td_ycbcrpositioning) {
case YCBCRPOSITION_CENTERED:
fprintf(fd, "centered\n");
break;
case YCBCRPOSITION_COSITED:
fprintf(fd, "cosited\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_ycbcrpositioning, td->td_ycbcrpositioning);
break;
}
}
if (TIFFFieldSet(tif,FIELD_YCBCRCOEFFICIENTS))
fprintf(fd, " YCbCr Coefficients: %g, %g, %g\n",
td->td_ycbcrcoeffs[0],
td->td_ycbcrcoeffs[1],
td->td_ycbcrcoeffs[2]);
#endif
if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))
fprintf(fd, " Halftone Hints: light %u dark %u\n",
td->td_halftonehints[0], td->td_halftonehints[1]);
if (TIFFFieldSet(tif,FIELD_ARTIST))
_TIFFprintAsciiTag(fd, "Artist", td->td_artist);
if (TIFFFieldSet(tif,FIELD_DATETIME))
_TIFFprintAsciiTag(fd, "Date & Time", td->td_datetime);
if (TIFFFieldSet(tif,FIELD_HOSTCOMPUTER))
_TIFFprintAsciiTag(fd, "Host Computer", td->td_hostcomputer);
if (TIFFFieldSet(tif,FIELD_COPYRIGHT))
_TIFFprintAsciiTag(fd, "Copyright", td->td_copyright);
if (TIFFFieldSet(tif,FIELD_DOCUMENTNAME))
_TIFFprintAsciiTag(fd, "Document Name", td->td_documentname);
if (TIFFFieldSet(tif,FIELD_IMAGEDESCRIPTION))
_TIFFprintAsciiTag(fd, "Image Description", td->td_imagedescription);
if (TIFFFieldSet(tif,FIELD_MAKE))
_TIFFprintAsciiTag(fd, "Make", td->td_make);
if (TIFFFieldSet(tif,FIELD_MODEL))
_TIFFprintAsciiTag(fd, "Model", td->td_model);
if (TIFFFieldSet(tif,FIELD_ORIENTATION)) {
fprintf(fd, " Orientation: ");
if (td->td_orientation < NORIENTNAMES)
fprintf(fd, "%s\n", orientNames[td->td_orientation]);
else
fprintf(fd, "%u (0x%x)\n",
td->td_orientation, td->td_orientation);
}
if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
fprintf(fd, " Samples/Pixel: %u\n", td->td_samplesperpixel);
if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) {
fprintf(fd, " Rows/Strip: ");
if (td->td_rowsperstrip == (uint32) -1)
fprintf(fd, "(infinite)\n");
else
fprintf(fd, "%lu\n", (u_long) td->td_rowsperstrip);
}
if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))
fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue);
if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))
fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE))
fprintf(fd, " SMin Sample Value: %g\n",
td->td_sminsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE))
fprintf(fd, " SMax Sample Value: %g\n",
td->td_smaxsamplevalue);
if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) {
fprintf(fd, " Planar Configuration: ");
switch (td->td_planarconfig) {
case PLANARCONFIG_CONTIG:
fprintf(fd, "single image plane\n");
break;
case PLANARCONFIG_SEPARATE:
fprintf(fd, "separate image planes\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_planarconfig, td->td_planarconfig);
break;
}
}
if (TIFFFieldSet(tif,FIELD_PAGENAME))
_TIFFprintAsciiTag(fd, "Page Name", td->td_pagename);
if (TIFFFieldSet(tif,FIELD_PAGENUMBER))
fprintf(fd, " Page Number: %u-%u\n",
td->td_pagenumber[0], td->td_pagenumber[1]);
if (TIFFFieldSet(tif,FIELD_COLORMAP)) {
fprintf(fd, " Color Map: ");
if (flags & TIFFPRINT_COLORMAP) {
fprintf(fd, "\n");
n = 1L<<td->td_bitspersample;
for (l = 0; l < n; l++)
fprintf(fd, " %5lu: %5u %5u %5u\n",
l,
td->td_colormap[0][l],
td->td_colormap[1][l],
td->td_colormap[2][l]);
} else
fprintf(fd, "(present)\n");
}
#ifdef COLORIMETRY_SUPPORT
if (TIFFFieldSet(tif,FIELD_WHITEPOINT))
fprintf(fd, " White Point: %g-%g\n",
td->td_whitepoint[0], td->td_whitepoint[1]);
if (TIFFFieldSet(tif,FIELD_PRIMARYCHROMAS))
fprintf(fd, " Primary Chromaticities: %g,%g %g,%g %g,%g\n",
td->td_primarychromas[0], td->td_primarychromas[1],
td->td_primarychromas[2], td->td_primarychromas[3],
td->td_primarychromas[4], td->td_primarychromas[5]);
if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) {
fprintf(fd, " Reference Black/White:\n");
for (i = 0; i < td->td_samplesperpixel; i++)
fprintf(fd, " %2d: %5g %5g\n",
i,
td->td_refblackwhite[2*i+0],
td->td_refblackwhite[2*i+1]);
}
if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) {
fprintf(fd, " Transfer Function: ");
if (flags & TIFFPRINT_CURVES) {
fprintf(fd, "\n");
n = 1L<<td->td_bitspersample;
for (l = 0; l < n; l++) {
fprintf(fd, " %2lu: %5u",
l, td->td_transferfunction[0][l]);
for (i = 1; i < td->td_samplesperpixel; i++)
fprintf(fd, " %5u",
td->td_transferfunction[i][l]);
fputc('\n', fd);
}
} else
fprintf(fd, "(present)\n");
}
#endif
#ifdef ICC_SUPPORT
if (TIFFFieldSet(tif,FIELD_ICCPROFILE))
fprintf(fd, " ICC Profile: <present>, %lu bytes\n",
(u_long) td->td_profileLength);
#endif
#ifdef PHOTOSHOP_SUPPORT
if (TIFFFieldSet(tif,FIELD_PHOTOSHOP))
fprintf(fd, " Photoshop Data: <present>, %lu bytes\n",
(u_long) td->td_photoshopLength);
#endif
#ifdef IPTC_SUPPORT
if (TIFFFieldSet(tif,FIELD_RICHTIFFIPTC))
fprintf(fd, " RichTIFFIPTC Data: <present>, %lu bytes\n",
(u_long) td->td_richtiffiptcLength);
#endif
#if SUBIFD_SUPPORT
if (TIFFFieldSet(tif, FIELD_SUBIFD)) {
fprintf(fd, " SubIFD Offsets:");
for (i = 0; i < td->td_nsubifd; i++)
fprintf(fd, " %5lu", (long) td->td_subifd[i]);
fputc('\n', fd);
}
#endif
/*
** Custom tag support.
*/
{
int i, count;
count = TIFFGetTagListCount( tif );
for( i = 0; i < count; i++ )
{
ttag_t tag = TIFFGetTagListEntry( tif, i );
const TIFFFieldInfo *fld;
fld = TIFFFieldWithTag( tif, tag );
if( fld == NULL )
continue;
if( fld->field_passcount )
{
int count, i;
void *raw_data;
if( TIFFGetField( tif, tag, &count, &raw_data ) != 1 )
continue;
fprintf(fd, " %s: ", fld->field_name );
for( i = 0; i < count; i++ )
{
if( fld->field_type == TIFF_SHORT )
fprintf( fd, "%d",
(int) ((short *) raw_data)[i] );
else if( fld->field_type == TIFF_ASCII )
{
fprintf( fd, "%s",
(char *) raw_data );
break;
}
else if( fld->field_type == TIFF_DOUBLE )
fprintf( fd, "%f",
((double *) raw_data)[i] );
else if( fld->field_type == TIFF_FLOAT )
fprintf( fd, "%f",
(float) ((double *) raw_data)[i] );
else if( fld->field_type == TIFF_LONG )
fprintf( fd, "%d",
(int) ((long *) raw_data)[i] );
else
{
fprintf( fd,
"<unsupported data type in TIFFPrint>" );
break;
}
if( i < count-1 )
fprintf( fd, "," );
}
fprintf( fd, "\n" );
}
else if( !fld->field_passcount
&& fld->field_type == TIFF_ASCII )
{
char *data;
if( TIFFGetField( tif, tag, &data ) )
fprintf(fd, " %s: %s\n", fld->field_name, data );
}
}
}
if (tif->tif_tagmethods.printdir)
(*tif->tif_tagmethods.printdir)(tif, fd, flags);
if ((flags & TIFFPRINT_STRIPS) &&
TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) {
tstrip_t s;
fprintf(fd, " %lu %s:\n",
(long) td->td_nstrips,
isTiled(tif) ? "Tiles" : "Strips");
for (s = 0; s < td->td_nstrips; s++)
fprintf(fd, " %3lu: [%8lu, %8lu]\n",
(u_long) s,
(u_long) td->td_stripoffset[s],
(u_long) td->td_stripbytecount[s]);
}
}
void
_TIFFprintAscii(FILE* fd, const char* cp)
{
for (; *cp != '\0'; cp++) {
const char* tp;
if (isprint(*cp)) {
fputc(*cp, fd);
continue;
}
for (tp = "\tt\bb\rr\nn\vv"; *tp; tp++)
if (*tp++ == *cp)
break;
if (*tp)
fprintf(fd, "\\%c", *tp);
else
fprintf(fd, "\\%03o", *cp & 0xff);
}
}
void
_TIFFprintAsciiTag(FILE* fd, const char* name, const char* value)
{
fprintf(fd, " %s: \"", name);
_TIFFprintAscii(fd, value);
fprintf(fd, "\"\n");
}
src/add-ons/translators/libtifftranslator/tif_read.c
+637
View File
@@ -0,0 +1,637 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_read.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
* Scanline-oriented Read Support
*/
#include "tiffiop.h"
#include <stdio.h>
#include <assert.h>
int TIFFFillStrip(TIFF*, tstrip_t);
int TIFFFillTile(TIFF*, ttile_t);
static int TIFFStartStrip(TIFF*, tstrip_t);
static int TIFFStartTile(TIFF*, ttile_t);
static int TIFFCheckRead(TIFF*, int);
#define NOSTRIP ((tstrip_t) -1) /* undefined state */
#define NOTILE ((ttile_t) -1) /* undefined state */
/*
* Seek to a random row+sample in a file.
*/
static int
TIFFSeek(TIFF* tif, uint32 row, tsample_t sample)
{
register TIFFDirectory *td = &tif->tif_dir;
tstrip_t strip;
if (row >= td->td_imagelength) { /* out of range */
TIFFError(tif->tif_name, "%lu: Row out of range, max %lu",
(u_long) row, (u_long) td->td_imagelength);
return (0);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
if (sample >= td->td_samplesperpixel) {
TIFFError(tif->tif_name,
"%lu: Sample out of range, max %lu",
(u_long) sample, (u_long) td->td_samplesperpixel);
return (0);
}
strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
} else
strip = row / td->td_rowsperstrip;
if (strip != tif->tif_curstrip) { /* different strip, refill */
if (!TIFFFillStrip(tif, strip))
return (0);
} else if (row < tif->tif_row) {
/*
* Moving backwards within the same strip: backup
* to the start and then decode forward (below).
*
* NB: If you're planning on lots of random access within a
* strip, it's better to just read and decode the entire
* strip, and then access the decoded data in a random fashion.
*/
if (!TIFFStartStrip(tif, strip))
return (0);
}
if (row != tif->tif_row) {
/*
* Seek forward to the desired row.
*/
if (!(*tif->tif_seek)(tif, row - tif->tif_row))
return (0);
tif->tif_row = row;
}
return (1);
}
int
TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
{
int e;
if (!TIFFCheckRead(tif, 0))
return (-1);
if( (e = TIFFSeek(tif, row, sample)) != 0) {
/*
* Decompress desired row into user buffer.
*/
e = (*tif->tif_decoderow)
(tif, (tidata_t) buf, tif->tif_scanlinesize, sample);
/* we are now poised at the beginning of the next row */
tif->tif_row = row + 1;
if (e)
(*tif->tif_postdecode)(tif, (tidata_t) buf,
tif->tif_scanlinesize);
}
return (e > 0 ? 1 : -1);
}
/*
* Read a strip of data and decompress the specified
* amount into the user-supplied buffer.
*/
tsize_t
TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
{
TIFFDirectory *td = &tif->tif_dir;
uint32 nrows;
tsize_t stripsize;
tstrip_t sep_strip, strips_per_sep;
if (!TIFFCheckRead(tif, 0))
return (-1);
if (strip >= td->td_nstrips) {
TIFFError(tif->tif_name, "%ld: Strip out of range, max %ld",
(long) strip, (long) td->td_nstrips);
return (-1);
}
/*
* Calculate the strip size according to the number of
* rows in the strip (check for truncated last strip on any
* of the separations).
*/
if( td->td_rowsperstrip >= td->td_imagelength )
strips_per_sep = 1;
else
strips_per_sep = (td->td_imagelength+td->td_rowsperstrip-1)
/ td->td_rowsperstrip;
sep_strip = strip % strips_per_sep;
if (sep_strip != strips_per_sep-1 ||
(nrows = td->td_imagelength % td->td_rowsperstrip) == 0)
nrows = td->td_rowsperstrip;
stripsize = TIFFVStripSize(tif, nrows);
if (size == (tsize_t) -1)
size = stripsize;
else if (size > stripsize)
size = stripsize;
if (TIFFFillStrip(tif, strip)
&& (*tif->tif_decodestrip)(tif, (tidata_t) buf, size,
(tsample_t)(strip / td->td_stripsperimage)) > 0 ) {
(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
return (size);
} else
return ((tsize_t) -1);
}
static tsize_t
TIFFReadRawStrip1(TIFF* tif,
tstrip_t strip, tdata_t buf, tsize_t size, const char* module)
{
TIFFDirectory *td = &tif->tif_dir;
if (!isMapped(tif)) {
tsize_t cc;
if (!SeekOK(tif, td->td_stripoffset[strip])) {
TIFFError(module,
"%s: Seek error at scanline %lu, strip %lu",
tif->tif_name,
(u_long) tif->tif_row, (u_long) strip);
return (-1);
}
cc = TIFFReadFile(tif, buf, size);
if (cc != size) {
TIFFError(module,
"%s: Read error at scanline %lu; got %lu bytes, expected %lu",
tif->tif_name,
(u_long) tif->tif_row,
(u_long) cc,
(u_long) size);
return (-1);
}
} else {
if (td->td_stripoffset[strip] + size > tif->tif_size) {
TIFFError(module,
"%s: Read error at scanline %lu, strip %lu; got %lu bytes, expected %lu",
tif->tif_name,
(u_long) tif->tif_row,
(u_long) strip,
(u_long) tif->tif_size - td->td_stripoffset[strip],
(u_long) size);
return (-1);
}
_TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[strip], size);
}
return (size);
}
/*
* Read a strip of data from the file.
*/
tsize_t
TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
{
static const char module[] = "TIFFReadRawStrip";
TIFFDirectory *td = &tif->tif_dir;
tsize_t bytecount;
if (!TIFFCheckRead(tif, 0))
return ((tsize_t) -1);
if (strip >= td->td_nstrips) {
TIFFError(tif->tif_name, "%lu: Strip out of range, max %lu",
(u_long) strip, (u_long) td->td_nstrips);
return ((tsize_t) -1);
}
bytecount = td->td_stripbytecount[strip];
if (bytecount <= 0) {
TIFFError(tif->tif_name,
"%lu: Invalid strip byte count, strip %lu",
(u_long) bytecount, (u_long) strip);
return ((tsize_t) -1);
}
if (size != (tsize_t)-1 && size < bytecount)
bytecount = size;
return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module));
}
/*
* Read the specified strip and setup for decoding.
* The data buffer is expanded, as necessary, to
* hold the strip's data.
*/
int
TIFFFillStrip(TIFF* tif, tstrip_t strip)
{
static const char module[] = "TIFFFillStrip";
TIFFDirectory *td = &tif->tif_dir;
tsize_t bytecount;
bytecount = td->td_stripbytecount[strip];
if (bytecount <= 0) {
TIFFError(tif->tif_name,
"%lu: Invalid strip byte count, strip %lu",
(u_long) bytecount, (u_long) strip);
return (0);
}
if (isMapped(tif) &&
(isFillOrder(tif, td->td_fillorder) || (tif->tif_flags & TIFF_NOBITREV))) {
/*
* The image is mapped into memory and we either don't
* need to flip bits or the compression routine is going
* to handle this operation itself. In this case, avoid
* copying the raw data and instead just reference the
* data from the memory mapped file image. This assumes
* that the decompression routines do not modify the
* contents of the raw data buffer (if they try to,
* the application will get a fault since the file is
* mapped read-only).
*/
if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
_TIFFfree(tif->tif_rawdata);
tif->tif_flags &= ~TIFF_MYBUFFER;
if ( td->td_stripoffset[strip] + bytecount > tif->tif_size) {
/*
* This error message might seem strange, but it's
* what would happen if a read were done instead.
*/
TIFFError(module,
"%s: Read error on strip %lu; got %lu bytes, expected %lu",
tif->tif_name,
(u_long) strip,
(u_long) tif->tif_size - td->td_stripoffset[strip],
(u_long) bytecount);
tif->tif_curstrip = NOSTRIP;
return (0);
}
tif->tif_rawdatasize = bytecount;
tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip];
} else {
/*
* Expand raw data buffer, if needed, to
* hold data strip coming from file
* (perhaps should set upper bound on
* the size of a buffer we'll use?).
*/
if (bytecount > tif->tif_rawdatasize) {
tif->tif_curstrip = NOSTRIP;
if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
TIFFError(module,
"%s: Data buffer too small to hold strip %lu",
tif->tif_name, (u_long) strip);
return (0);
}
if (!TIFFReadBufferSetup(tif, 0,
TIFFroundup(bytecount, 1024)))
return (0);
}
if (TIFFReadRawStrip1(tif, strip, (u_char *)tif->tif_rawdata,
bytecount, module) != bytecount)
return (0);
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits(tif->tif_rawdata, bytecount);
}
return (TIFFStartStrip(tif, strip));
}
/*
* Tile-oriented Read Support
* Contributed by Nancy Cam (Silicon Graphics).
*/
/*
* Read and decompress a tile of data. The
* tile is selected by the (x,y,z,s) coordinates.
*/
tsize_t
TIFFReadTile(TIFF* tif,
tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
{
if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
return (-1);
return (TIFFReadEncodedTile(tif,
TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
}
/*
* Read a tile of data and decompress the specified
* amount into the user-supplied buffer.
*/
tsize_t
TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t tilesize = tif->tif_tilesize;
if (!TIFFCheckRead(tif, 1))
return (-1);
if (tile >= td->td_nstrips) {
TIFFError(tif->tif_name, "%ld: Tile out of range, max %ld",
(long) tile, (u_long) td->td_nstrips);
return (-1);
}
if (size == (tsize_t) -1)
size = tilesize;
else if (size > tilesize)
size = tilesize;
if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif,
(tidata_t) buf, size, (tsample_t)(tile/td->td_stripsperimage))) {
(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
return (size);
} else
return (-1);
}
static tsize_t
TIFFReadRawTile1(TIFF* tif,
ttile_t tile, tdata_t buf, tsize_t size, const char* module)
{
TIFFDirectory *td = &tif->tif_dir;
if (!isMapped(tif)) {
tsize_t cc;
if (!SeekOK(tif, td->td_stripoffset[tile])) {
TIFFError(module,
"%s: Seek error at row %ld, col %ld, tile %ld",
tif->tif_name,
(long) tif->tif_row,
(long) tif->tif_col,
(long) tile);
return ((tsize_t) -1);
}
cc = TIFFReadFile(tif, buf, size);
if (cc != size) {
TIFFError(module,
"%s: Read error at row %ld, col %ld; got %lu bytes, expected %lu",
tif->tif_name,
(long) tif->tif_row,
(long) tif->tif_col,
(u_long) cc,
(u_long) size);
return ((tsize_t) -1);
}
} else {
if (td->td_stripoffset[tile] + size > tif->tif_size) {
TIFFError(module,
"%s: Read error at row %ld, col %ld, tile %ld; got %lu bytes, expected %lu",
tif->tif_name,
(long) tif->tif_row,
(long) tif->tif_col,
(long) tile,
(u_long) tif->tif_size - td->td_stripoffset[tile],
(u_long) size);
return ((tsize_t) -1);
}
_TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[tile], size);
}
return (size);
}
/*
* Read a tile of data from the file.
*/
tsize_t
TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
{
static const char module[] = "TIFFReadRawTile";
TIFFDirectory *td = &tif->tif_dir;
tsize_t bytecount;
if (!TIFFCheckRead(tif, 1))
return ((tsize_t) -1);
if (tile >= td->td_nstrips) {
TIFFError(tif->tif_name, "%lu: Tile out of range, max %lu",
(u_long) tile, (u_long) td->td_nstrips);
return ((tsize_t) -1);
}
bytecount = td->td_stripbytecount[tile];
if (size != (tsize_t) -1 && size < bytecount)
bytecount = size;
return (TIFFReadRawTile1(tif, tile, buf, bytecount, module));
}
/*
* Read the specified tile and setup for decoding.
* The data buffer is expanded, as necessary, to
* hold the tile's data.
*/
int
TIFFFillTile(TIFF* tif, ttile_t tile)
{
static const char module[] = "TIFFFillTile";
TIFFDirectory *td = &tif->tif_dir;
tsize_t bytecount;
bytecount = td->td_stripbytecount[tile];
if (bytecount <= 0) {
TIFFError(tif->tif_name,
"%lu: Invalid tile byte count, tile %lu",
(u_long) bytecount, (u_long) tile);
return (0);
}
if (isMapped(tif) &&
(isFillOrder(tif, td->td_fillorder) || (tif->tif_flags & TIFF_NOBITREV))) {
/*
* The image is mapped into memory and we either don't
* need to flip bits or the compression routine is going
* to handle this operation itself. In this case, avoid
* copying the raw data and instead just reference the
* data from the memory mapped file image. This assumes
* that the decompression routines do not modify the
* contents of the raw data buffer (if they try to,
* the application will get a fault since the file is
* mapped read-only).
*/
if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
_TIFFfree(tif->tif_rawdata);
tif->tif_flags &= ~TIFF_MYBUFFER;
if ( td->td_stripoffset[tile] + bytecount > tif->tif_size) {
tif->tif_curtile = NOTILE;
return (0);
}
tif->tif_rawdatasize = bytecount;
tif->tif_rawdata = tif->tif_base + td->td_stripoffset[tile];
} else {
/*
* Expand raw data buffer, if needed, to
* hold data tile coming from file
* (perhaps should set upper bound on
* the size of a buffer we'll use?).
*/
if (bytecount > tif->tif_rawdatasize) {
tif->tif_curtile = NOTILE;
if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
TIFFError(module,
"%s: Data buffer too small to hold tile %ld",
tif->tif_name, (long) tile);
return (0);
}
if (!TIFFReadBufferSetup(tif, 0,
TIFFroundup(bytecount, 1024)))
return (0);
}
if (TIFFReadRawTile1(tif, tile, (u_char *)tif->tif_rawdata,
bytecount, module) != bytecount)
return (0);
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits(tif->tif_rawdata, bytecount);
}
return (TIFFStartTile(tif, tile));
}
/*
* Setup the raw data buffer in preparation for
* reading a strip of raw data. If the buffer
* is specified as zero, then a buffer of appropriate
* size is allocated by the library. Otherwise,
* the client must guarantee that the buffer is
* large enough to hold any individual strip of
* raw data.
*/
int
TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
{
static const char module[] = "TIFFReadBufferSetup";
if (tif->tif_rawdata) {
if (tif->tif_flags & TIFF_MYBUFFER)
_TIFFfree(tif->tif_rawdata);
tif->tif_rawdata = NULL;
}
if (bp) {
tif->tif_rawdatasize = size;
tif->tif_rawdata = (tidata_t) bp;
tif->tif_flags &= ~TIFF_MYBUFFER;
} else {
tif->tif_rawdatasize = TIFFroundup(size, 1024);
tif->tif_rawdata = (tidata_t) _TIFFmalloc(tif->tif_rawdatasize);
tif->tif_flags |= TIFF_MYBUFFER;
}
if (tif->tif_rawdata == NULL) {
TIFFError(module,
"%s: No space for data buffer at scanline %ld",
tif->tif_name, (long) tif->tif_row);
tif->tif_rawdatasize = 0;
return (0);
}
return (1);
}
/*
* Set state to appear as if a
* strip has just been read in.
*/
static int
TIFFStartStrip(TIFF* tif, tstrip_t strip)
{
TIFFDirectory *td = &tif->tif_dir;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
if (!(*tif->tif_setupdecode)(tif))
return (0);
tif->tif_flags |= TIFF_CODERSETUP;
}
tif->tif_curstrip = strip;
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
tif->tif_rawcp = tif->tif_rawdata;
tif->tif_rawcc = td->td_stripbytecount[strip];
return ((*tif->tif_predecode)(tif,
(tsample_t)(strip / td->td_stripsperimage)));
}
/*
* Set state to appear as if a
* tile has just been read in.
*/
static int
TIFFStartTile(TIFF* tif, ttile_t tile)
{
TIFFDirectory *td = &tif->tif_dir;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
if (!(*tif->tif_setupdecode)(tif))
return (0);
tif->tif_flags |= TIFF_CODERSETUP;
}
tif->tif_curtile = tile;
tif->tif_row =
(tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) *
td->td_tilelength;
tif->tif_col =
(tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) *
td->td_tilewidth;
tif->tif_rawcp = tif->tif_rawdata;
tif->tif_rawcc = td->td_stripbytecount[tile];
return ((*tif->tif_predecode)(tif,
(tsample_t)(tile/td->td_stripsperimage)));
}
static int
TIFFCheckRead(TIFF* tif, int tiles)
{
if (tif->tif_mode == O_WRONLY) {
TIFFError(tif->tif_name, "File not open for reading");
return (0);
}
if (tiles ^ isTiled(tif)) {
TIFFError(tif->tif_name, tiles ?
"Can not read tiles from a stripped image" :
"Can not read scanlines from a tiled image");
return (0);
}
return (1);
}
void
_TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc)
{
(void) tif; (void) buf; (void) cc;
}
void
_TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc)
{
(void) tif;
assert((cc & 1) == 0);
TIFFSwabArrayOfShort((uint16*) buf, cc/2);
}
void
_TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc)
{
(void) tif;
assert((cc & 3) == 0);
TIFFSwabArrayOfLong((uint32*) buf, cc/4);
}
void
_TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc)
{
(void) tif;
assert((cc & 7) == 0);
TIFFSwabArrayOfDouble((double*) buf, cc/8);
}
src/add-ons/translators/libtifftranslator/tif_strip.c
+197
View File
@@ -0,0 +1,197 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_strip.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* Strip-organized Image Support Routines.
*/
#include "tiffiop.h"
/*
* Compute which strip a (row,sample) value is in.
*/
tstrip_t
TIFFComputeStrip(TIFF* tif, uint32 row, tsample_t sample)
{
TIFFDirectory *td = &tif->tif_dir;
tstrip_t strip;
strip = row / td->td_rowsperstrip;
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
if (sample >= td->td_samplesperpixel) {
TIFFError(tif->tif_name,
"%u: Sample out of range, max %u",
sample, td->td_samplesperpixel);
return ((tstrip_t) 0);
}
strip += sample*td->td_stripsperimage;
}
return (strip);
}
/*
* Compute how many strips are in an image.
*/
tstrip_t
TIFFNumberOfStrips(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tstrip_t nstrips;
nstrips = (td->td_rowsperstrip == (uint32) -1 ?
(td->td_imagelength != 0 ? 1 : 0) :
TIFFhowmany(td->td_imagelength, td->td_rowsperstrip));
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
nstrips *= td->td_samplesperpixel;
return (nstrips);
}
/*
* Compute the # bytes in a variable height, row-aligned strip.
*/
tsize_t
TIFFVStripSize(TIFF* tif, uint32 nrows)
{
TIFFDirectory *td = &tif->tif_dir;
if (nrows == (uint32) -1)
nrows = td->td_imagelength;
#ifdef YCBCR_SUPPORT
if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
td->td_photometric == PHOTOMETRIC_YCBCR &&
!isUpSampled(tif)) {
/*
* Packed YCbCr data contain one Cb+Cr for every
* HorizontalSampling*VerticalSampling Y values.
* Must also roundup width and height when calculating
* since images that are not a multiple of the
* horizontal/vertical subsampling area include
* YCbCr data for the extended image.
*/
uint16 ycbcrsubsampling[2];
tsize_t w, scanline, samplingarea;
TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling + 0,
ycbcrsubsampling + 1 );
w = TIFFroundup(td->td_imagewidth, ycbcrsubsampling[0]);
scanline = TIFFhowmany(w*td->td_bitspersample, 8);
samplingarea = ycbcrsubsampling[0]*ycbcrsubsampling[1];
nrows = TIFFroundup(nrows, ycbcrsubsampling[1]);
/* NB: don't need TIFFhowmany here 'cuz everything is rounded */
return ((tsize_t)
(nrows*scanline + 2*(nrows*scanline / samplingarea)));
} else
#endif
return ((tsize_t)(nrows * TIFFScanlineSize(tif)));
}
/*
* Compute the # bytes in a (row-aligned) strip.
*
* Note that if RowsPerStrip is larger than the
* recorded ImageLength, then the strip size is
* truncated to reflect the actual space required
* to hold the strip.
*/
tsize_t
TIFFStripSize(TIFF* tif)
{
TIFFDirectory* td = &tif->tif_dir;
uint32 rps = td->td_rowsperstrip;
if (rps > td->td_imagelength)
rps = td->td_imagelength;
return (TIFFVStripSize(tif, rps));
}
/*
* Compute a default strip size based on the image
* characteristics and a requested value. If the
* request is <1 then we choose a strip size according
* to certain heuristics.
*/
uint32
TIFFDefaultStripSize(TIFF* tif, uint32 request)
{
return (*tif->tif_defstripsize)(tif, request);
}
uint32
_TIFFDefaultStripSize(TIFF* tif, uint32 s)
{
if ((int32) s < 1) {
/*
* If RowsPerStrip is unspecified, try to break the
* image up into strips that are approximately 8Kbytes.
*/
tsize_t scanline = TIFFScanlineSize(tif);
s = (uint32)(8*1024) / (scanline == 0 ? 1 : scanline);
if (s == 0) /* very wide images */
s = 1;
}
return (s);
}
/*
* Return the number of bytes to read/write in a call to
* one of the scanline-oriented i/o routines. Note that
* this number may be 1/samples-per-pixel if data is
* stored as separate planes.
*/
tsize_t
TIFFScanlineSize(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t scanline;
scanline = td->td_bitspersample * td->td_imagewidth;
if (td->td_planarconfig == PLANARCONFIG_CONTIG)
scanline *= td->td_samplesperpixel;
return ((tsize_t) TIFFhowmany(scanline, 8));
}
/*
* Return the number of bytes required to store a complete
* decoded and packed raster scanline (as opposed to the
* I/O size returned by TIFFScanlineSize which may be less
* if data is store as separate planes).
*/
tsize_t
TIFFRasterScanlineSize(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t scanline;
scanline = td->td_bitspersample * td->td_imagewidth;
if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
scanline *= td->td_samplesperpixel;
return ((tsize_t) TIFFhowmany(scanline, 8));
} else
return ((tsize_t)
TIFFhowmany(scanline, 8)*td->td_samplesperpixel);
}
src/add-ons/translators/libtifftranslator/tif_swab.c
+217
View File
@@ -0,0 +1,217 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_swab.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library Bit & Byte Swapping Support.
*
* XXX We assume short = 16-bits and long = 32-bits XXX
*/
#include "tiffiop.h"
#ifndef TIFFSwabShort
void
TIFFSwabShort(uint16* wp)
{
register u_char* cp = (u_char*) wp;
int t;
t = cp[1]; cp[1] = cp[0]; cp[0] = t;
}
#endif
#ifndef TIFFSwabLong
void
TIFFSwabLong(uint32* lp)
{
register u_char* cp = (u_char*) lp;
int t;
t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t = cp[2]; cp[2] = cp[1]; cp[1] = t;
}
#endif
#ifndef TIFFSwabArrayOfShort
void
TIFFSwabArrayOfShort(uint16* wp, register u_long n)
{
register u_char* cp;
register int t;
/* XXX unroll loop some */
while (n-- > 0) {
cp = (u_char*) wp;
t = cp[1]; cp[1] = cp[0]; cp[0] = t;
wp++;
}
}
#endif
#ifndef TIFFSwabArrayOfLong
void
TIFFSwabArrayOfLong(register uint32* lp, register u_long n)
{
register unsigned char *cp;
register int t;
/* XXX unroll loop some */
while (n-- > 0) {
cp = (unsigned char *)lp;
t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t = cp[2]; cp[2] = cp[1]; cp[1] = t;
lp++;
}
}
#endif
#ifndef TIFFSwabDouble
void
TIFFSwabDouble(double *dp)
{
register uint32* lp = (uint32*) dp;
uint32 t;
TIFFSwabArrayOfLong(lp, 2);
t = lp[0]; lp[0] = lp[1]; lp[1] = t;
}
#endif
#ifndef TIFFSwabArrayOfDouble
void
TIFFSwabArrayOfDouble(double* dp, register u_long n)
{
register uint32* lp = (uint32*) dp;
register uint32 t;
TIFFSwabArrayOfLong(lp, n + n);
while (n-- > 0) {
t = lp[0]; lp[0] = lp[1]; lp[1] = t;
lp += 2;
}
}
#endif
/*
* Bit reversal tables. TIFFBitRevTable[<byte>] gives
* the bit reversed value of <byte>. Used in various
* places in the library when the FillOrder requires
* bit reversal of byte values (e.g. CCITT Fax 3
* encoding/decoding). TIFFNoBitRevTable is provided
* for algorithms that want an equivalent table that
* do not reverse bit values.
*/
static const unsigned char TIFFBitRevTable[256] = {
0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
};
static const unsigned char TIFFNoBitRevTable[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
};
const unsigned char*
TIFFGetBitRevTable(int reversed)
{
return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable);
}
void
TIFFReverseBits(register u_char* cp, register u_long n)
{
for (; n > 8; n -= 8) {
cp[0] = TIFFBitRevTable[cp[0]];
cp[1] = TIFFBitRevTable[cp[1]];
cp[2] = TIFFBitRevTable[cp[2]];
cp[3] = TIFFBitRevTable[cp[3]];
cp[4] = TIFFBitRevTable[cp[4]];
cp[5] = TIFFBitRevTable[cp[5]];
cp[6] = TIFFBitRevTable[cp[6]];
cp[7] = TIFFBitRevTable[cp[7]];
cp += 8;
}
while (n-- > 0)
*cp = TIFFBitRevTable[*cp], cp++;
}
src/add-ons/translators/libtifftranslator/tif_thunder.c
+154
View File
@@ -0,0 +1,154 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_thunder.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include "tiffiop.h"
#ifdef THUNDER_SUPPORT
/*
* TIFF Library.
*
* ThunderScan 4-bit Compression Algorithm Support
*/
/*
* ThunderScan uses an encoding scheme designed for
* 4-bit pixel values. Data is encoded in bytes, with
* each byte split into a 2-bit code word and a 6-bit
* data value. The encoding gives raw data, runs of
* pixels, or pixel values encoded as a delta from the
* previous pixel value. For the latter, either 2-bit
* or 3-bit delta values are used, with the deltas packed
* into a single byte.
*/
#define THUNDER_DATA 0x3f /* mask for 6-bit data */
#define THUNDER_CODE 0xc0 /* mask for 2-bit code word */
/* code values */
#define THUNDER_RUN 0x00 /* run of pixels w/ encoded count */
#define THUNDER_2BITDELTAS 0x40 /* 3 pixels w/ encoded 2-bit deltas */
#define DELTA2_SKIP 2 /* skip code for 2-bit deltas */
#define THUNDER_3BITDELTAS 0x80 /* 2 pixels w/ encoded 3-bit deltas */
#define DELTA3_SKIP 4 /* skip code for 3-bit deltas */
#define THUNDER_RAW 0xc0 /* raw data encoded */
static const int twobitdeltas[4] = { 0, 1, 0, -1 };
static const int threebitdeltas[8] = { 0, 1, 2, 3, 0, -3, -2, -1 };
#define SETPIXEL(op, v) { \
lastpixel = (v) & 0xf; \
if (npixels++ & 1) \
*op++ |= lastpixel; \
else \
op[0] = lastpixel << 4; \
}
static int
ThunderDecode(TIFF* tif, tidata_t op, tsize_t maxpixels)
{
register u_char *bp;
register tsize_t cc;
u_int lastpixel;
tsize_t npixels;
bp = (u_char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
lastpixel = 0;
npixels = 0;
while (cc > 0 && npixels < maxpixels) {
int n, delta;
n = *bp++, cc--;
switch (n & THUNDER_CODE) {
case THUNDER_RUN: /* pixel run */
/*
* Replicate the last pixel n times,
* where n is the lower-order 6 bits.
*/
if (npixels & 1) {
op[0] |= lastpixel;
lastpixel = *op++; npixels++; n--;
} else
lastpixel |= lastpixel << 4;
npixels += n;
for (; n > 0; n -= 2)
*op++ = lastpixel;
if (n == -1)
*--op &= 0xf0;
lastpixel &= 0xf;
break;
case THUNDER_2BITDELTAS: /* 2-bit deltas */
if ((delta = ((n >> 4) & 3)) != DELTA2_SKIP)
SETPIXEL(op, lastpixel + twobitdeltas[delta]);
if ((delta = ((n >> 2) & 3)) != DELTA2_SKIP)
SETPIXEL(op, lastpixel + twobitdeltas[delta]);
if ((delta = (n & 3)) != DELTA2_SKIP)
SETPIXEL(op, lastpixel + twobitdeltas[delta]);
break;
case THUNDER_3BITDELTAS: /* 3-bit deltas */
if ((delta = ((n >> 3) & 7)) != DELTA3_SKIP)
SETPIXEL(op, lastpixel + threebitdeltas[delta]);
if ((delta = (n & 7)) != DELTA3_SKIP)
SETPIXEL(op, lastpixel + threebitdeltas[delta]);
break;
case THUNDER_RAW: /* raw data */
SETPIXEL(op, n);
break;
}
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcc = cc;
if (npixels != maxpixels) {
TIFFError(tif->tif_name,
"ThunderDecode: %s data at scanline %ld (%lu != %lu)",
npixels < maxpixels ? "Not enough" : "Too much",
(long) tif->tif_row, (long) npixels, (long) maxpixels);
return (0);
}
return (1);
}
static int
ThunderDecodeRow(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
{
tidata_t row = buf;
(void) s;
while ((long)occ > 0) {
if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth))
return (0);
occ -= tif->tif_scanlinesize;
row += tif->tif_scanlinesize;
}
return (1);
}
int
TIFFInitThunderScan(TIFF* tif, int scheme)
{
(void) scheme;
tif->tif_decoderow = ThunderDecodeRow;
tif->tif_decodestrip = ThunderDecodeRow;
return (1);
}
#endif /* THUNDER_SUPPORT */
src/add-ons/translators/libtifftranslator/tif_tile.c
+219
View File
@@ -0,0 +1,219 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_tile.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* Tiled Image Support Routines.
*/
#include "tiffiop.h"
/*
* Compute which tile an (x,y,z,s) value is in.
*/
ttile_t
TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
{
TIFFDirectory *td = &tif->tif_dir;
uint32 dx = td->td_tilewidth;
uint32 dy = td->td_tilelength;
uint32 dz = td->td_tiledepth;
ttile_t tile = 1;
if (td->td_imagedepth == 1)
z = 0;
if (dx == (uint32) -1)
dx = td->td_imagewidth;
if (dy == (uint32) -1)
dy = td->td_imagelength;
if (dz == (uint32) -1)
dz = td->td_imagedepth;
if (dx != 0 && dy != 0 && dz != 0) {
uint32 xpt = TIFFhowmany(td->td_imagewidth, dx);
uint32 ypt = TIFFhowmany(td->td_imagelength, dy);
uint32 zpt = TIFFhowmany(td->td_imagedepth, dz);
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
tile = (xpt*ypt*zpt)*s +
(xpt*ypt)*(z/dz) +
xpt*(y/dy) +
x/dx;
else
tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx + s;
}
return (tile);
}
/*
* Check an (x,y,z,s) coordinate
* against the image bounds.
*/
int
TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
{
TIFFDirectory *td = &tif->tif_dir;
if (x >= td->td_imagewidth) {
TIFFError(tif->tif_name, "Col %ld out of range, max %lu",
(long) x, (u_long) td->td_imagewidth);
return (0);
}
if (y >= td->td_imagelength) {
TIFFError(tif->tif_name, "Row %ld out of range, max %lu",
(long) y, (u_long) td->td_imagelength);
return (0);
}
if (z >= td->td_imagedepth) {
TIFFError(tif->tif_name, "Depth %ld out of range, max %lu",
(long) z, (u_long) td->td_imagedepth);
return (0);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
s >= td->td_samplesperpixel) {
TIFFError(tif->tif_name, "Sample %d out of range, max %u",
(int) s, td->td_samplesperpixel);
return (0);
}
return (1);
}
/*
* Compute how many tiles are in an image.
*/
ttile_t
TIFFNumberOfTiles(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
uint32 dx = td->td_tilewidth;
uint32 dy = td->td_tilelength;
uint32 dz = td->td_tiledepth;
ttile_t ntiles;
if (dx == (uint32) -1)
dx = td->td_imagewidth;
if (dy == (uint32) -1)
dy = td->td_imagelength;
if (dz == (uint32) -1)
dz = td->td_imagedepth;
ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
(TIFFhowmany(td->td_imagewidth, dx) *
TIFFhowmany(td->td_imagelength, dy) *
TIFFhowmany(td->td_imagedepth, dz));
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
ntiles *= td->td_samplesperpixel;
return (ntiles);
}
/*
* Compute the # bytes in each row of a tile.
*/
tsize_t
TIFFTileRowSize(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t rowsize;
if (td->td_tilelength == 0 || td->td_tilewidth == 0)
return ((tsize_t) 0);
rowsize = td->td_bitspersample * td->td_tilewidth;
if (td->td_planarconfig == PLANARCONFIG_CONTIG)
rowsize *= td->td_samplesperpixel;
return ((tsize_t) TIFFhowmany(rowsize, 8));
}
/*
* Compute the # bytes in a variable length, row-aligned tile.
*/
tsize_t
TIFFVTileSize(TIFF* tif, uint32 nrows)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t tilesize;
if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
td->td_tiledepth == 0)
return ((tsize_t) 0);
#ifdef YCBCR_SUPPORT
if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
td->td_photometric == PHOTOMETRIC_YCBCR &&
!isUpSampled(tif)) {
/*
* Packed YCbCr data contain one Cb+Cr for every
* HorizontalSampling*VerticalSampling Y values.
* Must also roundup width and height when calculating
* since images that are not a multiple of the
* horizontal/vertical subsampling area include
* YCbCr data for the extended image.
*/
tsize_t w =
TIFFroundup(td->td_tilewidth, td->td_ycbcrsubsampling[0]);
tsize_t rowsize = TIFFhowmany(w*td->td_bitspersample, 8);
tsize_t samplingarea =
td->td_ycbcrsubsampling[0]*td->td_ycbcrsubsampling[1];
nrows = TIFFroundup(nrows, td->td_ycbcrsubsampling[1]);
/* NB: don't need TIFFhowmany here 'cuz everything is rounded */
tilesize = nrows*rowsize + 2*(nrows*rowsize / samplingarea);
} else
#endif
tilesize = nrows * TIFFTileRowSize(tif);
return ((tsize_t)(tilesize * td->td_tiledepth));
}
/*
* Compute the # bytes in a row-aligned tile.
*/
tsize_t
TIFFTileSize(TIFF* tif)
{
return (TIFFVTileSize(tif, tif->tif_dir.td_tilelength));
}
/*
* Compute a default tile size based on the image
* characteristics and a requested value. If a
* request is <1 then we choose a size according
* to certain heuristics.
*/
void
TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
{
(*tif->tif_deftilesize)(tif, tw, th);
}
void
_TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
{
(void) tif;
if (*(int32*) tw < 1)
*tw = 256;
if (*(int32*) th < 1)
*th = 256;
/* roundup to a multiple of 16 per the spec */
if (*tw & 0xf)
*tw = TIFFroundup(*tw, 16);
if (*th & 0xf)
*th = TIFFroundup(*th, 16);
}
src/add-ons/translators/libtifftranslator/tif_unix.c
+228
View File
@@ -0,0 +1,228 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_unix.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library UNIX-specific Routines.
*/
#include "tiffiop.h"
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return ((tsize_t) read((int) fd, buf, (size_t) size));
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return ((tsize_t) write((int) fd, buf, (size_t) size));
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
{
#if USE_64BIT_API == 1
return ((toff_t) lseek64((int) fd, (off64_t) off, whence));
#else
return ((toff_t) lseek((int) fd, (off_t) off, whence));
#endif
}
static int
_tiffCloseProc(thandle_t fd)
{
return (close((int) fd));
}
#include <sys/stat.h>
static toff_t
_tiffSizeProc(thandle_t fd)
{
#ifdef _AM29K
long fsize;
return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize);
#else
#if USE_64BIT_API == 1
struct stat64 sb;
return (toff_t) (fstat64((int) fd, &sb) < 0 ? 0 : sb.st_size);
#else
struct stat sb;
return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
#endif
#endif
}
#ifdef HAVE_MMAP
#include <sys/mman.h>
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
{
toff_t size = _tiffSizeProc(fd);
if (size != (toff_t) -1) {
*pbase = (tdata_t)
mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0);
if (*pbase != (tdata_t) -1) {
*psize = size;
return (1);
}
}
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
{
(void) fd;
(void) munmap(base, (off_t) size);
}
#else /* !HAVE_MMAP */
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
{
(void) fd; (void) pbase; (void) psize;
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
{
(void) fd; (void) base; (void) size;
}
#endif /* !HAVE_MMAP */
/*
* Open a TIFF file descriptor for read/writing.
*/
TIFF*
TIFFFdOpen(int fd, const char* name, const char* mode)
{
TIFF* tif;
tif = TIFFClientOpen(name, mode,
(thandle_t) fd,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffMapProc, _tiffUnmapProc);
if (tif)
tif->tif_fd = fd;
return (tif);
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
int m, fd;
m = _TIFFgetMode(mode, module);
if (m == -1)
return ((TIFF*)0);
/* for cygwin */
#ifdef O_BINARY
m |= O_BINARY;
#endif
#ifdef _AM29K
fd = open(name, m);
#else
#if USE_64BIT_API == 1
fd = open(name, m | O_LARGEFILE, 0666);
#else
fd = open(name, m, 0666);
#endif
#endif
if (fd < 0) {
TIFFError(module, "%s: Cannot open", name);
return ((TIFF *)0);
}
return (TIFFFdOpen(fd, name, mode));
}
void*
_TIFFmalloc(tsize_t s)
{
return (malloc((size_t) s));
}
void
_TIFFfree(tdata_t p)
{
free(p);
}
void*
_TIFFrealloc(tdata_t p, tsize_t s)
{
return (realloc(p, (size_t) s));
}
void
_TIFFmemset(tdata_t p, int v, tsize_t c)
{
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
}
static void
unixWarningHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
fprintf(stderr, "Warning, ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
static void
unixErrorHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
src/add-ons/translators/libtifftranslator/tif_version.c
+33
View File
@@ -0,0 +1,33 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_version.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1992-1997 Sam Leffler
* Copyright (c) 1992-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include "tiffiop.h"
static const char TIFFVersion[] = TIFFLIB_VERSION_STR;
const char*
TIFFGetVersion(void)
{
return (TIFFVersion);
}
src/add-ons/translators/libtifftranslator/tif_warning.c
+49
View File
@@ -0,0 +1,49 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_warning.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*/
#include "tiffiop.h"
TIFFErrorHandler
TIFFSetWarningHandler(TIFFErrorHandler handler)
{
TIFFErrorHandler prev = _TIFFwarningHandler;
_TIFFwarningHandler = handler;
return (prev);
}
void
TIFFWarning(const char* module, const char* fmt, ...)
{
if (_TIFFwarningHandler) {
va_list ap;
va_start(ap, fmt);
(*_TIFFwarningHandler)(module, fmt, ap);
va_end(ap);
}
}
src/add-ons/translators/libtifftranslator/tif_write.c
+678
View File
@@ -0,0 +1,678 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_write.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* TIFF Library.
*
* Scanline-oriented Write Support
*/
#include "tiffiop.h"
#include <assert.h>
#include <stdio.h>
#define REWRITE_HACK
#define STRIPINCR 20 /* expansion factor on strip array */
#define WRITECHECKSTRIPS(tif, module) \
(((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),0,module))
#define WRITECHECKTILES(tif, module) \
(((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),1,module))
#define BUFFERCHECK(tif) \
((((tif)->tif_flags & TIFF_BUFFERSETUP) && tif->tif_rawdata) || \
TIFFWriteBufferSetup((tif), NULL, (tsize_t) -1))
static int TIFFGrowStrips(TIFF*, int, const char*);
static int TIFFAppendToStrip(TIFF*, tstrip_t, tidata_t, tsize_t);
int
TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
{
static const char module[] = "TIFFWriteScanline";
register TIFFDirectory *td;
int status, imagegrew = 0;
tstrip_t strip;
if (!WRITECHECKSTRIPS(tif, module))
return (-1);
/*
* Handle delayed allocation of data buffer. This
* permits it to be sized more intelligently (using
* directory information).
*/
if (!BUFFERCHECK(tif))
return (-1);
td = &tif->tif_dir;
/*
* Extend image length if needed
* (but only for PlanarConfig=1).
*/
if (row >= td->td_imagelength) { /* extend image */
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
TIFFError(tif->tif_name,
"Can not change \"ImageLength\" when using separate planes");
return (-1);
}
td->td_imagelength = row+1;
imagegrew = 1;
}
/*
* Calculate strip and check for crossings.
*/
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
if (sample >= td->td_samplesperpixel) {
TIFFError(tif->tif_name,
"%d: Sample out of range, max %d",
sample, td->td_samplesperpixel);
return (-1);
}
strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
} else
strip = row / td->td_rowsperstrip;
if (strip != tif->tif_curstrip) {
/*
* Changing strips -- flush any data present.
*/
if (!TIFFFlushData(tif))
return (-1);
tif->tif_curstrip = strip;
/*
* Watch out for a growing image. The value of
* strips/image will initially be 1 (since it
* can't be deduced until the imagelength is known).
*/
if (strip >= td->td_stripsperimage && imagegrew)
td->td_stripsperimage =
TIFFhowmany(td->td_imagelength,td->td_rowsperstrip);
tif->tif_row =
(strip % td->td_stripsperimage) * td->td_rowsperstrip;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
if (!(*tif->tif_setupencode)(tif))
return (-1);
tif->tif_flags |= TIFF_CODERSETUP;
}
if (!(*tif->tif_preencode)(tif, sample))
return (-1);
tif->tif_flags |= TIFF_POSTENCODE;
}
/*
* Check strip array to make sure there's space.
* We don't support dynamically growing files that
* have data organized in separate bitplanes because
* it's too painful. In that case we require that
* the imagelength be set properly before the first
* write (so that the strips array will be fully
* allocated above).
*/
if (strip >= td->td_nstrips && !TIFFGrowStrips(tif, 1, module))
return (-1);
/*
* Ensure the write is either sequential or at the
* beginning of a strip (or that we can randomly
* access the data -- i.e. no encoding).
*/
if (row != tif->tif_row) {
if (row < tif->tif_row) {
/*
* Moving backwards within the same strip:
* backup to the start and then decode
* forward (below).
*/
tif->tif_row = (strip % td->td_stripsperimage) *
td->td_rowsperstrip;
tif->tif_rawcp = tif->tif_rawdata;
}
/*
* Seek forward to the desired row.
*/
if (!(*tif->tif_seek)(tif, row - tif->tif_row))
return (-1);
tif->tif_row = row;
}
status = (*tif->tif_encoderow)(tif, (tidata_t) buf,
tif->tif_scanlinesize, sample);
/* we are now poised at the beginning of the next row */
tif->tif_row = row + 1;
return (status);
}
/*
* Encode the supplied data and write it to the
* specified strip. There must be space for the
* data; we don't check if strips overlap!
*
* NB: Image length must be setup before writing.
*/
tsize_t
TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
{
static const char module[] = "TIFFWriteEncodedStrip";
TIFFDirectory *td = &tif->tif_dir;
tsample_t sample;
if (!WRITECHECKSTRIPS(tif, module))
return ((tsize_t) -1);
/*
* Check strip array to make sure there's space.
* We don't support dynamically growing files that
* have data organized in separate bitplanes because
* it's too painful. In that case we require that
* the imagelength be set properly before the first
* write (so that the strips array will be fully
* allocated above).
*/
if (strip >= td->td_nstrips) {
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
TIFFError(tif->tif_name,
"Can not grow image by strips when using separate planes");
return ((tsize_t) -1);
}
if (!TIFFGrowStrips(tif, 1, module))
return ((tsize_t) -1);
td->td_stripsperimage =
TIFFhowmany(td->td_imagelength, td->td_rowsperstrip);
}
/*
* Handle delayed allocation of data buffer. This
* permits it to be sized according to the directory
* info.
*/
if (!BUFFERCHECK(tif))
return ((tsize_t) -1);
tif->tif_curstrip = strip;
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
if (!(*tif->tif_setupencode)(tif))
return ((tsize_t) -1);
tif->tif_flags |= TIFF_CODERSETUP;
}
#ifdef REWRITE_HACK
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
if( td->td_stripbytecount[strip] > 0 )
{
/* if we are writing over existing tiles, zero length. */
td->td_stripbytecount[strip] = 0;
/* this forces TIFFAppendToStrip() to do a seek */
tif->tif_curoff = 0;
}
#endif
tif->tif_flags &= ~TIFF_POSTENCODE;
sample = (tsample_t)(strip / td->td_stripsperimage);
if (!(*tif->tif_preencode)(tif, sample))
return ((tsize_t) -1);
if (!(*tif->tif_encodestrip)(tif, (tidata_t) data, cc, sample))
return ((tsize_t) 0);
if (!(*tif->tif_postencode)(tif))
return ((tsize_t) -1);
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits(tif->tif_rawdata, tif->tif_rawcc);
if (tif->tif_rawcc > 0 &&
!TIFFAppendToStrip(tif, strip, tif->tif_rawdata, tif->tif_rawcc))
return ((tsize_t) -1);
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
return (cc);
}
/*
* Write the supplied data to the specified strip.
* There must be space for the data; we don't check
* if strips overlap!
*
* NB: Image length must be setup before writing.
*/
tsize_t
TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
{
static const char module[] = "TIFFWriteRawStrip";
TIFFDirectory *td = &tif->tif_dir;
if (!WRITECHECKSTRIPS(tif, module))
return ((tsize_t) -1);
/*
* Check strip array to make sure there's space.
* We don't support dynamically growing files that
* have data organized in separate bitplanes because
* it's too painful. In that case we require that
* the imagelength be set properly before the first
* write (so that the strips array will be fully
* allocated above).
*/
if (strip >= td->td_nstrips) {
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
TIFFError(tif->tif_name,
"Can not grow image by strips when using separate planes");
return ((tsize_t) -1);
}
/*
* Watch out for a growing image. The value of
* strips/image will initially be 1 (since it
* can't be deduced until the imagelength is known).
*/
if (strip >= td->td_stripsperimage)
td->td_stripsperimage =
TIFFhowmany(td->td_imagelength,td->td_rowsperstrip);
if (!TIFFGrowStrips(tif, 1, module))
return ((tsize_t) -1);
}
tif->tif_curstrip = strip;
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
return (TIFFAppendToStrip(tif, strip, (tidata_t) data, cc) ?
cc : (tsize_t) -1);
}
/*
* Write and compress a tile of data. The
* tile is selected by the (x,y,z,s) coordinates.
*/
tsize_t
TIFFWriteTile(TIFF* tif,
tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
{
if (!TIFFCheckTile(tif, x, y, z, s))
return (-1);
/*
* NB: A tile size of -1 is used instead of tif_tilesize knowing
* that TIFFWriteEncodedTile will clamp this to the tile size.
* This is done because the tile size may not be defined until
* after the output buffer is setup in TIFFWriteBufferSetup.
*/
return (TIFFWriteEncodedTile(tif,
TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
}
/*
* Encode the supplied data and write it to the
* specified tile. There must be space for the
* data. The function clamps individual writes
* to a tile to the tile size, but does not (and
* can not) check that multiple writes to the same
* tile do not write more than tile size data.
*
* NB: Image length must be setup before writing; this
* interface does not support automatically growing
* the image on each write (as TIFFWriteScanline does).
*/
tsize_t
TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
{
static const char module[] = "TIFFWriteEncodedTile";
TIFFDirectory *td;
tsample_t sample;
if (!WRITECHECKTILES(tif, module))
return ((tsize_t) -1);
td = &tif->tif_dir;
if (tile >= td->td_nstrips) {
TIFFError(module, "%s: Tile %lu out of range, max %lu",
tif->tif_name, (u_long) tile, (u_long) td->td_nstrips);
return ((tsize_t) -1);
}
/*
* Handle delayed allocation of data buffer. This
* permits it to be sized more intelligently (using
* directory information).
*/
if (!BUFFERCHECK(tif))
return ((tsize_t) -1);
tif->tif_curtile = tile;
#ifdef REWRITE_HACK
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
if( td->td_stripbytecount[tile] > 0 )
{
/* if we are writing over existing tiles, zero length. */
td->td_stripbytecount[tile] = 0;
/* this forces TIFFAppendToStrip() to do a seek */
tif->tif_curoff = 0;
}
#endif
/*
* Compute tiles per row & per column to compute
* current row and column
*/
tif->tif_row = (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength))
* td->td_tilelength;
tif->tif_col = (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth))
* td->td_tilewidth;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
if (!(*tif->tif_setupencode)(tif))
return ((tsize_t) -1);
tif->tif_flags |= TIFF_CODERSETUP;
}
tif->tif_flags &= ~TIFF_POSTENCODE;
sample = (tsample_t)(tile/td->td_stripsperimage);
if (!(*tif->tif_preencode)(tif, sample))
return ((tsize_t) -1);
/*
* Clamp write amount to the tile size. This is mostly
* done so that callers can pass in some large number
* (e.g. -1) and have the tile size used instead.
*/
if ( cc < 1 || cc > tif->tif_tilesize)
cc = tif->tif_tilesize;
if (!(*tif->tif_encodetile)(tif, (tidata_t) data, cc, sample))
return ((tsize_t) 0);
if (!(*tif->tif_postencode)(tif))
return ((tsize_t) -1);
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((u_char *)tif->tif_rawdata, tif->tif_rawcc);
if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, tile,
tif->tif_rawdata, tif->tif_rawcc))
return ((tsize_t) -1);
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
return (cc);
}
/*
* Write the supplied data to the specified strip.
* There must be space for the data; we don't check
* if strips overlap!
*
* NB: Image length must be setup before writing; this
* interface does not support automatically growing
* the image on each write (as TIFFWriteScanline does).
*/
tsize_t
TIFFWriteRawTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
{
static const char module[] = "TIFFWriteRawTile";
if (!WRITECHECKTILES(tif, module))
return ((tsize_t) -1);
if (tile >= tif->tif_dir.td_nstrips) {
TIFFError(module, "%s: Tile %lu out of range, max %lu",
tif->tif_name, (u_long) tile,
(u_long) tif->tif_dir.td_nstrips);
return ((tsize_t) -1);
}
return (TIFFAppendToStrip(tif, tile, (tidata_t) data, cc) ?
cc : (tsize_t) -1);
}
#define isUnspecified(tif, f) \
(TIFFFieldSet(tif,f) && (tif)->tif_dir.td_imagelength == 0)
int
TIFFSetupStrips(TIFF* tif)
{
TIFFDirectory* td = &tif->tif_dir;
if (isTiled(tif))
td->td_stripsperimage =
isUnspecified(tif, FIELD_TILEDIMENSIONS) ?
td->td_samplesperpixel : TIFFNumberOfTiles(tif);
else
td->td_stripsperimage =
isUnspecified(tif, FIELD_ROWSPERSTRIP) ?
td->td_samplesperpixel : TIFFNumberOfStrips(tif);
td->td_nstrips = td->td_stripsperimage;
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
td->td_stripsperimage /= td->td_samplesperpixel;
td->td_stripoffset = (uint32 *)
_TIFFmalloc(td->td_nstrips * sizeof (uint32));
td->td_stripbytecount = (uint32 *)
_TIFFmalloc(td->td_nstrips * sizeof (uint32));
if (td->td_stripoffset == NULL || td->td_stripbytecount == NULL)
return (0);
/*
* Place data at the end-of-file
* (by setting offsets to zero).
*/
_TIFFmemset(td->td_stripoffset, 0, td->td_nstrips*sizeof (uint32));
_TIFFmemset(td->td_stripbytecount, 0, td->td_nstrips*sizeof (uint32));
TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
return (1);
}
#undef isUnspecified
/*
* Verify file is writable and that the directory
* information is setup properly. In doing the latter
* we also "freeze" the state of the directory so
* that important information is not changed.
*/
int
TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
{
if (tif->tif_mode == O_RDONLY) {
TIFFError(module, "%s: File not open for writing",
tif->tif_name);
return (0);
}
if (tiles ^ isTiled(tif)) {
TIFFError(tif->tif_name, tiles ?
"Can not write tiles to a stripped image" :
"Can not write scanlines to a tiled image");
return (0);
}
/*
* While we allow compressed TIFF files to be opened in update mode,
* we don't allow writing any image blocks in an existing compressed
* image. Eventually we could do so, by moving blocks that grow
* to the end of the file, but we don't for now.
*/
if (tif->tif_dir.td_stripoffset != NULL
&& tif->tif_dir.td_compression != COMPRESSION_NONE )
{
TIFFError( module,
"%s:\n"
"In place update to compressed TIFF images not "
"supported.",
tif->tif_name );
return (0);
}
/*
* On the first write verify all the required information
* has been setup and initialize any data structures that
* had to wait until directory information was set.
* Note that a lot of our work is assumed to remain valid
* because we disallow any of the important parameters
* from changing after we start writing (i.e. once
* TIFF_BEENWRITING is set, TIFFSetField will only allow
* the image's length to be changed).
*/
if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
TIFFError(module,
"%s: Must set \"ImageWidth\" before writing data",
tif->tif_name);
return (0);
}
if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
TIFFError(module,
"%s: Must set \"PlanarConfiguration\" before writing data",
tif->tif_name);
return (0);
}
if (tif->tif_dir.td_stripoffset == NULL && !TIFFSetupStrips(tif)) {
tif->tif_dir.td_nstrips = 0;
TIFFError(module, "%s: No space for %s arrays",
tif->tif_name, isTiled(tif) ? "tile" : "strip");
return (0);
}
tif->tif_tilesize = TIFFTileSize(tif);
tif->tif_scanlinesize = TIFFScanlineSize(tif);
tif->tif_flags |= TIFF_BEENWRITING;
return (1);
}
/*
* Setup the raw data buffer used for encoding.
*/
int
TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
{
static const char module[] = "TIFFWriteBufferSetup";
if (tif->tif_rawdata) {
if (tif->tif_flags & TIFF_MYBUFFER) {
_TIFFfree(tif->tif_rawdata);
tif->tif_flags &= ~TIFF_MYBUFFER;
}
tif->tif_rawdata = NULL;
}
if (size == (tsize_t) -1) {
size = (isTiled(tif) ?
tif->tif_tilesize : tif->tif_scanlinesize);
/*
* Make raw data buffer at least 8K
*/
if (size < 8*1024)
size = 8*1024;
bp = NULL; /* NB: force malloc */
}
if (bp == NULL) {
bp = _TIFFmalloc(size);
if (bp == NULL) {
TIFFError(module, "%s: No space for output buffer",
tif->tif_name);
return (0);
}
tif->tif_flags |= TIFF_MYBUFFER;
} else
tif->tif_flags &= ~TIFF_MYBUFFER;
tif->tif_rawdata = (tidata_t) bp;
tif->tif_rawdatasize = size;
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
tif->tif_flags |= TIFF_BUFFERSETUP;
return (1);
}
/*
* Grow the strip data structures by delta strips.
*/
static int
TIFFGrowStrips(TIFF* tif, int delta, const char* module)
{
TIFFDirectory *td = &tif->tif_dir;
assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
td->td_stripoffset = (uint32*)_TIFFrealloc(td->td_stripoffset,
(td->td_nstrips + delta) * sizeof (uint32));
td->td_stripbytecount = (uint32*)_TIFFrealloc(td->td_stripbytecount,
(td->td_nstrips + delta) * sizeof (uint32));
if (td->td_stripoffset == NULL || td->td_stripbytecount == NULL) {
td->td_nstrips = 0;
TIFFError(module, "%s: No space to expand strip arrays",
tif->tif_name);
return (0);
}
_TIFFmemset(td->td_stripoffset+td->td_nstrips, 0, delta*sizeof (uint32));
_TIFFmemset(td->td_stripbytecount+td->td_nstrips, 0, delta*sizeof (uint32));
td->td_nstrips += delta;
return (1);
}
/*
* Append the data to the specified strip.
*
* NB: We don't check that there's space in the
* file (i.e. that strips do not overlap).
*/
static int
TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc)
{
TIFFDirectory *td = &tif->tif_dir;
static const char module[] = "TIFFAppendToStrip";
if (td->td_stripoffset[strip] == 0 || tif->tif_curoff == 0) {
/*
* No current offset, set the current strip.
*/
if (td->td_stripoffset[strip] != 0) {
if (!SeekOK(tif, td->td_stripoffset[strip])) {
TIFFError(module,
"%s: Seek error at scanline %lu",
tif->tif_name, (u_long) tif->tif_row);
return (0);
}
} else
td->td_stripoffset[strip] =
TIFFSeekFile(tif, (toff_t) 0, SEEK_END);
tif->tif_curoff = td->td_stripoffset[strip];
}
if (!WriteOK(tif, data, cc)) {
TIFFError(module, "%s: Write error at scanline %lu",
tif->tif_name, (u_long) tif->tif_row);
return (0);
}
tif->tif_curoff += cc;
td->td_stripbytecount[strip] += cc;
return (1);
}
/*
* Internal version of TIFFFlushData that can be
* called by ``encodestrip routines'' w/o concern
* for infinite recursion.
*/
int
TIFFFlushData1(TIFF* tif)
{
if (tif->tif_rawcc > 0) {
if (!isFillOrder(tif, tif->tif_dir.td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((u_char *)tif->tif_rawdata,
tif->tif_rawcc);
if (!TIFFAppendToStrip(tif,
isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,
tif->tif_rawdata, tif->tif_rawcc))
return (0);
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
}
return (1);
}
/*
* Set the current write offset. This should only be
* used to set the offset to a known previous location
* (very carefully), or to 0 so that the next write gets
* appended to the end of the file.
*/
void
TIFFSetWriteOffset(TIFF* tif, toff_t off)
{
tif->tif_curoff = off;
}
src/add-ons/translators/libtifftranslator/tif_zip.c
+367
View File
@@ -0,0 +1,367 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tif_zip.c,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1995-1997 Sam Leffler
* Copyright (c) 1995-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include "tiffiop.h"
#ifdef ZIP_SUPPORT
/*
* TIFF Library.
*
* ZIP (aka Deflate) Compression Support
*
* This file is simply an interface to the zlib library written by
* Jean-loup Gailly and Mark Adler. You must use version 1.0 or later
* of the library: this code assumes the 1.0 API and also depends on
* the ability to write the zlib header multiple times (one per strip)
* which was not possible with versions prior to 0.95. Note also that
* older versions of this codec avoided this bug by supressing the header
* entirely. This means that files written with the old library cannot
* be read; they should be converted to a different compression scheme
* and then reconverted.
*
* The data format used by the zlib library is described in the files
* zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available in the
* directory ftp://ftp.uu.net/pub/archiving/zip/doc. The library was
* last found at ftp://ftp.uu.net/pub/archiving/zip/zlib/zlib-0.99.tar.gz.
*/
#include "tif_predict.h"
#include "zlib.h"
#include <stdio.h>
#include <assert.h>
/*
* Sigh, ZLIB_VERSION is defined as a string so there's no
* way to do a proper check here. Instead we guess based
* on the presence of #defines that were added between the
* 0.95 and 1.0 distributions.
*/
#if !defined(Z_NO_COMPRESSION) || !defined(Z_DEFLATED)
#error "Antiquated ZLIB software; you must use version 1.0 or later"
#endif
/*
* State block for each open TIFF
* file using ZIP compression/decompression.
*/
typedef struct {
TIFFPredictorState predict;
z_stream stream;
int zipquality; /* compression level */
int state; /* state flags */
#define ZSTATE_INIT 0x1 /* zlib setup successfully */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
} ZIPState;
#define ZState(tif) ((ZIPState*) (tif)->tif_data)
#define DecoderState(tif) ZState(tif)
#define EncoderState(tif) ZState(tif)
static int ZIPEncode(TIFF*, tidata_t, tsize_t, tsample_t);
static int ZIPDecode(TIFF*, tidata_t, tsize_t, tsample_t);
static int
ZIPSetupDecode(TIFF* tif)
{
ZIPState* sp = DecoderState(tif);
static const char module[] = "ZIPSetupDecode";
assert(sp != NULL);
if (inflateInit(&sp->stream) != Z_OK) {
TIFFError(module, "%s: %s", tif->tif_name, sp->stream.msg);
return (0);
} else {
sp->state |= ZSTATE_INIT;
return (1);
}
}
/*
* Setup state for decoding a strip.
*/
static int
ZIPPreDecode(TIFF* tif, tsample_t s)
{
ZIPState* sp = DecoderState(tif);
(void) s;
assert(sp != NULL);
sp->stream.next_in = tif->tif_rawdata;
sp->stream.avail_in = tif->tif_rawcc;
return (inflateReset(&sp->stream) == Z_OK);
}
static int
ZIPDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
{
ZIPState* sp = DecoderState(tif);
static const char module[] = "ZIPDecode";
(void) s;
assert(sp != NULL);
sp->stream.next_out = op;
sp->stream.avail_out = occ;
do {
int state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
if (state == Z_STREAM_END)
break;
if (state == Z_DATA_ERROR) {
TIFFError(module,
"%s: Decoding error at scanline %d, %s",
tif->tif_name, tif->tif_row, sp->stream.msg);
if (inflateSync(&sp->stream) != Z_OK)
return (0);
continue;
}
if (state != Z_OK) {
TIFFError(module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
return (0);
}
} while (sp->stream.avail_out > 0);
if (sp->stream.avail_out != 0) {
TIFFError(module,
"%s: Not enough data at scanline %d (short %d bytes)",
tif->tif_name, tif->tif_row, sp->stream.avail_out);
return (0);
}
return (1);
}
static int
ZIPSetupEncode(TIFF* tif)
{
ZIPState* sp = EncoderState(tif);
static const char module[] = "ZIPSetupEncode";
assert(sp != NULL);
if (deflateInit(&sp->stream, sp->zipquality) != Z_OK) {
TIFFError(module, "%s: %s", tif->tif_name, sp->stream.msg);
return (0);
} else {
sp->state |= ZSTATE_INIT;
return (1);
}
}
/*
* Reset encoding state at the start of a strip.
*/
static int
ZIPPreEncode(TIFF* tif, tsample_t s)
{
ZIPState *sp = EncoderState(tif);
(void) s;
assert(sp != NULL);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
return (deflateReset(&sp->stream) == Z_OK);
}
/*
* Encode a chunk of pixels.
*/
static int
ZIPEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
{
ZIPState *sp = EncoderState(tif);
static const char module[] = "ZIPEncode";
(void) s;
sp->stream.next_in = bp;
sp->stream.avail_in = cc;
do {
if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) {
TIFFError(module, "%s: Encoder error: %s",
tif->tif_name, sp->stream.msg);
return (0);
}
if (sp->stream.avail_out == 0) {
tif->tif_rawcc = tif->tif_rawdatasize;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
}
} while (sp->stream.avail_in > 0);
return (1);
}
/*
* Finish off an encoded strip by flushing the last
* string and tacking on an End Of Information code.
*/
static int
ZIPPostEncode(TIFF* tif)
{
ZIPState *sp = EncoderState(tif);
static const char module[] = "ZIPPostEncode";
int state;
sp->stream.avail_in = 0;
do {
state = deflate(&sp->stream, Z_FINISH);
switch (state) {
case Z_STREAM_END:
case Z_OK:
if (sp->stream.avail_out != tif->tif_rawdatasize) {
tif->tif_rawcc =
tif->tif_rawdatasize - sp->stream.avail_out;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
}
break;
default:
TIFFError(module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
return (0);
}
} while (state != Z_STREAM_END);
return (1);
}
static void
ZIPCleanup(TIFF* tif)
{
ZIPState* sp = ZState(tif);
if (sp) {
if (sp->state&ZSTATE_INIT) {
/* NB: avoid problems in the library */
if (tif->tif_mode == O_RDONLY)
inflateEnd(&sp->stream);
else
deflateEnd(&sp->stream);
}
_TIFFfree(sp);
tif->tif_data = NULL;
}
}
static int
ZIPVSetField(TIFF* tif, ttag_t tag, va_list ap)
{
ZIPState* sp = ZState(tif);
static const char module[] = "ZIPVSetField";
switch (tag) {
case TIFFTAG_ZIPQUALITY:
sp->zipquality = va_arg(ap, int);
if (tif->tif_mode != O_RDONLY && (sp->state&ZSTATE_INIT)) {
if (deflateParams(&sp->stream,
sp->zipquality, Z_DEFAULT_STRATEGY) != Z_OK) {
TIFFError(module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
return (0);
}
}
return (1);
default:
return (*sp->vsetparent)(tif, tag, ap);
}
/*NOTREACHED*/
}
static int
ZIPVGetField(TIFF* tif, ttag_t tag, va_list ap)
{
ZIPState* sp = ZState(tif);
switch (tag) {
case TIFFTAG_ZIPQUALITY:
*va_arg(ap, int*) = sp->zipquality;
break;
default:
return (*sp->vgetparent)(tif, tag, ap);
}
return (1);
}
static const TIFFFieldInfo zipFieldInfo[] = {
{ TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO,
TRUE, FALSE, "" },
};
#define N(a) (sizeof (a) / sizeof (a[0]))
int
TIFFInitZIP(TIFF* tif, int scheme)
{
ZIPState* sp;
assert( (scheme == COMPRESSION_DEFLATE) || (scheme == COMPRESSION_ADOBE_DEFLATE));
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (ZIPState));
if (tif->tif_data == NULL)
goto bad;
sp = ZState(tif);
sp->stream.zalloc = NULL;
sp->stream.zfree = NULL;
sp->stream.opaque = NULL;
sp->stream.data_type = Z_BINARY;
/*
* Merge codec-specific tag information and
* override parent get/set field methods.
*/
_TIFFMergeFieldInfo(tif, zipFieldInfo, N(zipFieldInfo));
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = ZIPVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield = ZIPVSetField; /* hook for codec tags */
/* Default values for codec-specific fields */
sp->zipquality = Z_DEFAULT_COMPRESSION; /* default comp. level */
sp->state = 0;
/*
* Install codec methods.
*/
tif->tif_setupdecode = ZIPSetupDecode;
tif->tif_predecode = ZIPPreDecode;
tif->tif_decoderow = ZIPDecode;
tif->tif_decodestrip = ZIPDecode;
tif->tif_decodetile = ZIPDecode;
tif->tif_setupencode = ZIPSetupEncode;
tif->tif_preencode = ZIPPreEncode;
tif->tif_postencode = ZIPPostEncode;
tif->tif_encoderow = ZIPEncode;
tif->tif_encodestrip = ZIPEncode;
tif->tif_encodetile = ZIPEncode;
tif->tif_cleanup = ZIPCleanup;
/*
* Setup predictor setup.
*/
(void) TIFFPredictorInit(tif);
return (1);
bad:
TIFFError("TIFFInitZIP", "No space for ZIP state block");
return (0);
}
#endif /* ZIP_SUPORT */
src/add-ons/translators/libtifftranslator/tiff.h
+481
View File
@@ -0,0 +1,481 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tiff.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _TIFF_
#define _TIFF_
/*
* Tag Image File Format (TIFF)
*
* Based on Rev 6.0 from:
* Developer's Desk
* Aldus Corporation
* 411 First Ave. South
* Suite 200
* Seattle, WA 98104
* 206-622-5500
*/
#define TIFF_VERSION 42
#define TIFF_BIGENDIAN 0x4d4d
#define TIFF_LITTLEENDIAN 0x4949
/*
* The so called TIFF types conflict with definitions from inttypes.h
* included from sys/types.h on AIX (at least using VisualAge compiler).
* We try to work around this by detecting this case. Defining
* _TIFF_DATA_TYPEDEFS_ short circuits the later definitions in tiff.h, and
* we will in the holes not provided for by inttypes.h.
*
* See http://bugzilla.remotesensing.org/show_bug.cgi?id=39
*/
#if defined(_H_INTTYPES) && defined(_ALL_SOURCE) && defined(USING_VISUALAGE)
#define _TIFF_DATA_TYPEDEFS_
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
#endif
/*
* Intrinsic data types required by the file format:
*
* 8-bit quantities int8/uint8
* 16-bit quantities int16/uint16
* 32-bit quantities int32/uint32
* strings unsigned char*
*/
#ifndef _TIFF_DATA_TYPEDEFS_
#define _TIFF_DATA_TYPEDEFS_
#ifdef __STDC__
typedef signed char int8; /* NB: non-ANSI compilers may not grok */
#else
typedef char int8;
#endif
typedef unsigned char uint8;
typedef short int16;
typedef unsigned short uint16; /* sizeof (uint16) must == 2 */
#if defined(__alpha) || (defined(_MIPS_SZLONG) && _MIPS_SZLONG == 64) || defined(__LP64__) || defined(__arch64__)
typedef int int32;
typedef unsigned int uint32; /* sizeof (uint32) must == 4 */
#else
typedef long int32;
typedef unsigned long uint32; /* sizeof (uint32) must == 4 */
#endif
#endif /* _TIFF_DATA_TYPEDEFS_ */
/* For TIFFReassignTagToIgnore */
enum TIFFIgnoreSense /* IGNORE tag table */
{
TIS_STORE,
TIS_EXTRACT,
TIS_EMPTY
};
typedef struct {
uint16 tiff_magic; /* magic number (defines byte order) */
uint16 tiff_version; /* TIFF version number */
uint32 tiff_diroff; /* byte offset to first directory */
} TIFFHeader;
/*
* TIFF Image File Directories are comprised of
* a table of field descriptors of the form shown
* below. The table is sorted in ascending order
* by tag. The values associated with each entry
* are disjoint and may appear anywhere in the file
* (so long as they are placed on a word boundary).
*
* If the value is 4 bytes or less, then it is placed
* in the offset field to save space. If the value
* is less than 4 bytes, it is left-justified in the
* offset field.
*/
typedef struct {
uint16 tdir_tag; /* see below */
uint16 tdir_type; /* data type; see below */
uint32 tdir_count; /* number of items; length in spec */
uint32 tdir_offset; /* byte offset to field data */
} TIFFDirEntry;
/*
* NB: In the comments below,
* - items marked with a + are obsoleted by revision 5.0,
* - items marked with a ! are introduced in revision 6.0.
* - items marked with a % are introduced post revision 6.0.
* - items marked with a $ are obsoleted by revision 6.0.
*/
/*
* Tag data type information.
*
* Note: RATIONALs are the ratio of two 32-bit integer values.
*/
typedef enum {
TIFF_NOTYPE = 0, /* placeholder */
TIFF_BYTE = 1, /* 8-bit unsigned integer */
TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */
TIFF_SHORT = 3, /* 16-bit unsigned integer */
TIFF_LONG = 4, /* 32-bit unsigned integer */
TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */
TIFF_SBYTE = 6, /* !8-bit signed integer */
TIFF_UNDEFINED = 7, /* !8-bit untyped data */
TIFF_SSHORT = 8, /* !16-bit signed integer */
TIFF_SLONG = 9, /* !32-bit signed integer */
TIFF_SRATIONAL = 10, /* !64-bit signed fraction */
TIFF_FLOAT = 11, /* !32-bit IEEE floating point */
TIFF_DOUBLE = 12 /* !64-bit IEEE floating point */
} TIFFDataType;
/*
* TIFF Tag Definitions.
*/
#define TIFFTAG_SUBFILETYPE 254 /* subfile data descriptor */
#define FILETYPE_REDUCEDIMAGE 0x1 /* reduced resolution version */
#define FILETYPE_PAGE 0x2 /* one page of many */
#define FILETYPE_MASK 0x4 /* transparency mask */
#define TIFFTAG_OSUBFILETYPE 255 /* +kind of data in subfile */
#define OFILETYPE_IMAGE 1 /* full resolution image data */
#define OFILETYPE_REDUCEDIMAGE 2 /* reduced size image data */
#define OFILETYPE_PAGE 3 /* one page of many */
#define TIFFTAG_IMAGEWIDTH 256 /* image width in pixels */
#define TIFFTAG_IMAGELENGTH 257 /* image height in pixels */
#define TIFFTAG_BITSPERSAMPLE 258 /* bits per channel (sample) */
#define TIFFTAG_COMPRESSION 259 /* data compression technique */
#define COMPRESSION_NONE 1 /* dump mode */
#define COMPRESSION_CCITTRLE 2 /* CCITT modified Huffman RLE */
#define COMPRESSION_CCITTFAX3 3 /* CCITT Group 3 fax encoding */
#define COMPRESSION_CCITT_T4 3 /* CCITT T.4 (TIFF 6 name) */
#define COMPRESSION_CCITTFAX4 4 /* CCITT Group 4 fax encoding */
#define COMPRESSION_CCITT_T6 4 /* CCITT T.6 (TIFF 6 name) */
#define COMPRESSION_LZW 5 /* Lempel-Ziv & Welch */
#define COMPRESSION_OJPEG 6 /* !6.0 JPEG */
#define COMPRESSION_JPEG 7 /* %JPEG DCT compression */
#define COMPRESSION_NEXT 32766 /* NeXT 2-bit RLE */
#define COMPRESSION_CCITTRLEW 32771 /* #1 w/ word alignment */
#define COMPRESSION_PACKBITS 32773 /* Macintosh RLE */
#define COMPRESSION_THUNDERSCAN 32809 /* ThunderScan RLE */
/* codes 32895-32898 are reserved for ANSI IT8 TIFF/IT <[email protected]) */
#define COMPRESSION_IT8CTPAD 32895 /* IT8 CT w/padding */
#define COMPRESSION_IT8LW 32896 /* IT8 Linework RLE */
#define COMPRESSION_IT8MP 32897 /* IT8 Monochrome picture */
#define COMPRESSION_IT8BL 32898 /* IT8 Binary line art */
/* compression codes 32908-32911 are reserved for Pixar */
#define COMPRESSION_PIXARFILM 32908 /* Pixar companded 10bit LZW */
#define COMPRESSION_PIXARLOG 32909 /* Pixar companded 11bit ZIP */
#define COMPRESSION_DEFLATE 32946 /* Deflate compression */
#define COMPRESSION_ADOBE_DEFLATE 8 /* Deflate compression, as recognized by Adobe */
/* compression code 32947 is reserved for Oceana Matrix <[email protected]> */
#define COMPRESSION_DCS 32947 /* Kodak DCS encoding */
#define COMPRESSION_JBIG 34661 /* ISO JBIG */
#define COMPRESSION_SGILOG 34676 /* SGI Log Luminance RLE */
#define COMPRESSION_SGILOG24 34677 /* SGI Log 24-bit packed */
#define COMPRESSION_JP2000 34712 /* Leadtools JPEG2000 */
#define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */
#define PHOTOMETRIC_MINISWHITE 0 /* min value is white */
#define PHOTOMETRIC_MINISBLACK 1 /* min value is black */
#define PHOTOMETRIC_RGB 2 /* RGB color model */
#define PHOTOMETRIC_PALETTE 3 /* color map indexed */
#define PHOTOMETRIC_MASK 4 /* $holdout mask */
#define PHOTOMETRIC_SEPARATED 5 /* !color separations */
#define PHOTOMETRIC_YCBCR 6 /* !CCIR 601 */
#define PHOTOMETRIC_CIELAB 8 /* !1976 CIE L*a*b* */
#define PHOTOMETRIC_ICCLAB 9 /* ICC L*a*b* [Adobe TIFF Technote 4] */
#define PHOTOMETRIC_ITULAB 10 /* ITU L*a*b* */
#define PHOTOMETRIC_LOGL 32844 /* CIE Log2(L) */
#define PHOTOMETRIC_LOGLUV 32845 /* CIE Log2(L) (u',v') */
#define TIFFTAG_THRESHHOLDING 263 /* +thresholding used on data */
#define THRESHHOLD_BILEVEL 1 /* b&w art scan */
#define THRESHHOLD_HALFTONE 2 /* or dithered scan */
#define THRESHHOLD_ERRORDIFFUSE 3 /* usually floyd-steinberg */
#define TIFFTAG_CELLWIDTH 264 /* +dithering matrix width */
#define TIFFTAG_CELLLENGTH 265 /* +dithering matrix height */
#define TIFFTAG_FILLORDER 266 /* data order within a byte */
#define FILLORDER_MSB2LSB 1 /* most significant -> least */
#define FILLORDER_LSB2MSB 2 /* least significant -> most */
#define TIFFTAG_DOCUMENTNAME 269 /* name of doc. image is from */
#define TIFFTAG_IMAGEDESCRIPTION 270 /* info about image */
#define TIFFTAG_MAKE 271 /* scanner manufacturer name */
#define TIFFTAG_MODEL 272 /* scanner model name/number */
#define TIFFTAG_STRIPOFFSETS 273 /* offsets to data strips */
#define TIFFTAG_ORIENTATION 274 /* +image orientation */
#define ORIENTATION_TOPLEFT 1 /* row 0 top, col 0 lhs */
#define ORIENTATION_TOPRIGHT 2 /* row 0 top, col 0 rhs */
#define ORIENTATION_BOTRIGHT 3 /* row 0 bottom, col 0 rhs */
#define ORIENTATION_BOTLEFT 4 /* row 0 bottom, col 0 lhs */
#define ORIENTATION_LEFTTOP 5 /* row 0 lhs, col 0 top */
#define ORIENTATION_RIGHTTOP 6 /* row 0 rhs, col 0 top */
#define ORIENTATION_RIGHTBOT 7 /* row 0 rhs, col 0 bottom */
#define ORIENTATION_LEFTBOT 8 /* row 0 lhs, col 0 bottom */
#define TIFFTAG_SAMPLESPERPIXEL 277 /* samples per pixel */
#define TIFFTAG_ROWSPERSTRIP 278 /* rows per strip of data */
#define TIFFTAG_STRIPBYTECOUNTS 279 /* bytes counts for strips */
#define TIFFTAG_MINSAMPLEVALUE 280 /* +minimum sample value */
#define TIFFTAG_MAXSAMPLEVALUE 281 /* +maximum sample value */
#define TIFFTAG_XRESOLUTION 282 /* pixels/resolution in x */
#define TIFFTAG_YRESOLUTION 283 /* pixels/resolution in y */
#define TIFFTAG_PLANARCONFIG 284 /* storage organization */
#define PLANARCONFIG_CONTIG 1 /* single image plane */
#define PLANARCONFIG_SEPARATE 2 /* separate planes of data */
#define TIFFTAG_PAGENAME 285 /* page name image is from */
#define TIFFTAG_XPOSITION 286 /* x page offset of image lhs */
#define TIFFTAG_YPOSITION 287 /* y page offset of image lhs */
#define TIFFTAG_FREEOFFSETS 288 /* +byte offset to free block */
#define TIFFTAG_FREEBYTECOUNTS 289 /* +sizes of free blocks */
#define TIFFTAG_GRAYRESPONSEUNIT 290 /* $gray scale curve accuracy */
#define GRAYRESPONSEUNIT_10S 1 /* tenths of a unit */
#define GRAYRESPONSEUNIT_100S 2 /* hundredths of a unit */
#define GRAYRESPONSEUNIT_1000S 3 /* thousandths of a unit */
#define GRAYRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */
#define GRAYRESPONSEUNIT_100000S 5 /* hundred-thousandths */
#define TIFFTAG_GRAYRESPONSECURVE 291 /* $gray scale response curve */
#define TIFFTAG_GROUP3OPTIONS 292 /* 32 flag bits */
#define TIFFTAG_T4OPTIONS 292 /* TIFF 6.0 proper name alias */
#define GROUP3OPT_2DENCODING 0x1 /* 2-dimensional coding */
#define GROUP3OPT_UNCOMPRESSED 0x2 /* data not compressed */
#define GROUP3OPT_FILLBITS 0x4 /* fill to byte boundary */
#define TIFFTAG_GROUP4OPTIONS 293 /* 32 flag bits */
#define TIFFTAG_T6OPTIONS 293 /* TIFF 6.0 proper name */
#define GROUP4OPT_UNCOMPRESSED 0x2 /* data not compressed */
#define TIFFTAG_RESOLUTIONUNIT 296 /* units of resolutions */
#define RESUNIT_NONE 1 /* no meaningful units */
#define RESUNIT_INCH 2 /* english */
#define RESUNIT_CENTIMETER 3 /* metric */
#define TIFFTAG_PAGENUMBER 297 /* page numbers of multi-page */
#define TIFFTAG_COLORRESPONSEUNIT 300 /* $color curve accuracy */
#define COLORRESPONSEUNIT_10S 1 /* tenths of a unit */
#define COLORRESPONSEUNIT_100S 2 /* hundredths of a unit */
#define COLORRESPONSEUNIT_1000S 3 /* thousandths of a unit */
#define COLORRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */
#define COLORRESPONSEUNIT_100000S 5 /* hundred-thousandths */
#define TIFFTAG_TRANSFERFUNCTION 301 /* !colorimetry info */
#define TIFFTAG_SOFTWARE 305 /* name & release */
#define TIFFTAG_DATETIME 306 /* creation date and time */
#define TIFFTAG_ARTIST 315 /* creator of image */
#define TIFFTAG_HOSTCOMPUTER 316 /* machine where created */
#define TIFFTAG_PREDICTOR 317 /* prediction scheme w/ LZW */
#define TIFFTAG_WHITEPOINT 318 /* image white point */
#define TIFFTAG_PRIMARYCHROMATICITIES 319 /* !primary chromaticities */
#define TIFFTAG_COLORMAP 320 /* RGB map for pallette image */
#define TIFFTAG_HALFTONEHINTS 321 /* !highlight+shadow info */
#define TIFFTAG_TILEWIDTH 322 /* !rows/data tile */
#define TIFFTAG_TILELENGTH 323 /* !cols/data tile */
#define TIFFTAG_TILEOFFSETS 324 /* !offsets to data tiles */
#define TIFFTAG_TILEBYTECOUNTS 325 /* !byte counts for tiles */
#define TIFFTAG_BADFAXLINES 326 /* lines w/ wrong pixel count */
#define TIFFTAG_CLEANFAXDATA 327 /* regenerated line info */
#define CLEANFAXDATA_CLEAN 0 /* no errors detected */
#define CLEANFAXDATA_REGENERATED 1 /* receiver regenerated lines */
#define CLEANFAXDATA_UNCLEAN 2 /* uncorrected errors exist */
#define TIFFTAG_CONSECUTIVEBADFAXLINES 328 /* max consecutive bad lines */
#define TIFFTAG_SUBIFD 330 /* subimage descriptors */
#define TIFFTAG_INKSET 332 /* !inks in separated image */
#define INKSET_CMYK 1 /* !cyan-magenta-yellow-black color */
#define INKSET_MULTIINK 2 /* !multi-ink or hi-fi color */
#define TIFFTAG_INKNAMES 333 /* !ascii names of inks */
#define TIFFTAG_NUMBEROFINKS 334 /* !number of inks */
#define TIFFTAG_DOTRANGE 336 /* !0% and 100% dot codes */
#define TIFFTAG_TARGETPRINTER 337 /* !separation target */
#define TIFFTAG_EXTRASAMPLES 338 /* !info about extra samples */
#define EXTRASAMPLE_UNSPECIFIED 0 /* !unspecified data */
#define EXTRASAMPLE_ASSOCALPHA 1 /* !associated alpha data */
#define EXTRASAMPLE_UNASSALPHA 2 /* !unassociated alpha data */
#define TIFFTAG_SAMPLEFORMAT 339 /* !data sample format */
#define SAMPLEFORMAT_UINT 1 /* !unsigned integer data */
#define SAMPLEFORMAT_INT 2 /* !signed integer data */
#define SAMPLEFORMAT_IEEEFP 3 /* !IEEE floating point data */
#define SAMPLEFORMAT_VOID 4 /* !untyped data */
#define SAMPLEFORMAT_COMPLEXINT 5 /* !complex signed int */
#define SAMPLEFORMAT_COMPLEXIEEEFP 6 /* !complex ieee floating */
#define TIFFTAG_SMINSAMPLEVALUE 340 /* !variable MinSampleValue */
#define TIFFTAG_SMAXSAMPLEVALUE 341 /* !variable MaxSampleValue */
#define TIFFTAG_CLIPPATH 343 /* %ClipPath [Adobe TIFF technote 2] */
#define TIFFTAG_XCLIPPATHUNITS 344 /* %XClipPathUnits [Adobe TIFF technote 2] */
#define TIFFTAG_YCLIPPATHUNITS 344 /* %YClipPathUnits [Adobe TIFF technote 2] */
#define TIFFTAG_INDEXED 345 /* %Indexed [Adobe TIFF Technote 3] */
#define TIFFTAG_JPEGTABLES 347 /* %JPEG table stream */
#define TIFFTAG_OPIPROXY 351 /* %OPI Proxy [Adobe TIFF technote] */
/*
* Tags 512-521 are obsoleted by Technical Note #2
* which specifies a revised JPEG-in-TIFF scheme.
*/
#define TIFFTAG_JPEGPROC 512 /* !JPEG processing algorithm */
#define JPEGPROC_BASELINE 1 /* !baseline sequential */
#define JPEGPROC_LOSSLESS 14 /* !Huffman coded lossless */
#define TIFFTAG_JPEGIFOFFSET 513 /* !pointer to SOI marker */
#define TIFFTAG_JPEGIFBYTECOUNT 514 /* !JFIF stream length */
#define TIFFTAG_JPEGRESTARTINTERVAL 515 /* !restart interval length */
#define TIFFTAG_JPEGLOSSLESSPREDICTORS 517 /* !lossless proc predictor */
#define TIFFTAG_JPEGPOINTTRANSFORM 518 /* !lossless point transform */
#define TIFFTAG_JPEGQTABLES 519 /* !Q matrice offsets */
#define TIFFTAG_JPEGDCTABLES 520 /* !DCT table offsets */
#define TIFFTAG_JPEGACTABLES 521 /* !AC coefficient offsets */
#define TIFFTAG_YCBCRCOEFFICIENTS 529 /* !RGB -> YCbCr transform */
#define TIFFTAG_YCBCRSUBSAMPLING 530 /* !YCbCr subsampling factors */
#define TIFFTAG_YCBCRPOSITIONING 531 /* !subsample positioning */
#define YCBCRPOSITION_CENTERED 1 /* !as in PostScript Level 2 */
#define YCBCRPOSITION_COSITED 2 /* !as in CCIR 601-1 */
#define TIFFTAG_REFERENCEBLACKWHITE 532 /* !colorimetry info */
#define TIFFTAG_XMLPACKET 700 /* %XML packet [Adobe XMP technote 9-14-02] ([email protected]) */
#define TIFFTAG_OPIIMAGEID 32781 /* %OPI ImageID [Adobe TIFF technote] */
/* tags 32952-32956 are private tags registered to Island Graphics */
#define TIFFTAG_REFPTS 32953 /* image reference points */
#define TIFFTAG_REGIONTACKPOINT 32954 /* region-xform tack point */
#define TIFFTAG_REGIONWARPCORNERS 32955 /* warp quadrilateral */
#define TIFFTAG_REGIONAFFINE 32956 /* affine transformation mat */
/* tags 32995-32999 are private tags registered to SGI */
#define TIFFTAG_MATTEING 32995 /* $use ExtraSamples */
#define TIFFTAG_DATATYPE 32996 /* $use SampleFormat */
#define TIFFTAG_IMAGEDEPTH 32997 /* z depth of image */
#define TIFFTAG_TILEDEPTH 32998 /* z depth/data tile */
/* tags 33300-33309 are private tags registered to Pixar */
/*
* TIFFTAG_PIXAR_IMAGEFULLWIDTH and TIFFTAG_PIXAR_IMAGEFULLLENGTH
* are set when an image has been cropped out of a larger image.
* They reflect the size of the original uncropped image.
* The TIFFTAG_XPOSITION and TIFFTAG_YPOSITION can be used
* to determine the position of the smaller image in the larger one.
*/
#define TIFFTAG_PIXAR_IMAGEFULLWIDTH 33300 /* full image size in x */
#define TIFFTAG_PIXAR_IMAGEFULLLENGTH 33301 /* full image size in y */
/* Tags 33302-33306 are used to identify special image modes and data
* used by Pixar's texture formats.
*/
#define TIFFTAG_PIXAR_TEXTUREFORMAT 33302 /* texture map format */
#define TIFFTAG_PIXAR_WRAPMODES 33303 /* s & t wrap modes */
#define TIFFTAG_PIXAR_FOVCOT 33304 /* cotan(fov) for env. maps */
#define TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN 33305
#define TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA 33306
/* tag 33405 is a private tag registered to Eastman Kodak */
#define TIFFTAG_WRITERSERIALNUMBER 33405 /* device serial number */
/* tag 33432 is listed in the 6.0 spec w/ unknown ownership */
#define TIFFTAG_COPYRIGHT 33432 /* copyright string */
/* IPTC TAG from RichTIFF specifications */
#define TIFFTAG_RICHTIFFIPTC 33723
/* 34016-34029 are reserved for ANSI IT8 TIFF/IT <[email protected]) */
#define TIFFTAG_IT8SITE 34016 /* site name */
#define TIFFTAG_IT8COLORSEQUENCE 34017 /* color seq. [RGB,CMYK,etc] */
#define TIFFTAG_IT8HEADER 34018 /* DDES Header */
#define TIFFTAG_IT8RASTERPADDING 34019 /* raster scanline padding */
#define TIFFTAG_IT8BITSPERRUNLENGTH 34020 /* # of bits in short run */
#define TIFFTAG_IT8BITSPEREXTENDEDRUNLENGTH 34021/* # of bits in long run */
#define TIFFTAG_IT8COLORTABLE 34022 /* LW colortable */
#define TIFFTAG_IT8IMAGECOLORINDICATOR 34023 /* BP/BL image color switch */
#define TIFFTAG_IT8BKGCOLORINDICATOR 34024 /* BP/BL bg color switch */
#define TIFFTAG_IT8IMAGECOLORVALUE 34025 /* BP/BL image color value */
#define TIFFTAG_IT8BKGCOLORVALUE 34026 /* BP/BL bg color value */
#define TIFFTAG_IT8PIXELINTENSITYRANGE 34027 /* MP pixel intensity value */
#define TIFFTAG_IT8TRANSPARENCYINDICATOR 34028 /* HC transparency switch */
#define TIFFTAG_IT8COLORCHARACTERIZATION 34029 /* color character. table */
#define TIFFTAG_IT8HCUSAGE 34030 /* HC usage indicator */
#define TIFFTAG_IT8TRAPINDICATOR 34031 /* Trapping indicator (untrapped=0, trapped=1) */
#define TIFFTAG_IT8CMYKEQUIVALENT 34032 /* CMYK color equivalents */
/* tags 34232-34236 are private tags registered to Texas Instruments */
#define TIFFTAG_FRAMECOUNT 34232 /* Sequence Frame Count */
/* tag 34750 is a private tag registered to Adobe? */
#define TIFFTAG_ICCPROFILE 34675 /* ICC profile data */
/* tag 34377 is private tag registered to Adobe for PhotoShop */
#define TIFFTAG_PHOTOSHOP 34377
/* tag 34750 is a private tag registered to Pixel Magic */
#define TIFFTAG_JBIGOPTIONS 34750 /* JBIG options */
/* tags 34908-34914 are private tags registered to SGI */
#define TIFFTAG_FAXRECVPARAMS 34908 /* encoded Class 2 ses. parms */
#define TIFFTAG_FAXSUBADDRESS 34909 /* received SubAddr string */
#define TIFFTAG_FAXRECVTIME 34910 /* receive time (secs) */
/* tags 37439-37443 are registered to SGI <[email protected]> */
#define TIFFTAG_STONITS 37439 /* Sample value to Nits */
/* tag 34929 is a private tag registered to FedEx */
#define TIFFTAG_FEDEX_EDR 34929 /* unknown use */
/* tag 65535 is an undefined tag used by Eastman Kodak */
#define TIFFTAG_DCSHUESHIFTVALUES 65535 /* hue shift correction data */
/*
* The following are ``pseudo tags'' that can be
* used to control codec-specific functionality.
* These tags are not written to file. Note that
* these values start at 0xffff+1 so that they'll
* never collide with Aldus-assigned tags.
*
* If you want your private pseudo tags ``registered''
* (i.e. added to this file), send mail to sam@sgi.com
* with the appropriate C definitions to add.
*/
#define TIFFTAG_FAXMODE 65536 /* Group 3/4 format control */
#define FAXMODE_CLASSIC 0x0000 /* default, include RTC */
#define FAXMODE_NORTC 0x0001 /* no RTC at end of data */
#define FAXMODE_NOEOL 0x0002 /* no EOL code at end of row */
#define FAXMODE_BYTEALIGN 0x0004 /* byte align row */
#define FAXMODE_WORDALIGN 0x0008 /* word align row */
#define FAXMODE_CLASSF FAXMODE_NORTC /* TIFF Class F */
#define TIFFTAG_JPEGQUALITY 65537 /* Compression quality level */
/* Note: quality level is on the IJG 0-100 scale. Default value is 75 */
#define TIFFTAG_JPEGCOLORMODE 65538 /* Auto RGB<=>YCbCr convert? */
#define JPEGCOLORMODE_RAW 0x0000 /* no conversion (default) */
#define JPEGCOLORMODE_RGB 0x0001 /* do auto conversion */
#define TIFFTAG_JPEGTABLESMODE 65539 /* What to put in JPEGTables */
#define JPEGTABLESMODE_QUANT 0x0001 /* include quantization tbls */
#define JPEGTABLESMODE_HUFF 0x0002 /* include Huffman tbls */
/* Note: default is JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF */
#define TIFFTAG_FAXFILLFUNC 65540 /* G3/G4 fill function */
#define TIFFTAG_PIXARLOGDATAFMT 65549 /* PixarLogCodec I/O data sz */
#define PIXARLOGDATAFMT_8BIT 0 /* regular u_char samples */
#define PIXARLOGDATAFMT_8BITABGR 1 /* ABGR-order u_chars */
#define PIXARLOGDATAFMT_11BITLOG 2 /* 11-bit log-encoded (raw) */
#define PIXARLOGDATAFMT_12BITPICIO 3 /* as per PICIO (1.0==2048) */
#define PIXARLOGDATAFMT_16BIT 4 /* signed short samples */
#define PIXARLOGDATAFMT_FLOAT 5 /* IEEE float samples */
/* 65550-65556 are allocated to Oceana Matrix <[email protected]> */
#define TIFFTAG_DCSIMAGERTYPE 65550 /* imager model & filter */
#define DCSIMAGERMODEL_M3 0 /* M3 chip (1280 x 1024) */
#define DCSIMAGERMODEL_M5 1 /* M5 chip (1536 x 1024) */
#define DCSIMAGERMODEL_M6 2 /* M6 chip (3072 x 2048) */
#define DCSIMAGERFILTER_IR 0 /* infrared filter */
#define DCSIMAGERFILTER_MONO 1 /* monochrome filter */
#define DCSIMAGERFILTER_CFA 2 /* color filter array */
#define DCSIMAGERFILTER_OTHER 3 /* other filter */
#define TIFFTAG_DCSINTERPMODE 65551 /* interpolation mode */
#define DCSINTERPMODE_NORMAL 0x0 /* whole image, default */
#define DCSINTERPMODE_PREVIEW 0x1 /* preview of image (384x256) */
#define TIFFTAG_DCSBALANCEARRAY 65552 /* color balance values */
#define TIFFTAG_DCSCORRECTMATRIX 65553 /* color correction values */
#define TIFFTAG_DCSGAMMA 65554 /* gamma value */
#define TIFFTAG_DCSTOESHOULDERPTS 65555 /* toe & shoulder points */
#define TIFFTAG_DCSCALIBRATIONFD 65556 /* calibration file desc */
/* Note: quality level is on the ZLIB 1-9 scale. Default value is -1 */
#define TIFFTAG_ZIPQUALITY 65557 /* compression quality level */
#define TIFFTAG_PIXARLOGQUALITY 65558 /* PixarLog uses same scale */
/* 65559 is allocated to Oceana Matrix <[email protected]> */
#define TIFFTAG_DCSCLIPRECTANGLE 65559 /* area of image to acquire */
#define TIFFTAG_SGILOGDATAFMT 65560 /* SGILog user data format */
#define SGILOGDATAFMT_FLOAT 0 /* IEEE float samples */
#define SGILOGDATAFMT_16BIT 1 /* 16-bit samples */
#define SGILOGDATAFMT_RAW 2 /* uninterpreted data */
#define SGILOGDATAFMT_8BIT 3 /* 8-bit RGB monitor values */
#define TIFFTAG_SGILOGENCODE 65561 /* SGILog data encoding control*/
#define SGILOGENCODE_NODITHER 0 /* do not dither encoded values*/
#define SGILOGENCODE_RANDITHER 1 /* randomly dither encd values */
#endif /* _TIFF_ */
src/add-ons/translators/libtifftranslator/tiffcomp.h
+214
View File
@@ -0,0 +1,214 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tiffcomp.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1990-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _COMPAT_
#define _COMPAT_
/*
* This file contains a hodgepodge of definitions and
* declarations that are needed to provide compatibility
* between the native system and the base implementation
* that the library assumes.
*
* NB: This file is a mess.
*/
/*
* Setup basic type definitions and function declaratations.
*/
/*
* Simplify Acorn RISC OS identifier (to avoid confusion with Acorn RISC iX
* and with defunct Unix Risc OS)
* No need to specify __arm - hey, Acorn might port the OS, no problem here!
*/
#ifdef __acornriscos
#undef __acornriscos
#endif
#if defined(__acorn) && defined(__riscos)
#define __acornriscos
#endif
#if defined(__MWERKS__) || defined(THINK_C)
#include <unix.h>
#include <math.h>
#endif
#include <stdio.h>
#if defined(__PPCC__) || defined(__SC__) || defined(__MRC__)
#include <types.h>
#elif !defined(__MWERKS__) && !defined(THINK_C) && !defined(__acornriscos) && !defined(applec)
#include <sys/types.h>
#endif
#if defined(VMS)
#include <file.h>
#include <unixio.h>
#elif !defined(__acornriscos)
#include <fcntl.h>
#endif
/*
* This maze of checks controls defines or not the
* target system has BSD-style typdedefs declared in
* an include file and/or whether or not to include
* <unistd.h> to get the SEEK_* definitions. Some
* additional includes are also done to pull in the
* appropriate definitions we're looking for.
*/
#if defined(__MWERKS__) || defined(THINK_C) || defined(__PPCC__) || defined(__SC__) || defined(__MRC__)
#include <stdlib.h>
#define BSDTYPES
#define HAVE_UNISTD_H 0
#elif (defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows) || defined(_WIN32)) && !defined(unix)
#define BSDTYPES
#elif defined(OS2_16) || defined(OS2_32)
#define BSDTYPES
#elif defined(__acornriscos)
#include <stdlib.h>
#define BSDTYPES
#define HAVE_UNISTD_H 0
#elif defined(VMS)
#define HAVE_UNISTD_H 0
#else
#define HAVE_UNISTD_H 1
#endif
/*
* The library uses the ANSI C/POSIX SEEK_*
* definitions that should be defined in unistd.h
* (except on system where they are in stdio.h and
* there is no unistd.h).
*/
#if !defined(SEEK_SET) && HAVE_UNISTD_H
#include <unistd.h>
#endif
/*
* The library uses memset, memcpy, and memcmp.
* ANSI C and System V define these in string.h.
*/
#include <string.h>
/*
* The BSD typedefs are used throughout the library.
* If your system doesn't have them in <sys/types.h>,
* then define BSDTYPES in your Makefile.
*/
#if defined(BSDTYPES)
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
#endif
/*
* dblparam_t is the type that a double precision
* floating point value will have on the parameter
* stack (when coerced by the compiler).
*/
/* Note: on MacPowerPC "extended" is undefined. So only use it for 68K-Macs */
#if defined(__SC__) || defined(THINK_C)
typedef extended dblparam_t;
#else
typedef double dblparam_t;
#endif
/*
* If your compiler supports inline functions, then
* set INLINE appropriately to get the known hotspots
* in the library expanded inline.
*/
#if defined(__GNUC__)
#if defined(__STRICT_ANSI__)
#define INLINE __inline__
#else
#define INLINE inline
#endif
#else /* !__GNUC__ */
#define INLINE
#endif
/*
* GLOBALDATA is a macro that is used to define global variables
* private to the library. We use this indirection to hide
* brain-damage in VAXC (and GCC) under VAX/VMS. In these
* environments the macro places the variable in a non-shareable
* program section, which ought to be done by default (sigh!)
*
* Apparently DEC are aware of the problem as this behaviour is the
* default under VMS on AXP.
*
* The GNU C variant is untested.
*/
#if defined(VAX) && defined(VMS)
#if defined(VAXC)
#define GLOBALDATA(TYPE,NAME) extern noshare TYPE NAME
#endif
#if defined(__GNUC__)
#define GLOBALDATA(TYPE,NAME) extern TYPE NAME \
asm("_$$PsectAttributes_NOSHR$$" #NAME)
#endif
#else /* !VAX/VMS */
#define GLOBALDATA(TYPE,NAME) extern TYPE NAME
#endif
#if defined(__acornriscos)
/*
* osfcn.h is part of C++Lib on Acorn C/C++, and as such can't be used
* on C alone. For that reason, the relevant functions are
* implemented in tif_acorn.c, and the elements from the header
* file are included here.
*/
#if defined(__cplusplus)
#include <osfcn.h>
#else
#define O_RDONLY 0
#define O_WRONLY 1
#define O_RDWR 2
#define O_APPEND 8
#define O_CREAT 0x200
#define O_TRUNC 0x400
typedef long off_t;
extern int open(const char *name, int flags, int mode);
extern int close(int fd);
extern int write(int fd, const char *buf, int nbytes);
extern int read(int fd, char *buf, int nbytes);
extern off_t lseek(int fd, off_t offset, int whence);
extern int creat(const char *path, int mode);
#endif /* __cplusplus */
#endif /* __acornriscos */
/* Bit and byte order, the default is MSB to LSB */
#ifdef VMS
#undef HOST_FILLORDER
#undef HOST_BIGENDIAN
#define HOST_FILLORDER FILLORDER_LSB2MSB
#define HOST_BIGENDIAN 0
#endif
#endif /* _COMPAT_ */
src/add-ons/translators/libtifftranslator/tiffconf.h
+163
View File
@@ -0,0 +1,163 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tiffconf.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _TIFFCONF_
#define _TIFFCONF_
#include <ByteOrder.h>
/*
* Library Configuration Definitions.
*
* This file defines the default configuration for the library.
* If the target system does not have make or a way to specify
* #defines on the command line, this file can be edited to
* configure the library. Otherwise, one can override portability
* and configuration-related definitions from a Makefile or command
* line by defining FEATURE_SUPPORT and COMPRESSION_SUPPORT (see below).
*/
/*
* General portability-related defines:
*
* HAVE_IEEEFP define as 0 or 1 according to the floating point
* format suported by the machine
* BSDTYPES define this if your system does NOT define the
* usual 4BSD typedefs u_int et. al.
* HAVE_MMAP enable support for memory mapping read-only files;
* this is typically deduced by the configure script
* HOST_FILLORDER native cpu bit order: one of FILLORDER_MSB2LSB
* or FILLODER_LSB2MSB; this is typically set by the
* configure script
* HOST_BIGENDIAN native cpu byte order: 1 if big-endian (Motorola)
* or 0 if little-endian (Intel); this may be used
* in codecs to optimize code
* USE_64BIT_API set to 1 if tif_unix.c should use lseek64(),
* fstat64() and stat64 allowing 2-4GB files.
*/
#ifndef HAVE_IEEEFP
#define HAVE_IEEEFP 1
#endif
#ifndef HOST_FILLORDER
#define HOST_FILLORDER FILLORDER_MSB2LSB
#endif
#ifndef HOST_BIGENDIAN
#define HOST_BIGENDIAN B_HOST_IS_BENDIAN
#endif
#ifndef USE_64BIT_API
# define USE_64BIT_API 0
#endif
#ifndef FEATURE_SUPPORT
/*
* Feature support definitions:
*
* COLORIMETRY_SUPPORT enable support for 6.0 colorimetry tags
* YCBCR_SUPPORT enable support for 6.0 YCbCr tags
* CMYK_SUPPORT enable support for 6.0 CMYK tags
* ICC_SUPPORT enable support for ICC profile tag
* PHOTOSHOP_SUPPORT enable support for PHOTOSHOP resource tag
* IPTC_SUPPORT enable support for RichTIFF IPTC tag
*/
#define COLORIMETRY_SUPPORT
#define YCBCR_SUPPORT
#define CMYK_SUPPORT
#define ICC_SUPPORT
#define PHOTOSHOP_SUPPORT
#define IPTC_SUPPORT
#endif /* FEATURE_SUPPORT */
#ifndef COMPRESSION_SUPPORT
/*
* Compression support defines:
*
* CCITT_SUPPORT enable support for CCITT Group 3 & 4 algorithms
* PACKBITS_SUPPORT enable support for Macintosh PackBits algorithm
* LZW_SUPPORT enable support for LZW algorithm
* THUNDER_SUPPORT enable support for ThunderScan 4-bit RLE algorithm
* NEXT_SUPPORT enable support for NeXT 2-bit RLE algorithm
* OJPEG_SUPPORT enable support for 6.0-style JPEG DCT algorithms
* (requires IJG software)
* JPEG_SUPPORT enable support for post-6.0-style JPEG DCT algorithms
* (requires freely available IJG software, see tif_jpeg.c)
* ZIP_SUPPORT enable support for Deflate algorithm
* (requires freely available zlib software, see tif_zip.c)
* PIXARLOG_SUPPORT enable support for Pixar log-format algorithm
* LOGLUV_SUPPORT enable support for LogLuv high dynamic range encoding
*/
#define CCITT_SUPPORT
#define PACKBITS_SUPPORT
#define LZW_SUPPORT
#define THUNDER_SUPPORT
#define NEXT_SUPPORT
#define LOGLUV_SUPPORT
#endif /* COMPRESSION_SUPPORT */
/*
* If JPEG compression is enabled then we must also include
* support for the colorimetry and YCbCr-related tags.
*/
#ifdef JPEG_SUPPORT
#ifndef YCBCR_SUPPORT
#define YCBCR_SUPPORT
#endif
#ifndef COLORIMETRY_SUPPORT
#define COLORIMETRY_SUPPORT
#endif
#endif /* JPEG_SUPPORT */
/*
* ``Orthogonal Features''
*
* STRIPCHOP_DEFAULT default handling of strip chopping support (whether
* or not to convert single-strip uncompressed images
* to mutiple strips of ~8Kb--to reduce memory use)
* SUBIFD_SUPPORT enable support for SubIFD tag (thumbnails and such)
* DEFAULT_EXTRASAMPLE_AS_ALPHA
* The RGBA interface will treat a fourth sample with
* no EXTRASAMPLE_ value as being ASSOCALPHA. Many
* packages produce RGBA files but don't mark the alpha
* properly.
* CHECK_JPEG_YCBCR_SUBSAMPLING
* Enable picking up YCbCr subsampling info from the
* JPEG data stream to support files lacking the tag.
* See Bug 168 in Bugzilla, and JPEGFixupTestSubsampling()
* for details.
*/
#ifndef STRIPCHOP_DEFAULT
#define STRIPCHOP_DEFAULT TIFF_STRIPCHOP /* default is to enable */
#endif
#ifndef SUBIFD_SUPPORT
#define SUBIFD_SUPPORT 1 /* enable SubIFD tag (330) support */
#endif
#ifndef DEFAULT_EXTRASAMPLE_AS_ALPHA
#define DEFAULT_EXTRASAMPLE_AS_ALPHA 1
#endif
#ifndef CHECK_JPEG_YCBCR_SUBSAMPLING
#define CHECK_JPEG_YCBCR_SUBSAMPLING 1
#endif
#endif /* _TIFFCONF_ */
src/add-ons/translators/libtifftranslator/tiffio.h
+417
View File
@@ -0,0 +1,417 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tiffio.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _TIFFIO_
#define _TIFFIO_
/*
* TIFF I/O Library Definitions.
*/
#include "tiff.h"
#include "tiffvers.h"
/*
* TIFF is defined as an incomplete type to hide the
* library's internal data structures from clients.
*/
typedef struct tiff TIFF;
/*
* The following typedefs define the intrinsic size of
* data types used in the *exported* interfaces. These
* definitions depend on the proper definition of types
* in tiff.h. Note also that the varargs interface used
* to pass tag types and values uses the types defined in
* tiff.h directly.
*
* NB: ttag_t is unsigned int and not unsigned short because
* ANSI C requires that the type before the ellipsis be a
* promoted type (i.e. one of int, unsigned int, pointer,
* or double) and because we defined pseudo-tags that are
* outside the range of legal Aldus-assigned tags.
* NB: tsize_t is int32 and not uint32 because some functions
* return -1.
* NB: toff_t is not off_t for many reasons; TIFFs max out at
* 32-bit file offsets being the most important, and to ensure
* that it is unsigned, rather than signed.
*/
typedef uint32 ttag_t; /* directory tag */
typedef uint16 tdir_t; /* directory index */
typedef uint16 tsample_t; /* sample number */
typedef uint32 tstrip_t; /* strip number */
typedef uint32 ttile_t; /* tile number */
typedef int32 tsize_t; /* i/o size in bytes */
typedef void* tdata_t; /* image data ref */
typedef uint32 toff_t; /* file offset */
#if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32))
#define __WIN32__
#endif
/*
* On windows you should define USE_WIN32_FILEIO if you are using tif_win32.c
* or AVOID_WIN32_FILEIO if you are using something else (like tif_unix.c).
*
* By default tif_win32.c is assumed on windows if not using the cygwin
* environment.
*/
#if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows)
# if !defined(__CYGWIN) && !defined(AVOID_WIN32_FILEIO) && !defined(USE_WIN32_FILIO)
# define USE_WIN32_FILEIO
# endif
#endif
#if defined(USE_WIN32_FILEIO)
#include <windows.h>
#ifdef __WIN32__
DECLARE_HANDLE(thandle_t); /* Win32 file handle */
#else
typedef HFILE thandle_t; /* client data handle */
#endif
#else
typedef void* thandle_t; /* client data handle */
#endif
#ifndef NULL
#define NULL 0
#endif
/*
* Flags to pass to TIFFPrintDirectory to control
* printing of data structures that are potentially
* very large. Bit-or these flags to enable printing
* multiple items.
*/
#define TIFFPRINT_NONE 0x0 /* no extra info */
#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */
#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */
#define TIFFPRINT_COLORMAP 0x4 /* colormap */
#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */
#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */
#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */
/*
* RGBA-style image support.
*/
typedef unsigned char TIFFRGBValue; /* 8-bit samples */
typedef struct _TIFFRGBAImage TIFFRGBAImage;
/*
* The image reading and conversion routines invoke
* ``put routines'' to copy/image/whatever tiles of
* raw image data. A default set of routines are
* provided to convert/copy raw image data to 8-bit
* packed ABGR format rasters. Applications can supply
* alternate routines that unpack the data into a
* different format or, for example, unpack the data
* and draw the unpacked raster on the display.
*/
typedef void (*tileContigRoutine)
(TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32,
unsigned char*);
typedef void (*tileSeparateRoutine)
(TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32,
unsigned char*, unsigned char*, unsigned char*, unsigned char*);
/*
* RGBA-reader state.
*/
typedef struct { /* YCbCr->RGB support */
TIFFRGBValue* clamptab; /* range clamping table */
int* Cr_r_tab;
int* Cb_b_tab;
int32* Cr_g_tab;
int32* Cb_g_tab;
float coeffs[3]; /* cached for repeated use */
} TIFFYCbCrToRGB;
struct _TIFFRGBAImage {
TIFF* tif; /* image handle */
int stoponerr; /* stop on read error */
int isContig; /* data is packed/separate */
int alpha; /* type of alpha data present */
uint32 width; /* image width */
uint32 height; /* image height */
uint16 bitspersample; /* image bits/sample */
uint16 samplesperpixel; /* image samples/pixel */
uint16 orientation; /* image orientation */
uint16 photometric; /* image photometric interp */
uint16* redcmap; /* colormap pallete */
uint16* greencmap;
uint16* bluecmap;
/* get image data routine */
int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32);
union {
void (*any)(TIFFRGBAImage*);
tileContigRoutine contig;
tileSeparateRoutine separate;
} put; /* put decoded strip/tile */
TIFFRGBValue* Map; /* sample mapping array */
uint32** BWmap; /* black&white map */
uint32** PALmap; /* palette image map */
TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */
int row_offset;
int col_offset;
};
/*
* Macros for extracting components from the
* packed ABGR form returned by TIFFReadRGBAImage.
*/
#define TIFFGetR(abgr) ((abgr) & 0xff)
#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)
#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)
#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff)
/*
* A CODEC is a software package that implements decoding,
* encoding, or decoding+encoding of a compression algorithm.
* The library provides a collection of builtin codecs.
* More codecs may be registered through calls to the library
* and/or the builtin implementations may be overridden.
*/
typedef int (*TIFFInitMethod)(TIFF*, int);
typedef struct {
char* name;
uint16 scheme;
TIFFInitMethod init;
} TIFFCodec;
#include <stdio.h>
#include <stdarg.h>
/* share internal LogLuv conversion routines? */
#ifndef LOGLUV_PUBLIC
#define LOGLUV_PUBLIC 1
#endif
#if defined(__cplusplus)
extern "C" {
#endif
typedef void (*TIFFErrorHandler)(const char*, const char*, va_list);
typedef tsize_t (*TIFFReadWriteProc)(thandle_t, tdata_t, tsize_t);
typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
typedef int (*TIFFCloseProc)(thandle_t);
typedef toff_t (*TIFFSizeProc)(thandle_t);
typedef int (*TIFFMapFileProc)(thandle_t, tdata_t*, toff_t*);
typedef void (*TIFFUnmapFileProc)(thandle_t, tdata_t, toff_t);
typedef void (*TIFFExtendProc)(TIFF*);
extern const char* TIFFGetVersion(void);
extern const TIFFCodec* TIFFFindCODEC(uint16);
extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod);
extern void TIFFUnRegisterCODEC(TIFFCodec*);
extern tdata_t _TIFFmalloc(tsize_t);
extern tdata_t _TIFFrealloc(tdata_t, tsize_t);
extern void _TIFFmemset(tdata_t, int, tsize_t);
extern void _TIFFmemcpy(tdata_t, const tdata_t, tsize_t);
extern int _TIFFmemcmp(const tdata_t, const tdata_t, tsize_t);
extern void _TIFFfree(tdata_t);
extern void TIFFClose(TIFF*);
extern int TIFFFlush(TIFF*);
extern int TIFFFlushData(TIFF*);
extern int TIFFGetField(TIFF*, ttag_t, ...);
extern int TIFFVGetField(TIFF*, ttag_t, va_list);
extern int TIFFGetFieldDefaulted(TIFF*, ttag_t, ...);
extern int TIFFVGetFieldDefaulted(TIFF*, ttag_t, va_list);
extern int TIFFReadDirectory(TIFF*);
extern tsize_t TIFFScanlineSize(TIFF*);
extern tsize_t TIFFRasterScanlineSize(TIFF*);
extern tsize_t TIFFStripSize(TIFF*);
extern tsize_t TIFFVStripSize(TIFF*, uint32);
extern tsize_t TIFFTileRowSize(TIFF*);
extern tsize_t TIFFTileSize(TIFF*);
extern tsize_t TIFFVTileSize(TIFF*, uint32);
extern uint32 TIFFDefaultStripSize(TIFF*, uint32);
extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
extern int TIFFFileno(TIFF*);
extern int TIFFGetMode(TIFF*);
extern int TIFFIsTiled(TIFF*);
extern int TIFFIsByteSwapped(TIFF*);
extern int TIFFIsUpSampled(TIFF*);
extern int TIFFIsMSB2LSB(TIFF*);
extern uint32 TIFFCurrentRow(TIFF*);
extern tdir_t TIFFCurrentDirectory(TIFF*);
extern tdir_t TIFFNumberOfDirectories(TIFF*);
extern uint32 TIFFCurrentDirOffset(TIFF*);
extern tstrip_t TIFFCurrentStrip(TIFF*);
extern ttile_t TIFFCurrentTile(TIFF*);
extern int TIFFReadBufferSetup(TIFF*, tdata_t, tsize_t);
extern int TIFFWriteBufferSetup(TIFF*, tdata_t, tsize_t);
extern int TIFFSetupStrips(TIFF *);
extern int TIFFWriteCheck(TIFF*, int, const char *);
extern int TIFFCreateDirectory(TIFF*);
extern int TIFFLastDirectory(TIFF*);
extern int TIFFSetDirectory(TIFF*, tdir_t);
extern int TIFFSetSubDirectory(TIFF*, uint32);
extern int TIFFUnlinkDirectory(TIFF*, tdir_t);
extern int TIFFSetField(TIFF*, ttag_t, ...);
extern int TIFFVSetField(TIFF*, ttag_t, va_list);
extern int TIFFWriteDirectory(TIFF *);
extern int TIFFCheckpointDirectory(TIFF *);
extern int TIFFRewriteDirectory(TIFF *);
extern int TIFFReassignTagToIgnore(enum TIFFIgnoreSense, int);
#if defined(c_plusplus) || defined(__cplusplus)
extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0);
extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t = 0);
extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t = 0);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0);
#else
extern void TIFFPrintDirectory(TIFF*, FILE*, long);
extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t);
extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int);
#endif
extern int TIFFReadRGBAStrip(TIFF*, tstrip_t, uint32 * );
extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * );
extern int TIFFRGBAImageOK(TIFF*, char [1024]);
extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]);
extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32);
extern void TIFFRGBAImageEnd(TIFFRGBAImage*);
extern TIFF* TIFFOpen(const char*, const char*);
extern TIFF* TIFFFdOpen(int, const char*, const char*);
extern TIFF* TIFFClientOpen(const char*, const char*,
thandle_t,
TIFFReadWriteProc, TIFFReadWriteProc,
TIFFSeekProc, TIFFCloseProc,
TIFFSizeProc,
TIFFMapFileProc, TIFFUnmapFileProc);
extern const char* TIFFFileName(TIFF*);
extern void TIFFError(const char*, const char*, ...);
extern void TIFFWarning(const char*, const char*, ...);
extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
extern ttile_t TIFFComputeTile(TIFF*, uint32, uint32, uint32, tsample_t);
extern int TIFFCheckTile(TIFF*, uint32, uint32, uint32, tsample_t);
extern ttile_t TIFFNumberOfTiles(TIFF*);
extern tsize_t TIFFReadTile(TIFF*,
tdata_t, uint32, uint32, uint32, tsample_t);
extern tsize_t TIFFWriteTile(TIFF*,
tdata_t, uint32, uint32, uint32, tsample_t);
extern tstrip_t TIFFComputeStrip(TIFF*, uint32, tsample_t);
extern tstrip_t TIFFNumberOfStrips(TIFF*);
extern tsize_t TIFFReadEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFReadRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFReadEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFReadRawTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteRawTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */
extern void TIFFSetWriteOffset(TIFF*, toff_t);
extern void TIFFSwabShort(uint16*);
extern void TIFFSwabLong(uint32*);
extern void TIFFSwabDouble(double*);
extern void TIFFSwabArrayOfShort(uint16*, unsigned long);
extern void TIFFSwabArrayOfLong(uint32*, unsigned long);
extern void TIFFSwabArrayOfDouble(double*, unsigned long);
extern void TIFFReverseBits(unsigned char *, unsigned long);
extern const unsigned char* TIFFGetBitRevTable(int);
#ifdef LOGLUV_PUBLIC
#define U_NEU 0.210526316
#define V_NEU 0.473684211
#define UVSCALE 410.
extern double LogL16toY(int);
extern double LogL10toY(int);
extern void XYZtoRGB24(float*, uint8*);
extern int uv_decode(double*, double*, int);
extern void LogLuv24toXYZ(uint32, float*);
extern void LogLuv32toXYZ(uint32, float*);
#if defined(c_plusplus) || defined(__cplusplus)
extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER);
extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER);
extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER);
extern uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER);
extern uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER);
#else
extern int LogL16fromY(double, int);
extern int LogL10fromY(double, int);
extern int uv_encode(double, double, int);
extern uint32 LogLuv24fromXYZ(float*, int);
extern uint32 LogLuv32fromXYZ(float*, int);
#endif
#endif /* LOGLUV_PUBLIC */
/*
** New stuff going public in 3.6.x.
*/
extern int TIFFGetTagListCount( TIFF * );
extern ttag_t TIFFGetTagListEntry( TIFF *, int tag_index );
#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */
#define TIFF_VARIABLE -1 /* marker for variable length tags */
#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */
#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */
#define FIELD_CUSTOM 65
typedef struct {
ttag_t field_tag; /* field's tag */
short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */
short field_writecount; /* write count/TIFF_VARIABLE */
TIFFDataType field_type; /* type of associated data */
unsigned short field_bit; /* bit in fieldsset bit vector */
unsigned char field_oktochange; /* if true, can change while writing */
unsigned char field_passcount; /* if true, pass dir count on set */
char *field_name; /* ASCII name */
} TIFFFieldInfo;
typedef struct _TIFFTagValue {
const TIFFFieldInfo *info;
int count;
void *value;
} TIFFTagValue;
extern void TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], int);
extern const TIFFFieldInfo* TIFFFindFieldInfo(TIFF*, ttag_t, TIFFDataType);
extern const TIFFFieldInfo* TIFFFieldWithTag(TIFF*, ttag_t);
typedef int (*TIFFVSetMethod)(TIFF*, ttag_t, va_list);
typedef int (*TIFFVGetMethod)(TIFF*, ttag_t, va_list);
typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long);
typedef struct {
TIFFVSetMethod vsetfield; /* tag set routine */
TIFFVGetMethod vgetfield; /* tag get routine */
TIFFPrintMethod printdir; /* directory print routine */
} TIFFTagMethods;
extern TIFFTagMethods *TIFFAccessTagMethods( TIFF * );
extern void *TIFFGetClientInfo( TIFF *, const char * );
extern void TIFFSetClientInfo( TIFF *, void *, const char * );
#if defined(__cplusplus)
}
#endif
#endif /* _TIFFIO_ */
src/add-ons/translators/libtifftranslator/tiffiop.h
+282
View File
@@ -0,0 +1,282 @@
/* $Header: /tmp/bonefish/open-beos/current/src/add-ons/translators/libtifftranslator/tiffiop.h,v 1.1 2003/07/19 16:40:33 mwilber Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _TIFFIOP_
#define _TIFFIOP_
/*
* ``Library-private'' definitions.
*/
/*
* UNIX systems should run the configure script to generate
* a port.h file that reflects the system capabilities.
* Doing this obviates all the dreck done in tiffcomp.h.
*/
#if defined(unix) || defined(__unix)
#include "port.h"
#include "tiffconf.h"
#else
#include "tiffconf.h"
#include "tiffcomp.h"
#endif
#include "tiffio.h"
#include "tif_dir.h"
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
typedef struct client_info {
struct client_info *next;
void *data;
char *name;
} TIFFClientInfoLink;
/*
* Typedefs for ``method pointers'' used internally.
*/
typedef unsigned char tidataval_t; /* internal image data value type */
typedef tidataval_t* tidata_t; /* reference to internal image data */
typedef void (*TIFFVoidMethod)(TIFF*);
typedef int (*TIFFBoolMethod)(TIFF*);
typedef int (*TIFFPreMethod)(TIFF*, tsample_t);
typedef int (*TIFFCodeMethod)(TIFF*, tidata_t, tsize_t, tsample_t);
typedef int (*TIFFSeekMethod)(TIFF*, uint32);
typedef void (*TIFFPostMethod)(TIFF*, tidata_t, tsize_t);
typedef uint32 (*TIFFStripMethod)(TIFF*, uint32);
typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*);
struct tiff {
char* tif_name; /* name of open file */
int tif_fd; /* open file descriptor */
int tif_mode; /* open mode (O_*) */
uint32 tif_flags;
#define TIFF_FILLORDER 0x0003 /* natural bit fill order for machine */
#define TIFF_DIRTYHEADER 0x0004 /* header must be written on close */
#define TIFF_DIRTYDIRECT 0x0008 /* current directory must be written */
#define TIFF_BUFFERSETUP 0x0010 /* data buffers setup */
#define TIFF_CODERSETUP 0x0020 /* encoder/decoder setup done */
#define TIFF_BEENWRITING 0x0040 /* written 1+ scanlines to file */
#define TIFF_SWAB 0x0080 /* byte swap file information */
#define TIFF_NOBITREV 0x0100 /* inhibit bit reversal logic */
#define TIFF_MYBUFFER 0x0200 /* my raw data buffer; free on close */
#define TIFF_ISTILED 0x0400 /* file is tile, not strip- based */
#define TIFF_MAPPED 0x0800 /* file is mapped into memory */
#define TIFF_POSTENCODE 0x1000 /* need call to postencode routine */
#define TIFF_INSUBIFD 0x2000 /* currently writing a subifd */
#define TIFF_UPSAMPLED 0x4000 /* library is doing data up-sampling */
#define TIFF_STRIPCHOP 0x8000 /* enable strip chopping support */
toff_t tif_diroff; /* file offset of current directory */
toff_t tif_nextdiroff; /* file offset of following directory */
TIFFDirectory tif_dir; /* internal rep of current directory */
TIFFHeader tif_header; /* file's header block */
const int* tif_typeshift; /* data type shift counts */
const long* tif_typemask; /* data type masks */
uint32 tif_row; /* current scanline */
tdir_t tif_curdir; /* current directory (index) */
tstrip_t tif_curstrip; /* current strip for read/write */
toff_t tif_curoff; /* current offset for read/write */
toff_t tif_dataoff; /* current offset for writing dir */
#if SUBIFD_SUPPORT
uint16 tif_nsubifd; /* remaining subifds to write */
toff_t tif_subifdoff; /* offset for patching SubIFD link */
#endif
/* tiling support */
uint32 tif_col; /* current column (offset by row too) */
ttile_t tif_curtile; /* current tile for read/write */
tsize_t tif_tilesize; /* # of bytes in a tile */
/* compression scheme hooks */
int tif_decodestatus;
TIFFBoolMethod tif_setupdecode;/* called once before predecode */
TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */
TIFFBoolMethod tif_setupencode;/* called once before preencode */
int tif_encodestatus;
TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */
TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */
TIFFCodeMethod tif_decoderow; /* scanline decoding routine */
TIFFCodeMethod tif_encoderow; /* scanline encoding routine */
TIFFCodeMethod tif_decodestrip;/* strip decoding routine */
TIFFCodeMethod tif_encodestrip;/* strip encoding routine */
TIFFCodeMethod tif_decodetile; /* tile decoding routine */
TIFFCodeMethod tif_encodetile; /* tile encoding routine */
TIFFVoidMethod tif_close; /* cleanup-on-close routine */
TIFFSeekMethod tif_seek; /* position within a strip routine */
TIFFVoidMethod tif_cleanup; /* cleanup state routine */
TIFFStripMethod tif_defstripsize;/* calculate/constrain strip size */
TIFFTileMethod tif_deftilesize;/* calculate/constrain tile size */
tidata_t tif_data; /* compression scheme private data */
/* input/output buffering */
tsize_t tif_scanlinesize;/* # of bytes in a scanline */
tsize_t tif_scanlineskew;/* scanline skew for reading strips */
tidata_t tif_rawdata; /* raw data buffer */
tsize_t tif_rawdatasize;/* # of bytes in raw data buffer */
tidata_t tif_rawcp; /* current spot in raw buffer */
tsize_t tif_rawcc; /* bytes unread from raw buffer */
/* memory-mapped file support */
tidata_t tif_base; /* base of mapped file */
toff_t tif_size; /* size of mapped file region (bytes) */
TIFFMapFileProc tif_mapproc; /* map file method */
TIFFUnmapFileProc tif_unmapproc;/* unmap file method */
/* input/output callback methods */
thandle_t tif_clientdata; /* callback parameter */
TIFFReadWriteProc tif_readproc; /* read method */
TIFFReadWriteProc tif_writeproc;/* write method */
TIFFSeekProc tif_seekproc; /* lseek method */
TIFFCloseProc tif_closeproc; /* close method */
TIFFSizeProc tif_sizeproc; /* filesize method */
/* post-decoding support */
TIFFPostMethod tif_postdecode; /* post decoding routine */
/* tag support */
TIFFFieldInfo** tif_fieldinfo; /* sorted table of registered tags */
int tif_nfields; /* # entries in registered tag table */
TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */
TIFFClientInfoLink *tif_clientinfo; /* extra client information. */
};
#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */
#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0)
#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0)
#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0)
#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)
#define TIFFReadFile(tif, buf, size) \
((*(tif)->tif_readproc)((tif)->tif_clientdata,buf,size))
#define TIFFWriteFile(tif, buf, size) \
((*(tif)->tif_writeproc)((tif)->tif_clientdata,buf,size))
#define TIFFSeekFile(tif, off, whence) \
((*(tif)->tif_seekproc)((tif)->tif_clientdata,(toff_t)(off),whence))
#define TIFFCloseFile(tif) \
((*(tif)->tif_closeproc)((tif)->tif_clientdata))
#define TIFFGetFileSize(tif) \
((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
#define TIFFMapFileContents(tif, paddr, psize) \
((*(tif)->tif_mapproc)((tif)->tif_clientdata,paddr,psize))
#define TIFFUnmapFileContents(tif, addr, size) \
((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,size))
/*
* Default Read/Seek/Write definitions.
*/
#ifndef ReadOK
#define ReadOK(tif, buf, size) \
(TIFFReadFile(tif, (tdata_t) buf, (tsize_t)(size)) == (tsize_t)(size))
#endif
#ifndef SeekOK
#define SeekOK(tif, off) \
(TIFFSeekFile(tif, (toff_t) off, SEEK_SET) == (toff_t) off)
#endif
#ifndef WriteOK
#define WriteOK(tif, buf, size) \
(TIFFWriteFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size)
#endif
/* NB: the uint32 casts are to silence certain ANSI-C compilers */
#define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y)))
#define TIFFroundup(x, y) (TIFFhowmany(x,y)*((uint32)(y)))
#if defined(__cplusplus)
extern "C" {
#endif
extern int _TIFFgetMode(const char*, const char*);
extern int _TIFFNoRowEncode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoStripEncode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoTileEncode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoRowDecode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoStripDecode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoTileDecode(TIFF*, tidata_t, tsize_t, tsample_t);
extern void _TIFFNoPostDecode(TIFF*, tidata_t, tsize_t);
extern int _TIFFNoPreCode (TIFF*, tsample_t);
extern int _TIFFNoSeek(TIFF*, uint32);
extern void _TIFFSwab16BitData(TIFF*, tidata_t, tsize_t);
extern void _TIFFSwab32BitData(TIFF*, tidata_t, tsize_t);
extern void _TIFFSwab64BitData(TIFF*, tidata_t, tsize_t);
extern int TIFFFlushData1(TIFF*);
extern void TIFFFreeDirectory(TIFF*);
extern int TIFFDefaultDirectory(TIFF*);
extern int TIFFSetCompressionScheme(TIFF*, int);
extern int TIFFSetDefaultCompressionState(TIFF*);
extern uint32 _TIFFDefaultStripSize(TIFF*, uint32);
extern void _TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
extern void _TIFFsetByteArray(void**, void*, long);
extern void _TIFFsetString(char**, char*);
extern void _TIFFsetShortArray(uint16**, uint16*, long);
extern void _TIFFsetLongArray(uint32**, uint32*, long);
extern void _TIFFsetFloatArray(float**, float*, long);
extern void _TIFFsetDoubleArray(double**, double*, long);
extern void _TIFFprintAscii(FILE*, const char*);
extern void _TIFFprintAsciiTag(FILE*, const char*, const char*);
GLOBALDATA(TIFFErrorHandler,_TIFFwarningHandler);
GLOBALDATA(TIFFErrorHandler,_TIFFerrorHandler);
extern int TIFFInitDumpMode(TIFF*, int);
#ifdef PACKBITS_SUPPORT
extern int TIFFInitPackBits(TIFF*, int);
#endif
#ifdef CCITT_SUPPORT
extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int);
extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int);
#endif
#ifdef THUNDER_SUPPORT
extern int TIFFInitThunderScan(TIFF*, int);
#endif
#ifdef NEXT_SUPPORT
extern int TIFFInitNeXT(TIFF*, int);
#endif
#ifdef LZW_SUPPORT
extern int TIFFInitLZW(TIFF*, int);
#endif
#ifdef OJPEG_SUPPORT
extern int TIFFInitOJPEG(TIFF*, int);
#endif
#ifdef JPEG_SUPPORT
extern int TIFFInitJPEG(TIFF*, int);
#endif
#ifdef JBIG_SUPPORT
extern int TIFFInitJBIG(TIFF*, int);
#endif
#ifdef ZIP_SUPPORT
extern int TIFFInitZIP(TIFF*, int);
#endif
#ifdef PIXARLOG_SUPPORT
extern int TIFFInitPixarLog(TIFF*, int);
#endif
#ifdef LOGLUV_SUPPORT
extern int TIFFInitSGILog(TIFF*, int);
#endif
#ifdef VMS
extern const TIFFCodec _TIFFBuiltinCODECS[];
#else
extern TIFFCodec _TIFFBuiltinCODECS[];
#endif
#if defined(__cplusplus)
}
#endif
#endif /* _TIFFIOP_ */
src/add-ons/translators/libtifftranslator/tiffvers.h
+9
View File
@@ -0,0 +1,9 @@
#define TIFFLIB_VERSION_STR "LIBTIFF, Version 3.6.0 beta2\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
/*
* This define can be used in code that requires
* compilation-related definitions specific to a
* version or versions of the library. Runtime
* version checking should be done based on the
* string returned by TIFFGetVersion.
*/
#define TIFFLIB_VERSION 20030619
src/add-ons/translators/libtifftranslator/uvcode.h
+173
View File
@@ -0,0 +1,173 @@
/* Version 1.0 generated April 7, 1997 by Greg Ward Larson, SGI */
#define UV_SQSIZ (float)0.003500
#define UV_NDIVS 16289
#define UV_VSTART (float)0.016940
#define UV_NVS 163
static struct {
float ustart;
short nus, ncum;
} uv_row[UV_NVS] = {
(float)0.247663, 4, 0,
(float)0.243779, 6, 4,
(float)0.241684, 7, 10,
(float)0.237874, 9, 17,
(float)0.235906, 10, 26,
(float)0.232153, 12, 36,
(float)0.228352, 14, 48,
(float)0.226259, 15, 62,
(float)0.222371, 17, 77,
(float)0.220410, 18, 94,
(float)0.214710, 21, 112,
(float)0.212714, 22, 133,
(float)0.210721, 23, 155,
(float)0.204976, 26, 178,
(float)0.202986, 27, 204,
(float)0.199245, 29, 231,
(float)0.195525, 31, 260,
(float)0.193560, 32, 291,
(float)0.189878, 34, 323,
(float)0.186216, 36, 357,
(float)0.186216, 36, 393,
(float)0.182592, 38, 429,
(float)0.179003, 40, 467,
(float)0.175466, 42, 507,
(float)0.172001, 44, 549,
(float)0.172001, 44, 593,
(float)0.168612, 46, 637,
(float)0.168612, 46, 683,
(float)0.163575, 49, 729,
(float)0.158642, 52, 778,
(float)0.158642, 52, 830,
(float)0.158642, 52, 882,
(float)0.153815, 55, 934,
(float)0.153815, 55, 989,
(float)0.149097, 58, 1044,
(float)0.149097, 58, 1102,
(float)0.142746, 62, 1160,
(float)0.142746, 62, 1222,
(float)0.142746, 62, 1284,
(float)0.138270, 65, 1346,
(float)0.138270, 65, 1411,
(float)0.138270, 65, 1476,
(float)0.132166, 69, 1541,
(float)0.132166, 69, 1610,
(float)0.126204, 73, 1679,
(float)0.126204, 73, 1752,
(float)0.126204, 73, 1825,
(float)0.120381, 77, 1898,
(float)0.120381, 77, 1975,
(float)0.120381, 77, 2052,
(float)0.120381, 77, 2129,
(float)0.112962, 82, 2206,
(float)0.112962, 82, 2288,
(float)0.112962, 82, 2370,
(float)0.107450, 86, 2452,
(float)0.107450, 86, 2538,
(float)0.107450, 86, 2624,
(float)0.107450, 86, 2710,
(float)0.100343, 91, 2796,
(float)0.100343, 91, 2887,
(float)0.100343, 91, 2978,
(float)0.095126, 95, 3069,
(float)0.095126, 95, 3164,
(float)0.095126, 95, 3259,
(float)0.095126, 95, 3354,
(float)0.088276, 100, 3449,
(float)0.088276, 100, 3549,
(float)0.088276, 100, 3649,
(float)0.088276, 100, 3749,
(float)0.081523, 105, 3849,
(float)0.081523, 105, 3954,
(float)0.081523, 105, 4059,
(float)0.081523, 105, 4164,
(float)0.074861, 110, 4269,
(float)0.074861, 110, 4379,
(float)0.074861, 110, 4489,
(float)0.074861, 110, 4599,
(float)0.068290, 115, 4709,
(float)0.068290, 115, 4824,
(float)0.068290, 115, 4939,
(float)0.068290, 115, 5054,
(float)0.063573, 119, 5169,
(float)0.063573, 119, 5288,
(float)0.063573, 119, 5407,
(float)0.063573, 119, 5526,
(float)0.057219, 124, 5645,
(float)0.057219, 124, 5769,
(float)0.057219, 124, 5893,
(float)0.057219, 124, 6017,
(float)0.050985, 129, 6141,
(float)0.050985, 129, 6270,
(float)0.050985, 129, 6399,
(float)0.050985, 129, 6528,
(float)0.050985, 129, 6657,
(float)0.044859, 134, 6786,
(float)0.044859, 134, 6920,
(float)0.044859, 134, 7054,
(float)0.044859, 134, 7188,
(float)0.040571, 138, 7322,
(float)0.040571, 138, 7460,
(float)0.040571, 138, 7598,
(float)0.040571, 138, 7736,
(float)0.036339, 142, 7874,
(float)0.036339, 142, 8016,
(float)0.036339, 142, 8158,
(float)0.036339, 142, 8300,
(float)0.032139, 146, 8442,
(float)0.032139, 146, 8588,
(float)0.032139, 146, 8734,
(float)0.032139, 146, 8880,
(float)0.027947, 150, 9026,
(float)0.027947, 150, 9176,
(float)0.027947, 150, 9326,
(float)0.023739, 154, 9476,
(float)0.023739, 154, 9630,
(float)0.023739, 154, 9784,
(float)0.023739, 154, 9938,
(float)0.019504, 158, 10092,
(float)0.019504, 158, 10250,
(float)0.019504, 158, 10408,
(float)0.016976, 161, 10566,
(float)0.016976, 161, 10727,
(float)0.016976, 161, 10888,
(float)0.016976, 161, 11049,
(float)0.012639, 165, 11210,
(float)0.012639, 165, 11375,
(float)0.012639, 165, 11540,
(float)0.009991, 168, 11705,
(float)0.009991, 168, 11873,
(float)0.009991, 168, 12041,
(float)0.009016, 170, 12209,
(float)0.009016, 170, 12379,
(float)0.009016, 170, 12549,
(float)0.006217, 173, 12719,
(float)0.006217, 173, 12892,
(float)0.005097, 175, 13065,
(float)0.005097, 175, 13240,
(float)0.005097, 175, 13415,
(float)0.003909, 177, 13590,
(float)0.003909, 177, 13767,
(float)0.002340, 177, 13944,
(float)0.002389, 170, 14121,
(float)0.001068, 164, 14291,
(float)0.001653, 157, 14455,
(float)0.000717, 150, 14612,
(float)0.001614, 143, 14762,
(float)0.000270, 136, 14905,
(float)0.000484, 129, 15041,
(float)0.001103, 123, 15170,
(float)0.001242, 115, 15293,
(float)0.001188, 109, 15408,
(float)0.001011, 103, 15517,
(float)0.000709, 97, 15620,
(float)0.000301, 89, 15717,
(float)0.002416, 82, 15806,
(float)0.003251, 76, 15888,
(float)0.003246, 69, 15964,
(float)0.004141, 62, 16033,
(float)0.005963, 55, 16095,
(float)0.008839, 47, 16150,
(float)0.010490, 40, 16197,
(float)0.016994, 31, 16237,
(float)0.023659, 21, 16268,
};