osg::JPGImageFileType Class Reference
[Image]

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

#include <OSGJPGImageFileType.h>

Inheritance diagram for osg::JPGImageFileType:

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	~JPGImageFileType (void)
Get Method
void	setQuality (UInt32 cl)
UInt32	getQuality (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 JPGImageFileType &	the (void)
Protected Member Functions
Default Constructor
	JPGImageFileType (const Char8 *mimeType, const Char8 *suffixArray[], UInt16 suffixByteCount, UInt32 flags)
Protected Attributes
MTD Header
std::string	_options
Private Member Functions
Copy Constructor
	JPGImageFileType (const JPGImageFileType &obj)
Copy Operator
const JPGImageFileType &	operator= (const JPGImageFileType &obj)
Private Attributes
UInt32	_quality
Static Private Attributes
static JPGImageFileType	_the

---

Detailed Description

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

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

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

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

JPGImageFileType::~JPGImageFileType

(

void

)

[virtual]

Destructor

Definition at line 758 of file OSGJPGImageFileType.cpp.

{}

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

Constructor used for the singleton object

Definition at line 746 of file OSGJPGImageFileType.cpp.

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

osg::JPGImageFileType::JPGImageFileType

(

const JPGImageFileType &

obj

)

[private]

---

Member Function Documentation

void JPGImageFileType::setQuality

(

UInt32

cl

)

Definition at line 358 of file OSGJPGImageFileType.cpp.

References _quality.

{
    if(cl > 100)
        cl = 100;
    
    _quality = cl;
}

UInt32 JPGImageFileType::getQuality

(

void

)

Definition at line 366 of file OSGJPGImageFileType.cpp.

References _quality.

{
    return _quality;
}

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

Reimplemented from osg::ImageFileType.

Definition at line 554 of file OSGJPGImageFileType.cpp.

{
    implemented = true;

    if(fileName == NULL)
        return false;

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

    UInt16 magic = 0;
    fread((void *) &magic, sizeof(magic), 1, file);
    fclose(file);

#if BYTE_ORDER == LITTLE_ENDIAN
    if(magic == 0xd8ff) // the magic header is big endian need to swap it.
#else
    if(magic == 0xffd8)
#endif
    {
        return true;
    }

    return false;
}

bool JPGImageFileType::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 376 of file OSGJPGImageFileType.cpp.

References osg::ImageFileType::getMimeType(), osg::Image::OSG_INVALID_PF, osg::Image::OSG_L_PF, osg::Image::OSG_RESUNIT_INCH, osg::Image::OSG_RGB_PF, and SWARNING.

{
#ifdef OSG_WITH_JPG

    struct osg_jpeg_error_mgr jerr;
    struct jpeg_decompress_struct cinfo;

    cinfo.err = jpeg_std_error(&jerr.pub);
    if (setjmp(jerr.setjmp_buffer))
        return false;
    cinfo.err->error_exit = osg_jpeg_error_exit;
    cinfo.err->output_message = osg_jpeg_output_message;

    jpeg_create_decompress(&cinfo);

    SourceManager *sourceManager =
        new ((*cinfo.mem->alloc_small)((j_common_ptr)&cinfo, JPOOL_IMAGE, sizeof(SourceManager)))
        SourceManager(&cinfo, is);
    cinfo.src = (jpeg_source_mgr*)sourceManager;

    jpeg_read_header(&cinfo, TRUE);
    jpeg_start_decompress(&cinfo);

    Image::PixelFormat pixelFormat;
    switch (cinfo.output_components)
    {
    case 1:
        pixelFormat = Image::OSG_L_PF;
        break;
    case 3:
        pixelFormat = Image::OSG_RGB_PF;
        break;
    default:
        pixelFormat = Image::OSG_INVALID_PF;
        break;
    };

    bool retCode;
    if (image->set(pixelFormat, cinfo.output_width, cinfo.output_height) == true)
    {
        Real32 res_x = Real32(cinfo.X_density);
        Real32 res_y = Real32(cinfo.Y_density);
        UInt16 res_unit = UInt16(cinfo.density_unit);
        if(res_unit == 2) // centimeter
        {
            // convert dpcm to dpi.
            res_x *= 2.54f;
            res_y *= 2.54f;
            res_unit = Image::OSG_RESUNIT_INCH;
        }
        image->setResX(res_x);
        image->setResY(res_y);
        image->setResUnit(res_unit);

        unsigned char *destData = image->getData() + image->getSize();
        int row_stride = cinfo.output_width * cinfo.output_components;
        while (cinfo.output_scanline < cinfo.output_height)
        {
            destData -= row_stride;
            jpeg_read_scanlines(&cinfo, &destData, 1);
        }
        retCode = true;
    }
    else
        retCode = false;

    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);

    return retCode;

#else

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

#endif
}

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

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

Reimplemented from osg::ImageFileType.

Definition at line 464 of file OSGJPGImageFileType.cpp.

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

{
#ifdef OSG_WITH_JPG

    if ((image->getBpp() != 1 && 
         image->getBpp() != 3) || image->getDepth() != 1)
    {
        SWARNING <<
            getMimeType() <<
            " JPEG write only works for 2D 1 or 3 bpp images " <<
            std::endl;
        return false;
    }

    struct osg_jpeg_error_mgr jerr;
    struct jpeg_compress_struct cinfo;

    cinfo.err = jpeg_std_error(&jerr.pub);
    if (setjmp(jerr.setjmp_buffer))
        return false;
    cinfo.err->error_exit = osg_jpeg_error_exit;
    cinfo.err->output_message = osg_jpeg_output_message;

    jpeg_create_compress(&cinfo);

    DestinationManager *destinationManager =
        new ((*cinfo.mem->alloc_small)((j_common_ptr)&cinfo, JPOOL_IMAGE, sizeof(DestinationManager)))
        DestinationManager(&cinfo, os);
    cinfo.dest = (jpeg_destination_mgr*)destinationManager;

    cinfo.image_width = image->getWidth();
    cinfo.image_height = image->getHeight();
    cinfo.input_components = image->getBpp();
    cinfo.in_color_space = (image->getBpp() == 1) ? JCS_GRAYSCALE : JCS_RGB;

    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, _quality, TRUE);

    cinfo.density_unit = 1;  // dpi
    cinfo.X_density = UInt16(image->getResX() < 0.0f ?
                             image->getResX() - 0.5f :
                             image->getResX() + 0.5f);
    cinfo.Y_density = UInt16(image->getResY() < 0.0f ?
                             image->getResY() - 0.5f :
                             image->getResY() + 0.5f);

    jpeg_start_compress(&cinfo, TRUE);

    unsigned char *srcData = image->getData() + image->getSize();
    int row_stride = cinfo.image_width * cinfo.input_components;
    while (cinfo.next_scanline < cinfo.image_height)
    {
        srcData -= row_stride;
        jpeg_write_scanlines(&cinfo, &srcData, 1);
    }

    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);

    return true;

#else

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

#endif
}

std::string JPGImageFileType::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 543 of file OSGJPGImageFileType.cpp.

References osg::ImageFileType::getMimeType().

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

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

Reimplemented from osg::ImageFileType.

Definition at line 583 of file OSGJPGImageFileType.cpp.

References 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, and SWARNING.

{
#ifdef OSG_WITH_JPG
    UInt64    retCode = 0;
    struct local_error_mgr
    {
        struct jpeg_error_mgr   pub;
        jmp_buf                 setjmp_buffer;
    };

    unsigned char                   *destData;
    Image::PixelFormat              pixelFormat = osg::Image::OSG_INVALID_PF;

    unsigned long                    imageSize;
    typedef struct local_error_mgr  *local_error_ptr;
    struct local_error_mgr          jerr;
    struct jpeg_decompress_struct   cinfo;
    JSAMPARRAY                      imagebuffer;

    int                             row_stride;

    cinfo.err = jpeg_std_error(&jerr.pub);
    if(setjmp(jerr.setjmp_buffer))
    {
        jpeg_destroy_decompress(&cinfo);
        return 0;
    }

    jpeg_create_decompress(&cinfo);
    jpeg_memory_src(&cinfo, buffer, memSize);
    jpeg_read_header(&cinfo, TRUE);
    jpeg_start_decompress(&cinfo);

    switch(cinfo.output_components)
    {
    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, cinfo.output_width, cinfo.output_height))
    {
        imageSize = image->getSize();
        destData = image->getData() + imageSize;
        row_stride = cinfo.output_width * cinfo.output_components;
        imagebuffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) & cinfo, JPOOL_IMAGE, row_stride, 1);
        while(cinfo.output_scanline < cinfo.output_height)
        {
            destData -= row_stride;
            jpeg_read_scanlines(&cinfo, imagebuffer, 1);
            memcpy(destData, *imagebuffer, row_stride);
        }

        retCode = imageSize;
    }
    else
        retCode = 0;

    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);

    return retCode;

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

UInt64 JPGImageFileType::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 671 of file OSGJPGImageFileType.cpp.

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

{
#ifdef OSG_WITH_JPG
    if((image->getBpp() != 1 && image->getBpp() != 3)
       || image->getDepth() != 1)
    {
        SWARNING <<
            getMimeType() <<
            " JPEG storeData only works for 2D 1 or 3 bpp images " <<
            std::endl;
        return 0;
    }

    struct local_error_mgr
    {
        struct jpeg_error_mgr   pub;
        jmp_buf                 setjmp_buffer;
    };

    typedef struct local_error_mgr  *local_error_ptr;

    struct local_error_mgr          jerr;
    struct jpeg_compress_struct     cinfo;
    JSAMPARRAY                      imagebuffer;
    UChar8                          *data;

    cinfo.err = jpeg_std_error(&jerr.pub);
    if(setjmp(jerr.setjmp_buffer))
    {
        jpeg_destroy_compress(&cinfo);
        return 0;
    }

    jpeg_create_compress(&cinfo);
    jpeg_memory_dest(&cinfo, buffer, memSize);

    cinfo.image_width = image->getWidth();
    cinfo.image_height = image->getHeight();
    cinfo.input_components = image->getBpp();
    cinfo.in_color_space = (image->getBpp() == 1) ? JCS_GRAYSCALE : JCS_RGB;

    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, _quality, TRUE);
    jpeg_start_compress(&cinfo, TRUE);

    imagebuffer = &data;
    while(cinfo.next_scanline < cinfo.image_height)
    {
        data = image->getData() +
            (image->getHeight() - 1 - cinfo.next_scanline) *
            image->getWidth() *
            image->getBpp();
        jpeg_write_scanlines(&cinfo, imagebuffer, 1);
    }

    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);

    return jpeg_mem.dataSize;

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

JPGImageFileType & JPGImageFileType::the

(

void

)

[static]

Class method to get the singleton Object

Definition at line 349 of file OSGJPGImageFileType.cpp.

References _the.

{
  return _the;
}

const JPGImageFileType& osg::JPGImageFileType::operator=

(

const JPGImageFileType &

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(), osg::PNGImageFileType::determineMimetypeFromStream(), osg::MNGImageFileType::determineMimetypeFromStream(), determineMimetypeFromStream(), osg::JP2ImageFileType::determineMimetypeFromStream(), osg::GIFImageFileType::determineMimetypeFromStream(), osg::DDSImageFileType::determineMimetypeFromStream(), osg::BMPImageFileType::determineMimetypeFromStream(), osg::ImageFileType::dump(), osg::TIFImageFileType::read(), osg::PNGImageFileType::read(), read(), osg::JP2ImageFileType::read(), osg::ImageFileType::read(), osg::ImageFileHandler::read(), osg::EXRImageFileType::read(), osg::PNGImageFileType::restoreData(), restoreData(), osg::ImageFileType::restoreData(), osg::ImageFileHandler::store(), osg::PNGImageFileType::storeData(), storeData(), osg::ImageFileType::storeData(), osg::TIFImageFileType::write(), osg::PNGImageFileType::write(), 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

UInt32 osg::JPGImageFileType::_quality [private]

Definition at line 140 of file OSGJPGImageFileType.h.

Referenced by getQuality(), setQuality(), storeData(), and write().

JPGImageFileType JPGImageFileType::_the [static, private]

Definition at line 142 of file OSGJPGImageFileType.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:

• OSGJPGImageFileType.h
• OSGJPGImageFileType.cpp