1499 lines
47 KiB
C++
1499 lines
47 KiB
C++
|
///////////////////////////////////////////////////////////////////////////
|
|||
|
|
//
|
|||
|
|
// Copyright (c) 2006, 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.
|
|||
|
|
//
|
|||
|
|
///////////////////////////////////////////////////////////////////////////
|
|||
|
|
|
|||
|
|
//----------------------------------------------------------------------------
|
|||
|
|
//
|
|||
|
|
// Play an OpenEXR image sequence.
|
|||
|
|
//
|
|||
|
|
// This is the display thread of the playExr program.
|
|||
|
|
// It does the following:
|
|||
|
|
//
|
|||
|
|
// * Reads the first frame in the image sequence to find out how
|
|||
|
|
// big the images are and what channels they contain.
|
|||
|
|
//
|
|||
|
|
// * Allocates a ring buffer for receiving images from the file
|
|||
|
|
// file reading thread.
|
|||
|
|
//
|
|||
|
|
// * Creates an OpenGL window for displaying the images.
|
|||
|
|
//
|
|||
|
|
// * Launches a file reading thread, which reads the frames in
|
|||
|
|
// the image sequence and passes them to the display thread.
|
|||
|
|
//
|
|||
|
|
// * Enters an infinite loop: get the next frame from the
|
|||
|
|
// ring buffer, display the frame.
|
|||
|
|
//
|
|||
|
|
//----------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
#include "playExr.h"
|
|||
|
|
#include "ctlToLut.h"
|
|||
|
|
#include "fileNameForFrame.h"
|
|||
|
|
#include "FileReadingThread.h"
|
|||
|
|
#include "osDependent.h"
|
|||
|
|
#include "ImageBuffers.h"
|
|||
|
|
#include "Timer.h"
|
|||
|
|
#include <ImfThreading.h>
|
|||
|
|
#include <ImfInputFile.h>
|
|||
|
|
#include <ImfChannelList.h>
|
|||
|
|
#include <ImfStandardAttributes.h>
|
|||
|
|
#include <ImfRgbaYca.h>
|
|||
|
|
#include <ImfArray.h>
|
|||
|
|
|
|||
|
|
#include <half.h>
|
|||
|
|
#include <stdlib.h>
|
|||
|
|
#include <sstream>
|
|||
|
|
#include <iomanip>
|
|||
|
|
#include <cmath>
|
|||
|
|
|
|||
|
|
|
|||
|
|
using namespace OPENEXR_IMF_NAMESPACE;
|
|||
|
|
using namespace IMATH_NAMESPACE;
|
|||
|
|
using namespace std;
|
|||
|
|
using namespace ILMTHREAD_NAMESPACE;
|
|||
|
|
|
|||
|
|
namespace {
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Static variables.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
ImageBuffers ib; // Ring buffer; transports frames from
|
|||
|
|
// the file reading thread to the display
|
|||
|
|
// thread.
|
|||
|
|
|
|||
|
|
int i = 0; // Index of current frame buffer
|
|||
|
|
|
|||
|
|
int frameNumber = 0; // Frame number of current frame
|
|||
|
|
|
|||
|
|
int firstFrameNumber = 0; // Frame number of first and last frame
|
|||
|
|
int lastFrameNumber = 0; // in the sequence
|
|||
|
|
|
|||
|
|
Timer timer; // Timing control
|
|||
|
|
|
|||
|
|
GLuint texId[3]; // For display, a frame's three image channels
|
|||
|
|
// are converted to OpenGL textures, eigher
|
|||
|
|
// one three-channel texture or three one-
|
|||
|
|
// channel textures. texId contains the
|
|||
|
|
// names by which OpenGL refers to those
|
|||
|
|
// textures.
|
|||
|
|
|
|||
|
|
int glWindowWidth = 0; // Preferred width and height of the on-screen
|
|||
|
|
int glWindowHeight = 0; // window where the images will be displayed
|
|||
|
|
|
|||
|
|
Box2i drawRect; // The size and location of the images' data
|
|||
|
|
// window relative to the on-screen window.
|
|||
|
|
|
|||
|
|
V3f yWeights (1, 1, 1); // Weights for converting the pixels in
|
|||
|
|
// luminance chroma channels to RGB,
|
|||
|
|
// computed from the chromaticities of
|
|||
|
|
// the frames' primaries and white point
|
|||
|
|
|
|||
|
|
float exposure = 0; // Current exposure setting. All pixels
|
|||
|
|
// are multiplied by pow(2,exposure) before
|
|||
|
|
// they appear on the screen
|
|||
|
|
|
|||
|
|
bool enableCtl = true; // If enableCtl is true, CTL transforms
|
|||
|
|
// are applied to the pixels after exposure
|
|||
|
|
// has been applied. If enableCtl is false,
|
|||
|
|
// no CTL transforms are applied.
|
|||
|
|
|
|||
|
|
const size_t lutN = 64; // The 3D color lookup table that is used
|
|||
|
|
// to approximate the CTL transforms has
|
|||
|
|
// lutN by lutN by lutN entries.
|
|||
|
|
|
|||
|
|
bool hwTexInterpolation = true; // Flag that controls whether the Cg shader
|
|||
|
|
// that performs 3D color table lookups
|
|||
|
|
// relies on hardware-interpolated texture
|
|||
|
|
// lookups or if the shader itself interpolates
|
|||
|
|
// between texture samples
|
|||
|
|
|
|||
|
|
bool showTextOverlay = true; // Flag that controls whether the actual
|
|||
|
|
// frame rate and the current exposure
|
|||
|
|
// setting are displayed
|
|||
|
|
|
|||
|
|
bool fullScreenMode = false; // Flag that controls whether the images
|
|||
|
|
// are displayed in full-screen mode or not
|
|||
|
|
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Initialization of the ring buffer, ib.
|
|||
|
|
// We allocate space for the pixels of ib.numBuffers() frames,
|
|||
|
|
// and we initialize Imf::FrameBuffer objects that allow the
|
|||
|
|
// the file reading thread to fill the pixel buffers.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
char *
|
|||
|
|
addSlice
|
|||
|
|
(FrameBuffer &fb,
|
|||
|
|
const Box2i &dw,
|
|||
|
|
const char name[],
|
|||
|
|
int xSampling,
|
|||
|
|
int ySampling)
|
|||
|
|
{
|
|||
|
|
int w = dw.max.x - dw.min.x + 1;
|
|||
|
|
int h = dw.max.y - dw.min.y + 1;
|
|||
|
|
size_t pixelSize = sizeof (half);
|
|||
|
|
size_t lineSize = pixelSize * (w / xSampling);
|
|||
|
|
size_t numLines = h / ySampling;
|
|||
|
|
|
|||
|
|
char *pixels = new char [lineSize * numLines];
|
|||
|
|
|
|||
|
|
fb.insert (name,
|
|||
|
|
Slice (HALF,
|
|||
|
|
pixels - (dw.min.y / ySampling) * lineSize -
|
|||
|
|
(dw.min.x / xSampling) * pixelSize,
|
|||
|
|
pixelSize,
|
|||
|
|
lineSize,
|
|||
|
|
xSampling,
|
|||
|
|
ySampling));
|
|||
|
|
|
|||
|
|
return pixels;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
initializeImageBuffers
|
|||
|
|
(ImageBuffers &ib,
|
|||
|
|
Header &header,
|
|||
|
|
const char fileNameTemplate[])
|
|||
|
|
{
|
|||
|
|
InputFile
|
|||
|
|
in (fileNameForFrame (fileNameTemplate, firstFrameNumber).c_str());
|
|||
|
|
|
|||
|
|
header = in.header();
|
|||
|
|
|
|||
|
|
const ChannelList &ch = in.header().channels();
|
|||
|
|
const Box2i &dw = in.header().dataWindow();
|
|||
|
|
|
|||
|
|
ib.dataWindow = dw;
|
|||
|
|
|
|||
|
|
if (ch.findChannel ("Y") || ch.findChannel ("RY") || ch.findChannel ("BY"))
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Luminance/chroma mode
|
|||
|
|
//
|
|||
|
|
// The image channels go into three separate pixel buffers.
|
|||
|
|
// The buffer for the luminance channel has the same width and
|
|||
|
|
// height as the frame. The buffers for the two chroma channels
|
|||
|
|
// have half the width and half the height of the frame.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
ib.rgbMode = false;
|
|||
|
|
|
|||
|
|
for (int i = 0; i < ib.numBuffers(); ++i)
|
|||
|
|
{
|
|||
|
|
FrameBuffer &fb = ib.frameBuffer (i);
|
|||
|
|
ib.pixels (i, 0) = addSlice (fb, dw, "Y", 1, 1);
|
|||
|
|
ib.pixels (i, 1) = addSlice (fb, dw, "RY", 2, 2);
|
|||
|
|
ib.pixels (i, 2) = addSlice (fb, dw, "BY", 2, 2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Chromaticities chroma;
|
|||
|
|
|
|||
|
|
if (hasChromaticities (in.header()))
|
|||
|
|
chroma = chromaticities (in.header());
|
|||
|
|
|
|||
|
|
yWeights = RgbaYca::computeYw (chroma);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// RGB mode
|
|||
|
|
//
|
|||
|
|
// The pixel buffers for the tree image channels (RGB)
|
|||
|
|
// are padded with a fourth dummy channel (A) and interleaved
|
|||
|
|
// (RGBARGBARGBA...). All three buffers have the same width
|
|||
|
|
// and height as the frame.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
ib.rgbMode = true;
|
|||
|
|
|
|||
|
|
for (int i = 0; i < ib.numBuffers(); ++i)
|
|||
|
|
{
|
|||
|
|
FrameBuffer &fb = ib.frameBuffer (i);
|
|||
|
|
|
|||
|
|
int w = dw.max.x - dw.min.x + 1;
|
|||
|
|
int h = dw.max.y - dw.min.y + 1;
|
|||
|
|
size_t pixelSize = sizeof (half) * 4;
|
|||
|
|
size_t lineSize = pixelSize * w;
|
|||
|
|
|
|||
|
|
char *pixels = new char [lineSize * h];
|
|||
|
|
|
|||
|
|
ib.pixels (i, 0) = pixels;
|
|||
|
|
ib.pixels (i, 1) = pixels + sizeof (half);
|
|||
|
|
ib.pixels (i, 2) = pixels + sizeof (half) * 2;
|
|||
|
|
|
|||
|
|
fb.insert ("R",
|
|||
|
|
Slice (HALF,
|
|||
|
|
ib.pixels (i, 0) - dw.min.y * lineSize -
|
|||
|
|
dw.min.x * pixelSize,
|
|||
|
|
pixelSize,
|
|||
|
|
lineSize,
|
|||
|
|
1, 1));
|
|||
|
|
|
|||
|
|
fb.insert ("G",
|
|||
|
|
Slice (HALF,
|
|||
|
|
ib.pixels (i, 1) - dw.min.y * lineSize -
|
|||
|
|
dw.min.x * pixelSize,
|
|||
|
|
pixelSize,
|
|||
|
|
lineSize,
|
|||
|
|
1, 1));
|
|||
|
|
|
|||
|
|
fb.insert ("B",
|
|||
|
|
Slice (HALF,
|
|||
|
|
ib.pixels (i, 2) - dw.min.y * lineSize -
|
|||
|
|
dw.min.x * pixelSize,
|
|||
|
|
pixelSize,
|
|||
|
|
lineSize,
|
|||
|
|
1, 1));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Compute the size of the window on the screen where the image
|
|||
|
|
// sequence will be displayed, and the size and location of the
|
|||
|
|
// images within that window.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
computeWindowSizes
|
|||
|
|
(Box2i &dataWindow,
|
|||
|
|
Box2i &displayWindow,
|
|||
|
|
float pixelAspectRatio,
|
|||
|
|
float xyScale)
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Beginning with the data and display window of the first frame
|
|||
|
|
// in the image sequence, translate both windows so that the upper
|
|||
|
|
// left corner of the display window is at coordinates (0,0) in
|
|||
|
|
// OpenEXR's pixel space (with y going from top to bottom).
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
dataWindow.min -= displayWindow.min;
|
|||
|
|
dataWindow.max -= displayWindow.min;
|
|||
|
|
displayWindow.max -= displayWindow.min;
|
|||
|
|
displayWindow.min = V2i (0, 0);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// If the pixel aspect is not 1.0, stretch the display
|
|||
|
|
// and data window so that the pixels become square.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (pixelAspectRatio < 1.0)
|
|||
|
|
{
|
|||
|
|
dataWindow.min.y =
|
|||
|
|
int (floor (dataWindow.min.y / pixelAspectRatio + 0.5));
|
|||
|
|
|
|||
|
|
dataWindow.max.y =
|
|||
|
|
int (floor (dataWindow.max.y / pixelAspectRatio + 0.5));
|
|||
|
|
|
|||
|
|
displayWindow.max.y =
|
|||
|
|
int (floor (displayWindow.max.y / pixelAspectRatio + 0.5));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (pixelAspectRatio > 1.0)
|
|||
|
|
{
|
|||
|
|
dataWindow.min.x =
|
|||
|
|
int (floor (dataWindow.min.x * pixelAspectRatio + 0.5));
|
|||
|
|
|
|||
|
|
dataWindow.max.x =
|
|||
|
|
int (floor (dataWindow.max.x * pixelAspectRatio + 0.5));
|
|||
|
|
|
|||
|
|
displayWindow.max.x =
|
|||
|
|
int (floor (displayWindow.max.x * pixelAspectRatio + 0.5));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// The size of the OpenGL window on the screen is equal to the
|
|||
|
|
// size of the (possibly stretched) display window.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
glWindowWidth = displayWindow.max.x + 1;
|
|||
|
|
glWindowHeight = displayWindow.max.y + 1;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// The size and location of the image within the OpenGL window
|
|||
|
|
// is determined by the (possibly stretched) data window.
|
|||
|
|
// The data window must be transformed from OpenEXR pixel space
|
|||
|
|
// to OpenGL coordinates (with y going from bottom to top).
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
drawRect.min.x = dataWindow.min.x;
|
|||
|
|
drawRect.min.y = displayWindow.max.y - dataWindow.max.y;
|
|||
|
|
|
|||
|
|
drawRect.max.x = dataWindow.max.x + 1;
|
|||
|
|
drawRect.max.y = displayWindow.max.y - dataWindow.min.y + 1;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// The user may have requested that the images be
|
|||
|
|
// displayed smaller or larger than their original size.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
glWindowWidth = int (floor (glWindowWidth * xyScale + 0.5));
|
|||
|
|
glWindowHeight = int (floor (glWindowHeight * xyScale + 0.5));
|
|||
|
|
|
|||
|
|
drawRect.min.x = int (floor (drawRect.min.x * xyScale + 0.5));
|
|||
|
|
drawRect.min.y = int (floor (drawRect.min.y * xyScale + 0.5));
|
|||
|
|
drawRect.max.x = int (floor (drawRect.max.x * xyScale + 0.5));
|
|||
|
|
drawRect.max.y = int (floor (drawRect.max.y * xyScale + 0.5));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Cg shaders. For each frame, the drawFrame() function, below, draws
|
|||
|
|
// a big rectangle that fills the entire OpenGL window. The current
|
|||
|
|
// frame is stored in one or three textures; a Cg shader projects the
|
|||
|
|
// textures onto the rectangle, making the frame appear in the window.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
CGcontext cgContext;
|
|||
|
|
CGprogram cgProgram;
|
|||
|
|
CGprofile cgProfile;
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
handleCgErrors ()
|
|||
|
|
{
|
|||
|
|
cerr << cgGetErrorString (cgGetError()) << endl;
|
|||
|
|
cerr << cgGetLastListing (cgContext) << endl;
|
|||
|
|
exit (1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Shader for luminance/chroma images:
|
|||
|
|
// R, G and B are computed from the full-resolution Y (luminance)
|
|||
|
|
// channel and the half-resolution RY and BY (chroma) channels.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
const char shaderLuminanceChromaSource[] =
|
|||
|
|
" \n"
|
|||
|
|
" struct Out \n"
|
|||
|
|
" { \n"
|
|||
|
|
" half3 pixel: COLOR; \n"
|
|||
|
|
" }; \n"
|
|||
|
|
" \n"
|
|||
|
|
" Out \n"
|
|||
|
|
" main (float2 tc: TEXCOORD0, \n"
|
|||
|
|
" uniform sampler2D yImage: TEXUNIT0, \n"
|
|||
|
|
" uniform sampler2D ryImage: TEXUNIT1, \n"
|
|||
|
|
" uniform sampler2D byImage: TEXUNIT2, \n"
|
|||
|
|
" uniform sampler3D lut: TEXUNIT3, \n"
|
|||
|
|
" uniform float3 yw, \n"
|
|||
|
|
" uniform float expMult, \n"
|
|||
|
|
" uniform float videoGamma, \n"
|
|||
|
|
" uniform float lutMin, \n"
|
|||
|
|
" uniform float lutMax, \n"
|
|||
|
|
" uniform float lutM, \n"
|
|||
|
|
" uniform float lutT, \n"
|
|||
|
|
" uniform float lutF, \n"
|
|||
|
|
" uniform float enableLut) \n"
|
|||
|
|
" { \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Sample luminance and chroma, convert to RGB. \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" half Y = tex2D (yImage, tc).r; \n"
|
|||
|
|
" half RY = tex2D (ryImage, tc).r; \n"
|
|||
|
|
" half BY = tex2D (byImage, tc).r; \n"
|
|||
|
|
" \n"
|
|||
|
|
" float r = (RY + 1) * Y; \n"
|
|||
|
|
" float b = (BY + 1) * Y; \n"
|
|||
|
|
" float g = (Y - r * yw.x - b * yw.z) / yw.y; \n"
|
|||
|
|
" \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Apply exposure \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" half3 color = half3 (r, g, b) * expMult; \n"
|
|||
|
|
" \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Apply 3D color lookup table (in log space). \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" if (enableLut) \n"
|
|||
|
|
" { \n"
|
|||
|
|
" if (lutF) \n"
|
|||
|
|
" { \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Texture hardware does not support \n"
|
|||
|
|
" // interpolation between texture samples. \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" half3 i = lutF * half3 \n"
|
|||
|
|
" (lutT + lutM * log (clamp (color, lutMin, lutMax))); \n"
|
|||
|
|
" \n"
|
|||
|
|
" half3 fi = floor (i); \n"
|
|||
|
|
" half3 fj = fi + 1; \n"
|
|||
|
|
" half3 s = i - fi; \n"
|
|||
|
|
" \n"
|
|||
|
|
" fi = fi / lutF; \n"
|
|||
|
|
" fj = fj / lutF; \n"
|
|||
|
|
" \n"
|
|||
|
|
" half3 c0 = tex3D (lut, half3 (fi.x, fi.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c1 = tex3D (lut, half3 (fj.x, fi.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c2 = tex3D (lut, half3 (fi.x, fj.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c3 = tex3D (lut, half3 (fj.x, fj.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c4 = tex3D (lut, half3 (fi.x, fi.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c5 = tex3D (lut, half3 (fj.x, fi.y, fj.z)).rgb; \n"
|
|||
|
|
" half3 c6 = tex3D (lut, half3 (fi.x, fj.y, fj.z)).rgb; \n"
|
|||
|
|
" half3 c7 = tex3D (lut, half3 (fj.x, fj.y, fj.z)).rgb; \n"
|
|||
|
|
" \n"
|
|||
|
|
" color = ((c0 * (1-s.x) + c1 * s.x) * (1-s.y) + \n"
|
|||
|
|
" (c2 * (1-s.x) + c3 * s.x) * s.y) * (1-s.z) + \n"
|
|||
|
|
" ((c4 * (1-s.x) + c5 * s.x) * (1-s.y) + \n"
|
|||
|
|
" (c6 * (1-s.x) + c7 * s.x) * s.y) * s.z; \n"
|
|||
|
|
" \n"
|
|||
|
|
" color = exp (color); \n"
|
|||
|
|
" } \n"
|
|||
|
|
" else \n"
|
|||
|
|
" { \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Texture hardware supports trilinear \n"
|
|||
|
|
" // interpolation between texture samples. \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" color = lutT + lutM * log (clamp (color, lutMin, lutMax));\n"
|
|||
|
|
" color = exp (tex3D (lut, color).rgb); \n"
|
|||
|
|
" } \n"
|
|||
|
|
" } \n"
|
|||
|
|
" \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Apply video gamma correction. \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" Out output; \n"
|
|||
|
|
" output.pixel = pow (color, videoGamma); \n"
|
|||
|
|
" return output; \n"
|
|||
|
|
" } \n"
|
|||
|
|
" \n";
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
initShaderLuminanceChroma
|
|||
|
|
(float lutMin,
|
|||
|
|
float lutMax,
|
|||
|
|
float lutM,
|
|||
|
|
float lutT)
|
|||
|
|
{
|
|||
|
|
cgSetErrorCallback (handleCgErrors);
|
|||
|
|
|
|||
|
|
cgContext = cgCreateContext();
|
|||
|
|
cgProfile = cgGLGetLatestProfile (CG_GL_FRAGMENT);
|
|||
|
|
cgGLSetOptimalOptions (cgProfile);
|
|||
|
|
|
|||
|
|
cgProgram =
|
|||
|
|
cgCreateProgram (cgContext, CG_SOURCE, shaderLuminanceChromaSource,
|
|||
|
|
cgProfile, "main", 0);
|
|||
|
|
|
|||
|
|
cgGLLoadProgram (cgProgram);
|
|||
|
|
cgGLBindProgram (cgProgram);
|
|||
|
|
|
|||
|
|
cgGLEnableProfile (cgProfile);
|
|||
|
|
|
|||
|
|
CGparameter ywParam = cgGetNamedParameter (cgProgram, "yw");
|
|||
|
|
cgSetParameter3f (ywParam, yWeights.x, yWeights.y, yWeights.z);
|
|||
|
|
|
|||
|
|
CGparameter emParam = cgGetNamedParameter (cgProgram, "expMult");
|
|||
|
|
cgSetParameter1f (emParam, pow (2.0f, exposure));
|
|||
|
|
|
|||
|
|
CGparameter vgParam = cgGetNamedParameter (cgProgram, "videoGamma");
|
|||
|
|
cgSetParameter1f (vgParam, displayVideoGamma());
|
|||
|
|
|
|||
|
|
CGparameter lutMinParam = cgGetNamedParameter (cgProgram, "lutMin");
|
|||
|
|
cgSetParameter1f (lutMinParam, lutMin);
|
|||
|
|
|
|||
|
|
CGparameter lutMaxParam = cgGetNamedParameter (cgProgram, "lutMax");
|
|||
|
|
cgSetParameter1f (lutMaxParam, lutMax);
|
|||
|
|
|
|||
|
|
CGparameter lutMParam = cgGetNamedParameter (cgProgram, "lutM");
|
|||
|
|
cgSetParameter1f (lutMParam, lutM);
|
|||
|
|
|
|||
|
|
CGparameter lutTParam = cgGetNamedParameter (cgProgram, "lutT");
|
|||
|
|
cgSetParameter1f (lutTParam, lutT);
|
|||
|
|
|
|||
|
|
CGparameter enableLutParam = cgGetNamedParameter (cgProgram, "enableLut");
|
|||
|
|
cgSetParameter1f (enableLutParam, enableCtl? 1.0: 0.0);
|
|||
|
|
|
|||
|
|
CGparameter lutFParam = cgGetNamedParameter (cgProgram, "lutF");
|
|||
|
|
cgSetParameter1f (lutFParam, hwTexInterpolation? 0: lutN - 1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Shader for RGB images
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
const char shaderRgbSource[] =
|
|||
|
|
" \n"
|
|||
|
|
" struct Out \n"
|
|||
|
|
" { \n"
|
|||
|
|
" half3 pixel: COLOR; \n"
|
|||
|
|
" }; \n"
|
|||
|
|
" \n"
|
|||
|
|
" Out \n"
|
|||
|
|
" main (float2 tc: TEXCOORD0, \n"
|
|||
|
|
" uniform sampler2D rgbImage: TEXUNIT0, \n"
|
|||
|
|
" uniform sampler3D lut: TEXUNIT3, \n"
|
|||
|
|
" uniform float expMult, \n"
|
|||
|
|
" uniform float videoGamma, \n"
|
|||
|
|
" uniform float lutMin, \n"
|
|||
|
|
" uniform float lutMax, \n"
|
|||
|
|
" uniform float lutM, \n"
|
|||
|
|
" uniform float lutT, \n"
|
|||
|
|
" uniform float lutF, \n"
|
|||
|
|
" uniform float enableLut) \n"
|
|||
|
|
" { \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Sample RGB image, apply exposure. \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" half3 color = tex2D (rgbImage, tc).rgb * expMult; \n"
|
|||
|
|
" \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Apply 3D color lookup table (in log space). \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" if (enableLut) \n"
|
|||
|
|
" { \n"
|
|||
|
|
" if (lutF) \n"
|
|||
|
|
" { \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Texture hardware does not support \n"
|
|||
|
|
" // interpolation between texture samples. \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" half3 i = lutF * half3 \n"
|
|||
|
|
" (lutT + lutM * log (clamp (color, lutMin, lutMax))); \n"
|
|||
|
|
" \n"
|
|||
|
|
" half3 fi = floor (i); \n"
|
|||
|
|
" half3 fj = fi + 1; \n"
|
|||
|
|
" half3 s = i - fi; \n"
|
|||
|
|
" \n"
|
|||
|
|
" fi = fi / lutF; \n"
|
|||
|
|
" fj = fj / lutF; \n"
|
|||
|
|
" \n"
|
|||
|
|
" half3 c0 = tex3D (lut, half3 (fi.x, fi.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c1 = tex3D (lut, half3 (fj.x, fi.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c2 = tex3D (lut, half3 (fi.x, fj.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c3 = tex3D (lut, half3 (fj.x, fj.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c4 = tex3D (lut, half3 (fi.x, fi.y, fi.z)).rgb; \n"
|
|||
|
|
" half3 c5 = tex3D (lut, half3 (fj.x, fi.y, fj.z)).rgb; \n"
|
|||
|
|
" half3 c6 = tex3D (lut, half3 (fi.x, fj.y, fj.z)).rgb; \n"
|
|||
|
|
" half3 c7 = tex3D (lut, half3 (fj.x, fj.y, fj.z)).rgb; \n"
|
|||
|
|
" \n"
|
|||
|
|
" color = ((c0 * (1-s.x) + c1 * s.x) * (1-s.y) + \n"
|
|||
|
|
" (c2 * (1-s.x) + c3 * s.x) * s.y) * (1-s.z) + \n"
|
|||
|
|
" ((c4 * (1-s.x) + c5 * s.x) * (1-s.y) + \n"
|
|||
|
|
" (c6 * (1-s.x) + c7 * s.x) * s.y) * s.z; \n"
|
|||
|
|
" \n"
|
|||
|
|
" color = exp (color); \n"
|
|||
|
|
" } \n"
|
|||
|
|
" else \n"
|
|||
|
|
" { \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Texture hardware supports trilinear \n"
|
|||
|
|
" // interpolation between texture samples. \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" color = lutT + lutM * log (clamp (color, lutMin, lutMax));\n"
|
|||
|
|
" color = exp (tex3D (lut, color).rgb); \n"
|
|||
|
|
" } \n"
|
|||
|
|
" } \n"
|
|||
|
|
" \n"
|
|||
|
|
" // \n"
|
|||
|
|
" // Apply video gamma correction. \n"
|
|||
|
|
" // \n"
|
|||
|
|
" \n"
|
|||
|
|
" Out output; \n"
|
|||
|
|
" output.pixel = pow (color, videoGamma); \n"
|
|||
|
|
" return output; \n"
|
|||
|
|
" } \n"
|
|||
|
|
" \n";
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
initShaderRgb
|
|||
|
|
(float lutMin,
|
|||
|
|
float lutMax,
|
|||
|
|
float lutM,
|
|||
|
|
float lutT)
|
|||
|
|
{
|
|||
|
|
cgSetErrorCallback (handleCgErrors);
|
|||
|
|
|
|||
|
|
cgContext = cgCreateContext();
|
|||
|
|
cgProfile = cgGLGetLatestProfile (CG_GL_FRAGMENT);
|
|||
|
|
cgGLSetOptimalOptions (cgProfile);
|
|||
|
|
|
|||
|
|
cgProgram =
|
|||
|
|
cgCreateProgram (cgContext, CG_SOURCE, shaderRgbSource,
|
|||
|
|
cgProfile, "main", 0);
|
|||
|
|
|
|||
|
|
cgGLLoadProgram (cgProgram);
|
|||
|
|
cgGLBindProgram (cgProgram);
|
|||
|
|
cgGLEnableProfile (cgProfile);
|
|||
|
|
|
|||
|
|
CGparameter emParam = cgGetNamedParameter (cgProgram, "expMult");
|
|||
|
|
cgSetParameter1f (emParam, pow (2.0f, exposure));
|
|||
|
|
|
|||
|
|
CGparameter vgParam = cgGetNamedParameter (cgProgram, "videoGamma");
|
|||
|
|
cgSetParameter1f (vgParam, displayVideoGamma());
|
|||
|
|
|
|||
|
|
CGparameter lutMinParam = cgGetNamedParameter (cgProgram, "lutMin");
|
|||
|
|
cgSetParameter1f (lutMinParam, lutMin);
|
|||
|
|
|
|||
|
|
CGparameter lutMaxParam = cgGetNamedParameter (cgProgram, "lutMax");
|
|||
|
|
cgSetParameter1f (lutMaxParam, lutMax);
|
|||
|
|
|
|||
|
|
CGparameter lutMParam = cgGetNamedParameter (cgProgram, "lutM");
|
|||
|
|
cgSetParameter1f (lutMParam, lutM);
|
|||
|
|
|
|||
|
|
CGparameter lutTParam = cgGetNamedParameter (cgProgram, "lutT");
|
|||
|
|
cgSetParameter1f (lutTParam, lutT);
|
|||
|
|
|
|||
|
|
CGparameter enableLutParam = cgGetNamedParameter (cgProgram, "enableLut");
|
|||
|
|
cgSetParameter1f (enableLutParam, enableCtl? 1.0: 0.0);
|
|||
|
|
|
|||
|
|
CGparameter lutFParam = cgGetNamedParameter (cgProgram, "lutF");
|
|||
|
|
cgSetParameter1f (lutFParam, hwTexInterpolation? 0: lutN - 1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// GL drawing code
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
checkGlErrors (const char where[])
|
|||
|
|
{
|
|||
|
|
GLenum error = glGetError();
|
|||
|
|
|
|||
|
|
if (error != GL_NO_ERROR)
|
|||
|
|
{
|
|||
|
|
cerr << where << ": " << gluErrorString (error) << endl;
|
|||
|
|
exit (1);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
handleReshape (int w, int h)
|
|||
|
|
{
|
|||
|
|
int xOffset = (w - glWindowWidth) / 2;
|
|||
|
|
int yOffset = (h - glWindowHeight) / 2;
|
|||
|
|
|
|||
|
|
glViewport (xOffset, yOffset, glWindowWidth, glWindowHeight);
|
|||
|
|
glScissor (xOffset, yOffset, glWindowWidth, glWindowHeight);
|
|||
|
|
|
|||
|
|
checkGlErrors ("handleReshape");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
initTexturesLuminanceChroma ()
|
|||
|
|
{
|
|||
|
|
const Box2i &dw = ib.dataWindow;
|
|||
|
|
int w = dw.max.x - dw.min.x + 1;
|
|||
|
|
int h = dw.max.y - dw.min.y + 1;
|
|||
|
|
|
|||
|
|
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
|
|||
|
|
glGenTextures (3, texId);
|
|||
|
|
|
|||
|
|
glActiveTexture (GL_TEXTURE0);
|
|||
|
|
glBindTexture (GL_TEXTURE_2D, texId[0]);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|||
|
|
|
|||
|
|
glTexImage2D (GL_TEXTURE_2D,
|
|||
|
|
0, // level
|
|||
|
|
GL_LUMINANCE16F_ARB, // internalFormat
|
|||
|
|
w, h,
|
|||
|
|
0, // border
|
|||
|
|
GL_LUMINANCE, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
0); // pixels
|
|||
|
|
|
|||
|
|
glActiveTexture (GL_TEXTURE1);
|
|||
|
|
glBindTexture (GL_TEXTURE_2D, texId[1]);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|||
|
|
|
|||
|
|
glTexImage2D (GL_TEXTURE_2D,
|
|||
|
|
0, // level
|
|||
|
|
GL_LUMINANCE16F_ARB, // internalFormat
|
|||
|
|
w / 2, h / 2,
|
|||
|
|
0, // border
|
|||
|
|
GL_LUMINANCE, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
0); // pixels
|
|||
|
|
|
|||
|
|
glActiveTexture (GL_TEXTURE2);
|
|||
|
|
glBindTexture (GL_TEXTURE_2D, texId[2]);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|||
|
|
|
|||
|
|
glTexImage2D (GL_TEXTURE_2D,
|
|||
|
|
0, // level
|
|||
|
|
GL_LUMINANCE16F_ARB, // internalFormat
|
|||
|
|
w / 2, h / 2,
|
|||
|
|
0, // border
|
|||
|
|
GL_LUMINANCE, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
0); // pixels
|
|||
|
|
|
|||
|
|
checkGlErrors ("initTexturesLuminanceChroma");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
initTexturesRgb ()
|
|||
|
|
{
|
|||
|
|
const Box2i &dw = ib.dataWindow;
|
|||
|
|
int w = dw.max.x - dw.min.x + 1;
|
|||
|
|
int h = dw.max.y - dw.min.y + 1;
|
|||
|
|
|
|||
|
|
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
|
|||
|
|
glGenTextures (1, texId);
|
|||
|
|
|
|||
|
|
glActiveTexture (GL_TEXTURE0);
|
|||
|
|
glBindTexture (GL_TEXTURE_2D, texId[0]);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|||
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|||
|
|
|
|||
|
|
glTexImage2D (GL_TEXTURE_2D,
|
|||
|
|
0, // level
|
|||
|
|
GL_RGBA16F_ARB, // internalFormat
|
|||
|
|
w, h,
|
|||
|
|
0, // border
|
|||
|
|
GL_RGBA, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
0); // pixels
|
|||
|
|
|
|||
|
|
checkGlErrors ("initTexturesRgb");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
init3DLut
|
|||
|
|
(const vector<string> &transformNames, // names of CTL transforms
|
|||
|
|
const Header &header, // header of first frame
|
|||
|
|
float &lutMin,
|
|||
|
|
float &lutMax,
|
|||
|
|
float &lutM,
|
|||
|
|
float &lutT)
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// We build a 3D color lookup table by running a set of color
|
|||
|
|
// samples through a series of CTL transforms.
|
|||
|
|
//
|
|||
|
|
// The 3D lookup table covers a range from lutMin to lutMax or
|
|||
|
|
// NUM_STOPS f-stops above and below 0.18 or MIDDLE_GRAY. The
|
|||
|
|
// size of the table is lutN by lutN by lutN samples.
|
|||
|
|
//
|
|||
|
|
// In order make the distribution of the samples in the table
|
|||
|
|
// approximately perceptually uniform, the Cg shaders that use
|
|||
|
|
// the table perform lookups in "log space":
|
|||
|
|
// In a Cg shader, the lookup table is represented as a 3D texture.
|
|||
|
|
// In order to apply the table to a pixel value, the Cg shader takes
|
|||
|
|
// the logarithm of the pixel value and scales and offsets the result
|
|||
|
|
// so that lutMin and lutMax map to 0 and 1 respectively. The scaled
|
|||
|
|
// value is used to perform a texture lookup and the shader computes
|
|||
|
|
// e raised to the power of the result of the texture lookup.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Compute lutMin, lutMax, and scale and offset
|
|||
|
|
// values, lutM and lutT, so that
|
|||
|
|
//
|
|||
|
|
// lutM * lutMin + lutT == 0
|
|||
|
|
// lutM * lutMax + lutT == 1
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
static const int NUM_STOPS = 7;
|
|||
|
|
static const float MIDDLE_GRAY = 0.18;
|
|||
|
|
|
|||
|
|
lutMin = MIDDLE_GRAY / (1 << NUM_STOPS);
|
|||
|
|
lutMax = MIDDLE_GRAY * (1 << NUM_STOPS);
|
|||
|
|
|
|||
|
|
float logLutMin = log (lutMin);
|
|||
|
|
float logLutMax = log (lutMax);
|
|||
|
|
|
|||
|
|
lutM = 1 / (logLutMax - logLutMin);
|
|||
|
|
lutT = -lutM * logLutMin;
|
|||
|
|
|
|||
|
|
size_t LUT_SIZE = lutN * lutN * lutN * 4;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Build a 3D array of RGB input pixel values.
|
|||
|
|
// such that R, G and B are between lutMin and lutMax.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
Array<half> pixelValues (LUT_SIZE);
|
|||
|
|
|
|||
|
|
for (size_t ib = 0; ib < lutN; ++ib)
|
|||
|
|
{
|
|||
|
|
float b = ib / (lutN - 1.0);
|
|||
|
|
half B = exp ((b - lutT) / lutM);
|
|||
|
|
|
|||
|
|
for (size_t ig = 0; ig < lutN; ++ig)
|
|||
|
|
{
|
|||
|
|
float g = ig / (lutN - 1.0);
|
|||
|
|
half G = exp ((g - lutT) / lutM);
|
|||
|
|
|
|||
|
|
for (int ir = 0; ir < lutN; ++ir)
|
|||
|
|
{
|
|||
|
|
float r = ir / (lutN - 1.0);
|
|||
|
|
half R = exp ((r - lutT) / lutM);
|
|||
|
|
|
|||
|
|
size_t i = (ib * lutN * lutN + ig * lutN + ir) * 4;
|
|||
|
|
pixelValues[i + 0] = R;
|
|||
|
|
pixelValues[i + 1] = G;
|
|||
|
|
pixelValues[i + 2] = B;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Initialize an array output pixel values to zero.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
Array<half> lut (LUT_SIZE);
|
|||
|
|
|
|||
|
|
for (int i = 0; i < LUT_SIZE; ++i)
|
|||
|
|
lut[i] = 0;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Generate output pixel values by applying CTL transforms
|
|||
|
|
// to the pixel values. (If the CTL transforms fail to
|
|||
|
|
// write to the output values, zero-initialization, above,
|
|||
|
|
// causes the displayed image to be black.)
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
ctlToLut (transformNames, header, LUT_SIZE, pixelValues, lut);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Take the logarithm of the output values that were
|
|||
|
|
// produced by the CTL transforms.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
for (int i = 0; i < LUT_SIZE; ++i)
|
|||
|
|
{
|
|||
|
|
if (lut[i] >= HALF_MIN && lut[i] <= HALF_MAX)
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// lut[i] is finite and positive.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
lut[i] = log (lut[i]);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// lut[i] is zero, negative or not finite;
|
|||
|
|
// log (lut[i]) is undefined.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
lut[i] = log (HALF_MIN);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Convert the output values into a 3D texture.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
GLuint lutId;
|
|||
|
|
|
|||
|
|
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
|
|||
|
|
glGenTextures (1, &lutId);
|
|||
|
|
|
|||
|
|
glActiveTexture (GL_TEXTURE3);
|
|||
|
|
glBindTexture (GL_TEXTURE_3D, lutId);
|
|||
|
|
glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|||
|
|
glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
|||
|
|
glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|||
|
|
glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|||
|
|
|
|||
|
|
glTexImage3D (GL_TEXTURE_3D,
|
|||
|
|
0, // level
|
|||
|
|
GL_RGBA16F_ARB, // internalFormat
|
|||
|
|
lutN, lutN, lutN, // width, height, depth
|
|||
|
|
0, // border
|
|||
|
|
GL_RGBA, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
(char *) &lut[0]);
|
|||
|
|
|
|||
|
|
checkGlErrors ("init3DLut");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
drawString (GLfloat x, GLfloat y, const char str[])
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Draw a text string.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
glPushMatrix();
|
|||
|
|
glTranslatef (x, y, 0);
|
|||
|
|
glScalef (0.10, 0.15, 0);
|
|||
|
|
|
|||
|
|
while (*str)
|
|||
|
|
glutStrokeCharacter (GLUT_STROKE_MONO_ROMAN, *str++);
|
|||
|
|
|
|||
|
|
glPopMatrix();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
drawStringWithBorder (GLfloat x, GLfloat y, const char str[])
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Draw text string where each character is surrounded
|
|||
|
|
// by a one pixel wide black border.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|||
|
|
glEnable (GL_BLEND);
|
|||
|
|
glEnable (GL_LINE_SMOOTH);
|
|||
|
|
glColor4f (0, 0, 0, 1);
|
|||
|
|
glLineWidth (2);
|
|||
|
|
drawString (x - 1, y - 1, str);
|
|||
|
|
drawString (x + 1, y - 1, str);
|
|||
|
|
drawString (x - 1, y + 1, str);
|
|||
|
|
drawString (x + 1, y + 1, str);
|
|||
|
|
glLineWidth (2);
|
|||
|
|
glColor4f (0.8, 0.8, 0.8, 1);
|
|||
|
|
drawString (x, y, str);
|
|||
|
|
glDisable (GL_LINE_SMOOTH);
|
|||
|
|
glDisable (GL_BLEND);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
drawFrame ()
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Draw the current frame
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
glMatrixMode (GL_PROJECTION);
|
|||
|
|
glLoadIdentity();
|
|||
|
|
glOrtho (0, glWindowWidth, 0, glWindowHeight, -1, 1);
|
|||
|
|
glMatrixMode (GL_MODELVIEW);
|
|||
|
|
glLoadIdentity ();
|
|||
|
|
|
|||
|
|
glDisable (GL_SCISSOR_TEST);
|
|||
|
|
glClearColor (0.0, 0.0, 0.0, 0.0);
|
|||
|
|
glClear (GL_COLOR_BUFFER_BIT);
|
|||
|
|
|
|||
|
|
glEnable (GL_SCISSOR_TEST);
|
|||
|
|
glClearColor (0.3, 0.3, 0.3, 1.0);
|
|||
|
|
glClear (GL_COLOR_BUFFER_BIT);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Convert the pixels of the current frame into OpenGL textures.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
const Box2i &dw = ib.dataWindow;
|
|||
|
|
int w = dw.max.x - dw.min.x + 1;
|
|||
|
|
int h = dw.max.y - dw.min.y + 1;
|
|||
|
|
|
|||
|
|
if (ib.rgbMode)
|
|||
|
|
{
|
|||
|
|
glActiveTexture (GL_TEXTURE0);
|
|||
|
|
glEnable (GL_TEXTURE_2D);
|
|||
|
|
glBindTexture (GL_TEXTURE_2D, texId[0]);
|
|||
|
|
|
|||
|
|
glTexSubImage2D (GL_TEXTURE_2D,
|
|||
|
|
0, // level
|
|||
|
|
0, 0, // xoffset, yoffset
|
|||
|
|
w, h,
|
|||
|
|
GL_RGBA, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
(GLvoid *) ib.pixels (i, 0));
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
glActiveTexture (GL_TEXTURE0);
|
|||
|
|
glEnable (GL_TEXTURE_2D);
|
|||
|
|
glBindTexture (GL_TEXTURE_2D, texId[0]);
|
|||
|
|
|
|||
|
|
glTexSubImage2D (GL_TEXTURE_2D,
|
|||
|
|
0, // level
|
|||
|
|
0, 0, // xoffset, yoffset
|
|||
|
|
w, h,
|
|||
|
|
GL_LUMINANCE, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
(GLvoid *) ib.pixels (i, 0));
|
|||
|
|
|
|||
|
|
glActiveTexture (GL_TEXTURE1);
|
|||
|
|
glEnable (GL_TEXTURE_2D);
|
|||
|
|
glBindTexture (GL_TEXTURE_2D, texId[1]);
|
|||
|
|
|
|||
|
|
glTexSubImage2D (GL_TEXTURE_2D,
|
|||
|
|
0, // level
|
|||
|
|
0, 0, // xoffset, yoffset
|
|||
|
|
w / 2, h / 2,
|
|||
|
|
GL_LUMINANCE, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
(GLvoid *) ib.pixels (i, 1));
|
|||
|
|
|
|||
|
|
glActiveTexture (GL_TEXTURE2);
|
|||
|
|
glEnable (GL_TEXTURE_2D);
|
|||
|
|
glBindTexture (GL_TEXTURE_2D, texId[2]);
|
|||
|
|
|
|||
|
|
glTexSubImage2D (GL_TEXTURE_2D,
|
|||
|
|
0, // level
|
|||
|
|
0, 0, // xoffset, yoffset
|
|||
|
|
w / 2, h / 2,
|
|||
|
|
GL_LUMINANCE, // format
|
|||
|
|
GL_HALF_FLOAT_ARB, // type
|
|||
|
|
(GLvoid *) ib.pixels (i, 2));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Enable Cg shading and draw a rectangle that fills
|
|||
|
|
// the entire data window. The textures will be mapped
|
|||
|
|
// onto this rectangle.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
glActiveTexture (GL_TEXTURE3);
|
|||
|
|
glEnable (GL_TEXTURE_3D);
|
|||
|
|
|
|||
|
|
cgGLEnableProfile (cgProfile);
|
|||
|
|
|
|||
|
|
glBegin (GL_POLYGON);
|
|||
|
|
glTexCoord2f (0, 1);
|
|||
|
|
glVertex2i (drawRect.min.x, drawRect.min.y);
|
|||
|
|
glTexCoord2f (1, 1);
|
|||
|
|
glVertex2i (drawRect.max.x, drawRect.min.y);
|
|||
|
|
glTexCoord2f (1, 0);
|
|||
|
|
glVertex2i (drawRect.max.x, drawRect.max.y);
|
|||
|
|
glTexCoord2f (0, 0);
|
|||
|
|
glVertex2i (drawRect.min.x, drawRect.max.y);
|
|||
|
|
glEnd ();
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Disable texture mapping and Cg shading and draw the text overlay
|
|||
|
|
// that indicates the frame rate and exposure settings.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (showTextOverlay)
|
|||
|
|
{
|
|||
|
|
glActiveTexture (GL_TEXTURE0);
|
|||
|
|
glDisable (GL_TEXTURE_2D);
|
|||
|
|
glActiveTexture (GL_TEXTURE1);
|
|||
|
|
glDisable (GL_TEXTURE_2D);
|
|||
|
|
glActiveTexture (GL_TEXTURE2);
|
|||
|
|
glDisable (GL_TEXTURE_2D);
|
|||
|
|
glActiveTexture (GL_TEXTURE3);
|
|||
|
|
glDisable (GL_TEXTURE_3D);
|
|||
|
|
cgGLDisableProfile (cgProfile);
|
|||
|
|
glShadeModel (GL_FLAT);
|
|||
|
|
|
|||
|
|
stringstream ss;
|
|||
|
|
|
|||
|
|
ss << setw (6) << frameNumber << " ";
|
|||
|
|
|
|||
|
|
if (timer.playState == RUNNING)
|
|||
|
|
{
|
|||
|
|
ss << setiosflags (ios_base::fixed) <<
|
|||
|
|
setprecision (2) << setw (7) <<
|
|||
|
|
timer.actualFrameRate() << " fps";
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ss << " pause";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ss << " " <<
|
|||
|
|
setiosflags (ios_base::showpos | ios_base::fixed) <<
|
|||
|
|
setprecision (1) << setw (5) <<
|
|||
|
|
exposure << " stops";
|
|||
|
|
|
|||
|
|
if (ib.rgbMode)
|
|||
|
|
ss << " RGB";
|
|||
|
|
else
|
|||
|
|
ss << " YC";
|
|||
|
|
|
|||
|
|
if (!enableCtl)
|
|||
|
|
ss << " CTL off";
|
|||
|
|
|
|||
|
|
drawStringWithBorder (20, 20, ss.str().c_str());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
checkGlErrors ("drawFrame");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
redrawWindow ()
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Display the next image on the screen
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Exit if the file reading thread has terminated.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (ib.exitSemaphore2.tryWait())
|
|||
|
|
exit (1);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Wait until it is time to display the next image
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
timer.waitUntilNextFrameIsDue();
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Wait until the file reading thread has made the next frame available
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (timer.playState == RUNNING || timer.playState == PREPARE_TO_PAUSE)
|
|||
|
|
ib.fullBuffersSemaphore.wait();
|
|||
|
|
|
|||
|
|
if (timer.playState == PREPARE_TO_PAUSE)
|
|||
|
|
timer.playState = PAUSE;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Draw the frame
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
frameNumber = ib.frameNumber (i);
|
|||
|
|
drawFrame ();
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Return the image buffer to the file reading thread
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (timer.playState == RUNNING || timer.playState == PREPARE_TO_RUN)
|
|||
|
|
{
|
|||
|
|
i = (i + 1) % ib.numBuffers();
|
|||
|
|
ib.emptyBuffersSemaphore.post();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (timer.playState == PREPARE_TO_RUN)
|
|||
|
|
timer.playState = RUNNING;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Flush and ѕwap buffers to make the frame visible
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
glFlush();
|
|||
|
|
glutSwapBuffers();
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Make sure this function gets called again immediately
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (timer.playState == RUNNING || timer.playState == PREPARE_TO_RUN)
|
|||
|
|
glutPostRedisplay();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
handleKeypress (unsigned char key, int, int)
|
|||
|
|
{
|
|||
|
|
if (key == 'q' || key == 0x1b)
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Quit: In order to make sure that the file reading thread
|
|||
|
|
// won't crash by trying to use shared resources while we
|
|||
|
|
// exit, we first tell the file reading thread to exit.
|
|||
|
|
// Then we wait until the file reading thread signals that
|
|||
|
|
// it has received the exit command. At this point, it is
|
|||
|
|
// safe to exit.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
ib.exitSemaphore1.post();
|
|||
|
|
ib.emptyBuffersSemaphore.post();
|
|||
|
|
ib.exitSemaphore2.wait();
|
|||
|
|
|
|||
|
|
exit (0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (key == '>' || key == '.' || key == '<' || key == ',')
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Change exposure: 1 f-stop brighter or darker
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if ((key == '>' || key == '.') && exposure < 10)
|
|||
|
|
exposure += 1;
|
|||
|
|
|
|||
|
|
if ((key == '<' || key == ',') && exposure > -10)
|
|||
|
|
exposure -= 1;
|
|||
|
|
|
|||
|
|
CGparameter emParam = cgGetNamedParameter (cgProgram, "expMult");
|
|||
|
|
cgSetParameter1f (emParam, pow (2.0f, exposure));
|
|||
|
|
glutPostRedisplay();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if HAVE_CTL_INTERPRETER
|
|||
|
|
|
|||
|
|
if (key == 'c' || key == 'C')
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Toggle CTL transforms on/off
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
CGparameter enableLutParam =
|
|||
|
|
cgGetNamedParameter (cgProgram, "enableLut");
|
|||
|
|
|
|||
|
|
enableCtl = !enableCtl;
|
|||
|
|
cgSetParameter1f (enableLutParam, enableCtl? 1.0: 0.0);
|
|||
|
|
glutPostRedisplay();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if (key == 'o' || key == 'O')
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Toggle text overlay on/off
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
showTextOverlay = !showTextOverlay;
|
|||
|
|
glutPostRedisplay();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (key == 'p' || key == 'P' || key == 'l' || key == 'L')
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Toggle between playing forward and pause
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (timer.playState == RUNNING && ib.forward)
|
|||
|
|
timer.playState = PREPARE_TO_PAUSE;
|
|||
|
|
|
|||
|
|
if (timer.playState == PAUSE)
|
|||
|
|
timer.playState = PREPARE_TO_RUN;
|
|||
|
|
|
|||
|
|
ib.forward = true;
|
|||
|
|
glutPostRedisplay();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (key == 'h' || key == 'H')
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Toggle between playing backward and pause
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (timer.playState == RUNNING && !ib.forward)
|
|||
|
|
timer.playState = PREPARE_TO_PAUSE;
|
|||
|
|
|
|||
|
|
if (timer.playState == PAUSE)
|
|||
|
|
timer.playState = PREPARE_TO_RUN;
|
|||
|
|
|
|||
|
|
ib.forward = false;
|
|||
|
|
glutPostRedisplay();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (key == 'j' || key == 'J' || key == 'k' || key == 'K')
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Step one frame forward or backward
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (timer.playState == RUNNING || timer.playState == PREPARE_TO_PAUSE)
|
|||
|
|
|
|||
|
|
ib.fullBuffersSemaphore.wait();
|
|||
|
|
|
|||
|
|
if (key == 'k' || key == 'K')
|
|||
|
|
ib.forward = true;
|
|||
|
|
else
|
|||
|
|
ib.forward = false;
|
|||
|
|
|
|||
|
|
timer.playState = PAUSE;
|
|||
|
|
|
|||
|
|
int newFrameNumber;
|
|||
|
|
|
|||
|
|
if (ib.forward)
|
|||
|
|
{
|
|||
|
|
if (frameNumber >= lastFrameNumber)
|
|||
|
|
newFrameNumber = firstFrameNumber;
|
|||
|
|
else
|
|||
|
|
newFrameNumber = frameNumber + 1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if (ib.frameNumber(i) <= firstFrameNumber)
|
|||
|
|
newFrameNumber = lastFrameNumber;
|
|||
|
|
else
|
|||
|
|
newFrameNumber = frameNumber - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
while (ib.frameNumber(i) != newFrameNumber)
|
|||
|
|
{
|
|||
|
|
i = (i + 1) % ib.numBuffers();
|
|||
|
|
ib.emptyBuffersSemaphore.post();
|
|||
|
|
ib.fullBuffersSemaphore.wait();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
glutPostRedisplay();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (key == 'f' || key == 'F')
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Toggle full-screen mode on/off
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
fullScreenMode = !fullScreenMode;
|
|||
|
|
|
|||
|
|
if (fullScreenMode)
|
|||
|
|
glutFullScreen();
|
|||
|
|
else
|
|||
|
|
glutReshapeWindow (glWindowWidth, glWindowHeight);
|
|||
|
|
|
|||
|
|
glutPostRedisplay();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
} // namespace
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
playExr (const char fileNameTemplate[],
|
|||
|
|
int firstFrame,
|
|||
|
|
int lastFrame,
|
|||
|
|
int numThreads,
|
|||
|
|
float fps,
|
|||
|
|
float xyScale,
|
|||
|
|
const vector<string> &transformNames,
|
|||
|
|
bool useHwTexInterpolation)
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Set the number of threads the IlmImf library
|
|||
|
|
// will use internally for OpenEXR file reading.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
OPENEXR_IMF_NAMESPACE::setGlobalThreadCount (numThreads);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Allocate buffers for the images, initialize semaphores
|
|||
|
|
// for synchronization between the file reading thread
|
|||
|
|
// and the display loop in the main thread
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
firstFrameNumber = firstFrame;
|
|||
|
|
lastFrameNumber = lastFrame;
|
|||
|
|
|
|||
|
|
Header header;
|
|||
|
|
initializeImageBuffers (ib, header, fileNameTemplate);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Determine the playback frame rate.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (fps < 0)
|
|||
|
|
{
|
|||
|
|
if (hasFramesPerSecond (header) && framesPerSecond (header) >= 1)
|
|||
|
|
fps = framesPerSecond (header);
|
|||
|
|
else
|
|||
|
|
fps = 24;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Compute on-screen window sizes
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
computeWindowSizes (header.dataWindow(),
|
|||
|
|
header.displayWindow(),
|
|||
|
|
header.pixelAspectRatio(),
|
|||
|
|
xyScale);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Create an OpenGL window
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
glutInitDisplayMode (GLUT_RGBA | GLUT_DOUBLE);
|
|||
|
|
glutInitWindowSize (glWindowWidth, glWindowHeight);
|
|||
|
|
glutCreateWindow (fileNameTemplate);
|
|||
|
|
glutKeyboardFunc (handleKeypress);
|
|||
|
|
glutReshapeFunc (handleReshape);
|
|||
|
|
glutDisplayFunc (redrawWindow);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Verify that OpenGL supports the extensions we need
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
initAndCheckGlExtensions();
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Initialize textures and Cg shaders
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
float xMin;
|
|||
|
|
float xMax;
|
|||
|
|
float m;
|
|||
|
|
float t;
|
|||
|
|
|
|||
|
|
init3DLut (transformNames, header, xMin, xMax, m, t);
|
|||
|
|
|
|||
|
|
hwTexInterpolation = useHwTexInterpolation;
|
|||
|
|
|
|||
|
|
if (ib.rgbMode)
|
|||
|
|
{
|
|||
|
|
initShaderRgb (xMin, xMax, m, t);
|
|||
|
|
initTexturesRgb();
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
initShaderLuminanceChroma (xMin, xMax, m, t);
|
|||
|
|
initTexturesLuminanceChroma();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Start the file reading thread and the display loop
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
FileReadingThread frt (fileNameTemplate, firstFrame, lastFrame, ib);
|
|||
|
|
timer.playState = (firstFrame != lastFrame)? RUNNING: PREPARE_TO_PAUSE;
|
|||
|
|
timer.setDesiredFrameRate (fps);
|
|||
|
|
glutMainLoop();
|
|||
|
|
}
|