/src/freeimage-svn/FreeImage/trunk/Source/OpenEXR/IlmImf/ImfHeader.h

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



#ifndef INCLUDED_IMF_HEADER_H
#define INCLUDED_IMF_HEADER_H

//-----------------------------------------------------------------------------
//
//  class Header
//
//-----------------------------------------------------------------------------

#include "ImfLineOrder.h"
#include "ImfCompression.h"
#include "ImfName.h"
#include "ImfTileDescription.h"
#include "ImfInt64.h"
#include "ImathVec.h"
#include "ImathBox.h"
#include "IexBaseExc.h"

#include "ImfForward.h"
#include "ImfNamespace.h"
#include "ImfExport.h"

#include <map>
#include <iosfwd>
#include <string>


OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER

using std::string;


class IMF_EXPORT Header
{
  public:
    
    //----------------------------------------------------------------
    // Default constructor -- the display window and the data window
    // are both set to Box2i (V2i (0, 0), V2i (width-1, height-1).
    //----------------------------------------------------------------

    Header (int width = 64,
      int height = 64,
      float pixelAspectRatio = 1,
      const IMATH_NAMESPACE::V2f &screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0),
      float screenWindowWidth = 1,
      LineOrder lineOrder = INCREASING_Y,
      Compression = ZIP_COMPRESSION);


    //--------------------------------------------------------------------
    // Constructor -- the data window is specified explicitly; the display
    // window is set to Box2i (V2i (0, 0), V2i (width-1, height-1).
    //--------------------------------------------------------------------

    Header (int width,
      int height,
      const IMATH_NAMESPACE::Box2i &dataWindow,
      float pixelAspectRatio = 1,
      const IMATH_NAMESPACE::V2f &screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0),
      float screenWindowWidth = 1,
      LineOrder lineOrder = INCREASING_Y,
      Compression = ZIP_COMPRESSION);


    //----------------------------------------------------------
    // Constructor -- the display window and the data window are
    // both specified explicitly.
    //----------------------------------------------------------

    Header (const IMATH_NAMESPACE::Box2i &displayWindow,
      const IMATH_NAMESPACE::Box2i &dataWindow,
      float pixelAspectRatio = 1,
      const IMATH_NAMESPACE::V2f &screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0),
      float screenWindowWidth = 1,
      LineOrder lineOrder = INCREASING_Y,
      Compression = ZIP_COMPRESSION);


    //-----------------
    // Copy constructor
    //-----------------

    Header (const Header &other);


    //-----------
    // Destructor
    //-----------

    ~Header ();


    //-----------
    // Assignment
    //-----------

    Header &      operator = (const Header &other);


    //---------------------------------------------------------------
    // Add an attribute:
    //
    // insert(n,attr) If no attribute with name n exists, a new
    //      attribute with name n, and the same type as
    //      attr, is added, and the value of attr is
    //      copied into the new attribute.
    //
    //      If an attribute with name n exists, and its
    //      type is the same as attr, the value of attr
    //      is copied into this attribute.
    //
    //      If an attribute with name n exists, and its
    //      type is different from attr, an IEX_NAMESPACE::TypeExc
    //      is thrown.
    //
    //---------------------------------------------------------------

    void      insert (const char name[],
                const Attribute &attribute);

    void      insert (const std::string &name,
                const Attribute &attribute);

    //---------------------------------------------------------------
    // Remove an attribute:
    //
    // remove(n)       If an attribute with name n exists, then it
    //                 is removed from the map of present attributes.
    //
    //                 If no attribute with name n exists, then this
    //                 functions becomes a 'no-op'
    //
    //---------------------------------------------------------------
    void                        erase (const char name[]);
    void                        erase (const std::string &name);

    
    
    //------------------------------------------------------------------
    // Access to existing attributes:
    //
    // [n]      Returns a reference to the attribute
    //        with name n.  If no attribute with
    //        name n exists, an IEX_NAMESPACE::ArgExc is thrown.
    //
    // typedAttribute<T>(n) Returns a reference to the attribute
    //        with name n and type T.  If no attribute
    //        with name n exists, an IEX_NAMESPACE::ArgExc is
    //        thrown.  If an attribute with name n
    //        exists, but its type is not T, an
    //        IEX_NAMESPACE::TypeExc is thrown.
    //
    // findTypedAttribute<T>(n) Returns a pointer to the attribute with
    //        name n and type T, or 0 if no attribute
    //        with name n and type T exists.
    //
    //------------------------------------------------------------------

    Attribute &     operator [] (const char name[]);
    const Attribute &   operator [] (const char name[]) const;

    Attribute &     operator [] (const std::string &name);
    const Attribute &   operator [] (const std::string &name) const;

    template <class T> T& typedAttribute (const char name[]);
    template <class T> const T& typedAttribute (const char name[]) const;

    template <class T> T& typedAttribute (const std::string &name);
    template <class T> const T& typedAttribute (const std::string &name) const;

    template <class T> T* findTypedAttribute (const char name[]);
    template <class T> const T* findTypedAttribute (const char name[]) const;

    template <class T> T* findTypedAttribute (const std::string &name);
    template <class T> const T* findTypedAttribute (const std::string &name)
                       const;

    //---------------------------------------------
    // Iterator-style access to existing attributes
    //---------------------------------------------

    typedef std::map <Name, Attribute *> AttributeMap;

    class Iterator;
    class ConstIterator;

    Iterator      begin ();
    ConstIterator   begin () const;

    Iterator      end ();
    ConstIterator   end () const;

    Iterator      find (const char name[]);
    ConstIterator   find (const char name[]) const;

    Iterator      find (const std::string &name);
    ConstIterator   find (const std::string &name) const;


    //--------------------------------
    // Access to predefined attributes
    //--------------------------------

    IMATH_NAMESPACE::Box2i &    displayWindow ();
    const IMATH_NAMESPACE::Box2i &  displayWindow () const;

    IMATH_NAMESPACE::Box2i &    dataWindow ();
    const IMATH_NAMESPACE::Box2i &  dataWindow () const;

    float &     pixelAspectRatio ();
    const float &   pixelAspectRatio () const;

    IMATH_NAMESPACE::V2f &    screenWindowCenter ();
    const IMATH_NAMESPACE::V2f &    screenWindowCenter () const;

    float &     screenWindowWidth ();
    const float &   screenWindowWidth () const;

    ChannelList &   channels ();
    const ChannelList &   channels () const;

    LineOrder &     lineOrder ();
    const LineOrder &   lineOrder () const;

    Compression &   compression ();
    const Compression &   compression () const;


    //-----------------------------------------------------
    // Access to required attributes for multipart files
    // They are optional to non-multipart files and mandatory
    // for multipart files.
    //-----------------------------------------------------
    void                        setName (const string& name);

    string&                     name();
    const string&               name() const;

    bool                        hasName() const;

    void                        setType (const string& Type);

    string&                     type();
    const string&               type() const;

    bool                        hasType() const;

    void                        setVersion (const int version);

    int&                        version();
    const int&                  version() const;

    bool                        hasVersion() const;

    //
    // the chunkCount attribute is set automatically when a file is written.
    // There is no need to set it manually
    //
    void                        setChunkCount(int chunks);
    bool                        hasChunkCount() const;
    const int &                 chunkCount() const;
    int &                       chunkCount();

    
    //
    // for multipart files, return whether the file has a view string attribute
    // (for the deprecated single part multiview format EXR, see ImfMultiView.h)
    //
    void                       setView(const string & view);
    bool                       hasView() const;
    string &                   view();
    const string &             view() const;
    

    //----------------------------------------------------------------------
    // Tile Description:
    //
    // The tile description is a TileDescriptionAttribute whose name
    // is "tiles".  The "tiles" attribute must be present in any tiled
    // image file. When present, it describes various properties of the
    // tiles that make up the file.
    //
    // Convenience functions:
    //
    // setTileDescription(td)
    //     calls insert ("tiles", TileDescriptionAttribute (td))
    //
    // tileDescription()
    //     returns typedAttribute<TileDescriptionAttribute>("tiles").value()
    //
    // hasTileDescription()
    //     return findTypedAttribute<TileDescriptionAttribute>("tiles") != 0
    //
    //----------------------------------------------------------------------

    void      setTileDescription (const TileDescription & td);

    TileDescription &   tileDescription ();
    const TileDescription & tileDescription () const;

    bool      hasTileDescription() const;


    //----------------------------------------------------------------------
    // Preview image:
    //
    // The preview image is a PreviewImageAttribute whose name is "preview".
    // This attribute is special -- while an image file is being written,
    // the pixels of the preview image can be changed repeatedly by calling
    // OutputFile::updatePreviewImage().
    //
    // Convenience functions:
    //
    // setPreviewImage(p)
    //     calls insert ("preview", PreviewImageAttribute (p))
    //
    // previewImage()
    //     returns typedAttribute<PreviewImageAttribute>("preview").value()
    //
    // hasPreviewImage()
    //     return findTypedAttribute<PreviewImageAttribute>("preview") != 0
    //
    //----------------------------------------------------------------------

    void      setPreviewImage (const PreviewImage &p);

    PreviewImage &    previewImage ();
    const PreviewImage &  previewImage () const;

    bool      hasPreviewImage () const;


    //-------------------------------------------------------------
    // Sanity check -- examines the header, and throws an exception
    // if it finds something wrong (empty display window, negative
    // pixel aspect ratio, unknown compression sceme etc.)
    //
    // set isTiled to true if you are checking a tiled/multi-res
    // header
    //-------------------------------------------------------------

    void      sanityCheck (bool isTiled = false,
                           bool isMultipartFile = false) const;


    //----------------------------------------------------------------
    // Maximum image size and maximim tile size:
    //
    // sanityCheck() will throw an exception if the width or height of
    // the data window exceeds the maximum image width or height, or
    // if the size of a tile exceeds the maximum tile width or height.
    // 
    // At program startup the maximum image and tile width and height
    // are set to zero, meaning that width and height are unlimited.
    //
    // Limiting image and tile width and height limits how much memory
    // will be allocated when a file is opened.  This can help protect
    // applications from running out of memory while trying to read
    // a damaged image file.
    //----------------------------------------------------------------

    static void     setMaxImageSize (int maxWidth, int maxHeight);
    static void     setMaxTileSize (int maxWidth, int maxHeight);

    //
    // Check if the header reads nothing.
    //
    bool                        readsNothing();


    //------------------------------------------------------------------
    // Input and output:
    //
    // If the header contains a preview image attribute, then writeTo()
    // returns the position of that attribute in the output stream; this
    // information is used by OutputFile::updatePreviewImage().
    // If the header contains no preview image attribute, then writeTo()
    // returns 0.
    //------------------------------------------------------------------


    Int64     writeTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
           bool isTiled = false) const;

    void      readFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,
                        int &version);
    

  private:

    AttributeMap    _map;

    bool                        _readsNothing;
};


//----------
// Iterators
//----------

class Header::Iterator
{
  public:

    Iterator ();
    Iterator (const Header::AttributeMap::iterator &i);

    Iterator &      operator ++ ();
    Iterator      operator ++ (int);

    const char *    name () const;
    Attribute &     attribute () const;

  private:

    friend class Header::ConstIterator;

    Header::AttributeMap::iterator _i;
};


class Header::ConstIterator
{
  public:

    ConstIterator ();
    ConstIterator (const Header::AttributeMap::const_iterator &i);
    ConstIterator (const Header::Iterator &other);

    ConstIterator &   operator ++ ();
    ConstIterator     operator ++ (int);

    const char *    name () const;
    const Attribute &   attribute () const;

  private:

    friend bool operator == (const ConstIterator &, const ConstIterator &);
    friend bool operator != (const ConstIterator &, const ConstIterator &);

    Header::AttributeMap::const_iterator _i;
};


//------------------------------------------------------------------------
// Library initialization:
//
// In a multithreaded program, staticInitialize() must be called once
// during startup, before the program accesses any other functions or
// classes in the IlmImf library.  Calling staticInitialize() in this
// way avoids races during initialization of the library's global
// variables.
//
// Single-threaded programs are not required to call staticInitialize();
// initialization of the library's global variables happens automatically.
//
//------------------------------------------------------------------------

void staticInitialize ();


//-----------------
// Inline Functions
//-----------------


inline
Header::Iterator::Iterator (): _i()
{
    // empty
}


inline
Header::Iterator::Iterator (const Header::AttributeMap::iterator &i): _i (i)
{
    // empty
}


inline Header::Iterator &   
Header::Iterator::operator ++ ()
{
    ++_i;
    return *this;
}


inline Header::Iterator   
Header::Iterator::operator ++ (int)
{
    Iterator tmp = *this;
    ++_i;
    return tmp;
}


inline const char *
Header::Iterator::name () const
{
    return *_i->first;
}


inline Attribute &  
Header::Iterator::attribute () const
{
    return *_i->second;
}


inline
Header::ConstIterator::ConstIterator (): _i()
{
    // empty
}

inline
Header::ConstIterator::ConstIterator
    (const Header::AttributeMap::const_iterator &i): _i (i)
{
    // empty
}


inline
Header::ConstIterator::ConstIterator (const Header::Iterator &other):
    _i (other._i)
{
    // empty
}

inline Header::ConstIterator &
Header::ConstIterator::operator ++ ()
{
    ++_i;
    return *this;
}


inline Header::ConstIterator    
Header::ConstIterator::operator ++ (int)
{
    ConstIterator tmp = *this;
    ++_i;
    return tmp;
}


inline const char *
Header::ConstIterator::name () const
{
    return *_i->first;
}


inline const Attribute &  
Header::ConstIterator::attribute () const
{
    return *_i->second;
}


inline bool
operator == (const Header::ConstIterator &x, const Header::ConstIterator &y)
{
    return x._i == y._i;
}


inline bool
operator != (const Header::ConstIterator &x, const Header::ConstIterator &y)
{
    return !(x == y);
}


//---------------------
// Template definitions
//---------------------

template <class T>
T &
Header::typedAttribute (const char name[])
{
    Attribute *attr = &(*this)[name];
    T *tattr = dynamic_cast <T*> (attr);

    if (tattr == 0)
  throw IEX_NAMESPACE::TypeExc ("Unexpected attribute type.");

    return *tattr;
}


template <class T>
const T &
Header::typedAttribute (const char name[]) const
{
    const Attribute *attr = &(*this)[name];
    const T *tattr = dynamic_cast <const T*> (attr);

    if (tattr == 0)
  throw IEX_NAMESPACE::TypeExc ("Unexpected attribute type.");

    return *tattr;
}


template <class T>
T &
Header::typedAttribute (const std::string &name)
{
    return typedAttribute<T> (name.c_str());
}


template <class T>
const T &
Header::typedAttribute (const std::string &name) const
{
    return typedAttribute<T> (name.c_str());
}


template <class T>
T *
Header::findTypedAttribute (const char name[])
{
    AttributeMap::iterator i = _map.find (name);
    return (i == _map.end())? 0: dynamic_cast <T*> (i->second);
}


template <class T>
const T *
Header::findTypedAttribute (const char name[]) const
{
    AttributeMap::const_iterator i = _map.find (name);
    return (i == _map.end())? 0: dynamic_cast <const T*> (i->second);
}


template <class T>
T *
Header::findTypedAttribute (const std::string &name)
{
    return findTypedAttribute<T> (name.c_str());
}


template <class T>
const T *
Header::findTypedAttribute (const std::string &name) const
{
    return findTypedAttribute<T> (name.c_str());
}


OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT

#endif

Coverage Report

Created: 2025-10-28 06:24