mi32/imagecache.h

Go to the documentation of this file.

#ifndef  INC_MI32_IMAGECACHE_H
#define  INC_MI32_IMAGECACHE_H

#ifndef INC_RVC_IMAGE_H
   #include <rvc/image.h>
#endif

#ifndef INC_MI32_ERRHANDLER_H
   #include <mi32/errhandler.h>
#endif

//=====================================================================================================================
template <typename _TT> class IMAGECACHE_T {
   public:

      IMAGECACHE_T (
         RVC::IMAGE& image,         
         const _TT outofbound = 0   
         ) :
         m_Image(image),
         m_Band(((image.GetCellType() & (RVC::IMAGE::CELLTYPE_Color)) != 0) ? RVC::IMAGE::GetCompositeBandNum() : 0),
         m_OutOfBound(outofbound)
         { }

      virtual ~IMAGECACHE_T (
         ) {}

      bool IsOpen (
         ) {return m_Image.IsOpen(); }


      ERRVALUE Get (
         const INT32 line, 
         const INT32 column, 
         _TT& value
         ) const { return v_Get(line, column, value); }

      ERRVALUE Put (
         const INT32 line, 
         const INT32 column, 
         _TT value
         ) { return v_Put(line, column, value); }

      ERRVALUE Flush (
         ) { return v_Flush(); }

      bool IsInside (
         const INT32 line,
         const INT32 column
         ) const {
         if (line < 0) return false;
         if (column < 0) return  false;
         if (line >= m_Image.GetNumLines()) return false;
         if (column >= m_Image.GetNumColumns()) return false;
         return true;
         }

   protected:

      const _TT m_OutOfBound;
      const INT32 m_Band;
      RVC::IMAGE& m_Image;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual ERRVALUE v_Get (const INT32 line, const INT32 column, _TT& value) const = 0;
      virtual ERRVALUE v_Put (const INT32 line, const INT32 column, _TT value) = 0;
      virtual ERRVALUE v_Flush () = 0;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//=====================================================================================================================
template <typename _TT> class ROLLTILE_T : public IMAGECACHE_T<_TT> {
   public:

      ROLLTILE_T (
         RVC::IMAGE& image,               
         const _TT outofbound = 0,        
         const INT32 numLines = 64,       
         const INT32 numColumns = 64,     
         const INT32 numTileLines = 3,    
         const INT32 numTileColumns = 3   
         ) :
         IMAGECACHE_T<_TT>(image, outofbound),
         m_NumLines(numLines),
         m_NumColumns(numColumns),
         m_TileSize(numLines * numColumns),
         m_NumTileLines(numTileLines),
         m_NumTileColumns(numTileColumns),
         m_NumTiles(numTileLines * numTileColumns)
         {
         if (!Init()) Done();
         }

      ~ROLLTILE_T (
         ) { Done(); }

      INT32 GetNumColumnsPerTile (
         ) {return m_NumColumns; }

      INT32 GetNumLinesPerTile (
         ) {return m_NumLines; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      template <typename _TTT> struct TILE {

         TILE (
            ) :
            m_Buffer(0),
            m_NumColumns(-1),
            m_NumLines(-1),
            m_Dirty(false),
            m_TileColumn(-1),
            m_TileLine(-1)
            { }

         ~TILE (
            ) {
            }

         void Init (
            _TTT* buffer,
            INT32 numColumns,
            INT32 numLines
            ) {
            m_Buffer = buffer;
            m_NumColumns = numColumns;
            m_NumLines = numLines;
            m_Dirty = false;;
            m_TileColumn = -1;
            m_TileLine = -1;
            return;
            }

         bool IsDirty (
            ) { return m_Dirty; }

         ERRVALUE Read (
            RVC::IMAGE& image,
            const INT32 band,
            const INT32 tileLine,
            const INT32 tileColumn
            ) {
            const INT32 line = tileLine * m_NumLines;
            const INT32 numlines = MIN(m_NumLines, image.GetNumLines() - line);
            const INT32 column = tileColumn * m_NumColumns;
            const INT32 numcolumns = MIN(m_NumColumns, image.GetNumColumns() - column);
            _TTT *p = m_Buffer;
            for (INT32 i = 0, cline = line; i < numlines; ++i, p += m_NumColumns, ++cline) {
               ERRVALUE err = image.ReadBand(band, cline, column, p, numcolumns);
               if (err < 0) return SetErrPosn(err);
               }
            m_TileColumn = tileColumn;
            m_TileLine = tileLine;
            return 0;
            }

         ERRVALUE Write (
            RVC::IMAGE& image,
            const INT32 band
            ) {
            if (!m_Dirty) return 0;
            const INT32 line = m_TileLine * m_NumLines;
            const INT32 numlines = MIN(m_NumLines, image.GetNumLines() - line);
            const INT32 column = m_TileColumn * m_NumColumns;
            const INT32 numcolumns = MIN(m_NumColumns, image.GetNumColumns() - column);
            _TTT *p = m_Buffer;
            for (INT32 i = 0, cline = line; i < numlines; ++i, p += m_NumColumns, ++cline) {
               ERRVALUE err = image.WriteBand(band, cline, column, p, numcolumns);
               if (err < 0) return SetErrPosn(err);
               }
            m_Dirty = false;
            return 0;
            }

         _TTT Get (
            const INT32 line,
            const INT32 column
            ) {
            return m_Buffer[line * m_NumColumns + column];
            }

         void Put (
            const INT32 line,
            const INT32 column,
            _TTT value
            ) {
            m_Buffer[line * m_NumColumns + column] = value;
            m_Dirty = true;
            }

         INT32 GetTileColumn (
            ) { return m_TileColumn; }
         INT32 GetTileLine (
            ) { return m_TileLine; }

         _TTT* m_Buffer;
         INT32 m_NumColumns;
         INT32 m_NumLines;
         bool m_Dirty;
         INT32 m_TileColumn;
         INT32 m_TileLine;

         };

      ERRVALUE v_Get (
         const INT32 line,
         const INT32 column,
         _TT& value
         ) const {
         if (!IMAGECACHE_T<_TT>::IsInside(line, column)) { value = IMAGECACHE_T<_TT>::m_OutOfBound; return 0; }
         const INT32 lt = line / m_NumLines;
         const INT32 ct = column / m_NumColumns;
         const INT32 lti = lt % m_NumTileLines;
         const INT32 cti = ct % m_NumTileColumns;
         TILE<_TT>& tile = m_Tiles[lti * m_NumTileColumns + cti];
         if ((tile.GetTileColumn() != ct) || (tile.GetTileLine() != lt)) {
            ERRVALUE err = 0;
            if (tile.IsDirty()) {
               err = tile.Write(IMAGECACHE_T<_TT>::m_Image);
               if (err < 0) return SetErrPosn(err);
               }
            err = tile.Read(IMAGECACHE_T<_TT>::m_Image, lt, ct);
            if (err < 0) return SetErrPosn(err);
            }
         value = tile.Get(line % m_NumLines, column % m_NumColumns);
         return 1;
         }

      ERRVALUE v_Put (
         const INT32 line,
         const INT32 column,
         _TT value
         ) {
         if (!IMAGECACHE_T<_TT>::IsInside(line, column)) return 0;
         const INT32 lt = line / m_NumLines;
         const INT32 ct = column / m_NumColumns;
         const INT32 lti = lt % m_NumTileLines;
         const INT32 cti = ct % m_NumTileColumns;
         TILE<_TT>& tile = m_Tiles[lti * m_NumTileColumns + cti];
         if ((tile.GetTileColumn() != ct) || (tile.GetTileLine() != lt)) {
            ERRVALUE err = 0;
            if (tile.IsDirty()) {
               err = tile.Write(IMAGECACHE_T<_TT>::m_Image);
               if (err < 0) return SetErrPosn(err);
               }
            err = tile.Read(IMAGECACHE_T<_TT>::m_Image, lt, ct);
            if (err < 0) return SetErrPosn(err);
            }
         tile.Put(line % m_NumLines, column % m_NumColumns, value);
         return 1;
         }

      ERRVALUE v_Flush (
         ) {
         for (INT32 i = 0; i < m_NumTiles; ++i) {
            ERRVALUE err = m_Tiles[i].Write(IMAGECACHE_T<_TT>::m_Image);
            if (err < 0) return SetErrPosn(err);
            }
         return 0;
         }

      bool Init (
         ) {
         m_Buffer = new _TT[m_NumTiles * m_TileSize];

         ERRVALUE err = m_Tiles.Resize(m_NumTiles);
         if (err < 0) return false;

         _TT* p = m_Buffer;
         for (INT32 i = 0; i < m_NumTiles; ++i, p += m_TileSize) {
            m_Tiles[i].Init(p, m_NumColumns, m_NumLines);
            }
         return true;
         }

      void Done (
         ) {
         IMAGECACHE_T<_TT>::Flush();
         delete[] m_Buffer;
         return;
         }

      const INT32 m_NumColumns;
      const INT32 m_NumLines;
      const INT32 m_NumTileColumns;
      const INT32 m_NumTileLines;
      const INT32 m_NumTiles;
      const INT32 m_TileSize;

      _TT* m_Buffer;
      SIMPLE_ARRAY<TILE<_TT> > m_Tiles;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//=====================================================================================================================
template <typename _TT> class ROLLSPAN_T : public IMAGECACHE_T<_TT> {
   public:

      ROLLSPAN_T (
         RVC::IMAGE& image,               
         const _TT outofbound = 0,        
         const INT32 numColumns = 64,     
         const INT32 numSpanLines = 192,  
         const INT32 numSpanColumns = 3   
         ) :                              
         IMAGECACHE_T<_TT>(image, outofbound),
         m_NumColumns(numColumns),
         m_SpanSize(numColumns),
         m_NumSpanLines(numSpanLines),
         m_NumSpanColumns(numSpanColumns),
         m_NumSpans(numSpanLines * numSpanColumns)
         {
         if (!Init()) Done();
         }

      ~ROLLSPAN_T (
         ) { Done(); }

      INT32 GetNumColumnsPerSpan (
         ) { return m_NumColumns; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      template <typename _TTT> struct SPAN {

         SPAN (
            ) :
            m_Buffer(0),
            m_NumColumns(-1),
            m_Dirty(false),
            m_SpanColumn(-1),
            m_Line(-1)
            { }

         ~SPAN (
            ) {
            }

         void Init (
            _TTT* buffer,
            INT32 numColumns
            ) {
            m_Buffer = buffer;
            m_NumColumns = numColumns;
            m_Dirty = false;
            m_SpanColumn = -1;
            m_Line = -1;
            return;
            }

         bool IsDirty (
            ) { return m_Dirty; }

         ERRVALUE Read (
            RVC::IMAGE& image,
            const INT32 band,
            const INT32 line,
            const INT32 spanColumn
            ) {
            const INT32 column = spanColumn * m_NumColumns;
            const INT32 numcolumns = MIN(m_NumColumns, image.GetNumColumns() - column);
            ERRVALUE err = image.ReadBand(band, line, column, m_Buffer, numcolumns);
            if (err < 0) return SetErrPosn(err);
            m_SpanColumn = spanColumn;
            m_Line = line;
            return 0;
            }

         ERRVALUE Write (
            RVC::IMAGE& image,
            const INT32 band
            ) {
            if (!m_Dirty) return 0;
            const INT32 column = m_SpanColumn * m_NumColumns;
            const INT32 numcolumns = MIN(m_NumColumns, image.GetNumColumns() - column);
            ERRVALUE err = image.WriteBand(band, m_Line, column, m_Buffer, numcolumns);
            if (err < 0) return SetErrPosn(err);
            m_Dirty = false;
            return 0;
            }

         _TTT Get (
            const INT32 column
            ) {
            return m_Buffer[column];
            }

         void Put (
            const INT32 column,
            _TTT value
            ) {
            m_Buffer[column] = value;
            m_Dirty = true;
            }

         INT32 GetSpanColumn (
            ) { return m_SpanColumn; }

         INT32 GetLine (
            ) { return m_Line; }

         _TTT* m_Buffer;
         INT32 m_NumColumns;
         bool m_Dirty;
         INT32 m_SpanColumn;
         INT32 m_Line;

         };

         ERRVALUE v_Get (
         const INT32 line,
         const INT32 column,
         _TT& value
         ) const {
         if (!IMAGECACHE_T<_TT>::IsInside(line, column)) { value = IMAGECACHE_T<_TT>::m_OutOfBound; return 0; }

         const INT32 cs = column / m_NumColumns;
         const INT32 lsi = line % m_NumSpanLines;
         const INT32 csi = cs % m_NumSpanColumns;
         SPAN<_TT>& span = const_cast<SPAN<_TT>&>(m_Spans[lsi * m_NumSpanColumns + csi]);
         if ((span.GetSpanColumn() != cs) || (span.GetLine() != line)) {
            ERRVALUE err = 0;
            if (span.IsDirty()) {
               err = span.Write(IMAGECACHE_T<_TT>::m_Image, IMAGECACHE_T<_TT>::m_Band);
               if (err < 0) return SetErrPosn(err);
               }
            err = span.Read(IMAGECACHE_T<_TT>::m_Image, IMAGECACHE_T<_TT>::m_Band, line, cs);
            if (err < 0) return SetErrPosn(err);
            }
         value = span.Get(column % m_NumColumns);
         return 1;
         }

      ERRVALUE v_Put (
         const INT32 line,
         const INT32 column,
         _TT value
         ) {
         if (!IMAGECACHE_T<_TT>::IsInside(line, column)) return 0;

         const INT32 cs = column / m_NumColumns;
         const INT32 lsi = line % m_NumSpanLines;
         const INT32 csi = cs % m_NumSpanColumns;
         SPAN<_TT>& span = m_Spans[lsi * m_NumSpanColumns + csi];
         if ((span.GetSpanColumn() != cs) || (span.GetLine() != line)) {
            ERRVALUE err = 0;
            if (span.IsDirty()) {
               err = span.Write(IMAGECACHE_T<_TT>::m_Image, IMAGECACHE_T<_TT>::m_Band);
               if (err < 0) return SetErrPosn(err);
               }
            err = span.Read(IMAGECACHE_T<_TT>::m_Image, IMAGECACHE_T<_TT>::m_Band, line, cs);
            if (err < 0) return SetErrPosn(err);
            }
         span.Put(column % m_NumColumns, value);
         return 1;
         }

      ERRVALUE v_Flush (
         ) {
         for (INT32 i = 0; i < m_NumSpans; ++i) {
            ERRVALUE err = m_Spans[i].Write(IMAGECACHE_T<_TT>::m_Image, IMAGECACHE_T<_TT>::m_Band);
            if (err < 0) return SetErrPosn(err);
            }
         return 0;
         }

      bool Init (
         ) {
         m_Buffer = new _TT[m_NumSpans * m_SpanSize];

         ERRVALUE err = m_Spans.Resize(m_NumSpans);
         if (err < 0) return false;

         _TT* p = m_Buffer;
         for (INT32 i = 0; i < m_NumSpans; ++i, p += m_SpanSize) {
            m_Spans[i].Init(p, m_NumColumns);
            }

         return true;
         }

      void Done (
         ) {
         IMAGECACHE_T<_TT>::Flush();
         delete[] m_Buffer;

         return;
         }

      const INT32 m_NumColumns;
      const INT32 m_NumSpanColumns;
      const INT32 m_NumSpanLines;
      const INT32 m_NumSpans;
      const INT32 m_SpanSize;

      _TT* m_Buffer;
      SIMPLE_ARRAY<SPAN<_TT> > m_Spans;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================
class IMAGECACHE {
   public:

      IMAGECACHE (
         RVC::IMAGE& image,      
         const UINT8* outofbound 
         ) :
         m_Image(image),
         m_Band(((image.GetCellType() & (RVC::IMAGE::CELLTYPE_Color)) != 0) ? RVC::IMAGE::GetCompositeBandNum() : 0),
         m_ConvMode(RVC::IMAGE::GetNumBitsFromCellType(image.GetCellType()) < 8 ? RVC::IMAGE::CONVMODE_INT8 : RVC::IMAGE::CONVMODE_None),
         m_NumBytes(static_cast<UINT8>((RVC::IMAGE::GetNumBitsFromCellType(image.GetCellType()) + 7) / 8))
         {
         memcpy(m_OutOfBound, outofbound, m_NumBytes); 
         }

      virtual ~IMAGECACHE (
         ) {}

      bool IsOpen (
         ) const {return m_Image.IsOpen(); }


      ERRVALUE Get (
         const INT32 line, 
         const INT32 column, 
         UINT8* value
         ) const { return v_Get(line, column, value); }

      ERRVALUE Put (
         const INT32 line, 
         const INT32 column, 
         const UINT8* value
         ) { return v_Put(line, column, value); }

      ERRVALUE Flush (
         ) { return v_Flush(); }

      bool IsInside (
         const INT32 line,
         const INT32 column
         ) const {
         if (line < 0) return false;
         if (column < 0) return  false;
         if (line >= m_Image.GetNumLines()) return false;
         if (column >= m_Image.GetNumColumns()) return false;
         return true;
         }

      RVC::IMAGE& GetImage (
         ) const { return m_Image; }

   protected:

      const UINT8 m_NumBytes;
      const INT32 m_Band;
      const RVC::IMAGE::CONVMODE m_ConvMode;

      UINT8 m_OutOfBound[8];
      RVC::IMAGE& m_Image;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual ERRVALUE v_Get (const INT32 line, const INT32 column, UINT8* value) const = 0;
      virtual ERRVALUE v_Put (const INT32 line, const INT32 column, const UINT8* value) = 0;
      virtual ERRVALUE v_Flush () = 0;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================
class ROLLTILE : public IMAGECACHE {
   public:

      ROLLTILE (
         RVC::IMAGE& image,               
         const UINT8* outofbound,         
         const INT32 numLines = 64,       
         const INT32 numColumns = 64,     
         const INT32 numTileLines = 3,    
         const INT32 numTileColumns = 3   
         ) :
         IMAGECACHE(image, outofbound),
         m_NumLines(numLines),
         m_NumColumns(numColumns),
         m_TileSize(numLines * numColumns),
         m_NumTileLines(numTileLines),
         m_NumTileColumns(numTileColumns),
         m_NumTiles(numTileLines * numTileColumns)
         {
         if (!Init()) Done();
         }

      ~ROLLTILE (
         ) { Done(); }

      INT32 GetNumColumnsPerTile (
         ) {return m_NumColumns; }

      INT32 GetNumLinesPerTile (
         ) {return m_NumLines; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      struct TILE {

         TILE (
            ) :
            m_Buffer(0),
            m_NumBytes(0),
            m_NumColumns(-1),
            m_NumLines(-1),
            m_Dirty(false),
            m_TileColumn(-1),
            m_TileLine(-1)
            {
            }

         ~TILE (
            ) {
            }

         void Init (
            UINT8* buffer,
            UINT8 NumBytes,
            INT32 numColumns,
            INT32 numLines
            ) {
            m_Buffer = buffer;
            m_NumBytes = NumBytes;
            m_NumColumns = numColumns;
            m_NumLines = numLines;
            m_Dirty = false;;
            m_TileColumn = -1;
            m_TileLine = -1;
            return;
            }

         bool IsDirty (
            ) { return m_Dirty; }

         ERRVALUE Read (
            RVC::IMAGE& image,
            const INT32 band,
            const RVC::IMAGE::CONVMODE convmode,
            const INT32 tileLine,
            const INT32 tileColumn
            ) {
            const INT32 line = tileLine * m_NumLines;
            const INT32 numlines = MIN(m_NumLines, image.GetNumLines() - line);
            const INT32 column = tileColumn * m_NumColumns;
            const INT32 numcolumns = MIN(m_NumColumns, image.GetNumColumns() - column);
            UINT8 *p = m_Buffer;
            for (INT32 i = 0, cline = line; i < numlines; ++i, p += m_NumColumns * m_NumBytes, ++cline) {
               ERRVALUE err = image.ReadBand(band, cline, column, p, numcolumns, convmode);
               if (err < 0) return SetErrPosn(err);
               }
            m_TileColumn = tileColumn;
            m_TileLine = tileLine;
            return 0;
            }

         ERRVALUE Write (
            RVC::IMAGE& image,
            const INT32 band,
            const RVC::IMAGE::CONVMODE convmode
            ) {
            if (!m_Dirty) return 0;
            const INT32 line = m_TileLine * m_NumLines;
            const INT32 numlines = MIN(m_NumLines, image.GetNumLines() - line);
            const INT32 column = m_TileColumn * m_NumColumns;
            const INT32 numcolumns = MIN(m_NumColumns, image.GetNumColumns() - column);
            UINT8 *p = m_Buffer;
            for (INT32 i = 0, cline = line; i < numlines; ++i, p += m_NumColumns * m_NumBytes, ++cline) {
               ERRVALUE err = image.WriteBand(band, cline, column, p, numcolumns, convmode);
               if (err < 0) return SetErrPosn(err);
               }
            m_Dirty = false;
            return 0;
            }

         const UINT8* Get (
            const INT32 line,
            const INT32 column
            ) const {
            return &m_Buffer[(line * m_NumColumns + column) * m_NumBytes];
            }

         void Put (
            const INT32 line,
            const INT32 column,
            const UINT8* value
            ) {
            memcpy(&m_Buffer[(line * m_NumColumns + column) * m_NumBytes], value, m_NumBytes);
            m_Dirty = true;
            }

         INT32 GetTileColumn (
            ) { return m_TileColumn; }

         INT32 GetTileLine (
            ) { return m_TileLine; }

         UINT8* m_Buffer;
         UINT8 m_NumBytes;
         INT32 m_NumColumns;
         INT32 m_NumLines;
         bool m_Dirty;
         INT32 m_TileColumn;
         INT32 m_TileLine;

         };

      ERRVALUE v_Get (
         const INT32 line,
         const INT32 column,
         UINT8* value
         ) const {
            if (!IMAGECACHE::IsInside(line, column)) { memcpy(value, IMAGECACHE::m_OutOfBound, m_NumBytes); return 0; }
         const INT32 lt = line / m_NumLines;
         const INT32 ct = column / m_NumColumns;
         const INT32 lti = lt % m_NumTileLines;
         const INT32 cti = ct % m_NumTileColumns;
         TILE& tile = const_cast<TILE&>(m_Tiles[lti * m_NumTileColumns + cti]);
         if ((tile.GetTileColumn() != ct) || (tile.GetTileLine() != lt)) {
            ERRVALUE err = 0;
            if (tile.IsDirty()) {
               err = tile.Write(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode);
               if (err < 0) return SetErrPosn(err);
               }
            err = tile.Read(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode, lt, ct);
            if (err < 0) return SetErrPosn(err);
            }
         memcpy(value, const_cast<UINT8*>(tile.Get(line % m_NumLines, column % m_NumColumns)), m_NumBytes);
         return 1;
         }

      ERRVALUE v_Put (
         const INT32 line,
         const INT32 column,
         const UINT8* value
         ) {
         if (!IMAGECACHE::IsInside(line, column)) return 0;
         const INT32 lt = line / m_NumLines;
         const INT32 ct = column / m_NumColumns;
         const INT32 lti = lt % m_NumTileLines;
         const INT32 cti = ct % m_NumTileColumns;
         TILE& tile = m_Tiles[lti * m_NumTileColumns + cti];
         if ((tile.GetTileColumn() != ct) || (tile.GetTileLine() != lt)) {
            ERRVALUE err = 0;
            if (tile.IsDirty()) {
               err = tile.Write(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode);
               if (err < 0) return SetErrPosn(err);
               }
            err = tile.Read(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode, lt, ct);
            if (err < 0) return SetErrPosn(err);
            }
         tile.Put(line % m_NumLines, column % m_NumColumns, value);
         return 1;
         }

      ERRVALUE v_Flush (
         ) {
         for (INT32 i = 0; i < m_NumTiles; ++i) {
            ERRVALUE err = m_Tiles[i].Write(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode);
            if (err < 0) return SetErrPosn(err);
            }
         return 0;
         }

      bool Init (
         ) {
         m_Buffer = new UINT8[m_NumTiles * m_TileSize * m_NumBytes];

         ERRVALUE err = m_Tiles.Resize(m_NumTiles);
         if (err < 0) return false;

         UINT8* p = m_Buffer;
         for (INT32 i = 0; i < m_NumTiles; ++i, p += m_TileSize * m_NumBytes) {
            m_Tiles[i].Init(p, m_NumBytes, m_NumColumns, m_NumLines);
            }
         return true;
         }

      void Done (
         ) {
         IMAGECACHE::Flush();
         delete[] m_Buffer;
         return;
         }

      const INT32 m_NumColumns;
      const INT32 m_NumLines;
      const INT32 m_NumTileColumns;
      const INT32 m_NumTileLines;
      const INT32 m_NumTiles;
      const INT32 m_TileSize;

      UINT8* m_Buffer;
      SIMPLE_ARRAY<TILE> m_Tiles;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================
class ROLLSPAN : public IMAGECACHE {
   public:

      ROLLSPAN (
         RVC::IMAGE& image,               
         const UINT8* outofbound,         
         const INT32 numColumns = 64,     
         const INT32 numSpanLines = 192,  
         const INT32 numSpanColumns = 3   
         ) :                              
         IMAGECACHE(image, outofbound),
         m_NumColumns(numColumns),
         m_SpanSize(numColumns),
         m_NumSpanLines(numSpanLines),
         m_NumSpanColumns(numSpanColumns),
         m_NumSpans(numSpanLines * numSpanColumns)
         {
         if (!Init()) Done();
         }

      ~ROLLSPAN (
         ) { Done(); }

      INT32 GetNumColumnsPerSpan (
         ) { return m_NumColumns; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      struct SPAN {

         SPAN (
            ) :
            m_Buffer(0),
            m_NumBytes(0),
            m_NumColumns(-1),
            m_Dirty(false),
            m_SpanColumn(-1),
            m_Line(-1)
            {
            }

         ~SPAN (
            ) {
            }

         void Init (
            UINT8* buffer,
            UINT8 NumBytes,
            INT32 numColumns
            ) {
            m_Buffer = buffer;
            m_NumBytes = NumBytes;
            m_NumColumns = numColumns;
            m_Dirty = false;
            m_SpanColumn = -1;
            m_Line = -1;
            return;
            }

         bool IsDirty (
            ) { return m_Dirty; }

         ERRVALUE Read (
            RVC::IMAGE& image,
            const INT32 band,
            const RVC::IMAGE::CONVMODE convmode,
            const INT32 line,
            const INT32 spanColumn
            ) {
            const INT32 column = spanColumn * m_NumColumns;
            const INT32 numcolumns = MIN(m_NumColumns, image.GetNumColumns() - column);
            ERRVALUE err = image.ReadBand(band, line, column, m_Buffer, numcolumns, convmode);
            if (err < 0) return SetErrPosn(err);
            m_SpanColumn = spanColumn;
            m_Line = line;
            return 0;
            }

         ERRVALUE Write (
            RVC::IMAGE& image,
            const INT32 band,
            const RVC::IMAGE::CONVMODE convmode
            ) {
            if (!m_Dirty) return 0;
            const INT32 column = m_SpanColumn * m_NumColumns;
            const INT32 numcolumns = MIN(m_NumColumns, image.GetNumColumns() - column);
            ERRVALUE err = image.WriteBand(band, m_Line, column, m_Buffer, numcolumns, convmode);
            if (err < 0) return SetErrPosn(err);
            m_Dirty = false;
            return 0;
            }

         UINT8* Get (
            const INT32 column
            ) {
            return &m_Buffer[column * m_NumBytes];
            }

         void Put (
            const INT32 column,
            const UINT8* value
            ) {
            memcpy(&m_Buffer[column * m_NumBytes], value, m_NumBytes);
            m_Dirty = true;
            }

         INT32 GetSpanColumn (
            ) { return m_SpanColumn; }

         INT32 GetLine (
            ) { return m_Line; }

         UINT8* m_Buffer;
         UINT8 m_NumBytes;
         INT32 m_NumColumns;
         bool m_Dirty;
         INT32 m_SpanColumn;
         INT32 m_Line;

         };

      ERRVALUE v_Get (
         const INT32 line,
         const INT32 column,
         UINT8* value
         ) const {
         if (!IMAGECACHE::IsInside(line, column)) { memcpy(value, IMAGECACHE::m_OutOfBound, m_NumBytes); return 0; }

         const INT32 cs = column / m_NumColumns;
         const INT32 lsi = line % m_NumSpanLines;
         const INT32 csi = cs % m_NumSpanColumns;
         SPAN& span = const_cast<SPAN&>(m_Spans[lsi * m_NumSpanColumns + csi]);
         if ((span.GetSpanColumn() != cs) || (span.GetLine() != line)) {
            ERRVALUE err = 0;
            if (span.IsDirty()) {
               err = span.Write(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode);
               if (err < 0) return SetErrPosn(err);
               }
            err = span.Read(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode, line, cs);
            if (err < 0) return SetErrPosn(err);
            }
         memcpy(value, span.Get(column % m_NumColumns), m_NumBytes);
         return 1;
         }

      ERRVALUE v_Put (
         const INT32 line,
         const INT32 column,
         const UINT8* value
         ) {
         if (!IMAGECACHE::IsInside(line, column)) return 0;

         const INT32 cs = column / m_NumColumns;
         const INT32 lsi = line % m_NumSpanLines;
         const INT32 csi = cs % m_NumSpanColumns;
         SPAN& span = m_Spans[lsi * m_NumSpanColumns + csi];
         if ((span.GetSpanColumn() != cs) || (span.GetLine() != line)) {
            ERRVALUE err = 0;
            if (span.IsDirty()) {
               err = span.Write(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode);
               if (err < 0) return SetErrPosn(err);
               }
            err = span.Read(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode, line, cs);
            if (err < 0) return SetErrPosn(err);
            }
         span.Put(column % m_NumColumns, value);
         return 1;
         }

      ERRVALUE v_Flush (
         ) {
         for (INT32 i = 0; i < m_NumSpans; ++i) {
            ERRVALUE err = m_Spans[i].Write(IMAGECACHE::m_Image, IMAGECACHE::m_Band, IMAGECACHE::m_ConvMode);
            if (err < 0) return SetErrPosn(err);
            }
         return 0;
         }

      bool Init (
         ) {
         m_Buffer = new UINT8[m_NumSpans * m_SpanSize * m_NumBytes];

         ERRVALUE err = m_Spans.Resize(m_NumSpans);
         if (err < 0) return false;

         UINT8* p = m_Buffer;
         for (INT32 i = 0; i < m_NumSpans; ++i, p += m_SpanSize * m_NumBytes) {
            m_Spans[i].Init(p, m_NumBytes, m_NumColumns);
            }

         return true;
         }

      void Done (
         ) {
         IMAGECACHE::Flush();
         delete[] m_Buffer;

         return;
         }

      const INT32 m_NumColumns;
      const INT32 m_NumSpanColumns;
      const INT32 m_NumSpanLines;
      const INT32 m_NumSpans;
      const INT32 m_SpanSize;

      UINT8* m_Buffer;
      SIMPLE_ARRAY<SPAN> m_Spans;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

#endif   // INC_MI32_IMAGECACHE_H

---