pfs.h

Go to the documentation of this file.

#ifndef PFS_H
#define PFS_H

#include <stdio.h>
#include <string.h>
#include "array2d.h"

struct option;

namespace pfs
{

  template<class T>
    class SelfDestructPtr
    {
      T *ptr;
      mutable bool itsOwn;
    public:
      explicit SelfDestructPtr( T *ptr = 0 ): ptr(ptr), itsOwn(ptr!=0)
        {
        }

      SelfDestructPtr( const SelfDestructPtr& r ) 
        : itsOwn(r.itsOwn), ptr(r.release()) {}
      
      SelfDestructPtr& operator=( const SelfDestructPtr& r ) {
        if (&r != this) {
            if (ptr != r.ptr) {
              if( itsOwn ) delete ptr;
              itsOwn = r.itsOwn;
            }
            else if( r.itsOwn ) itsOwn = true;
            ptr = r.release();
        }
        return *this;
      }
      
      ~SelfDestructPtr()
        {
          if( itsOwn ) 
            delete ptr;
        }  

      bool operator==( const SelfDestructPtr &x ) const {
        return *(ptr) == *(x.ptr);
      }

      bool operator!=( const SelfDestructPtr &x ) const {
        return *(ptr) != *(x.ptr);
      }
      
      T& operator*()  const            {return *ptr;}
      T* operator->() const            {return ptr;}
      T* get()        const            {return ptr;}
      T* release()    const  {itsOwn = false; return ptr;}
      
    };
  
  
  class TagIterator 
    {
    public:
      virtual const char *getNext() = 0;
      virtual bool hasNext() const = 0;
    };

  typedef SelfDestructPtr<TagIterator> TagIteratorPtr;
  
  class TagContainer
    {
    public:
      virtual const char* getString( const char *tagName ) = 0;

      virtual void setString( const char *tagName, const char *tagValue ) = 0;
      
      virtual void removeTag( const char *tagName ) = 0;

      virtual TagIteratorPtr getIterator() const = 0;
    };


  class Channel : public Array2D {
  public:
    int getWidth() const {
      return getCols();
    }

    virtual int getHeight() const
      {
        return getRows();
      }

    virtual const char *getName() const = 0;
        
    virtual TagContainer *getTags() = 0;

    virtual float *getRawData() = 0;
  };

  class ChannelIterator 
    {
    public:
      virtual Channel *getNext() = 0;
      virtual bool hasNext() const = 0;
    };
  
  typedef SelfDestructPtr<ChannelIterator> ChannelIteratorPtr;
  
  class Frame {
  public:
    virtual int getWidth() const = 0;

    virtual int getHeight() const = 0;

    virtual void getXYZChannels( Channel* &X, Channel* &Y, Channel* &Z ) = 0;

    virtual void createXYZChannels( Channel* &X, Channel* &Y, Channel* &Z ) = 0;

    virtual Channel* getChannel( const char *name ) = 0;

    virtual Channel* createChannel( const char *name ) = 0;


    virtual void removeChannel( Channel *channel ) = 0;
    
    virtual ChannelIterator *getChannels() = 0;
    
    virtual ChannelIteratorPtr getChannelIterator() = 0;
    
    virtual TagContainer *getTags() = 0;

    virtual ~Frame() = 0;
    
  };

  void copyTags( Frame *from, Frame *to );
  
  void copyTags( const TagContainer *from, TagContainer *to );

  
  class DOMIOImpl;

  class DOMIO {
    DOMIOImpl *impl;
  public:
    DOMIO();
    ~DOMIO();

    Frame *createFrame( int width, int height );

    Frame *readFrame( FILE *inputStream );

    void writeFrame( Frame *frame, FILE *outputStream );

    void freeFrame( Frame *frame );
  };



  struct FrameFile
  {
    FrameFile( FILE *fh, const char* fileName ): fh(fh), fileName( fileName )
    {
    }

    FILE *fh;

    const char *fileName;
  };


  class FrameFileIteratorImpl;

  class FrameFileIterator
    {
      FrameFileIteratorImpl *impl;
    public:
      FrameFileIterator( int &argc, char* argv[], const char *fopenMode,
        const char *fileNamePrefix = NULL, FILE *stdinout = NULL,
        const char *optstring = NULL, const struct option *getopt_long = NULL );
      ~FrameFileIterator();

      FrameFile getNextFrameFile( );

      void closeFrameFile( FrameFile &frameFile );

      static void printUsage( FILE *out, const char *progName );

    };


  enum ColorSpace
    {
      CS_XYZ = 0,         
      CS_RGB,             
      CS_SRGB,            





      CS_YUV,             
      CS_Yxy,              
      CS_LAST             
    };

  void transformColorSpace( ColorSpace inCS,
    const Array2D *inC1, const Array2D *inC2, const Array2D *inC3,
    ColorSpace outCS,
    Array2D *outC1, Array2D *outC2, Array2D *outC3 );


  class Exception
    {
      char msg[1024];
    public:
      Exception( const char* const message )
  {
          strcpy( msg, message );
  }
      
      ~Exception() {};

      const char* getMessage()
        {
          return msg;
  }
    };


  class CommandLineException: public Exception
    {
    public:
      CommandLineException( const char* const message ): Exception( message )
  {
  }
    };


}



#endif

---