/Source/System/Image/WS/OSGImage.cpp

https://github.com/msteners/OpenSGDevMaster_Toolbox · C++ · 4396 lines · 3567 code · 562 blank · 267 comment · 523 complexity · ff0725ce8aebf3f44e101061dc457d17 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /*---------------------------------------------------------------------------*\
    2. 

  2.  *                                OpenSG                                     *
    3. 

  3.  *                                                                           *
    4. 

  4.  *                                                                           *
    5. 

  5.  *               Copyright (C) 2000-2002 by the OpenSG Forum                 *
    6. 

  6.  *                                                                           *
    7. 

  7.  *                            www.opensg.org                                 *
    8. 

  8.  *                                                                           *
    9. 

  9.  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
    10. 

  10.  *                                                                           *
    11. 

  11. \*---------------------------------------------------------------------------*/
    12. 

  12. /*---------------------------------------------------------------------------*\
    13. 

  13.  *                                License                                    *
    14. 

  14.  *                                                                           *
    15. 

  15.  * This library is free software; you can redistribute it and/or modify it   *
    16. 

  16.  * under the terms of the GNU Library General Public License as published    *
    17. 

  17.  * by the Free Software Foundation, version 2.                               *
    18. 

  18.  *                                                                           *
    19. 

  19.  * This library is distributed in the hope that it will be useful, but       *
    20. 

  20.  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
    21. 

  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
    22. 

  22.  * Library General Public License for more details.                          *
    23. 

  23.  *                                                                           *
    24. 

  24.  * You should have received a copy of the GNU Library General Public         *
    25. 

  25.  * License along with this library; if not, write to the Free Software       *
    26. 

  26.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
    27. 

  27.  *                                                                           *
    28. 

  28. \*---------------------------------------------------------------------------*/
    29. 

  29. /*---------------------------------------------------------------------------*\
    30. 

  30.  *                                Changes                                    *
    31. 

  31.  *                                                                           *
    32. 

  32.  *                                                                           *
    33. 

  33.  *                                                                           *
    34. 

  34.  *                                                                           *
    35. 

  35.  *                                                                           *
    36. 

  36.  *                                                                           *
    37. 

  37. \*---------------------------------------------------------------------------*/
    38. 

  38. 

  39. #if __GNUC__ >= 4 || __GNUC_MINOR__ >=3
    40. 

  40. #pragma GCC diagnostic warning "-Wsign-compare"
    41. 

  41. #endif
    42. 

  42. 

  43. #ifdef WIN32
    44. 

  44. #pragma warning( disable : 4018 )
    45. 

  45. #endif
    46. 

  46. 

  47. //---------------------------------------------------------------------------
    48. 

  48. //  Includes
    49. 

  49. //---------------------------------------------------------------------------
    50. 

  50. 

  51. #define OSG_COMPILEIMAGE
    52. 

  52. 

  53. #include <cstdlib>
    54. 

  54. #include <cstdio>
    55. 

  55. 

  56. #include <algorithm>
    57. 

  57. 

  58. #include "OSGConfig.h"
    59. 

  59. #include "OSGLog.h"
    60. 

  60. #include "OSGImageGenericAtt.h"
    61. 

  61. #include "OSGFieldContainerFields.h"
    62. 

  62. #include "OSGFileSystem.h"
    63. 

  63. #include "OSGImageFileHandler.h"
    64. 

  64. #include "OSGSquish.h"
    65. 

  65. 

  66. /*
    67. 

  67. #include "OSGPathHandler.h"
    68. 

  68. #include "OSGSceneFileHandler.h"
    69. 

  69.  */
    70. 

  70. 

  71. #include "OSGImage.h"
    72. 

  72. 

  73. OSG_USING_NAMESPACE
    74. 

  74. 

  75. /*! \class OSG::Image
    76. 

  76.   1D/2D/3D Image with various pixel types data, can also optional hold
    77. 

  77.   mipMap and simple multi-frame data.
    78. 

  78.  */
    79. 

  79. 

  80. /*------------------------------------------------------------------------*/
    81. 

  81. /*                              static member                             */
    82. 

  82. 

  83. /*! Static dictionary to map pixelData values to the bytes per pixel
    84. 

  84.   (bpp) value.
    85. 

  85.   Internaly used in the createData() method.
    86. 

  86.  */
    87. 

  87. 

  88. UInt32 Image::_formatDic[][2] =
    89. 

  89. {
    90. 

  90.     { OSG_A_PF,      1 },
    91. 

  91.     { OSG_I_PF,      1 },
    92. 

  92.     { OSG_L_PF,      1 },
    93. 

  93.     { OSG_LA_PF,     2 },
    94. 

  94.     { OSG_RGB_PF,    3 },
    95. 

  95.     { OSG_RGBA_PF,   4 },
    96. 

  96.     { OSG_BGR_PF,    3 },
    97. 

  97.     { OSG_BGRA_PF,   4 },
    98. 

  98.     { OSG_RGB_DXT1,  3 },
    99. 

  99.     { OSG_RGBA_DXT1, 4 },
    100. 

  100.     { OSG_RGBA_DXT3, 4 },
    101. 

  101.     { OSG_RGBA_DXT5, 4 },
    102. 

  102.     { OSG_ALPHA_INTEGER_PF,           1 },
    103. 

  103.     { OSG_RGB_INTEGER_PF,             3 },
    104. 

  104.     { OSG_RGBA_INTEGER_PF,            4 },
    105. 

  105.     { OSG_BGR_INTEGER_PF,             3 },
    106. 

  106.     { OSG_BGRA_INTEGER_PF,            4 },
    107. 

  107.     { OSG_LUMINANCE_INTEGER_PF,       1 },
    108. 

  108.     { OSG_LUMINANCE_ALPHA_INTEGER_PF, 2 }
    109. 

  109. };
    110. 

  110. 

  111. Int32 Image::_typeDic[][2] =
    112. 

  112. {
    113. 

  113.     { OSG_INVALID_IMAGEDATATYPE, 0 },
    114. 

  114.     { OSG_UINT8_IMAGEDATA,       1 },
    115. 

  115.     { OSG_UINT16_IMAGEDATA,      2 },
    116. 

  116.     { OSG_UINT32_IMAGEDATA,      4 },
    117. 

  117.     { OSG_FLOAT32_IMAGEDATA,     4 },
    118. 

  118.     { OSG_FLOAT16_IMAGEDATA,     2 },
    119. 

  119.     { OSG_INT16_IMAGEDATA,       2 },
    120. 

  120.     { OSG_INT32_IMAGEDATA,       4 }
    121. 

  121. };
    122. 

  122. 

  123. /*----------------------------- class specific ----------------------------*/
    124. 

  124. 

  125. void Image::initMethod(InitPhase ePhase)
    126. 

  126. {
    127. 

  127. }
    128. 

  128. 

  129. /*! Inform parents, when image was changed
    130. 

  130.  */
    131. 

  131. 

  132. void Image::changed(ConstFieldMaskArg whichField, 
    133. 

  133.                     UInt32            origin,
    134. 

  134.                     BitVector         details)
    135. 

  135. {
    136. 

  136.     const Image *pThis = this;
    137. 

  137. 

  138.     MFParentFieldContainerPtr::const_iterator parentsIt  = 
    139. 

  139.         pThis->_mfParents.begin();
    140. 

  140. 

  141.     MFParentFieldContainerPtr::const_iterator parentsEnd = 
    142. 

  142.         pThis->_mfParents.end();
    143. 

  143. 

  144.     while(parentsIt != parentsEnd)
    145. 

  145.     {
    146. 

  146.         (*parentsIt)->changed(
    147. 

  147.             TypeTraits<BitVector>::One << parentsIt.getParentFieldPos(),
    148. 

  148.             ChangedOrigin::Child,
    149. 

  149.             whichField);
    150. 

  150. 

  151.         ++parentsIt;
    152. 

  152.     }
    153. 

  153. 

  154.     if(0x0000 != (whichField & DataTypeFieldMask))
    155. 

  155.     {
    156. 

  156.         // Update internals
    157. 

  157.         Int32 mapSizeType = sizeof(_typeDic) / sizeof(UInt32[2]);
    158. 

  158.         UInt32 typeFormat  = 0;
    159. 

  159.         Int32 i;
    160. 

  160.         
    161. 

  161.         for(i = 0; i < mapSizeType; i++)
    162. 

  162.         {
    163. 

  163.             if(_typeDic[i][0] == _sfDataType.getValue())
    164. 

  164.             {
    165. 

  165.                 typeFormat = _typeDic[i][1];
    166. 

  166.             }
    167. 

  167.         }
    168. 

  168.         
    169. 

  169.         setComponentSize( typeFormat );
    170. 

  170.     }
    171. 

  171. 

  172.     if(0x0000 != (whichField & (MipMapCountFieldMask |
    173. 

  173.                                 WidthFieldMask       |
    174. 

  174.                                 HeightFieldMask      |
    175. 

  175.                                 DepthFieldMask       |
    176. 

  176.                                 PixelFormatFieldMask )))
    177. 

  177.     {
    178. 

  178.         setSideSize(calcMipmapSumSize(_sfMipMapCount.getValue()));
    179. 

  179.     }
    180. 

  180. 

  181.     if(0x0000 != (whichField & (SideSizeFieldMask | SideCountFieldMask)))
    182. 

  182.     {
    183. 

  183.         setFrameSize(_sfSideSize.getValue() * _sfSideCount.getValue());
    184. 

  184.     }
    185. 

  185. 

  186.     calcMipmapOffsets();
    187. 

  187. 

  188.     Inherited::changed(whichField, origin, details);
    189. 

  189. }
    190. 

  190. 

  191. /*----------------------------- output ------------------------------------*/
    192. 

  192. 

  193. void Image::dump(      UInt32    ,
    194. 

  194.                  const BitVector ) const
    195. 

  195. {
    196. 

  196.     const Char8  *pfStr   = "UNDEF_PIXEL_FORMAT";
    197. 

  197.     const Char8  *typeStr = "INVALID_IMAGEDATA_TYPE";
    198. 

  198. 

  199.     switch(getPixelFormat())
    200. 

  200.     {
    201. 

  201.         case OSG_A_PF:
    202. 

  202.             pfStr = "ALPHA";
    203. 

  203.             break;
    204. 

  204.         case OSG_I_PF:
    205. 

  205.             pfStr = "INTENSITY";
    206. 

  206.             break;
    207. 

  207.         case OSG_L_PF:
    208. 

  208.             pfStr = "LUMINANCE";
    209. 

  209.             break;
    210. 

  210.         case OSG_LA_PF:
    211. 

  211.             pfStr = "LUMINANCE_ALPHA";
    212. 

  212.             break;
    213. 

  213.         case OSG_BGR_PF:
    214. 

  214.             pfStr = "BGR";
    215. 

  215.             break;
    216. 

  216.         case OSG_BGRA_PF:
    217. 

  217.             pfStr = "BGRA";
    218. 

  218.             break;
    219. 

  219.         case OSG_RGB_PF:
    220. 

  220.             pfStr = "RGB";
    221. 

  221.             break;
    222. 

  222.         case OSG_RGBA_PF:
    223. 

  223.             pfStr = "RGBA";
    224. 

  224.             break;
    225. 

  225.         case OSG_RGB_DXT1:
    226. 

  226.             pfStr = "RGB_DXT1";
    227. 

  227.             break;
    228. 

  228.         case OSG_RGBA_DXT1:
    229. 

  229.             pfStr = "RGBA_DXT1";
    230. 

  230.             break;
    231. 

  231.         case OSG_RGBA_DXT3:
    232. 

  232.             pfStr = "RGBA_DXT3";
    233. 

  233.             break;
    234. 

  234.         case OSG_RGBA_DXT5:
    235. 

  235.             pfStr = "RGBA_DXT5";
    236. 

  236.             break;
    237. 

  237.         case OSG_ALPHA_INTEGER_PF:
    238. 

  238.             pfStr = "ALPHA_INTEGER";
    239. 

  239.             break;
    240. 

  240.         case OSG_RGB_INTEGER_PF:
    241. 

  241.             pfStr = "RGB_INTEGER";
    242. 

  242.             break;
    243. 

  243.         case OSG_RGBA_INTEGER_PF:
    244. 

  244.             pfStr = "RGBA_INTEGER";
    245. 

  245.             break;
    246. 

  246.         case OSG_BGR_INTEGER_PF:
    247. 

  247.             pfStr = "BGR_INTEGER";
    248. 

  248.             break;
    249. 

  249.         case OSG_BGRA_INTEGER_PF:
    250. 

  250.             pfStr = "BGRA_INTEGER";
    251. 

  251.             break;
    252. 

  252.         case OSG_LUMINANCE_INTEGER_PF:
    253. 

  253.             pfStr = "LUMINANCE_INTEGER";
    254. 

  254.             break;
    255. 

  255.         case OSG_LUMINANCE_ALPHA_INTEGER_PF:
    256. 

  256.             pfStr = "LUMINANCE_ALPHA_INTEGER";
    257. 

  257.             break;
    258. 

  258.         default:
    259. 

  259.             pfStr = "UNKNOWN_PIXEL_FORMAT";
    260. 

  260.             break;
    261. 

  261.     };
    262. 

  262. 

  263.     switch (getDataType())
    264. 

  264.     {
    265. 

  265.         case OSG_UINT8_IMAGEDATA:
    266. 

  266.             typeStr = "IMAGEDATA_TYPE UCHAR8";
    267. 

  267.             break;
    268. 

  268.         case OSG_UINT16_IMAGEDATA:
    269. 

  269.             typeStr = "IMAGEDATA_TYPE UCHAR16";
    270. 

  270.             break;
    271. 

  271.         case OSG_UINT32_IMAGEDATA:
    272. 

  272.             typeStr = "IMAGEDATA_TYPE UCHAR32";
    273. 

  273.             break;
    274. 

  274.         case OSG_FLOAT16_IMAGEDATA:
    275. 

  275.             typeStr = "IMAGEDATA_TYPE FLOAT16";
    276. 

  276.             break;
    277. 

  277.         case OSG_FLOAT32_IMAGEDATA:
    278. 

  278.             typeStr = "IMAGEDATA_TYPE FLOAT32";
    279. 

  279.             break;
    280. 

  280.         case OSG_INT16_IMAGEDATA:
    281. 

  281.             typeStr = "IMAGEDATA_TYPE INT16";
    282. 

  282.             break;
    283. 

  283.         case OSG_INT32_IMAGEDATA:
    284. 

  284.             typeStr = "IMAGEDATA_TYPE INT32";
    285. 

  285.             break;
    286. 

  286. 

  287.         default:
    288. 

  288.             typeStr = "UNKNOWN_IMAGEDATA_TYPE";
    289. 

  289.             break;
    290. 

  290.     };
    291. 

  291. 

  292.     FLOG (("ImageDump: %s; %d/%d/%d; #mm: %d, side %d, #frame: %d, "
    293. 

  293.            "frameDelay %g, dataType %s, size: %ld\n",
    294. 

  294.            pfStr,
    295. 

  295.            getWidth(),
    296. 

  296.            getHeight(),
    297. 

  297.            getDepth(),
    298. 

  298.            getMipMapCount(),
    299. 

  299.            getSideCount(),
    300. 

  300.            getFrameCount(),
    301. 

  301.            getFrameDelay(),
    302. 

  302.            typeStr,
    303. 

  303.            getSize()));
    304. 

  304. }
    305. 

  305. 

  306. // Return the number of components per pixel.
    307. 

  307. 

  308. UInt8  Image::getComponents(void) const
    309. 

  309. {
    310. 

  310.     UInt16 mapSizeFormat = sizeof(_formatDic) / sizeof(UInt32[2]);
    311. 

  311. 

  312.     for(UInt16 i = 0; i < mapSizeFormat; i++)
    313. 

  313.     {
    314. 

  314.         if(_formatDic[i][0] == getPixelFormat())
    315. 

  315.             return _formatDic[i][1];
    316. 

  316.     }
    317. 

  317. 

  318.     FWARNING(("Image::getComponents: image %p has unknown pixel format 0x%x!",
    319. 

  319.                 this, getPixelFormat()));
    320. 

  320. 

  321.     return 0;
    322. 

  322. }
    323. 

  323. 

  324. /*------------------------------ set object data --------------------------*/
    325. 

  325. 

  326. /*! method to set the image data. Use the doCopy parameter to specify, whether
    327. 

  327.     the method should copy or link the pixel data.
    328. 

  328. */
    329. 

  329. bool Image::set(      UInt32  pF,
    330. 

  330.                       Int32   w,
    331. 

  331.                       Int32   h,
    332. 

  332.                       Int32   d,
    333. 

  333.                       Int32   mmS,
    334. 

  334.                       Int32   fS,
    335. 

  335.                       Time    fD,
    336. 

  336.                 const UChar8 *da,
    337. 

  337.                       Int32   t,
    338. 

  338.                       bool    allocMem,
    339. 

  339.                       Int32   sS)
    340. 

  340. {
    341. 

  341.     setPixelFormat(pF );
    342. 

  342. 

  343.     setWidth      (osgMax ( 1, w  ));
    344. 

  344.     setHeight     (osgMax ( 1, h  ));
    345. 

  345.     setDepth      (osgMax ( 1, d  ));
    346. 

  346. 

  347.     setMipMapCount(osgMax ( 1, mmS));
    348. 

  348.     setSideCount  (osgMax ( 1, sS ));
    349. 

  349.     setFrameCount (osgMax ( 1, fS ));
    350. 

  350. 

  351.     setFrameDelay (fD);
    352. 

  352. 

  353.     setDataType   (t );
    354. 

  354. 

  355.     calcMipmapOffsets();
    356. 

  356. 

  357.     return createData(da, allocMem);
    358. 

  358. }
    359. 

  359. 

  360. /*! method to set the image from another image object.
    361. 

  361.     Use the doCopy parameter to specify, whether
    362. 

  362.     the method should copy or link the pixel data.
    363. 

  363.  */
    364. 

  364. 

  365. bool Image::set(Image *image)
    366. 

  366. {
    367. 

  367.     this->set(image->getPixelFormat(),
    368. 

  368.               image->getWidth      (),
    369. 

  369.               image->getHeight     (),
    370. 

  370.               image->getDepth      (),
    371. 

  371.               image->getMipMapCount(),
    372. 

  372.               image->getFrameCount (),
    373. 

  373.               image->getFrameDelay (),
    374. 

  374.               image->getData       (),
    375. 

  375.               image->getDataType   (),
    376. 

  376.               true,
    377. 

  377.               image->getSideCount  ());
    378. 

  378.     return true;
    379. 

  379. }
    380. 

  380. 

  381. /*! method to set only the image pixel data, all parameter (e. pixelFormat
    382. 

  382.     width,height and depth) stay the same
    383. 

  383.  */
    384. 

  384. 

  385. bool Image::setData(const UChar8 *da)
    386. 

  386. {
    387. 

  387.     if(da)
    388. 

  388.     {
    389. 

  389.         createData(da);
    390. 

  390.     }
    391. 

  391.     else
    392. 

  392.     {
    393. 

  393.         FWARNING(("Image::setData(Null) call\n"));
    394. 

  394.     }
    395. 

  395. 

  396.     return (da ? true : false);
    397. 

  397. }
    398. 

  398. 

  399. void Image::clearData(void)
    400. 

  400. {
    401. 

  401.     editMFPixel()->clear();
    402. 

  402. }
    403. 

  403. 

  404. /*! method to update just a subregion of the image data
    405. 

  405.   all paramter (e. pixelFormat,width,height,depth) stay the same
    406. 

  406. */
    407. 

  407. bool Image::setSubData(      Int32  offX,
    408. 

  408.                              Int32  offY,
    409. 

  409.                              Int32  offZ,
    410. 

  410.                              Int32  srcW,
    411. 

  411.                              Int32  srcH,
    412. 

  412.                              Int32  srcD,
    413. 

  413.                        const UInt8 *src )
    414. 

  414. {
    415. 

  415.     UChar8 *dest = editData();
    416. 

  416.     UInt64  lineSize;
    417. 

  417. 

  418.     FDEBUG(( "Image::setSubData (%d %d %d) - (%d %d %d) - src %p\n",
    419. 

  419.              offX, offY, offZ, srcW, srcH, srcD, src ));
    420. 

  420. 

  421.     if (hasCompressedData())
    422. 

  422.     {
    423. 

  423.         FFATAL (("Invalid Image::setSubData for compressed image\n"));
    424. 

  424.         return false;
    425. 

  425.     }
    426. 

  426. 

  427.     if(!src || !dest)
    428. 

  428.     {
    429. 

  429.         FFATAL(("Invalid data pointer in Image::setSubData\n"));
    430. 

  430.         return false;
    431. 

  431.     }
    432. 

  432. 

  433.     // determine the area to actually copy
    434. 

  434.     UInt32 xMin = osgMax(0, offX);
    435. 

  435.     UInt32 yMin = osgMax(0, offY);
    436. 

  436.     UInt32 zMin = osgMax(0, offZ);
    437. 

  437. 

  438.     UInt32 xMax = osgMin(getWidth (), offX + srcW);
    439. 

  439.     UInt32 yMax = osgMin(getHeight(), offY + srcH);
    440. 

  440.     UInt32 zMax = osgMin(getDepth (), offZ + srcD);
    441. 

  441. 

  442.     // fill the destination buffer with the subdata
    443. 

  443.     UInt32 destIdx, srcIdx = 0;
    444. 

  444. 

  445.     for(UInt32 z = zMin; z < zMax; z++)
    446. 

  446.     {
    447. 

  447.         for(UInt32 y = yMin; y < yMax; y++)
    448. 

  448.         {
    449. 

  449.             lineSize = (xMax - xMin) * getBpp();
    450. 

  450.             destIdx  = ((z * getHeight() + y) * getWidth() + xMin) * getBpp();
    451. 

  451. 

  452.             memcpy (&dest[destIdx], &src[srcIdx], size_t(lineSize));
    453. 

  453. 

  454.             srcIdx  += Int32((srcW - (xMax - xMin)) * getBpp() + lineSize);
    455. 

  455.         }
    456. 

  456.         srcIdx += (srcH - (yMax - yMin)) * srcW * getBpp();
    457. 

  457.     }
    458. 

  458. 

  459.     return true;
    460. 

  460. }
    461. 

  461. 

  462. /*! The Image is not just a 2D container. The class can hold 3D (volume)
    463. 

  463.     and movie data. If we have 3D/singleFrame or 2D/multiFrame data without
    464. 

  464.     mipmaps we can flip between this two formats by just swapping the
    465. 

  465.     getFrameCount() and getDepth() values.
    466. 

  466. */
    467. 

  467. bool Image::flipDepthFrameData(void)
    468. 

  468. {
    469. 

  469.     bool  retCode = false;
    470. 

  470.     Int32 value;
    471. 

  471. 

  472.     if((getMipMapCount() == 1) &&
    473. 

  473.        ((getFrameCount() == 1) || (getDepth() == 1)))
    474. 

  474.     {
    475. 

  475.         value = getFrameCount();
    476. 

  476. 

  477.         setFrameCount(getDepth());
    478. 

  478.         setDepth     (value     );
    479. 

  479. 

  480.         retCode = true;
    481. 

  481.     }
    482. 

  482.     else
    483. 

  483.     {
    484. 

  484.       FWARNING (("Cant flipDepthFrameData(); invalid data layout\n"));
    485. 

  485.     }
    486. 

  486. 

  487.     return retCode;
    488. 

  488. }
    489. 

  489. 

  490. /*! This method is used by the parser to fill the image with
    491. 

  491.     string pixel data. It expects the data in VRML PixelTexture Format.
    492. 

  492. */
    493. 

  493. bool Image::addValue(const char *value)
    494. 

  494. {
    495. 

  495.     static Image  *currentImage = 0;
    496. 

  496.     static UChar8 *currentData  = 0;
    497. 

  497. 

  498.            Int64   j;
    499. 

  499.            Int64   v;
    500. 

  500. 

  501.            bool    isHead = strchr(value, ' ') ? true : false;
    502. 

  502. 

  503.     if (hasCompressedData())
    504. 

  504.     {
    505. 

  505.         FFATAL (("Invalid Image::addValue for compressed image\n"));
    506. 

  506.         return false;
    507. 

  507.     }
    508. 

  508. 

  509.     // make sure we only read one image at a time
    510. 

  510.     if(currentImage == this)
    511. 

  511.     {
    512. 

  512.         if(isHead)
    513. 

  513.         {
    514. 

  514.             FDEBUG(("Start new read cycle in image::addValue()\n"));
    515. 

  515.         }
    516. 

  516.     }
    517. 

  517.     else
    518. 

  518.     {
    519. 

  519.         if(!isHead)
    520. 

  520.         {
    521. 

  521.             FFATAL(("Additional image date for different image\n"));
    522. 

  522.         }
    523. 

  523.     }
    524. 

  524. 

  525.     currentImage = this;
    526. 

  526. 

  527.     if(isHead == true)
    528. 

  528.     {
    529. 

  529.         Int32        width;
    530. 

  530.         Int32        height;
    531. 

  531.         Int32        pixelDepth;
    532. 

  532.         PixelFormat  pf         = Image::OSG_INVALID_PF;
    533. 

  533. 

  534.         // read the head
    535. 

  535.         sscanf(value, "%d %d %d", &width, &height, &pixelDepth);
    536. 

  536. 

  537.         FDEBUG(("Image::addValue() set: w/h/bpp: %d/%d/%d\n",
    538. 

  538.                 width, height, pixelDepth));
    539. 

  539. 

  540.         switch(getDataType())
    541. 

  541.         {
    542. 

  542.             case OSG_UINT8_IMAGEDATA:
    543. 

  543.                 switch(pixelDepth)
    544. 

  544.                 {
    545. 

  545.                     case 1:
    546. 

  546.                         pf = OSG::Image::OSG_L_PF;
    547. 

  547.                         break;
    548. 

  548.                     case 2:
    549. 

  549.                         pf = OSG::Image::OSG_LA_PF;
    550. 

  550.                         break;
    551. 

  551.                     case 3:
    552. 

  552.                         pf = OSG::Image::OSG_RGB_PF;
    553. 

  553.                         break;
    554. 

  554.                     case 4:
    555. 

  555.                         pf = OSG::Image::OSG_RGBA_PF;
    556. 

  556.                         break;
    557. 

  557.                     default:
    558. 

  558.                         pf = OSG::Image::OSG_INVALID_PF;
    559. 

  559.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    560. 

  560.                         break;
    561. 

  561.                 }
    562. 

  562.                 break;
    563. 

  563. 

  564.             case OSG_UINT16_IMAGEDATA:
    565. 

  565.                 switch(pixelDepth)
    566. 

  566.                 {
    567. 

  567.                     case 2:
    568. 

  568.                         pf = OSG::Image::OSG_L_PF;
    569. 

  569.                         break;
    570. 

  570.                     case 4:
    571. 

  571.                         pf = OSG::Image::OSG_LA_PF;
    572. 

  572.                         break;
    573. 

  573.                     case 6:
    574. 

  574.                         pf = OSG::Image::OSG_RGB_PF;
    575. 

  575.                         break;
    576. 

  576.                     case 8:
    577. 

  577.                         pf = OSG::Image::OSG_RGBA_PF;
    578. 

  578.                         break;
    579. 

  579.                     default:
    580. 

  580.                         pf = OSG::Image::OSG_INVALID_PF;
    581. 

  581.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    582. 

  582.                         break;
    583. 

  583.                 }
    584. 

  584.                 break;
    585. 

  585. 

  586.             case OSG_UINT32_IMAGEDATA:
    587. 

  587.                 switch(pixelDepth)
    588. 

  588.                 {
    589. 

  589.                     case 4:
    590. 

  590.                         pf = OSG::Image::OSG_L_PF;
    591. 

  591.                         break;
    592. 

  592.                     case 8:
    593. 

  593.                         pf = OSG::Image::OSG_LA_PF;
    594. 

  594.                         break;
    595. 

  595.                     case 12:
    596. 

  596.                         pf = OSG::Image::OSG_RGB_PF;
    597. 

  597.                         break;
    598. 

  598.                     case 16:
    599. 

  599.                         pf = OSG::Image::OSG_RGBA_PF;
    600. 

  600.                         break;
    601. 

  601.                     default:
    602. 

  602.                         pf = OSG::Image::OSG_INVALID_PF;
    603. 

  603.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    604. 

  604.                         break;
    605. 

  605.                 }
    606. 

  606.                 break;
    607. 

  607. 

  608.             case OSG_FLOAT32_IMAGEDATA:
    609. 

  609.                 switch(pixelDepth)
    610. 

  610.                 {
    611. 

  611.                     case 4:
    612. 

  612.                         pf = OSG::Image::OSG_L_PF;
    613. 

  613.                         break;
    614. 

  614.                     case 8:
    615. 

  615.                         pf = OSG::Image::OSG_LA_PF;
    616. 

  616.                         break;
    617. 

  617.                     case 12:
    618. 

  618.                         pf = OSG::Image::OSG_RGB_PF;
    619. 

  619.                         break;
    620. 

  620.                     case 16:
    621. 

  621.                         pf = OSG::Image::OSG_RGBA_PF;
    622. 

  622.                         break;
    623. 

  623.                     default:
    624. 

  624.                         pf = OSG::Image::OSG_INVALID_PF;
    625. 

  625.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    626. 

  626.                         break;
    627. 

  627.                 }
    628. 

  628.                 break;
    629. 

  629. 

  630.             case OSG_FLOAT16_IMAGEDATA:
    631. 

  631.                 switch(pixelDepth)
    632. 

  632.                 {
    633. 

  633.                     case 2:
    634. 

  634.                         pf = OSG::Image::OSG_L_PF;
    635. 

  635.                         break;
    636. 

  636.                     case 4:
    637. 

  637.                         pf = OSG::Image::OSG_LA_PF;
    638. 

  638.                         break;
    639. 

  639.                     case 6:
    640. 

  640.                         pf = OSG::Image::OSG_RGB_PF;
    641. 

  641.                         break;
    642. 

  642.                     case 8:
    643. 

  643.                         pf = OSG::Image::OSG_RGBA_PF;
    644. 

  644.                         break;
    645. 

  645.                     default:
    646. 

  646.                         pf = OSG::Image::OSG_INVALID_PF;
    647. 

  647.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    648. 

  648.                         break;
    649. 

  649.                 }
    650. 

  650.                 break;
    651. 

  651. 

  652. 			case OSG_INT16_IMAGEDATA:
    653. 

  653. 			case OSG_INT32_IMAGEDATA:
    654. 

  654.             {
    655. 

  655.                 FFATAL((" 'addValue' NYI\n "));
    656. 

  656.             }
    657. 

  657.             break;
    658. 

  658. 

  659.             default:
    660. 

  660.                 setDataType(OSG_INVALID_IMAGEDATATYPE);
    661. 

  661.                 FFATAL(("Invalid type of image data: %d\n", getDataType()));
    662. 

  662.         }
    663. 

  663. 

  664.         if(pf != 0 && (width > 0) && (height > 0))
    665. 

  665.         {
    666. 

  666.             set(pf, width, height);
    667. 

  667. 

  668.             currentData = editData();
    669. 

  669.         }
    670. 

  670.         else
    671. 

  671.         {
    672. 

  672.             currentData = NULL;
    673. 

  673.         }
    674. 

  674.     }
    675. 

  675.     else
    676. 

  676.     {
    677. 

  677.         if(currentData != NULL)
    678. 

  678.         {
    679. 

  679.             // add data
    680. 

  680.             // TODO; should we check the bounds, should be done by the parser
    681. 

  681. 

  682.             v = strtoul(value, 0, strchr(value, 'x') ? 16 : 10);
    683. 

  683. 

  684.             for(j = getBpp(); j--;)
    685. 

  685.             {
    686. 

  686.                 *currentData++ = UChar8( (v >> (8 * j)) & 255 );
    687. 

  687.             }
    688. 

  688. 

  689.         }
    690. 

  690.     }
    691. 

  691. 

  692.     return currentData ? true : false;
    693. 

  693. }
    694. 

  694. 

  695. /*! It is a simple method to reformat the image pixelFormat (not the size).
    696. 

  696.     So you can for example convert a RGBA to RGB or RGB to Grey image.
    697. 

  697. */
    698. 

  698. bool Image::reformat(const Image::PixelFormat  pixelFormat,
    699. 

  699.                            Image              *destination,
    700. 

  700.                            Int32               iCompressionFlags)
    701. 

  701. {
    702. 

  702.           UChar8   *data       = NULL;
    703. 

  703.     const UChar8   *sourceData = NULL;
    704. 

  704.           UInt32    srcI, destI, destSize = 0;
    705. 

  705.           UInt32         sum;
    706. 

  706.           Real64         sumReal;
    707. 

  707.           ImageUnrecPtr  dest(destination);
    708. 

  708. 

  709.     if (hasCompressedData())
    710. 

  710.     {
    711. 

  711.         FFATAL (("Invalid Image::reformat for compressed image\n"));
    712. 

  712.         return false;
    713. 

  713.     }
    714. 

  714. 

  715.     if(destination == NULL)
    716. 

  716.     {
    717. 

  717.         dest = Image::create();
    718. 

  718.     }
    719. 

  719. 

  720.     FINFO(("Try to reformat image from pixelDepth %d to %d\n",
    721. 

  721.            getPixelFormat(),
    722. 

  722.            pixelFormat    ));
    723. 

  723. 

  724.     if(iCompressionFlags == 0)
    725. 

  725.     {
    726. 

  726.         iCompressionFlags = (osgsquish::kColourMetricPerceptual | 
    727. 

  727.                              osgsquish::kColourRangeFit         );
    728. 

  728.     }
    729. 

  729. 

  730.     iCompressionFlags &= ~0x07;
    731. 

  731. 

  732.     // TODO !!! code all the cases !!!
    733. 

  733. 

  734.     if(getSize()    != 0              &&
    735. 

  735.        pixelFormat  != OSG_INVALID_PF &&
    736. 

  736.        (destination != 0 || (pixelFormat != static_cast<Image::PixelFormat>(getPixelFormat()))))
    737. 

  737.     {
    738. 

  738. 

  739.         dest->set(pixelFormat, 
    740. 

  740.                   getWidth      (), 
    741. 

  741.                   getHeight     (), 
    742. 

  742.                   getDepth      (), 
    743. 

  743.                   getMipMapCount(),
    744. 

  744.                   getFrameCount (), 
    745. 

  745.                   getFrameDelay (), 
    746. 

  746.                   NULL, 
    747. 

  747.                   getDataType   (), 
    748. 

  748.                   true, 
    749. 

  749.                   getSideCount  ());
    750. 

  750. 

  751.         sourceData = getData();
    752. 

  752. 

  753.         data       = dest->editData();
    754. 

  754.         destSize   = dest->getSize();
    755. 

  755. 

  756.         const UInt16 *sourceDataUC16 = 
    757. 

  757.             reinterpret_cast<const UInt16 *>(sourceData);
    758. 

  758. 

  759.               UInt16 *destDataUC16   = reinterpret_cast<UInt16 *>(data);
    760. 

  760. 

  761.         const UInt32 *sourceDataUC32 = 
    762. 

  762.             reinterpret_cast<const UInt32 *>(sourceData);
    763. 

  763. 

  764.               UInt32 *destDataUC32   = reinterpret_cast<UInt32 *>(data);
    765. 

  765. 

  766.         const Real32 *sourceDataF32  = 
    767. 

  767.             reinterpret_cast<const Real32 *>(sourceData);
    768. 

  768. 

  769.               Real32 *destDataF32    = reinterpret_cast<Real32 *>(data);
    770. 

  770. 

  771.         const Real16 *sourceDataH16  = 
    772. 

  772.             reinterpret_cast<const Real16 *>(sourceData);
    773. 

  773. 

  774.               Real16 *destDataH16    = reinterpret_cast<Real16 *>(data);
    775. 

  775. 

  776.         if(data)
    777. 

  777.         {
    778. 

  778.             switch (getPixelFormat())
    779. 

  779.             {
    780. 

  780.                 //-----------------------------------------------------
    781. 

  781.                 case OSG_A_PF:
    782. 

  782.                     switch (pixelFormat) 
    783. 

  783.                     {
    784. 

  784.                         case OSG_A_PF:
    785. 

  785.                         case OSG_I_PF:
    786. 

  786.                         case OSG_L_PF:
    787. 

  787.                             switch (getDataType())
    788. 

  788.                             {
    789. 

  789.                                 case OSG_UINT8_IMAGEDATA:
    790. 

  790.                                 case OSG_UINT16_IMAGEDATA:
    791. 

  791.                                 case OSG_UINT32_IMAGEDATA:
    792. 

  792.                                 case OSG_FLOAT32_IMAGEDATA:
    793. 

  793.                                 case OSG_FLOAT16_IMAGEDATA:
    794. 

  794.                                     memcpy (data, getData(), destSize);
    795. 

  795.                                     break;
    796. 

  796.                                     
    797. 

  797.                                 default:
    798. 

  798.                                     FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    799. 

  799.                                 break;
    800. 

  800.                             }
    801. 

  801.                             break;
    802. 

  802. 

  803.                         case OSG_LA_PF:
    804. 

  804.                             switch (getDataType())
    805. 

  805.                             {
    806. 

  806.                                 case OSG_UINT8_IMAGEDATA:
    807. 

  807.                                     for (srcI = destI = 0; destI < destSize;)
    808. 

  808.                                     {
    809. 

  809.                                         data[destI++] = sourceData[srcI];
    810. 

  810.                                         data[destI++] = sourceData[srcI++];
    811. 

  811.                                     }
    812. 

  812.                                     break;
    813. 

  813.                                 case OSG_UINT16_IMAGEDATA:
    814. 

  814.                                     for (srcI = destI = 0; destI < destSize/getComponentSize();)
    815. 

  815.                                     {
    816. 

  816.                                         destDataUC16[destI++] = sourceDataUC16[srcI];
    817. 

  817.                                         destDataUC16[destI++] = sourceDataUC16[srcI++];
    818. 

  818.                                     }
    819. 

  819.                                     break;
    820. 

  820.                                 case OSG_UINT32_IMAGEDATA:
    821. 

  821.                                     for (srcI = destI = 0; destI < destSize/getComponentSize();)
    822. 

  822.                                     {
    823. 

  823.                                         destDataUC32[destI++] = sourceDataUC32[srcI];
    824. 

  824.                                         destDataUC32[destI++] = sourceDataUC32[srcI++];
    825. 

  825.                                     }
    826. 

  826.                                     break;
    827. 

  827.                                 case OSG_FLOAT32_IMAGEDATA:
    828. 

  828.                                     for (srcI = destI = 0; destI < destSize/getComponentSize();)
    829. 

  829.                                     {
    830. 

  830.                                         destDataF32[destI++] = sourceDataF32[srcI];
    831. 

  831.                                         destDataF32[destI++] = sourceDataF32[srcI++];
    832. 

  832.                                     }
    833. 

  833.                                     break;
    834. 

  834.                                     
    835. 

  835.                                 case OSG_FLOAT16_IMAGEDATA:
    836. 

  836.                                     for (srcI = destI = 0; destI < destSize/getComponentSize();)
    837. 

  837.                                     {
    838. 

  838.                                         destDataH16[destI++] = sourceDataH16[srcI];
    839. 

  839.                                         destDataH16[destI++] = sourceDataH16[srcI++];
    840. 

  840.                                     }
    841. 

  841.                                     break;
    842. 

  842.                                 default:
    843. 

  843.                                     FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    844. 

  844.                                     break;
    845. 

  845.                             }
    846. 

  846.                             break;
    847. 

  847.                             
    848. 

  848.                         case OSG_RGB_PF:
    849. 

  849.                             switch (getDataType())
    850. 

  850.                             {
    851. 

  851.                                 case OSG_UINT8_IMAGEDATA:
    852. 

  852.                                     for (srcI = destI = 0; destI < destSize;)
    853. 

  853.                                     {
    854. 

  854.                                         data[destI++] = sourceData[srcI];
    855. 

  855.                                         data[destI++] = sourceData[srcI];
    856. 

  856.                                         data[destI++] = sourceData[srcI++];
    857. 

  857.                                     }
    858. 

  858.                                     break;
    859. 

  859.                                 case OSG_UINT16_IMAGEDATA:
    860. 

  860.                                     for (srcI = destI = 0; destI < destSize/getComponentSize();)
    861. 

  861.                                     {
    862. 

  862.                                         destDataUC16[destI++] = sourceDataUC16[srcI];
    863. 

  863.                                         destDataUC16[destI++] = sourceDataUC16[srcI];
    864. 

  864.                                         destDataUC16[destI++] = sourceDataUC16[srcI++];
    865. 

  865.                                     }
    866. 

  866.                                     break;
    867. 

  867.                                 case OSG_UINT32_IMAGEDATA:
    868. 

  868.                                     for (srcI = destI = 0; destI < destSize/getComponentSize();)
    869. 

  869.                                     {
    870. 

  870.                                         destDataUC32[destI++] = sourceDataUC32[srcI];
    871. 

  871.                                         destDataUC32[destI++] = sourceDataUC32[srcI];
    872. 

  872.                                         destDataUC32[destI++] = sourceDataUC32[srcI++];
    873. 

  873.                                     }
    874. 

  874.                                     break;
    875. 

  875.                                 case OSG_FLOAT32_IMAGEDATA:
    876. 

  876.                                     for (srcI = destI = 0; destI < destSize/getComponentSize();)
    877. 

  877.                                     {
    878. 

  878.                                         destDataF32[destI++] = sourceDataF32[srcI];
    879. 

  879.                                         destDataF32[destI++] = sourceDataF32[srcI];
    880. 

  880.                                         destDataF32[destI++] = sourceDataF32[srcI++];
    881. 

  881.                                     }
    882. 

  882.                                     break;
    883. 

  883.                                 case OSG_FLOAT16_IMAGEDATA:
    884. 

  884.                                     for (srcI = destI = 0; destI < destSize/getComponentSize();)
    885. 

  885.                                     {
    886. 

  886.                                         destDataH16[destI++] = sourceDataH16[srcI];
    887. 

  887.                                         destDataH16[destI++] = sourceDataH16[srcI];
    888. 

  888.                                         destDataH16[destI++] = sourceDataH16[srcI++];
    889. 

  889.                                     }
    890. 

  890.                                     break;
    891. 

  891.                                 default:
    892. 

  892.                                     FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    893. 

  893.                                     break;
    894. 

  894.                             }
    895. 

  895.                             break;
    896. 

  896.                             
    897. 

  897.                         case OSG_RGBA_PF:
    898. 

  898.                             switch (getDataType())
    899. 

  899.                             {
    900. 

  900.                                 case OSG_UINT8_IMAGEDATA:
    901. 

  901.                                     for (srcI = destI = 0; destI < destSize;)
    902. 

  902.                                     {
    903. 

  903.                                         data[destI++] = sourceData[srcI];
    904. 

  904.                                     data[destI++] = sourceData[srcI];
    905. 

  905.                                     data[destI++] = sourceData[srcI];
    906. 

  906.                                     data[destI++] = sourceData[srcI++];
    907. 

  907.                                 }
    908. 

  908.                                 break;
    909. 

  909.                             case OSG_UINT16_IMAGEDATA:
    910. 

  910.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    911. 

  911.                                 {
    912. 

  912.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    913. 

  913.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    914. 

  914.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    915. 

  915.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    916. 

  916.                                 }
    917. 

  917.                                 break;
    918. 

  918.                             case OSG_UINT32_IMAGEDATA:
    919. 

  919.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    920. 

  920.                                 {
    921. 

  921.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    922. 

  922.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    923. 

  923.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    924. 

  924.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    925. 

  925.                                 }
    926. 

  926.                                 break;
    927. 

  927.                             case OSG_FLOAT32_IMAGEDATA:
    928. 

  928.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    929. 

  929.                                 {
    930. 

  930.                                     destDataF32[destI++] = sourceDataF32[srcI];
    931. 

  931.                                     destDataF32[destI++] = sourceDataF32[srcI];
    932. 

  932.                                     destDataF32[destI++] = sourceDataF32[srcI];
    933. 

  933.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    934. 

  934.                                 }
    935. 

  935.                                 break;
    936. 

  936.                             case OSG_FLOAT16_IMAGEDATA:
    937. 

  937.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    938. 

  938.                                 {
    939. 

  939.                                     destDataH16[destI++] = sourceDataH16[srcI];
    940. 

  940.                                     destDataH16[destI++] = sourceDataH16[srcI];
    941. 

  941.                                     destDataH16[destI++] = sourceDataH16[srcI];
    942. 

  942.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    943. 

  943.                                 }
    944. 

  944.                                 break;
    945. 

  945.                             default:
    946. 

  946.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    947. 

  947.                                 break;
    948. 

  948.                             }
    949. 

  949.                             break;
    950. 

  950.                     default:
    951. 

  951.                         FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    952. 

  952.                         break;
    953. 

  953.                     }
    954. 

  954.                     break;
    955. 

  955. 

  956.                 //-----------------------------------------------------
    957. 

  957.                 case OSG_I_PF:
    958. 

  958.                     switch (pixelFormat) 
    959. 

  959.                     {
    960. 

  960.                         case OSG_A_PF:
    961. 

  961.                         case OSG_I_PF:
    962. 

  962.                         case OSG_L_PF:
    963. 

  963.                             switch (getDataType())
    964. 

  964.                             {
    965. 

  965.                             case OSG_UINT8_IMAGEDATA:
    966. 

  966.                                 memcpy (data, getData(), destSize);
    967. 

  967.                                 break;
    968. 

  968.                             case OSG_UINT16_IMAGEDATA:
    969. 

  969.                                 memcpy (data, getData(), destSize);
    970. 

  970.                                 break;
    971. 

  971.                             case OSG_UINT32_IMAGEDATA:
    972. 

  972.                                 memcpy (data, getData(), destSize);
    973. 

  973.                                 break;
    974. 

  974.                             case OSG_FLOAT32_IMAGEDATA:
    975. 

  975.                                 memcpy (data, getData(), destSize);
    976. 

  976.                                 break;
    977. 

  977.                             case OSG_FLOAT16_IMAGEDATA:
    978. 

  978.                                 memcpy (data, getData(), destSize);
    979. 

  979.                                 break;
    980. 

  980. 

  981.                             default:
    982. 

  982.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    983. 

  983.                                 break;
    984. 

  984.                             }
    985. 

  985.                             break;
    986. 

  986. 

  987.                         case OSG_LA_PF:
    988. 

  988.                             switch (getDataType())
    989. 

  989.                             {
    990. 

  990.                             case OSG_UINT8_IMAGEDATA:
    991. 

  991.                                 for (srcI = destI = 0; destI < destSize;)
    992. 

  992.                                 {
    993. 

  993.                                     data[destI++] = sourceData[srcI];
    994. 

  994.                                     data[destI++] = sourceData[srcI++];
    995. 

  995.                                 }
    996. 

  996.                                 break;
    997. 

  997.                             case OSG_UINT16_IMAGEDATA:
    998. 

  998.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    999. 

  999.                                 {
    1000. 

  1000.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1001. 

  1001.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1002. 

  1002.                                 }
    1003. 

  1003.                                 break;
    1004. 

  1004.                             case OSG_UINT32_IMAGEDATA:
    1005. 

  1005.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1006. 

  1006.                                 {
    1007. 

  1007.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1008. 

  1008.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1009. 

  1009.                                 }
    1010. 

  1010.                                 break;
    1011. 

  1011.                             case OSG_FLOAT32_IMAGEDATA:
    1012. 

  1012.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1013. 

  1013.                                 {
    1014. 

  1014.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1015. 

  1015.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1016. 

  1016.                                 }
    1017. 

  1017.                                 break;
    1018. 

  1018. 

  1019.                             case OSG_FLOAT16_IMAGEDATA:
    1020. 

  1020.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1021. 

  1021.                                 {
    1022. 

  1022.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1023. 

  1023.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1024. 

  1024.                                 }
    1025. 

  1025.                                 break;
    1026. 

  1026.                             default:
    1027. 

  1027.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1028. 

  1028.                                 break;
    1029. 

  1029.                             }
    1030. 

  1030.                             break;
    1031. 

  1031. 

  1032.                         case OSG_RGB_PF:
    1033. 

  1033.                             switch (getDataType())
    1034. 

  1034.                             {
    1035. 

  1035.                             case OSG_UINT8_IMAGEDATA:
    1036. 

  1036.                                 for (srcI = destI = 0; destI < destSize;)
    1037. 

  1037.                                 {
    1038. 

  1038.                                     data[destI++] = sourceData[srcI];
    1039. 

  1039.                                     data[destI++] = sourceData[srcI];
    1040. 

  1040.                                     data[destI++] = sourceData[srcI++];
    1041. 

  1041.                                 }
    1042. 

  1042.                                 break;
    1043. 

  1043.                             case OSG_UINT16_IMAGEDATA:
    1044. 

  1044.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1045. 

  1045.                                 {
    1046. 

  1046.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1047. 

  1047.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1048. 

  1048.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1049. 

  1049.                                 }
    1050. 

  1050.                                 break;
    1051. 

  1051.                             case OSG_UINT32_IMAGEDATA:
    1052. 

  1052.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1053. 

  1053.                                 {
    1054. 

  1054.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1055. 

  1055.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1056. 

  1056.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1057. 

  1057.                                 }
    1058. 

  1058.                                 break;
    1059. 

  1059.                             case OSG_FLOAT32_IMAGEDATA:
    1060. 

  1060.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1061. 

  1061.                                 {
    1062. 

  1062.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1063. 

  1063.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1064. 

  1064.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1065. 

  1065.                                 }
    1066. 

  1066.                                 break;
    1067. 

  1067.                             case OSG_FLOAT16_IMAGEDATA:
    1068. 

  1068.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1069. 

  1069.                                 {
    1070. 

  1070.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1071. 

  1071.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1072. 

  1072.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1073. 

  1073.                                 }
    1074. 

  1074.                                 break;
    1075. 

  1075.                             default:
    1076. 

  1076.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1077. 

  1077.                                 break;
    1078. 

  1078.                             }
    1079. 

  1079.                             break;
    1080. 

  1080. 

  1081.                         case OSG_RGBA_PF:
    1082. 

  1082.                             switch (getDataType())
    1083. 

  1083.                             {
    1084. 

  1084.                             case OSG_UINT8_IMAGEDATA:
    1085. 

  1085.                                 for (srcI = destI = 0; destI < destSize;)
    1086. 

  1086.                                 {
    1087. 

  1087.                                     data[destI++] = sourceData[srcI];
    1088. 

  1088.                                     data[destI++] = sourceData[srcI];
    1089. 

  1089.                                     data[destI++] = sourceData[srcI];
    1090. 

  1090.                                     data[destI++] = sourceData[srcI++];
    1091. 

  1091.                                 }
    1092. 

  1092.                                 break;
    1093. 

  1093.                             case OSG_UINT16_IMAGEDATA:
    1094. 

  1094.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1095. 

  1095.                                 {
    1096. 

  1096.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1097. 

  1097.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1098. 

  1098.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1099. 

  1099.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1100. 

  1100.                                 }
    1101. 

  1101.                                 break;
    1102. 

  1102.                             case OSG_UINT32_IMAGEDATA:
    1103. 

  1103.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1104. 

  1104.                                 {
    1105. 

  1105.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1106. 

  1106.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1107. 

  1107.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1108. 

  1108.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1109. 

  1109.                                 }
    1110. 

  1110.                                 break;
    1111. 

  1111.                             case OSG_FLOAT32_IMAGEDATA:
    1112. 

  1112.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1113. 

  1113.                                 {
    1114. 

  1114.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1115. 

  1115.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1116. 

  1116.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1117. 

  1117.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1118. 

  1118.                                 }
    1119. 

  1119.                                 break;
    1120. 

  1120.                             case OSG_FLOAT16_IMAGEDATA:
    1121. 

  1121.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1122. 

  1122.                                 {
    1123. 

  1123.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1124. 

  1124.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1125. 

  1125.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1126. 

  1126.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1127. 

  1127.                                 }
    1128. 

  1128.                                 break;
    1129. 

  1129.                             default:
    1130. 

  1130.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1131. 

  1131.                                 break;
    1132. 

  1132.                             }
    1133. 

  1133.                             break;
    1134. 

  1134.                     default:
    1135. 

  1135.                         FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1136. 

  1136.                         break;
    1137. 

  1137.                     }
    1138. 

  1138.                     break;
    1139. 

  1139. 

  1140. 

  1141.                 //-----------------------------------------------------
    1142. 

  1142.                 case OSG_L_PF:
    1143. 

  1143.                     switch (pixelFormat) 
    1144. 

  1144.                     {
    1145. 

  1145.                         case OSG_A_PF:
    1146. 

  1146.                         case OSG_I_PF:
    1147. 

  1147.                         case OSG_L_PF:
    1148. 

  1148.                             switch (getDataType())
    1149. 

  1149.                             {
    1150. 

  1150.                             case OSG_UINT8_IMAGEDATA:
    1151. 

  1151.                                 memcpy (data, getData(), destSize);
    1152. 

  1152.                                 break;
    1153. 

  1153.                             case OSG_UINT16_IMAGEDATA:
    1154. 

  1154.                                 memcpy (data, getData(), destSize);
    1155. 

  1155.                                 break;
    1156. 

  1156.                             case OSG_UINT32_IMAGEDATA:
    1157. 

  1157.                                 memcpy (data, getData(), destSize);
    1158. 

  1158.                                 break;
    1159. 

  1159.                             case OSG_FLOAT32_IMAGEDATA:
    1160. 

  1160.                                 memcpy (data, getData(), destSize);
    1161. 

  1161.                                 break;
    1162. 

  1162.                             case OSG_FLOAT16_IMAGEDATA:
    1163. 

  1163.                                 memcpy (data, getData(), destSize);
    1164. 

  1164.                                 break;
    1165. 

  1165. 

  1166.                             default:
    1167. 

  1167.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1168. 

  1168.                                 break;
    1169. 

  1169.                             }
    1170. 

  1170.                             break;
    1171. 

  1171. 

  1172.                         case OSG_LA_PF:
    1173. 

  1173.                             switch (getDataType())
    1174. 

  1174.                             {
    1175. 

  1175.                             case OSG_UINT8_IMAGEDATA:
    1176. 

  1176.                                 for (srcI = destI = 0; destI < destSize;)
    1177. 

  1177.                                 {
    1178. 

  1178.                                     data[destI++] = sourceData[srcI];
    1179. 

  1179.                                     data[destI++] = sourceData[srcI++];
    1180. 

  1180.                                 }
    1181. 

  1181.                                 break;
    1182. 

  1182.                             case OSG_UINT16_IMAGEDATA:
    1183. 

  1183.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1184. 

  1184.                                 {
    1185. 

  1185.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1186. 

  1186.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1187. 

  1187.                                 }
    1188. 

  1188.                                 break;
    1189. 

  1189.                             case OSG_UINT32_IMAGEDATA:
    1190. 

  1190.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1191. 

  1191.                                 {
    1192. 

  1192.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1193. 

  1193.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1194. 

  1194.                                 }
    1195. 

  1195.                                 break;
    1196. 

  1196.                             case OSG_FLOAT32_IMAGEDATA:
    1197. 

  1197.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1198. 

  1198.                                 {
    1199. 

  1199.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1200. 

  1200.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1201. 

  1201.                                 }
    1202. 

  1202.                                 break;
    1203. 

  1203. 

  1204.                             case OSG_FLOAT16_IMAGEDATA:
    1205. 

  1205.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1206. 

  1206.                                 {
    1207. 

  1207.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1208. 

  1208.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1209. 

  1209.                                 }
    1210. 

  1210.                                 break;
    1211. 

  1211.                             default:
    1212. 

  1212.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1213. 

  1213.                                 break;
    1214. 

  1214.                             }
    1215. 

  1215.                             break;
    1216. 

  1216. 

  1217.                         case OSG_RGB_PF:
    1218. 

  1218.                             switch (getDataType())
    1219. 

  1219.                             {
    1220. 

  1220.                             case OSG_UINT8_IMAGEDATA:
    1221. 

  1221.                                 for (srcI = destI = 0; destI < destSize;)
    1222. 

  1222.                                 {
    1223. 

  1223.                                     data[destI++] = sourceData[srcI];
    1224. 

  1224.                                     data[destI++] = sourceData[srcI];
    1225. 

  1225.                                     data[destI++] = sourceData[srcI++];
    1226. 

  1226.                                 }
    1227. 

  1227.                                 break;
    1228. 

  1228.                             case OSG_UINT16_IMAGEDATA:
    1229. 

  1229.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1230. 

  1230.                                 {
    1231. 

  1231.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1232. 

  1232.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1233. 

  1233.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1234. 

  1234.                                 }
    1235. 

  1235.                                 break;
    1236. 

  1236.                             case OSG_UINT32_IMAGEDATA:
    1237. 

  1237.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1238. 

  1238.                                 {
    1239. 

  1239.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1240. 

  1240.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1241. 

  1241.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1242. 

  1242.                                 }
    1243. 

  1243.                                 break;
    1244. 

  1244.                             case OSG_FLOAT32_IMAGEDATA:
    1245. 

  1245.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1246. 

  1246.                                 {
    1247. 

  1247.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1248. 

  1248.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1249. 

  1249.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1250. 

  1250.                                 }
    1251. 

  1251.                                 break;
    1252. 

  1252.                             case OSG_FLOAT16_IMAGEDATA:
    1253. 

  1253.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1254. 

  1254.                                 {
    1255. 

  1255.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1256. 

  1256.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1257. 

  1257.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1258. 

  1258.                                 }
    1259. 

  1259.                                 break;
    1260. 

  1260.                             default:
    1261. 

  1261.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));…
    1262.