m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
grafX2/src/tifformat.c
Thomas Bernard addf8d9798 Win32/msvc: build with libtiff
2019-01-04 21:00:56 +01:00

485 lines
14 KiB
C
Raw Blame History

/* vim:expandtab:ts=2 sw=2:
*/
/* Grafx2 - The Ultimate 256-color bitmap paint program
Copyright 2018 Thomas Bernard
Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud)
Grafx2 is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2
of the License.
Grafx2 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Grafx2; if not, see <http://www.gnu.org/licenses/>
*/
///@file tifformat.c
/// Support of TIFF
///
/// @todo use TIFFSetErrorHandler() and TIFFSetWarningHandler() to
/// redirect warning/error output to our own functions
#ifndef __no_tifflib__
#ifdef _MSC_VER
#include <stdio.h>
#if _MSC_VER < 1900
#define snprintf _snprintf
#define fileno _fileno
#endif
#endif
#include <tiffio.h>
#include "global.h"
#include "io.h"
#include "loadsave.h"
#include "gfx2log.h"
extern char Program_version[]; // generated in pversion.c
extern const char SVN_revision[]; // generated in version.c
/// test for a valid TIFF
void Test_TIFF(T_IO_Context * context, FILE * file)
{
char buffer[4];
File_error = 1;
if (!Read_bytes(file, buffer, 4))
return;
if (0 == memcmp(buffer, "MM\0*", 4) || 0 == memcmp(buffer, "II*\0", 4))
File_error = 0;
}
/// Load current image in TIFF
static void Load_TIFF_image(T_IO_Context * context, TIFF * tif, word spp, word bps)
{
tsize_t size;
int x, y;
unsigned int i, j;
if (TIFFIsTiled(tif))
{
// Tiled image
dword tile_width, tile_height;
if (!TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width) || !TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height))
{
File_error = 2;
return;
}
if (spp > 1 || bps > 8)
{
dword * buffer;
dword x2, y2;
buffer = malloc(sizeof(dword) * tile_width * tile_height);
for (y = 0; y < context->Height; y += tile_height)
{
for (x = 0; x < context->Width; x += tile_width)
{
if (!TIFFReadRGBATile(tif, x, y, buffer))
{
free(buffer);
File_error = 2;
return;
}
j = 0;
// Note that the raster is assume to be organized such that the pixel at
// location (x,y) is raster[y*width+x]; with the raster origin in the
// lower-left hand corner of the tile. That is bottom to top organization.
// Edge tiles which partly fall off the image will be filled out with
// appropriate zeroed areas.
for (y2 = 0; y2 < tile_height; y2++)
{
int y_pos = y + tile_height - 1 - y2;
for (x2 = 0; x2 < tile_width ; x2++)
{
Set_pixel_24b(context, x + x2, y_pos, TIFFGetR(buffer[j]), TIFFGetG(buffer[j]), TIFFGetB(buffer[j]));
j++;
}
}
}
}
free(buffer);
}
else
{
byte * buffer;
//ttile_t tile;
size = TIFFTileSize(tif);
buffer = malloc(size);
for (y = 0; y < context->Height; y += tile_height)
{
for (x = 0; x < context->Width; x += tile_width)
{
dword x2, y2;
if (TIFFReadTile(tif, buffer, x, y, 0, 0) == -1)
{
free(buffer);
File_error = 2;
return;
}
j = 0;
for (y2 = 0; y2 < tile_height; y2++)
{
for (x2 = 0; x2 < tile_width ; x2++)
{
Set_pixel(context, x + x2, y + y2, buffer[j]);
j++;
}
}
}
}
free(buffer);
}
}
else
{
dword rows_per_strip = 0;
tstrip_t strip, strip_count;
// "Striped" image
TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rows_per_strip);
if (rows_per_strip == 0)
{
File_error = 2;
return;
}
if (spp > 1 || bps > 8)
{
// if not 8bit with colormap, use TIFFReadRGBAStrip
dword * buffer;
strip_count = (context->Height + rows_per_strip - 1) / rows_per_strip;
buffer = malloc(sizeof(dword) * rows_per_strip * context->Width);
for (strip = 0, y = 0; strip < strip_count; strip++)
{
if (!TIFFReadRGBAStrip(tif, strip * rows_per_strip, buffer))
{
free(buffer);
File_error = 2;
return;
}
// Note that the raster is assume to be organized such that the
// pixel at location (x,y) is raster[y*width+x]; with the raster
// origin in the lower-left hand corner of the strip. That is bottom
// to top organization. When reading a partial last strip in the
// file the last line of the image will begin at the beginning of
// the buffer.
y = (strip + 1) * rows_per_strip - 1;
if (y >= context->Height)
y = context->Height - 1;
for (i = 0, j = 0;
i < rows_per_strip && y >= (int)(strip * rows_per_strip);
i++, y--)
{
for (x = 0; x < context->Width; x++)
{
Set_pixel_24b(context, x, y, TIFFGetR(buffer[j]), TIFFGetG(buffer[j]), TIFFGetB(buffer[j]));
j++;
}
}
}
free(buffer);
return; // ignore next image for now...
}
else
{
byte * buffer = NULL;
strip_count = TIFFNumberOfStrips(tif);
size = TIFFStripSize(tif);
GFX2_Log(GFX2_DEBUG, "TIFF %u strips of %u bytes\n", strip_count, size);
buffer = malloc(size);
for (strip = 0, y = 0; strip < strip_count; strip++)
{
tsize_t r = TIFFReadEncodedStrip(tif, strip, buffer, size);
if (r == -1)
{
free(buffer);
File_error = 2;
return;
}
for (i = 0, j = 0; i < rows_per_strip && y < context->Height; i++, y++)
{
for (x = 0; x < context->Width; x++)
{
switch (bps)
{
case 8:
Set_pixel(context, x, y, buffer[j++]);
break;
case 6: // 3 bytes => 4 pixels
Set_pixel(context, x++, y, buffer[j] >> 2);
if (x < context->Width)
{
Set_pixel(context, x++, y, (buffer[j] & 3) << 4 | (buffer[j+1] & 0xf0) >> 4);
j++;
if (x < context->Width)
{
Set_pixel(context, x++, y, (buffer[j] & 0x0f) << 2 | (buffer[j+1] & 0xc0) >> 6);
j++;
Set_pixel(context, x, y, buffer[j] & 0x3f);
}
}
j++;
break;
case 4:
Set_pixel(context, x++, y, buffer[j] >> 4);
Set_pixel(context, x, y, buffer[j++] & 0x0f);
break;
case 2:
Set_pixel(context, x++, y, buffer[j] >> 6);
Set_pixel(context, x++, y, (buffer[j] >> 4) & 3);
Set_pixel(context, x++, y, (buffer[j] >> 2) & 3);
Set_pixel(context, x, y, buffer[j++] & 3);
break;
case 1:
Set_pixel(context, x++, y, (buffer[j] >> 7) & 1);
Set_pixel(context, x++, y, (buffer[j] >> 6) & 1);
Set_pixel(context, x++, y, (buffer[j] >> 5) & 1);
Set_pixel(context, x++, y, (buffer[j] >> 4) & 1);
Set_pixel(context, x++, y, (buffer[j] >> 3) & 1);
Set_pixel(context, x++, y, (buffer[j] >> 2) & 1);
Set_pixel(context, x++, y, (buffer[j] >> 1) & 1);
Set_pixel(context, x, y, buffer[j++] & 1);
break;
default:
File_error = 2;
GFX2_Log(GFX2_ERROR, "TIFF : %u bps unsupported\n", bps);
free(buffer);
return;
}
}
}
}
free(buffer);
}
}
}
/// Load TIFF
void Load_TIFF_Sub(T_IO_Context * context, TIFF * tif, unsigned long file_size)
{
int layer = 0;
enum PIXEL_RATIO ratio = PIXEL_SIMPLE;
dword width, height;
word bps, spp;
word photometric = PHOTOMETRIC_RGB;
char * desc;
TIFFPrintDirectory(tif, stdout, TIFFPRINT_NONE);
if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) || !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))
return;
if (!TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bps) || !TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &spp))
return;
GFX2_Log(GFX2_DEBUG, "TIFF #0 : %ux%u %ux%ubps\n", width, height, spp, bps);
if (TIFFGetField(tif, TIFFTAG_IMAGEDESCRIPTION, &desc))
{
size_t len = strlen(desc);
if (len <= COMMENT_SIZE)
memcpy(context->Comment, desc, len + 1);
else
{
memcpy(context->Comment, desc, COMMENT_SIZE);
context->Comment[COMMENT_SIZE] = '\0';
}
}
TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric);
File_error = 0;
Pre_load(context, width, height, file_size, FORMAT_TIFF, ratio, bps * spp);
if (File_error != 0)
return;
if (spp == 1)
{
struct {
word * r;
word * g;
word * b;
} colormap;
unsigned i, count;
count = (bps <= 8) ? 1 << bps : 256;
if (TIFFGetField(tif, TIFFTAG_COLORMAP, &colormap.r, &colormap.g, &colormap.b))
{
for (i = 0; i < count; i++)
{
context->Palette[i].R = colormap.r[i] >> 8;
context->Palette[i].G = colormap.g[i] >> 8;
context->Palette[i].B = colormap.b[i] >> 8;
}
}
else
{
// Grayscale palette
for (i = 0; i < count; i++)
{
unsigned int value = 255
* (photometric == PHOTOMETRIC_MINISWHITE ? (count - 1 - i) : i)
/ (count - 1);
context->Palette[i].R = value;
context->Palette[i].G = value;
context->Palette[i].B = value;
}
}
}
for (;;)
{
Load_TIFF_image(context, tif, spp, bps);
if (File_error != 0)
return;
if (context->Type != CONTEXT_MAIN_IMAGE)
return;
if (!TIFFReadDirectory(tif))
return;
if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) || !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))
return;
if (!TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bps) || !TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &spp))
return;
layer++;
GFX2_Log(GFX2_DEBUG, "TIFF #%d : %ux%u %ux%ubps\n", layer, width, height, spp, bps);
if ((int)width != context->Width || (int)height != context->Height)
return;
if (context->bpp != (spp * bps))
return;
Set_loading_layer(context, layer);
TIFFPrintDirectory(tif, stdout, TIFFPRINT_NONE);
}
}
/// Load TIFF from file
void Load_TIFF(T_IO_Context * context)
{
TIFF * tif;
#if !defined(WIN32)
FILE * file;
File_error = 1;
file = Open_file_read(context);
if (file != NULL)
{
tif = TIFFFdOpen(fileno(file), context->File_name, "r");
if (tif != NULL)
{
Load_TIFF_Sub(context, tif, File_length_file(file));
TIFFClose(tif);
}
fclose(file);
}
#else
char filename[MAX_PATH_CHARACTERS]; // filename with full path
File_error = 1;
Get_full_filename(filename, context->File_name, context->File_directory);
tif = TIFFOpen(filename, "r");
if (tif != NULL)
{
Load_TIFF_Sub(context, tif, File_length(filename));
TIFFClose(tif);
}
#endif
}
void Save_TIFF_Sub(T_IO_Context * context, TIFF * tif)
{
char version[64];
int i;
int layer = 0;
dword width, height;
dword y;
tstrip_t strip;
struct {
word r[256];
word g[256];
word b[256];
} colormap;
const word bps = 8;
const word spp = 1;
const dword rowsperstrip = 64;
snprintf(version, sizeof(version), "GrafX2 %s.%s", Program_version, SVN_revision);
width = context->Width;
height = context->Height;
for (i = 0; i < 256; i++)
{
colormap.r[i] = 0x101 * context->Palette[i].R;
colormap.g[i] = 0x101 * context->Palette[i].G;
colormap.b[i] = 0x101 * context->Palette[i].B;
}
for (;;)
{
GFX2_Log(GFX2_DEBUG, "TIFF save layer #%d\n", layer);
TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, spp);
TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
//TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); // not relevant if SAMPLESPERPIXEL == 1
TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
if (context->Comment[0] != '\0')
TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, context->Comment);
TIFFSetField(tif, TIFFTAG_SOFTWARE, version);
TIFFSetField(tif, TIFFTAG_COLORMAP, colormap.r, colormap.g, colormap.b);
#if 0
for (y = 0; y < height; y++)
{
if (TIFFWriteScanline(tif, context->Target_address + y*context->Pitch, y, 0) < 0)
return;
}
#else
for (y = 0, strip = 0; y < height; y += rowsperstrip, strip++)
{
if (TIFFWriteEncodedStrip(tif, strip, context->Target_address + y*context->Pitch, rowsperstrip * context->Pitch) < 0)
return;
}
#endif
layer++;
if (layer >= context->Nb_layers)
{
TIFFFlushData(tif);
File_error = 0; // everything was fine
return;
}
Set_saving_layer(context, layer);
if (!TIFFWriteDirectory(tif))
return;
TIFFFlushData(tif);
}
}
/// Save TIFF
void Save_TIFF(T_IO_Context * context)
{
TIFF * tif;
File_error = 1;
#if defined(WIN32)
if (context->File_name_unicode != NULL && context->File_name_unicode[0] != 0)
tif = TIFFOpenW(context->File_name_unicode, "w");
else
#endif
tif = TIFFOpen(context->File_name, "w");
if (tif != NULL)
{
Save_TIFF_Sub(context, tif);
TIFFClose(tif);
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink