int
main(int argc, char* argv[])
{
TIFF *in, *out;
if (argc < 2) {
fprintf(stderr, "%s\n\n", TIFFGetVersion());
fprintf(stderr, "usage: tiffsplit input.tif [prefix]\n");
return (-3);
}
if (argc > 2)
strcpy(fname, argv[2]);
in = TIFFOpen(argv[1], "r");
if (in != NULL) {
do {
char path[1024+1];
newfilename();
strcpy(path, fname);
strcat(path, ".tif");
out = TIFFOpen(path, TIFFIsBigEndian(in)?"wb":"wl");
if (out == NULL)
return (-2);
if (!tiffcp(in, out))
return (-1);
TIFFClose(out);
} while (TIFFReadDirectory(in));
(void) TIFFClose(in);
}
return (0);
}
static int
tiffcvt(TIFF* in, TIFF* out)
{
uint32 width, height; /* image width & height */
uint32* raster; /* retrieve RGBA image */
uint16 shortv;
float floatv;
char *stringv;
uint32 longv;
TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField(in, TIFFTAG_IMAGELENGTH, &height);
raster = (uint32*)_TIFFmalloc(width * height * sizeof (uint32));
if (raster == 0) {
TIFFError(TIFFFileName(in), "No space for raster buffer");
return (0);
}
if (!TIFFReadRGBAImage(in, width, height, raster, 0)) {
_TIFFfree(raster);
return (0);
}
CopyField(TIFFTAG_SUBFILETYPE, longv);
TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(out, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
if (compression == COMPRESSION_JPEG)
TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RAW);
CopyField(TIFFTAG_FILLORDER, shortv);
TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3);
CopyField(TIFFTAG_XRESOLUTION, floatv);
CopyField(TIFFTAG_YRESOLUTION, floatv);
CopyField(TIFFTAG_RESOLUTIONUNIT, shortv);
TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
{ char buf[2048];
char *cp = strrchr(TIFFFileName(in), '/');
sprintf(buf, "YCbCr conversion of %s", cp ? cp+1 : TIFFFileName(in));
TIFFSetField(out, TIFFTAG_IMAGEDESCRIPTION, buf);
}
TIFFSetField(out, TIFFTAG_SOFTWARE, TIFFGetVersion());
CopyField(TIFFTAG_DOCUMENTNAME, stringv);
TIFFSetField(out, TIFFTAG_REFERENCEBLACKWHITE, refBlackWhite);
TIFFSetField(out, TIFFTAG_YCBCRSUBSAMPLING,
horizSubSampling, vertSubSampling);
TIFFSetField(out, TIFFTAG_YCBCRPOSITIONING, YCBCRPOSITION_CENTERED);
TIFFSetField(out, TIFFTAG_YCBCRCOEFFICIENTS, ycbcrCoeffs);
rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip);
TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
return (cvtRaster(out, raster, width, height));
}
static void
usage(void)
{
char buf[BUFSIZ];
int i;
setbuf(stderr, buf);
fprintf(stderr, "%s\n\n", TIFFGetVersion());
for (i = 0; stuff[i] != NULL; i++)
fprintf(stderr, "%s\n", stuff[i]);
exit(-1);
}
/** help function */
void help () {
printf ("fixit_tiff\n");
printf ("uses libtiff version %s\n", TIFFGetVersion());
printf ("call it with:\n");
printf ("\tfixit_tiff [-h|-c|-s|-b] -i <infile> [-o <outfile>]\n");
printf ("\nwhere <infile> is the possibly broken file\n");
printf ("and <outfile> is the name of the corrected file\n");
printf ("\t-c checks file only\n");
printf ("\t-s inplace file substitution (only -i needed, dangerous)\n");
printf ("\t-b clean up (eliminates tags to be baseline tiff conform)\n");
printf ("\t-q disables describing messages\n");
printf ("\t-t try to fix tagorder (dangerous)\n");
printf ("\tHint: 'fixit_tiff -i <infile> -o <outfile>' repairs date only\n");
}
static int
tiffcvt(TIFF* in, TIFF* out)
{
uint32 width, height; /* image width & height */
uint16 shortv;
float floatv;
char *stringv;
uint32 longv;
uint16 v[1];
TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField(in, TIFFTAG_IMAGELENGTH, &height);
CopyField(TIFFTAG_SUBFILETYPE, longv);
TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(out, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
CopyField(TIFFTAG_FILLORDER, shortv);
TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
if( no_alpha )
TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3);
else
TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 4);
if( !no_alpha )
{
v[0] = EXTRASAMPLE_ASSOCALPHA;
TIFFSetField(out, TIFFTAG_EXTRASAMPLES, 1, v);
}
CopyField(TIFFTAG_XRESOLUTION, floatv);
CopyField(TIFFTAG_YRESOLUTION, floatv);
CopyField(TIFFTAG_RESOLUTIONUNIT, shortv);
TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(out, TIFFTAG_SOFTWARE, TIFFGetVersion());
CopyField(TIFFTAG_DOCUMENTNAME, stringv);
if( process_by_block && TIFFIsTiled( in ) )
return( cvt_by_tile( in, out ) );
else if( process_by_block )
return( cvt_by_strip( in, out ) );
else
return( cvt_whole_image( in, out ) );
}
/**
* Libtiff version
*/
static PyObject* libtiff_version() {
static const std::string beg_str("LIBTIFF, Version ");
static const size_t beg_len = beg_str.size();
std::string vtiff(TIFFGetVersion());
// Remove first part if it starts with "LIBTIFF, Version "
if(vtiff.compare(0, beg_len, beg_str) == 0)
vtiff = vtiff.substr(beg_len);
// Remove multiple (copyright) lines if any
size_t end_line = vtiff.find("\n");
if(end_line != std::string::npos)
vtiff = vtiff.substr(0,end_line);
return Py_BuildValue("s", vtiff.c_str());
}
void PrintVersion(int mode=0)
{
cout << LISA_VERSION << endl;
if (mode) {
cout << "compiled ";
#ifdef __GNUC__
cout << "with GNU " << __VERSION__;
#endif
#if __x86_64__
cout << " (64-bit)";
#else
cout << " (32-bit)";
#endif
cout << " on " << __DATE__ << endl;
}
#ifdef TIFF_SUPPORT
cout << endl << TIFFGetVersion() << endl;
#endif
}
static void
usage(void)
{
char buf[BUFSIZ];
int i;
setbuf(stderr, buf);
fprintf(stderr, "%s\n\n", TIFFGetVersion());
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; stuff[i] != NULL; i++)
fprintf(stderr, "%s\n", stuff[i]);
exit(-1);
}
int
main(int argc, char* argv[])
{
TIFF *in, *out;
if (argc < 2) {
fprintf(stderr, "%s\n\n", TIFFGetVersion());
fprintf(stderr, "usage: tiffsplit input.tif [prefix]\n");
return (-3);
}
if (argc > 2) {
strncpy(fname, argv[2], sizeof(fname));
fname[sizeof(fname) - 1] = '\0';
}
in = TIFFOpen(argv[1], "r");
if (in != NULL) {
do {
size_t path_len;
char *path;
newfilename();
path_len = strlen(fname) + sizeof(TIFF_SUFFIX);
path = (char *) _TIFFmalloc(path_len);
strncpy(path, fname, path_len);
path[path_len - 1] = '\0';
strncat(path, TIFF_SUFFIX, path_len - strlen(path) - 1);
out = TIFFOpen(path, TIFFIsBigEndian(in)?"wb":"wl");
_TIFFfree(path);
if (out == NULL)
return (-2);
if (!tiffcp(in, out))
return (-1);
TIFFClose(out);
} while (TIFFReadDirectory(in));
(void) TIFFClose(in);
}
return (0);
}
static gboolean
tiff_check_version(gint required_macro, gint required_micro, GError **error)
{
gchar *version = g_strdup(TIFFGetVersion());
gchar *ptr;
gboolean result = TRUE;
gint major;
gint minor;
gint micro;
ptr = strchr(version, '\n');
if (ptr)
*ptr = '\0';
ptr = version;
while (*ptr && !g_ascii_isdigit(*ptr))
ptr++;
if (sscanf(ptr, "%d.%d.%d", &major, &minor, µ) != 3) {
g_warning("Cannot parse TIFF version, proceed with fingers crossed");
}
else if ((major < required_macro)
|| (major == required_macro && minor < required_micro)) {
result = FALSE;
g_set_error(error, GWY_MODULE_FILE_ERROR,
GWY_MODULE_FILE_ERROR_SPECIFIC,
_("LibTIFF too old!\n\n"
"You are using %s. Please update to "
"libtiff version %d.%d or newer."), version,
required_macro, required_micro);
}
g_free(version);
return result;
}
static int
tiffcvt(TIFF* in, TIFF* out)
{
uint32 width, height; /* image width & height */
uint32* raster; /* retrieve RGBA image */
uint16 shortv;
float floatv;
char *stringv;
uint32 longv;
size_t pixel_count;
TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField(in, TIFFTAG_IMAGELENGTH, &height);
pixel_count = width * height;
/* XXX: Check the integer overflow. */
if (!width || !height || pixel_count / width != height) {
TIFFError(TIFFFileName(in),
"Malformed input file; "
"can't allocate buffer for raster of %lux%lu size",
(unsigned long)width, (unsigned long)height);
return 0;
}
raster = (uint32*)_TIFFCheckMalloc(in, pixel_count, sizeof(uint32),
"raster buffer");
if (raster == 0) {
TIFFError(TIFFFileName(in),
"Requested buffer size is %lu elements %lu each",
(unsigned long)pixel_count,
(unsigned long)sizeof(uint32));
return (0);
}
if (!TIFFReadRGBAImage(in, width, height, raster, 0)) {
_TIFFfree(raster);
return (0);
}
CopyField(TIFFTAG_SUBFILETYPE, longv);
TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(out, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
if (compression == COMPRESSION_JPEG)
TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RAW);
CopyField(TIFFTAG_FILLORDER, shortv);
TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3);
CopyField(TIFFTAG_XRESOLUTION, floatv);
CopyField(TIFFTAG_YRESOLUTION, floatv);
CopyField(TIFFTAG_RESOLUTIONUNIT, shortv);
TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
{ char buf[2048];
char *cp = strrchr(TIFFFileName(in), '/');
sprintf(buf, "YCbCr conversion of %s", cp ? cp+1 : TIFFFileName(in));
TIFFSetField(out, TIFFTAG_IMAGEDESCRIPTION, buf);
}
TIFFSetField(out, TIFFTAG_SOFTWARE, TIFFGetVersion());
CopyField(TIFFTAG_DOCUMENTNAME, stringv);
TIFFSetField(out, TIFFTAG_REFERENCEBLACKWHITE, refBlackWhite);
TIFFSetField(out, TIFFTAG_YCBCRSUBSAMPLING,
horizSubSampling, vertSubSampling);
TIFFSetField(out, TIFFTAG_YCBCRPOSITIONING, YCBCRPOSITION_CENTERED);
TIFFSetField(out, TIFFTAG_YCBCRCOEFFICIENTS, ycbcrCoeffs);
rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip);
TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
return (cvtRaster(out, raster, width, height));
}
/*
*---------------------------------------------------------------------------
*
* PictureToTif --
*
* Writes a TIFF format image to the provided data buffer.
*
* Results:
* A standard TCL result. If an error occured, TCL_ERROR is
* returned and an error message will be place in the interpreter
* result. Otherwise, the data sink will contain the binary
* output of the image.
*
* Side Effects:
* Memory is allocated for the data sink.
*
*---------------------------------------------------------------------------
*/
static int
PictureToTif(Tcl_Interp *interp, Blt_Picture picture, Blt_DBuffer dbuffer,
TifExportSwitches *switchesPtr)
{
TIFF *tifPtr;
TIFFErrorHandler oldErrorHandler, oldWarningHandler;
TifMessage message;
int photometric, samplesPerPixel;
int compress, result, nColors;
Picture *srcPtr;
compress = tifCompressionSchemes[switchesPtr->compress];
if (compress == COMPRESSION_NONE) {
fprintf(stderr, "not compressing TIFF output\n");
}
#ifdef notdef
if (!TIFFIsCODECConfigured((unsigned short int)compress)) {
compress = COMPRESSION_NONE;
}
#endif
srcPtr = picture;
Tcl_DStringInit(&message.errors);
Tcl_DStringInit(&message.warnings);
Tcl_DStringAppend(&message.errors, "error writing TIF output: ", -1);
tifMessagePtr = &message;
message.nErrors = message.nWarnings = 0;
oldErrorHandler = TIFFSetErrorHandler(TifError);
oldWarningHandler = TIFFSetWarningHandler(TifWarning);
tifPtr = TIFFClientOpen("data buffer", "w", (thandle_t)dbuffer,
TifRead, /* TIFFReadWriteProc */
TifWrite, /* TIFFReadWriteProc */
TifSeek, /* TIFFSeekProc */
TifClose, /* TIFFCloseProc */
TifSize, /* TIFFSizeProc */
TifMapFile, /* TIFFMapFileProc */
TifUnmapFile); /* TIFFUnmapFileProc */
if (tifPtr == NULL) {
Tcl_AppendResult(interp, "can't register TIF procs: ", (char *)NULL);
return TCL_ERROR;
}
nColors = Blt_QueryColors(srcPtr, (Blt_HashTable *)NULL);
if (Blt_PictureIsColor(srcPtr)) {
samplesPerPixel = (Blt_PictureIsOpaque(srcPtr)) ? 3 : 4;
photometric = PHOTOMETRIC_RGB;
} else {
if (!Blt_PictureIsOpaque(srcPtr)) {
Blt_Picture background;
Blt_Pixel white;
/* Blend picture with solid color background. */
background = Blt_CreatePicture(srcPtr->width, srcPtr->height);
white.u32 = 0xFFFFFFFF;
Blt_BlankPicture(background, &white); /* White background. */
Blt_BlendPictures(background, srcPtr, 0, 0, srcPtr->width,
srcPtr->height, 0, 0);
srcPtr = background;
}
samplesPerPixel = 1;
photometric = PHOTOMETRIC_MINISBLACK;
}
TIFFSetField(tifPtr, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(tifPtr, TIFFTAG_COMPRESSION, (unsigned short int)compress);
TIFFSetField(tifPtr, TIFFTAG_IMAGELENGTH, srcPtr->height);
TIFFSetField(tifPtr, TIFFTAG_IMAGEWIDTH, srcPtr->width);
TIFFSetField(tifPtr, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(tifPtr, TIFFTAG_PHOTOMETRIC, photometric);
TIFFSetField(tifPtr, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(tifPtr, TIFFTAG_RESOLUTIONUNIT, 2);
TIFFSetField(tifPtr, TIFFTAG_ROWSPERSTRIP, srcPtr->height);
TIFFSetField(tifPtr, TIFFTAG_SAMPLESPERPIXEL, samplesPerPixel);
TIFFSetField(tifPtr, TIFFTAG_SOFTWARE, TIFFGetVersion());
TIFFSetField(tifPtr, TIFFTAG_XRESOLUTION, 300.0f);
TIFFSetField(tifPtr, TIFFTAG_YRESOLUTION, 300.0f);
#ifdef WORD_BIGENDIAN
TIFFSetField(tifPtr, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
#else
TIFFSetField(tifPtr, TIFFTAG_FILLORDER, FILLORDER_LSB2MSB);
#endif
result = -1;
{
Blt_Pixel *srcRowPtr;
int destBitsSize;
int y;
unsigned char *destBits;
unsigned char *dp;
destBitsSize = srcPtr->width * srcPtr->height * sizeof(uint32);
destBits = (unsigned char *)_TIFFmalloc(destBitsSize);
if (destBits == NULL) {
TIFFError("tiff", "can't allocate space for TIF buffer");
TIFFClose(tifPtr);
return TCL_ERROR;
}
dp = destBits;
srcRowPtr = srcPtr->bits;
switch (samplesPerPixel) {
case 4:
for (y = 0; y < srcPtr->height; y++) {
Blt_Pixel *sp;
int x;
sp = srcRowPtr;
for (x = 0; x < srcPtr->width; x++) {
dp[0] = sp->Red;
dp[1] = sp->Green;
dp[2] = sp->Blue;
dp[3] = sp->Alpha;
dp += 4, sp++;
}
srcRowPtr += srcPtr->pixelsPerRow;
}
break;
case 3: /* RGB, 100% opaque image. */
for (y = 0; y < srcPtr->height; y++) {
Blt_Pixel *sp;
int x;
sp = srcRowPtr;
for (x = 0; x < srcPtr->width; x++) {
dp[0] = sp->Red;
dp[1] = sp->Green;
dp[2] = sp->Blue;
dp += 3, sp++;
}
srcRowPtr += srcPtr->pixelsPerRow;
}
break;
case 1:
for (y = 0; y < srcPtr->height; y++) {
Blt_Pixel *sp;
int x;
sp = srcRowPtr;
for (x = 0; x < srcPtr->width; x++) {
*dp++ = sp->Red;
sp++;
}
srcRowPtr += srcPtr->pixelsPerRow;
}
break;
}
result = TIFFWriteEncodedStrip(tifPtr, 0, destBits, destBitsSize);
if (result < 0) {
Tcl_AppendResult(interp, "error writing TIFF encoded strip",
(char *)NULL);
}
_TIFFfree(destBits);
}
TIFFClose(tifPtr);
if (result == -1) {
Blt_DBuffer_Free(dbuffer);
}
TIFFSetErrorHandler(oldErrorHandler);
TIFFSetWarningHandler(oldWarningHandler);
if (message.nWarnings > 0) {
Tcl_SetErrorCode(interp, "PICTURE", "TIF_WRITE_WARNINGS",
Tcl_DStringValue(&message.warnings), (char *)NULL);
} else {
Tcl_SetErrorCode(interp, "NONE", (char *)NULL);
}
Tcl_DStringFree(&message.warnings);
if (message.nErrors > 0) {
Tcl_DStringResult(interp, &message.errors);
}
Tcl_DStringFree(&message.errors);
if (srcPtr != picture) {
Blt_FreePicture(srcPtr);
}
return (result == -1) ? TCL_ERROR : TCL_OK;
}
const char*
ImagingTiffVersion(void)
{
return TIFFGetVersion();
}
/*!
* getImagelibVersions()
*
* Return: string of version numbers; e.g.,
* libgif 5.0.3
* libjpeg 8b
* libpng 1.4.3
* libtiff 3.9.5
* zlib 1.2.5
* libwebp 0.3.0
* libopenjp2 2.1.0
*
* Notes:
* (1) The caller has responsibility to free the memory.
*/
char *
getImagelibVersions()
{
char buf[128];
l_int32 first = TRUE;
#if HAVE_LIBJPEG
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr err;
char buffer[JMSG_LENGTH_MAX];
#endif
char *tempStrP;
char *versionNumP;
char *nextTokenP;
char *versionStrP = stringNew("");
#if HAVE_LIBGIF
first = FALSE;
stringJoinInPlace(versionStrP, "libgif ");
#ifdef GIFLIB_MAJOR
snprintf(buf, sizeof(buf), "%d.%d.%d", GIFLIB_MAJOR, GIFLIB_MINOR,
GIFLIB_RELEASE);
#else
stringCopy(buf, "4.1.6(?)", sizeof(buf));
#endif
stringJoinInPlace(versionStrP, buf);
#endif
#if HAVE_LIBJPEG
cinfo.err = jpeg_std_error(&err);
err.msg_code = JMSG_VERSION;
(*err.format_message) ((j_common_ptr ) &cinfo, buffer);
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libjpeg ");
versionNumP = strtokSafe(buffer, " ", &nextTokenP);
stringJoinInPlace(versionStrP, versionNumP);
FREE(versionNumP);
#endif
#if HAVE_LIBPNG
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libpng ");
stringJoinInPlace(versionStrP, png_get_libpng_ver(NULL));
#endif
#if HAVE_LIBTIFF
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libtiff ");
versionNumP = strtokSafe((char *)TIFFGetVersion(), " \n", &nextTokenP);
FREE(versionNumP);
versionNumP = strtokSafe(NULL, " \n", &nextTokenP);
FREE(versionNumP);
versionNumP = strtokSafe(NULL, " \n", &nextTokenP);
stringJoinInPlace(versionStrP, versionNumP);
FREE(versionNumP);
#endif
#if HAVE_LIBZ
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "zlib ");
stringJoinInPlace(versionStrP, zlibVersion());
#endif
#if HAVE_LIBWEBP
{
l_int32 val;
char buf[32];
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libwebp ");
val = WebPGetEncoderVersion();
snprintf(buf, sizeof(buf), "%d.%d.%d", val >> 16, (val >> 8) & 0xff,
val & 0xff);
stringJoinInPlace(versionStrP, buf);
}
#endif
#if HAVE_LIBJP2K
{
const char *version;
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libopenjp2 ");
version = opj_version();
stringJoinInPlace(versionStrP, version);
}
#endif
stringJoinInPlace(versionStrP, "\n");
return versionStrP;
}
/*!
* getImagelibVersions()
*
* Return: string of version numbers; e.g.,
* libgif 5.0.3
* libjpeg 8b (libjpeg-turbo 1.3.0)
* libpng 1.4.3
* libtiff 3.9.5
* zlib 1.2.5
* libwebp 0.3.0
* libopenjp2 2.1.0
*
* Notes:
* (1) The caller must free the memory.
*/
char *
getImagelibVersions()
{
char buf[128];
l_int32 first = TRUE;
char *versionNumP;
char *nextTokenP;
char *versionStrP = NULL;
#if HAVE_LIBGIF
first = FALSE;
stringJoinIP(&versionStrP, "libgif ");
#ifdef GIFLIB_MAJOR
snprintf(buf, sizeof(buf), "%d.%d.%d", GIFLIB_MAJOR, GIFLIB_MINOR,
GIFLIB_RELEASE);
#else
stringCopy(buf, "4.1.6(?)", sizeof(buf));
#endif
stringJoinIP(&versionStrP, buf);
#endif /* HAVE_LIBGIF */
#if HAVE_LIBJPEG
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr err;
char buffer[JMSG_LENGTH_MAX];
cinfo.err = jpeg_std_error(&err);
err.msg_code = JMSG_VERSION;
(*err.format_message) ((j_common_ptr ) &cinfo, buffer);
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libjpeg ");
versionNumP = strtokSafe(buffer, " ", &nextTokenP);
stringJoinIP(&versionStrP, versionNumP);
FREE(versionNumP);
#if defined(LIBJPEG_TURBO_VERSION)
/* To stringify the result of expansion of a macro argument,
* you must use two levels of macros. See:
* https://gcc.gnu.org/onlinedocs/cpp/Stringification.html */
#define l_xstr(s) l_str(s)
#define l_str(s) #s
snprintf(buf, sizeof(buf), " (libjpeg-turbo %s)",
l_xstr(LIBJPEG_TURBO_VERSION));
stringJoinIP(&versionStrP, buf);
#endif /* LIBJPEG_TURBO_VERSION */
}
#endif /* HAVE_LIBJPEG */
#if HAVE_LIBPNG
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libpng ");
stringJoinIP(&versionStrP, png_get_libpng_ver(NULL));
#endif /* HAVE_LIBPNG */
#if HAVE_LIBTIFF
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libtiff ");
versionNumP = strtokSafe((char *)TIFFGetVersion(), " \n", &nextTokenP);
FREE(versionNumP);
versionNumP = strtokSafe(NULL, " \n", &nextTokenP);
FREE(versionNumP);
versionNumP = strtokSafe(NULL, " \n", &nextTokenP);
stringJoinIP(&versionStrP, versionNumP);
FREE(versionNumP);
#endif /* HAVE_LIBTIFF */
#if HAVE_LIBZ
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "zlib ");
stringJoinIP(&versionStrP, zlibVersion());
#endif /* HAVE_LIBZ */
#if HAVE_LIBWEBP
{
l_int32 val;
char buf[32];
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libwebp ");
val = WebPGetEncoderVersion();
snprintf(buf, sizeof(buf), "%d.%d.%d", val >> 16, (val >> 8) & 0xff,
val & 0xff);
stringJoinIP(&versionStrP, buf);
}
#endif /* HAVE_LIBWEBP */
#if HAVE_LIBJP2K
{
const char *version;
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libopenjp2 ");
version = opj_version();
stringJoinIP(&versionStrP, version);
}
#endif /* HAVE_LIBJP2K */
stringJoinIP(&versionStrP, "\n");
return versionStrP;
}
void Send_InitInfo()
{
POVMSAttributeList attrlist;
POVMSAttribute attr;
POVMSObject msg;
int err = kNoErr;
if(err == kNoErr)
err = POVMSObject_New(&msg, kPOVMSType_WildCard);
if(err == kNoErr)
err = POVMSUtil_SetString(&msg, kPOVAttrib_PlatformName, POVRAY_PLATFORM_NAME);
if(err == kNoErr)
err = POVMSUtil_SetFormatString(&msg, kPOVAttrib_CoreVersion,
"Persistence of Vision(tm) Ray Tracer Version %s%s", POV_RAY_VERSION, COMPILER_VER);
if(err == kNoErr)
err = POVMSUtil_SetString(&msg, kPOVAttrib_EnglishText,
DISTRIBUTION_MESSAGE_1 "\n" DISTRIBUTION_MESSAGE_2 "\n" DISTRIBUTION_MESSAGE_3
"\nPOV-Ray is based on DKBTrace 2.12 by David K. Buck & Aaron A. Collins\n" POV_RAY_COPYRIGHT);
if(err == kNoErr)
err = POVMSUtil_SetBool(&msg, kPOVAttrib_Official, POV_RAY_IS_OFFICIAL);
if(err == kNoErr)
err = POVMSAttrList_New(&attrlist);
if(err == kNoErr)
{
for(int i = 0; Primary_Developers[i] != NULL; i++)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
err = POVMSAttr_Set(&attr, kPOVMSType_CString, Primary_Developers[i], strlen(Primary_Developers[i]) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
}
if(err == kNoErr)
err = POVMSObject_Set(&msg, &attrlist, kPOVAttrib_PrimaryDevs);
if(err == kNoErr)
err = POVMSAttrList_New(&attrlist);
if(err == kNoErr)
{
for(int i = 0; Contributing_Authors[i] != NULL; i++)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
err = POVMSAttr_Set(&attr, kPOVMSType_CString, Contributing_Authors[i], strlen(Contributing_Authors[i]) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
}
if(err == kNoErr)
err = POVMSObject_Set(&msg, &attrlist, kPOVAttrib_ContributingDevs);
if(err == kNoErr)
err = POVMSAttrList_New(&attrlist);
#ifndef DONT_SHOW_IMAGE_LIB_VERSIONS
// ZLib library version and copyright notice
if(err == kNoErr)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
const char *tempstr = pov_tsprintf("ZLib %s, Copyright 1995-1998 Jean-loup Gailly and Mark Adler", Extract_Version(zlibVersion()));
err = POVMSAttr_Set(&attr, kPOVMSType_CString, (void *)tempstr, strlen(tempstr) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
// LibPNG library version and copyright notice
if(err == kNoErr)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
const char *tempstr = pov_tsprintf("LibPNG %s, Copyright 1998-2002 Glenn Randers-Pehrson", Extract_Version(png_get_libpng_ver(NULL)));
err = POVMSAttr_Set(&attr, kPOVMSType_CString, (void *)tempstr, strlen(tempstr) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
// LibJPEG library version and copyright notice
if(err == kNoErr)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
const char *tempstr = pov_tsprintf("LibJPEG %s, Copyright 1998 Thomas G. Lane", Extract_Version(JVERSION));
err = POVMSAttr_Set(&attr, kPOVMSType_CString, (void *)tempstr, strlen(tempstr) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
// LibTIFF library version and copyright notice
if(err == kNoErr)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
const char *tempstr = pov_tsprintf("LibTIFF %s, Copyright 1988-1997 Sam Leffler, 1991-1997 SGI", Extract_Version(TIFFGetVersion()));
err = POVMSAttr_Set(&attr, kPOVMSType_CString, (void *)tempstr, strlen(tempstr) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
#endif
if(err == kNoErr)
err = POVMSObject_Set(&msg, &attrlist, kPOVAttrib_ImageLibVersions);
if(err == kNoErr)
err = POVMSMsg_SetupMessage(&msg, kPOVMsgClass_Miscellaneous, kPOVMsgIdent_InitInfo);
if(err == kNoErr)
err = POVMSMsg_SetDestinationAddress(&msg, FRONTEND_ADDRESS);
if(err == kNoErr)
err = POVMS_Send(POVMS_Render_Context, &msg, NULL, kPOVMSSendMode_NoReply);
if(err != 0)
(void)POVMS_ASSERT_OUTPUT("Sending InitInfo failed!", "povmsend.cpp", 0);
}
_declspec (dllexport) void tiffVersion(char x[]) {
const char* p = TIFFGetVersion();
memcpy(x, p, min(strlen(p),231)); // LabVIEW string size limit (unless pre-allocated)
}
int
vips__tiff_write( VipsImage *in, const char *filename,
VipsForeignTiffCompression compression, int Q,
VipsForeignTiffPredictor predictor,
char *profile,
gboolean tile, int tile_width, int tile_height,
gboolean pyramid,
gboolean squash,
gboolean miniswhite,
VipsForeignTiffResunit resunit, double xres, double yres,
gboolean bigtiff,
gboolean rgbjpeg,
gboolean properties, gboolean strip )
{
Write *write;
#ifdef DEBUG
printf( "tiff2vips: libtiff version is \"%s\"\n", TIFFGetVersion() );
#endif /*DEBUG*/
vips__tiff_init();
if( vips_check_coding_known( "vips2tiff", in ) )
return( -1 );
/* Make output image.
*/
if( !(write = write_new( in, filename,
compression, Q, predictor, profile,
tile, tile_width, tile_height, pyramid, squash,
miniswhite, resunit, xres, yres, bigtiff, rgbjpeg,
properties, strip )) )
return( -1 );
if( vips_sink_disc( write->im, write_strip, write ) ) {
write_free( write );
return( -1 );
}
if( !TIFFWriteDirectory( write->layer->tif ) )
return( -1 );
if( write->pyramid ) {
/* Free lower pyramid resources ... this will TIFFClose() (but
* not delete) the smaller layers ready for us to read from
* them again.
*/
if( write->layer->below )
pyramid_free( write->layer->below );
/* Append smaller layers to the main file.
*/
if( write_gather( write ) ) {
write_free( write );
return( -1 );
}
}
write_free( write );
return( 0 );
}
OIIO_EXPORT const char* tiff_imageio_library_version () {
string_view v (TIFFGetVersion());
v = v.substr (0, v.find ('\n'));
return v.c_str();
}
