- Main Page
- Related Pages
- Modules
- Classes
- Examples

# ddsFloatReader.cpp

    //-
    // ==========================================================================
    // Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
    //
    // Use of this software is subject to the terms of the Autodesk
    // license agreement provided at the time of installation or download,
    // or which otherwise accompanies this software in either electronic
    // or hard copy form.
    // ==========================================================================
    //+

    // DESCRIPTION:
    //
    //  Example DDS floating point image reader plugin.
    //

    #include <maya/MPxImageFile.h>
    #include <maya/MImageFileInfo.h>
    #include <maya/MImage.h>
    #include <maya/MFnPlugin.h>
    #include <maya/MStringArray.h>
    #include <maya/MIOStream.h>

    #if _WIN32
    #pragma warning( disable : 4290 )       // Disable STL warnings.
    #endif

    #include "ddsFloatReader.h"
    #include <math.h>

    using namespace dds_Float_Reader;
    MString kImageFormatName( "DDS Float");

    class ddsFloatReader : public MPxImageFile
    {
    public:
                        ddsFloatReader();
        virtual         ~ddsFloatReader();
        static void*    creator();
        virtual MStatus open( MString pathname, MImageFileInfo* info);
        virtual MStatus load( MImage& image, unsigned int idx);
        virtual MStatus close();

    protected:
        // Data members
        unsigned int        fWidth;
        unsigned int        fHeight;
        unsigned int        fNumChannels;
        unsigned int        fBytesPerPixel;

        // File and header description
        FILE                *fInputFile;
        DDS_HEADER          fHeader;
    };

    //
    // DESCRIPTION:
    ddsFloatReader::ddsFloatReader()
    :   fWidth(0),
        fHeight(0),
        fNumChannels(0),
        fBytesPerPixel(0),
        fInputFile(NULL)
    {
    }

    //
    // DESCRIPTION:
    ddsFloatReader::~ddsFloatReader()
    {
        close();
    }

    //
    // DESCRIPTION:
    /* virtual */
    MStatus  ddsFloatReader::close()
    {
        fWidth = 0;
        fHeight = 0;
        fNumChannels = 0;
        fBytesPerPixel = 0;

        // Close our file
        if (fInputFile != NULL)
            fclose(fInputFile);
        fInputFile = NULL;

        return MS::kSuccess;
    }

    //
    // DESCRIPTION:
    void * ddsFloatReader::creator()
    {
        return new ddsFloatReader();
    }

    // Need to swap byte order on Mac
    //
    inline void swap_endian(void *val)
    {
    #if defined(OSMac_)
        unsigned int *ival = (unsigned int *)val;

        *ival = ((*ival >> 24) & 0x000000ff) |
                ((*ival >>  8) & 0x0000ff00) |
                ((*ival <<  8) & 0x00ff0000) |
                ((*ival << 24) & 0xff000000);

    #endif
    }

    inline void swap_endian_half(void *val)
    {
    #if defined(OSMac_)
        unsigned short *ival = (unsigned short *)val;

        *ival = ((*ival >> 8) & 255) |
                ((*ival << 8) & 65280);

    #endif
    }

    const double two_pow_neg14 = pow(2.0, -14.0);

    //
    // Half to float conversion
    //
    inline float halfToFloat(unsigned short val)
    {
        float outValue = 0.0f;

    #if defined(OSMac_)
        // Need to swap bytes on Power PC (Mac)
        swap_endian_half( &val );
    #endif

        // Convert 16-value into a float...
        double h_mantissa = (float) (val & 1023); // Mantissa = low order 10  bits
        double h_exponent = (float)  ((val >> 10) & 31); // Exponent = next 5 bits
        unsigned int i_sign = (val >> 15) & 1;  ; // Sign is the highest bit
        double h_sign = (i_sign == 0) ? 1.0 : -1.0;

        if (h_exponent != 30.0)
        {
            outValue = (float) (h_sign * pow(2.0, h_exponent-15.0) * ( 1.0 + ( h_mantissa / 1024.0 )));
        }
        else
        {
            outValue = (float) ( h_sign * pow(2.0, two_pow_neg14) * ( h_mantissa / 1024.0 ) );
        }
        //printf("[%d][%d] = inValue=%d, isign =%d, sign=%g, exp=%g, mant=%g, value=%g\n", y,x, *inPtr, i_sign, h_sign, h_exponent, h_mantissa, outValue);
        return outValue;
    }

    //
    // DESCRIPTION:
    MStatus ddsFloatReader::open( MString filename, MImageFileInfo* info)
    {
    #if _WIN32
        if ( ( fInputFile = fopen( filename.asChar(), "rb" ) ) == NULL )
    #else
        if ( ( fInputFile = fopen( filename.asChar(), "r" ) ) == NULL )
    #endif
        {
            // Unable to open the file
            return MS::kFailure;
        }

        // Read the DDS header in
        //
        if ( fread( &fHeader, 1, sizeof(DDS_HEADER), fInputFile) == sizeof(DDS_HEADER) )
        {
            swap_endian(&fHeader.fCapabilities.dwCaps2);

            // Cube maps and volume textures are not supported currently.
            //
            if (( (fHeader.fCapabilities.dwCaps2) & DDSCAPS2_CUBEMAP_FLAG ) ||
                ( (fHeader.fCapabilities.dwCaps2) & DDSCAPS2_VOLUME_FLAG ))
            {
                close();
                return MS::kFailure;
            }

            // Get dimensions of image
            //
            swap_endian(&fHeader.fWidth);
            swap_endian(&fHeader.fHeight);
            fWidth = fHeader.fWidth;
            fHeight = fHeader.fHeight;
            fNumChannels = 0;

            if (fWidth==0 || fHeight==0)
            {
                close();
                return MS::kFailure;
            }

            // Check for float formats
            //
            swap_endian(& fHeader.fFormat.fFlags );
            if (fHeader.fFormat.fFlags & DDS_FOURCC_FLAG)
            {
                swap_endian(&fHeader.fFormat.fPixelFormat);

                bool supportedFormat = true;

                // Half float formats
                switch (fHeader.fFormat.fPixelFormat)
                {

                // Half float formats
                //
                case DDS_R16F:
                    fNumChannels = 1;
                    fBytesPerPixel = 2; // 16-bits
                    break;
                case DDS_G16R16F:
                    fNumChannels = 2;
                    fBytesPerPixel = 4; // 32-bits
                    break;
                case DDS_A16B16G16R16F:
                    fNumChannels = 4;
                    fBytesPerPixel = 8; // 64-bits
                    break;

                // IEEE 32 bit formats
                case DDS_R32F:
                    fNumChannels = 1;
                    fBytesPerPixel = 4; // 32-bits
                    break;
                case DDS_G32R32F:
                    fNumChannels = 2;
                    fBytesPerPixel = 8; // 64-bits
                    break;
                case DDS_A32B32G32R32F:
                    fNumChannels = 4;
                    fBytesPerPixel = 16; // 128-bits
                    break;

                // Anything else is not supported
                default:
                    supportedFormat = false;
                    break;
                }

                if (!supportedFormat)
                {
                    close();
                    return MS::kFailure;
                }
            }
            else
            {
                close();
                return MS::kFailure;
            }

            // Return image information based on the header
            //
            if (info)
            {
                //printf("** Opened DDS: %s (w=%d,h=%d, fmt=%d)\n",
                //  filename.asChar(),
                //  fWidth,
                //  fHeight,
                //  fHeader.fFormat.fPixelFormat);

                // Only read in 1 image for now
                info->numberOfImages( 1 );
                info->width( fWidth );
                info->height( fHeight );
                info->channels( fNumChannels );
                info->hasAlpha( fNumChannels == 4 );

                // Mip maps not handled for now
                info->hasMipMaps( false );

                info->imageType( MImageFileInfo::kImageTypeColor );
                info->hardwareType( MImageFileInfo::kHwTexture2D );
                info->pixelType( MImage::kFloat );
            }
        }
        return MS::kSuccess;
    }

    //
    // DESCRIPTION:
    MStatus ddsFloatReader::load( MImage& image, unsigned int imageNumber)
    {
        MStatus loaded = MS::kFailure;

        // Check for half type, since we need to perform
        // some special bit conversions to get a float back.
        //
        bool isHalfType = false;
        switch (fHeader.fFormat.fPixelFormat)
        {
        case DDS_R16F:
            isHalfType = true;
            break;
        case DDS_G16R16F:
            isHalfType = true;
            break;
        case DDS_A16B16G16R16F:
            isHalfType = true;
            break;
        default:
            break;
        }

        // Create the output buffer
        //
        image.create( fWidth, fHeight, fNumChannels, MImage::kFloat);
        float* outputBuffer = image.floatPixels();

        // Create the input buffer to read one scanline at a time.
        //
        float *inputFloatBuffer = NULL;         // For IEEE float
        unsigned short *inputIntBuffer = NULL;  // For half-float = 16-bits per channel
        if (!isHalfType)
        {
            inputFloatBuffer = new float[fWidth * fNumChannels];
        }
        else
            inputIntBuffer= new unsigned short[fWidth * fNumChannels];

        // Can't get sufficient memory so fail and close up the
        // file.
        if ((!inputFloatBuffer && !inputIntBuffer) || !outputBuffer)
        {
            if (inputFloatBuffer)
            {
                delete [] inputFloatBuffer;
                inputFloatBuffer = NULL;
            }
            if (inputIntBuffer)
            {
                delete [] inputIntBuffer;
                inputIntBuffer = NULL;
            }
            close();
            return MS::kFailure;
        }

        // Transfer to output buffer.
        //
        if (isHalfType)
        {
            unsigned int x,y;
            float *outPtr = outputBuffer;

            // Do a scanline at a time. From top-to-bottom
            // so that scan lines are flipped for Maya's usage.
            //
            outPtr += (fHeight-1) * (fWidth * fNumChannels);

            for (y=0; y<fHeight; y++)
            {
                // Read in one scan line of data
                unsigned int numBytes = fWidth * fBytesPerPixel;
                fread( inputIntBuffer, 1, numBytes, fInputFile);

                unsigned short *inPtr = inputIntBuffer;

                for (x=0; x<fWidth * fNumChannels; x++)
                {
                    float outValue = halfToFloat(*inPtr);
                    *(outPtr + x) = outValue;
                    inPtr++; // Jump 2 bytes at a time = 1 channel
                }
                outPtr -= (fWidth * fNumChannels);
            }
            loaded = MS::kSuccess;
        }

        // IEEE 32-bit float
        else
        {
            unsigned int x,y;
            float *outPtr = outputBuffer;

            // Do a scanline at a time. From top-to-bottom
            // so that scan lines are flipped for Maya's usage.
            //
            outPtr += (fHeight-1) * (fWidth * fNumChannels);

            for (y=0; y<fHeight; y++)
            {
                // Read in one scan line of data
                unsigned int numBytes = fWidth * fBytesPerPixel;
                fread( inputFloatBuffer, 1, numBytes, fInputFile);

    #if defined(OSMac_)
                // Need to swap bytes on Power PC (Mac)
                unsigned int *bPtr = (unsigned int *)inputFloatBuffer;
                unsigned int b;
                for (b=0; b<numBytes / 4; b++)
                {
                    swap_endian( bPtr );
                    bPtr++;
                }
    #endif
                float *inPtr = inputFloatBuffer;
                for (x=0; x<fWidth * fNumChannels; x++)
                {
                    *(outPtr + x) = *inPtr;
                    inPtr++;
                }
                outPtr -= (fWidth * fNumChannels);
            }
            loaded = MS::kSuccess;
        }

        // Cleanup memory and close the file
        if (inputFloatBuffer)
        {
            delete [] inputFloatBuffer;
            inputFloatBuffer = NULL;
        }
        if (inputIntBuffer)
        {
            delete [] inputFloatBuffer;
            inputFloatBuffer = NULL;
        }
        close();

        return loaded;
    }

    MStatus initializePlugin( MObject obj )
    {
        MFnPlugin plugin( obj, PLUGIN_COMPANY, "8.0", "Any" );
        MStringArray extensions;
        extensions.append( "dds");
        CHECK_MSTATUS( plugin.registerImageFile(
                        kImageFormatName,
                        ddsFloatReader::creator,
                        extensions));

        return MS::kSuccess;
    }

    // DESCRIPTION:
    MStatus uninitializePlugin( MObject obj )
    {
        MFnPlugin plugin( obj );
        CHECK_MSTATUS( plugin.deregisterImageFile( kImageFormatName ) );

        return MS::kSuccess;
    }