osg::TGAImageFileType Class Reference
[Image]

TGA File Handler. Used to read/write TGA files. See Image for a detailed description. More...

#include <OSGTGAImageFileType.h>

Inheritance diagram for osg::TGAImageFileType:

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	~TGAImageFileType (void)
Read/Write
virtual bool	read (ImagePtr &image, std::istream &is, const std::string &mimetype)
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)
virtual bool	write (const ImagePtr &image, std::ostream &os, const std::string &mimetype)
virtual bool	validateHeader (const Char8 *fileName, bool &implemented)
virtual std::string	determineMimetypeFromStream (std::istream &is)
Raw Store/Restore
virtual UInt64	restoreData (ImagePtr &image, const UChar8 *buffer, Int32 memSize=-1)
virtual UInt64	storeData (const ImagePtr &image, UChar8 *buffer, Int32 memSize=-1)
dump
void	dump (void)
Static Public Member Functions
Get Method
static TGAImageFileType &	the (void)
Protected Member Functions
Default Constructor
	TGAImageFileType (const Char8 *mimeType, const Char8 *suffixArray[], UInt16 suffixByteCount)
Protected Attributes
MTD Header
std::string	_options
Private Member Functions
bool	readHeader (std::istream &in, TGAHeader &header)
bool	readCompressedImageData (std::istream &in, ImagePtr &image)
Copy Constructor
	TGAImageFileType (const TGAImageFileType &obj)
Copy Operator
const TGAImageFileType &	operator= (const TGAImageFileType &obj)
Static Private Attributes
static TGAImageFileType	_the
Classes
struct	TGAHeader

---

Detailed Description

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

All the type specific code is included in the class. Does not depend on external libs.

Definition at line 56 of file OSGTGAImageFileType.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

TGAImageFileType::~TGAImageFileType

(

void

)

[virtual]

Destructor

Definition at line 336 of file OSGTGAImageFileType.cpp.

{}

TGAImageFileType::TGAImageFileType	(	const Char8 *	mimeType,
		const Char8 *	suffixArray[],
		UInt16	suffixByteCount
	)			[protected]

Constructor used for the singleton object

Definition at line 326 of file OSGTGAImageFileType.cpp.

                                                           :
    ImageFileType(mimeType, suffixArray, suffixByteCount)
{}

osg::TGAImageFileType::TGAImageFileType

(

const TGAImageFileType &

obj

)

[private]

---

Member Function Documentation

TGAImageFileType & TGAImageFileType::the

(

void

)

[static]

Class method to get the singleton Object

Definition at line 86 of file OSGTGAImageFileType.cpp.

References _the.

{
  return _the;
}

bool TGAImageFileType::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 196 of file OSGTGAImageFileType.cpp.

References osg::TGAImageFileType::TGAHeader::cmapEntrySize, osg::TGAImageFileType::TGAHeader::cmapLength, osg::TGAImageFileType::TGAHeader::colorMapType, osg::TGAImageFileType::TGAHeader::depth, osg::TGAImageFileType::TGAHeader::descriptor, FDEBUG, FWARNING, osg::TGAImageFileType::TGAHeader::height, osg::TGAImageFileType::TGAHeader::idLength, osg::TGAImageFileType::TGAHeader::imageType, osg::Image::OSG_INVALID_PF, osg::Image::OSG_L_PF, osg::Image::OSG_RGB_PF, osg::Image::OSG_RGBA_PF, osg::osgMin(), readCompressedImageData(), readHeader(), and osg::TGAImageFileType::TGAHeader::width.

{
    // read the header
    TGAHeader header;
    if (readHeader(is, header) == false)
        return false;

    // determine format
    Image::PixelFormat format = Image::OSG_INVALID_PF;
    switch (header.imageType & ~0x8)
    {
    case 1: FWARNING(("TGA: 8-bit image not supported!\n"));
            break;

    case 2: switch (header.depth)
            {
            case 24: format = Image::OSG_RGB_PF;
                     break;
            case 32: format = Image::OSG_RGBA_PF;
                     break;
            default: FWARNING(("TGA: Unknown pixel depth %d!\n",
                              header.depth));
                     break;
            }
            break;

    case 3: format = Image::OSG_L_PF;
            break;
    }
    if (format == Image::OSG_INVALID_PF)
    {
        FWARNING(("Unsupported image type for TGA file!\n"));
        return false;
    }

    // read the image ID
    UInt8 imageid[256];
    is.read(reinterpret_cast<char *>(imageid), header.idLength);
    if (is.gcount() != header.idLength)
        return false;
    imageid[header.idLength] = 0;
    FDEBUG(("TGA: Image ID '%s'\n", imageid));

    // read color map data
    if (header.colorMapType == 1)
    {
        Int32 len = osgMin(header.cmapEntrySize / 3, 8) * header.cmapLength;

        //UInt8 * dum = new UInt8 [len];
        //in.read(reinterpret_cast<char *>(dum), len);
        //delete [] dum;
        is.ignore(len);
        if (is.gcount() != len)
            return false;
    }

    // read image data
    image->set(format, header.width, header.height);
    if ((header.imageType & 0x8) != 0)
    {
        if (readCompressedImageData(is, image) == false)
        {
            FWARNING(("Unsupported image type for TGA file!\n"));
            return false;
        }
    }
    else
    {
        Int32 len = image->getSize();
        is.read(reinterpret_cast<char *>(image->getData()), len);
        if (is.gcount() != len)
            return false;
    }

    // check origin
    switch (header.descriptor & 0x30)
    {
    case 0x00: // bottom left, ok!
               break;
    case 0x20: // top left
               // do top-bottom swap
               {
                   UInt32 bpl = image->getBpp() * image->getWidth();
                   UChar8 *t = image->getData(), 
                          *b = t + (image->getHeight() - 1) * bpl,
                           dum;

                   for(UInt32 y = image->getHeight() / 2; y > 0; --y)
                   {
                       for(UInt32 x = bpl; x > 0; --x, ++t, ++b)
                       {
                           dum = *t;
                           *t = *b;
                           *b = dum;
                       }
                       b -= bpl * 2;
                   }
               }
               break;
    case 0x10: // bottom right
    case 0x30: // top right
               FWARNING(("TGA: origin 0x%d not supported!\n",
                         header.descriptor & 0x30));
               return false;
    }

    // do BGR -> RGB swap, as GL_BGR_EXT is not supported everywhere
    if (image->getPixelFormat() == Image::OSG_RGB_PF ||
        image->getPixelFormat() == Image::OSG_RGBA_PF)
    {
        UChar8 *d    = image->getData(), dum;
        UInt32  npix = image->getWidth() * image->getHeight();
        UInt8   bpp  = image->getBpp();

        while (npix--)
        {
            dum  = d[2];
            d[2] = d[0];
            d[0] = dum;
            d += bpp;
        }
    }
    
    return true;
}

const TGAImageFileType& osg::TGAImageFileType::operator=

(

const TGAImageFileType &

obj

)

[private]

bool TGAImageFileType::readHeader	(	std::istream &	in,
		TGAHeader &	header
	)			[private]

Definition at line 91 of file OSGTGAImageFileType.cpp.

References osg::TGAImageFileType::TGAHeader::cmapEntrySize, osg::TGAImageFileType::TGAHeader::cmapFirst, osg::TGAImageFileType::TGAHeader::cmapLength, osg::TGAImageFileType::TGAHeader::colorMapType, osg::TGAImageFileType::TGAHeader::depth, osg::TGAImageFileType::TGAHeader::descriptor, osg::TGAImageFileType::TGAHeader::height, osg::TGAImageFileType::TGAHeader::idLength, osg::TGAImageFileType::TGAHeader::imageType, osg::TGAImageFileType::TGAHeader::width, osg::TGAImageFileType::TGAHeader::xOrigin, and osg::TGAImageFileType::TGAHeader::yOrigin.

Referenced by read().

{
    UInt8 dum[18];
    is.read(reinterpret_cast<char *>(dum), 18);
    if (is.gcount() != 18)
        return false;

    header.idLength      = dum[ 0];
    header.colorMapType  = dum[ 1];
    header.imageType     = dum[ 2];
    header.cmapFirst     = dum[ 3] | (dum[ 4] << 8);
    header.cmapLength    = dum[ 5] | (dum[ 6] << 8);
    header.cmapEntrySize = dum[ 7];
    header.xOrigin       = dum[ 8] | (dum[ 9] << 8);
    header.yOrigin       = dum[10] | (dum[11] << 8);
    header.width         = dum[12] | (dum[13] << 8);
    header.height        = dum[14] | (dum[15] << 8);
    header.depth         = dum[16];
    header.descriptor    = dum[17];

    return true;
}

bool TGAImageFileType::readCompressedImageData	(	std::istream &	in,
		ImagePtr &	image
	)			[private]

Definition at line 114 of file OSGTGAImageFileType.cpp.

References FWARNING, osg::Image::OSG_L_PF, osg::Image::OSG_RGB_PF, and osg::Image::OSG_RGBA_PF.

Referenced by read().

{
    UInt32 npix = image->getWidth() * image->getHeight();
    Int32  rep, len;
    UChar8 *data = image->getData();
    UInt16 bpp = image->getBpp();
    Char8 c[4];

    while (npix > 0)
    {
        rep = is.get();
        if (rep == EOF)
            return false;
        bool repFlag = (rep & 0x80) != 0;
        rep = (rep & 0x7f) + 1;
        if (static_cast<UInt32>(rep) > npix)
            return false;
        npix -= rep;

        if (repFlag == true)
        {
            switch (image->getPixelFormat())
            {
            case Image::OSG_L_PF:
                is.read(c, 1);
                if (is.gcount() != 1)
                    return false;
                for (; rep > 0; --rep)
                    *data++ = c[0];
                break;
            case Image::OSG_RGB_PF:
                is.read(c, 3);
                if (is.gcount() != 3)
                    return false;
                for (; rep > 0; --rep)
                {
                    *data++ = c[0];
                    *data++ = c[1];
                    *data++ = c[2];
                }
                break;
            case Image::OSG_RGBA_PF:
                is.read(c, 4);
                if (is.gcount() != 4)
                    return false;
                for (; rep > 0; --rep)
                {
                    *data++ = c[0];
                    *data++ = c[1];
                    *data++ = c[2];
                    *data++ = c[3];
                }
                break;
            default:
                FWARNING(("TGA: unknown pixel "
                          "format!?!\n"));
                return false;
            }
        }
        else // raw packet
        {
            len = bpp * rep;
            is.read(reinterpret_cast<char *>(data), len);
            if (is.gcount() != len)
                return false;
            data += len;
        }
    }
    return true;
}

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(), osg::PNGImageFileType::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(), osg::PNGImageFileType::read(), osg::JPGImageFileType::read(), osg::JP2ImageFileType::read(), osg::ImageFileType::read(), osg::ImageFileHandler::read(), osg::EXRImageFileType::read(), osg::PNGImageFileType::restoreData(), osg::JPGImageFileType::restoreData(), osg::ImageFileType::restoreData(), osg::ImageFileHandler::store(), osg::PNGImageFileType::storeData(), osg::JPGImageFileType::storeData(), osg::ImageFileType::storeData(), osg::TIFImageFileType::write(), osg::PNGImageFileType::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());
}

bool ImageFileType::write	(	const ImagePtr &	image,
		std::ostream &	os,
		const std::string &	mimetype
	)			[virtual, inherited]

Tries to write the image object to the given output stream. Returns true on success.

Reimplemented in osg::BMPImageFileType, osg::EXRImageFileType, osg::HDRImageFileType, osg::JPGImageFileType, osg::MTDImageFileType, osg::PNGImageFileType, osg::PNMImageFileType, and osg::TIFImageFileType.

Definition at line 185 of file OSGImageFileType.cpp.

References osg::endLog(), osg::ImageFileType::getMimeType(), and SWARNING.

{
    SWARNING << getMimeType()
             << " write to stream is not implemented"
             << endLog;
    return false;
}

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

Reimplemented in osg::GIFImageFileType, osg::JPGImageFileType, osg::PNGImageFileType, osg::SGIImageFileType, and osg::TIFImageFileType.

Definition at line 161 of file OSGImageFileType.cpp.

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

{
    implemented = false;
    return true;
}

std::string ImageFileType::determineMimetypeFromStream

(

std::istream &

is

)

[virtual, inherited]

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 in osg::BMPImageFileType, osg::DDSImageFileType, osg::GIFImageFileType, osg::JP2ImageFileType, osg::JPGImageFileType, osg::MNGImageFileType, osg::PNGImageFileType, osg::PNMImageFileType, osg::PSDImageFileType, osg::SGIImageFileType, and osg::TIFImageFileType.

Definition at line 199 of file OSGImageFileType.cpp.

{
    return 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;
}

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

Abstract restore method. Should be overwriten by a concrete derived class. Tries to restore the image data from the given memblock.

Reimplemented in osg::DATImageFileType, osg::EXRImageFileType, osg::HDRImageFileType, osg::JPGImageFileType, osg::MTDImageFileType, and osg::PNGImageFileType.

Definition at line 253 of file OSGImageFileType.cpp.

References FWARNING, and osg::ImageFileType::getMimeType().

{
  FWARNING(("ImageXFileType::restoreData() not impl. for mimeType %s\n",
            getMimeType()));

  return 0;
}

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

Abstract restore method. Should be overwriten by a concrete derived class. Tries to store the given image data to the given memblock

Reimplemented in osg::DATImageFileType, osg::EXRImageFileType, osg::HDRImageFileType, osg::JPGImageFileType, osg::MTDImageFileType, and osg::PNGImageFileType.

Definition at line 268 of file OSGImageFileType.cpp.

References FWARNING, and osg::ImageFileType::getMimeType().

Referenced by osg::ImageFileType::store().

{
  FWARNING(("ImageXFileType::storeData() not impl. for mimeType %s\n",
            getMimeType()));
  
  return 0;
}

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

TGAImageFileType TGAImageFileType::_the [static, private]

Definition at line 136 of file OSGTGAImageFileType.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:

• OSGTGAImageFileType.h
• OSGTGAImageFileType.cpp