///////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas

// Digital Ltd. LLC

// 

// All rights reserved.

// 

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

// *       Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// *       Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// *       Neither the name of Industrial Light & Magic nor the names of

// its contributors may be used to endorse or promote products derived

// from this software without specific prior written permission. 

// 

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

///////////////////////////////////////////////////////////////////////////

#include <ImfOutputFile.h>

#include <ImfInputFile.h>

#include <ImfChannelList.h>

#include <ImfArray.h>

#include <ImfVersion.h>

#include "half.h"

#include <ImfBoxAttribute.h>

#include <ImfChannelListAttribute.h>

#include <ImfCompressionAttribute.h>

#include <ImfChromaticitiesAttribute.h>

#include <ImfFloatAttribute.h>

#include <ImfEnvmapAttribute.h>

#include <ImfDoubleAttribute.h>

#include <ImfIntAttribute.h>

#include <ImfLineOrderAttribute.h>

#include <ImfMatrixAttribute.h>

#include <ImfOpaqueAttribute.h>

#include <ImfStringAttribute.h>

#include <ImfStringVectorAttribute.h>

#include <ImfVecAttribute.h>

#include <stdio.h>

#include <assert.h>

#include <string.h>

using namespace std;

namespace IMF = OPENEXR_IMF_NAMESPACE;

using namespace IMF;

namespace IMATH = IMATH_NAMESPACE;

using namespace IMATH;

namespace

{

static const int IMAGE_2K_HEIGHT = 1152;

static const int IMAGE_2K_WIDTH = 2048;

static const char* CHANNEL_NAMES[] = {"R", "G", "B", "A"};

static const char* CHANNEL_NAMES_LEFT[] = {"left.R", "left.G", "left.B", "left.A"};

static const half ALPHA_DEFAULT_VALUE(1.0f);

#define RGB_FILENAME "imf_optimized_aces_rgb.exr"

#define RGBA_FILENAME "imf_optimized_aces_rgba.exr"

#define RGB_STEREO_FILENAME "imf_optimized_aces_rgb_stereo.exr"

#define RGBA_STEREO_FILENAME "imf_optimized_aces_rgba_stereo.exr"

typedef enum EImageType

{

    IMAGE_TYPE_RGB         = 1,

    IMAGE_TYPE_RGBA        = 2,

    IMAGE_TYPE_OTHER        =3

} EImageType;

int

getNbChannels(EImageType pImageType)

{

    int retVal = 0;

    switch(pImageType)

    {

        case IMAGE_TYPE_RGB:

            retVal = 3;

            break;

        case IMAGE_TYPE_RGBA:

            retVal = 4;

            break;

        case IMAGE_TYPE_OTHER:

            retVal = 2;

            break;

        default:

            retVal = 0;

            break;

    }

    return retVal;

}

//

//

//

void

generatePixel (int i, int j, half* rgbaValue, bool pIsLeft)

{

    float redValue = 0.0f;

    float greenValue = 0.0f;

    float blueValue = 0.0f;

    float alphaValue = 0.0f;

    // These formulas are arbitrary but generate results that vary

    // depending on pixel position.  They are used to validate that

    // pixels are read/written correctly, because if we had only one

    // value for the whole image, the tests would still pass if we read

    // only one pixel and copied it all across the buffer.

    if(pIsLeft)

    {

        redValue = ((i + j) % 10 + 0.004f * j) / 10.0f;

        greenValue = ((j + j) % 10 + 0.006f * i) / 10.0f;

        blueValue = ((j * j + i) % 10 + 0.003f * j) / 10.0f;

        alphaValue = ALPHA_DEFAULT_VALUE;

    }

    else

    {

        redValue = ((i * j) % 10 + 0.005f * j) / 10.0f;

        greenValue = ((i + i) % 10 + 0.007f * i) / 10.0f;

        blueValue = ((i * i + j) % 10 + 0.006f * j) / 10.0f;

        alphaValue = ALPHA_DEFAULT_VALUE;

    }

    rgbaValue[0] = redValue;

    rgbaValue[1] = greenValue;

    rgbaValue[2] = blueValue;

    rgbaValue[3] = alphaValue;

}

//

// Given a buffer, fill the pixels with arbitrary but deterministic values.

// Used to fill the pixels in a buffer before writing them to a file.

//

void

fillPixels (const int& pImageHeight,

            const int& pImageWidth,

            Array2D<half>& pPixels,

            int pNbChannels,

            bool pIsLeft)

{

    for(int i = 0; i < pImageHeight; ++i)

    {

        for(int j = 0; j < pImageWidth; ++j)

        {

            half rgbaValue[4];

            generatePixel(i, j, &rgbaValue[0], pIsLeft);

            memcpy( (void*)&pPixels[i][j * pNbChannels],

                    &rgbaValue[0],

                    pNbChannels * sizeof(half));

        }

    }

}

//

// Validate that the pixels value are the same as what we used to fill them.

// Used after reading the pixels from the file to validate that it was read

// properly.

//

void

validatePixels (const int& pImageHeight,

                const int& pImageWidth,

                Array2D<half>& pPixels,

                int pNbChannels,

                bool pIsLeft)

{

    for(int i = 0; i < pImageHeight; ++i)

    {

        for(int j = 0; j < pImageWidth; ++j)

        {

            int retVal = -1;

            half rgbaValue[4];

            generatePixel(i, j, &rgbaValue[0], pIsLeft);

            retVal = memcmp ((void*)&pPixels[i][j * pNbChannels],

                             (void*)&rgbaValue[0],

                             pNbChannels * sizeof(half));

            if(retVal != 0)

            {

                cout << "ERROR at pixel [" << i << ";" << j << "]" << endl;

                cout << "\tExpected [" << rgbaValue[0] << ", "

                        << rgbaValue[1] << ", "

                        << rgbaValue[2] << "] " << endl;

                cout << "\tReceived ["      << pPixels[i][j * pNbChannels] << ", "

                        << pPixels[i][j * pNbChannels + 1] << ", "

                        << pPixels[i][j * pNbChannels + 2] << "]" << endl;

                assert(retVal == 0);

            }

        }

    }

}

//

//  Write pixels to a file (mono version)

//

void

writePixels (const char pFilename[],

             const int& pImageHeight,

             const int& pImageWidth,

             Array2D<half>& pPixels,

             int pNbChannels,

             Compression pCompression)

{

    Header header (pImageWidth,

                   pImageHeight,

                   1.0f,

                   V2f(0.0f,0.0f),

                   1.0f,

                   INCREASING_Y,

                   pCompression);

    for(int i = 0; i < pNbChannels; ++i)

    {

        header.channels().insert (CHANNEL_NAMES[i], Channel(HALF));

    }

    OutputFile lFile(pFilename, header);

    FrameBuffer lOutputFrameBuffer;

    for(int i = 0; i < pNbChannels; ++i)

    {

        lOutputFrameBuffer.insert (CHANNEL_NAMES[i],

                Slice (HALF,

                        (char *) &pPixels[0][i],

                        sizeof (pPixels[0][0]) * pNbChannels,

                        sizeof (pPixels[0][0]) * pNbChannels * pImageWidth));

    }

    lFile.setFrameBuffer (lOutputFrameBuffer);

    lFile.writePixels (pImageHeight);

}

//

//  Write pixels to a file (stereo version)

//

void

writePixels (const char pFilename[],

             const int& pImageHeight,

             const int& pImageWidth,

             Array2D<half>& pPixels,

             Array2D<half>& pPixelsLeft,

             int pNbChannels,

             Compression pCompression)

{

    Header header (pImageWidth,

                   pImageHeight,

                   1.0f,

                   V2f(0.0f,0.0f),

                   1.0f,

                   INCREASING_Y,

                   pCompression);

    for(int i = 0; i < pNbChannels; ++i)

    {

        header.channels().insert (CHANNEL_NAMES[i], Channel(HALF));

        header.channels().insert (CHANNEL_NAMES_LEFT[i], Channel(HALF));

    }

    StringVector multiView;

    multiView.push_back ("right");

    multiView.push_back ("left");

    header.insert("multiView", IMF::TypedAttribute<IMF::StringVector>(multiView));

    OutputFile lFile(pFilename, header);

    FrameBuffer lOutputFrameBuffer;

    for(int i = 0; i < pNbChannels; ++i)

    {

        lOutputFrameBuffer.insert (CHANNEL_NAMES[i],

                Slice (HALF,

                        (char *) &pPixels[0][i],

                        sizeof (pPixels[0][0]) * pNbChannels,

                        sizeof (pPixels[0][0]) * pNbChannels * pImageWidth));

        lOutputFrameBuffer.insert (CHANNEL_NAMES_LEFT[i],

                Slice (HALF,

                        (char *) &pPixelsLeft[0][i],

                        sizeof (pPixelsLeft[0][0]) * pNbChannels,

                        sizeof (pPixelsLeft[0][0]) * pNbChannels * pImageWidth));

    }

    lFile.setFrameBuffer (lOutputFrameBuffer);

    lFile.writePixels (pImageHeight);

}

//

//  Read pixels from a file (mono version).

//

void

readPixels (const char pFilename[], int pNbChannels, Array2D<half>& pPixels)

{

    InputFile lFile(pFilename);

    IMATH::Box2i lDataWindow = lFile.header().dataWindow();

    int lWidth = lDataWindow.max.x - lDataWindow.min.x + 1;

    int lHeight = lDataWindow.max.y - lDataWindow.min.y + 1;

    FrameBuffer lInputFrameBuffer;

    for(int i = 0; i < pNbChannels; ++i)

    {

        lInputFrameBuffer.insert (CHANNEL_NAMES[i],

                Slice (HALF,

                        (char *) &pPixels[0][i],

                        sizeof (pPixels[0][0]) * pNbChannels,

                        sizeof (pPixels[0][0]) * pNbChannels * lWidth,

                        1,

                        1,

                        ALPHA_DEFAULT_VALUE));

    }

    lFile.setFrameBuffer (lInputFrameBuffer);

    bool is_optimized = lFile.isOptimizationEnabled();

    if(is_optimized)

    {

        cout << " optimization enabled\n";

        if(pNbChannels==2)

        {

            cerr << " error: isOptimizationEnabled returned TRUE, but "

            "optimization not known to work for two channel images\n";

            assert(pNbChannels!=2);

        }

    }else{

        cout << " optimization disabled\n";

#ifdef IMF_HAVE_SSE2

        if(pNbChannels!=2)

        {

            cerr << " error: isOptimizationEnabled returned FALSE, but "

            "should work for " << pNbChannels << "channel images\n";

            assert(pNbChannels==2);

        }

#endif

    }

    lFile.readPixels (lDataWindow.min.y, lDataWindow.max.y);

}

//

//  Read pixels from a file (stereo version).

//

void

readPixels (const char pFilename[],

            int pNbChannels,

            Array2D<half>& pPixels,

            Array2D<half>& pPixelsLeft)

{

    InputFile lFile(pFilename);

    IMATH::Box2i lDataWindow = lFile.header().dataWindow();

    int lWidth = lDataWindow.max.x - lDataWindow.min.x + 1;

    int lHeight = lDataWindow.max.y - lDataWindow.min.y + 1;

    FrameBuffer lInputFrameBuffer;

    for(int i = 0; i < pNbChannels; ++i)

    {

        lInputFrameBuffer.insert (CHANNEL_NAMES[i],

                Slice (HALF,

                        (char *) &pPixels[0][i],

                        sizeof (pPixels[0][0]) * pNbChannels,

                        sizeof (pPixels[0][0]) * pNbChannels * lWidth,

                        1,

                        1,

                        ALPHA_DEFAULT_VALUE));

        lInputFrameBuffer.insert (CHANNEL_NAMES_LEFT[i],

                Slice (HALF,

                        (char *) &pPixelsLeft[0][i],

                        sizeof (pPixelsLeft[0][0]) * pNbChannels,

                        sizeof (pPixelsLeft[0][0]) * pNbChannels * lWidth,

                        1,

                        1,

                        ALPHA_DEFAULT_VALUE));

    }

    lFile.setFrameBuffer (lInputFrameBuffer);

    lFile.readPixels (lDataWindow.min.y, lDataWindow.max.y);

}

//

// Allocate an array of pixels, fill them with values and then write

// them to a file.

void

writeFile (const char pFilename[],

           int pHeight,

           int pWidth,

           EImageType pImageType,

           bool pIsStereo,

           Compression pCompression)

{

    const int lNbChannels = getNbChannels (pImageType);

    Array2D<half> lPixels;

    lPixels.resizeErase (pHeight, pWidth * lNbChannels);

    fillPixels (pHeight, pWidth, lPixels, lNbChannels, false);

    if(pIsStereo)

    {

        Array2D<half> lPixelsLeft;

        lPixelsLeft.resizeErase (pHeight, pWidth * lNbChannels);

        fillPixels (pHeight,

                    pWidth,

                    lPixelsLeft,

                    lNbChannels,

                    true);

        writePixels (pFilename,

                     pHeight,

                     pWidth,

                     lPixels,

                     lPixelsLeft,

                     lNbChannels,

                     pCompression);

    }

    else

    {

        writePixels (pFilename,

                    pHeight,

                    pWidth,

                    lPixels,

                    lNbChannels,

                    pCompression);

    }

}

//

// Read pixels from a file and then validate that the values are the

// same as what was used to fill them before writing.

//

void

readValidateFile (const char pFilename[],

                  int pHeight,

                  int pWidth,

                  EImageType

                  pImageType,

                  bool pIsStereo)

{

    const int lNbChannels = getNbChannels(pImageType);

    Array2D<half> lPixels;

    lPixels.resizeErase(pHeight, pWidth * lNbChannels);

    //readPixels(pFilename, lNbChannels, lPixels);

    //writePixels("pkTest.exr", pHeight, pWidth, lPixels, lNbChannels, NO_COMPRESSION);

    if(pIsStereo)

    {

        Array2D<half> lPixelsLeft;

        lPixelsLeft.resizeErase (pHeight, pWidth * lNbChannels);

        readPixels (pFilename, lNbChannels, lPixels, lPixelsLeft);

        validatePixels (pHeight, pWidth, lPixels, lNbChannels, false);

        validatePixels (pHeight, pWidth, lPixelsLeft, lNbChannels, true);

    }

    else

    {

        readPixels (pFilename, lNbChannels, lPixels);

        validatePixels (pHeight, pWidth, lPixels, lNbChannels, false);

    }

}

//

// confirm the optimization flag returns false for non-RGB files

//

void

testNonOptimized (const std::string & tempDir)

{

    const int pHeight = IMAGE_2K_HEIGHT - 1;

    const int pWidth  =  IMAGE_2K_WIDTH - 1;

    std::string fn = tempDir +  RGB_FILENAME;

    const char* filename  = fn.c_str();

    remove(filename);

    writeFile (filename,  pHeight, pWidth, IMAGE_TYPE_OTHER,  false, NO_COMPRESSION);

    readValidateFile(filename,pHeight,pWidth,IMAGE_TYPE_OTHER,false);

    remove(filename);

}

//

// Test all combinations of file/framebuffer

//  RGB  file to RGB  framebuffer

//  RGB  file to RGBA framebuffer

//  RGBA file to RGB  framebuffer

//  RGBA file to RGBA framebuffer

// Given a switch that determines whether the pixels will be SSE-aligned,

// whether the file is mono or stereo, and the compression algorithm used

// to write the file.

//

void

testAllCombinations (bool isAligned,

                     bool isStereo,

                     Compression pCompression,

                     const std::string & tempDir)

{

    std::string pRgb  = isStereo ?  RGB_STEREO_FILENAME :

                                    RGB_FILENAME;

    pRgb = tempDir + pRgb;

    std::string pRgba = isStereo ?  RGBA_STEREO_FILENAME :

                                    RGBA_FILENAME;

    pRgba = tempDir + pRgba;

    const char * pRgbFilename  = pRgb.c_str();

    const char * pRgbaFilename = pRgba.c_str();

    const int pHeight = isAligned ? IMAGE_2K_HEIGHT : IMAGE_2K_HEIGHT - 1;

    const int pWidth  = isAligned ? IMAGE_2K_WIDTH  : IMAGE_2K_WIDTH  - 1;

    remove(pRgbFilename);

    remove(pRgbaFilename);

    writeFile (pRgbFilename,  pHeight, pWidth, IMAGE_TYPE_RGB,  isStereo, pCompression);

    writeFile (pRgbaFilename, pHeight, pWidth, IMAGE_TYPE_RGBA, isStereo, pCompression);

    cout << "\t\tRGB file to RGB framebuffer" << endl;

    readValidateFile (pRgbFilename,  pHeight, pWidth, IMAGE_TYPE_RGB,  isStereo);

    cout << "\t\tRGB file to RGB framebuffer" << endl;

    readValidateFile (pRgbFilename,  pHeight, pWidth, IMAGE_TYPE_RGB,  isStereo);

    cout << "\t\tRGB file to RGBA framebuffer" << endl;

    readValidateFile (pRgbFilename,  pHeight, pWidth, IMAGE_TYPE_RGBA, isStereo);

    cout << "\t\tRGBA file to RGB framebuffer" << endl;

    readValidateFile (pRgbaFilename, pHeight, pWidth, IMAGE_TYPE_RGB,  isStereo);

    cout << "\t\tRGBA file to RGBA framebuffer" << endl;

    readValidateFile (pRgbaFilename, pHeight, pWidth, IMAGE_TYPE_RGBA, isStereo);

    remove(pRgbFilename);

    remove(pRgbaFilename);

}

} // anonymous namespace

void

testOptimized (const std::string & tempDir)

{    

    try

    {

        // Test all combinations

        // Aligned file with no compression

        // Unaligned file with no compression

        // Aligned file with zip compression 

        // Unaligned file with zip compression

        //

        // Other algorithms are not necessary because we are not testing

        // compression but whetherthe optimized readPixels() code works

        // with a compressed file.

        // MONO

        cout << "\nTesting optimized code path for rgb(a) images-- "

                "2048x1152 (alignment respected) UNCOMPRESSED" << endl;

        cout << "\tNON-OPTIMIZABLE file" << endl;

        testNonOptimized(tempDir);

        cout << "\tALIGNED -- MONO -- NO COMPRESSION" << endl;

        testAllCombinations (true, false, NO_COMPRESSION, tempDir);

        cout << "\tUNALIGNED -- MONO -- NO COMPRESSION" << endl;

        testAllCombinations (false, false, NO_COMPRESSION, tempDir);

        cout << "\tALIGNED -- MONO -- ZIP COMPRESSION" << endl;

        testAllCombinations (true, false, ZIP_COMPRESSION, tempDir);

        cout << "\tUNALIGNED -- MONO -- ZIP COMPRESSION" << endl;

        testAllCombinations (false, false, ZIP_COMPRESSION, tempDir);

        //// STEREO

        cout << "\tALIGNED -- STEREO -- NO COMPRESSION" << endl;

        testAllCombinations (true, true, NO_COMPRESSION, tempDir);

        cout << "\tUNALIGNED -- STEREO -- NO COMPRESSION" << endl;

        testAllCombinations (false, true, NO_COMPRESSION, tempDir);

        cout << "\tALIGNED -- STEREO -- ZIP COMPRESSION" << endl;

        testAllCombinations (true, true, ZIP_COMPRESSION, tempDir);

        cout << "\tUNALIGNED -- STEREO -- ZIP COMPRESSION" << endl;

        testAllCombinations (false, true, ZIP_COMPRESSION, tempDir);

        cout << "RGB(A) files validation complete \n" << endl;

    }

    catch (const std::exception &e)

    {

	    cerr << "ERROR -- caught exception: " << e.what() << endl;

	    assert (false);

    }

}