1 : /******************************************************************************
2 : * $Id: mrsidstream.cpp 16078 2009-01-14 05:43:02Z warmerdam $
3 : *
4 : * Project: Multi-resolution Seamless Image Database (MrSID)
5 : * Purpose: Input/output stream wrapper for usage with LizardTech's
6 : * MrSID SDK, implemenattion of the wrapper class methods.
7 : * Author: Andrey Kiselev, dron@ak4719.spb.edu
8 : *
9 : ******************************************************************************
10 : * Copyright (c) 2008, Andrey Kiselev <dron@ak4719.spb.edu>
11 : *
12 : * Permission is hereby granted, free of charge, to any person obtaining a
13 : * copy of this software and associated documentation files (the "Software"),
14 : * to deal in the Software without restriction, including without limitation
15 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
16 : * and/or sell copies of the Software, and to permit persons to whom the
17 : * Software is furnished to do so, subject to the following conditions:
18 : *
19 : * The above copyright notice and this permission notice shall be included
20 : * in all copies or substantial portions of the Software.
21 : *
22 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23 : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28 : * DEALINGS IN THE SOFTWARE.
29 : ****************************************************************************/
30 :
31 : #include "cpl_error.h"
32 : #include "mrsidstream.h"
33 :
34 : CPL_CVSID("$Id: mrsidstream.cpp 16078 2009-01-14 05:43:02Z warmerdam $");
35 :
36 : LT_USE_NAMESPACE(LizardTech)
37 :
38 : /************************************************************************/
39 : /* ==================================================================== */
40 : /* LTIVSIStream */
41 : /* ==================================================================== */
42 : /************************************************************************/
43 :
44 108 : LTIVSIStream::LTIVSIStream() : poFileHandle(NULL), nError(0), pnRefCount(NULL),
45 108 : bIsOpen(FALSE)
46 : {
47 108 : }
48 :
49 : /************************************************************************/
50 : /* ~LTIVSIStream() */
51 : /************************************************************************/
52 :
53 108 : LTIVSIStream::~LTIVSIStream()
54 : {
55 108 : if ( poFileHandle)
56 : {
57 21 : (*pnRefCount)--;
58 21 : if (*pnRefCount == 0)
59 : {
60 19 : VSIFCloseL( (FILE *)poFileHandle );
61 19 : nError = errno;
62 19 : delete pnRefCount;
63 : }
64 : }
65 108 : }
66 :
67 : /************************************************************************/
68 : /* initialize() */
69 : /************************************************************************/
70 :
71 : LT_STATUS LTIVSIStream::initialize( const char *pszFilename,
72 19 : const char *pszAccess )
73 : {
74 19 : CPLAssert(poFileHandle == NULL);
75 :
76 19 : errno = 0;
77 19 : poFileHandle = (VSIVirtualHandle *)VSIFOpenL( pszFilename, pszAccess );
78 19 : if (poFileHandle)
79 : {
80 19 : pnRefCount = new int;
81 19 : *pnRefCount = 1;
82 : }
83 19 : nError = errno;
84 :
85 19 : return poFileHandle ? LT_STS_Success : LT_STS_Failure;
86 : }
87 :
88 : /************************************************************************/
89 : /* initialize() */
90 : /************************************************************************/
91 :
92 2 : LT_STATUS LTIVSIStream::initialize( LTIVSIStream* ltiVSIStream )
93 : {
94 2 : CPLAssert(poFileHandle == NULL);
95 :
96 2 : poFileHandle = ltiVSIStream->poFileHandle;
97 2 : if (poFileHandle)
98 : {
99 2 : pnRefCount = ltiVSIStream->pnRefCount;
100 2 : (*pnRefCount) ++;
101 : }
102 :
103 2 : return poFileHandle ? LT_STS_Success : LT_STS_Failure;
104 : }
105 :
106 : /************************************************************************/
107 : /* isEOF() */
108 : /************************************************************************/
109 :
110 0 : bool LTIVSIStream::isEOF()
111 : {
112 0 : CPLAssert(poFileHandle);
113 :
114 0 : errno = 0;
115 0 : bool bIsEOF = (0 != poFileHandle->Eof());
116 0 : nError = errno;
117 :
118 0 : return bIsEOF;
119 : }
120 :
121 : /************************************************************************/
122 : /* isOpen() */
123 : /************************************************************************/
124 :
125 1490 : bool LTIVSIStream::isOpen()
126 : {
127 1490 : return poFileHandle != NULL && bIsOpen;
128 : }
129 :
130 : /************************************************************************/
131 : /* open() */
132 : /************************************************************************/
133 :
134 741 : LT_STATUS LTIVSIStream::open()
135 : {
136 741 : bIsOpen = poFileHandle != NULL;
137 741 : return poFileHandle ? LT_STS_Success : LT_STS_Failure;
138 : }
139 :
140 : /************************************************************************/
141 : /* close() */
142 : /************************************************************************/
143 :
144 743 : LT_STATUS LTIVSIStream::close()
145 : {
146 743 : CPLAssert(poFileHandle);
147 :
148 743 : bIsOpen = FALSE;
149 743 : errno = 0;
150 743 : if ( poFileHandle->Seek( 0, SEEK_SET ) == 0 )
151 743 : return LT_STS_Success;
152 : else
153 : {
154 0 : nError = errno;
155 0 : return LT_STS_Failure;
156 : }
157 : }
158 :
159 : /************************************************************************/
160 : /* read() */
161 : /************************************************************************/
162 :
163 70511 : lt_uint32 LTIVSIStream::read( lt_uint8 *pDest, lt_uint32 nBytes )
164 : {
165 70511 : CPLAssert(poFileHandle);
166 :
167 70511 : errno = 0;
168 : lt_uint32 nBytesRead =
169 70511 : (lt_uint32)poFileHandle->Read( pDest, 1, nBytes );
170 70511 : nError = errno;
171 :
172 70511 : return nBytesRead;
173 : }
174 :
175 : /************************************************************************/
176 : /* write() */
177 : /************************************************************************/
178 :
179 0 : lt_uint32 LTIVSIStream::write( const lt_uint8 *pSrc, lt_uint32 nBytes )
180 : {
181 0 : CPLAssert(poFileHandle);
182 :
183 0 : errno = 0;
184 : lt_uint32 nBytesWritten =
185 0 : (lt_uint32)poFileHandle->Write( pSrc, 1, nBytes );
186 0 : nError = errno;
187 :
188 0 : return nBytesWritten;
189 : }
190 :
191 : /************************************************************************/
192 : /* seek() */
193 : /************************************************************************/
194 :
195 1191 : LT_STATUS LTIVSIStream::seek( lt_int64 nOffset, LTIOSeekDir nOrigin )
196 : {
197 1191 : CPLAssert(poFileHandle);
198 :
199 : int nWhence;
200 1191 : switch (nOrigin)
201 : {
202 : case (LTIO_SEEK_DIR_BEG):
203 1154 : nWhence = SEEK_SET;
204 1154 : break;
205 :
206 : case (LTIO_SEEK_DIR_CUR):
207 : {
208 24 : nWhence = SEEK_CUR;
209 24 : if( nOffset < 0 )
210 : {
211 20 : nWhence = SEEK_SET;
212 20 : nOffset += (lt_int64)poFileHandle->Tell();
213 : }
214 24 : break;
215 : }
216 :
217 : case (LTIO_SEEK_DIR_END):
218 13 : nWhence = SEEK_END;
219 13 : break;
220 :
221 : default:
222 0 : return LT_STS_Failure;
223 : }
224 :
225 1191 : if ( poFileHandle->Seek( (vsi_l_offset)nOffset, nWhence ) == 0 )
226 1191 : return LT_STS_Success;
227 : else
228 : {
229 0 : nError = errno;
230 0 : return LT_STS_Failure;
231 : }
232 : }
233 :
234 : /************************************************************************/
235 : /* tell() */
236 : /************************************************************************/
237 :
238 748 : lt_int64 LTIVSIStream::tell()
239 : {
240 748 : CPLAssert(poFileHandle);
241 :
242 748 : errno = 0;
243 748 : lt_int64 nPos = (lt_int64)poFileHandle->Tell();
244 748 : nError = errno;
245 :
246 748 : return nPos;
247 : }
248 :
249 : /************************************************************************/
250 : /* duplicate() */
251 : /************************************************************************/
252 :
253 2 : LTIOStreamInf* LTIVSIStream::duplicate()
254 : {
255 2 : LTIVSIStream *poNew = new LTIVSIStream;
256 2 : poNew->initialize( this );
257 :
258 2 : return poNew;
259 : }
260 :
261 : /************************************************************************/
262 : /* getLastError() */
263 : /************************************************************************/
264 :
265 0 : LT_STATUS LTIVSIStream::getLastError() const
266 : {
267 0 : return nError;
268 : }
269 :
270 : /************************************************************************/
271 : /* getID() */
272 : /************************************************************************/
273 :
274 6 : const char *LTIVSIStream::getID() const
275 : {
276 6 : return "LTIVSIStream:";
277 : }
278 :
|
