utilities/CxImage/xmemfile.cpp

   1 #include "xmemfile.h"\r
   2 \r
   3 //////////////////////////////////////////////////////////\r
   4 CxMemFile::CxMemFile(BYTE* pBuffer, DWORD size)\r
   5 {\r
   6         m_pBuffer = pBuffer;\r
   7         m_Position = 0;\r
   8         m_Size = m_Edge = size;\r
   9         m_bFreeOnClose = (bool)(pBuffer==0);\r
  10 }\r
  11 //////////////////////////////////////////////////////////\r
  12 CxMemFile::~CxMemFile()\r
  13 {\r
  14         Close();\r
  15 }\r
  16 //////////////////////////////////////////////////////////\r
  17 bool CxMemFile::Close()\r
  18 {\r
  19         if ( (m_pBuffer) && (m_bFreeOnClose) ){\r
  20                 free(m_pBuffer);\r
  21                 m_pBuffer = NULL;\r
  22                 m_Size = 0;\r
  23         }\r
  24         return true;\r
  25 }\r
  26 //////////////////////////////////////////////////////////\r
  27 bool CxMemFile::Open()\r
  28 {\r
  29         if (m_pBuffer) return false;    // Can't re-open without closing first\r
  30 \r
  31         m_Position = m_Size = m_Edge = 0;\r
  32         m_pBuffer=(BYTE*)malloc(1);\r
  33         m_bFreeOnClose = true;\r
  34 \r
  35         return (m_pBuffer!=0);\r
  36 }\r
  37 //////////////////////////////////////////////////////////\r
  38 BYTE* CxMemFile::GetBuffer(bool bDetachBuffer)\r
  39 {\r
  40         //can only detach, avoid inadvertantly attaching to\r
  41         // memory that may not be ours [Jason De Arte]\r
  42         if( bDetachBuffer )\r
  43                 m_bFreeOnClose = false;\r
  44         return m_pBuffer;\r
  45 }\r
  46 //////////////////////////////////////////////////////////\r
  47 size_t CxMemFile::Read(void *buffer, size_t size, size_t count)\r
  48 {\r
  49         if (buffer==NULL) return 0;\r
  50 \r
  51         if (m_pBuffer==NULL) return 0;\r
  52         if (m_Position >= (long)m_Size) return 0;\r
  53 \r
  54         long nCount = (long)(count*size);\r
  55         if (nCount == 0) return 0;\r
  56 \r
  57         long nRead;\r
  58         if (m_Position + nCount > (long)m_Size)\r
  59                 nRead = (m_Size - m_Position);\r
  60         else\r
  61                 nRead = nCount;\r
  62 \r
  63         memcpy(buffer, m_pBuffer + m_Position, nRead);\r
  64         m_Position += nRead;\r
  65 \r
  66         return (size_t)(nRead/size);\r
  67 }\r
  68 //////////////////////////////////////////////////////////\r
  69 size_t CxMemFile::Write(const void *buffer, size_t size, size_t count)\r
  70 {\r
  71         if (m_pBuffer==NULL) return 0;\r
  72         if (buffer==NULL) return 0;\r
  73 \r
  74         long nCount = (long)(count*size);\r
  75         if (nCount == 0) return 0;\r
  76 \r
  77         if (m_Position + nCount > m_Edge){\r
  78                 if (!Alloc(m_Position + nCount)){\r
  79                         return false;\r
  80                 }\r
  81         }\r
  82 \r
  83         memcpy(m_pBuffer + m_Position, buffer, nCount);\r
  84 \r
  85         m_Position += nCount;\r
  86 \r
  87         if (m_Position > (long)m_Size) m_Size = m_Position;\r
  88         \r
  89         return count;\r
  90 }\r
  91 //////////////////////////////////////////////////////////\r
  92 bool CxMemFile::Seek(long offset, int origin)\r
  93 {\r
  94         if (m_pBuffer==NULL) return false;\r
  95         long lNewPos = m_Position;\r
  96 \r
  97         if (origin == SEEK_SET)          lNewPos = offset;\r
  98         else if (origin == SEEK_CUR) lNewPos += offset;\r
  99         else if (origin == SEEK_END) lNewPos = m_Size + offset;\r
 100         else return false;\r
 101 \r
 102         if (lNewPos < 0) lNewPos = 0;\r
 103 \r
 104         m_Position = lNewPos;\r
 105         return true;\r
 106 }\r
 107 //////////////////////////////////////////////////////////\r
 108 long CxMemFile::Tell()\r
 109 {\r
 110         if (m_pBuffer==NULL) return -1;\r
 111         return m_Position;\r
 112 }\r
 113 //////////////////////////////////////////////////////////\r
 114 long CxMemFile::Size()\r
 115 {\r
 116         if (m_pBuffer==NULL) return -1;\r
 117         return m_Size;\r
 118 }\r
 119 //////////////////////////////////////////////////////////\r
 120 bool CxMemFile::Flush()\r
 121 {\r
 122         if (m_pBuffer==NULL) return false;\r
 123         return true;\r
 124 }\r
 125 //////////////////////////////////////////////////////////\r
 126 bool CxMemFile::Eof()\r
 127 {\r
 128         if (m_pBuffer==NULL) return true;\r
 129         return (m_Position >= (long)m_Size);\r
 130 }\r
 131 //////////////////////////////////////////////////////////\r
 132 long CxMemFile::Error()\r
 133 {\r
 134         if (m_pBuffer==NULL) return -1;\r
 135         return (m_Position > (long)m_Size);\r
 136 }\r
 137 //////////////////////////////////////////////////////////\r
 138 bool CxMemFile::PutC(unsigned char c)\r
 139 {\r
 140         if (m_pBuffer==NULL) return false;\r
 141 \r
 142         if (m_Position >= m_Edge){\r
 143                 if (!Alloc(m_Position + 1)){\r
 144                         return false;\r
 145                 }\r
 146         }\r
 147 \r
 148         m_pBuffer[m_Position++] = c;\r
 149 \r
 150         if (m_Position > (long)m_Size) m_Size = m_Position;\r
 151         \r
 152         return true;\r
 153 }\r
 154 //////////////////////////////////////////////////////////\r
 155 long CxMemFile::GetC()\r
 156 {\r
 157         if (Eof()) return EOF;\r
 158         return *(BYTE*)((BYTE*)m_pBuffer + m_Position++);\r
 159 }\r
 160 //////////////////////////////////////////////////////////\r
 161 char * CxMemFile::GetS(char *string, int n)\r
 162 {\r
 163         n--;\r
 164         long c,i=0;\r
 165         while (i<n){\r
 166                 c = GetC();\r
 167                 if (c == EOF) return 0;\r
 168                 string[i++] = (char)c;\r
 169                 if (c == '\n') break;\r
 170         }\r
 171         string[i] = 0;\r
 172         return string;\r
 173 }\r
 174 //////////////////////////////////////////////////////////\r
 175 long    CxMemFile::Scanf(const char *format, void* output)\r
 176 {\r
 177         return 0;\r
 178 }\r
 179 //////////////////////////////////////////////////////////\r
 180 bool CxMemFile::Alloc(DWORD dwNewLen)\r
 181 {\r
 182         if (dwNewLen > (DWORD)m_Edge)\r
 183         {\r
 184                 // find new buffer size\r
 185                 DWORD dwNewBufferSize = (DWORD)(((dwNewLen>>16)+1)<<16);\r
 186 \r
 187                 // allocate new buffer\r
 188                 if (m_pBuffer == NULL) m_pBuffer = (BYTE*)malloc(dwNewBufferSize);\r
 189                 else    m_pBuffer = (BYTE*)realloc(m_pBuffer, dwNewBufferSize);\r
 190                 // I own this buffer now (caller knows nothing about it)\r
 191                 m_bFreeOnClose = true;\r
 192 \r
 193                 m_Edge = dwNewBufferSize;\r
 194         }\r
 195         return (m_pBuffer!=0);\r
 196 }\r
 197 //////////////////////////////////////////////////////////\r
 198 void CxMemFile::Free()\r
 199 {\r
 200         Close();\r
 201 }\r
 202 //////////////////////////////////////////////////////////\r