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

//

// Copyright (c) 2013, Weta Digital Ltd

//

// 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 "ImfInputFile.h"

#include <stdlib.h>

#include <vector>

#include "ImfChannelList.h"

#include "ImfOutputFile.h"

#include "ImfCompression.h"

#include "ImfStandardAttributes.h"

#include <algorithm>

#include <iostream>

#include <assert.h>

#include <IlmThread.h>

#include <ImathBox.h>

#include "tmpDir.h"

namespace IMF = OPENEXR_IMF_NAMESPACE;

using namespace IMF;

using namespace std;

using namespace IMATH_NAMESPACE;

using namespace ILMTHREAD_NAMESPACE;

namespace

{

using OPENEXR_IMF_NAMESPACE::UINT;

using OPENEXR_IMF_NAMESPACE::FLOAT;

std::string filename;

vector<char> writingBuffer; // buffer as file was written

vector<char> readingBuffer; // buffer containing new image (and filled channels?)

vector<char> preReadBuffer; // buffer as it was before reading - unread, unfilled channels should be unchanged

int gOptimisedReads = 0;

int gSuccesses = 0;

int gFailures = 0;

//

// @todo Needs a description of what this is used for.

//

//

struct Schema

{

    const char*         _name;     // name of this scheme

    const char* const*  _active;   // channels to be read

    const char* const * _passive;  // channels to be ignored (keep in buffer passed to inputfile, should not be overwritten)

    int                 _banks;

    const char* const * _views;    // list of views to write, or NULL

    const PixelType*    _types;    // NULL for all HALF, otherwise per-channel type

    vector<string> views() const

    {

        const char * const* v = _views;

        vector<string> svec;

        while(*v!=NULL)

        {

            svec.push_back (*v);

            v++;

        }

        return svec;

    } 

};

const char * rgb[] = {"R","G","B",NULL};

const char * rgba[] = {"R","G","B","A",NULL};

const char * bgr[] = {"B","G","R",NULL};

const char * abgr[] = {"A","B","G","R",NULL};

const char * alpha[] = {"A",NULL};

const char * redalpha[] = {"R","A",NULL};

const char * rgbrightrgb[] = {"R","G","B","right.R","right.G","right.B",NULL};

const char * rgbleftrgb[] = {"R","G","B","left.R","left.G","left.B",NULL};

const char * rgbarightrgba[] = {"R","G","B","A","right.R","right.G","right.B","right.A",NULL};

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

const char * rgbrightrgba[] = {"R","G","B","right.R","right.G","right.B","right.A",NULL};

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

const char * rgbarightrgb[] = {"R","G","B","A","right.R","right.G","right.B",NULL};

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

const char * rightrgba[] = {"right.R","right.G","right.B","right.A",NULL};

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

const char * rightrgb[] = {"right.R","right.G","right.B",NULL};

const char * leftrgb[] = {"left.R","left.G","left.B",NULL};

const char * threeview[] ={"R","G","B","A","left.R","left.G","left.B","left.A","right.R","right.G","right.B","right.A",NULL};

const char * trees[] = {"rimu","pohutukawa","manuka","kauri",NULL};

const char * treesandbirds[]= {"kiwi","rimu","pohutukawa","kakapu","kauri","manuka","moa","fantail",NULL};

const char * lefthero[] = {"left","right",NULL};

const char * righthero[] = {"right","left",NULL};

const char * centrehero[] = {"centre","left","right",NULL};

const PixelType four_floats[] = {IMF::FLOAT,IMF::FLOAT,IMF::FLOAT,IMF::FLOAT};

const PixelType hhhfff[] = {IMF::HALF,IMF::HALF,IMF::HALF,IMF::FLOAT,IMF::FLOAT,IMF::FLOAT};

const PixelType hhhhffff[] = {IMF::HALF,IMF::HALF,IMF::HALF,IMF::HALF,IMF::FLOAT,IMF::FLOAT,IMF::FLOAT,IMF::FLOAT};

Schema Schemes[] =

{

        {"RGBHalf"              ,rgb           ,NULL      ,1 ,NULL       ,NULL       },

        {"RGBAHalf"             ,rgba          ,NULL      ,1 ,NULL       ,NULL       },

        {"ABGRHalf"             ,abgr          ,NULL      ,1 ,NULL       ,NULL       },

        {"RGBFloat"             ,rgb           ,NULL      ,1 ,NULL       ,four_floats},

        {"BGRHalf"              ,bgr           ,NULL      ,1 ,NULL       ,NULL       },

        {"RGBLeftRGB"           ,rgbleftrgb    ,NULL      ,1 ,righthero  ,NULL       },

        {"RGBRightRGB"          ,rgbrightrgb   ,NULL      ,1 ,lefthero   ,NULL       },

        {"RGBALeftRGBA"         ,rgbaleftrgba  ,NULL      ,1 ,righthero  ,NULL       },

        {"RGBARightRGBA"        ,rgbarightrgba ,NULL      ,1 ,lefthero   ,NULL       },

        {"LeftRGB"              ,leftrgb       ,NULL      ,1 ,NULL       ,NULL       },

        {"RightRGB"             ,rightrgb      ,NULL      ,1 ,NULL       ,NULL       },

        {"LeftRGBA"             ,leftrgba      ,NULL      ,1 ,NULL       ,NULL       },

        {"RightRGBA"            ,rightrgba     ,NULL      ,1 ,NULL       ,NULL       },

        {"TripleView"           ,threeview     ,NULL      ,1 ,centrehero ,NULL       },

        {"Trees"                ,trees         ,NULL      ,1 ,NULL       ,NULL       },

        {"TreesAndBirds"        ,treesandbirds ,NULL      ,1 ,NULL       ,NULL       },

        {"RGBLeftRGBA"          ,rgbleftrgba   ,NULL      ,1 ,righthero  ,NULL       },

        {"RGBRightRGBA"         ,rgbrightrgba  ,NULL      ,1 ,lefthero   ,NULL       },

        {"RGBALeftRGB"          ,rgbaleftrgb   ,NULL      ,1 ,righthero  ,NULL       },

        {"RGBARightRGB"         ,rgbarightrgb  ,NULL      ,1 ,lefthero   ,NULL       },

        {"TwinRGBLeftRGB"       ,rgbleftrgb    ,NULL      ,2 ,righthero  ,NULL       },

        {"TwinRGBRightRGB"      ,rgbrightrgb   ,NULL      ,2 ,lefthero   ,NULL       },

        {"TwinRGBALeftRGBA"     ,rgbaleftrgba  ,NULL      ,2 ,righthero  ,NULL       },

        {"TwinRGBARightRGBA"    ,rgbarightrgba ,NULL     , 2 ,lefthero   ,NULL       },

        {"TripleTripleView"     ,threeview     ,NULL      ,3 ,centrehero ,NULL       },

        {"Alpha"                ,alpha         ,NULL      ,1 ,NULL       ,NULL       },

        {"RedAlpha"             ,redalpha      ,NULL      ,1 ,NULL       ,NULL       },

        {"RG+BA"                ,rgba          ,NULL      ,2 ,NULL       ,NULL       },//interleave only RG, then BA

        {"RGBpassiveA"          ,rgb           ,alpha     ,1 ,NULL       ,NULL       },//interleave only RG, then BA

        {"RGBpassiveleftRGB"    ,rgb           ,leftrgb   ,1 ,NULL       ,NULL       },

        {"RGBFloatA"            ,rgba          ,NULL      ,1 ,NULL       ,hhhfff     },

        {"RGBFloatLeftRGB"      ,rgbleftrgb    ,NULL      ,1 ,righthero  ,hhhfff     },

        {"RGBAFloatLeftRGBA"    ,rgbaleftrgba  ,NULL      ,1 ,righthero  ,hhhhffff   },

        {"RGBApassiverightRGBA" ,rgba          ,rightrgba ,1 ,NULL       ,NULL       },

        {"BanksOfTreesAndBirds" ,treesandbirds ,NULL      ,2 ,NULL       ,NULL       },

        {NULL,NULL,NULL,0,NULL,NULL}

};

bool compare(const FrameBuffer& asRead,

             const FrameBuffer& asWritten,

             const Box2i& dataWindow,

             bool nonfatal

            )

{

    for (FrameBuffer::ConstIterator i =asRead.begin();i!=asRead.end();i++)

    {

        FrameBuffer::ConstIterator p = asWritten.find(i.name());

        for (int y=dataWindow.min.y; y<= dataWindow.max.y; y++)

        {

            for (int x = dataWindow.min.x; x <= dataWindow.max.x; x++)

            {

                char * ptr = (i.slice().base+i.slice().yStride*y +i.slice().xStride*x);

                half readHalf;

                switch (i.slice().type)

                {

                    case IMF::FLOAT :

                        readHalf =  half(*(float*) ptr);

                        break;

                    case IMF::HALF :

                        readHalf = half(*(half*) ptr);

                        break;

                    case IMF::UINT :

                        continue; // can't very well check this

                    default :

                        cout << "don't know about that\n";

                        exit(1);

                }

                half writtenHalf;

                if (p!=asWritten.end())

                {

                    char * ptr = p.slice().base+p.slice().yStride*y +

                                 p.slice().xStride*x;

                    switch (p.slice().type)

                    {

                    case IMF::FLOAT :

                        writtenHalf = half(*(float*) ptr);

                        break;

                    case IMF::HALF :

                        writtenHalf = half(*(half*) ptr);

                        break;

                    case IMF::UINT :

                        continue;

                    default :

                        cout << "don't know about that\n";

                        exit(1);

                    }

                }

                else

                {

                    writtenHalf=half(i.slice().fillValue);

                }

                if (writtenHalf.bits()!=readHalf.bits())

                {

                    if (nonfatal)

                    {

                        return false;

                    }

                    else

                    {

                        cout << "\n\nerror reading back channel " << i.name() << " pixel " << x << ',' << y << " got " << readHalf << " expected " << writtenHalf << endl;

                        assert(writtenHalf.bits()==readHalf.bits());

                        exit(1);

                    }

                }             

            }

        }

    }

    return true;

}

//

// allocate readingBuffer or writingBuffer, setting up a framebuffer to point to the right thing

//

ChannelList

setupBuffer (const Header& hdr,       // header to grab datawindow from

             const char * const *channels, // NULL terminated list of channels to write

             const char * const *passivechannels, // NULL terminated list of channels to write

             const PixelType* pt,     // type of each channel, or NULL for all HALF

             FrameBuffer& buf,        // buffer to fill with pointers to channel

             FrameBuffer& prereadbuf, // channels which aren't being read - indexes into the preread buffer

             FrameBuffer& postreadbuf, // channels which aren't being read - indexes into the postread buffer

             int banks,                    // number of banks - channels within each bank are interleaved, banks are scanline interleaved

             bool writing                  // true if should allocate

            )

{

    Box2i dw = hdr.dataWindow();

    //

    // how many channels in total

    //

    int activechans = 0;

    int bytes_per_pixel =0;

    while (channels[activechans]!=NULL)

    {

        if (pt==NULL)

        {

            bytes_per_pixel+=2;

        }

        else

        {

            switch (pt[activechans])

            {

                case IMF::HALF : bytes_per_pixel+=2;break;

                case IMF::FLOAT : case IMF::UINT : bytes_per_pixel+=4;break;

                default :

                    cout << "Unexpected PixelType?\n";

                    exit(1);

            }

        }

        activechans++;

    }

    int passivechans=0;

    while (passivechannels!=NULL && passivechannels[passivechans]!=NULL)

    {

        if (pt==NULL)

        {

            bytes_per_pixel+=2;

        }

        else

        {

            switch (pt[passivechans+activechans])

            {

                case IMF::HALF : bytes_per_pixel+=2;break;

                case IMF::FLOAT : case IMF::UINT : bytes_per_pixel+=4;break;

                default :

                    cout << "Unexpected PixelType?\n";

                    exit(1);

            }

        }

        passivechans++;

    }

   int chans = activechans+passivechans;

    int bytes_per_bank = bytes_per_pixel/banks;

    int samples = (hdr.dataWindow().max.x+1-hdr.dataWindow().min.x)*

                  (hdr.dataWindow().max.y+1-hdr.dataWindow().min.y)*chans;

    int size = samples*bytes_per_pixel;

    if (writing)

    {

        writingBuffer.resize(size);

    }

    else

    {

        readingBuffer.resize(size);

    }

     const char * write_ptr = writing ? &writingBuffer[0] : &readingBuffer[0];

     // fill with random halfs, casting to floats for float channels

     int chan=0;

     for (int i=0;i

     {

         unsigned short int values = (unsigned short int) floor((double(rand())/double(RAND_MAX))*65535.0);

         half v;

         v.setBits(values);

         if (pt==NULL || pt[chan]==IMF::HALF)

         {

             *(half*)write_ptr = half(v);

             write_ptr+=2;

         }

         else

         {

             *(float*)write_ptr = float(v);

             write_ptr+=4;

         }

         chan++;

         if (chan==chans)

         {

             chan=0;

         }

     }

     if (!writing)

     {

         //take a copy of the buffer as it was before being read

         preReadBuffer = readingBuffer;

     }

    char* offset=NULL;

    ChannelList chanlist;

    int bytes_per_row = bytes_per_pixel*(dw.max.x+1-dw.min.x);

    int bytes_per_bank_row = bytes_per_row/banks;

    int first_pixel_index = bytes_per_row*dw.min.y+bytes_per_bank*dw.min.x;

    for (int i=0;i

    {

        PixelType type = pt==NULL ? IMF::HALF : pt[i];

        if (i

        {

            chanlist.insert(channels[i],type);

        }

        if (i % (chans/banks) ==0)

        {

            //

            // set offset pointer to beginning of bank

            //

            int bank = i / (chans/banks);

            offset = (writing ? &writingBuffer[0] :

                                &readingBuffer[0]) + bank*bytes_per_bank_row - first_pixel_index;

        }

        if (i

        {

            buf.insert (channels[i],

                        Slice (type,

                               offset,

                               bytes_per_bank,

                               bytes_per_row,

                               1,1,100+i));

        }

        else

        {

            if (!writing)

            {

                postreadbuf.insert (passivechannels[i-activechans],

                                    Slice (type,

                                           offset,

                                           bytes_per_bank,

                                           bytes_per_row,

                                           1,1,0.4));

                char * pre_offset = offset-&readingBuffer[0]+&preReadBuffer[0];

                prereadbuf.insert (passivechannels[i-activechans],

                                   Slice (type,

                                          pre_offset,

                                          bytes_per_bank,

                                          bytes_per_row,

                                          1,1,0.4));

            }

        }

        switch (type)

        {

            case IMF::HALF :

                offset+=2;

                break;

            case IMF::FLOAT :

                offset+=4;

                break;

            default :

                cout << "Unexpected Pixel Type\n";

                exit(1);

        }

    }

    return chanlist;

}

Box2i writefile(Schema & scheme,FrameBuffer& buf,bool tiny)

{

    const int height = 128;

    const int width  = 128;

    Header hdr(width,height,1);

    //min values in range (-100,100)

    hdr.dataWindow().min.x = int(200.0*double(rand())/double(RAND_MAX)-100.0);

    hdr.dataWindow().min.y = int(200.0*double(rand())/double(RAND_MAX)-100.0);

    // in tiny mode, make image up to 14*14 pixels (less than two SSE instructions)

    if (tiny)

    {

        hdr.dataWindow().max.x = hdr.dataWindow().min.x + 1+int(13*double(rand())/double(RAND_MAX));

        hdr.dataWindow().max.y = hdr.dataWindow().min.y + 1+int(13*double(rand())/double(RAND_MAX));

    }

    else

    {

        // in normal mode, make chunky images

        hdr.dataWindow().max.x = hdr.dataWindow().min.x + 64+int(400*double(rand())/double(RAND_MAX));

        hdr.dataWindow().max.y = hdr.dataWindow().min.y + 64+int(400*double(rand())/double(RAND_MAX));

    }

    hdr.compression()=ZIPS_COMPRESSION;

    FrameBuffer dummy1,dummy2;

    hdr.channels() = setupBuffer (hdr,

                                  scheme._active,

                                  scheme._passive,

                                  scheme._types,

                                  buf,

                                  dummy1,

                                  dummy2,

                                  scheme._banks,

                                  true);

    if (scheme._views)

    {

        addMultiView(hdr,scheme.views());

    }

    remove (filename.c_str());

    OutputFile f(filename.c_str(), hdr);

    f.setFrameBuffer(buf);

    f.writePixels(hdr.dataWindow().max.y-hdr.dataWindow().min.y+1);

    return hdr.dataWindow();

}

bool

readfile (Schema scheme,

          FrameBuffer & buf,      ///< list of channels to read: index to readingBuffer

          FrameBuffer & preread,  ///< list of channels to skip: index to preReadBuffer

          FrameBuffer & postread) ///< list of channels to skip: index to readingBuffer)

{

    InputFile infile (filename.c_str());

    setupBuffer(infile.header(),

                scheme._active,

                scheme._passive,

                scheme._types,

                buf,

                preread,

                postread,

                scheme._banks,false);

    infile.setFrameBuffer(buf);

    cout.flush();

    infile.readPixels (infile.header().dataWindow().min.y,

                       infile.header().dataWindow().max.y);

    return infile.isOptimizationEnabled();

}

void

test (Schema writeScheme, Schema readScheme, bool nonfatal, bool tiny)

{

    ostringstream q;

    q << writeScheme._name << " read as " << readScheme._name << "...";

    cout << left << setw(53) << q.str();

    FrameBuffer writeFrameBuf;

    Box2i dw = writefile(writeScheme,writeFrameBuf,tiny);

    FrameBuffer readFrameBuf;

    FrameBuffer preReadFrameBuf;

    FrameBuffer postReadFrameBuf;

    cout.flush();

    bool opt = readfile (readScheme,

                         readFrameBuf,

                         preReadFrameBuf,

                         postReadFrameBuf);

    if (compare(readFrameBuf, writeFrameBuf, dw, nonfatal) &&

        compare(preReadFrameBuf, postReadFrameBuf, dw, nonfatal)

    )

    {

        cout <<  " OK ";

        if (opt)

        {

            cout << "OPTIMISED ";

            gOptimisedReads++;

        }

        cout << "\n";

        gSuccesses++;

    }

    else

    {

        cout <<  " FAIL" << endl;

        gFailures++;

    }

    remove (filename.c_str());

}

void runtests(bool nonfatal,bool tiny)

{

    srand(1);

    int i=0;

    int skipped=0;

    gFailures=0;

    gSuccesses=0;

    gOptimisedReads=0;

    while(Schemes[i]._name!=NULL)

    {

        int j=0;

        while(Schemes[j]._name!=NULL)

        {

           cout << right << setw(2) << i << ',' << right << setw(2) << j << ": ";

           cout.flush();

           if (nonfatal)

           {

               cout << " skipping " << Schemes[i]._name << ',' << Schemes[j]._name << ": known to crash\n";

               skipped++;

           }

           else

           {

               test(Schemes[i],Schemes[j],nonfatal,tiny);

           }

           j++;

        }

        i++;

    }

    cout << gFailures << '/' << (gSuccesses+gFailures) << " runs failed\n";

    cout << skipped << " tests skipped (assumed to be bad)\n";

    cout << gOptimisedReads << '/' << gSuccesses << " optimised\n";

    if (gFailures>0 )

    {

        cout << " TESTS FAILED\n";

        assert(false);

    }

}

} // namespace anon

void 

testOptimizedInterleavePatterns (const std::string & tempDir)

{

    filename = tempDir + "imf_test_interleave_patterns.exr";

    cout << "Testing SSE optimisation with different interleave patterns (large images) ... " << endl;

    runtests (false,false);

    cout << "Testing SSE optimisation with different interleave patterns (tiny images) ... " << endl;

    runtests (false,true);

    cout << "ok\n" << endl;

}