00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 #define OSG_COMPILEIMAGE
00044
00045 #include <stdlib.h>
00046 #include <stdio.h>
00047
00048 #include <algorithm>
00049
00050 #include <OSGConfig.h>
00051 #include <OSGLog.h>
00052 #include <OSGImageGenericAtt.h>
00053 #include <OSGFieldContainerFields.h>
00054 #include <OSGFileSystem.h>
00055
00056 #include "OSGImageFileHandler.h"
00057 #include "OSGPathHandler.h"
00058 #include "OSGSceneFileHandler.h"
00059
00060 #include "OSGImage.h"
00061
00062 OSG_USING_NAMESPACE
00063
00068
00069
00070
00074 Int32 Image::_formatDic[][2] =
00075 {
00076 { OSG_I_PF, 1 },
00077 { OSG_L_PF, 1 },
00078 { OSG_LA_PF, 2 },
00079 { OSG_RGB_PF, 3 },
00080 { OSG_RGBA_PF, 4 },
00081 { OSG_BGR_PF, 3 },
00082 { OSG_BGRA_PF, 4 },
00083 { OSG_RGB_DXT1, 3},
00084 { OSG_RGBA_DXT1, 4},
00085 { OSG_RGBA_DXT3, 4},
00086 { OSG_RGBA_DXT5, 4},
00087 };
00088
00089 Int32 Image::_typeDic[][2] =
00090 {
00091 { OSG_INVALID_IMAGEDATATYPE, 0 },
00092 { OSG_UINT8_IMAGEDATA, 1 },
00093 { OSG_UINT16_IMAGEDATA, 2 },
00094 { OSG_UINT32_IMAGEDATA, 4 },
00095 { OSG_FLOAT32_IMAGEDATA, 4 },
00096 { OSG_FLOAT16_IMAGEDATA, 2 },
00097 };
00098
00099
00100
00101 void Image::initMethod (void)
00102 {
00103 }
00104
00107 void Image::changed(BitVector whichField, UInt32 origin)
00108 {
00109 MFFieldContainerPtr::iterator parentsIt = _mfParents.begin();
00110 MFFieldContainerPtr::iterator parentsEnd = _mfParents.end();
00111
00112 while(parentsIt != parentsEnd)
00113 {
00114 (*parentsIt)->changed( TypeTraits<BitVector>::One <<
00115 parentsIt->getParentFieldPos(),
00116 ChangedOrigin::Child);
00117 ++parentsIt;
00118 }
00119
00120
00121 Int32 mapSizeType = sizeof(_typeDic) / sizeof(UInt32[2]);
00122 UInt32 typeFormat = 0;
00123 Int32 i;
00124 for(i = 0; i < mapSizeType; i++)
00125 {
00126 if(_typeDic[i][0] == getDataType())
00127 typeFormat = _typeDic[i][1];
00128 }
00129
00130 setComponentSize( typeFormat );
00131 setSideSize ( calcMipmapSumSize(getMipMapCount()) );
00132 setFrameSize( getSideSize() * getSideCount() );
00133
00134 Inherited::changed(whichField, origin);
00135 }
00136
00137
00138
00139 void Image::dump(UInt32 ,
00140 const BitVector ) const
00141 {
00142 const char *pfStr = "UNDEF_PIXEL_FORMAT";
00143 const char *typeStr = "INVALID_IMAGEDATA_TYPE";
00144
00145 switch(getPixelFormat())
00146 {
00147 case OSG_I_PF:
00148 pfStr = "INTENSITY";
00149 break;
00150 case OSG_L_PF:
00151 pfStr = "LUMINANCE";
00152 break;
00153 case OSG_LA_PF:
00154 pfStr = "LUMINANCE_ALPHA";
00155 break;
00156 case OSG_BGR_PF:
00157 pfStr = "BGR";
00158 break;
00159 case OSG_BGRA_PF:
00160 pfStr = "BGRA";
00161 break;
00162 case OSG_RGB_PF:
00163 pfStr = "RGB";
00164 break;
00165 case OSG_RGBA_PF:
00166 pfStr = "RGBA";
00167 break;
00168 case OSG_RGB_DXT1:
00169 pfStr = "RGB_DXT1";
00170 break;
00171 case OSG_RGBA_DXT1:
00172 pfStr = "RGBA_DXT1";
00173 break;
00174 case OSG_RGBA_DXT3:
00175 pfStr = "RGBA_DXT3";
00176 break;
00177 case OSG_RGBA_DXT5:
00178 pfStr = "RGBA_DXT5";
00179 break;
00180 default:
00181 pfStr = "UNKNOWN_PIXEL_FORMAT";
00182 break;
00183 };
00184
00185 switch (getDataType())
00186 {
00187 case OSG_UINT8_IMAGEDATA:
00188 typeStr = "IMAGEDATA_TYPE UCHAR8";
00189 break;
00190 case OSG_UINT16_IMAGEDATA:
00191 typeStr = "IMAGEDATA_TYPE UCHAR16";
00192 break;
00193 case OSG_UINT32_IMAGEDATA:
00194 typeStr = "IMAGEDATA_TYPE UCHAR32";
00195 break;
00196 case OSG_FLOAT16_IMAGEDATA:
00197 typeStr = "IMAGEDATA_TYPE FLOAT16";
00198 break;
00199 case OSG_FLOAT32_IMAGEDATA:
00200 typeStr = "IMAGEDATA_TYPE FLOAT32";
00201 break;
00202
00203 default:
00204 typeStr = "UNKNOWN_IMAGEDATA_TYPE";
00205 break;
00206 };
00207
00208 FLOG (("ImageDump: %s; %d/%d/%d; #mm: %d, #side: %d, #frame: %d, frameDelay %g, dataType %s, size: %d\n",
00209 pfStr, getWidth(),
00210 getHeight(), getDepth(),
00211 getMipMapCount(),
00212 getSideCount(),
00213 getFrameCount(), getFrameDelay(),
00214 typeStr,
00215 getSize()
00216 ));
00217 }
00218
00219
00220
00221
00222 UInt8 Image::getComponents(void) const
00223 {
00224 Int32 mapSizeFormat = sizeof(_formatDic) / sizeof(UInt32[2]);
00225
00226 for(UInt16 i = 0; i < mapSizeFormat; i++)
00227 {
00228 if(_formatDic[i][0] == getPixelFormat())
00229 return _formatDic[i][1];
00230 }
00231 FWARNING(("Image::getComponents: image %p has unknown pixel format 0x%x!",
00232 this, getPixelFormat()));
00233 return 0;
00234 }
00235
00236
00237
00241 bool Image::set(UInt32 pF,
00242 Int32 w, Int32 h,
00243 Int32 d, Int32 mmS, Int32 fS,
00244 Time fD, const UChar8 *da, Int32 t, bool allocMem,
00245 Int32 sS)
00246 {
00247 ImagePtr iPtr(this);
00248
00249 beginEditCP(iPtr,
00250 PixelFormatFieldMask |
00251 WidthFieldMask |
00252 HeightFieldMask |
00253 DepthFieldMask |
00254 MipMapCountFieldMask |
00255 SideCountFieldMask |
00256 FrameCountFieldMask |
00257 FrameDelayFieldMask |
00258 DataTypeFieldMask);
00259
00260 setPixelFormat(pF);
00261
00262 setWidth ( osgMax ( 1, w) );
00263 setHeight ( osgMax ( 1, h) );
00264 setDepth ( osgMax ( 1, d) );
00265
00266 setMipMapCount ( osgMax ( 1, mmS) );
00267 setSideCount ( osgMax ( 1, sS) );
00268 setFrameCount ( osgMax ( 1, fS) );
00269
00270 setFrameDelay(fD);
00271
00272 setDataType (t);
00273
00274 endEditCP(iPtr,
00275 PixelFormatFieldMask |
00276 WidthFieldMask |
00277 HeightFieldMask |
00278 DepthFieldMask |
00279 MipMapCountFieldMask |
00280 FrameCountFieldMask |
00281 FrameDelayFieldMask |
00282 DataTypeFieldMask);
00283
00284 return createData(da, allocMem);
00285 }
00286
00291 bool Image::set(ImagePtr image)
00292 {
00293 this->set(image->getPixelFormat(),
00294 image->getWidth(),
00295 image->getHeight(),
00296 image->getDepth(),
00297 image->getMipMapCount(),
00298 image->getFrameCount(),
00299 image->getFrameDelay(),
00300 image->getData(),
00301 image->getDataType(),
00302 true,
00303 image->getSideCount());
00304
00305 return true;
00306 }
00307
00311 bool Image::setData(const UChar8 *da)
00312 {
00313 if(da)
00314 {
00315 createData(da);
00316 }
00317 else
00318 {
00319 FWARNING(("Image::setData(Null) call\n"));
00320 }
00321
00322 return (da ? true : false);
00323 }
00324
00325 void Image::clearData(void)
00326 {
00327 getPixel().clear();
00328 }
00329
00333 bool Image::setSubData ( Int32 offX, Int32 offY, Int32 offZ,
00334 Int32 srcW, Int32 srcH, Int32 srcD,
00335 const UInt8 *src )
00336 {
00337 UChar8 *dest = getData();
00338 UInt64 lineSize;
00339
00340 FDEBUG(( "Image::setSubData (%d %d %d) - (%d %d %d) - src %p\n",
00341 offX, offY, offZ, srcW, srcH, srcD, src ));
00342
00343 if (hasCompressedData())
00344 {
00345 FFATAL (("Invalid Image::setSubData for compressed image\n"));
00346 return false;
00347 }
00348
00349 if(!src || !dest)
00350 {
00351 FFATAL(("Invalid data pointer in Image::setSubData\n"));
00352 return false;
00353 }
00354
00355
00356 UInt32 xMin = osgMax(0,offX);
00357 UInt32 yMin = osgMax(0,offY);
00358 UInt32 zMin = osgMax(0,offZ);
00359
00360 UInt32 xMax = osgMin(getWidth(), offX + srcW);
00361 UInt32 yMax = osgMin(getHeight(), offY + srcH);
00362 UInt32 zMax = osgMin(getDepth(), offZ + srcD);
00363
00364
00365 UInt32 destIdx, srcIdx = 0;
00366
00367 for(UInt32 z = zMin; z < zMax; z++)
00368 {
00369 for(UInt32 y = yMin; y < yMax; y++)
00370 {
00371 lineSize = (xMax - xMin) * getBpp();
00372 destIdx = ( (z * getHeight() + y) * getWidth() + xMin) * getBpp();
00373 memcpy (&dest[destIdx], &src[srcIdx], size_t(lineSize));
00374 srcIdx += Int32((srcW - (xMax - xMin)) * getBpp() + lineSize);
00375 }
00376 srcIdx += (srcH - (yMax - yMin)) * srcW * getBpp();
00377 }
00378
00379 return true;
00380 }
00381
00387 bool Image::flipDepthFrameData (void)
00388 {
00389 bool retCode = false;
00390 Int32 value;
00391
00392 if((getMipMapCount() == 1)&&((getFrameCount() == 1)||(getDepth() == 1)))
00393 {
00394 value = getFrameCount();
00395 setFrameCount(getDepth());
00396 setDepth(value);
00397 retCode = true;
00398 }
00399 else
00400 {
00401 FWARNING (("Cant flipDepthFrameData(); invalid data layout\n"));
00402 }
00403
00404 return retCode;
00405 }
00406
00410 bool Image::addValue(const char *value)
00411 {
00412 static Image *currentImage = 0;
00413 static UChar8 *currentData = 0;
00414
00415 Int64 j;
00416 Int64 v;
00417
00418 bool isHead = strchr(value, ' ') ? true : false;
00419
00420 if (hasCompressedData())
00421 {
00422 FFATAL (("Invalid Image::addValue for compressed image\n"));
00423 return false;
00424 }
00425
00426
00427 if(currentImage == this)
00428 {
00429 if(isHead)
00430 {
00431 FDEBUG(("Start new read cycle in image::addValue()\n"));
00432 }
00433 }
00434 else
00435 {
00436 if(!isHead)
00437 {
00438 FFATAL(("Additional image date for different image\n"));
00439 }
00440 }
00441
00442 currentImage = this;
00443
00444 if(isHead == true)
00445 {
00446 Int32 width;
00447 Int32 height;
00448 Int32 pixelDepth;
00449 PixelFormat pf = osg::Image::OSG_INVALID_PF;
00450
00451
00452 sscanf(value, "%d %d %d", &width, &height, &pixelDepth);
00453
00454 FDEBUG(("Image::addValue() set: w/h/bpp: %d/%d/%d\n",
00455 width, height, pixelDepth));
00456
00457 switch(getDataType())
00458 {
00459 case OSG_UINT8_IMAGEDATA:
00460 switch(pixelDepth)
00461 {
00462 case 1:
00463 pf = osg::Image::OSG_L_PF;
00464 break;
00465 case 2:
00466 pf = osg::Image::OSG_LA_PF;
00467 break;
00468 case 3:
00469 pf = osg::Image::OSG_RGB_PF;
00470 break;
00471 case 4:
00472 pf = osg::Image::OSG_RGBA_PF;
00473 break;
00474 default:
00475 pf = osg::Image::OSG_INVALID_PF;
00476 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00477 break;
00478 }
00479 break;
00480 case OSG_UINT16_IMAGEDATA:
00481 switch(pixelDepth)
00482 {
00483 case 2:
00484 pf = osg::Image::OSG_L_PF;
00485 break;
00486 case 4:
00487 pf = osg::Image::OSG_LA_PF;
00488 break;
00489 case 6:
00490 pf = osg::Image::OSG_RGB_PF;
00491 break;
00492 case 8:
00493 pf = osg::Image::OSG_RGBA_PF;
00494 break;
00495 default:
00496 pf = osg::Image::OSG_INVALID_PF;
00497 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00498 break;
00499 }
00500 break;
00501 case OSG_UINT32_IMAGEDATA:
00502 switch(pixelDepth)
00503 {
00504 case 4:
00505 pf = osg::Image::OSG_L_PF;
00506 break;
00507 case 8:
00508 pf = osg::Image::OSG_LA_PF;
00509 break;
00510 case 12:
00511 pf = osg::Image::OSG_RGB_PF;
00512 break;
00513 case 16:
00514 pf = osg::Image::OSG_RGBA_PF;
00515 break;
00516 default:
00517 pf = osg::Image::OSG_INVALID_PF;
00518 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00519 break;
00520 }
00521 break;
00522 case OSG_FLOAT32_IMAGEDATA:
00523 switch(pixelDepth)
00524 {
00525 case 4:
00526 pf = osg::Image::OSG_L_PF;
00527 break;
00528 case 8:
00529 pf = osg::Image::OSG_LA_PF;
00530 break;
00531 case 12:
00532 pf = osg::Image::OSG_RGB_PF;
00533 break;
00534 case 16:
00535 pf = osg::Image::OSG_RGBA_PF;
00536 break;
00537 default:
00538 pf = osg::Image::OSG_INVALID_PF;
00539 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00540 break;
00541 }
00542 break;
00543 case OSG_FLOAT16_IMAGEDATA:
00544 switch(pixelDepth)
00545 {
00546 case 2:
00547 pf = osg::Image::OSG_L_PF;
00548 break;
00549 case 4:
00550 pf = osg::Image::OSG_LA_PF;
00551 break;
00552 case 6:
00553 pf = osg::Image::OSG_RGB_PF;
00554 break;
00555 case 8:
00556 pf = osg::Image::OSG_RGBA_PF;
00557 break;
00558 default:
00559 pf = osg::Image::OSG_INVALID_PF;
00560 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00561 break;
00562 }
00563 break;
00564 default:
00565 setDataType(OSG_INVALID_IMAGEDATATYPE);
00566 FFATAL(("Invalid type of image data: %d\n", getDataType()));
00567 }
00568
00569 if(pf != 0 && (width > 0) && (height > 0))
00570 {
00571 set(pf, width, height);
00572
00573 currentData = getData();
00574 }
00575 else
00576 {
00577 currentData = NULL;
00578 }
00579 }
00580 else
00581 {
00582 if(currentData != NULL)
00583 {
00584
00585
00586
00587 v = strtoul(value, 0, strchr(value, 'x') ? 16 : 10);
00588
00589 for(j = getBpp(); j--;)
00590 {
00591 *currentData++ = UChar8( (v >> (8 * j)) & 255 );
00592 }
00593
00594 }
00595 }
00596
00597 return currentData ? true : false;
00598 }
00599
00603 bool Image::reformat ( const Image::PixelFormat pixelFormat,
00604 ImagePtr destination )
00605 {
00606 UChar8 *data = 0,*sourceData = 0;
00607 UInt32 srcI, destI, destSize = 0;
00608 UInt32 sum;
00609 Real64 sumReal;
00610 ImagePtr dest = destination;
00611
00612 if (hasCompressedData())
00613 {
00614 FFATAL (("Invalid Image::reformat for compressed image\n"));
00615 return false;
00616 }
00617
00618 if(destination == NullFC)
00619 {
00620 dest = Image::create();
00621 addRefCP(dest);
00622 }
00623
00624 FINFO (( "Try to reformat image from pixelDepth %d to %d\n",
00625 getPixelFormat(), pixelFormat ));
00626
00627
00628
00629 if ( getSize() && pixelFormat &&
00630 (destination != NullFC || (pixelFormat != getPixelFormat()) ) )
00631 {
00632
00633 dest->set(pixelFormat, getWidth(), getHeight(), getDepth() );
00634 sourceData = getData();
00635 data = dest->getData();
00636 destSize = dest->getSize();
00637
00638 UInt16 *sourceDataUC16 = (UInt16*) sourceData;
00639 UInt16 *destDataUC16 = (UInt16*) data;
00640 UInt32 *sourceDataUC32 = (UInt32*) sourceData;
00641 UInt32 *destDataUC32 = (UInt32*) data;
00642 Real32 *sourceDataF32 = (Real32*) sourceData;
00643 Real32 *destDataF32 = (Real32*) data;
00644 Real16 *sourceDataH16 = (Real16*) sourceData;
00645 Real16 *destDataH16 = (Real16* ) data;
00646
00647 if (data)
00648 {
00649 switch (getPixelFormat())
00650 {
00651
00652 case OSG_I_PF:
00653 switch (pixelFormat) {
00654 case OSG_I_PF:
00655 switch (getDataType())
00656 {
00657 case OSG_UINT8_IMAGEDATA:
00658 memcpy (getData(), data, destSize);
00659 break;
00660 case OSG_UINT16_IMAGEDATA:
00661 memcpy (getData(), data, destSize);
00662 break;
00663 case OSG_UINT32_IMAGEDATA:
00664 memcpy (getData(), data, destSize);
00665 break;
00666 case OSG_FLOAT32_IMAGEDATA:
00667 memcpy (getData(), data, destSize);
00668 break;
00669 case OSG_FLOAT16_IMAGEDATA:
00670 memcpy (getData(), data, destSize);
00671 break;
00672
00673 default:
00674 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00675 break;
00676 }
00677 break;
00678
00679 case OSG_L_PF:
00680 switch (getDataType())
00681 {
00682 case OSG_UINT8_IMAGEDATA:
00683 memcpy (getData(), data, destSize);
00684 break;
00685 case OSG_UINT16_IMAGEDATA:
00686 memcpy (getData(), data, destSize);
00687 break;
00688 case OSG_UINT32_IMAGEDATA:
00689 memcpy (getData(), data, destSize);
00690 break;
00691 case OSG_FLOAT32_IMAGEDATA:
00692 memcpy (getData(), data, destSize);
00693 break;
00694 case OSG_FLOAT16_IMAGEDATA:
00695 memcpy (getData(), data, destSize);
00696 break;
00697
00698 default:
00699 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00700 break;
00701 }
00702 break;
00703
00704 case OSG_LA_PF:
00705 switch (getDataType())
00706 {
00707 case OSG_UINT8_IMAGEDATA:
00708 for (srcI = destI = 0; destI < destSize;)
00709 {
00710 data[destI++] = sourceData[srcI];
00711 data[destI++] = sourceData[srcI++];
00712 }
00713 break;
00714 case OSG_UINT16_IMAGEDATA:
00715 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00716 {
00717 destDataUC16[destI++] = sourceDataUC16[srcI];
00718 destDataUC16[destI++] = sourceDataUC16[srcI++];
00719 }
00720 break;
00721 case OSG_UINT32_IMAGEDATA:
00722 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00723 {
00724 destDataUC32[destI++] = sourceDataUC32[srcI];
00725 destDataUC32[destI++] = sourceDataUC32[srcI++];
00726 }
00727 break;
00728 case OSG_FLOAT32_IMAGEDATA:
00729 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00730 {
00731 destDataF32[destI++] = sourceDataF32[srcI];
00732 destDataF32[destI++] = sourceDataF32[srcI++];
00733 }
00734 break;
00735
00736 case OSG_FLOAT16_IMAGEDATA:
00737 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00738 {
00739 destDataH16[destI++] = sourceDataH16[srcI];
00740 destDataH16[destI++] = sourceDataH16[srcI++];
00741 }
00742 break;
00743 default:
00744 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00745 break;
00746 }
00747 break;
00748
00749 case OSG_RGB_PF:
00750 switch (getDataType())
00751 {
00752 case OSG_UINT8_IMAGEDATA:
00753 for (srcI = destI = 0; destI < destSize;)
00754 {
00755 data[destI++] = sourceData[srcI];
00756 data[destI++] = sourceData[srcI];
00757 data[destI++] = sourceData[srcI++];
00758 }
00759 break;
00760 case OSG_UINT16_IMAGEDATA:
00761 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00762 {
00763 destDataUC16[destI++] = sourceDataUC16[srcI];
00764 destDataUC16[destI++] = sourceDataUC16[srcI];
00765 destDataUC16[destI++] = sourceDataUC16[srcI++];
00766 }
00767 break;
00768 case OSG_UINT32_IMAGEDATA:
00769 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00770 {
00771 destDataUC32[destI++] = sourceDataUC32[srcI];
00772 destDataUC32[destI++] = sourceDataUC32[srcI];
00773 destDataUC32[destI++] = sourceDataUC32[srcI++];
00774 }
00775 break;
00776 case OSG_FLOAT32_IMAGEDATA:
00777 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00778 {
00779 destDataF32[destI++] = sourceDataF32[srcI];
00780 destDataF32[destI++] = sourceDataF32[srcI];
00781 destDataF32[destI++] = sourceDataF32[srcI++];
00782 }
00783 break;
00784 case OSG_FLOAT16_IMAGEDATA:
00785 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00786 {
00787 destDataH16[destI++] = sourceDataH16[srcI];
00788 destDataH16[destI++] = sourceDataH16[srcI];
00789 destDataH16[destI++] = sourceDataH16[srcI++];
00790 }
00791 break;
00792 default:
00793 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00794 break;
00795 }
00796 break;
00797
00798 case OSG_RGBA_PF:
00799 switch (getDataType())
00800 {
00801 case OSG_UINT8_IMAGEDATA:
00802 for (srcI = destI = 0; destI < destSize;)
00803 {
00804 data[destI++] = sourceData[srcI];
00805 data[destI++] = sourceData[srcI];
00806 data[destI++] = sourceData[srcI];
00807 data[destI++] = sourceData[srcI++];
00808 }
00809 break;
00810 case OSG_UINT16_IMAGEDATA:
00811 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00812 {
00813 destDataUC16[destI++] = sourceDataUC16[srcI];
00814 destDataUC16[destI++] = sourceDataUC16[srcI];
00815 destDataUC16[destI++] = sourceDataUC16[srcI];
00816 destDataUC16[destI++] = sourceDataUC16[srcI++];
00817 }
00818 break;
00819 case OSG_UINT32_IMAGEDATA:
00820 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00821 {
00822 destDataUC32[destI++] = sourceDataUC32[srcI];
00823 destDataUC32[destI++] = sourceDataUC32[srcI];
00824 destDataUC32[destI++] = sourceDataUC32[srcI];
00825 destDataUC32[destI++] = sourceDataUC32[srcI++];
00826 }
00827 break;
00828 case OSG_FLOAT32_IMAGEDATA:
00829 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00830 {
00831 destDataF32[destI++] = sourceDataF32[srcI];
00832 destDataF32[destI++] = sourceDataF32[srcI];
00833 destDataF32[destI++] = sourceDataF32[srcI];
00834 destDataF32[destI++] = sourceDataF32[srcI++];
00835 }
00836 break;
00837 case OSG_FLOAT16_IMAGEDATA:
00838 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00839 {
00840 destDataH16[destI++] = sourceDataH16[srcI];
00841 destDataH16[destI++] = sourceDataH16[srcI];
00842 destDataH16[destI++] = sourceDataH16[srcI];
00843 destDataH16[destI++] = sourceDataH16[srcI++];
00844 }
00845 break;
00846 default:
00847 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00848 break;
00849 }
00850 break;
00851 default:
00852 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00853 break;
00854 }
00855 break;
00856
00857
00858
00859 case OSG_L_PF:
00860 switch (pixelFormat) {
00861 case OSG_L_PF:
00862 case OSG_I_PF:
00863 switch (getDataType())
00864 {
00865 case OSG_UINT8_IMAGEDATA:
00866 memcpy (getData(), data, destSize);
00867 break;
00868 case OSG_UINT16_IMAGEDATA:
00869 memcpy (getData(), data, destSize);
00870 break;
00871 case OSG_UINT32_IMAGEDATA:
00872 memcpy (getData(), data, destSize);
00873 break;
00874 case OSG_FLOAT32_IMAGEDATA:
00875 memcpy (getData(), data, destSize);
00876 break;
00877 case OSG_FLOAT16_IMAGEDATA:
00878 memcpy (getData(), data, destSize);
00879 break;
00880
00881 default:
00882 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00883 break;
00884 }
00885 break;
00886
00887 case OSG_LA_PF:
00888 switch (getDataType())
00889 {
00890 case OSG_UINT8_IMAGEDATA:
00891 for (srcI = destI = 0; destI < destSize;)
00892 {
00893 data[destI++] = sourceData[srcI];
00894 data[destI++] = sourceData[srcI++];
00895 }
00896 break;
00897 case OSG_UINT16_IMAGEDATA:
00898 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00899 {
00900 destDataUC16[destI++] = sourceDataUC16[srcI];
00901 destDataUC16[destI++] = sourceDataUC16[srcI++];
00902 }
00903 break;
00904 case OSG_UINT32_IMAGEDATA:
00905 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00906 {
00907 destDataUC32[destI++] = sourceDataUC32[srcI];
00908 destDataUC32[destI++] = sourceDataUC32[srcI++];
00909 }
00910 break;
00911 case OSG_FLOAT32_IMAGEDATA:
00912 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00913 {
00914 destDataF32[destI++] = sourceDataF32[srcI];
00915 destDataF32[destI++] = sourceDataF32[srcI++];
00916 }
00917 break;
00918
00919 case OSG_FLOAT16_IMAGEDATA:
00920 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00921 {
00922 destDataH16[destI++] = sourceDataH16[srcI];
00923 destDataH16[destI++] = sourceDataH16[srcI++];
00924 }
00925 break;
00926 default:
00927 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00928 break;
00929 }
00930 break;
00931
00932 case OSG_RGB_PF:
00933 switch (getDataType())
00934 {
00935 case OSG_UINT8_IMAGEDATA:
00936 for (srcI = destI = 0; destI < destSize;)
00937 {
00938 data[destI++] = sourceData[srcI];
00939 data[destI++] = sourceData[srcI];
00940 data[destI++] = sourceData[srcI++];
00941 }
00942 break;
00943 case OSG_UINT16_IMAGEDATA:
00944 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00945 {
00946 destDataUC16[destI++] = sourceDataUC16[srcI];
00947 destDataUC16[destI++] = sourceDataUC16[srcI];
00948 destDataUC16[destI++] = sourceDataUC16[srcI++];
00949 }
00950 break;
00951 case OSG_UINT32_IMAGEDATA:
00952 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00953 {
00954 destDataUC32[destI++] = sourceDataUC32[srcI];
00955 destDataUC32[destI++] = sourceDataUC32[srcI];
00956 destDataUC32[destI++] = sourceDataUC32[srcI++];
00957 }
00958 break;
00959 case OSG_FLOAT32_IMAGEDATA:
00960 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00961 {
00962 destDataF32[destI++] = sourceDataF32[srcI];
00963 destDataF32[destI++] = sourceDataF32[srcI];
00964 destDataF32[destI++] = sourceDataF32[srcI++];
00965 }
00966 break;
00967 case OSG_FLOAT16_IMAGEDATA:
00968 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00969 {
00970 destDataH16[destI++] = sourceDataH16[srcI];
00971 destDataH16[destI++] = sourceDataH16[srcI];
00972 destDataH16[destI++] = sourceDataH16[srcI++];
00973 }
00974 break;
00975 default:
00976 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00977 break;
00978 }
00979 break;
00980
00981 case OSG_RGBA_PF:
00982 switch (getDataType())
00983 {
00984 case OSG_UINT8_IMAGEDATA:
00985 for (srcI = destI = 0; destI < destSize;)
00986 {
00987 data[destI++] = sourceData[srcI];
00988 data[destI++] = sourceData[srcI];
00989 data[destI++] = sourceData[srcI];
00990 data[destI++] = sourceData[srcI++];
00991 }
00992 break;
00993 case OSG_UINT16_IMAGEDATA:
00994 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00995 {
00996 destDataUC16[destI++] = sourceDataUC16[srcI];
00997 destDataUC16[destI++] = sourceDataUC16[srcI];
00998 destDataUC16[destI++] = sourceDataUC16[srcI];
00999 destDataUC16[destI++] = sourceDataUC16[srcI++];
01000 }
01001 break;
01002 case OSG_UINT32_IMAGEDATA:
01003 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01004 {
01005 destDataUC32[destI++] = sourceDataUC32[srcI];
01006 destDataUC32[destI++] = sourceDataUC32[srcI];
01007 destDataUC32[destI++] = sourceDataUC32[srcI];
01008 destDataUC32[destI++] = sourceDataUC32[srcI++];
01009 }
01010 break;
01011 case OSG_FLOAT32_IMAGEDATA:
01012 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01013 {
01014 destDataF32[destI++] = sourceDataF32[srcI];
01015 destDataF32[destI++] = sourceDataF32[srcI];
01016 destDataF32[destI++] = sourceDataF32[srcI];
01017 destDataF32[destI++] = sourceDataF32[srcI++];
01018 }
01019 break;
01020 case OSG_FLOAT16_IMAGEDATA:
01021 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01022 {
01023 destDataH16[destI++] = sourceDataH16[srcI];
01024 destDataH16[destI++] = sourceDataH16[srcI];
01025 destDataH16[destI++] = sourceDataH16[srcI];
01026 destDataH16[destI++] = sourceDataH16[srcI++];
01027 }
01028 break;
01029 default:
01030 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01031 break;
01032 }
01033 break;
01034 default:
01035 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01036 break;
01037 }
01038 break;
01039
01040
01041 case OSG_LA_PF:
01042 switch (pixelFormat) {
01043 case OSG_I_PF:
01044 case OSG_L_PF:
01045 switch (getDataType())
01046 {
01047 case OSG_UINT8_IMAGEDATA:
01048 for (srcI = destI = 0; destI < destSize;)
01049 {
01050 data[destI++] = sourceData[srcI];
01051 srcI++;
01052 }
01053 break;
01054 case OSG_UINT16_IMAGEDATA:
01055 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01056 {
01057 destDataUC16[destI++] = sourceDataUC16[srcI];
01058 srcI++;
01059 }
01060 break;
01061 case OSG_UINT32_IMAGEDATA:
01062 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01063 {
01064 destDataUC32[destI++] = sourceDataUC32[srcI];
01065 srcI++;
01066 }
01067 break;
01068 case OSG_FLOAT32_IMAGEDATA:
01069 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01070 {
01071 destDataF32[destI++] = sourceDataF32[srcI];
01072 srcI++;
01073 }
01074 break;
01075 case OSG_FLOAT16_IMAGEDATA:
01076 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01077 {
01078 destDataH16[destI++] = sourceDataH16[srcI];
01079 srcI++;
01080 }
01081 break;
01082 default:
01083 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01084 break;
01085 }
01086 break;
01087 case OSG_LA_PF:
01088 switch (getDataType())
01089 {
01090 case OSG_UINT8_IMAGEDATA:
01091 memcpy (getData(), data, destSize);
01092 break;
01093 case OSG_UINT16_IMAGEDATA:
01094 memcpy (getData(), data, destSize);
01095 break;
01096 case OSG_UINT32_IMAGEDATA:
01097 memcpy (getData(), data, destSize);
01098 break;
01099 case OSG_FLOAT32_IMAGEDATA:
01100 memcpy (getData(), data, destSize);
01101 break;
01102 case OSG_FLOAT16_IMAGEDATA:
01103 memcpy (getData(), data, destSize);
01104 break;
01105 default:
01106 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01107 break;
01108 }
01109 break;
01110
01111 case OSG_RGB_PF:
01112 switch (getDataType())
01113 {
01114 case OSG_UINT8_IMAGEDATA:
01115 for (srcI = destI = 0; destI < destSize;)
01116 {
01117 data[destI++] = sourceData[srcI];
01118 data[destI++] = sourceData[srcI];
01119 data[destI++] = sourceData[srcI++];
01120 srcI++;
01121 }
01122 break;
01123 case OSG_UINT16_IMAGEDATA:
01124 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01125 {
01126 destDataUC16[destI++] = sourceDataUC16[srcI];
01127 destDataUC16[destI++] = sourceDataUC16[srcI];
01128 destDataUC16[destI++] = sourceDataUC16[srcI++];
01129 srcI++;
01130 }
01131 break;
01132 case OSG_UINT32_IMAGEDATA:
01133 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01134 {
01135 destDataUC32[destI++] = sourceDataUC32[srcI];
01136 destDataUC32[destI++] = sourceDataUC32[srcI];
01137 destDataUC32[destI++] = sourceDataUC32[srcI++];
01138 srcI++;
01139 }
01140 break;
01141 case OSG_FLOAT32_IMAGEDATA:
01142 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01143 {
01144 destDataF32[destI++] = sourceDataF32[srcI];
01145 destDataF32[destI++] = sourceDataF32[srcI];
01146 destDataF32[destI++] = sourceDataF32[srcI++];
01147 srcI++;
01148 }
01149 break;
01150 case OSG_FLOAT16_IMAGEDATA:
01151 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01152 {
01153 destDataH16[destI++] = sourceDataH16[srcI];
01154 destDataH16[destI++] = sourceDataH16[srcI];
01155 destDataH16[destI++] = sourceDataH16[srcI++];
01156 srcI++;
01157 }
01158 break;
01159 default:
01160 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01161 break;
01162 }
01163 break;
01164
01165 case OSG_RGBA_PF:
01166 switch (getDataType())
01167 {
01168 case OSG_UINT8_IMAGEDATA:
01169 for (srcI = destI = 0; destI < destSize;)
01170 {
01171 data[destI++] = sourceData[srcI];
01172 data[destI++] = sourceData[srcI];
01173 data[destI++] = sourceData[srcI++];
01174 data[destI++] = sourceData[srcI++];
01175 }
01176 break;
01177 case OSG_UINT16_