Source/System/Image/OSGImageFileType.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 // System declarations
  40 #include "OSGConfig.h"
  41 #include <iostream>
  42
  43 // Application declarations
  44 // to get ntons/ntohs
  45
  46 // Class declarations
  47 #include "OSGImageFileType.h"
  48 #include "OSGImageFileHandler.h"
  49 #include "OSGImageGenericAtt.h"
  50 #include "OSGLog.h"
  51
  52 OSG_BEGIN_NAMESPACE
  53
  54 ImageBlockAccessor::~ImageBlockAccessor(void)
  55 {
  56     _pGeoRef = NULL;
  57 }
  58
  59 ImageBlockAccessor::ImageBlockAccessor(void) :
  60     _pGeoRef     (NULL                            ),
  61     _vSize       (0, 0                            ),
  62     _eImgType    (Image::OSG_INVALID_IMAGEDATATYPE),
  63     _eImgFormat  (Image::OSG_INVALID_PF           ),
  64     _fNoDataValue(0                               )
  65 {
  66 }
  67
  68 Vec2i ImageBlockAccessor::getSize(void)
  69 {
  70     return _vSize;
  71 }
  72
  73 Image::Type ImageBlockAccessor::getType(void)
  74 {
  75     return _eImgType;
  76 }
  77
  78 Image::PixelFormat ImageBlockAccessor::getFormat(void)
  79 {
  80     return _eImgFormat;
  81 }
  82
  83 GeoReferenceAttachment *ImageBlockAccessor::getGeoRef(void)
  84 {
  85     return _pGeoRef;
  86 }
  87
  88 Real64 ImageBlockAccessor::getNoDataValue(void)
  89 {
  90     return _fNoDataValue;
  91 }
  92
  93
  94
  95 BlockAccessWrapper::~BlockAccessWrapper(void)
  96 {
  97     _pImage = NULL;
  98 }
  99
 100
 101 bool BlockAccessWrapper::isOpen(void)
 102 {
 103     return (_pImage != NULL);
 104 }
 105
 106 bool BlockAccessWrapper::readBlockA16(Vec2i   vSampleOrigin,
 107                                       Int32   iTextureSize,
 108                                       UInt16 *pTarget,
 109                                       Int32   iTargetSizeBytes)
 110 {
 111     if(_pImage == NULL)
 112         return false;
 113
 114     const UInt8 *pData = _pImage->getData();
 115
 116     UInt8 *pDst = reinterpret_cast<UInt8 *>(pTarget);
 117
 118     UInt32 destIdx = 0;
 119
 120     Int32 xMin = vSampleOrigin.x();
 121     Int32 xMax = vSampleOrigin.x() + iTextureSize;
 122
 123     Int32 yMin = vSampleOrigin.y();
 124     Int32 yMax = vSampleOrigin.y() + iTextureSize;
 125
 126     for(Int32 y = yMin; y < yMax; y++)
 127     {
 128         for(Int32 x = xMin; x < xMax; x++)
 129         {
 130             for(Int32 i = 0; i < 2; i++)
 131             {
 132                 if(y >= _pImage->getHeight() ||
 133                    x >= _pImage->getWidth()   )
 134                 {
 135                     pDst[destIdx] = 0;
 136                 }
 137                 else
 138                 {
 139                     pDst[destIdx] =
 140                         pData[((y) * _pImage->getWidth() + x) * 2 + i];
 141                 }
 142
 143                 destIdx++;
 144             }
 145         }
 146
 147         destIdx += (iTextureSize - (xMax - xMin)) * 2;
 148     }
 149
 150     return true;
 151 }
 152
 153 bool BlockAccessWrapper::readBlockA16(Vec2i   vSampleOrigin,
 154                                       Int32   iTextureSize,
 155                                       Int16  *pTarget,
 156                                       Int32   iTargetSizeBytes)
 157 {
 158     if(_pImage == NULL)
 159         return false;
 160
 161 #if 0
 162     const UInt8 *pData = _pImage->getData();
 163
 164     UInt8 *pDst = (UInt8 *) pTarget;
 165
 166     UInt32 destIdx = 0;
 167
 168     Int32 xMin = vSampleOrigin.x();
 169     Int32 xMax = vSampleOrigin.x() + iTextureSize;
 170
 171     Int32 yMin = vSampleOrigin.y();
 172     Int32 yMax = vSampleOrigin.y() + iTextureSize;
 173
 174     for(UInt32 y = yMin; y < yMax; y++)
 175     {
 176         for(UInt32 x = xMin; x < xMax; x++)
 177         {
 178             for(UInt32 i = 0; i < 2; i++)
 179             {
 180                 if(y >= _pImage->getHeight() ||
 181                    x >= _pImage->getWidth()   )
 182                 {
 183                     pDst[destIdx] = 0;
 184                 }
 185                 else
 186                 {
 187                     pDst[destIdx] =
 188                         pData[((y) * _pImage->getWidth() + x) * 2 + i];
 189                 }
 190
 191                 destIdx++;
 192             }
 193         }
 194
 195         destIdx += (iTextureSize - (xMax - xMin)) * 2;
 196     }
 197 #else
 198     const Int16 *pData = reinterpret_cast<const Int16 *>(_pImage->getData());
 199
 200     UInt32 destIdx = 0;
 201
 202     Int32 xMin = vSampleOrigin.x();
 203     Int32 xMax = vSampleOrigin.x() + iTextureSize;
 204
 205     Int32 yMin = vSampleOrigin.y();
 206     Int32 yMax = vSampleOrigin.y() + iTextureSize;
 207
 208     for(Int32 y = yMin; y < yMax; y++)
 209     {
 210         for(Int32 x = xMin; x < xMax; x++)
 211         {
 212             if(y >= _pImage->getHeight() ||
 213                x >= _pImage->getWidth()   )
 214             {
 215                 pTarget[destIdx] = 0;
 216             }
 217             else
 218             {
 219                 pTarget[destIdx] =
 220                     pData[((y) * _pImage->getWidth() + x)];
 221             }
 222
 223             ++destIdx;
 224         }
 225     }
 226 #endif
 227
 228     return true;
 229 }
 230
 231 BlockAccessWrapper::BlockAccessWrapper(void) :
 232      Inherited(    ),
 233     _pImage   (NULL)
 234 {
 235 }
 236
 237 void BlockAccessWrapper::open(const Char8 *szFilename)
 238 {
 239     _pImage = ImageFileHandler::the()->read(szFilename);
 240
 241     if(_pImage != NULL)
 242     {
 243         _pGeoRef =
 244             dynamic_cast<GeoReferenceAttachment *>(
 245                 _pImage->findAttachment(
 246                     GeoReferenceAttachment::getClassType().getGroupId()));
 247
 248         _vSize.setValues(_pImage->getWidth(),
 249                          _pImage->getHeight());
 250
 251         _eImgType   = Image::Type       (_pImage->getDataType   ());
 252         _eImgFormat = Image::PixelFormat(_pImage->getPixelFormat());
 253
 254         fprintf(stderr, "FOOO\n");
 255
 256         _pImage->dump();
 257     }
 258 }
 259
 260
 261 /*! \class ImageFileType
 262  */
 263
 264 //-------------------------------------------------------------------------
 265 /*!
 266   Helper method to convert the Head block from net to host format
 267 */
 268
 269 bool ImageFileType::Head::netToHost(void)
 270 {
 271     pixelFormat    = osgNetToHost<UInt16>(pixelFormat);
 272     width          = osgNetToHost<UInt16>(width);
 273     height         = osgNetToHost<UInt16>(height);
 274     depth          = osgNetToHost<UInt16>(depth);
 275     mipmapCount    = osgNetToHost<UInt16>(mipmapCount);
 276     frameCount     = osgNetToHost<UInt16>(frameCount);
 277     frameDelay     = osgNetToHost<UInt16>(frameDelay);
 278     sideCount      = osgNetToHost<UInt16>(sideCount);
 279     dataType       = osgNetToHost<UInt16>(dataType);
 280     _reserved3     = 0;
 281     _reserved4     = 0;
 282     attachmentSize = osgNetToHost<UInt16>(attachmentSize);
 283
 284     return true;
 285 }
 286
 287
 288 //-------------------------------------------------------------------------
 289 /*!
 290 Helper method to convert the Head block from host to net format
 291 */
 292
 293 bool ImageFileType::Head::hostToNet(void)
 294 {
 295     pixelFormat    = osgHostToNet<UInt16>(pixelFormat);
 296     width          = osgHostToNet<UInt16>(width);
 297     height         = osgHostToNet<UInt16>(height);
 298     depth          = osgHostToNet<UInt16>(depth);
 299     mipmapCount    = osgHostToNet<UInt16>(mipmapCount);
 300     frameCount     = osgHostToNet<UInt16>(frameCount);
 301     frameDelay     = osgHostToNet<UInt16>(frameDelay);
 302     sideCount      = osgHostToNet<UInt16>(sideCount);
 303     dataType       = osgHostToNet<UInt16>(dataType);
 304     _reserved3     = 0;
 305     _reserved4     = 0;
 306     attachmentSize = osgHostToNet<UInt16>(attachmentSize);
 307
 308     return true;
 309 }
 310
 311 //-------------------------------------------------------------------------
 312 /*! Get method for the mime type
 313 */
 314
 315 const Char8 *ImageFileType::getMimeType(void) const
 316 {
 317     return _mimeType.c_str();
 318 }
 319
 320 //-------------------------------------------------------------------------
 321
 322 bool ImageFileType::read(Image *pImage, const Char8 *fileName)
 323 {
 324     std::ifstream is(fileName, std::ios::binary);
 325
 326     if (is.good() == false)
 327         return false;
 328
 329     return read(pImage, is, std::string());
 330 }
 331
 332 //-------------------------------------------------------------------------
 333
 334 bool ImageFileType::write(Image const * pImage, const Char8 *fileName)
 335 {
 336     std::ofstream os(fileName, std::ios::binary);
 337
 338     if (os.good() == false)
 339         return false;
 340
 341     return write(pImage, os, std::string());
 342 }
 343
 344 //-------------------------------------------------------------------------
 345 /*! Get method for the suffix list container
 346 */
 347
 348 const std::list<std::string> &ImageFileType::getSuffixList(void) const
 349 {
 350     return _suffixList;
 351 }
 352
 353 //-------------------------------------------------------------------------
 354
 355 bool ImageFileType::validateHeader(const Char8 *fileName, bool &implemented)
 356 {
 357     implemented = false;
 358
 359     return true;
 360 }
 361
 362 ImageBlockAccessorPtr ImageFileType::open(const Char8 *szFilename)
 363 {
 364     BlockAccessWrapperPtr returnValue(new BlockAccessWrapper);
 365
 366     returnValue->open(szFilename);
 367
 368     return returnValue;
 369 }
 370
 371 //-------------------------------------------------------------------------
 372 /*!
 373   Tries to fill the image object with the data read from
 374   the given input stream. Returns true on success.
 375 */
 376
 377 bool ImageFileType::read(      Image        *pImage,
 378                                std::istream &is,
 379                          const std::string  &mimetype)
 380 {
 381     SWARNING << getMimeType()
 382              << " read from stream is not implemented"
 383              << endLog;
 384     return false;
 385 }
 386
 387 //-------------------------------------------------------------------------
 388 /*!
 389   Tries to write the image object to the given output stream.
 390   Returns true on success.
 391 */
 392
 393 bool ImageFileType::write(Image         const  *pImage,
 394                           std::ostream         &os,
 395                           std::string   const  &mimetype)
 396 {
 397     SWARNING << getMimeType()
 398              << " write to stream is not implemented"
 399              << endLog;
 400
 401     return false;
 402 }
 403
 404 //-------------------------------------------------------------------------
 405 /*!
 406   Tries to determine the mime type of the data provided by an input stream
 407   by searching for magic bytes. Returns the mime type or an empty string
 408   when the function could not determine the mime type.
 409  */
 410
 411 std::string ImageFileType::determineMimetypeFromStream(std::istream &is)
 412 {
 413     return std::string();
 414 }
 415
 416 //-------------------------------------------------------------------------
 417 /*! Constructor which takes a suffix array and size to add the
 418     ImageFileType to the Singleton ImageFileHandler
 419 */
 420
 421 ImageFileType::ImageFileType(const char   *mimeType,
 422                              const Char8  *suffixArray[],
 423                                    UInt16  suffixByteCount,
 424                                    UInt32  flags          ) :
 425
 426      Inherited (flags),
 427     _suffixList(     ),
 428     _mimeType  (     )
 429 {
 430     Int32 suffixCount = suffixByteCount / sizeof(const Char8 *);
 431     Int32 i           = 0;
 432     std::list<std::string>::iterator sI;
 433
 434     if (!mimeType)
 435     {
 436         FFATAL (("ImageFileType without valid mimeType\n"));
 437     }
 438
 439     _mimeType.assign(mimeType);
 440
 441     _suffixList.resize(suffixCount);
 442
 443     for(sI = _suffixList.begin(); sI != _suffixList.end(); sI++)
 444     {
 445         sI->assign(suffixArray[i++]);
 446         SINFO << "add image suffix: " << *sI << endLog;
 447     }
 448
 449     ImageFileHandler::the()->addImageFileType(*this);
 450 }
 451
 452 //-------------------------------------------------------------------------
 453 /*! Destructor
 454 */
 455
 456 ImageFileType::~ImageFileType(void)
 457 {
 458 }
 459
 460 //-------------------------------------------------------------------------
 461 /*! Abstract restore method. Should be overwriten by an concrete derived
 462     class. Tries to restore the image data from the given memblock.
 463 */
 464
 465 UInt64 ImageFileType::restoreData(      Image  * ,
 466                                   const UChar8 *OSG_CHECK_ARG(buffer ),
 467                                         Int32   OSG_CHECK_ARG(memSize)) const
 468 {
 469     FWARNING(("ImageXFileType::restoreData() not impl. for mimeType %s\n",
 470               getMimeType()));
 471
 472     return 0;
 473 }
 474
 475 //-------------------------------------------------------------------------
 476 /*! Abstract restore method. Should be overwriten by an concrete derived
 477     class. Tries to store the given image data to the given memblock
 478 */
 479
 480 UInt64 ImageFileType::storeData(Image  const * ,
 481                                 UChar8       *OSG_CHECK_ARG(buffer ),
 482                                 Int32         OSG_CHECK_ARG(memSize)) const
 483 {
 484     FWARNING(("ImageXFileType::storeData() not impl. for mimeType %s\n",
 485               getMimeType()));
 486
 487     return 0;
 488 }
 489
 490 //-------------------------------------------------------------------------
 491 /*! Tries to restore the Imagedata from the given memblock. The buffer must
 492     include a ImageFileType::Head data block.
 493 */
 494
 495 UInt64 ImageFileType::restore(      Image  *pImage,
 496                               const UChar8 *buffer,
 497                                     Int32   memSize)
 498 {
 499     long            imageSize, headSize = sizeof(Head);
 500     unsigned long   size = 0, attachmentSize;
 501     Head            head;
 502     const UChar8   *data = buffer ? (buffer + headSize) : 0;
 503     ImageFileType  *type;
 504     std::string     mimeType;
 505     Image::Type     dataType;
 506
 507     if((pImage != NULL) && (buffer != NULL) && (memSize >= headSize))
 508     {
 509         // Copy header. Otherwise netToHost would change the original
 510         // data structur.
 511
 512         memcpy(&head,buffer,sizeof(Head));
 513         head.netToHost();
 514         mimeType =
 515             ImageFileHandler::the()->determineMimetypeFromSuffix(head.suffix);
 516
 517         if((type = ImageFileHandler::the()->getFileType(mimeType.c_str(), 0)))
 518         {
 519             if (head.dataType)
 520                 dataType = Image::Type(head.dataType);
 521             else
 522                 dataType = Image::OSG_UINT8_IMAGEDATA;
 523
 524             pImage->set(Image::PixelFormat(head.pixelFormat),
 525                        head.width,
 526                        head.height,
 527                        head.depth,
 528                        head.mipmapCount,
 529                        head.frameCount,
 530                        float(head.frameDelay) / 1000.0,
 531                        0,
 532                        dataType,
 533                        true,
 534                        head.sideCount);
 535
 536             imageSize = static_cast<unsigned long>(
 537                 type->restoreData(pImage, data, memSize - headSize));
 538
 539             attachmentSize = 0; // head->attachmentSize;
 540
 541             /*
 542             if ((attachmentSize = head->attachmentSize))
 543             {
 544                 attData = (char*)(buffer + headSize + imageSize);
 545                 attKey = attData;
 546                 attValue = 0;
 547                 for (i = 0; i < (attachmentSize-1); i++) {
 548                     if (attData[i] == 0)
 549                         if (attKey) {
 550                             attValue = &(attData[i+1]);
 551                             image->setAttachmentField (attKey,attValue);
 552                             attKey = attValue = 0;
 553                         }
 554                         else
 555                             attKey = &(attData[i+1]);
 556                 }
 557                 if (attKey || attValue) {
 558                     FFATAL (("Attachment restore error\n"));
 559                 }
 560             }
 561             */
 562
 563             size = headSize + imageSize + attachmentSize;
 564
 565             FDEBUG (( "Restore image data: %lu (%lu/%lu/%lu)\n",
 566                       size, headSize, imageSize, attachmentSize ));
 567
 568         }
 569         else
 570         {
 571             imageSize = 0;
 572
 573             FWARNING(("Can not restore image data, invalid mimeType: %s\n",
 574                       mimeType.empty() == false ?
 575                           mimeType.c_str() : "Unknown"));
 576         }
 577     }
 578
 579     return size;
 580 }
 581
 582 //-------------------------------------------------------------------------
 583 /*! Tries to store the raster data to the given mem block.
 584     Will include a ImageFileType::Head description and the data encoded
 585     as 'mimeType'
 586 */
 587
 588 UInt64 ImageFileType::store(Image  const *pImage,
 589                             Char8  const *mimeType,
 590                             UChar8       *buffer,
 591                             Int32         memSize)
 592 {
 593     ImageFileType *type = ImageFileHandler::the()->getFileType(mimeType);
 594
 595     return type ? type->store(pImage, buffer, memSize) : 0;
 596 }
 597
 598 //-------------------------------------------------------------------------
 599 /*! Tries to store the raster data to the given mem block.
 600     Will include a ImageFileType::Head description for the derived
 601     concreate mimeType.
 602 */
 603
 604 UInt64 ImageFileType::store(Image  const *pImage,
 605                             UChar8       *buffer,
 606                             Int32         memSize)
 607 {
 608     Head            *head;
 609     unsigned long   dataSize = 0, headSize = sizeof(Head);
 610     unsigned long   attachmentSize;
 611     UChar8          *dest;
 612     const UChar8    *src = pImage->getData();
 613     std::map<std::string, std::string>::const_iterator aI;
 614     std::string     value;
 615
 616     attachmentSize = 0;
 617
 618     // get attachment size
 619     /*
 620     ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
 621         const_cast<Image*>(image.getCPtr())->findAttachment(
 622             ImageGenericAtt::getClassType().getGroupId()));
 623     if(att != NULL)
 624     {
 625         for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
 626         {
 627             FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
 628             Field *field=att->getField(i);
 629             if (fieldDesc && field)
 630             {
 631                 field->getValueByStr(value);
 632                 attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
 633                 attachmentSize += value.length() + 1;
 634
 635                 std::cout << fieldDesc->getName().str() << std::endl;
 636                 std::cout << value << std::endl;
 637             }
 638             else
 639             {
 640                 FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
 641             }
 642         }
 643     }
 644     */
 645
 646     if (buffer)
 647     {
 648         head = reinterpret_cast<Head *>(buffer);
 649
 650         head->pixelFormat    = pImage->getPixelFormat();
 651         head->width          = pImage->getWidth();
 652         head->height         = pImage->getHeight();
 653         head->depth          = pImage->getDepth();
 654         head->mipmapCount    = pImage->getMipMapCount();
 655         head->frameCount     = pImage->getFrameCount();
 656         head->frameDelay     = short(pImage->getFrameDelay() * 1000.0);
 657         head->sideCount      = pImage->getSideCount();
 658         head->dataType       = pImage->getDataType();
 659         head->attachmentSize = static_cast<unsigned short>(attachmentSize);
 660         head->hostToNet();
 661
 662         strcpy(head->suffix, _suffixList.front().c_str());
 663
 664         dest = static_cast<UChar8 *>(buffer + headSize);
 665
 666         if(src)
 667         {
 668             dataSize = static_cast<unsigned long>(
 669                 storeData(pImage, dest, memSize - headSize));
 670         }
 671
 672         dest = static_cast<UChar8 *>(buffer + headSize + dataSize);
 673
 674         /*
 675         if(att != NULL)
 676         {
 677             for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
 678             {
 679                 FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
 680                 Field *field=att->getField(i);
 681                 if (field && fieldDesc)
 682                 {
 683                     field->getValueByStr(value);
 684
 685                     l = strlen( fieldDesc->getName().str() );
 686                     for (i = 0; i < l; i++)
 687                       *dest++ = fieldDesc->getName().str()[i];
 688                     *dest++ = 0;
 689                     l = value.length();
 690                     for (i = 0; i < l; i++)
 691                       *dest++ = value[i];
 692                     *dest++ = 0;
 693                 }
 694                 else
 695                 {
 696                     FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
 697                 }
 698             }
 699         }
 700         */
 701
 702         FDEBUG (( "Store image data: %lu (%lu/%lu/%lu)\n",
 703                   headSize + dataSize + attachmentSize, headSize, dataSize,
 704                   attachmentSize ));
 705     }
 706     else
 707     {
 708         FFATAL (("Invalid buffer in ImageFileType::store()\n"));
 709     }
 710
 711     return (headSize + dataSize + attachmentSize);
 712 }
 713
 714 //-------------------------------------------------------------------------
 715 /*! Returns the max buffer size needed to store the Image (Head + mimeType
 716     specific data block)
 717 */
 718
 719 UInt64 ImageFileType::maxBufferSize(Image const * pImage)
 720 {
 721     std::string value;
 722     unsigned long size, attachmentSize;
 723     unsigned long imageSize = pImage->getSize(), headSize = sizeof(Head);
 724
 725     std::map<std::string, std::string>::const_iterator aI;
 726
 727     attachmentSize = 0;
 728
 729     // get attachment size
 730                 /*
 731     ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
 732         const_cast<Image*>(image.getCPtr())->findAttachment(
 733             ImageGenericAtt::getClassType().getGroupId()));
 734     if(att != NULL)
 735     {
 736         for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
 737         {
 738             FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
 739             Field *field=att->getField(i);
 740             if (field && fieldDesc)
 741             {
 742                 field->getValueByStr(value);
 743                 attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
 744                 attachmentSize += value.length() + 1;
 745             }
 746             else
 747             {
 748                 FFATAL (("Invalid Attachment in ImageFileType::maxBufferSize()\n"));
 749             }
 750         }
 751     }
 752                 */
 753
 754     size = headSize + imageSize + attachmentSize;
 755
 756     FINFO (( "ImageFileType::maxBufferSize(): %lu (%lu/%lu/%lu)\n",
 757              size, headSize, imageSize, attachmentSize ));
 758
 759     return size;
 760 }
 761
 762 //-------------------------------------------------------------------------
 763 /*! The dump method just writes some object debugging info to the LOG stream
 764 */
 765
 766 void ImageFileType::dump(void)
 767 {
 768     std::list<std::string>::iterator    sI;
 769
 770     SLOG << getMimeType();
 771
 772     if(_suffixList.empty())
 773     {
 774         SLOG << ": Suffix: ";
 775
 776         for(sI = _suffixList.begin(); sI != _suffixList.end(); sI++)
 777         {
 778             Log().stream(OSG::LOG_DEBUG) << sI->c_str() << " ";
 779         }
 780     }
 781
 782     std::cerr << std::endl;
 783 }
 784
 785 OSG_END_NAMESPACE
 786