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



//-----------------------------------------------------------------------------
//
//	Code examples that show how to add preview images
//	(also known as thumbnais) to OpenEXR image files.
//
//-----------------------------------------------------------------------------


#include <ImfRgbaFile.h>
#include <ImfArray.h>
#include <ImfPreviewImage.h>
#include <ImathFun.h>
#include <drawImage.h>

#include <iostream>

using namespace std;
using namespace Imf;
using namespace Imath;


unsigned char
gamma (float x)
{
    //
    // Convert a floating-point pixel value to an 8-bit gamma-2.2
    // preview pixel.  (This routine is a simplified version of
    // how the exrdisplay program transforms floating-point pixel
    // values in order to display them on the screen.)
    //

    x = pow (5.5555f * max (0.f, x), 0.4545f) * 84.66f;
    return (unsigned char) clamp (x, 0.f, 255.f);
}


void
makePreviewImage (const Array2D <Rgba> &pixels,
		  int width,
		  int height,
		  Array2D <PreviewRgba> &previewPixels,
		  int &previewWidth,
		  int &previewHeight)
{
    const int N = 8;

    previewWidth  = width / N;
    previewHeight = height / N;
    previewPixels.resizeErase (previewHeight, previewWidth);

    for (int y = 0; y < previewHeight; ++y)
    {
	for (int x = 0; x < previewWidth; ++x)
	{
	    const Rgba  &inPixel = pixels[y * N][x * N];
	    PreviewRgba &outPixel = previewPixels[y][x];

	    outPixel.r = gamma (inPixel.r);
	    outPixel.g = gamma (inPixel.g);
	    outPixel.b = gamma (inPixel.b);
	    outPixel.a = int (clamp (inPixel.a * 255.f, 0.f, 255.f) + 0.5f);
	}
    }
}


void
writeRgbaWithPreview1 (const char fileName[],
		       const Array2D <Rgba> &pixels,
		       int width,
		       int height)
{
    //
    // Write an image file with a preview image, version 1:
    //
    // - generate the preview image by subsampling the main image
    // - generate a file header
    // - add the preview image to the file header
    // - open the file (this stores the header with the
    //   preview image in the file)
    // - describe the memory layout of the main image's pixels
    // - store the main image's pixels in the file
    //

    Array2D <PreviewRgba> previewPixels;
    int previewWidth;
    int previewHeight;

    makePreviewImage (pixels, width, height,
		      previewPixels, previewWidth, previewHeight);

    Header header (width, height);

    header.setPreviewImage
	(PreviewImage (previewWidth, previewHeight, &previewPixels[0][0]));

    RgbaOutputFile file (fileName, header, WRITE_RGBA);
    file.setFrameBuffer (&pixels[0][0], 1, width);
    file.writePixels (height);
}


void
writeRgbaWithPreview2 (const char fileName[],
		       int width,
		       int height)
{
    //
    // Write an image file with a preview image, version 2:
    //
    // - generate a file header
    // - add a dummy preview image to the file header
    // - open the file (this stores the header with the dummy
    //   preview image in the file)
    // - render the main image's pixels one scan line at a time,
    //   and store each scan line in the file before rendering
    //   the next scan line
    // - generate the preview image on the fly, while the main
    //   image is being rendered
    // - once the main image has been rendered, store the preview
    //   image in the file, overwriting the dummy preview
    //   

    Array <Rgba> pixels (width);

    const int N = 8;

    int previewWidth = width / N;
    int previewHeight = height / N;
    Array2D <PreviewRgba> previewPixels (previewHeight, previewWidth);

    Header header (width, height);
    header.setPreviewImage (PreviewImage (previewWidth, previewHeight));

    RgbaOutputFile file (fileName, header, WRITE_RGBA);
    file.setFrameBuffer (pixels, 1, 0);

    for (int y = 0; y < height; ++y)
    {
	drawImage7 (pixels, width, height, y);
	file.writePixels (1);

	if (y % N == 0)
	{
	    for (int x = 0; x < width; x += N)
	    {
		const Rgba  &inPixel = pixels[x];
		PreviewRgba &outPixel = previewPixels[y / N][x / N];

		outPixel.r = gamma (inPixel.r);
		outPixel.g = gamma (inPixel.g);
		outPixel.b = gamma (inPixel.b);
		outPixel.a = int (clamp (inPixel.a * 255.f, 0.f, 255.f) + 0.5f);
	    }
	}
    }

    file.updatePreviewImage (&previewPixels[0][0]);
}


void
previewImageExamples ()
{
    cout << "\nfiles with preview images\n" << endl;

    cout << "drawing image then writing file" << endl;

    int w = 800;
    int h = 600;

    Array2D<Rgba> p (h, w);
    drawImage1 (p, w, h);
    writeRgbaWithPreview1 ("rgbaWithPreview1.exr", p, w, h);

    cout << "drawing image while writing file" << endl;

    writeRgbaWithPreview2 ("rgbaWithPreview2.exr", w, h);

    cout << endl;
}
