root/OpenSceneGraph/trunk/src/osgPlugins/dds/ReaderWriterDDS.cpp @ 12541

Revision 12541, 38.0 kB (checked in by robert, 3 years ago)

From Farshid Lashkari, "Attached is a small patch that adds support for writing BGR images to the DDS plugin."

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/**********************************************************************
2*
3*    FILE:            ReaderWriterdds.cpp
4*
5*    DESCRIPTION:    Class for reading a DDS file into an osg::Image.
6*
7*                    Example on reading a DDS file code can be found at:
8*                    http://developer.nvidia.com/docs/IO/1327/ATT/
9*                    ARB_texture_compression.pdf
10*                    Author: Sebastien Domine, NVIDIA Corporation
11*
12*    CREATED BY:     Rune Schmidt Jensen, rsj@uni-dk
13*
14*    HISTORY:        Created   31.03.2003
15*             Modified  13.05.2004
16*                by George Tarantilis, gtaranti@nps.navy.mil
17*             Modified  22.05.2009
18*                Wojtek Lewandowski, lewandowski@ai.com.pl
19*
20*    WARNING:
21*          Bit Masks in the WrtiteDDS are set for 8 bit components
22*          write with 4 or 16 bit components will
23*          probably produce corrupted file
24*          Wojtek Lewandowski 2009-05-22
25*
26**********************************************************************/
27#include <osg/Texture>
28#include <osg/Notify>
29
30#include <osgDB/Registry>
31#include <osgDB/FileNameUtils>
32#include <osgDB/FileUtils>
33#include <osgDB/fstream>
34#include <iomanip>
35#include <stdio.h>
36#include <string.h>
37
38#if defined(OSG_GLES1_AVAILABLE) || defined(OSG_GLES2_AVAILABLE)
39    #define GL_RED                  0x1903
40    #define GL_LUMINANCE4_ALPHA4    0x8043
41#endif
42
43#if defined(OSG_GL3_AVAILABLE)
44    #define GL_LUMINANCE4_ALPHA4    0x8043
45#endif
46
47// NOTICE ON WIN32:
48// typedef DWORD unsigned long;
49// sizeof(DWORD) = 4
50
51typedef unsigned int UI32;
52typedef int I32;
53
54struct  DDCOLORKEY
55{
56    DDCOLORKEY():
57        dwColorSpaceLowValue(0),
58        dwColorSpaceHighValue(0) {}
59       
60    UI32    dwColorSpaceLowValue;
61    UI32    dwColorSpaceHighValue;
62};
63
64struct DDPIXELFORMAT
65{
66
67    DDPIXELFORMAT():
68        dwSize(0),
69        dwFlags(0),
70        dwFourCC(0),
71        dwRGBBitCount(0),
72        dwRBitMask(0),
73        dwGBitMask(0),
74        dwBBitMask(0),
75        dwRGBAlphaBitMask(0) {}
76       
77
78    UI32    dwSize;
79    UI32    dwFlags;
80    UI32    dwFourCC;
81    union
82    {
83        UI32    dwRGBBitCount;
84        UI32    dwYUVBitCount;
85        UI32    dwZBufferBitDepth;
86        UI32    dwAlphaBitDepth;
87        UI32    dwLuminanceBitDepth;
88    };
89    union
90    {
91        UI32    dwRBitMask;
92        UI32    dwYBitMask;
93    };
94    union
95    {
96        UI32    dwGBitMask;
97        UI32    dwUBitMask;
98    };
99    union
100    {
101        UI32    dwBBitMask;
102        UI32    dwVBitMask;
103    };
104    union
105    {
106        UI32    dwRGBAlphaBitMask;
107        UI32    dwYUVAlphaBitMask;
108        UI32    dwRGBZBitMask;
109        UI32    dwYUVZBitMask;
110    };
111};
112
113struct  DDSCAPS2
114{
115     DDSCAPS2():
116        dwCaps(0),
117        dwCaps2(0),
118        dwCaps3(0),
119        dwCaps4(0) {}
120
121    UI32       dwCaps;
122    UI32       dwCaps2;
123    UI32       dwCaps3;
124    union
125    {
126        UI32       dwCaps4;
127        UI32       dwVolumeDepth;
128    };
129};
130
131struct DDSURFACEDESC2
132{
133    DDSURFACEDESC2():
134        dwSize(0),
135        dwFlags(0),
136        dwHeight(0),
137        dwWidth(0),
138        lPitch(0),
139        dwBackBufferCount(0),
140        dwMipMapCount(0),
141        dwAlphaBitDepth(0),
142        dwReserved(0),     
143        lpSurface(0),     
144        dwTextureStage(0) {}     
145       
146
147    UI32         dwSize;
148    UI32         dwFlags;
149    UI32         dwHeight;
150    UI32         dwWidth;
151    union                         
152    {
153        I32              lPitch;
154        UI32     dwLinearSize;
155    };
156    union
157    {
158        UI32      dwBackBufferCount;
159        UI32      dwDepth;     
160    };
161    union
162    {
163        UI32     dwMipMapCount;
164        UI32     dwRefreshRate;
165    };
166    UI32         dwAlphaBitDepth;
167    UI32         dwReserved;     
168    UI32        lpSurface;         //Fred Marmond: removed from pointer type to UI32 for 64bits compatibility. it is unused data
169    DDCOLORKEY    ddckCKDestOverlay;     
170    DDCOLORKEY    ddckCKDestBlt;           
171    DDCOLORKEY    ddckCKSrcOverlay;       
172    DDCOLORKEY    ddckCKSrcBlt;           
173    DDPIXELFORMAT ddpfPixelFormat;         
174    DDSCAPS2      ddsCaps;                 
175    UI32 dwTextureStage;         
176};
177
178//
179// Structure of a DXT-1 compressed texture block
180// see page "Opaque and 1-Bit Alpha Textures (Direct3D 9)" on http://msdn.microsoft.com
181// url at time of writing http://msdn.microsoft.com/en-us/library/bb147243(v=VS.85).aspx
182//
183struct DXT1TexelsBlock
184{
185    unsigned short color_0;     // colors at their
186    unsigned short color_1;     // extreme
187    unsigned int   texels4x4;   // interpolated colors (2 bits per texel)
188};
189
190//
191// DDSURFACEDESC2 flags that mark the validity of the struct data
192//
193#define DDSD_CAPS               0x00000001l     // default
194#define DDSD_HEIGHT             0x00000002l        // default
195#define DDSD_WIDTH              0x00000004l        // default
196#define DDSD_PIXELFORMAT        0x00001000l        // default
197#define DDSD_PITCH              0x00000008l     // For uncompressed formats
198#define DDSD_MIPMAPCOUNT        0x00020000l
199#define DDSD_LINEARSIZE         0x00080000l     // For compressed formats
200#define DDSD_DEPTH              0x00800000l        // Volume Textures
201
202//
203// DDPIXELFORMAT flags
204//
205#define DDPF_ALPHAPIXELS        0x00000001l
206#define DDPF_FOURCC             0x00000004l        // Compressed formats
207#define DDPF_RGB                0x00000040l        // Uncompressed formats
208#define DDPF_ALPHA              0x00000002l
209#define DDPF_COMPRESSED         0x00000080l
210#define DDPF_LUMINANCE          0x00020000l
211#define DDPF_BUMPLUMINANCE      0x00040000l        // L,U,V
212#define DDPF_BUMPDUDV           0x00080000l        // U,V
213
214//
215// DDSCAPS flags
216//
217#define DDSCAPS_TEXTURE         0x00001000l     // default
218#define DDSCAPS_COMPLEX         0x00000008l
219#define DDSCAPS_MIPMAP          0x00400000l
220#define DDSCAPS2_VOLUME         0x00200000l
221
222
223#ifndef MAKEFOURCC
224#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
225    ((UI32)(char)(ch0) | ((UI32)(char)(ch1) << 8) |   \
226    ((UI32)(char)(ch2) << 16) | ((UI32)(char)(ch3) << 24 ))
227#endif //defined(MAKEFOURCC)
228
229/*
230* FOURCC codes for DX compressed-texture pixel formats
231*/
232#define FOURCC_DXT1  (MAKEFOURCC('D','X','T','1'))
233#define FOURCC_DXT2  (MAKEFOURCC('D','X','T','2'))
234#define FOURCC_DXT3  (MAKEFOURCC('D','X','T','3'))
235#define FOURCC_DXT4  (MAKEFOURCC('D','X','T','4'))
236#define FOURCC_DXT5  (MAKEFOURCC('D','X','T','5'))
237
238/*
239* FOURCC codes for 3dc compressed-texture pixel formats
240*/
241#define FOURCC_ATI1  (MAKEFOURCC('A','T','I','1'))
242#define FOURCC_ATI2  (MAKEFOURCC('A','T','I','2'))
243
244static unsigned int ComputeImageSizeInBytes
245    ( int width, int height, int depth,
246      unsigned int pixelFormat, unsigned int pixelType,
247      int packing = 1, int slice_packing = 1, int image_packing = 1 )
248{
249    if( width < 1 )  width = 1;
250    if( height < 1 ) height = 1;
251    if( depth < 1 )  depth = 1;
252
253    // Taking advantage of the fact that
254    // DXT formats are defined as 4 successive numbers:
255    // GL_COMPRESSED_RGB_S3TC_DXT1_EXT         0x83F0
256    // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT        0x83F1
257    // GL_COMPRESSED_RGBA_S3TC_DXT3_EXT        0x83F2
258    // GL_COMPRESSED_RGBA_S3TC_DXT5_EXT        0x83F3
259    if( pixelFormat >= GL_COMPRESSED_RGB_S3TC_DXT1_EXT &&
260        pixelFormat <= GL_COMPRESSED_RGBA_S3TC_DXT5_EXT )
261    {
262        width = (width + 3) & ~3;
263        height = (height + 3) & ~3;
264    }
265    // 3dc ATI formats
266    // GL_COMPRESSED_RED_RGTC1_EXT                     0x8DBB
267    // GL_COMPRESSED_SIGNED_RED_RGTC1_EXT              0x8DBC
268    // GL_COMPRESSED_RED_GREEN_RGTC2_EXT               0x8DBD
269    // GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT        0x8DBE
270    if( pixelFormat >= GL_COMPRESSED_RED_RGTC1_EXT &&
271        pixelFormat <= GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT )
272    {
273        width = (width + 3) & ~3;
274        height = (height + 3) & ~3;
275    }
276    // compute size of one row
277    unsigned int size = osg::Image::computeRowWidthInBytes
278                            ( width, pixelFormat, pixelType, packing );
279
280    // now compute size of slice
281    size *= height;
282    size += slice_packing - 1;
283    size -= size % slice_packing;
284
285    // compute size of whole image
286    size *= depth;
287    size += image_packing - 1;
288    size -= size % image_packing;
289
290    return size;
291}
292
293osg::Image* ReadDDSFile(std::istream& _istream)
294{
295    DDSURFACEDESC2 ddsd;
296
297    char filecode[4];
298   
299    _istream.read(filecode, 4);
300    if (strncmp(filecode, "DDS ", 4) != 0) {
301        return NULL;
302    }
303    // Get the surface desc.
304    _istream.read((char*)(&ddsd), sizeof(ddsd));
305
306    osg::ref_ptr<osg::Image> osgImage = new osg::Image();   
307   
308    //Check valid structure sizes
309    if(ddsd.dwSize != 124 && ddsd.ddpfPixelFormat.dwSize != 32)
310    {
311        return NULL;
312    }
313
314    bool is3dImage = false;
315    int depth = 1;
316
317    // Check for volume image
318    if( ddsd.dwDepth > 0 && (ddsd.dwFlags & DDSD_DEPTH))
319    {
320        is3dImage = true;
321        depth = ddsd.dwDepth;
322    }
323
324    // Retreive image properties.
325    int s = ddsd.dwWidth;
326    int t = ddsd.dwHeight;
327    int r = depth;
328    unsigned int dataType = GL_UNSIGNED_BYTE;
329    unsigned int pixelFormat = 0;
330    unsigned int internalFormat = 0;
331
332    // Handle some esoteric formats
333    if(ddsd.ddpfPixelFormat.dwFlags & DDPF_BUMPDUDV)
334    {
335        OSG_WARN << "ReadDDSFile warning: DDPF_BUMPDUDV format is not supported" << std::endl;
336        return NULL;
337//         ddsd.ddpfPixelFormat.dwFlags =
338//             DDPF_LUMINANCE + DDPF_ALPHAPIXELS;
339//         // handle V8U8 as A8L8
340//         // handle V16U16 as A16L16
341//         // but Q8W8U8L8 as RGB?
342//         // A2W10U10V10 as RGBA (dwFlags == DDPF_BUMPDUDV + DDPF_ALPHAPIXELS)
343    }
344    if(ddsd.ddpfPixelFormat.dwFlags & DDPF_BUMPLUMINANCE)
345    {
346        OSG_WARN << "ReadDDSFile warning: DDPF_BUMPLUMINANCE format is not supported" << std::endl;
347        return NULL;
348//         ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
349//         // handle as RGB
350//         // L6V5U5 -- 655 is not supported data type in GL
351//         // X8L8V8U8 -- just as RGB
352    }
353   
354    // Uncompressed formats will usually use DDPF_RGB to indicate an RGB format,
355    // while compressed formats will use DDPF_FOURCC with a four-character code.
356   
357    bool usingAlpha = ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS;
358
359    // Uncompressed formats.
360    if(ddsd.ddpfPixelFormat.dwFlags & DDPF_RGB)
361    {
362        struct RGBFormat
363        {
364                const char*  name;
365                UI32         bitCount;
366                UI32         rBitMask;
367                UI32         gBitMask;
368                UI32         bBitMask;
369                UI32         aBitMask;
370                unsigned int internalFormat;
371                unsigned int pixelFormat;
372                unsigned int dataType;
373        };
374
375        const unsigned int UNSUPPORTED = 0;
376
377        static const RGBFormat rgbFormats[] =           
378        {
379            { "R3G3B2"     ,  8,       0xe0,       0x1c,       0x03,       0x00,
380              GL_RGB , GL_RGB , GL_UNSIGNED_BYTE_3_3_2 },
381
382            { "R5G6B5"     , 16,     0xf800,     0x07e0,     0x001f,     0x0000,
383              GL_RGB , GL_RGB , GL_UNSIGNED_SHORT_5_6_5 },
384            { "A1R5G5B5"   , 16,     0x7c00,     0x03e0,     0x001f,     0x8000,
385              GL_RGBA, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV },
386            { "X1R5G5B5"   , 16,     0x7c00,     0x03e0,     0x001f,     0x0000,
387              GL_RGB , GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV },
388            { "A4R4G4B4"   , 16,     0x0f00,     0x00f0,     0x000f,     0xf000,
389              GL_RGBA, GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV },
390            { "X4R4G4B4"   , 16,     0x0f00,     0x00f0,     0x000f,     0x0000,
391              GL_RGB , GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV },
392            { "A8R3G3B2"   , 16,     0x00e0,     0x001c,     0x0003,     0xff00,
393              GL_RGBA, GL_BGRA, UNSUPPORTED },
394
395            { "R8G8B8",      24,   0xff0000,   0x00ff00,   0x0000ff,   0x000000,
396              GL_RGB , GL_BGR , GL_UNSIGNED_BYTE },
397
398            { "B8G8R8",      24,   0x0000ff,   0x00ff00,   0xff0000,   0x000000,
399              GL_RGB , GL_RGB , GL_UNSIGNED_BYTE },
400
401            { "A8R8G8B8",    32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000,
402              GL_RGBA, GL_BGRA, GL_UNSIGNED_BYTE },
403            { "X8R8G8B8",    32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000,
404              GL_RGB , GL_BGRA, GL_UNSIGNED_BYTE },
405            { "A8B8G8R8",    32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000,
406              GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE },
407            { "X8B8G8R8",    32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000,
408              GL_RGB , GL_RGBA, GL_UNSIGNED_BYTE },
409            { "A2R10G10B10", 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000,
410              GL_RGBA, GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV },
411            { "A2B10G10R10", 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000,
412              GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV },
413            { "G16R16",      32, 0x0000ffff, 0xffff0000, 0x00000000, 0x00000000,
414              GL_RGB, UNSUPPORTED, GL_UNSIGNED_SHORT },
415        };
416
417        bool found = false;
418
419        for ( unsigned int i = 0; i < sizeof ( rgbFormats ) / sizeof ( RGBFormat ); i++ )
420        {
421            const RGBFormat& f = rgbFormats[ i ];
422            if ( ddsd.ddpfPixelFormat.dwRGBBitCount     == f.bitCount &&
423                 ddsd.ddpfPixelFormat.dwRBitMask        == f.rBitMask &&
424                 ddsd.ddpfPixelFormat.dwGBitMask        == f.gBitMask &&
425                 ddsd.ddpfPixelFormat.dwBBitMask        == f.bBitMask &&
426                 ddsd.ddpfPixelFormat.dwRGBAlphaBitMask == f.aBitMask )
427            {
428                if ( f.internalFormat != UNSUPPORTED &&
429                     f.pixelFormat    != UNSUPPORTED &&
430                     f.dataType       != UNSUPPORTED )
431                {
432                    OSG_INFO << "ReadDDSFile info : format = " << f.name << std::endl;
433                    internalFormat = f.internalFormat;
434                    pixelFormat    = f.pixelFormat;
435                    dataType       = f.dataType;
436                    found = true;
437                    break;
438                }
439                else
440                {
441                    OSG_INFO << "ReadDDSFile info : " << f.name
442                                           << " format is not supported" << std::endl;
443                    return NULL;                   
444                }
445            }           
446        }
447
448        if ( !found )
449        {
450            OSG_WARN << "ReadDDSFile warning: unhandled RGB pixel format in dds file, image not loaded" << std::endl;
451            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwRGBBitCount     = "
452                                   << ddsd.ddpfPixelFormat.dwRGBBitCount << std::endl;
453            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwRBitMask        = 0x"
454                                   << std::hex << std::setw(8) << std::setfill('0')
455                                   << ddsd.ddpfPixelFormat.dwRBitMask << std::endl;
456            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwGBitMask        = 0x"
457                                   << std::hex << std::setw(8) << std::setfill('0')
458                                   << ddsd.ddpfPixelFormat.dwGBitMask << std::endl;
459            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwBBitMask        = 0x"
460                                   << std::hex << std::setw(8) << std::setfill('0')
461                                   << ddsd.ddpfPixelFormat.dwBBitMask << std::endl;
462            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0x"
463                                   << std::hex << std::setw(8) << std::setfill('0')
464                                   << ddsd.ddpfPixelFormat.dwRGBAlphaBitMask << std::dec << std::endl;
465            return NULL;
466        }
467    }
468    else if(ddsd.ddpfPixelFormat.dwFlags & DDPF_LUMINANCE)
469    {
470            internalFormat = usingAlpha ? GL_LUMINANCE_ALPHA : GL_LUMINANCE;
471            pixelFormat    = usingAlpha ? GL_LUMINANCE_ALPHA : GL_LUMINANCE;
472            if ( usingAlpha && ddsd.ddpfPixelFormat.dwLuminanceBitDepth == 8 )
473            {
474                OSG_INFO << "ReadDDSFile info : format = L4A4" << std::endl;
475                pixelFormat = GL_LUMINANCE4_ALPHA4; // invalid enumerant?
476            }
477            else if ( usingAlpha && ddsd.ddpfPixelFormat.dwLuminanceBitDepth == 32 )
478            {
479                OSG_INFO << "ReadDDSFile info : format = L16A16" << std::endl;
480                dataType = GL_UNSIGNED_SHORT;
481            }
482            else if ( !usingAlpha && ddsd.ddpfPixelFormat.dwLuminanceBitDepth == 16 )
483            {
484                OSG_INFO << "ReadDDSFile info : format = L16" << std::endl;
485                dataType = GL_UNSIGNED_SHORT;
486            }
487            else if ( usingAlpha )
488            {
489                OSG_INFO << "ReadDDSFile info : format = L8A8" << std::endl;
490            }
491            else
492            {
493                OSG_INFO << "ReadDDSFile info : format = L8" << std::endl;
494            }
495//             else if ( ddsd.ddpfPixelFormat.dwLuminanceBitDepth == (usingAlpha ? 64 : 32) )
496//             {
497//                 dataType = GL_UNSIGNED_INT;
498//             }
499    }
500    else if(ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHA)
501    {
502            OSG_INFO << "ReadDDSFile info : format = ALPHA" << std::endl;
503            internalFormat = GL_ALPHA;
504            pixelFormat    = GL_ALPHA;             
505    }
506    // Compressed formats
507    else if(ddsd.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
508    {
509        switch(ddsd.ddpfPixelFormat.dwFourCC)
510        {
511        case FOURCC_DXT1:
512            OSG_INFO << "ReadDDSFile info : format = DXT1, usingAlpha=" <<usingAlpha<< std::endl;
513            if (usingAlpha)
514            {
515                internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
516                pixelFormat    = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
517            }
518            else
519            {
520                internalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
521                pixelFormat    = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
522            }
523            break;
524        case FOURCC_DXT3:
525            OSG_INFO << "ReadDDSFile info : format = DXT3" << std::endl;
526            internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
527            pixelFormat    = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
528            break;
529        case FOURCC_DXT5:
530            OSG_INFO << "ReadDDSFile info : format = DXT5" << std::endl;
531            internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
532            pixelFormat    = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
533            break;
534        case FOURCC_ATI1:
535            OSG_INFO << "ReadDDSFile info : format = ATI1" << std::endl;
536            internalFormat = GL_COMPRESSED_RED_RGTC1_EXT;
537            pixelFormat    = GL_COMPRESSED_RED_RGTC1_EXT;
538            break;
539        case FOURCC_ATI2:
540            OSG_INFO << "ReadDDSFile info : format = ATI2" << std::endl;
541            internalFormat = GL_COMPRESSED_RED_GREEN_RGTC2_EXT;
542            pixelFormat    = GL_COMPRESSED_RED_GREEN_RGTC2_EXT;
543            break;       
544        case 0x00000024: // A16B16G16R16
545            OSG_INFO << "ReadDDSFile info : format = A16B16G16R16" << std::endl;
546            internalFormat = GL_RGBA;
547            pixelFormat    = GL_RGBA;
548            dataType       = GL_UNSIGNED_SHORT;
549            break;
550        case 0x00000071: // A16B16G16R16F
551            OSG_INFO << "ReadDDSFile info : format = A16B16G16R16F" << std::endl;
552            internalFormat = GL_RGBA; // why no transparency?
553            pixelFormat    = GL_RGBA;
554            dataType       = GL_HALF_FLOAT_NV;
555            break;
556        case 0x0000006E: // Q16W16V16U16
557            OSG_INFO << "ReadDDSFile info : format = Q16W16V16U16" << std::endl;
558            internalFormat = GL_RGBA;
559            pixelFormat    = GL_RGBA;
560            dataType       = GL_UNSIGNED_SHORT;
561            break;
562        case 0x00000070: // G16R16F
563            OSG_INFO << "ReadDDSFile info : G16R16F format is not supported"
564                                   << std::endl;
565            return NULL;
566//             internalFormat = GL_RGB;
567//             pixelFormat    = must be GL_RED and GL_GREEN
568//             dataType       = GL_HALF_FLOAT_NV;
569            break;
570        case 0x00000073: // G32R32F
571            OSG_INFO << "ReadDDSFile info : G32R32F format is not supported"
572                                   << std::endl;
573            return NULL;
574//             internalFormat = GL_RGB;
575//             pixelFormat    = must be GL_RED and GL_GREEN
576//             dataType       = GL_FLOAT;
577            break;
578        case 0x00000072: // R32F
579            OSG_INFO << "ReadDDSFile info : format = R32F" << std::endl;
580            internalFormat = GL_RGB;
581            pixelFormat    = GL_RED;
582            dataType       = GL_FLOAT;
583            break;
584        case 0x0000006F: // R16F
585            OSG_INFO << "ReadDDSFile info : format = R16F" << std::endl;
586            internalFormat = GL_RGB;
587            pixelFormat    = GL_RED;
588            dataType       = GL_HALF_FLOAT_NV;
589            break;
590        case 0x00000074: // A32B32G32R32F
591            OSG_INFO << "ReadDDSFile info : format = A32B32G32R32F" << std::endl;
592            internalFormat = GL_RGBA;
593            pixelFormat    = GL_RGBA;
594            dataType       = GL_FLOAT;
595            break;
596        case 0x00000075: // CxV8U8
597            OSG_INFO << "ReadDDSFile info : CxV8U8 format is not supported" << std::endl;
598            return NULL;
599
600        case MAKEFOURCC( 'U', 'Y', 'V', 'Y' ): // not supported in OSG
601        case MAKEFOURCC( 'U', 'Y', 'V', '2' ): // not supported in OSG
602        case MAKEFOURCC( 'R', 'G', 'B', 'G' ): // R8G8_B8G8 -- what is it?
603        case MAKEFOURCC( 'G', 'R', 'G', 'B' ): // G8R8_G8B8 -- what is it?
604            //break;
605
606        default:
607            OSG_WARN << "ReadDDSFile warning: unhandled FOURCC pixel format ("
608                                   << (char)((ddsd.ddpfPixelFormat.dwFourCC & 0x000000ff))
609                                   << (char)((ddsd.ddpfPixelFormat.dwFourCC & 0x0000ff00) >> 8)
610                                   << (char)((ddsd.ddpfPixelFormat.dwFourCC & 0x00ff0000) >> 16)
611                                   << (char)((ddsd.ddpfPixelFormat.dwFourCC & 0xff000000) >> 24)
612                                   << " = 0x" << std::hex << std::setw(8) << std::setfill('0')
613                                   << ddsd.ddpfPixelFormat.dwFourCC << std::dec
614                                   << ") in dds file, image not loaded." << std::endl;
615            return NULL;
616        }
617    }
618    else 
619    {
620        OSG_WARN << "ReadDDSFile warning: unhandled pixel format (ddsd.ddpfPixelFormat.dwFlags"
621                               << " = 0x" << std::hex << std::setw(8) << std::setfill('0')
622                               << ddsd.ddpfPixelFormat.dwFlags << std::dec
623                               << ") in dds file, image not loaded."<<std::endl;
624        return NULL;
625    }
626
627    unsigned int size = ComputeImageSizeInBytes( s, t, r, pixelFormat, dataType );
628
629    // Take care of mipmaps if any.
630    unsigned int sizeWithMipmaps = size;
631    osg::Image::MipmapDataType mipmap_offsets;
632    if ( ddsd.dwMipMapCount>1 )
633    {       
634        unsigned numMipmaps = osg::Image::computeNumberOfMipmapLevels( s, t, r );
635        if( numMipmaps > ddsd.dwMipMapCount ) numMipmaps = ddsd.dwMipMapCount;
636        // array starts at 1 level offset, 0 level skipped
637        mipmap_offsets.resize( numMipmaps - 1 );
638
639        int width = s;
640        int height = t;
641        int depth = r;
642
643        for( unsigned int k = 0; k < mipmap_offsets.size(); ++k  )
644        {
645           mipmap_offsets[k] = sizeWithMipmaps;
646
647           width = osg::maximum( width >> 1, 1 );
648           height = osg::maximum( height >> 1, 1 );
649           depth = osg::maximum( depth >> 1, 1 );
650
651           sizeWithMipmaps +=
652                ComputeImageSizeInBytes( width, height, depth, pixelFormat, dataType );
653        }
654    }
655     
656    unsigned char* imageData = new unsigned char [sizeWithMipmaps];
657    if(!imageData)
658    {
659        OSG_WARN << "ReadDDSFile warning: imageData == NULL" << std::endl;
660        return NULL;
661    }
662   
663    // Read pixels in two chunks. First main image, next mipmaps.
664    if ( !_istream.read( (char*)imageData, size ) )
665    {
666        delete [] imageData;
667        OSG_WARN << "ReadDDSFile warning: couldn't read imageData" << std::endl;
668        return NULL;
669    }
670
671    // If loading mipmaps in second chunk fails we may still use main image
672    if ( size < sizeWithMipmaps && !_istream.read( (char*)imageData + size, sizeWithMipmaps - size ) )
673    {
674        sizeWithMipmaps = size;
675        mipmap_offsets.resize( 0 );
676        OSG_WARN << "ReadDDSFile warning: couldn't read mipmapData" << std::endl;
677
678        // if mipmaps read failed we leave some not used overhead memory allocated past main image
679        // this memory will not be used but it will not cause leak in worst meaning of this word.
680    }
681
682    osgImage->setImage(s,t,r, internalFormat, pixelFormat, dataType, imageData, osg::Image::USE_NEW_DELETE);
683
684    if (mipmap_offsets.size()>0) osgImage->setMipmapLevels(mipmap_offsets);
685
686    // Return Image.
687    return osgImage.release();
688}
689
690bool WriteDDSFile(const osg::Image *img, std::ostream& fout)
691{
692
693    // Initialize ddsd structure and its members
694    DDSURFACEDESC2 ddsd;
695    memset( &ddsd, 0, sizeof( ddsd ) );
696    DDPIXELFORMAT  ddpf;
697    memset( &ddpf, 0, sizeof( ddpf ) );
698    //DDCOLORKEY     ddckCKDestOverlay;
699    //DDCOLORKEY     ddckCKDestBlt;
700    //DDCOLORKEY     ddckCKSrcOverlay;
701    //DDCOLORKEY     ddckCKSrcBlt;
702    DDSCAPS2       ddsCaps;
703    memset( &ddsCaps, 0, sizeof( ddsCaps ) );
704
705    ddsd.dwSize = sizeof(ddsd); 
706    ddpf.dwSize = sizeof(ddpf);
707
708    // Default values and initialization of structures' flags
709    unsigned int SD_flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
710    unsigned int CAPS_flags  = DDSCAPS_TEXTURE;
711    unsigned int PF_flags = 0;
712    unsigned int CAPS2_flags = 0;
713
714    // Get image properties
715    unsigned int dataType       = img->getDataType();
716    unsigned int pixelFormat    = img->getPixelFormat();
717    //unsigned int internalFormat = img->getInternalTextureFormat();
718    //unsigned int components     = osg::Image::computeNumComponents(pixelFormat);
719    unsigned int pixelSize      = osg::Image::computePixelSizeInBits(pixelFormat, dataType);
720    unsigned int imageSize      = img->getImageSizeInBytes();
721    bool is3dImage = false;
722
723    ddsd.dwWidth  = img->s();
724    ddsd.dwHeight = img->t();
725    int r = img->r();
726
727    if(r > 1)  /* check for 3d image */
728    {
729        is3dImage = true;
730        ddsd.dwDepth = r;
731        SD_flags    |= DDSD_DEPTH;
732        CAPS_flags  |= DDSCAPS_COMPLEX;
733        CAPS2_flags |= DDSCAPS2_VOLUME;
734    }
735
736    // Determine format - set flags and ddsd, ddpf properties
737    switch (pixelFormat)
738    {
739        //Uncompressed
740    case GL_RGBA:
741        {
742            ddpf.dwRBitMask        = 0x000000ff;
743            ddpf.dwGBitMask        = 0x0000ff00;
744            ddpf.dwBBitMask        = 0x00ff0000; 
745            ddpf.dwRGBAlphaBitMask = 0xff000000;
746            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_RGB);
747            ddpf.dwRGBBitCount = pixelSize;
748            ddsd.lPitch = img->getRowSizeInBytes();
749            SD_flags |= DDSD_PITCH;
750        }
751        break;
752    case GL_BGRA:
753        {
754            ddpf.dwBBitMask        = 0x000000ff;
755            ddpf.dwGBitMask        = 0x0000ff00;
756            ddpf.dwRBitMask        = 0x00ff0000; 
757            ddpf.dwRGBAlphaBitMask = 0xff000000;
758            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_RGB);
759            ddpf.dwRGBBitCount = pixelSize;
760            ddsd.lPitch = img->getRowSizeInBytes();
761            SD_flags |= DDSD_PITCH;
762        }
763        break;
764    case GL_LUMINANCE_ALPHA:
765        {
766            ddpf.dwRBitMask         = 0x000000ff;
767            ddpf.dwRGBAlphaBitMask  = 0x0000ff00;
768            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_LUMINANCE); 
769            ddpf.dwRGBBitCount = pixelSize;
770            ddsd.lPitch = img->getRowSizeInBytes();
771            SD_flags |= DDSD_PITCH;
772        }
773        break;
774    case GL_RGB:
775        {
776            ddpf.dwRBitMask        = 0x000000ff;
777            ddpf.dwGBitMask        = 0x0000ff00;
778            ddpf.dwBBitMask        = 0x00ff0000; 
779            PF_flags |= DDPF_RGB;
780            ddpf.dwRGBBitCount = pixelSize;
781            ddsd.lPitch = img->getRowSizeInBytes();
782            SD_flags |= DDSD_PITCH;
783        }
784        break;
785    case GL_BGR:
786        {
787            ddpf.dwBBitMask        = 0x000000ff;
788            ddpf.dwGBitMask        = 0x0000ff00;
789            ddpf.dwRBitMask        = 0x00ff0000; 
790            PF_flags |= DDPF_RGB;
791            ddpf.dwRGBBitCount = pixelSize;
792            ddsd.lPitch = img->getRowSizeInBytes();
793            SD_flags |= DDSD_PITCH;
794        }
795        break;
796    case GL_LUMINANCE:
797        {
798            ddpf.dwRBitMask         = 0x000000ff;
799            PF_flags |= DDPF_LUMINANCE;
800            ddpf.dwRGBBitCount = pixelSize;
801            ddsd.lPitch = img->getRowSizeInBytes();
802            SD_flags |= DDSD_PITCH;
803        }
804        break;
805    case GL_ALPHA:
806        {
807            ddpf.dwRGBAlphaBitMask  = 0x000000ff;
808            PF_flags |= DDPF_ALPHA;
809            ddpf.dwRGBBitCount = pixelSize;
810            ddsd.lPitch = img->getRowSizeInBytes();
811            SD_flags |= DDSD_PITCH;
812        }
813        break;
814
815        //Compressed
816    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
817        {
818            ddpf.dwFourCC = FOURCC_DXT1;
819            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_FOURCC);
820            ddsd.dwLinearSize = imageSize;
821            SD_flags |= DDSD_LINEARSIZE;
822        }
823        break;
824    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
825        {
826            ddpf.dwFourCC = FOURCC_DXT3;
827            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_FOURCC);
828            ddsd.dwLinearSize = imageSize;
829            SD_flags |= DDSD_LINEARSIZE;
830        }
831        break;
832    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
833        {
834            ddpf.dwFourCC = FOURCC_DXT5;
835            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_FOURCC);
836            ddsd.dwLinearSize = imageSize;
837            SD_flags |= DDSD_LINEARSIZE;
838        }
839        break;
840    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
841        {
842            ddpf.dwFourCC = FOURCC_DXT1;
843            PF_flags |= DDPF_FOURCC;  /* No alpha here */
844            ddsd.dwLinearSize = imageSize;
845            SD_flags |= DDSD_LINEARSIZE;
846        }
847        break;
848    case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
849        {
850            ddpf.dwFourCC = FOURCC_ATI1;
851            PF_flags |= DDPF_FOURCC;  /* No alpha here */
852            ddsd.dwLinearSize = imageSize;
853            SD_flags |= DDSD_LINEARSIZE;
854        }
855        break;
856    case GL_COMPRESSED_RED_RGTC1_EXT:
857        {
858            ddpf.dwFourCC = FOURCC_ATI1;
859            PF_flags |= DDPF_FOURCC;  /* No alpha here */
860            ddsd.dwLinearSize = imageSize;
861            SD_flags |= DDSD_LINEARSIZE;
862        }
863        break;   
864    case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
865        {
866            ddpf.dwFourCC = FOURCC_ATI2;
867            PF_flags |= DDPF_FOURCC;  /* No alpha here */
868            ddsd.dwLinearSize = imageSize;
869            SD_flags |= DDSD_LINEARSIZE;
870        }
871        break;   
872    case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
873        {
874            ddpf.dwFourCC = FOURCC_ATI2;
875            PF_flags |= DDPF_FOURCC;  /* No alpha here */
876            ddsd.dwLinearSize = imageSize;
877            SD_flags |= DDSD_LINEARSIZE;
878        }
879        break;   
880    default:
881        OSG_WARN<<"Warning:: unhandled pixel format in image, file cannot be written."<<std::endl;
882        return false;
883    }
884
885    int size = img->getTotalSizeInBytes();
886
887    // set even more flags
888    if( !img->isMipmap() ) {
889
890       OSG_INFO<<"no mipmaps to write out."<<std::endl;
891
892    } else if( img->getPacking() > 1 ) {
893
894       OSG_WARN<<"Warning: mipmaps not written. DDS requires packing == 1."<<std::endl;
895
896    } else { // image contains mipmaps and has 1 byte alignment
897
898        SD_flags   |= DDSD_MIPMAPCOUNT;
899        CAPS_flags |= DDSCAPS_COMPLEX | DDSCAPS_MIPMAP;
900       
901        ddsd.dwMipMapCount = img->getNumMipmapLevels();
902
903        size = img->getTotalSizeInBytesIncludingMipmaps();
904
905        OSG_INFO<<"writing out with mipmaps ddsd.dwMipMapCount"<<ddsd.dwMipMapCount<<std::endl;
906    }
907
908    // Assign flags and structure members of ddsd
909    ddsd.dwFlags    = SD_flags;
910    ddpf.dwFlags    = PF_flags;
911    ddsCaps.dwCaps  = CAPS_flags;
912    ddsCaps.dwCaps2 = CAPS2_flags;
913
914    ddsd.ddpfPixelFormat = ddpf;
915    ddsd.ddsCaps = ddsCaps;
916
917    // Write DDS file
918    fout.write("DDS ", 4); /* write FOURCC */
919    fout.write(reinterpret_cast<char*>(&ddsd), sizeof(ddsd)); /* write file header */
920    fout.write(reinterpret_cast<const char*>(img->data()), size );
921
922    // Check for correct saving
923    if ( fout.fail() )
924        return false;
925
926    // If we get that far the file was saved properly //
927    return true;
928}
929
930
931class ReaderWriterDDS : public osgDB::ReaderWriter
932{
933public:
934
935    ReaderWriterDDS()
936    {
937        supportsExtension("dds","DDS image format");
938        supportsOption("dds_dxt1_rgb","Set the pixel format of DXT1 encoded images to be RGB variant of DXT1");
939        supportsOption("dds_dxt1_rgba","Set the pixel format of DXT1 encoded images to be RGBA variant of DXT1");
940        supportsOption("dds_dxt1_detect_rgba","For DXT1 encode images set the pixel format according to presence of transparent pixels");
941        supportsOption("dds_flip","Flip the image about the horizontl axis");
942    }
943
944    virtual const char* className() const
945    {
946        return "DDS Image Reader/Writer";
947    }
948
949    virtual ReadResult readObject(const std::string& file, const osgDB::ReaderWriter::Options* options) const
950    {
951        return readImage(file,options);
952    }
953
954    virtual ReadResult readObject(std::istream& fin, const Options* options) const
955    {
956        return readImage(fin,options);
957    }
958
959    virtual ReadResult readImage(const std::string& file, const osgDB::ReaderWriter::Options* options) const
960    {
961        std::string ext = osgDB::getLowerCaseFileExtension(file);
962        if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;
963
964        std::string fileName = osgDB::findDataFile( file, options );
965   
966        if (fileName.empty()) return ReadResult::FILE_NOT_FOUND;
967       
968        osgDB::ifstream stream(fileName.c_str(), std::ios::in | std::ios::binary);
969        if(!stream) return ReadResult::FILE_NOT_HANDLED;
970        ReadResult rr = readImage(stream, options);
971        if(rr.validImage()) rr.getImage()->setFileName(file);
972        return rr;
973    }
974
975    virtual ReadResult readImage(std::istream& fin, const Options* options) const
976    {
977        osg::Image* osgImage = ReadDDSFile(fin);
978        if (osgImage==NULL) return ReadResult::FILE_NOT_HANDLED;
979
980        if (osgImage->getPixelFormat()==GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
981            osgImage->getPixelFormat()==GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
982        {
983            if (options && options->getOptionString().find("dds_dxt1_rgba")!=std::string::npos)
984            {
985                osgImage->setPixelFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
986                osgImage->setInternalTextureFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
987            }
988            else if (options && options->getOptionString().find("dds_dxt1_rgb")!=std::string::npos)
989            {
990                osgImage->setPixelFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
991                osgImage->setInternalTextureFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
992            }
993            else if (options && options->getOptionString().find("dds_dxt1_detect_rgba")!=std::string::npos)
994            {
995                // check to see if DXT1c (RGB_S3TC_DXT1) format image might actually be
996                // a DXT1a format image
997
998                // temporarily set pixel format to GL_COMPRESSED_RGBA_S3TC_DXT1_EXT so
999                // that the isImageTranslucent() method assumes that RGBA is present and then
1000                // checks the alpha values to see if they are all 1.0.
1001                osgImage->setPixelFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
1002                osgImage->setInternalTextureFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
1003                if (!osgImage->isImageTranslucent())
1004                {
1005                    // image contains alpha's that are 1.0, so treat is as RGB
1006                    OSG_INFO<<"Image with PixelFormat==GL_COMPRESSED_RGB_S3TC_DXT1_EXT is opaque."<<std::endl;
1007                    osgImage->setPixelFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
1008                    osgImage->setInternalTextureFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
1009                }
1010                else
1011                {
1012                    // image contains alpha's that are non 1.0, so treat is as RGBA
1013                    OSG_INFO<<"Image with PixelFormat==GL_COMPRESSED_RGB_S3TC_DXT1_EXT has transparency, setting format to GL_COMPRESSED_RGBA_S3TC_DXT1_EXT."<<std::endl;
1014                }
1015            }
1016        }
1017
1018        if (options && options->getOptionString().find("dds_flip")!=std::string::npos)
1019        {
1020            osgImage->flipVertical();
1021        }
1022       
1023        return osgImage;
1024    }
1025
1026    virtual WriteResult writeObject(const osg::Object& object,const std::string& file, const osgDB::ReaderWriter::Options* options) const
1027    {
1028        const osg::Image* image = dynamic_cast<const osg::Image*>(&object);
1029        if (!image) return WriteResult::FILE_NOT_HANDLED;
1030
1031        return writeImage(*image,file,options);
1032    }
1033
1034    virtual WriteResult writeObject(const osg::Object& object,std::ostream& fout,const Options* options) const
1035    {
1036        const osg::Image* image = dynamic_cast<const osg::Image*>(&object);
1037        if (!image) return WriteResult::FILE_NOT_HANDLED;
1038
1039        return writeImage(*image,fout,options);
1040    }
1041
1042
1043    virtual WriteResult writeImage(const osg::Image &image,const std::string& file, const osgDB::ReaderWriter::Options* options) const
1044    {
1045        std::string ext = osgDB::getFileExtension(file);
1046        if (!acceptsExtension(ext)) return WriteResult::FILE_NOT_HANDLED;
1047
1048        osgDB::ofstream fout(file.c_str(), std::ios::out | std::ios::binary);
1049        if(!fout) return WriteResult::ERROR_IN_WRITING_FILE;
1050
1051        return writeImage(image,fout,options);
1052    }
1053
1054    virtual WriteResult writeImage(const osg::Image& image,std::ostream& fout,const Options*) const
1055    {
1056        bool success = WriteDDSFile(&image, fout);
1057
1058        if(success)
1059            return WriteResult::FILE_SAVED;
1060        else
1061            return WriteResult::ERROR_IN_WRITING_FILE;
1062    }
1063};
1064
1065// now register with Registry to instantiate the above
1066// reader/writer.
1067REGISTER_OSGPLUGIN(dds, ReaderWriterDDS)
Note: See TracBrowser for help on using the browser.