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

//

// Copyright (c) 2012, 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.

//

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

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

//

//	Produce a tiled version of an OpenEXR image.

//

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

#include "makeTiled.h"

#include "Image.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 "ImfChannelList.h"

#include "ImfChannelList.h"

#include "ImfFrameBuffer.h"

#include "ImfStandardAttributes.h"

#include "ImathFun.h"

#include "Iex.h"

#include "ImfMisc.h"

#include <map>

#include <algorithm>

#include <iostream>

#include <vector>

#include "namespaceAlias.h"

using namespace IMF;

using namespace IMATH_NAMESPACE;

using namespace std;

namespace {

string

extToString (Extrapolation ext)

{

    string str;

    switch (ext)

    {

        case BLACK:

            str = "black";

            break;

        case CLAMP:

            str = "clamp";

            break;

        case PERIODIC:

            str = "periodic";

            break;

        case MIRROR:

            str = "mirror";

            break;

    }

    return str;

}

int

mirror (int x, int w)

{

    int d = divp (x, w);

    int m = modp (x, w);

    return (d & 1)? w - 1 - m: m;

}

template <class T>

double

sampleX (const TypedImageChannel<T> &channel,

         int w,

         double x,

         int y,

         Extrapolation ext)

{

    //

    // Sample an image channel at location (x, y), where

    // x is a floating point number, and y is an integer.

    //

    int xs = IMATH_NAMESPACE::floor (x);

    int xt = xs + 1;

    double s = xt - x;

    double t = 1 - s;

    double vs=0.0;

    double vt=0.0;

    switch (ext)

    {

        case BLACK:

            vs = (xs >= 0 && xs < w)? double (channel (xs, y)): 0.0;

            vt = (xt >= 0 && xt < w)? double (channel (xt, y)): 0.0;

            break;

        case CLAMP:

            xs = clamp (xs, 0, w - 1);

            xt = clamp (xt, 0, w - 1);

            vs = channel (xs, y);

            vt = channel (xt, y);

            break;

        case PERIODIC:

            xs = modp (xs, w);

            xt = modp (xt, w);

            vs = channel (xs, y);

            vt = channel (xt, y);

            break;

        case MIRROR:

            xs = mirror (xs, w);

            xt = mirror (xt, w);

            vs = channel (xs, y);

            vt = channel (xt, y);

            break;

    }

    return s * vs + t * vt;

}

template <class T>

double

sampleY (const TypedImageChannel<T> &channel,

         int h,

         int x,

         double y,

         Extrapolation ext)

{

    //

    // Sample an image channel at location (x, y), where

    // x is an integer, and y is a floating point number.

    //

    int ys = IMATH_NAMESPACE::floor (y);

    int yt = ys + 1;

    double s = yt - y;

    double t = 1 - s;

    double vs=0.0;

    double vt=0.0;

    switch (ext)

    {

        case BLACK:

            vs = (ys >= 0 && ys < h)? double (channel (x, ys)): 0.0;

            vt = (yt >= 0 && yt < h)? double (channel (x, yt)): 0.0;

            break;

        case CLAMP:

            ys = clamp (ys, 0, h - 1);

            yt = clamp (yt, 0, h - 1);

            vs = channel (x, ys);

            vt = channel (x, yt);

            break;

        case PERIODIC:

            ys = modp (ys, h);

            yt = modp (yt, h);

            vs = channel (x, ys);

            vt = channel (x, yt);

            break;

        case MIRROR:

            ys = mirror (ys, h);

            yt = mirror (yt, h);

            vs = channel (x, ys);

            vt = channel (x, yt);

            break;

    }

    return s * vs + t * vt;

}

template <class T>

T

filterX (const TypedImageChannel<T> &channel,

         int w,

         double x,

         int y,

         Extrapolation ext)

{

    //

    // Horizontal four-tap filter, centered on pixel (x + 0.5, y)

    //

    return T (0.125 * sampleX (channel, w, x - 1, y, ext) +

              0.375 * sampleX (channel, w, x,     y, ext) +

              0.375 * sampleX (channel, w, x + 1, y, ext) +

              0.125 * sampleX (channel, w, x + 2, y, ext));

}

template <class T>

T

filterY (const TypedImageChannel<T> &channel,

         int h,

         int x,

         double y,

         Extrapolation ext)

{

    //

    // Vertical four-tap filter, centered on pixel (x, y + 0.5)

    //

    return T (0.125 * sampleY (channel, h, x, y - 1, ext) +

              0.375 * sampleY (channel, h, x, y,     ext) +

              0.375 * sampleY (channel, h, x, y + 1, ext) +

              0.125 * sampleY (channel, h, x, y + 2, ext));

}

template <class T>

void

reduceX (const TypedImageChannel<T> &channel0,

         TypedImageChannel<T> &channel1,

         bool filter,

         Extrapolation &ext,

         bool odd)

{

    //

    // Shrink an image channel, channel0, horizontally

    // by a factor of 2, and store the result in channel1.

    //

    int w0 = channel0.image().width();

    int w1 = channel1.image().width();

    int h1 = channel1.image().height();

    if (filter)

    {

        //

        // Low-pass filter and resample.

        // For pixels (0, y) and (w1 - 1, y) in channel 1,

        // the low-pass filter in channel0 is centered on

        // pixels (0.5, y) and (w0 - 1.5, y) respectively.

        //

        double f = (w1 > 1)? double (w0 - 2) / (w1 - 1): 1;

        for (int y = 0; y < h1; ++y)

            for (int x = 0; x < w1; ++x)

                channel1 (x, y) = filterX (channel0, w0, x * f, y, ext);

    }

    else

    {

        //

        // Resample, skipping every other pixel, without

        // low-pass filtering.  In order to keep the image

        // from sliding to the right if the channel is

        // resampled repeatedly, we skip the rightmost

        // pixel of every row on even passes, and the

        // leftmost pixel on odd passes.

        //

        int offset = odd? ((w0 - 1) - 2 * (w1 - 1)): 0;

        for (int y = 0; y < h1; ++y)

            for (int x = 0; x < w1; ++x)

                channel1 (x, y) = channel0 (2 * x + offset, y);

    }

}

template <class T>

void

reduceY (const TypedImageChannel<T> &channel0,

         TypedImageChannel<T> &channel1,

         bool filter,

         Extrapolation ext,

         bool odd)

{

    //

    // Shrink an image channel, channel0, vertically

    // by a factor of 2, and store the result in channel1.

    //

    int w1 = channel1.image().width();

    int h0 = channel0.image().height();

    int h1 = channel1.image().height();

    if (filter)

    {

        //

        // Low-pass filter and resample.

        // For pixels (x, 0) and (x, h1 - 1) in channel 1,

        // the low-pass filter in channel0 is centered on

        // pixels (x, 0.5) and (x, h0 - 1.5) respectively.

        //

        double f = (h1 > 1)? double (h0 - 2) / (h1 - 1): 1;

        for (int y = 0; y < h1; ++y)

            for (int x = 0; x < w1; ++x)

                channel1 (x, y) = filterY (channel0, h0, x, y * f, ext);

    }

    else

    {

        //

        // Resample, skipping every other pixel, without

        // low-pass filtering.  In order to keep the image

        // from sliding towards the top if the channel is

        // resampled repeatedly, we skip the top pixel of

        // every column on even passes, and the bottom pixel

        // on odd passes.

        //

        int offset = odd? ((h0 - 1) - 2 * (h1 - 1)): 0;

        for (int y = 0; y < h1; ++y)

            for (int x = 0; x < w1; ++x)

                channel1 (x, y) = channel0 (x, 2 * y + offset);

    }

}

void

reduceX (const ChannelList &channels,

         const set<string> &doNotFilter,

         Extrapolation ext,

         bool odd,

         const Image &image0,

         Image &image1)

{

    //

    // Shrink image image0 horizontally by a factor of 2,

    // and store the result in image image1.

    //

    for (ChannelList::ConstIterator i = channels.begin();

         i != channels.end();

         ++i)

    {

        const char *name = i.name();

        const Channel &channel = i.channel();

        bool filter = (doNotFilter.find (name) == doNotFilter.end());

        switch (channel.type)

        {

            case IMF::HALF:

                reduceX (image0.typedChannel<half> (name),

                         image1.typedChannel<half> (name),

                         filter, ext, odd);

                break;

            case IMF::FLOAT:

                reduceX (image0.typedChannel<float> (name),

                         image1.typedChannel<float> (name),

                         filter, ext, odd);

                break;

            case IMF::UINT:

                reduceX (image0.typedChannel<unsigned int> (name),

                         image1.typedChannel<unsigned int> (name),

                         filter, ext, odd);

                break;

            default : 

                break;

        }

    }

}

void

reduceY (const ChannelList &channels,

         const set<string> &doNotFilter,

         Extrapolation ext,

         bool odd,

         const Image &image0,

         Image &image1)

{

    //

    // Shrink image image0 vertically by a factor of 2,

    // and store the result in image image1.

    //

    for (ChannelList::ConstIterator i = channels.begin();

         i != channels.end();

         ++i)

    {

        const char *name = i.name();

        const Channel &channel = i.channel();

        bool filter = (doNotFilter.find (name) == doNotFilter.end());

        switch (channel.type)

        {

            case IMF::HALF:

                reduceY (image0.typedChannel<half> (name),

                         image1.typedChannel<half> (name),

                         filter, ext, odd);

                break;

            case IMF::FLOAT:

                reduceY (image0.typedChannel<float> (name),

                         image1.typedChannel<float> (name),

                         filter, ext, odd);

                break;

            case IMF::UINT:

                reduceY (image0.typedChannel<unsigned int> (name),

                         image1.typedChannel<unsigned int> (name),

                         filter, ext, odd);

                break;

            default : 

                break;

        }

    }

}

void

storeLevel (TiledOutputPart &out,

            const ChannelList &channels,

            int lx,

            int ly,

            const Image &image)

{

    //

    // Store the pixels for level (lx, ly) in output file out.

    //

    FrameBuffer fb;

    for (ChannelList::ConstIterator i = channels.begin();

         i != channels.end();

         ++i)

    {

        const char *name = i.name();

        fb.insert (name, image.channel(name).slice());

    }

    out.setFrameBuffer (fb);

    for (int y = 0; y < out.numYTiles (ly); ++y)

        for (int x = 0; x < out.numXTiles (lx); ++x)

            out.writeTile (x, y, lx, ly);

}

} // namespace

void

makeTiled (const char inFileName[],

           const char outFileName[],

           int partnum,

           LevelMode mode,

           LevelRoundingMode roundingMode,

           Compression compression,

           int tileSizeX,

           int tileSizeY,

           const set<string> &doNotFilter,

           Extrapolation extX,

           Extrapolation extY,

           bool verbose)

{

    Image image0;

    Image image1;

    Image image2;

    Header header;

    FrameBuffer fb;

    vector<Header> headers;

    //

    // Load the input image

    //

    MultiPartInputFile input (inFileName);

    int parts = input.parts();

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

    {

        if (verbose)

            cout << "reading file " << inFileName << endl;

        if(p == partnum)

        {

            InputPart in (input, p);

            header = in.header();

            if (hasEnvmap (header) && mode != ONE_LEVEL)

            {

                //

                // Proper low-pass filtering and subsampling

                // of environment maps is not implemented in

                // this program.

                //

                throw IEX_NAMESPACE::NoImplExc ("This program cannot generate "

                                      "multiresolution environment maps.  "

                                      "Use exrenvmap instead.");

            }

            image0.resize (header.dataWindow());

            for (ChannelList::ConstIterator i = header.channels().begin();

                            i != header.channels().end();

                            ++i)

            {

                const char *name = i.name();

                const Channel &channel = i.channel();

                if (channel.xSampling != 1 || channel.ySampling != 1)

                {

                    throw IEX_NAMESPACE::InputExc ("Sub-sampled image channels are "

                                         "not supported in tiled files.");

                }

                image0.addChannel (name, channel.type);

                image1.addChannel (name, channel.type);

                image2.addChannel (name, channel.type);

                fb.insert (name, image0.channel(name).slice());

            }

            in.setFrameBuffer (fb);

            in.readPixels (header.dataWindow().min.y, header.dataWindow().max.y);

            //

            // Generate the header for the output file by modifying

            // the input file's header

            //

            header.setTileDescription (TileDescription (tileSizeX, tileSizeY,

                                                        mode, roundingMode));

            header.compression() = compression;

            header.lineOrder() = INCREASING_Y;

            if (mode != ONE_LEVEL)

                addWrapmodes (header, extToString (extX) + "," + extToString (extY));

            //

            // set tileDescription, type, and chunckcount for multipart

            //

            header.setType(TILEDIMAGE);

            int chunkcount = getChunkOffsetTableSize(header, true);

            header.setChunkCount(chunkcount);

            headers.push_back(header);

        }

        else

        {

            Header h = input.header(p);

            headers.push_back(h);

        }

    }

    //

    // Store the highest-resolution level of the image in the output file

    //

    MultiPartOutputFile output (outFileName, &headers[0], headers.size());

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

    {

        if (p == partnum)

        {

            try

            {

                TiledOutputPart out (output, partnum);

            //    TiledOutputFile out (outFileName, header);

                out.setFrameBuffer (fb);

                if (verbose)

                    cout << "writing file " << outFileName << "\n"

                            "level (0, 0)" << endl;

                for (int y = 0; y < out.numYTiles (0); ++y)

                    for (int x = 0; x < out.numXTiles (0); ++x)

                        out.writeTile (x, y, 0);

                //

                // If necessary, generate the lower-resolution mipmap

                // or ripmap levels, and store them in the output file.

                //

                if (mode == MIPMAP_LEVELS)

                {

                    for (int l = 1; l < out.numLevels(); ++l)

                    {

                        image1.resize (out.dataWindowForLevel (l, l - 1));

                        reduceX (header.channels(),

                                 doNotFilter,

                                 extX,

                                 l & 1,

                                 image0,

                                 image1);

                        image0.resize (out.dataWindowForLevel (l, l));

                        reduceY (header.channels(),

                                 doNotFilter,

                                 extY,

                                 l & 1,

                                 image1,

                                 image0);

                        if (verbose)

                            cout << "level (" << l << ", " << l << ")" << endl;

                        storeLevel (out, header.channels(), l, l, image0);

                    }

                }

                if (mode == RIPMAP_LEVELS)

                {

                    Image *iptr0 = &image0;

                    Image *iptr1 = &image1;

                    Image *iptr2 = &image2;

                    for (int ly = 0; ly < out.numYLevels(); ++ly)

                    {

                        if (ly < out.numYLevels() - 1)

                        {

                            iptr2->resize (out.dataWindowForLevel (0, ly + 1));

                            reduceY (header.channels(),

                                     doNotFilter,

                                     extY,

                                     ly & 1,

                                     *iptr0,

                                     *iptr2);

                        }

                        for (int lx = 0; lx < out.numXLevels(); ++lx)

                        {

                            if (lx != 0 || ly != 0)

                            {

                                if (verbose)

                                    cout << "level (" << lx << ", " << ly << ")" << endl;

                                storeLevel (out, header.channels(), lx, ly, *iptr0);

                            }

                            if (lx < out.numXLevels() - 1)

                            {

                                iptr1->resize (out.dataWindowForLevel (lx + 1, ly));

                                reduceX (header.channels(),

                                         doNotFilter,

                                         extX,

                                         lx & 1,

                                         *iptr0,

                                         *iptr1);

                                swap (iptr0, iptr1);

                            }

                        }

                        swap (iptr2, iptr0);

                    }

                }

            }

            catch (const exception &e)

            {

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

            }

        }

        else

        {

            Header header = headers[p];

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

            if (type == TILEDIMAGE)

            {

                TiledInputPart in (input, p);

                TiledOutputPart out (output, p);

                out.copyPixels (in);

            }

            else if (type == SCANLINEIMAGE)

            {

                using std::max;  InputPart in (input, p);

                OutputPart out (output, p);

                out.copyPixels (in);

            }

            else if (type == DEEPSCANLINE)

            {

                DeepScanLineInputPart in (input,p);

                DeepScanLineOutputPart out (output,p);

                out.copyPixels (in);

            }

            else if (type == DEEPTILE)

            {

                DeepTiledInputPart in (input,p);

                DeepTiledOutputPart out (output,p);

                out.copyPixels (in);

            }

        }

    }

    if (verbose)

	cout << "done." << endl;

}