///////////////////////////////////////////////////////////////////////////
//
// 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<samples;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<chans;i++)
{
PixelType type = pt==NULL ? IMF::HALF : pt[i];
if (i<activechans && writing)
{
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<activechans)
{
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;
}