osg::PNGImageFileType Class Reference
[Image]

PNG File Handler. See Image for a detailed description. More...

#include <OSGPNGImageFileType.h>

Inheritance diagram for osg::PNGImageFileType:

List of all members.

Safe Store/Restore
UInt64	store (const ImagePtr &image, UChar8 *buffer, Int32 memSize=-1)
virtual UInt64	maxBufferSize (const ImagePtr &image)
static UInt64	restore (ImagePtr &image, const UChar8 *buffer, Int32 memSize=-1)
static UInt64	store (const ImagePtr &image, const char *mimeType, UChar8 *buffer, Int32 memSize=-1)
Public Types
Flags
enum	{ OSG_READ_SUPPORTED = 1, OSG_WRITE_SUPPORTED = 2 }
Public Member Functions
Destructor
virtual	~PNGImageFileType (void)
Read/Write
virtual bool	validateHeader (const Char8 *fileName, bool &implemented)
virtual bool	read (ImagePtr &image, std::istream &is, const std::string &mimetype)
virtual bool	write (const ImagePtr &image, std::ostream &os, const std::string &mimetype)
virtual std::string	determineMimetypeFromStream (std::istream &is)
Buffer
virtual UInt64	restoreData (ImagePtr &image, const UChar8 *buffer, Int32 memSize=-1)
virtual UInt64	storeData (const ImagePtr &image, UChar8 *buffer, Int32 memSize=-1)
Set
void	setOptions (const Char8 *options)
Get Methods
const Char8 *	getMimeType (void) const
const std::list< IDString > &	getSuffixList (void) const
virtual UInt32	getFlags (void) const
const Char8 *	getOptions (void)
Read/Write
virtual bool	read (ImagePtr &image, const Char8 *fileName)
virtual bool	write (const ImagePtr &image, const Char8 *fileName)
dump
void	dump (void)
Static Public Member Functions
Get Method
static PNGImageFileType &	the (void)
Protected Member Functions
Default Constructor
	PNGImageFileType (const Char8 *mimeType, const Char8 *suffixArray[], UInt16 suffixByteCount, UInt32 flags)
Protected Attributes
MTD Header
std::string	_options
Private Member Functions
Copy Constructor
	PNGImageFileType (const PNGImageFileType &obj)
Copy Operator
const PNGImageFileType &	operator= (const PNGImageFileType &obj)
Static Private Attributes
static PNGImageFileType	_the

---

Detailed Description

Image File Type to read/write and store/restore Image objects as PNG data.

To be able to load PNG images you need the PNG library, (check the Prerequisites page on www.opensg.org). The lib comes with all Linux distributions.

You have to --enable-png in the configure line to enable the singleton object.

Definition at line 56 of file OSGPNGImageFileType.h.

---

Member Enumeration Documentation

anonymous enum [inherited]

Enumerator:

OSG_READ_SUPPORTED
OSG_WRITE_SUPPORTED

Definition at line 66 of file OSGImageFileType.h.

    {
        OSG_READ_SUPPORTED = 1,
        OSG_WRITE_SUPPORTED = 2
    };

---

Constructor & Destructor Documentation

PNGImageFileType::~PNGImageFileType

(

void

)

[virtual]

Destructor

Definition at line 948 of file OSGPNGImageFileType.cpp.

{}

PNGImageFileType::PNGImageFileType	(	const Char8 *	mimeType,
		const Char8 *	suffixArray[],
		UInt16	suffixByteCount,
		UInt32	flags
	)			[protected]

Constructor used for the singleton object

Definition at line 937 of file OSGPNGImageFileType.cpp.

                                                   :
    ImageFileType(mimeType, suffixArray, suffixByteCount, flags)
{}

osg::PNGImageFileType::PNGImageFileType

(

const PNGImageFileType &

obj

)

[private]

---

Member Function Documentation

bool PNGImageFileType::validateHeader	(	const Char8 *	fileName,
		bool &	implemented
	)			[virtual]

Reimplemented from osg::ImageFileType.

Definition at line 571 of file OSGPNGImageFileType.cpp.

{
    implemented = true;

    if(fileName == NULL)
        return false;

    FILE *file = fopen(fileName, "rb");
    if(file == NULL)
        return false;

    std::string magic;
    magic.resize(4);
    fread((void *) &magic[0], 4, 1, file);
    fclose(file);

    if(magic == "\x89PNG")
    {
        return true;
    }

    return false;
}

bool PNGImageFileType::read	(	ImagePtr &	image,
		std::istream &	is,
		const std::string &	mimetype
	)			[virtual]

Tries to fill the image object with the data read from the given input stream. Returns true on success.

Reimplemented from osg::ImageFileType.

Definition at line 165 of file OSGPNGImageFileType.cpp.

References FWARNING, osg::ImageFileType::getMimeType(), osg::Image::OSG_INVALID_PF, osg::Image::OSG_L_PF, osg::Image::OSG_LA_PF, osg::Image::OSG_RESUNIT_INCH, osg::Image::OSG_RGB_PF, osg::Image::OSG_RGBA_PF, osg::Image::OSG_UINT16_IMAGEDATA, osg::Image::OSG_UINT8_IMAGEDATA, and SWARNING.

{
#ifdef OSG_WITH_PNG

    bool                retCode;
    Image::PixelFormat  pixelFormat = osg::Image::OSG_INVALID_PF;
    png_structp         png_ptr;
    png_infop           info_ptr;
    png_uint_32         width, wc, height, h, i, res_x, res_y;
    png_byte            bit_depth, channels, color_type;
    png_bytep           *row_pointers, base;

    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
    if(!png_ptr)
        return false;

    png_set_error_fn(png_ptr, 0, &errorOutput, &warningOutput);

    info_ptr = png_create_info_struct(png_ptr);
    if(!info_ptr)
    {
        png_destroy_read_struct(&png_ptr, 0, 0);
        return false;
    }

    if(setjmp(png_ptr->jmpbuf))
    {
        png_destroy_read_struct(&png_ptr, &info_ptr, 0);
        return false;
    }

    png_set_read_fn(png_ptr, &is, &isReadFunc);

    png_read_info(png_ptr, info_ptr);

    width = png_get_image_width(png_ptr, info_ptr);
    height = png_get_image_height(png_ptr, info_ptr);
    bit_depth = png_get_bit_depth(png_ptr, info_ptr);
    res_x = png_get_x_pixels_per_meter(png_ptr, info_ptr);
    res_y = png_get_y_pixels_per_meter(png_ptr, info_ptr);
    channels = png_get_channels(png_ptr, info_ptr);
    color_type = png_get_color_type(png_ptr, info_ptr);

    // Convert paletted images to RGB
    if (color_type == PNG_COLOR_TYPE_PALETTE)
    {
      png_set_palette_to_rgb(png_ptr);
      channels = 3;
      bit_depth = 8;
    }

    // Convert < 8 bit to 8 bit
    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
      png_set_gray_1_2_4_to_8(png_ptr);
      bit_depth = 8;
    }

#if BYTE_ORDER == LITTLE_ENDIAN
    if (bit_depth == 16)
      png_set_swap(png_ptr);
#endif

    // Add a full alpha channel if there is transparency
    // information in a tRNS chunk
    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
    {
      png_set_tRNS_to_alpha(png_ptr);
      ++channels;
    }                                                                                
    Int32 dataType;
    switch (bit_depth) {
    case 8:
      dataType = Image::OSG_UINT8_IMAGEDATA;
      break;
    case 16:
      dataType = Image::OSG_UINT16_IMAGEDATA;
      break;
    default:
      FWARNING (( "Invalid bit_depth: %d, can not read png-data\n",
                  bit_depth ));
      return false;
    }

    switch(channels)
    {
    case 1:
        pixelFormat = Image::OSG_L_PF;
        break;
    case 2:
        pixelFormat = Image::OSG_LA_PF;
        break;
    case 3:
        pixelFormat = Image::OSG_RGB_PF;
        break;
    case 4:
        pixelFormat = Image::OSG_RGBA_PF;
        break;
    };

    if(image->set( pixelFormat, width, height,
                   1, 1, 1, 0.0, 0,
                   dataType ))
    {
        // set resolution png supports only pixel per meter,
        // so we do a conversion to dpi with some rounding.
        res_x = png_uint_32((Real32(res_x) / 39.37007874f) < 0.0f ?
                            (Real32(res_x) / 39.37007874f) - 0.5f :
                            (Real32(res_x) / 39.37007874f) + 0.5f);
        res_y = png_uint_32((Real32(res_y) / 39.37007874f) < 0.0f ?
                            (Real32(res_y) / 39.37007874f) - 0.5f :
                            (Real32(res_y) / 39.37007874f) + 0.5f);

        image->setResX(Real32(res_x));
        image->setResY(Real32(res_y));
        image->setResUnit(Image::OSG_RESUNIT_INCH);

        // Calculate the row pointers
        row_pointers = new png_bytep[height];
        wc = width * channels * (bit_depth / 8);
        h = height - 1;
        base = image->getData();
        for(i = 0; i < height; ++i)
            row_pointers[i] = base + (h - i) * wc;

        // Read the image data
        png_read_image(png_ptr, row_pointers);

        delete[] row_pointers;

        retCode = true;
    }
    else
        retCode = false;

    png_destroy_read_struct(&png_ptr, &info_ptr, 0);

    return retCode;

#else

    SWARNING <<
        getMimeType() <<
        " read is not compiled into the current binary " <<
        std::endl;
    return false;

#endif

}

bool PNGImageFileType::write	(	const ImagePtr &	img,
		std::ostream &	os,
		const std::string &	mimetype
	)			[virtual]

Tries to write the image object to the given output stream. Returns true on success. Based on the public domain example.c from the PNG dist.

Reimplemented from osg::ImageFileType.

Definition at line 322 of file OSGPNGImageFileType.cpp.

References osg::endLog(), FWARNING, osg::ImageFileType::getMimeType(), osg::Image::OSG_BGR_PF, osg::Image::OSG_BGRA_PF, osg::Image::OSG_L_PF, osg::Image::OSG_LA_PF, osg::Image::OSG_RESUNIT_INCH, osg::Image::OSG_RGB_PF, osg::Image::OSG_RGBA_PF, osg::Image::OSG_UINT16_IMAGEDATA, osg::Image::OSG_UINT8_IMAGEDATA, and SWARNING.

{
#ifdef OSG_WITH_PNG

    png_structp png_ptr;
    png_infop info_ptr;

    if(img->getDimension() < 1 || img->getDimension() > 2)
    {
        FWARNING(("PNGImageFileType::write: invalid dimension %d!\n",
            img->getDimension()));
        return false;
    }
    
    /* Create and initialize the png_struct with the desired error handler
    * functions.  If you want to use the default stderr and longjump method,
    * you can supply NULL for the last three parameters.  We also check that
    * the library version is compatible with the one used at compile time,
    * in case we are using dynamically linked libraries.  REQUIRED.
    */
    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
                                0, &errorOutput, &warningOutput);

    if (png_ptr == NULL)
      return false;

    /* Allocate/initialize the image information data.  REQUIRED */
    info_ptr = png_create_info_struct(png_ptr);
    if (info_ptr == NULL)
    {
      png_destroy_write_struct(&png_ptr,  NULL);
      return false;
    }

    /* set up the output handlers */
    png_set_write_fn(png_ptr, &os, &osWriteFunc, &osFlushFunc);

    /* This is the hard way */

    /* Set the image information here.  Width and height are up to 2^31,
    * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
    * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
    * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
    * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
    * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
    * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
    */
    Int32 ctype;
    switch(img->getPixelFormat())
    {
    case Image::OSG_L_PF:       ctype = PNG_COLOR_TYPE_GRAY;        
                                break;
                                
    case Image::OSG_LA_PF:      ctype = PNG_COLOR_TYPE_GRAY_ALPHA;          
                                break;
                                
#if defined(GL_BGR) || defined(GL_BGR_EXT)
    case Image::OSG_BGR_PF:
#endif
    case Image::OSG_RGB_PF:     ctype = PNG_COLOR_TYPE_RGB;                 
                                break;
                                
#if defined(GL_BGRA) || defined(GL_BGRA_EXT)
    case Image::OSG_BGRA_PF:
#endif
    case Image::OSG_RGBA_PF:    ctype = PNG_COLOR_TYPE_RGB_ALPHA;           
                                break;

    default:
        FWARNING(("PNGImageFileType::write: unknown pixel format %d!\n",
            img->getPixelFormat()));
        png_destroy_write_struct(&png_ptr,  NULL);
        return false;
        
    }
    
    Int32 bit_depth;
    switch (img->getDataType()) {
    case Image::OSG_UINT8_IMAGEDATA:
      bit_depth = 8;
      break;
    case Image::OSG_UINT16_IMAGEDATA:
      bit_depth = 16;
      break;
    default:
      FWARNING (("Invalid pixeldepth, cannot store data\n"));
      return false;
    };

    png_set_IHDR(png_ptr, info_ptr, img->getWidth(), img->getHeight(),
                 bit_depth, ctype,      
                 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

    // set resolution png supports only meter per pixel,
    // so we do a conversion from dpi with some rounding.
    png_uint_32 res_x = img->getResX();
    png_uint_32 res_y = img->getResY();
    if(img->getResUnit() == Image::OSG_RESUNIT_INCH)
    {
        res_x = png_uint_32((img->getResX() * 39.37007874f) < 0.0f ?
                            (img->getResX() * 39.37007874f) - 0.5f :
                            (img->getResX() * 39.37007874f) + 0.5f);
        res_y = png_uint_32((img->getResY() * 39.37007874f) < 0.0f ?
                            (img->getResY() * 39.37007874f) - 0.5f :
                            (img->getResY() * 39.37007874f) + 0.5f);
    }

    png_set_pHYs(png_ptr, info_ptr, res_x, res_y,
                 PNG_RESOLUTION_METER);

#if 0
    /* optional significant bit chunk */
    /* if we are dealing with a grayscale image then */
    sig_bit.gray = true_bit_depth;
    /* otherwise, if we are dealing with a color image then */
    sig_bit.red = true_red_bit_depth;
    sig_bit.green = true_green_bit_depth;
    sig_bit.blue = true_blue_bit_depth;
    /* if the image has an alpha channel then */
    sig_bit.alpha = true_alpha_bit_depth;
    png_set_sBIT(png_ptr, info_ptr, sig_bit);


    /* Optional gamma chunk is strongly suggested if you have any guess
    * as to the correct gamma of the image.
    */
    png_set_gAMA(png_ptr, info_ptr, gamma);

    /* Optionally write comments into the image */
    text_ptr[0].key = "Title";
    text_ptr[0].text = "Mona Lisa";
    text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
    text_ptr[1].key = "Author";
    text_ptr[1].text = "Leonardo DaVinci";
    text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
    text_ptr[2].key = "Description";
    text_ptr[2].text = "<long text>";
    text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
#ifdef PNG_iTXt_SUPPORTED
    text_ptr[0].lang = NULL;
    text_ptr[1].lang = NULL;
    text_ptr[2].lang = NULL;
#endif
    png_set_text(png_ptr, info_ptr, text_ptr, 3);
#endif
    /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
    /* note that if sRGB is present the gAMA and cHRM chunks must be ignored
    * on read and must be written in accordance with the sRGB profile */

    /* Write the file header information.  REQUIRED */
    png_write_info(png_ptr, info_ptr);

#if BYTE_ORDER == LITTLE_ENDIAN

    if (bit_depth == 16) 
      png_set_swap(png_ptr);

#endif


#if 0
    /* invert monochrome pixels */
    png_set_invert_mono(png_ptr);

    /* Shift the pixels up to a legal bit depth and fill in
    * as appropriate to correctly scale the image.
    */
    png_set_shift(png_ptr, &sig_bit);

    /* pack pixels into bytes */
    png_set_packing(png_ptr);

    /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
    * RGB (4 channels -> 3 channels). The second parameter is not used.
    */
    png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

    /* swap bytes of 16-bit files to most significant byte first */
    png_set_swap(png_ptr);

    /* swap bits of 1, 2, 4 bit packed pixel formats */
    png_set_packswap(png_ptr);
#endif

    if(img->getPixelFormat() == Image::OSG_BGR_PF ||
       img->getPixelFormat() == Image::OSG_BGRA_PF
      )
    {
        /* flip BGR pixels to RGB */
        png_set_bgr(png_ptr);

        /* swap location of alpha bytes from ARGB to RGBA */
        png_set_swap_alpha(png_ptr);
    }
    
    /* The easiest way to write the image (you may have a different memory
    * layout, however, so choose what fits your needs best).  You need to
    * use the first method if you aren't handling interlacing yourself.
    */
    png_bytep *row_pointers = new png_bytep [img->getHeight()];
    
    for(Int32 k = 0; k < img->getHeight(); k++)
    {
        row_pointers[k] = img->getData() + 
                          (img->getHeight() - 1 - k) * 
                            img->getWidth() * img->getBpp();
    }
    
    /* write out the entire image data in one call */
    png_write_image(png_ptr, row_pointers);

    /* It is REQUIRED to call this to finish writing the rest of the file */
    png_write_end(png_ptr, info_ptr);
    
    /* clean up after the write, and free any memory allocated */
    png_destroy_write_struct(&png_ptr, &info_ptr);

    delete [] row_pointers;

    /* that's it */
    return true;

#else
    SWARNING <<
        getMimeType() <<
        " write is not compiled into the current binary " <<
        endLog;
    return false;
#endif
}

std::string PNGImageFileType::determineMimetypeFromStream

(

std::istream &

is

)

[virtual]

Tries to determine the mime type of the data provided by an input stream by searching for magic bytes. Returns the mime type or an empty string when the function could not determine the mime type.

Reimplemented from osg::ImageFileType.

Definition at line 560 of file OSGPNGImageFileType.cpp.

References osg::ImageFileType::getMimeType().

{
    char filecode[4];
    is.read(filecode, 4);
    is.seekg(-4, std::ios::cur);
    return strncmp(filecode, "\x89PNG", 4) == 0 ?
        std::string(getMimeType()) : std::string();
}

UInt64 PNGImageFileType::restoreData	(	ImagePtr &	image,
		const UChar8 *	buffer,
		Int32	memSize = -1
	)			[virtual]

Reimplemented from osg::ImageFileType.

Definition at line 614 of file OSGPNGImageFileType.cpp.

References FWARNING, osg::ImageFileType::getMimeType(), osg::Image::OSG_INVALID_PF, osg::Image::OSG_L_PF, osg::Image::OSG_LA_PF, osg::Image::OSG_RGB_PF, osg::Image::OSG_RGBA_PF, osg::Image::OSG_UINT16_IMAGEDATA, osg::Image::OSG_UINT8_IMAGEDATA, and SWARNING.

{
#ifdef OSG_WITH_PNG

    UInt64              retCode;
    Image::PixelFormat  pixelFormat = osg::Image::OSG_INVALID_PF;
    png_structp         png_ptr;
    png_infop           info_ptr;
    png_uint_32         width, wc, height, h, i;
    png_byte            bit_depth, channels, color_type;
    png_bytep           *row_pointers, base;

    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
    if(!png_ptr)
    {
        return 0;
    }

    png_set_error_fn(png_ptr, 0, &errorOutput, &warningOutput);

    info_ptr = png_create_info_struct(png_ptr);
    if(!info_ptr)
    {
        png_destroy_read_struct(&png_ptr, 0, 0);
        return 0;
    }

    if(setjmp(png_ptr->jmpbuf))
    {
        png_destroy_read_struct(&png_ptr, &info_ptr, 0);
        return 0;
    }

    BufferInfo bufferInfo;
    bufferInfo.buffer = (UChar8 *) buffer;
    bufferInfo.length = 0;
    png_set_read_fn(png_ptr, (void *) &bufferInfo, user_read_data);

    png_read_info(png_ptr, info_ptr);

    width = png_get_image_width(png_ptr, info_ptr);
    height = png_get_image_height(png_ptr, info_ptr);
    bit_depth = png_get_bit_depth(png_ptr, info_ptr);
    channels = png_get_channels(png_ptr, info_ptr);
    color_type = png_get_color_type(png_ptr, info_ptr);

    // Convert paletted images to RGB
    if (color_type == PNG_COLOR_TYPE_PALETTE)
    {
        png_set_palette_to_rgb(png_ptr);
        channels = 3;
        bit_depth = 8;
    }

    // Convert < 8 bit to 8 bit
    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
        png_set_gray_1_2_4_to_8(png_ptr);
        bit_depth = 8;
    }
    
#if BYTE_ORDER == LITTLE_ENDIAN
    if (bit_depth == 16)
      png_set_swap(png_ptr);
#endif

    // Add a full alpha channel if there is transparency
    // information in a tRNS chunk
    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
    {
        png_set_tRNS_to_alpha(png_ptr);
        ++channels;
    }                                                                                
    Int32 dataType;
    switch (bit_depth) {
    case 8:
      dataType = Image::OSG_UINT8_IMAGEDATA;
      break;
    case 16:
      dataType = Image::OSG_UINT16_IMAGEDATA;
      break;
    default:
      FWARNING (( "Invalid bit_depth: %d, can not read png-data\n",
                  bit_depth ));
      return false;
    }

    switch(channels)
    {
    case 1:
        pixelFormat = Image::OSG_L_PF;
        break;
    case 2:
        pixelFormat = Image::OSG_LA_PF;
        break;
    case 3:
        pixelFormat = Image::OSG_RGB_PF;
        break;
    case 4:
        pixelFormat = Image::OSG_RGBA_PF;
        break;
    };

    if(image->set( pixelFormat, width, height,
                   1, 1, 1, 0.0, 0,
                   dataType ))
    {
        // Calculate the row pointers
        row_pointers = new png_bytep[height];
        wc = width * channels * (bit_depth / 8);
        h = height - 1;
        base = image->getData();
        for(i = 0; i < height; ++i)
            row_pointers[i] = base + (h - i) * wc;

        // Read the image data
        png_read_image(png_ptr, row_pointers);

        delete[] row_pointers;

        retCode = bufferInfo.length;
    }
    else
        retCode = 0;

    png_destroy_read_struct(&png_ptr, &info_ptr, 0);

    return retCode;

#else
    SWARNING <<
        getMimeType() <<
        " restoreData is not compiled into the current binary " <<
        std::endl;
    return 0;
#endif
}

UInt64 PNGImageFileType::storeData	(	const ImagePtr &	image,
		UChar8 *	buffer,
		Int32	memSize = -1
	)			[virtual]

Tries to restore the image data from the given memblock. Returns the amount of data read.

Reimplemented from osg::ImageFileType.

Definition at line 775 of file OSGPNGImageFileType.cpp.

References FWARNING, osg::ImageFileType::getMimeType(), osg::Image::OSG_BGR_PF, osg::Image::OSG_BGRA_PF, osg::Image::OSG_L_PF, osg::Image::OSG_LA_PF, osg::Image::OSG_RGB_PF, osg::Image::OSG_RGBA_PF, osg::Image::OSG_UINT16_IMAGEDATA, osg::Image::OSG_UINT8_IMAGEDATA, and SWARNING.

{
#ifdef OSG_WITH_PNG

    png_structp png_ptr;
    png_infop info_ptr;

    if(image->getDimension() < 1 || image->getDimension() > 2)
    {
        FWARNING(("PNGImageFileType::write: invalid dimension %d!\n",
            image->getDimension()));
        return 0;
    }

    /* Create and initialize the png_struct with the desired error handler
    * functions.  If you want to use the default stderr and longjump method,
    * you can supply NULL for the last three parameters.  We also check that
    * the library version is compatible with the one used at compile time,
    * in case we are using dynamically linked libraries.  REQUIRED.
    */
    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
                                0, &errorOutput, &warningOutput);

    if (png_ptr == NULL)
    {
        return 0;
    }

    /* Allocate/initialize the image information data.  REQUIRED */
    info_ptr = png_create_info_struct(png_ptr);
    if (info_ptr == NULL)
    {
        png_destroy_write_struct(&png_ptr,  NULL);
        return 0;
    }

    BufferInfo bufferInfo;
    bufferInfo.buffer = buffer;
    bufferInfo.length = 0;
    png_set_write_fn(png_ptr, (void *) &bufferInfo, user_write_data, user_flush_data);

    /* This is the hard way */

    /* Set the image information here.  Width and height are up to 2^31,
    * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
    * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
    * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
    * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
    * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
    * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
    */
    Int32 ctype;
    switch(image->getPixelFormat())
    {
    case Image::OSG_L_PF:       ctype = PNG_COLOR_TYPE_GRAY;        
                                break;
                                
    case Image::OSG_LA_PF:      ctype = PNG_COLOR_TYPE_GRAY_ALPHA;          
                                break;
                                
#if defined(GL_BGR) || defined(GL_BGR_EXT)
    case Image::OSG_BGR_PF:
#endif
    case Image::OSG_RGB_PF:     ctype = PNG_COLOR_TYPE_RGB;                 
                                break;
                                
#if defined(GL_BGRA) || defined(GL_BGRA_EXT)
    case Image::OSG_BGRA_PF:
#endif
    case Image::OSG_RGBA_PF:    ctype = PNG_COLOR_TYPE_RGB_ALPHA;           
                                break;

    default:
        FWARNING(("PNGImageFileType::write: unknown pixel format %d!\n",
            image->getPixelFormat()));
        png_destroy_write_struct(&png_ptr,  NULL);
        return 0;
        
    }
    
    Int32 bit_depth;
    switch (image->getDataType()) {
    case Image::OSG_UINT8_IMAGEDATA:
      bit_depth = 8;
      break;
    case Image::OSG_UINT16_IMAGEDATA:
      bit_depth = 16;
      break;
    default:
      FWARNING (("Invalid pixeldepth, cannot store data\n"));
      return 0;
    };
      
    png_set_IHDR(png_ptr, info_ptr, image->getWidth(), image->getHeight(),
        bit_depth, ctype,      
        PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

    /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
    /* note that if sRGB is present the gAMA and cHRM chunks must be ignored
    * on read and must be written in accordance with the sRGB profile */

    /* Write the file header information.  REQUIRED */
    png_write_info(png_ptr, info_ptr);

#if BYTE_ORDER == LITTLE_ENDIAN
    if (bit_depth == 16)
      png_set_swap(png_ptr);
#endif

    if(image->getPixelFormat() == Image::OSG_BGR_PF ||
       image->getPixelFormat() == Image::OSG_BGRA_PF
      )
    {
        /* flip BGR pixels to RGB */
        png_set_bgr(png_ptr);

        /* swap location of alpha bytes from ARGB to RGBA */
        png_set_swap_alpha(png_ptr);
    }
    
    /* The easiest way to write the image (you may have a different memory
    * layout, however, so choose what fits your needs best).  You need to
    * use the first method if you aren't handling interlacing yourself.
    */
    png_bytep *row_pointers = new png_bytep [image->getHeight()];
    
    for(Int32 k = 0; k < image->getHeight(); k++)
    {
        row_pointers[k] = image->getData() + 
                          (image->getHeight() - 1 - k) * 
                            image->getWidth() * image->getBpp();
    }
    
    /* write out the entire image data in one call */
    png_write_image(png_ptr, row_pointers);

    /* It is REQUIRED to call this to finish writing the rest of the file */
    png_write_end(png_ptr, info_ptr);
    
    /* clean up after the write, and free any memory allocated */
    png_destroy_write_struct(&png_ptr, &info_ptr);

    delete [] row_pointers;

    /* that's it */
    return bufferInfo.length;

#else
    SWARNING <<
        getMimeType() <<
        " storeData is not compiled into the current binary " <<
        std::endl;
    return 0;
#endif
}

PNGImageFileType & PNGImageFileType::the

(

void

)

[static]

Definition at line 151 of file OSGPNGImageFileType.cpp.

References _the.

{
  return _the;
}

const PNGImageFileType& osg::PNGImageFileType::operator=

(

const PNGImageFileType &

obj

)

[private]

void ImageFileType::setOptions

(

const Char8 *

options

)

[inherited]

Definition at line 243 of file OSGImageFileType.cpp.

References osg::ImageFileType::_options.

Referenced by osg::ImageFileHandler::setOptions().

{
    _options = options;
}

const Char8 * ImageFileType::getMimeType

(

void

)

const [inherited]

Get method for the mime type

Definition at line 107 of file OSGImageFileType.cpp.

References osg::ImageFileType::_mimeType, and osg::IDString::str().

Referenced by osg::ImageFileHandler::addImageFileType(), osg::TIFImageFileType::determineMimetypeFromStream(), osg::SGIImageFileType::determineMimetypeFromStream(), osg::PSDImageFileType::determineMimetypeFromStream(), osg::PNMImageFileType::determineMimetypeFromStream(), determineMimetypeFromStream(), osg::MNGImageFileType::determineMimetypeFromStream(), osg::JPGImageFileType::determineMimetypeFromStream(), osg::JP2ImageFileType::determineMimetypeFromStream(), osg::GIFImageFileType::determineMimetypeFromStream(), osg::DDSImageFileType::determineMimetypeFromStream(), osg::BMPImageFileType::determineMimetypeFromStream(), osg::ImageFileType::dump(), osg::TIFImageFileType::read(), read(), osg::JPGImageFileType::read(), osg::JP2ImageFileType::read(), osg::ImageFileType::read(), osg::ImageFileHandler::read(), osg::EXRImageFileType::read(), restoreData(), osg::JPGImageFileType::restoreData(), osg::ImageFileType::restoreData(), osg::ImageFileHandler::store(), storeData(), osg::JPGImageFileType::storeData(), osg::ImageFileType::storeData(), osg::TIFImageFileType::write(), write(), osg::JPGImageFileType::write(), osg::ImageFileType::write(), osg::ImageFileHandler::write(), and osg::EXRImageFileType::write().

{
    return _mimeType.str();
}

const std::list< IDString > & ImageFileType::getSuffixList

(

void

)

const [inherited]

Get method for the suffix list container

Definition at line 134 of file OSGImageFileType.cpp.

References osg::ImageFileType::_suffixList.

Referenced by osg::ImageFileHandler::addImageFileType().

{
    return _suffixList; 
}

UInt32 ImageFileType::getFlags

(

void

)

const [virtual, inherited]

Get method for the flags indicating read/write support. Most image types only support reading.

Definition at line 117 of file OSGImageFileType.cpp.

References osg::ImageFileType::_flags.

Referenced by osg::ImageFileHandler::getSuffixList().

{
    return _flags;
}

const Char8 * ImageFileType::getOptions

(

void

)

[inherited]

Get method for the mime type

Definition at line 124 of file OSGImageFileType.cpp.

References osg::ImageFileType::_options.

Referenced by osg::ImageFileHandler::getOptions().

{
    return _options.c_str();
}

bool ImageFileType::read	(	ImagePtr &	image,
		const Char8 *	fileName
	)			[virtual, inherited]

Reimplemented in osg::DATImageFileType, and osg::HDRImageFileType.

Definition at line 141 of file OSGImageFileType.cpp.

Referenced by osg::ImageFileHandler::read().

{
    std::ifstream is(fileName, std::ios::binary);
    if (is.good() == false)
        return false;
    return read(image, is, std::string());
}

bool ImageFileType::write	(	const ImagePtr &	image,
		const Char8 *	fileName
	)			[virtual, inherited]

Reimplemented in osg::DATImageFileType, and osg::HDRImageFileType.

Definition at line 151 of file OSGImageFileType.cpp.

Referenced by osg::ImageFileHandler::write().

{
    std::ofstream os(fileName, std::ios::binary);
    if (os.good() == false)
        return false;
    return write(image, os, std::string());
}

UInt64 ImageFileType::restore	(	ImagePtr &	image,
		const UChar8 *	buffer,
		Int32	memSize = -1
	)			[static, inherited]

Tries to restore the Imagedata from the given memblock. The buffer must include a ImageFileType::Head data block.

Definition at line 283 of file OSGImageFileType.cpp.

References osg::ImageFileType::Head::dataType, osg::ImageFileType::Head::depth, osg::ImageFileHandler::determineMimetypeFromSuffix(), FDEBUG, osg::ImageFileType::Head::frameCount, osg::ImageFileType::Head::frameDelay, FWARNING, osg::ImageFileType::Head::height, osg::ImageFileType::Head::mipmapCount, osg::ImageFileType::Head::netToHost(), osg::NullFC, osg::Image::OSG_UINT8_IMAGEDATA, osg::ImageFileType::Head::pixelFormat, osg::ImageFileType::Head::sideCount, osg::ImageFileType::Head::suffix, osg::ImageFileHandler::the(), and osg::ImageFileType::Head::width.

Referenced by osg::ClusterViewBuffer::recv(), osg::ImageFileHandler::restore(), and osg::SimpleSceneManager::useOpenSGLogo().

{
    unsigned long   imageSize, headSize = sizeof(Head);
    unsigned long   size = 0, attachmentSize;
    Head            head;
    const UChar8    *data = buffer ? (buffer + headSize) : 0;
    ImageFileType   *type;
    std::string     mimeType;
    Image::Type     dataType;

    if ((image != osg::NullFC) && buffer && (memSize >= headSize)) {

        // Copy header. Otherwise netToHost would change the original
        // data structur.
        memcpy(&head,buffer,sizeof(Head));
        head.netToHost();
        mimeType = ImageFileHandler::the().determineMimetypeFromSuffix(head.suffix);
        
        if((type = ImageFileHandler::the().getFileType(mimeType.c_str(), 0)))
        {
            if (head.dataType)
              dataType = Image::Type(head.dataType);
            else
              dataType = Image::OSG_UINT8_IMAGEDATA;

            image->set(Image::PixelFormat(head.pixelFormat), head.width,
                       head.height, head.depth, head.mipmapCount,
                       head.frameCount, float(head.frameDelay) / 1000.0, 0,
                       dataType,true,head.sideCount );
            imageSize = static_cast<unsigned long>(
                type->restoreData(image, data, memSize - headSize));
            attachmentSize = 0; // head->attachmentSize;

            /*
            if ((attachmentSize = head->attachmentSize))
            {
                attData = (char*)(buffer + headSize + imageSize);
                attKey = attData;
                attValue = 0;
                for (i = 0; i < (attachmentSize-1); i++) {
                    if (attData[i] == 0) 
                        if (attKey) {
                            attValue = &(attData[i+1]);
                            image->setAttachmentField (attKey,attValue);
                            attKey = attValue = 0;
                        }
                        else
                            attKey = &(attData[i+1]);
                }
                if (attKey || attValue) {
                    FFATAL (("Attachment restore error\n"));
                }
            }
            */

            size = headSize + imageSize + attachmentSize;
      
            FDEBUG (( "Restore image data: %lu (%lu/%lu/%lu)\n",
                      size, headSize, imageSize, attachmentSize ));

        }
        else
        {
            imageSize = 0;
            FWARNING(("Can not restore image data, invalid mimeType: %s\n",
                      mimeType.empty() == false ? mimeType.c_str() : "Unknown"));
        }

      
    }

    return size;
}

UInt64 ImageFileType::store	(	const ImagePtr &	image,
		const char *	mimeType,
		UChar8 *	buffer,
		Int32	memSize = -1
	)			[static, inherited]

Tries to store the raster data to the given mem block. Will include a ImageFileType::Head description and the data encoded as 'mimeType'

Definition at line 364 of file OSGImageFileType.cpp.

References osg::ImageFileHandler::getFileType(), osg::ImageFileType::store(), and osg::ImageFileHandler::the().

Referenced by osg::ClusterViewBuffer::send(), osg::ImageFileType::store(), and osg::ImageFileHandler::store().

{
  ImageFileType   *type = ImageFileHandler::the().getFileType(mimeType);
  
  return type ? type->store(image, buffer, memSize) : 0;
}

UInt64 ImageFileType::store	(	const ImagePtr &	image,
		UChar8 *	buffer,
		Int32	memSize = -1
	)			[inherited]

Tries to store the raster data to the given mem block. Will include a ImageFileType::Head description for the derived concreate mimeType.

Definition at line 378 of file OSGImageFileType.cpp.

References osg::ImageFileType::_suffixList, osg::ImageFileType::Head::attachmentSize, osg::ImageFileType::Head::dataType, osg::ImageFileType::Head::depth, FDEBUG, FFATAL, osg::ImageFileType::Head::frameCount, osg::ImageFileType::Head::frameDelay, osg::ImageFileType::Head::height, osg::ImageFileType::Head::hostToNet(), osg::ImageFileType::Head::mipmapCount, osg::ImageFileType::Head::pixelFormat, osg::ImageFileType::Head::sideCount, osg::ImageFileType::storeData(), osg::ImageFileType::Head::suffix, and osg::ImageFileType::Head::width.

{
    Head            *head;
    unsigned long   dataSize = 0, headSize = sizeof(Head);
    unsigned long   attachmentSize;
    UChar8          *dest;
    const UChar8    *src = image->getData();
    std::map<std::string, std::string>::const_iterator aI;
    std::string     value;

    attachmentSize = 0;

    // get attachment size
    /*
    ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
        const_cast<Image*>(image.getCPtr())->findAttachment(
            ImageGenericAtt::getClassType().getGroupId()));
    if(att != NullFC)
    {
        for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
        {
            FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
            Field *field=att->getField(i);
            if (fieldDesc && field) 
            {
                field->getValueByStr(value);
                attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
                attachmentSize += value.length() + 1;
              
                std::cout << fieldDesc->getName().str() << std::endl; 
                std::cout << value << std::endl; 
            }
            else 
            {
                FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
            }
        }
    }
    */

    if (buffer) 
    {
        head = (Head *)buffer;

        head->pixelFormat    = image->getPixelFormat();
        head->width          = image->getWidth();
        head->height         = image->getHeight();
        head->depth          = image->getDepth();
        head->mipmapCount    = image->getMipMapCount();
        head->frameCount     = image->getFrameCount();
        head->frameDelay     = short(image->getFrameDelay() * 1000.0);
        head->sideCount      = image->getSideCount();
        head->dataType       = image->getDataType();
        head->attachmentSize = static_cast<unsigned short>(attachmentSize);
        head->hostToNet();
      
        strcpy(head->suffix, _suffixList.front().str());
      
        dest = (UChar8 *) (buffer + headSize);

        if (src) 
            dataSize = static_cast<unsigned long>(
                storeData(image, dest, memSize - headSize));

        dest = (UChar8 *) (buffer + headSize + dataSize);

        /*
        if(att != NullFC)
        {
            for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
            {
                FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
                Field *field=att->getField(i);
                if (field && fieldDesc) 
                {
                    field->getValueByStr(value);

                    l = strlen( fieldDesc->getName().str() );
                    for (i = 0; i < l; i++)
                      *dest++ = fieldDesc->getName().str()[i];
                    *dest++ = 0;
                    l = value.length();
                    for (i = 0; i < l; i++)
                      *dest++ = value[i];
                    *dest++ = 0;
                }
                else
                {
                    FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
                }
            }
        }
        */

        FDEBUG (( "Store image data: %lu (%lu/%lu/%lu)\n",
                  headSize + dataSize + attachmentSize, headSize, dataSize, 
                  attachmentSize ));
    }
    else {
        FFATAL (("Invalid buffer in ImageFileType::store()\n"));
    }
  
    return (headSize + dataSize + attachmentSize);

}

UInt64 ImageFileType::maxBufferSize

(

const ImagePtr &

image

)

[virtual, inherited]

Returns the max buffer size needed to store the Image (Head + mimeType specific data block)

Definition at line 490 of file OSGImageFileType.cpp.

References FINFO.

Referenced by osg::ClusterViewBuffer::send(), and osg::ImageFileHandler::store().

{
    std::string value;
    unsigned long size, attachmentSize;
    unsigned long imageSize = image->getSize(), headSize = sizeof(Head);

    std::map<std::string, std::string>::const_iterator aI;

    attachmentSize = 0;

    // get attachment size
        /*
    ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
        const_cast<Image*>(image.getCPtr())->findAttachment(
            ImageGenericAtt::getClassType().getGroupId()));
    if(att != NullFC)
    {
        for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
        {
            FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
            Field *field=att->getField(i);
            if (field && fieldDesc) 
            {
                field->getValueByStr(value);
                attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
                attachmentSize += value.length() + 1;
            }
            else 
            {
                FFATAL (("Invalid Attachment in ImageFileType::maxBufferSize()\n"));
            }
        }
    }
        */

    size = headSize + imageSize + attachmentSize;
  
    FINFO (( "ImageFileType::maxBufferSize(): %lu (%lu/%lu/%lu)\n", 
             size, headSize, imageSize, attachmentSize ));
  
    return size;
}

void ImageFileType::dump

(

void

)

[inherited]

The dump method just writes some object debugging info to the LOG stream

Definition at line 537 of file OSGImageFileType.cpp.

References osg::ImageFileType::_suffixList, osg::ImageFileType::getMimeType(), osg::LOG_DEBUG, and SLOG.

{
    std::list<IDString>::iterator    sI;

    SLOG << getMimeType();

    if(_suffixList.empty())
    {
        SLOG << ": Suffix: ";
        for(sI = _suffixList.begin(); sI != _suffixList.end(); sI++)
        {
            Log().stream(OSG::LOG_DEBUG) << sI->str() << " ";
        }
    }

    std::cerr << std::endl;
}

---

Member Data Documentation

PNGImageFileType PNGImageFileType::_the [static, private]

Definition at line 131 of file OSGPNGImageFileType.h.

Referenced by the().

std::string osg::ImageFileType::_options [protected, inherited]

Definition at line 182 of file OSGImageFileType.h.

Referenced by osg::ImageFileType::getOptions(), osg::ImageFileType::setOptions(), and osg::TIFImageFileType::write().

---

The documentation for this class was generated from the following files:

• OSGPNGImageFileType.h
• OSGPNGImageFileType.cpp