/////////////////////////////////////////////////////////////////////////// // // Copyright (c) 2002, 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. // /////////////////////////////////////////////////////////////////////////// #ifndef INCLUDED_IMF_MISC_H #define INCLUDED_IMF_MISC_H //----------------------------------------------------------------------------- // // Miscellaneous helper functions for OpenEXR image file I/O // //----------------------------------------------------------------------------- #include "ImfPixelType.h" #include "ImfCompressor.h" #include "ImfArray.h" #include "ImfNamespace.h" #include "ImfExport.h" #include "ImfForward.h" #include #include OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER // // Return the size of a single value of the indicated type, // in the machine's native format. // IMF_EXPORT int pixelTypeSize (PixelType type); // // Return the number of samples a channel with subsampling rate // s has in the interval [a, b]. For example, a channel with // subsampling rate 2 (and samples at 0, 2, 4, 6, 8, etc.) has // 2 samples in the interval [1, 5] and three samples in the // interval [2, 6]. // IMF_EXPORT int numSamples (int s, int a, int b); // // Build a table that lists, for each scanline in a file's // data window, how many bytes are required to store all // pixels in all channels in that scanline (assuming that // the pixel data are tightly packed). // IMF_EXPORT size_t bytesPerLineTable (const Header &header, std::vector &bytesPerLine); // // Get the sample count for pixel (x, y) using the array base // pointer, xStride and yStride. // IMF_EXPORT int& sampleCount(char* base, int xStride, int yStride, int x, int y); IMF_EXPORT const int& sampleCount(const char* base, int xStride, int yStride, int x, int y); // // Build a table that lists, for each scanline in a DEEP file's // data window, how many bytes are required to store all // pixels in all channels in scanlines ranged in [minY, maxY] // (assuming that the pixel data are tightly packed). // IMF_EXPORT size_t bytesPerDeepLineTable (const Header &header, int minY, int maxY, const char* base, int xStride, int yStride, std::vector &bytesPerLine); // // Build a table that lists, for each scanline in a DEEP file's // data window, how many bytes are required to store all // pixels in all channels in every scanline (assuming that // the pixel data are tightly packed). // IMF_EXPORT size_t bytesPerDeepLineTable (const Header &header, char* base, int xStride, int yStride, std::vector &bytesPerLine); // // For scanline-based files, pixels are read or written in // in multi-scanline blocks. Internally, class OutputFile // and class ScanLineInputFile store a block of scan lines // in a "line buffer". Function offsetInLineBufferTable() // builds a table that lists, scanlines within range // [scanline1, scanline2], the location of the pixel data // for the scanline relative to the beginning of the line buffer, // where scanline1 = 0 represents the first line in the DATA WINDOW. // The one without specifying the range will make scanline1 = 0 // and scanline2 = bytesPerLine.size(). // IMF_EXPORT void offsetInLineBufferTable (const std::vector &bytesPerLine, int scanline1, int scanline2, int linesInLineBuffer, std::vector &offsetInLineBuffer); IMF_EXPORT void offsetInLineBufferTable (const std::vector &bytesPerLine, int linesInLineBuffer, std::vector &offsetInLineBuffer); // // For a scanline-based file, compute the range of scanlines // that occupy the same line buffer as a given scanline, y. // (minY is the minimum y coordinate of the file's data window.) // IMF_EXPORT int lineBufferMinY (int y, int minY, int linesInLineBuffer); IMF_EXPORT int lineBufferMaxY (int y, int minY, int linesInLineBuffer); // // Return a compressor's data format (Compressor::NATIVE or Compressor::XDR). // If compressor is 0, return Compressor::XDR. // IMF_EXPORT Compressor::Format defaultFormat (Compressor *compressor); // // Return the number of scan lines a compressor wants to compress // or uncompress at once. If compressor is 0, return 1. // IMF_EXPORT int numLinesInBuffer (Compressor *compressor); // // Copy a single channel of a horizontal row of pixels from an // input file's internal line buffer or tile buffer into a // frame buffer slice. If necessary, perform on-the-fly data // type conversion. // // readPtr initially points to the beginning of the // data in the line or tile buffer. readPtr // is advanced as the pixel data are copied; // when copyIntoFrameBuffer() returns, // readPtr points just past the end of the // copied data. // // writePtr, endPtr point to the lefmost and rightmost pixels // in the frame buffer slice // // xStride the xStride for the frame buffer slice // // format indicates if the line or tile buffer is // in NATIVE or XDR format. // // typeInFrameBuffer the pixel data type of the frame buffer slice // // typeInFile the pixel data type in the input file's channel // IMF_EXPORT void copyIntoFrameBuffer (const char *&readPtr, char *writePtr, char *endPtr, size_t xStride, bool fill, double fillValue, Compressor::Format format, PixelType typeInFrameBuffer, PixelType typeInFile); // // Copy a single channel of a horizontal row of pixels from an // input file's internal line buffer or tile buffer into a // frame buffer slice. If necessary, perform on-the-fly data // type conversion. // // readPtr initially points to the beginning of the // data in the line or tile buffer. readPtr // is advanced as the pixel data are copied; // when copyIntoFrameBuffer() returns, // readPtr points just past the end of the // copied data. // // base point to each pixel in the framebuffer // // sampleCountBase, provide the number of samples in each pixel // sampleCountXStride, // sampleCountYStride // // y the scanline to copy. The coordinate is // relative to the datawindow.min.y. // // minX, maxX used to indicate which pixels in the scanline // will be copied. // // xOffsetForSampleCount, used to offset the sample count array // yOffsetForSampleCount, and the base array. // xOffsetForData, // yOffsetForData // // xStride the xStride for the frame buffer slice // // format indicates if the line or tile buffer is // in NATIVE or XDR format. // // typeInFrameBuffer the pixel data type of the frame buffer slice // // typeInFile the pixel data type in the input file's channel // IMF_EXPORT void copyIntoDeepFrameBuffer (const char *& readPtr, char * base, const char* sampleCountBase, ptrdiff_t sampleCountXStride, ptrdiff_t sampleCountYStride, int y, int minX, int maxX, int xOffsetForSampleCount, int yOffsetForSampleCount, int xOffsetForData, int yOffsetForData, ptrdiff_t xStride, ptrdiff_t xPointerStride, ptrdiff_t yPointerStride, bool fill, double fillValue, Compressor::Format format, PixelType typeInFrameBuffer, PixelType typeInFile); // // Given a pointer into a an input file's line buffer or tile buffer, // skip over the data for xSize pixels of type typeInFile. // readPtr initially points to the beginning of the data to be skipped; // when skipChannel() returns, readPtr points just past the end of the // skipped data. // IMF_EXPORT void skipChannel (const char *&readPtr, PixelType typeInFile, size_t xSize); // // Convert an array of pixel data from the machine's native // representation to XDR format. // // toPtr, fromPtr initially point to the beginning of the input // and output pixel data arrays; when convertInPlace() // returns, toPtr and fromPtr point just past the // end of the input and output arrays. // If the native representation of the data has the // same size as the XDR data, then the conversion // can take in place, without an intermediate // temporary buffer (toPtr and fromPtr can point // to the same location). // // type the pixel data type // // numPixels number of pixels in the input and output arrays // IMF_EXPORT void convertInPlace (char *&toPtr, const char *&fromPtr, PixelType type, size_t numPixels); // // Copy a single channel of a horizontal row of pixels from a // a frame buffer into an output file's internal line buffer or // tile buffer. // // writePtr initially points to the beginning of the // data in the line or tile buffer. writePtr // is advanced as the pixel data are copied; // when copyFromFrameBuffer() returns, // writePtr points just past the end of the // copied data. // // readPtr, endPtr point to the lefmost and rightmost pixels // in the frame buffer slice // // xStride the xStride for the frame buffer slice // // format indicates if the line or tile buffer is // in NATIVE or XDR format. // // type the pixel data type in the frame buffer // and in the output file's channel (function // copyFromFrameBuffer() doesn't do on-the-fly // data type conversion) // IMF_EXPORT void copyFromFrameBuffer (char *&writePtr, const char *&readPtr, const char *endPtr, size_t xStride, Compressor::Format format, PixelType type); // // Copy a single channel of a horizontal row of pixels from a // a frame buffer in a deep data file into an output file's // internal line buffer or tile buffer. // // writePtr initially points to the beginning of the // data in the line or tile buffer. writePtr // is advanced as the pixel data are copied; // when copyFromDeepFrameBuffer() returns, // writePtr points just past the end of the // copied data. // // base the start pointer of each pixel in this channel. // It points to the real data in FrameBuffer. // It is different for different channels. // dataWindowMinX and dataWindowMinY are involved in // locating for base. // // sampleCountBase, used to locate the position to get // sampleCountXStride, the number of samples for each pixel. // sampleCountYStride Used to determine how far we should // read based on the pointer provided by base. // // y the scanline to copy. If we are dealing // with a tiled deep file, then probably a portion // of the scanline is copied. // // xMin, xMax used to indicate which pixels in the scanline // will be copied. // // xOffsetForSampleCount, used to offset the sample count array // yOffsetForSampleCount, and the base array. // xOffsetForData, // yOffsetForData // // xStride the xStride for the frame buffer slice // // format indicates if the line or tile buffer is // in NATIVE or XDR format. // // type the pixel data type in the frame buffer // and in the output file's channel (function // copyFromFrameBuffer() doesn't do on-the-fly // data type conversion) // IMF_EXPORT void copyFromDeepFrameBuffer (char *& writePtr, const char * base, char* sampleCountBase, ptrdiff_t sampleCountXStride, ptrdiff_t sampleCountYStride, int y, int xMin, int xMax, int xOffsetForSampleCount, int yOffsetForSampleCount, int xOffsetForData, int yOffsetForData, ptrdiff_t sampleStride, ptrdiff_t xStrideForData, ptrdiff_t yStrideForData, Compressor::Format format, PixelType type); // // Fill part of an output file's line buffer or tile buffer with // zeroes. This routine is called when an output file contains // a channel for which the frame buffer contains no corresponding // slice. // // writePtr initially points to the beginning of the // data in the line or tile buffer. When // fillChannelWithZeroes() returns, writePtr // points just past the end of the zeroed // data. // // format indicates if the line or tile buffer is // in NATIVE or XDR format. // // type the pixel data type in the line or frame buffer. // // xSize number of pixels to be filled with zeroes. // IMF_EXPORT void fillChannelWithZeroes (char *&writePtr, Compressor::Format format, PixelType type, size_t xSize); IMF_EXPORT bool usesLongNames (const Header &header); // // compute size of chunk offset table - if ignore_attribute set to true // will compute from the image size and layout, rather than the attribute // The default behaviour is to read the attribute // IMF_EXPORT int getChunkOffsetTableSize(const Header& header,bool ignore_attribute=false); OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT #endif