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

//

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

// Digital Ltd. LLC

// Portions contributed and copyright held by others as indicated.

// 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.

//

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

//-----------------------------------------------------------------------------

//

//	Utility program to combine or separate multipart image files

//

//-----------------------------------------------------------------------------

#include <ImfMultiPartOutputFile.h>

#include <ImfMultiPartInputFile.h>

#include <ImfStringAttribute.h>

#include <ImfChannelList.h>

#include <ImfTiledInputPart.h>

#include <ImfTiledOutputPart.h>

#include <ImfInputPart.h>

#include <ImfOutputPart.h>

#include <ImfDeepScanLineInputPart.h>

#include <ImfDeepScanLineOutputPart.h>

#include <ImfDeepTiledInputPart.h>

#include <ImfDeepTiledOutputPart.h>

#include <ImfPartHelper.h>

#include <ImfPartType.h>

#include <OpenEXRConfig.h>

#include <Iex.h>

#include <iostream>

#include <vector>

#include <utility> // pair

#include <stdlib.h>

#include <sstream>

#include <assert.h>

#include <cctype>

#include <algorithm>

using std::cerr;

using std::cout;

using std::endl;

using std::vector;

using std::pair;

using std::set;

using std::ostringstream;

using std::min;

using std::max;

using std::string;

using std::make_pair;

using IMATH_NAMESPACE::Box2i;

using namespace OPENEXR_IMF_NAMESPACE;

#if defined(ANDROID) || defined(__ANDROID_API__)

    #define IMF_PATH_SEPARATOR "/"

#elif defined(_WIN32) || defined(_WIN64) || defined(__MWERKS__) || defined(PLATFORM_WINDOWS)

    #define IMF_PATH_SEPARATOR "\\"

#else

    #define IMF_PATH_SEPARATOR "/"

#endif

void

copy_tile (MultiPartInputFile & input,

           MultiPartOutputFile & output,

           int inPart, int outPart)

{

    TiledInputPart in (input, inPart);

    TiledOutputPart out (output, outPart);

    out.copyPixels (in);

}

void

copy_tiledeep (MultiPartInputFile & input,

               MultiPartOutputFile & output,

               int inPart, int outPart)

{

    DeepTiledInputPart in (input, inPart);

    DeepTiledOutputPart out (output, outPart);

    out.copyPixels (in);

}

void

copy_scanline (MultiPartInputFile & input,

               MultiPartOutputFile & output,

               int inPart, int outPart)

{

    InputPart in (input, inPart);

    OutputPart out (output, outPart);

    out.copyPixels (in);

}

void

copy_scanlinedeep (MultiPartInputFile & input,

                   MultiPartOutputFile & output,

                   int inPart, int outPart)

{

    DeepScanLineInputPart in (input, inPart);

    DeepScanLineOutputPart out (output, outPart);

    out.copyPixels (in);

}

bool

is_number(const std::string& s)

{

    std::string::const_iterator it = s.begin();

    while (it != s.end() && std::isdigit(*it)) ++it;

    return !s.empty() && it == s.end();

}

void

parse_partname (string & part_name)

{

    // strip off a path delimitation

    size_t posSlash = part_name.rfind(IMF_PATH_SEPARATOR);

    if (posSlash != string::npos)

        part_name = part_name.substr(posSlash+1);

    // strip the exr ext

    size_t pos = part_name.rfind(".exr");

    if (pos != string::npos)

    {

        part_name = part_name.substr(0, pos);

        // strip off the frame number

        size_t pos2 = part_name.rfind(".");

        if (pos2 != string::npos)

        {

            string frame = part_name.substr(pos2+1, pos);

            if (is_number(frame))

                part_name = part_name.substr(0, pos2);

        }

    }

}

///

/// If input is <...>::

/// Else, use the stripped version of the filename for partname

/// If input is <file>:<partnum> then extract part number,

/// Else, use all parts

///

void

parse_filename (string & file_name,

                string & part_name,

                bool   & force_part_name,

                int    & part_num)

{

    force_part_name = false;

    part_name = file_name; // default is the file_name

    size_t doublecolon = file_name.rfind ("::");

    if (doublecolon != string::npos)

    {

        part_name = file_name.substr (doublecolon+2);

        file_name = file_name.substr (0, doublecolon);

        force_part_name = true;

    }

    else

    {

        parse_partname(part_name);

    }

    size_t colon = file_name.rfind (':');

    if (colon == string::npos)

    {

        part_num = -1; // use all parts

    }

    else

    {

        string num = file_name.substr (colon + 1);

        if (is_number(num))

        {

            part_num  = atoi (num.c_str());

            file_name = file_name.substr (0, colon);

        }

        else

        {

            cerr <<"\n" << "ERROR: part number must be a number" << endl;

            exit(1);

        }

    }

}

void

make_unique_names (vector<Header> & headers)

{

    set<string> names;

    for ( size_t i = 0 ; i < headers.size() ; i++ )

    {

        Header & h = headers[i];

        std::string base_name;

        // if no name at all, set it to <type><partnum> (first part is part 1)

        if (!h.hasName())

        {

            // We should not be here, we have populated all headers with names.

            cerr << "\n" << "Software Error: header does not have a valid name"

                 << ":" << __LINE__ << endl;

            exit (1);

        }

        else

        {

            base_name = h.name();

        }

        // check name has already been used, if so add a _<number> to it

        if (names.find (base_name) != names.end())

        {

            ostringstream s;

            size_t backup=1;

            do

            {

                s.clear();

                s << h.name() << "_" << i << "_" << backup;

                backup++;

            }

            while (names.find(s.str()) != names.end());

            h.setName (s.str());

        }

        names.insert (h.name());

    }

}

void

filename_check (vector <string> names, const char* aname)

{

    string bname(aname);

    for (size_t i = 0; i < names.size(); i++)

    {

        if (bname.compare (names[i]) == 0)

        {

            cerr << "\n" << "ERROR: "

            "input and output file names cannot be the same." << endl;

            exit (1);

        }

    }

}

void

convert(vector <const char*> in,

        vector<const char *> views,

        const char* outname,

        bool override)

{

    if(in.size()!=1)

    {

        cerr <<"\n" << "ERROR: " 

        "can only convert one file at once - use 'combine' mode for multiple files" << endl;

        exit(1);

    }

    try

    {

        MultiPartInputFile infile(in[0]);

        if(infile.parts() != 1)

        {

            cerr <<"\n" << "ERROR: " 

            "can only convert single part EXRs to multipart EXR-2.0 files: use 'split' mode instead" << endl;

            exit(1);

        }

        vector<MultiViewChannelName> input_channels;

        string hero;

        if(hasMultiView(infile.header(0)))

        {

            StringVector h = multiView (infile.header(0));

            if(h.size()>0)

            {

                hero=h[0];

            }

        }

        // retrieve channel names from input file in view-friendly format

        GetChannelsInMultiPartFile(infile,input_channels);

        vector< MultiViewChannelName > output_channels = input_channels;

        // remap channels to multiple output parts

        int parts = SplitChannels(output_channels.begin(),output_channels.end(),true,hero);

        vector<Header> output_headers(parts);

        vector<FrameBuffer> output_framebuffers(parts);

        FrameBuffer input_framebuffer;

        //

        // make all output headers the same as the input header but 

        // with no channels

        //

        for(int i=0;i

        {

            Header & h = output_headers[i];

            h = infile.header(0);

            if (hasMultiView(h))

                h.erase("multiView");

            string fn, pname;

            int  pnum;

            bool pforce;

            parse_filename(fn, pname, pforce, pnum);

            if (!h.hasName() || pforce)

                h.setName (pname);

            h.channels()=ChannelList();

        }   

        make_unique_names(output_headers);

        const ChannelList & in_chanlist = infile.header(0).channels();

        int channel_count = 0;

        for(ChannelList::ConstIterator i=in_chanlist.begin();i!=in_chanlist.end();++i)

        {

            ++channel_count;

        }

        Box2i dataWindow = infile.header(0).dataWindow();

        int pixel_count = (dataWindow.size().y+1)*(dataWindow.size().x+1);

        int pixel_width = dataWindow.size().x+1;

        // offset in pixels between base of array and 0,0

        int pixel_base = dataWindow.min.y*pixel_width+dataWindow.min.x;

        vector< vector<char> > channelstore(channel_count);

        //

        // insert channels into correct header and framebuffers

        //

        for( size_t i=0 ; i

        {

            // read the part we should be writing channel into, insert into header

            int part = output_channels[i].part_number;

            ChannelList::ConstIterator chan = in_chanlist.find(input_channels[i].internal_name);

            Header & h = output_headers[part];

            h.channels().insert(output_channels[i].name,chan.channel());

            if( output_channels[i].view!="" )

            {

                h.setView( output_channels[i].view );

            }

            // compute size of channel

            size_t samplesize=sizeof(float);

            if(chan.channel().type==HALF)

            {

                samplesize=sizeof(half);

            }

            channelstore[i].resize(samplesize*pixel_count);

            output_framebuffers[part].insert(output_channels[i].name,

                                             Slice(chan.channel().type,

                                                   &channelstore[i][0]-pixel_base*samplesize,

                                                   samplesize,

                                                   pixel_width*samplesize));

            input_framebuffer.insert(input_channels[i].internal_name,

                                     Slice(chan.channel().type,

                                           &channelstore[i][0] - pixel_base*samplesize,

                                           samplesize,

                                           pixel_width*samplesize));

        }

        //

        // create output file

        //

        MultiPartOutputFile outfile(outname,&output_headers[0],

                                    output_headers.size());

        InputPart inpart(infile,0);

        //

        // read file

        //

        inpart.setFrameBuffer(input_framebuffer);

        inpart.readPixels(dataWindow.min.y,dataWindow.max.y);

        //

        // write each part

        //

        for(size_t i=0;i

        {

            OutputPart outpart(outfile,i);

            outpart.setFrameBuffer(output_framebuffers[i]);

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

        }

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        cerr << "\n" << "ERROR:" << endl;

        cerr << e.what() << endl;

        exit (1);

    }

}

void

combine (vector <const char*> in,

         vector<const char *> views,

         const char* outname,

         bool override)

{

    size_t numInputs = in.size();

    int numparts;

    vector<int> partnums;

    vector<MultiPartInputFile *> inputs;

    vector<MultiPartInputFile *> fordelete;

    MultiPartInputFile *infile;

    vector<Header> headers;

    vector<string> fornamecheck;

    //

    // parse all inputs

    //

    // Input format :

    // We support the following syntax for each input

    // <file>[:<partnum>][::<newpartname>]

    for (size_t i = 0 ; i < numInputs; i++)

    {

        string filename (in[i]);

        string partname;

        bool   forcepartname;

        int    partnum;

        parse_filename (filename, partname, forcepartname, partnum);

        if (partnum == -1)

        {

            fornamecheck.push_back (filename);

            try

            {

                infile = new MultiPartInputFile (filename.c_str());

                fordelete.push_back (infile);

                numparts = infile->parts();

                //copy header from all parts of input to our header array

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

                {

                    inputs.push_back (infile);

                    Header h = infile->header(j);

                    if (!h.hasName() || forcepartname)

                        h.setName (partname);

                    headers.push_back (h);

                    if( views[i] != NULL )

                        headers[headers.size()-1].setView( views[i] );

                    partnums.push_back (j);

                }

            }

            catch (IEX_NAMESPACE::BaseExc &e)

            {

                cerr << "\n" << "ERROR:" << endl;

                cerr << e.what() << endl;

                exit (1);

            }

        } // no user parts specified

        else

        {

            fornamecheck.push_back (filename);

            try

            {

                infile = new MultiPartInputFile (filename.c_str());

                fordelete.push_back (infile);

                if (partnum >= infile->parts())

                {

                    cerr << "ERROR: you asked for part " << partnum << " in " << in[i];

                    cerr << ", which only has " << infile->parts() << " parts\n";

                    exit (1);

                }

                //copy header from required part of input to our header array

                inputs.push_back (infile);

                Header h = infile->header(partnum);

                if (!h.hasName() || forcepartname)

                    h.setName (partname);

                headers.push_back (h);

                if( views[i] != NULL )

                     headers[headers.size()-1].setView( views[i] );

                partnums.push_back (partnum);

            }

            catch (IEX_NAMESPACE::BaseExc &e)

            {

                cerr << "\n" << "ERROR:" << endl;

                cerr << e.what()<< endl;

                exit (1);

            }

        } // user parts specified

    }

    filename_check (fornamecheck, outname);

    //

    // sort out names - make unique

    //

    if (numInputs>1)

    {

        make_unique_names (headers);

    }

    //

    // do combine

    //

    // early bail if need be

    try

    {

        MultiPartOutputFile temp (outname, &headers[0], headers.size(), override);

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        cerr << "\n" << "ERROR: " << e.what() << endl;

        exit (1);

    }

    MultiPartOutputFile out (outname, &headers[0], headers.size(), override);

    for (size_t p = 0 ; p < partnums.size();p++)

    {

        std::string type = headers[p].type();

        if (type == SCANLINEIMAGE)

        {

            cout << "part " << p << ": "<< "scanlineimage" << endl;

            copy_scanline (*inputs[p], out, partnums[p], p);

        }

        else if (type == TILEDIMAGE)

        {

            cout << "part " << p << ": "<< "tiledimage" << endl;

            copy_tile (*inputs[p], out, partnums[p], p);

        }

        else if (type == DEEPSCANLINE)

        {

            cout << "part " << p << ": "<< "deepscanlineimage" << endl;

            copy_scanlinedeep (*inputs[p], out, partnums[p], p);

        }

        else if (type == DEEPTILE)

        {

            cout << "part " << p << ": "<< "deeptile" << endl;

            copy_tiledeep (*inputs[p], out, partnums[p], p);

        }

    }

    for (size_t k = 0; k < fordelete.size(); k++)

    {

        delete fordelete[k];

    }

    inputs.clear();

    fordelete.size();

    cout << "\n" << "Combine Success" << endl;

}

void

separate (vector <const char*> in, const char* out, bool override)

{

    if (in.size() > 1)

    {

        cerr << "ERROR: -separate only take one input file\n"

        "syntax: exrmultipart -separate -i infile.exr -o outfileBaseName\n";

        exit (1);

    }

    //

    // parse the multipart input

    //

    string filename (in[0]);

    MultiPartInputFile *inputimage;

    int numOutputs;

    vector<string> fornamecheck;

    // add check for existance of the file

    try

    {

        MultiPartInputFile temp (filename.c_str());

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        cerr << "\n" << "ERROR: " << e.what() << endl;

        exit (1);

    }

    inputimage = new MultiPartInputFile (filename.c_str());

    numOutputs = inputimage->parts();

    cout << "numOutputs: " << numOutputs << endl;

    //

    // set outputs names

    //

    for (int p = 0 ; p 

    {

        string outfilename (out);

        //add number to outfilename

        std::ostringstream oss;

        oss << '.' << p + 1;

        outfilename += oss.str();

        outfilename += ".exr";

        cout << "outputfilename: " << outfilename << endl;

        fornamecheck.push_back (outfilename);

    }

    filename_check (fornamecheck, in[0]);

    //

    // separate outputs

    //

    for (int p = 0 ; p < numOutputs; p++)

    {

        Header header = inputimage->header (p);

        MultiPartOutputFile out (fornamecheck[p].c_str(), &header, 1, override);

        std::string type = header.type();

        if (type == "scanlineimage")

        {

            cout << "scanlineimage" << endl;

            copy_scanline (*inputimage, out, p, 0);

        }

        else if (type == "tiledimage")

        {

            cout << "tiledimage" << endl;

            copy_tile (*inputimage, out, p, 0);

        }

        else if (type == "deepscanline")

        {

            cout << "deepscanline" << endl;

            copy_scanlinedeep (*inputimage, out, p, 0);

        }

        else if (type == "deeptile")

        {

            cout << "deeptile" << endl;

            copy_tiledeep (*inputimage, out, p, 0);

        }

    }

    delete inputimage;

    cout << "\n" << "Seperate Success" << endl;

}

void

usageMessage (const char argv[])

{

    cout << argv << " handles the combining and splitting of multipart data\n";

    cout << "\n" << "Usage: "

            "exrmultipart -combine -i input.exr[:partnum][::partname] "

            "[input2.exr[:partnum]][::partname] [...] -o outfile.exr [options]\n";

    cout << "   or: exrmultipart -separate -i infile.exr -o outfileBaseName "

            "[options]\n";

    cout << "   or: exrmultipart -convert -i infile.exr -o outfile.exr "

            "[options]\n";

            cout << "\n" << "Options:\n";

    cout << "-override [0/1]      0-do not override conflicting shared "

            "attributes [default]\n"

            "                     1-override conflicting shared attributes\n";

    cout << "-view name           (after specifying -i) "

            "assign following inputs to view 'name'\n";

    exit (1);

}

int

main (int argc, char * argv[])

{

    if (argc < 6)

    {

        usageMessage (argv[0]);

    }

    vector <const char*> inFiles;

    vector <const char*> views;

    const char* view = 0;

    const char *outFile = 0;

    bool override = false;

    int i = 1;

    int mode = 0; // 0-do not read input, 1-infiles, 2-outfile, 3-override, 4-view

    while (i < argc)

    {

        if (!strcmp (argv[i], "-h"))

        {

            usageMessage (argv[0]);

        }

        if (!strcmp (argv[i], "-i"))

        {

            mode = 1;

        }

        else if (!strcmp (argv[i], "-o"))

        {

            mode = 2;

        }

        else if (!strcmp (argv[i], "-override"))

        {

            mode = 3;

        }

        else if (!strcmp (argv[i], "-view"))

        {

            if(mode !=1 )

            {

                usageMessage (argv[0]);

                return 1;

            }

            mode = 4;

        }

        else

        {

            switch (mode)

            {

                case 1:

                    inFiles.push_back (argv[i]);

                    views.push_back (view);

                    break;

                case 2: outFile = argv[i];

                    break;

                case 3: override = atoi (argv[i]);

                    break;

                case 4: view = argv[i];

                    mode=1;

                    break;

            }

        }

        i++;

    }

    // check input and output files found or not

    if (inFiles.size() == 0)

    {

        cerr << "\n" << "ERROR: found no input files" << endl;

        exit (1);

    }

    cout << "input:" << endl;

    for (size_t i = 0; i < inFiles.size(); i++)

    {

        cout << "      " << inFiles[i];

        if(views[i]) cout << " in view " << views[i];

        cout << endl;

    }

    if (!outFile)

    {

        cerr << "\n"<<"ERROR: found no output file" << endl;

        exit (1);

    }

    cout << "output:\n      " << outFile << endl;

    cout << "override:" << override << "\n" << endl;

    if (!strcmp (argv[1], "-combine"))

    {

        cout << "-combine multipart input " << endl;

        combine (inFiles, views, outFile, override);

    }

    else if (!strcmp(argv[1], "-separate"))

    {

        cout << "-separate multipart input " << endl;

        separate (inFiles, outFile, override);

    }

    else if(!strcmp(argv[1],"-convert"))

    {

        cout << "-convert input to EXR2 multipart" << endl;

        convert (inFiles, views, outFile, override);

    }

    else

    {

        usageMessage (argv[0]);

    }

    return 0;

}