You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2029 lines
53 KiB
C++
2029 lines
53 KiB
C++
// This code is in the public domain -- castanyo@yahoo.es
|
|
|
|
#include "ImageIO.h"
|
|
#include "Image.h"
|
|
#include "FloatImage.h"
|
|
#include "TgaFile.h"
|
|
#include "PsdFile.h"
|
|
#include "DirectDrawSurface.h"
|
|
#include "PixelFormat.h"
|
|
|
|
#include "nvmath/Color.h"
|
|
#include "nvmath/Half.h"
|
|
|
|
#include "nvcore/Ptr.h"
|
|
#include "nvcore/Utils.h"
|
|
#include "nvcore/Array.inl"
|
|
#include "nvcore/StrLib.h"
|
|
#include "nvcore/StdStream.h"
|
|
#include "nvcore/TextWriter.h"
|
|
|
|
// Extern
|
|
#if defined(HAVE_FREEIMAGE)
|
|
# include <FreeImage.h>
|
|
// If FreeImage available, do not use individual libraries, since that produces link conflicts in some platforms.
|
|
# undef HAVE_JPEG
|
|
# undef HAVE_PNG
|
|
# undef HAVE_TIFF
|
|
# undef HAVE_OPENEXR
|
|
#endif
|
|
|
|
#if defined(HAVE_JPEG)
|
|
extern "C" {
|
|
# include <jpeglib.h>
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_PNG)
|
|
# include <png.h>
|
|
#endif
|
|
|
|
#if defined(HAVE_TIFF)
|
|
# define _TIFF_DATA_TYPEDEFS_
|
|
# include <tiffio.h>
|
|
#endif
|
|
|
|
#if defined(HAVE_OPENEXR)
|
|
# include <ImfIO.h>
|
|
# include <ImathBox.h>
|
|
# include <ImfChannelList.h>
|
|
# include <ImfInputFile.h>
|
|
# include <ImfOutputFile.h>
|
|
# include <ImfArray.h>
|
|
#endif
|
|
|
|
#if defined(HAVE_STBIMAGE)
|
|
# define STBI_NO_STDIO
|
|
# include <stb_image.h>
|
|
#endif
|
|
|
|
|
|
using namespace nv;
|
|
|
|
|
|
|
|
struct Color555 {
|
|
uint16 b : 5;
|
|
uint16 g : 5;
|
|
uint16 r : 5;
|
|
};
|
|
|
|
// Load TGA image.
|
|
static Image * loadTGA(Stream & s)
|
|
{
|
|
nvCheck(!s.isError());
|
|
nvCheck(s.isLoading());
|
|
|
|
TgaHeader tga;
|
|
s << tga;
|
|
s.seek(TgaHeader::Size + tga.id_length);
|
|
|
|
// Get header info.
|
|
bool rle = false;
|
|
bool pal = false;
|
|
bool rgb = false;
|
|
bool grey = false;
|
|
|
|
switch( tga.image_type ) {
|
|
case TGA_TYPE_RLE_INDEXED:
|
|
rle = true;
|
|
// no break is intended!
|
|
case TGA_TYPE_INDEXED:
|
|
if( tga.colormap_type!=1 || tga.colormap_size!=24 || tga.colormap_length>256 ) {
|
|
nvDebug( "*** loadTGA: Error, only 24bit paletted images are supported.\n" );
|
|
return NULL;
|
|
}
|
|
pal = true;
|
|
break;
|
|
|
|
case TGA_TYPE_RLE_RGB:
|
|
rle = true;
|
|
// no break is intended!
|
|
case TGA_TYPE_RGB:
|
|
rgb = true;
|
|
break;
|
|
|
|
case TGA_TYPE_RLE_GREY:
|
|
rle = true;
|
|
// no break is intended!
|
|
case TGA_TYPE_GREY:
|
|
grey = true;
|
|
break;
|
|
|
|
default:
|
|
nvDebug( "*** loadTGA: Error, unsupported image type.\n" );
|
|
return NULL;
|
|
}
|
|
|
|
const uint pixel_size = (tga.pixel_size/8);
|
|
nvDebugCheck(pixel_size <= 4);
|
|
|
|
const uint size = tga.width * tga.height * pixel_size;
|
|
|
|
|
|
// Read palette
|
|
uint8 palette[768];
|
|
if( pal ) {
|
|
nvDebugCheck(tga.colormap_length <= 256);
|
|
s.serialize(palette, 3 * tga.colormap_length);
|
|
}
|
|
|
|
// Decode image.
|
|
uint8 * mem = new uint8[size];
|
|
if( rle ) {
|
|
// Decompress image in src.
|
|
uint8 * dst = mem;
|
|
int num = size;
|
|
|
|
while (num > 0) {
|
|
// Get packet header
|
|
uint8 c;
|
|
s << c;
|
|
|
|
uint count = (c & 0x7f) + 1;
|
|
num -= count * pixel_size;
|
|
|
|
if (c & 0x80) {
|
|
// RLE pixels.
|
|
uint8 pixel[4]; // uint8 pixel[pixel_size];
|
|
s.serialize( pixel, pixel_size );
|
|
do {
|
|
memcpy(dst, pixel, pixel_size);
|
|
dst += pixel_size;
|
|
} while (--count);
|
|
}
|
|
else {
|
|
// Raw pixels.
|
|
count *= pixel_size;
|
|
//file->Read8(dst, count);
|
|
s.serialize(dst, count);
|
|
dst += count;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
s.serialize(mem, size);
|
|
}
|
|
|
|
// Allocate image.
|
|
AutoPtr<Image> img(new Image());
|
|
img->allocate(tga.width, tga.height);
|
|
|
|
int lstep;
|
|
Color32 * dst;
|
|
if( tga.flags & TGA_ORIGIN_UPPER ) {
|
|
lstep = tga.width;
|
|
dst = img->pixels();
|
|
}
|
|
else {
|
|
lstep = - tga.width;
|
|
dst = img->pixels() + (tga.height-1) * tga.width;
|
|
}
|
|
|
|
// Write image.
|
|
uint8 * src = mem;
|
|
if( pal ) {
|
|
for( int y = 0; y < tga.height; y++ ) {
|
|
for( int x = 0; x < tga.width; x++ ) {
|
|
uint8 idx = *src++;
|
|
dst[x].setBGRA(palette[3*idx+0], palette[3*idx+1], palette[3*idx+2], 0xFF);
|
|
}
|
|
dst += lstep;
|
|
}
|
|
}
|
|
else if( grey ) {
|
|
img->setFormat(Image::Format_ARGB);
|
|
|
|
for( int y = 0; y < tga.height; y++ ) {
|
|
for( int x = 0; x < tga.width; x++ ) {
|
|
dst[x].setBGRA(*src, *src, *src, *src);
|
|
src++;
|
|
}
|
|
dst += lstep;
|
|
}
|
|
}
|
|
else {
|
|
|
|
if( tga.pixel_size == 16 ) {
|
|
for( int y = 0; y < tga.height; y++ ) {
|
|
for( int x = 0; x < tga.width; x++ ) {
|
|
Color555 c = *reinterpret_cast<Color555 *>(src);
|
|
uint8 b = (c.b << 3) | (c.b >> 2);
|
|
uint8 g = (c.g << 3) | (c.g >> 2);
|
|
uint8 r = (c.r << 3) | (c.r >> 2);
|
|
dst[x].setBGRA(b, g, r, 0xFF);
|
|
src += 2;
|
|
}
|
|
dst += lstep;
|
|
}
|
|
}
|
|
else if( tga.pixel_size == 24 ) {
|
|
for( int y = 0; y < tga.height; y++ ) {
|
|
for( int x = 0; x < tga.width; x++ ) {
|
|
dst[x].setBGRA(src[0], src[1], src[2], 0xFF);
|
|
src += 3;
|
|
}
|
|
dst += lstep;
|
|
}
|
|
}
|
|
else if( tga.pixel_size == 32 ) {
|
|
img->setFormat(Image::Format_ARGB);
|
|
|
|
for( int y = 0; y < tga.height; y++ ) {
|
|
for( int x = 0; x < tga.width; x++ ) {
|
|
dst[x].setBGRA(src[0], src[1], src[2], src[3]);
|
|
src += 4;
|
|
}
|
|
dst += lstep;
|
|
}
|
|
}
|
|
}
|
|
|
|
// free uncompressed data.
|
|
delete [] mem;
|
|
|
|
return img.release();
|
|
}
|
|
|
|
// Save TGA image.
|
|
static bool saveTGA(Stream & s, const Image * img)
|
|
{
|
|
nvCheck(!s.isError());
|
|
nvCheck(img != NULL);
|
|
nvCheck(img->pixels() != NULL);
|
|
|
|
TgaFile tga;
|
|
tga.head.id_length = 0;
|
|
tga.head.colormap_type = 0;
|
|
tga.head.image_type = TGA_TYPE_RGB;
|
|
|
|
tga.head.colormap_index = 0;
|
|
tga.head.colormap_length = 0;
|
|
tga.head.colormap_size = 0;
|
|
|
|
tga.head.x_origin = 0;
|
|
tga.head.y_origin = 0;
|
|
tga.head.width = img->width();
|
|
tga.head.height = img->height();
|
|
if(img->format() == Image::Format_ARGB) {
|
|
tga.head.pixel_size = 32;
|
|
tga.head.flags = TGA_ORIGIN_UPPER | TGA_HAS_ALPHA;
|
|
}
|
|
else {
|
|
tga.head.pixel_size = 24;
|
|
tga.head.flags = TGA_ORIGIN_UPPER;
|
|
}
|
|
|
|
// @@ Serialize directly.
|
|
tga.allocate();
|
|
|
|
const uint n = img->width() * img->height();
|
|
if(img->format() == Image::Format_ARGB) {
|
|
for(uint i = 0; i < n; i++) {
|
|
Color32 color = img->pixel(i);
|
|
tga.mem[4 * i + 0] = color.b;
|
|
tga.mem[4 * i + 1] = color.g;
|
|
tga.mem[4 * i + 2] = color.r;
|
|
tga.mem[4 * i + 3] = color.a;
|
|
}
|
|
}
|
|
else {
|
|
for(uint i = 0; i < n; i++) {
|
|
Color32 color = img->pixel(i);
|
|
tga.mem[3 * i + 0] = color.b;
|
|
tga.mem[3 * i + 1] = color.g;
|
|
tga.mem[3 * i + 2] = color.r;
|
|
}
|
|
}
|
|
|
|
s << tga;
|
|
|
|
tga.free();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*static Image * loadPPM(Stream & s)
|
|
{
|
|
// @@
|
|
return NULL;
|
|
}*/
|
|
|
|
// Save PPM image.
|
|
static bool savePPM(Stream & s, const Image * img)
|
|
{
|
|
//if (img->depth() != 1) return false;
|
|
//if (img->format() == Image::Format_ARGB) return false;
|
|
|
|
uint w = img->width();
|
|
uint h = img->height();
|
|
|
|
TextWriter writer(&s);
|
|
writer.format("P6\n");
|
|
writer.format("%d %d\n", w, h);
|
|
writer.writeString("255\n");
|
|
for (uint i = 0; i < w * h; i++) {
|
|
Color32 c = img->pixel(i);
|
|
s << (uint8_t&)c.r << (uint8_t&)c.g << (uint8_t&)c.b;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*static FloatImage * loadFloatPFM(Stream & s)
|
|
{
|
|
return NULL;
|
|
}*/
|
|
|
|
/*static bool saveFloatPFM(Stream & s, const FloatImage * img, uint base_channel, uint channel_count)
|
|
{
|
|
return false;
|
|
}*/
|
|
|
|
// Load PSD image.
|
|
static Image * loadPSD(Stream & s)
|
|
{
|
|
nvCheck(!s.isError());
|
|
nvCheck(s.isLoading());
|
|
|
|
s.setByteOrder(Stream::BigEndian);
|
|
|
|
PsdHeader header;
|
|
s << header;
|
|
|
|
if (!header.isValid())
|
|
{
|
|
printf("invalid header!\n");
|
|
return NULL;
|
|
}
|
|
|
|
if (!header.isSupported())
|
|
{
|
|
printf("unsupported file!\n");
|
|
return NULL;
|
|
}
|
|
|
|
int tmp;
|
|
|
|
// Skip mode data.
|
|
s << tmp;
|
|
s.seek(s.tell() + tmp);
|
|
|
|
// Skip image resources.
|
|
s << tmp;
|
|
s.seek(s.tell() + tmp);
|
|
|
|
// Skip the reserved data.
|
|
s << tmp;
|
|
s.seek(s.tell() + tmp);
|
|
|
|
// Find out if the data is compressed.
|
|
// Known values:
|
|
// 0: no compression
|
|
// 1: RLE compressed
|
|
uint16 compression;
|
|
s << compression;
|
|
|
|
if (compression > 1) {
|
|
// Unknown compression type.
|
|
return NULL;
|
|
}
|
|
|
|
uint channel_num = header.channel_count;
|
|
|
|
AutoPtr<Image> img(new Image());
|
|
img->allocate(header.width, header.height);
|
|
|
|
if (channel_num < 4)
|
|
{
|
|
// Clear the image.
|
|
img->fill(Color32(0, 0, 0, 0xFF));
|
|
}
|
|
else
|
|
{
|
|
// Enable alpha.
|
|
img->setFormat(Image::Format_ARGB);
|
|
|
|
// Ignore remaining channels.
|
|
channel_num = 4;
|
|
}
|
|
|
|
|
|
const uint pixel_count = header.height * header.width;
|
|
|
|
static const uint components[4] = {2, 1, 0, 3};
|
|
|
|
if (compression)
|
|
{
|
|
s.seek(s.tell() + header.height * header.channel_count * sizeof(uint16));
|
|
|
|
// Read RLE data.
|
|
for (uint channel = 0; channel < channel_num; channel++)
|
|
{
|
|
uint8 * ptr = (uint8 *)img->pixels() + components[channel];
|
|
|
|
uint count = 0;
|
|
while( count < pixel_count )
|
|
{
|
|
if (s.isAtEnd()) return NULL;
|
|
|
|
uint8 c;
|
|
s << c;
|
|
|
|
uint len = c;
|
|
if (len < 128)
|
|
{
|
|
// Copy next len+1 bytes literally.
|
|
len++;
|
|
count += len;
|
|
if (count > pixel_count) return NULL;
|
|
|
|
while (len != 0)
|
|
{
|
|
s << *ptr;
|
|
ptr += 4;
|
|
len--;
|
|
}
|
|
}
|
|
else if (len > 128)
|
|
{
|
|
// Next -len+1 bytes in the dest are replicated from next source byte.
|
|
// (Interpret len as a negative 8-bit int.)
|
|
len ^= 0xFF;
|
|
len += 2;
|
|
count += len;
|
|
if (s.isAtEnd() || count > pixel_count) return NULL;
|
|
|
|
uint8 val;
|
|
s << val;
|
|
while( len != 0 ) {
|
|
*ptr = val;
|
|
ptr += 4;
|
|
len--;
|
|
}
|
|
}
|
|
else if( len == 128 ) {
|
|
// No-op.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
|
|
// where each channel consists of an 8-bit value for each pixel in the image.
|
|
|
|
// Read the data by channel.
|
|
for (uint channel = 0; channel < channel_num; channel++)
|
|
{
|
|
uint8 * ptr = (uint8 *)img->pixels() + components[channel];
|
|
|
|
// Read the data.
|
|
uint count = pixel_count;
|
|
while (count != 0)
|
|
{
|
|
s << *ptr;
|
|
ptr += 4;
|
|
count--;
|
|
}
|
|
}
|
|
}
|
|
|
|
return img.release();
|
|
}
|
|
|
|
static FloatImage * loadFloatDDS(Stream & s)
|
|
{
|
|
nvCheck(s.isLoading());
|
|
nvCheck(!s.isError());
|
|
|
|
DDSHeader header;
|
|
s << header;
|
|
|
|
// @@ We only support a few formats for now.
|
|
|
|
if (header.pf.fourcc == D3DFMT_A16B16G16R16F) {
|
|
const int size = header.width * header.height;
|
|
uint16 * const data = new uint16[size * 4];
|
|
|
|
//s.serialize(data, size * 4 * sizeof(uint16));
|
|
for (int i = 0; i < 4* size; i++) {
|
|
s << data[i];
|
|
}
|
|
|
|
FloatImage * img = new FloatImage;
|
|
img->allocate(4, header.width, header.height);
|
|
|
|
uint32 * r = (uint32 *)img->channel(0);
|
|
uint32 * g = (uint32 *)img->channel(1);
|
|
uint32 * b = (uint32 *)img->channel(2);
|
|
uint32 * a = (uint32 *)img->channel(3);
|
|
|
|
uint16 * ptr = data;
|
|
for (int i = 0; i < size; i++) {
|
|
*r++ = half_to_float( *ptr++ );
|
|
*g++ = half_to_float( *ptr++ );
|
|
*b++ = half_to_float( *ptr++ );
|
|
*a++ = half_to_float( *ptr++ );
|
|
}
|
|
|
|
delete [] data;
|
|
|
|
return img;
|
|
}
|
|
else if (header.pf.fourcc == D3DFMT_R32F) {
|
|
const int size = header.width * header.height;
|
|
float * const data = new float[size];
|
|
|
|
for (int i = 0; i < size; i++) {
|
|
s << data[i];
|
|
}
|
|
|
|
FloatImage * img = new FloatImage;
|
|
img->allocate(4, header.width, header.height);
|
|
|
|
float * r = img->channel(0);
|
|
|
|
float * ptr = data;
|
|
for (int i = 0; i < size; i++) {
|
|
*r++ = *ptr++;
|
|
}
|
|
|
|
delete [] data;
|
|
|
|
img->clear(1, 0.0f);
|
|
img->clear(2, 0.0f);
|
|
img->clear(3, 1.0f);
|
|
|
|
return img;
|
|
}
|
|
else if (header.pf.fourcc == D3DFMT_L16 || (header.pf.bitcount == 16 && header.pf.rmask == 0xFFFF && header.pf.gmask == 0 && header.pf.bmask == 0 && header.pf.amask == 0))
|
|
{
|
|
const int size = header.width * header.height;
|
|
uint16 * const data = new uint16[size];
|
|
|
|
for (int i = 0; i < size; i++) {
|
|
s << data[i];
|
|
}
|
|
|
|
FloatImage * img = new FloatImage;
|
|
img->allocate(4, header.width, header.height);
|
|
|
|
float * r = img->channel(0);
|
|
|
|
uint16 * ptr = data;
|
|
for (int i = 0; i < size; i++) {
|
|
*r++ = float(*ptr++) / 65535.0f;
|
|
}
|
|
|
|
delete [] data;
|
|
|
|
img->clear(1, 0.0f);
|
|
img->clear(2, 0.0f);
|
|
img->clear(3, 1.0f);
|
|
|
|
return img;
|
|
}
|
|
else if (header.pf.fourcc == D3DFMT_L8 || (header.pf.bitcount == 8 && header.pf.rmask == 0xFF && header.pf.gmask == 0 && header.pf.bmask == 0 && header.pf.amask == 0))
|
|
{
|
|
const int size = header.width * header.height;
|
|
uint8 * const data = new uint8[size];
|
|
|
|
s.serialize(data, size);
|
|
|
|
FloatImage * img = new FloatImage;
|
|
img->allocate(4, header.width, header.height);
|
|
|
|
float * r = img->channel(0);
|
|
|
|
uint8 * ptr = data;
|
|
for (int i = 0; i < size; i++) {
|
|
*r++ = float(*ptr++) / 255.0f;
|
|
}
|
|
|
|
delete [] data;
|
|
|
|
img->clear(1, 0.0f);
|
|
img->clear(2, 0.0f);
|
|
img->clear(3, 1.0f);
|
|
|
|
return img;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static bool saveFloatDDS(Stream & s, const FloatImage * img, uint base_component, uint num_components)
|
|
{
|
|
nvCheck(s.isSaving());
|
|
nvCheck(!s.isError());
|
|
|
|
if (num_components != 4) return false;
|
|
|
|
static const uint D3DFMT_A16B16G16R16F = 113;
|
|
|
|
DDSHeader header;
|
|
header.setTexture2D();
|
|
header.setWidth(img->width());
|
|
header.setHeight(img->height());
|
|
header.setFormatCode(D3DFMT_A16B16G16R16F);
|
|
// ...
|
|
|
|
s << header;
|
|
|
|
uint32 * r = (uint32 *)img->channel(base_component + 0);
|
|
uint32 * g = (uint32 *)img->channel(base_component + 1);
|
|
uint32 * b = (uint32 *)img->channel(base_component + 2);
|
|
uint32 * a = (uint32 *)img->channel(base_component + 3);
|
|
|
|
const uint size = img->width() * img->height();
|
|
for (uint i = 0; i < size; i++) {
|
|
uint16 R = half_from_float( *r++ );
|
|
uint16 G = half_from_float( *g++ );
|
|
uint16 B = half_from_float( *b++ );
|
|
uint16 A = half_from_float( *a++ );
|
|
|
|
s.serialize(&R, sizeof(uint16));
|
|
s.serialize(&G, sizeof(uint16));
|
|
s.serialize(&B, sizeof(uint16));
|
|
s.serialize(&A, sizeof(uint16));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
#if defined(HAVE_PNG)
|
|
|
|
static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
|
|
{
|
|
nvDebugCheck(png_ptr != NULL);
|
|
|
|
Stream * s = (Stream *)png_get_io_ptr(png_ptr);
|
|
s->serialize(data, (int)length);
|
|
|
|
if (s->isError()) {
|
|
png_error(png_ptr, "Read Error");
|
|
}
|
|
}
|
|
|
|
|
|
static Image * loadPNG(Stream & s)
|
|
{
|
|
nvCheck(!s.isError());
|
|
|
|
// Set up a read buffer and check the library version
|
|
png_structp png_ptr;
|
|
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
|
|
if (png_ptr == NULL) {
|
|
// nvDebug( "*** LoadPNG: Error allocating read buffer in file '%s'.\n", name );
|
|
return NULL;
|
|
}
|
|
|
|
// Allocate/initialize a memory block for the image information
|
|
png_infop info_ptr = png_create_info_struct(png_ptr);
|
|
if (info_ptr == NULL) {
|
|
png_destroy_read_struct(&png_ptr, NULL, NULL);
|
|
// nvDebug( "*** LoadPNG: Error allocating image information for '%s'.\n", name );
|
|
return NULL;
|
|
}
|
|
|
|
// Set up the error handling
|
|
if (setjmp(png_jmpbuf(png_ptr))) {
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
|
// nvDebug( "*** LoadPNG: Error reading png file '%s'.\n", name );
|
|
return NULL;
|
|
}
|
|
|
|
// Set up the I/O functions.
|
|
png_set_read_fn(png_ptr, (void*)&s, user_read_data);
|
|
|
|
|
|
// Retrieve the image header information
|
|
png_uint_32 width, height;
|
|
int bit_depth, color_type, interlace_type;
|
|
png_read_info(png_ptr, info_ptr);
|
|
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL);
|
|
|
|
|
|
if (color_type == PNG_COLOR_TYPE_PALETTE && bit_depth <= 8) {
|
|
// Convert indexed images to RGB.
|
|
png_set_expand(png_ptr);
|
|
}
|
|
else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
|
|
// Convert grayscale to RGB.
|
|
png_set_expand(png_ptr);
|
|
}
|
|
else if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
|
|
// Expand images with transparency to full alpha channels
|
|
// so the data will be available as RGBA quartets.
|
|
png_set_expand(png_ptr);
|
|
}
|
|
else if (bit_depth < 8) {
|
|
// If we have < 8 scale it up to 8.
|
|
//png_set_expand(png_ptr);
|
|
png_set_packing(png_ptr);
|
|
}
|
|
|
|
// Reduce bit depth.
|
|
if (bit_depth == 16) {
|
|
png_set_strip_16(png_ptr);
|
|
}
|
|
|
|
// Represent gray as RGB
|
|
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
|
|
png_set_gray_to_rgb(png_ptr);
|
|
}
|
|
|
|
// Convert to RGBA filling alpha with 0xFF.
|
|
if (!(color_type & PNG_COLOR_MASK_ALPHA)) {
|
|
png_set_filler(png_ptr, 0xFF, PNG_FILLER_AFTER);
|
|
}
|
|
|
|
// @todo Choose gamma according to the platform?
|
|
double screen_gamma = 2.2;
|
|
int intent;
|
|
if (png_get_sRGB(png_ptr, info_ptr, &intent)) {
|
|
png_set_gamma(png_ptr, screen_gamma, 0.45455);
|
|
}
|
|
else {
|
|
double image_gamma;
|
|
if (png_get_gAMA(png_ptr, info_ptr, &image_gamma)) {
|
|
png_set_gamma(png_ptr, screen_gamma, image_gamma);
|
|
}
|
|
else {
|
|
png_set_gamma(png_ptr, screen_gamma, 0.45455);
|
|
}
|
|
}
|
|
|
|
// Perform the selected transforms.
|
|
png_read_update_info(png_ptr, info_ptr);
|
|
|
|
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL);
|
|
|
|
AutoPtr<Image> img(new Image());
|
|
img->allocate(width, height);
|
|
|
|
// Set internal format flags.
|
|
if(color_type & PNG_COLOR_MASK_COLOR) {
|
|
//img->flags |= PI_IF_HAS_COLOR;
|
|
}
|
|
if(color_type & PNG_COLOR_MASK_ALPHA) {
|
|
//img->flags |= PI_IF_HAS_ALPHA;
|
|
img->setFormat(Image::Format_ARGB);
|
|
}
|
|
|
|
// Read the image
|
|
uint8 * pixels = (uint8 *)img->pixels();
|
|
png_bytep * row_data = new png_bytep[sizeof(png_byte) * height];
|
|
for (uint i = 0; i < height; i++) {
|
|
row_data[i] = &(pixels[width * 4 * i]);
|
|
}
|
|
|
|
png_read_image(png_ptr, row_data);
|
|
delete [] row_data;
|
|
|
|
// Finish things up
|
|
png_read_end(png_ptr, info_ptr);
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
|
|
|
// RGBA to BGRA.
|
|
uint num = width * height;
|
|
for(uint i = 0; i < num; i++)
|
|
{
|
|
Color32 c = img->pixel(i);
|
|
img->pixel(i) = Color32(c.b, c.g, c.r, c.a);
|
|
}
|
|
|
|
// Compute alpha channel if needed.
|
|
/*if( img->flags & PI_IU_BUMPMAP || img->flags & PI_IU_ALPHAMAP ) {
|
|
if( img->flags & PI_IF_HAS_COLOR && !(img->flags & PI_IF_HAS_ALPHA)) {
|
|
img->ComputeAlphaFromColor();
|
|
}
|
|
}*/
|
|
|
|
return img.release();
|
|
}
|
|
|
|
static void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
|
|
{
|
|
nvDebugCheck(png_ptr != NULL);
|
|
|
|
Stream * s = (Stream *)png_get_io_ptr(png_ptr);
|
|
s->serialize(data, (int)length);
|
|
|
|
if (s->isError()) {
|
|
png_error(png_ptr, "Write Error");
|
|
}
|
|
}
|
|
|
|
static void user_write_flush(png_structp png_ptr) { }
|
|
|
|
static bool savePNG(Stream & s, const Image * img, const char ** tags/*=NULL*/)
|
|
{
|
|
nvCheck(!s.isError());
|
|
nvCheck(img != NULL);
|
|
nvCheck(img->pixels() != NULL);
|
|
|
|
// Set up a write buffer and check the library version
|
|
png_structp png_ptr;
|
|
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
|
|
if (png_ptr == NULL) {
|
|
return false;
|
|
}
|
|
|
|
// Allocate/initialize a memory block for the image information
|
|
png_infop info_ptr = png_create_info_struct(png_ptr);
|
|
if (info_ptr == NULL) {
|
|
png_destroy_write_struct(&png_ptr, NULL);
|
|
return false;
|
|
}
|
|
|
|
// Set up the error handling
|
|
if (setjmp(png_jmpbuf(png_ptr))) {
|
|
png_destroy_write_struct(&png_ptr, &info_ptr);
|
|
return false;
|
|
}
|
|
|
|
// Set up the I/O functions.
|
|
png_set_write_fn(png_ptr, (void*)&s, user_write_data, user_write_flush);
|
|
|
|
// Set image header information
|
|
int color_type = PNG_COLOR_TYPE_RGBA;
|
|
switch(img->format())
|
|
{
|
|
case Image::Format_RGB: color_type = PNG_COLOR_TYPE_RGB; break;
|
|
case Image::Format_ARGB: color_type = PNG_COLOR_TYPE_RGBA; break;
|
|
}
|
|
png_set_IHDR(png_ptr, info_ptr, img->width(), img->height(),
|
|
8, color_type, PNG_INTERLACE_NONE,
|
|
PNG_COMPRESSION_TYPE_DEFAULT,
|
|
PNG_FILTER_TYPE_DEFAULT);
|
|
|
|
// Set image data
|
|
png_bytep * row_data = new png_bytep[sizeof(png_byte) * img->height()];
|
|
for (uint i = 0; i < img->height(); i++) {
|
|
row_data[i] = (png_byte*)img->scanline (i);
|
|
if (img->format() == Image::Format_RGB) row_data[i]--; // This is a bit of a hack, libpng expects images in ARGB format not BGRA, it supports BGR swapping, but not alpha swapping.
|
|
}
|
|
png_set_rows(png_ptr, info_ptr, row_data);
|
|
|
|
png_text * text = NULL;
|
|
if (tags != NULL)
|
|
{
|
|
int count = 0;
|
|
while(tags[2 * count] != NULL) count++;
|
|
|
|
text = new png_text[count];
|
|
memset(text, 0, count * sizeof(png_text);
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
text[i].compression = PNG_TEXT_COMPRESSION_NONE;
|
|
text[i].key = tags[2 * i + 0];
|
|
text[i].text = tags[2 * i + 1];
|
|
}
|
|
|
|
png_set_text(png_ptr, info_ptr, text, count);
|
|
}
|
|
|
|
png_write_png(png_ptr, info_ptr,
|
|
// component order is BGR(A)
|
|
PNG_TRANSFORM_BGR |
|
|
// Strip alpha byte for RGB images
|
|
(img->format() == Image::Format_RGB ? PNG_TRANSFORM_STRIP_FILLER : 0)
|
|
, NULL);
|
|
|
|
// Finish things up
|
|
png_destroy_write_struct(&png_ptr, &info_ptr);
|
|
|
|
delete [] row_data;
|
|
delete [] text;
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif // defined(HAVE_PNG)
|
|
|
|
#if defined(HAVE_JPEG)
|
|
|
|
static void init_source (j_decompress_ptr /*cinfo*/){
|
|
}
|
|
|
|
static boolean fill_input_buffer (j_decompress_ptr cinfo) {
|
|
struct jpeg_source_mgr * src = cinfo->src;
|
|
static JOCTET FakeEOI[] = { 0xFF, JPEG_EOI };
|
|
|
|
// Generate warning
|
|
nvDebug("jpeglib: Premature end of file\n");
|
|
|
|
// Insert a fake EOI marker
|
|
src->next_input_byte = FakeEOI;
|
|
src->bytes_in_buffer = 2;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void skip_input_data (j_decompress_ptr cinfo, long num_bytes) {
|
|
struct jpeg_source_mgr * src = cinfo->src;
|
|
|
|
if(num_bytes >= (long)src->bytes_in_buffer) {
|
|
fill_input_buffer(cinfo);
|
|
return;
|
|
}
|
|
|
|
src->bytes_in_buffer -= num_bytes;
|
|
src->next_input_byte += num_bytes;
|
|
}
|
|
|
|
static void term_source (j_decompress_ptr /*cinfo*/){
|
|
// no work necessary here
|
|
}
|
|
|
|
|
|
static Image * loadJPG(Stream & s)
|
|
{
|
|
nvCheck(!s.isError());
|
|
|
|
// Read the entire file.
|
|
Array<uint8> byte_array;
|
|
byte_array.resize(s.size());
|
|
s.serialize(byte_array.buffer(), s.size());
|
|
|
|
jpeg_decompress_struct cinfo;
|
|
jpeg_error_mgr jerr;
|
|
|
|
cinfo.err = jpeg_std_error(&jerr);
|
|
jpeg_create_decompress(&cinfo);
|
|
|
|
cinfo.src = (struct jpeg_source_mgr *) (*cinfo.mem->alloc_small)
|
|
((j_common_ptr) &cinfo, JPOOL_PERMANENT, sizeof(struct jpeg_source_mgr));
|
|
cinfo.src->init_source = init_source;
|
|
cinfo.src->fill_input_buffer = fill_input_buffer;
|
|
cinfo.src->skip_input_data = skip_input_data;
|
|
cinfo.src->resync_to_restart = jpeg_resync_to_restart; // use default method
|
|
cinfo.src->term_source = term_source;
|
|
cinfo.src->bytes_in_buffer = byte_array.size();
|
|
cinfo.src->next_input_byte = byte_array.buffer();
|
|
|
|
jpeg_read_header(&cinfo, TRUE);
|
|
jpeg_start_decompress(&cinfo);
|
|
|
|
/*
|
|
cinfo.do_fancy_upsampling = FALSE; // fast decompression
|
|
cinfo.dct_method = JDCT_FLOAT; // Choose floating point DCT method.
|
|
*/
|
|
|
|
uint8 * tmp_buffer = new uint8 [cinfo.output_width * cinfo.output_height * cinfo.num_components];
|
|
uint8 * scanline = tmp_buffer;
|
|
|
|
while( cinfo.output_scanline < cinfo.output_height ){
|
|
int num_scanlines = jpeg_read_scanlines (&cinfo, &scanline, 1);
|
|
scanline += num_scanlines * cinfo.output_width * cinfo.num_components;
|
|
}
|
|
|
|
jpeg_finish_decompress(&cinfo);
|
|
|
|
AutoPtr<Image> img(new Image());
|
|
img->allocate(cinfo.output_width, cinfo.output_height);
|
|
|
|
Color32 * dst = img->pixels();
|
|
const int size = img->height() * img->width();
|
|
const uint8 * src = tmp_buffer;
|
|
|
|
if( cinfo.num_components == 3 ) {
|
|
img->setFormat(Image::Format_RGB);
|
|
for( int i = 0; i < size; i++ ) {
|
|
*dst++ = Color32(src[0], src[1], src[2]);
|
|
src += 3;
|
|
}
|
|
}
|
|
else {
|
|
img->setFormat(Image::Format_ARGB);
|
|
for( int i = 0; i < size; i++ ) {
|
|
*dst++ = Color32(*src, *src, *src, *src);
|
|
src++;
|
|
}
|
|
}
|
|
|
|
delete [] tmp_buffer;
|
|
jpeg_destroy_decompress (&cinfo);
|
|
|
|
return img.release();
|
|
}
|
|
|
|
#endif // defined(HAVE_JPEG)
|
|
|
|
#if defined(HAVE_TIFF)
|
|
|
|
/*
|
|
static tsize_t tiffReadWriteProc(thandle_t h, tdata_t ptr, tsize_t size)
|
|
{
|
|
Stream * s = (Stream *)h;
|
|
nvDebugCheck(s != NULL);
|
|
|
|
s->serialize(ptr, size);
|
|
|
|
return size;
|
|
}
|
|
|
|
static toff_t tiffSeekProc(thandle_t h, toff_t offset, int whence)
|
|
{
|
|
Stream * s = (Stream *)h;
|
|
nvDebugCheck(s != NULL);
|
|
|
|
if (!s->isSeekable())
|
|
{
|
|
return (toff_t)-1;
|
|
}
|
|
|
|
if (whence == SEEK_SET)
|
|
{
|
|
s->seek(offset);
|
|
}
|
|
else if (whence == SEEK_CUR)
|
|
{
|
|
s->seek(s->tell() + offset);
|
|
}
|
|
else if (whence == SEEK_END)
|
|
{
|
|
s->seek(s->size() + offset);
|
|
}
|
|
|
|
return s->tell();
|
|
}
|
|
|
|
static int tiffCloseProc(thandle_t)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static toff_t tiffSizeProc(thandle_t h)
|
|
{
|
|
Stream * s = (Stream *)h;
|
|
nvDebugCheck(s != NULL);
|
|
return s->size();
|
|
}
|
|
|
|
static int tiffMapFileProc(thandle_t, tdata_t*, toff_t*)
|
|
{
|
|
// @@ TODO, Implement these functions.
|
|
return -1;
|
|
}
|
|
|
|
static void tiffUnmapFileProc(thandle_t, tdata_t, toff_t)
|
|
{
|
|
// @@ TODO, Implement these functions.
|
|
}
|
|
*/
|
|
|
|
static FloatImage * loadFloatTIFF(const char * fileName, Stream & s)
|
|
{
|
|
nvCheck(!s.isError());
|
|
|
|
TIFF * tif = TIFFOpen(fileName, "r");
|
|
//TIFF * tif = TIFFClientOpen(fileName, "r", &s, tiffReadWriteProc, tiffReadWriteProc, tiffSeekProc, tiffCloseProc, tiffSizeProc, tiffMapFileProc, tiffUnmapFileProc);
|
|
|
|
if (!tif)
|
|
{
|
|
nvDebug("Can't open '%s' for reading\n", fileName);
|
|
return NULL;
|
|
}
|
|
|
|
::uint16 spp, bpp, format;
|
|
::uint32 width, height;
|
|
TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
|
|
TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
|
|
TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bpp);
|
|
TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &spp);
|
|
TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &format);
|
|
|
|
if (bpp != 8 && bpp != 16 && bpp != 32) {
|
|
nvDebug("Can't load '%s', only 1 sample per pixel supported\n", fileName);
|
|
TIFFClose(tif);
|
|
return NULL;
|
|
}
|
|
|
|
AutoPtr<FloatImage> fimage(new FloatImage());
|
|
fimage->allocate(spp, width, height);
|
|
|
|
int linesize = TIFFScanlineSize(tif);
|
|
tdata_t buf = malloc<uint8>(linesize);
|
|
|
|
for (uint y = 0; y < height; y++)
|
|
{
|
|
TIFFReadScanline(tif, buf, y, 0);
|
|
|
|
for (uint c=0; c<spp; c++ )
|
|
{
|
|
float * dst = fimage->scanline(y, c);
|
|
|
|
for(uint x = 0; x < width; x++)
|
|
{
|
|
if (bpp == 8)
|
|
{
|
|
dst[x] = float(((::uint8 *)buf)[x*spp+c]) / float(0xFF);
|
|
}
|
|
else if (bpp == 16)
|
|
{
|
|
dst[x] = float(((::uint16 *)buf)[x*spp+c]) / float(0xFFFF);
|
|
}
|
|
else if (bpp == 32)
|
|
{
|
|
if (format==SAMPLEFORMAT_IEEEFP)
|
|
{
|
|
dst[x] = float(((float *)buf)[x*spp+c]);
|
|
}
|
|
else
|
|
{
|
|
dst[x] = float(((::uint32 *)buf)[x*spp+c] >> 8) / float(0xFFFFFF);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
free(buf);
|
|
|
|
TIFFClose(tif);
|
|
|
|
return fimage.release();
|
|
}
|
|
|
|
static bool saveFloatTIFF(const char * fileName, const FloatImage * fimage, uint base_component, uint num_components)
|
|
{
|
|
nvCheck(fileName != NULL);
|
|
nvCheck(fimage != NULL);
|
|
nvCheck(base_component + num_components <= fimage->componentCount());
|
|
|
|
const int iW = fimage->width();
|
|
const int iH = fimage->height();
|
|
const int iC = num_components;
|
|
|
|
TIFF * image = TIFFOpen(fileName, "w");
|
|
|
|
// Open the TIFF file
|
|
if (image == NULL)
|
|
{
|
|
nvDebug("Could not open '%s' for writing\n", fileName);
|
|
return false;
|
|
}
|
|
|
|
TIFFSetField(image, TIFFTAG_IMAGEWIDTH, iW);
|
|
TIFFSetField(image, TIFFTAG_IMAGELENGTH, iH);
|
|
TIFFSetField(image, TIFFTAG_SAMPLESPERPIXEL, iC);
|
|
TIFFSetField(image, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
|
|
TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, 32);
|
|
|
|
uint32 rowsperstrip = TIFFDefaultStripSize(image, (uint32)-1);
|
|
|
|
TIFFSetField(image, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
|
|
TIFFSetField(image, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
|
|
if (num_components == 3)
|
|
{
|
|
// Set this so that it can be visualized with pfstools.
|
|
TIFFSetField(image, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
|
|
}
|
|
TIFFSetField(image, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
|
|
TIFFSetField(image, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
|
|
|
|
float * scanline = new float[iW * iC];
|
|
for (int y = 0; y < iH; y++)
|
|
{
|
|
for (int c = 0; c < iC; c++)
|
|
{
|
|
const float * src = fimage->scanline(y, base_component + c);
|
|
for (int x = 0; x < iW; x++) scanline[x * iC + c] = src[x];
|
|
}
|
|
if (TIFFWriteScanline(image, scanline, y, 0)==-1)
|
|
{
|
|
nvDebug("Error writing scanline %d\n", y);
|
|
return false;
|
|
}
|
|
}
|
|
delete [] scanline;
|
|
|
|
// Close the file
|
|
TIFFClose(image);
|
|
return true;
|
|
}
|
|
|
|
#endif // defined(HAVE_TIFF)
|
|
|
|
#if defined(HAVE_OPENEXR)
|
|
|
|
namespace
|
|
{
|
|
class ExrStream : public Imf::IStream
|
|
{
|
|
public:
|
|
ExrStream(const char * name, Stream & s) : Imf::IStream(name), m_stream(s)
|
|
{
|
|
nvDebugCheck(s.isLoading());
|
|
}
|
|
|
|
virtual bool read(char c[], int n)
|
|
{
|
|
m_stream.serialize(c, n);
|
|
|
|
if (m_stream.isError())
|
|
{
|
|
throw Iex::InputExc("I/O error.");
|
|
}
|
|
|
|
return m_stream.isAtEnd();
|
|
}
|
|
|
|
virtual Imf::Int64 tellg()
|
|
{
|
|
return m_stream.tell();
|
|
}
|
|
|
|
virtual void seekg(Imf::Int64 pos)
|
|
{
|
|
nvDebugCheck(pos >= 0 && pos < UINT_MAX);
|
|
m_stream.seek((uint)pos);
|
|
}
|
|
|
|
virtual void clear()
|
|
{
|
|
m_stream.clearError();
|
|
}
|
|
|
|
private:
|
|
Stream & m_stream;
|
|
};
|
|
|
|
static int channelIndexFromName(const char* name)
|
|
{
|
|
char c = tolower(name[0]);
|
|
switch (c)
|
|
{
|
|
default:
|
|
case 'r':
|
|
return 0;
|
|
case 'g':
|
|
return 1;
|
|
case 'b':
|
|
return 2;
|
|
case 'a':
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
static FloatImage * loadFloatEXR(const char * fileName, Stream & s)
|
|
{
|
|
nvCheck(s.isLoading());
|
|
nvCheck(!s.isError());
|
|
|
|
ExrStream stream(fileName, s);
|
|
Imf::InputFile inputFile(stream);
|
|
|
|
Imath::Box2i box = inputFile.header().dataWindow();
|
|
|
|
int width = box.max.x - box.min.y + 1;
|
|
int height = box.max.x - box.min.y + 1;
|
|
|
|
const Imf::ChannelList & channels = inputFile.header().channels();
|
|
|
|
// Count channels.
|
|
uint channelCount= 0;
|
|
for (Imf::ChannelList::ConstIterator it = channels.begin(); it != channels.end(); ++it)
|
|
{
|
|
channelCount++;
|
|
}
|
|
|
|
// Allocate FloatImage.
|
|
AutoPtr<FloatImage> fimage(new FloatImage());
|
|
fimage->allocate(channelCount, width, height);
|
|
|
|
// Describe image's layout with a framebuffer.
|
|
Imf::FrameBuffer frameBuffer;
|
|
uint i = 0;
|
|
for (Imf::ChannelList::ConstIterator it = channels.begin(); it != channels.end(); ++it, ++i)
|
|
{
|
|
int channelIndex = channelIndexFromName(it.name());
|
|
frameBuffer.insert(it.name(), Imf::Slice(Imf::FLOAT, (char *)fimage->channel(channelIndex), sizeof(float), sizeof(float) * width));
|
|
}
|
|
|
|
// Read it.
|
|
inputFile.setFrameBuffer (frameBuffer);
|
|
inputFile.readPixels (box.min.y, box.max.y);
|
|
|
|
return fimage.release();
|
|
}
|
|
|
|
static bool saveFloatEXR(const char * fileName, const FloatImage * fimage, uint base_component, uint num_components)
|
|
{
|
|
nvCheck(fileName != NULL);
|
|
nvCheck(fimage != NULL);
|
|
nvCheck(base_component + num_components <= fimage->componentCount());
|
|
nvCheck(num_components > 0 && num_components <= 4);
|
|
|
|
const int w = fimage->width();
|
|
const int h = fimage->height();
|
|
|
|
const char * channelNames[] = {"R", "G", "B", "A"};
|
|
|
|
Imf::Header header (w, h);
|
|
|
|
for (uint c = 0; c < num_components; c++)
|
|
{
|
|
header.channels().insert(channelNames[c], Imf::Channel(Imf::FLOAT));
|
|
}
|
|
|
|
Imf::OutputFile file(fileName, header);
|
|
Imf::FrameBuffer frameBuffer;
|
|
|
|
for (uint c = 0; c < num_components; c++)
|
|
{
|
|
char * channel = (char *) fimage->channel(base_component + c);
|
|
frameBuffer.insert(channelNames[c], Imf::Slice(Imf::FLOAT, channel, sizeof(float), sizeof(float) * w));
|
|
}
|
|
|
|
file.setFrameBuffer(frameBuffer);
|
|
file.writePixels(h);
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif // defined(HAVE_OPENEXR)
|
|
|
|
|
|
#if defined(HAVE_FREEIMAGE)
|
|
|
|
static unsigned DLL_CALLCONV ReadProc(void *buffer, unsigned size, unsigned count, fi_handle handle)
|
|
{
|
|
Stream * s = (Stream *) handle;
|
|
s->serialize(buffer, size * count);
|
|
return count;
|
|
}
|
|
|
|
static unsigned DLL_CALLCONV WriteProc(void *buffer, unsigned size, unsigned count, fi_handle handle)
|
|
{
|
|
Stream * s = (Stream *) handle;
|
|
s->serialize(buffer, size * count);
|
|
return count;
|
|
}
|
|
|
|
static int DLL_CALLCONV SeekProc(fi_handle handle, long offset, int origin)
|
|
{
|
|
Stream * s = (Stream *) handle;
|
|
|
|
switch(origin) {
|
|
case SEEK_SET :
|
|
s->seek(offset);
|
|
break;
|
|
case SEEK_END :
|
|
s->seek(s->size() + offset);
|
|
break;
|
|
case SEEK_CUR :
|
|
s->seek(s->tell() + offset);
|
|
break;
|
|
default :
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static long DLL_CALLCONV TellProc(fi_handle handle)
|
|
{
|
|
Stream * s = (Stream *) handle;
|
|
return s->tell();
|
|
}
|
|
|
|
|
|
Image * nv::ImageIO::loadFreeImage(FREE_IMAGE_FORMAT fif, Stream & s)
|
|
{
|
|
nvCheck(!s.isError());
|
|
|
|
FreeImageIO io;
|
|
io.read_proc = ReadProc;
|
|
io.write_proc = NULL;
|
|
io.seek_proc = SeekProc;
|
|
io.tell_proc = TellProc;
|
|
|
|
FIBITMAP * bitmap = FreeImage_LoadFromHandle(fif, &io, (fi_handle)&s, 0);
|
|
|
|
if (bitmap == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
const int w = FreeImage_GetWidth(bitmap);
|
|
const int h = FreeImage_GetHeight(bitmap);
|
|
|
|
if (FreeImage_GetImageType(bitmap) != FIT_BITMAP)
|
|
{
|
|
// @@ Use tone mapping?
|
|
FIBITMAP * tmp = FreeImage_ConvertToType(bitmap, FIT_BITMAP, true);
|
|
FreeImage_Unload(bitmap);
|
|
bitmap = tmp;
|
|
}
|
|
|
|
nvDebugCheck(FreeImage_GetImageType(bitmap) == FIT_BITMAP);
|
|
if (FreeImage_GetBPP(bitmap) != 32)
|
|
{
|
|
FIBITMAP * tmp = FreeImage_ConvertTo32Bits(bitmap);
|
|
FreeImage_Unload(bitmap);
|
|
bitmap = tmp;
|
|
}
|
|
|
|
|
|
Image * image = new Image();
|
|
image->allocate(w, h, 1); // freeimage can only load 2d images:
|
|
|
|
// Copy the image over to our internal format, FreeImage has the scanlines bottom to top though.
|
|
for (int y=0; y < h; y++)
|
|
{
|
|
const void * src = FreeImage_GetScanLine(bitmap, h - y - 1);
|
|
void * dst = image->scanline(y);
|
|
|
|
memcpy(dst, src, 4 * w);
|
|
}
|
|
|
|
FreeImage_Unload(bitmap);
|
|
|
|
return image;
|
|
}
|
|
|
|
FloatImage * nv::ImageIO::loadFloatFreeImage(FREE_IMAGE_FORMAT fif, Stream & s)
|
|
{
|
|
nvCheck(!s.isError());
|
|
|
|
FreeImageIO io;
|
|
io.read_proc = ReadProc;
|
|
io.write_proc = NULL;
|
|
io.seek_proc = SeekProc;
|
|
io.tell_proc = TellProc;
|
|
|
|
FIBITMAP * bitmap = FreeImage_LoadFromHandle(fif, &io, (fi_handle)&s, 0);
|
|
|
|
if (bitmap == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
const int w = FreeImage_GetWidth(bitmap);
|
|
const int h = FreeImage_GetHeight(bitmap);
|
|
|
|
FREE_IMAGE_TYPE fit = FreeImage_GetImageType(bitmap);
|
|
|
|
FloatImage * floatImage = new FloatImage();
|
|
|
|
switch (fit)
|
|
{
|
|
case FIT_BITMAP:
|
|
floatImage->allocate(4, w, h);
|
|
{
|
|
FIBITMAP * tmp = FreeImage_ConvertTo32Bits(bitmap);
|
|
|
|
uint bitcount = FreeImage_GetBPP(bitmap);
|
|
uint byteCount = bitcount / 8;
|
|
|
|
for (int y=0; y < h; y++)
|
|
{
|
|
const Color32 * src = (const Color32 *)FreeImage_GetScanLine(bitmap, h - y - 1 );
|
|
|
|
float * r = floatImage->scanline(y, 0);
|
|
float * g = floatImage->scanline(y, 1);
|
|
float * b = floatImage->scanline(y, 2);
|
|
float * a = floatImage->scanline(y, 3);
|
|
|
|
for (int x=0; x < w; x++)
|
|
{
|
|
r[x] = float(src[x].r) / 255.0f;
|
|
g[x] = float(src[x].g) / 255.0f;
|
|
b[x] = float(src[x].b) / 255.0f;
|
|
a[x] = float(src[x].a) / 255.0f;
|
|
}
|
|
|
|
src += byteCount;
|
|
}
|
|
|
|
FreeImage_Unload(tmp);
|
|
}
|
|
break;
|
|
case FIT_FLOAT:
|
|
floatImage->allocate(1, w, h);
|
|
|
|
for (int y=0; y < h; y++)
|
|
{
|
|
const float * src = (const float *)FreeImage_GetScanLine(bitmap, h - y - 1 );
|
|
float * dst = floatImage->scanline(y, 0);
|
|
|
|
for (int x=0; x < w; x++)
|
|
{
|
|
dst[x] = src[x];
|
|
}
|
|
}
|
|
break;
|
|
case FIT_UINT16:
|
|
floatImage->allocate(1, w, h);
|
|
|
|
for (int y=0; y < h; y++)
|
|
{
|
|
const uint16 * src = (const uint16 *)FreeImage_GetScanLine(bitmap, h - y - 1 );
|
|
float * dst = floatImage->scanline(y, 0);
|
|
|
|
for (int x=0; x < w; x++)
|
|
{
|
|
dst[x] = float(src[x]) / 65535;
|
|
}
|
|
}
|
|
break;
|
|
case FIT_COMPLEX:
|
|
floatImage->allocate(2, w, h);
|
|
|
|
for (int y=0; y < h; y++)
|
|
{
|
|
const FICOMPLEX * src = (const FICOMPLEX *)FreeImage_GetScanLine(bitmap, h - y - 1 );
|
|
|
|
float * dst_real = floatImage->scanline(y, 0);
|
|
float * dst_imag = floatImage->scanline(y, 1);
|
|
|
|
for (int x=0; x < w; x++)
|
|
{
|
|
dst_real[x] = (float)src[x].r;
|
|
dst_imag[x] = (float)src[x].i;
|
|
}
|
|
}
|
|
break;
|
|
case FIT_RGBF:
|
|
floatImage->allocate(3, w, h);
|
|
|
|
for (int y=0; y < h; y++)
|
|
{
|
|
const FIRGBF * src = (const FIRGBF *)FreeImage_GetScanLine(bitmap, h - y - 1 );
|
|
|
|
float * dst_red = floatImage->scanline(y, 0);
|
|
float * dst_green = floatImage->scanline(y, 1);
|
|
float * dst_blue = floatImage->scanline(y, 2);
|
|
|
|
for (int x=0; x < w; x++)
|
|
{
|
|
dst_red[x] = src[x].red;
|
|
dst_green[x] = src[x].green;
|
|
dst_blue[x] = src[x].blue;
|
|
}
|
|
}
|
|
break;
|
|
case FIT_RGBAF:
|
|
floatImage->allocate(4, w, h);
|
|
|
|
for (int y=0; y < h; y++)
|
|
{
|
|
const FIRGBAF * src = (const FIRGBAF *)FreeImage_GetScanLine(bitmap, h - y - 1 );
|
|
|
|
float * dst_red = floatImage->scanline(y, 0);
|
|
float * dst_green = floatImage->scanline(y, 1);
|
|
float * dst_blue = floatImage->scanline(y, 2);
|
|
float * dst_alpha = floatImage->scanline(y, 3);
|
|
|
|
for (int x=0; x < w; x++)
|
|
{
|
|
dst_red[x] = src[x].red;
|
|
dst_green[x] = src[x].green;
|
|
dst_blue[x] = src[x].blue;
|
|
dst_alpha[x] = src[x].alpha;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
delete floatImage;
|
|
floatImage = NULL;
|
|
}
|
|
|
|
FreeImage_Unload(bitmap);
|
|
|
|
return floatImage;
|
|
}
|
|
|
|
bool nv::ImageIO::saveFreeImage(FREE_IMAGE_FORMAT fif, Stream & s, const Image * img, const char ** tags)
|
|
{
|
|
nvCheck(!s.isError());
|
|
|
|
FreeImageIO io;
|
|
io.read_proc = NULL;
|
|
io.write_proc = WriteProc;
|
|
io.seek_proc = SeekProc;
|
|
io.tell_proc = TellProc;
|
|
|
|
const uint w = img->width();
|
|
const uint h = img->height();
|
|
|
|
FIBITMAP * bitmap = FreeImage_Allocate(w, h, 32);
|
|
|
|
for (uint i = 0; i < h; i++)
|
|
{
|
|
uint8 * scanline = FreeImage_GetScanLine(bitmap, i);
|
|
memcpy(scanline, img->scanline(h - i - 1), w * sizeof(Color32));
|
|
}
|
|
|
|
if (tags != NULL)
|
|
{
|
|
#pragma NV_MESSAGE("TODO: Save image metadata")
|
|
//FreeImage_SetMetadata(
|
|
}
|
|
|
|
bool result = FreeImage_SaveToHandle(fif, bitmap, &io, (fi_handle)&s, 0) != 0;
|
|
|
|
FreeImage_Unload(bitmap);
|
|
|
|
return result;
|
|
}
|
|
|
|
bool nv::ImageIO::saveFloatFreeImage(FREE_IMAGE_FORMAT fif, Stream & s, const FloatImage * img, uint baseComponent, uint componentCount)
|
|
{
|
|
nvCheck(!s.isError());
|
|
|
|
FreeImageIO io;
|
|
io.read_proc = NULL;
|
|
io.write_proc = WriteProc;
|
|
io.seek_proc = SeekProc;
|
|
io.tell_proc = TellProc;
|
|
|
|
const uint w = img->width();
|
|
const uint h = img->height();
|
|
|
|
FREE_IMAGE_TYPE type;
|
|
if (componentCount == 1)
|
|
{
|
|
type = FIT_FLOAT;
|
|
}
|
|
else if (componentCount == 3)
|
|
{
|
|
type = FIT_RGBF;
|
|
}
|
|
else if (componentCount == 4)
|
|
{
|
|
type = FIT_RGBAF;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
|
|
|
|
FIBITMAP * bitmap = FreeImage_AllocateT(type, w, h);
|
|
|
|
for (uint y = 0; y < h; y++)
|
|
{
|
|
float * scanline = (float *)FreeImage_GetScanLine(bitmap, y);
|
|
|
|
for (uint x = 0; x < w; x++)
|
|
{
|
|
for (uint c = 0; c < componentCount; c++)
|
|
{
|
|
scanline[x * componentCount + c] = img->pixel(x, y, baseComponent + c);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool result = FreeImage_SaveToHandle(fif, bitmap, &io, (fi_handle)&s, 0) != 0;
|
|
|
|
FreeImage_Unload(bitmap);
|
|
|
|
return result;
|
|
}
|
|
|
|
#endif // defined(HAVE_FREEIMAGE)
|
|
|
|
|
|
#if defined(HAVE_STBIMAGE)
|
|
|
|
static Image * loadSTB(Stream & s)
|
|
{
|
|
// @@ Assumes stream cursor is at the beginning and that image occupies the whole stream.
|
|
const int size = s.size();
|
|
uint8 * buffer = new uint8[size];
|
|
|
|
s.serialize(buffer, size);
|
|
|
|
int w, h, n;
|
|
uint8 * data = stbi_load_from_memory(buffer, size, &w, &h, &n, 4);
|
|
|
|
delete [] buffer;
|
|
|
|
if (data != NULL) {
|
|
Image * img = new Image;
|
|
img->allocate(w, h);
|
|
img->setFormat(n == 4 ? Image::Format_ARGB : Image::Format_RGB);
|
|
|
|
for (int y = 0; y < h; ++y)
|
|
{
|
|
nv::Color32* dest = img->scanline(y);
|
|
uint8* src = data + y * w * 4;
|
|
|
|
for (int x = 0; x < w; ++x)
|
|
{
|
|
dest[x].r = src[x * 4 + 0];
|
|
dest[x].g = src[x * 4 + 1];
|
|
dest[x].b = src[x * 4 + 2];
|
|
dest[x].a = src[x * 4 + 3];
|
|
}
|
|
}
|
|
|
|
free(data);
|
|
|
|
return img;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static FloatImage * loadFloatSTB(Stream & s)
|
|
{
|
|
// @@ Assumes stream cursor is at the beginning and that image occupies the whole stream.
|
|
const int size = s.size();
|
|
uint8 * buffer = new uint8[size];
|
|
|
|
s.serialize(buffer, size);
|
|
|
|
int w, h, n;
|
|
float * data = stbi_loadf_from_memory(buffer, size, &w, &h, &n, 0);
|
|
|
|
delete [] buffer;
|
|
|
|
// Copy to image.
|
|
if (data != NULL) {
|
|
FloatImage * img = new FloatImage;
|
|
img->allocate(n, w, h);
|
|
|
|
const int count = w * h;
|
|
|
|
for (int c = 0; c < n; c++) {
|
|
float * dst = img->channel(c);
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
dst[i] = data[i*n + c];
|
|
}
|
|
}
|
|
return img;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#endif // defined(HAVE_STBIMAGE)
|
|
|
|
|
|
|
|
|
|
|
|
Image * nv::ImageIO::load(const char * fileName)
|
|
{
|
|
nvDebugCheck(fileName != NULL);
|
|
|
|
StdInputStream stream(fileName);
|
|
|
|
if (stream.isError()) {
|
|
return NULL;
|
|
}
|
|
|
|
return ImageIO::load(fileName, stream);
|
|
}
|
|
|
|
Image * nv::ImageIO::load(const char * fileName, Stream & s)
|
|
{
|
|
nvDebugCheck(fileName != NULL);
|
|
nvDebugCheck(s.isLoading());
|
|
|
|
const char * extension = Path::extension(fileName);
|
|
|
|
if (strCaseDiff(extension, ".tga") == 0) {
|
|
return loadTGA(s);
|
|
}
|
|
|
|
if (strCaseDiff(extension, ".psd") == 0) {
|
|
return loadPSD(s);
|
|
}
|
|
|
|
/*if (strCaseDiff(extension, ".ppm") == 0) {
|
|
return loadPPM(s);
|
|
}*/
|
|
|
|
#if defined(HAVE_JPEG)
|
|
if (strCaseDiff(extension, ".jpg") == 0 || strCaseDiff(extension, ".jpeg") == 0) {
|
|
return loadJPG(s);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_PNG)
|
|
if (strCaseDiff(extension, ".png") == 0) {
|
|
return loadPNG(s);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_FREEIMAGE)
|
|
FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(fileName);
|
|
if (fif != FIF_UNKNOWN && FreeImage_FIFSupportsReading(fif)) {
|
|
return loadFreeImage(fif, s);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_STBIMAGE)
|
|
return loadSTB(s);
|
|
#endif
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool nv::ImageIO::save(const char * fileName, Stream & s, const Image * img, const char ** tags/*=NULL*/)
|
|
{
|
|
nvDebugCheck(fileName != NULL);
|
|
nvDebugCheck(s.isSaving());
|
|
nvDebugCheck(img != NULL);
|
|
|
|
const char * extension = Path::extension(fileName);
|
|
|
|
if (strCaseDiff(extension, ".tga") == 0) {
|
|
return saveTGA(s, img);
|
|
}
|
|
|
|
if (strCaseDiff(extension, ".ppm") == 0) {
|
|
return savePPM(s, img);
|
|
}
|
|
|
|
#if defined(HAVE_PNG)
|
|
if (strCaseDiff(extension, ".png") == 0) {
|
|
return savePNG(s, img, tags);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_FREEIMAGE)
|
|
FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(fileName);
|
|
if (fif != FIF_UNKNOWN && FreeImage_FIFSupportsWriting(fif)) {
|
|
return saveFreeImage(fif, s, img, tags);
|
|
}
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
|
|
bool nv::ImageIO::save(const char * fileName, const Image * img, const char ** tags/*=NULL*/)
|
|
{
|
|
nvDebugCheck(fileName != NULL);
|
|
nvDebugCheck(img != NULL);
|
|
|
|
StdOutputStream stream(fileName);
|
|
if (stream.isError())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return ImageIO::save(fileName, stream, img, tags);
|
|
}
|
|
|
|
FloatImage * nv::ImageIO::loadFloat(const char * fileName)
|
|
{
|
|
nvDebugCheck(fileName != NULL);
|
|
|
|
StdInputStream stream(fileName);
|
|
|
|
if (stream.isError()) {
|
|
return NULL;
|
|
}
|
|
|
|
return loadFloat(fileName, stream);
|
|
}
|
|
|
|
FloatImage * nv::ImageIO::loadFloat(const char * fileName, Stream & s)
|
|
{
|
|
nvDebugCheck(fileName != NULL);
|
|
|
|
const char * extension = Path::extension(fileName);
|
|
|
|
/*if (strCaseDiff(extension, ".pfm") == 0) {
|
|
return loadFloatPFM(s);
|
|
}*/
|
|
|
|
#if defined(HAVE_TIFF)
|
|
#pragma NV_MESSAGE("TODO: Load TIFF from stream.")
|
|
if (strCaseDiff(extension, ".tif") == 0 || strCaseDiff(extension, ".tiff") == 0) {
|
|
return loadFloatTIFF(fileName, s);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_OPENEXR)
|
|
#pragma NV_MESSAGE("TODO: Load EXR from stream.")
|
|
if (strCaseDiff(extension, ".exr") == 0) {
|
|
return loadFloatEXR(fileName, s);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_STBIMAGE)
|
|
if (strCaseDiff(extension, ".hdr") == 0) {
|
|
return loadFloatSTB(s);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_FREEIMAGE)
|
|
FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(fileName);
|
|
if (fif != FIF_UNKNOWN && FreeImage_FIFSupportsReading(fif)) {
|
|
return loadFloatFreeImage(fif, s);
|
|
}
|
|
#endif
|
|
|
|
if (strCaseDiff(extension, ".dds") == 0) {
|
|
const uint spos = s.tell(); // Save stream position.
|
|
FloatImage * floatImage = loadFloatDDS(s);
|
|
if (floatImage != NULL) return floatImage;
|
|
else s.seek(spos);
|
|
}
|
|
|
|
// Try to load as an RGBA8 image and convert to float.
|
|
AutoPtr<Image> img(load(fileName, s));
|
|
if (img != NULL) {
|
|
return new FloatImage(img.ptr());
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool nv::ImageIO::saveFloat(const char * fileName, Stream & s, const FloatImage * fimage, uint baseComponent, uint componentCount)
|
|
{
|
|
if (componentCount == 0) {
|
|
componentCount = fimage->componentCount() - baseComponent;
|
|
}
|
|
if (baseComponent + componentCount < fimage->componentCount()) {
|
|
return false;
|
|
}
|
|
|
|
const char * extension = Path::extension(fileName);
|
|
|
|
if (strCaseDiff(extension, ".dds") == 0) {
|
|
return saveFloatDDS(s, fimage, baseComponent, componentCount);
|
|
}
|
|
|
|
/*if (strCaseDiff(extension, ".pfm") == 0) {
|
|
return saveFloatPFM(s, fimage, baseComponent, componentCount);
|
|
}*/
|
|
|
|
#if defined(HAVE_FREEIMAGE)
|
|
FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(fileName);
|
|
if (fif != FIF_UNKNOWN && FreeImage_FIFSupportsWriting(fif)) {
|
|
return saveFloatFreeImage(fif, s, fimage, baseComponent, componentCount);
|
|
}
|
|
#endif
|
|
|
|
// If everything else fails, save as LDR.
|
|
if (componentCount <= 4)
|
|
{
|
|
AutoPtr<Image> image(fimage->createImage(baseComponent, componentCount));
|
|
nvCheck(image != NULL);
|
|
|
|
if (componentCount == 1)
|
|
{
|
|
Color32 * c = image->pixels();
|
|
const uint count = image->width() * image->height();
|
|
for (uint i = 0; i < count; i++)
|
|
{
|
|
c[i].b = c[i].g = c[i].r;
|
|
}
|
|
}
|
|
|
|
if (componentCount == 4)
|
|
{
|
|
image->setFormat(Image::Format_ARGB);
|
|
}
|
|
|
|
return ImageIO::save(fileName, s, image.ptr());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool nv::ImageIO::saveFloat(const char * fileName, const FloatImage * fimage, uint baseComponent, uint componentCount)
|
|
{
|
|
if (componentCount == 0) {
|
|
componentCount = fimage->componentCount() - baseComponent;
|
|
}
|
|
if (baseComponent + componentCount < fimage->componentCount()) {
|
|
return false;
|
|
}
|
|
|
|
const char * extension = Path::extension(fileName);
|
|
|
|
#if defined(HAVE_OPENEXR)
|
|
if (strCaseDiff(extension, ".exr") == 0) {
|
|
return saveFloatEXR(fileName, fimage, baseComponent, componentCount);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_TIFF)
|
|
if (strCaseDiff(extension, ".tif") == 0 || strCaseDiff(extension, ".tiff") == 0) {
|
|
return saveFloatTIFF(fileName, fimage, baseComponent, componentCount);
|
|
}
|
|
#endif
|
|
|
|
StdOutputStream stream(fileName);
|
|
|
|
if (stream.isError()) {
|
|
return false;
|
|
}
|
|
|
|
return saveFloat(fileName, stream, fimage, baseComponent, componentCount);
|
|
}
|