Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages
osg::DDSImageFileType

osg::DDSImageFileType Class Reference
[Image]

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

#include <OSGDDSImageFileType.h>

Inheritance diagram for osg::DDSImageFileType:

osg::ImageFileType 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 Member Functions

Destructor
*virtual ~DDSImageFileType (void)
Read/Write
*virtual bool read (ImagePtr &image, const Char8 *fileName)
virtual bool write (const ImagePtr &image, const Char8 *fileName)

Static Public Member Functions

Get Methods
*static DDSImageFileType & the (void)

Protected Member Functions

Default Constructor
* DDSImageFileType (const Char8 *mimeType, const Char8 *suffixArray[], UInt16 suffixByteCount, UInt32 flags)
Copy Constructor
* DDSImageFileType (const DDSImageFileType &obj)

Private Types

typedef ImageFileType Inherited

Static Private Attributes

static DDSImageFileType _the

Detailed Description

Image File Type to read/write and store/restore Image objects as DDS data. Should work with binary and ascii dds/pbm/pgm/ppm data.

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

Definition at line 55 of file OSGDDSImageFileType.h.

Member Typedef Documentation

typedef ImageFileType osg::DDSImageFileType::Inherited [private]
 

Definition at line 107 of file OSGDDSImageFileType.h.

Member Enumeration Documentation

anonymous enum [inherited]
 

Enumerator:
OSG_READ_SUPPORTED 
OSG_WRITE_SUPPORTED 

Definition at line 65 of file OSGImageFileType.h.

00066     {
00067         OSG_READ_SUPPORTED = 1,
00068         OSG_WRITE_SUPPORTED = 2
00069     };

Constructor & Destructor Documentation

DDSImageFileType::~DDSImageFileType (  void   )  [virtual]
 

Destructor

Definition at line 454 of file OSGDDSImageFileType.cpp.

00455 {
00456     return;
00457 }

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

Constructor used for the singleton object

Definition at line 431 of file OSGDDSImageFileType.cpp.

00434                                                  :
00435     ImageFileType(mimeType,suffixArray, suffixByteCount, flags)
00436 {
00437     return;
00438 }

DDSImageFileType::DDSImageFileType (  const DDSImageFileType &  obj  )  [protected]
 

Dummy Copy Constructor

Definition at line 444 of file OSGDDSImageFileType.cpp.

00444                                                               :
00445     ImageFileType(obj)
00446 {
00447     return;
00448 }

Member Function Documentation

DDSImageFileType & DDSImageFileType::the (  void   )  [static]
 

Class method to get the singleton Object

Definition at line 284 of file OSGDDSImageFileType.cpp.

References _the.

00285 {
00286   return _the;
00287 }

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

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

Implements osg::ImageFileType.

Definition at line 298 of file OSGDDSImageFileType.cpp.

References osg::endLog(), CDDSImage::get_components(), CDDSImage::get_format(), CDDSImage::get_num_images(), CDDSImage::is_compressed(), CDDSImage::is_cubemap(), CDDSImage::is_valid(), CDDSImage::is_volume(), CDDSImage::load(), osg::Image::OSG_UINT8_IMAGEDATA, SINFO, and SWARNING.

00299 {
00300   bool validImage = false;
00301   CDDSImage ddsImage;
00302   int i,j,w,h,d, mm = 0, components, format,size;
00303   int width = 0, height = 0, depth = 0, numMipMaps = 0;
00304   bool isCompressed, isCubeMap, isVolume;
00305   unsigned char *data;
00306   unsigned dataSize = 0;
00307 
00308   SINFO << "DDS File Info: " << fileName << ": ";
00309   
00310   if (ddsImage.load(fileName) && (validImage = ddsImage.is_valid())) {
00311     components = ddsImage.get_components();
00312     format = ddsImage.get_format();
00313     isCompressed = ddsImage.is_compressed();
00314     isCubeMap = ddsImage.is_cubemap();
00315     isVolume = ddsImage.is_volume();
00316     SINFO << "cs: " << components 
00317           << ", f: " << format
00318           << ", cd: " << isCompressed 
00319           << ", cm: " << isCubeMap
00320           << ", vo: " << isVolume
00321           << endLog;
00322     for (i = 0; i < ddsImage.get_num_images(); ++i) {
00323       w = ddsImage[i].get_width();
00324       h = ddsImage[i].get_height();
00325       d = ddsImage[i].get_depth();
00326       size = ddsImage[i].get_size();
00327       dataSize += size;
00328       mm = ddsImage[i].get_num_mipmaps();    
00329       if (i) {
00330         if ( (w != width) || (h != height) || (d != depth) &&
00331              (mm != numMipMaps) )
00332           validImage = false;
00333       }
00334       else {
00335         width = w;
00336         height = h;
00337         depth = d;
00338         numMipMaps = mm;
00339       }
00340       SINFO << "  " << i 
00341             << ", " << w << "x" << h << "x" << d 
00342             << ", size: " << size 
00343             << ", mm: " << mm
00344             << endLog;
00345       for (j = 0; j < mm; ++j) {
00346         w = ddsImage[i].get_mipmap(j).get_width();
00347         h = ddsImage[i].get_mipmap(j).get_height();
00348         d = ddsImage[i].get_mipmap(j).get_depth();
00349         size = ddsImage[i].get_mipmap(j).get_size();
00350         dataSize += size;
00351         SINFO << "    " << j 
00352               << ", " << w << "x" << h << "x" << d 
00353               << ", size: " << size 
00354               << ", mm: " << mm
00355               << endLog;
00356         
00357       }
00358     }
00359     if (validImage) {
00360       image->set( osg::Image::PixelFormat(format), 
00361                   width, height, depth,
00362                   numMipMaps + 1,
00363                   1, 0.0, 0, osg::Image::OSG_UINT8_IMAGEDATA,
00364                   true, 
00365                   ddsImage.get_num_images() );
00366       
00367       if (dataSize == image->getSize()) {
00368         data = image->getData();
00369 
00370         // copy data;
00371         for (i = 0; i < ddsImage.get_num_images(); ++i) {
00372           size = ddsImage[i].get_size();
00373           memcpy (data, ddsImage[i].get_pixels(), size);
00374           data += size;
00375           for (j = 0; j < mm; ++j) {
00376             size = ddsImage[i].get_mipmap(j).get_size();
00377             memcpy (data, ddsImage[i].get_mipmap(j).get_pixels(), size);
00378             data += size;
00379           }
00380         }
00381       }
00382       else {
00383         SWARNING << "ERROR: Invalid data size; cannot cp dds data"
00384                  << endLog;
00385 
00386       }
00387     }
00388   }
00389   else
00390     SWARNING << "DDS Load Failed !" << endLog;
00391 
00392   return validImage;;
00393 }

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

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

Implements osg::ImageFileType.

Definition at line 400 of file OSGDDSImageFileType.cpp.

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

00401 {
00402   SWARNING << getMimeType()
00403            << " write is not implemented "
00404            << endLog;
00405   
00406   return false;
00407 }

const Char8 * ImageFileType::getMimeType (  void   )  const [inherited]
 

Get method for the mime type

Definition at line 106 of file OSGImageFileType.cpp.

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

Referenced by osg::ImageFileType::dump(), osg::TIFImageFileType::read(), osg::PNGImageFileType::read(), osg::MNGImageFileType::read(), osg::JPGImageFileType::read(), osg::ImageFileHandler::read(), osg::PNGImageFileType::restoreData(), osg::JPGImageFileType::restoreData(), osg::ImageFileType::restoreData(), osg::ImageFileType::store(), osg::ImageFileHandler::store(), osg::PNGImageFileType::storeData(), osg::JPGImageFileType::storeData(), osg::ImageFileType::storeData(), osg::TIFImageFileType::write(), osg::TGAImageFileType::write(), osg::PNGImageFileType::write(), osg::MNGImageFileType::write(), osg::JPGImageFileType::write(), osg::ImageFileHandler::write(), osg::GIFImageFileType::write(), and write().

00107 {
00108     return _mimeType.str();
00109 }

const std::list< IDString > & ImageFileType::getSuffixList (  void   )  const [inherited]
 

Get method for the suffix list container

Definition at line 125 of file OSGImageFileType.cpp.

References osg::ImageFileType::_suffixList.

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

00126 {
00127     return _suffixList; 
00128 }

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 116 of file OSGImageFileType.cpp.

References osg::ImageFileType::_flags.

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

00117 {
00118     return _flags;
00119 }

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 132 of file OSGImageFileType.cpp.

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

00133 {
00134     implemented = false;
00135     return true;
00136 }

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 223 of file OSGImageFileType.cpp.

References FDEBUG, FWARNING, osg::ImageFileHandler::getFileType(), osg::NullFC, osg::Image::OSG_UINT8_IMAGEDATA, osg::ImageFileType::restoreData(), and osg::ImageFileHandler::the().

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

00225 {
00226     unsigned long   imageSize, headSize = sizeof(Head);
00227     unsigned long   size = 0, attachmentSize;
00228     Head            head;
00229     const UChar8    *data = buffer ? (buffer + headSize) : 0;
00230     ImageFileType   *type;
00231     const char      *mimeType;
00232     Image::Type     dataType;
00233 
00234     if ((image != osg::NullFC) && buffer && (memSize >= headSize)) {
00235 
00236         // Copy header. Otherwise netToHost would change the original
00237         // data structur.
00238         memcpy(&head,buffer,sizeof(Head));
00239         head.netToHost();
00240         mimeType = head.mimeType;
00241         
00242         if((type = ImageFileHandler::the().getFileType(mimeType, 0)))
00243         {
00244             if (head.dataType)
00245               dataType = Image::Type(head.dataType);
00246             else
00247               dataType = Image::OSG_UINT8_IMAGEDATA;
00248 
00249             image->set(Image::PixelFormat(head.pixelFormat), head.width,
00250                        head.height, head.depth, head.mipmapCount,
00251                        head.frameCount, float(head.frameDelay) / 1000.0, 0,
00252                        dataType,true,head.sideCount );
00253             imageSize = static_cast<unsigned long>(
00254                 type->restoreData(image, data, memSize - headSize));
00255             attachmentSize = 0; // head->attachmentSize;
00256 
00257             /*
00258             if ((attachmentSize = head->attachmentSize))
00259             {
00260                 attData = (char*)(buffer + headSize + imageSize);
00261                 attKey = attData;
00262                 attValue = 0;
00263                 for (i = 0; i < (attachmentSize-1); i++) {
00264                     if (attData[i] == 0) 
00265                         if (attKey) {
00266                             attValue = &(attData[i+1]);
00267                             image->setAttachmentField (attKey,attValue);
00268                             attKey = attValue = 0;
00269                         }
00270                         else
00271                             attKey = &(attData[i+1]);
00272                 }
00273                 if (attKey || attValue) {
00274                     FFATAL (("Attachment restore error\n"));
00275                 }
00276             }
00277             */
00278 
00279             size = headSize + imageSize + attachmentSize;
00280       
00281             FDEBUG (( "Restore image data: %lu (%lu/%lu/%lu)\n",
00282                       size, headSize, imageSize, attachmentSize ));
00283 
00284         }
00285         else
00286         {
00287             imageSize = 0;
00288             FWARNING(("Can not restore image data, invalid mimeType: %s\n",
00289                       mimeType ? mimeType : "Unknown"));
00290         }
00291 
00292       
00293     }
00294 
00295     return size;
00296 }

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 304 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().

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

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 318 of file OSGImageFileType.cpp.

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

00320 {
00321     Head            *head;
00322     unsigned long   dataSize = 0, headSize = sizeof(Head);
00323     unsigned long   attachmentSize;
00324     UChar8          *dest;
00325     const UChar8    *src = image->getData();
00326     std::map<std::string, std::string>::const_iterator aI;
00327     std::string     value;
00328 
00329     attachmentSize = 0;
00330 
00331     // get attachment size
00332     /*
00333     ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
00334         const_cast<Image*>(image.getCPtr())->findAttachment(
00335             ImageGenericAtt::getClassType().getGroupId()));
00336     if(att != NullFC)
00337     {
00338         for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
00339         {
00340             FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
00341             Field *field=att->getField(i);
00342             if (fieldDesc && field) 
00343             {
00344                 field->getValueByStr(value);
00345                 attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
00346                 attachmentSize += value.length() + 1;
00347               
00348                 std::cout << fieldDesc->getName().str() << std::endl; 
00349                 std::cout << value << std::endl; 
00350             }
00351             else 
00352             {
00353                 FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
00354             }
00355         }
00356     }
00357     */
00358 
00359     if (buffer) 
00360     {
00361         head = (Head *)buffer;
00362 
00363         head->pixelFormat    = image->getPixelFormat();
00364         head->width          = image->getWidth();
00365         head->height         = image->getHeight();
00366         head->depth          = image->getDepth();
00367         head->mipmapCount    = image->getMipMapCount();
00368         head->frameCount     = image->getFrameCount();
00369         head->frameDelay     = short(image->getFrameDelay() * 1000.0);
00370         head->sideCount      = image->getSideCount();
00371         head->dataType       = image->getDataType();
00372         head->attachmentSize = static_cast<unsigned short>(attachmentSize);
00373         head->hostToNet();
00374       
00375         strcpy(head->mimeType, getMimeType());
00376       
00377         dest = (UChar8 *) (buffer + headSize);
00378 
00379         if (src) 
00380             dataSize = static_cast<unsigned long>(
00381                 storeData(image, dest, memSize - headSize));
00382 
00383         dest = (UChar8 *) (buffer + headSize + dataSize);
00384 
00385         /*
00386         if(att != NullFC)
00387         {
00388             for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
00389             {
00390                 FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
00391                 Field *field=att->getField(i);
00392                 if (field && fieldDesc) 
00393                 {
00394                     field->getValueByStr(value);
00395 
00396                     l = strlen( fieldDesc->getName().str() );
00397                     for (i = 0; i < l; i++)
00398                       *dest++ = fieldDesc->getName().str()[i];
00399                     *dest++ = 0;
00400                     l = value.length();
00401                     for (i = 0; i < l; i++)
00402                       *dest++ = value[i];
00403                     *dest++ = 0;
00404                 }
00405                 else
00406                 {
00407                     FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
00408                 }
00409             }
00410         }
00411         */
00412 
00413         FDEBUG (( "Store image data: %lu (%lu/%lu/%lu)\n",
00414                   headSize + dataSize + attachmentSize, headSize, dataSize, 
00415                   attachmentSize ));
00416     }
00417     else {
00418         FFATAL (("Invalid buffer in ImageFileType::store()\n"));
00419     }
00420   
00421     return (headSize + dataSize + attachmentSize);
00422 
00423 }

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 430 of file OSGImageFileType.cpp.

References FINFO.

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

00431 {
00432     std::string value;
00433     unsigned long size, attachmentSize;
00434     unsigned long imageSize = image->getSize(), headSize = sizeof(Head);
00435 
00436     std::map<std::string, std::string>::const_iterator aI;
00437 
00438     attachmentSize = 0;
00439 
00440     // get attachment size
00441         /*
00442     ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
00443         const_cast<Image*>(image.getCPtr())->findAttachment(
00444             ImageGenericAtt::getClassType().getGroupId()));
00445     if(att != NullFC)
00446     {
00447         for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
00448         {
00449             FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
00450             Field *field=att->getField(i);
00451             if (field && fieldDesc) 
00452             {
00453                 field->getValueByStr(value);
00454                 attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
00455                 attachmentSize += value.length() + 1;
00456             }
00457             else 
00458             {
00459                 FFATAL (("Invalid Attachment in ImageFileType::maxBufferSize()\n"));
00460             }
00461         }
00462     }
00463         */
00464 
00465     size = headSize + imageSize + attachmentSize;
00466   
00467     FINFO (( "ImageFileType::maxBufferSize(): %lu (%lu/%lu/%lu)\n", 
00468              size, headSize, imageSize, attachmentSize ));
00469   
00470     return size;
00471 }

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::JPGImageFileType, osg::MTDImageFileType, and osg::PNGImageFileType.

Definition at line 193 of file OSGImageFileType.cpp.

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

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

00196 {
00197   FWARNING(("ImageXFileType::restoreData() not impl. for mimeType %s\n",
00198             getMimeType()));
00199 
00200   return 0;
00201 }

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::JPGImageFileType, osg::MTDImageFileType, and osg::PNGImageFileType.

Definition at line 208 of file OSGImageFileType.cpp.

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

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

00211 {
00212   FWARNING(("ImageXFileType::storeData() not impl. for mimeType %s\n",
00213             getMimeType()));
00214   
00215   return 0;
00216 }

void ImageFileType::dump (  void   )  [inherited]
 

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

Definition at line 477 of file OSGImageFileType.cpp.

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

00478 {
00479     std::list<IDString>::iterator    sI;
00480 
00481     SLOG << getMimeType();
00482 
00483     if(_suffixList.empty())
00484     {
00485         SLOG << ": Suffix: ";
00486         for(sI = _suffixList.begin(); sI != _suffixList.end(); sI++)
00487         {
00488             Log().stream(OSG::LOG_DEBUG) << sI->str() << " ";
00489         }
00490     }
00491 
00492     std::cerr << std::endl;
00493 }

Member Data Documentation

DDSImageFileType DDSImageFileType::_the [static, private]
 

Referenced by the().

The documentation for this class was generated from the following files:
Generated on Thu Aug 25 04:14:13 2005 for OpenSG by  doxygen 1.4.3