Zero out temporary arrays before use in PDF encryption.
[pdfium.git] / core / src / fxcodec / fx_libopenjpeg / libopenjpeg20 / cio.c
1 /*
2  * The copyright in this software is being made available under the 2-clauses 
3  * BSD License, included below. This software may be subject to other third 
4  * party and contributor rights, including patent rights, and no such rights
5  * are granted under this license.
6  *
7  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
8  * Copyright (c) 2002-2014, Professor Benoit Macq
9  * Copyright (c) 2001-2003, David Janssens
10  * Copyright (c) 2002-2003, Yannick Verschueren
11  * Copyright (c) 2003-2007, Francois-Olivier Devaux 
12  * Copyright (c) 2003-2014, Antonin Descampe
13  * Copyright (c) 2005, Herve Drolon, FreeImage Team
14  * Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR 
15  * Copyright (c) 2012, CS Systemes d'Information, France
16  * All rights reserved.
17  *
18  * Redistribution and use in source and binary forms, with or without
19  * modification, are permitted provided that the following conditions
20  * are met:
21  * 1. Redistributions of source code must retain the above copyright
22  *    notice, this list of conditions and the following disclaimer.
23  * 2. Redistributions in binary form must reproduce the above copyright
24  *    notice, this list of conditions and the following disclaimer in the
25  *    documentation and/or other materials provided with the distribution.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37  * POSSIBILITY OF SUCH DAMAGE.
38  */
39
40 #include "opj_includes.h"
41
42 /* ----------------------------------------------------------------------- */
43
44
45 /* ----------------------------------------------------------------------- */
46
47 void opj_write_bytes_BE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes)
48 {
49         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes;
50
51         assert(p_nb_bytes > 0 && p_nb_bytes <=  sizeof(OPJ_UINT32));
52
53         memcpy(p_buffer,l_data_ptr,p_nb_bytes);
54 }
55
56 void opj_write_bytes_LE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes)
57 {
58         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes - 1;
59         OPJ_UINT32 i;
60
61         assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
62
63         for     (i=0;i<p_nb_bytes;++i) {
64                 *(p_buffer++) = *(l_data_ptr--);
65         }
66 }
67
68 void opj_read_bytes_BE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes)
69 {
70         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
71
72         assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
73
74         *p_value = 0;
75         memcpy(l_data_ptr+4-p_nb_bytes,p_buffer,p_nb_bytes);
76 }
77
78 void opj_read_bytes_LE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes)
79 {
80         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + p_nb_bytes-1;
81         OPJ_UINT32 i;
82
83         assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
84
85         *p_value = 0;
86         for (i=0;i<p_nb_bytes;++i) {
87                 *(l_data_ptr--) = *(p_buffer++);
88         }
89 }
90
91 void opj_write_double_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
92 {
93         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
94         memcpy(p_buffer,l_data_ptr,sizeof(OPJ_FLOAT64));
95 }
96
97 void opj_write_double_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
98 {
99         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(OPJ_FLOAT64) - 1;
100         OPJ_UINT32 i;
101         for     (i=0;i<sizeof(OPJ_FLOAT64);++i) {
102                 *(p_buffer++) = *(l_data_ptr--);
103         }
104 }
105
106 void opj_read_double_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
107 {
108         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
109         memcpy(l_data_ptr,p_buffer,sizeof(OPJ_FLOAT64));
110 }
111
112 void opj_read_double_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
113 {
114         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT64)-1;
115         OPJ_UINT32 i;
116         for (i=0;i<sizeof(OPJ_FLOAT64);++i) {
117                 *(l_data_ptr--) = *(p_buffer++);
118         }
119 }
120
121 void opj_write_float_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
122 {
123         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
124         memcpy(p_buffer,l_data_ptr,sizeof(OPJ_FLOAT32));
125 }
126
127 void opj_write_float_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
128 {
129         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(OPJ_FLOAT32) - 1;
130         OPJ_UINT32 i;
131         for     (i=0;i<sizeof(OPJ_FLOAT32);++i) {
132                 *(p_buffer++) = *(l_data_ptr--);
133         }
134 }
135
136 void opj_read_float_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
137 {
138         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
139         memcpy(l_data_ptr,p_buffer,sizeof(OPJ_FLOAT32));
140 }
141
142 void opj_read_float_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
143 {
144         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT32)-1;
145         OPJ_UINT32 i;
146         for     (i=0;i<sizeof(OPJ_FLOAT32);++i) {
147                 *(l_data_ptr--) = *(p_buffer++);
148         }
149 }
150
151 opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size,OPJ_BOOL l_is_input)
152 {
153         opj_stream_private_t * l_stream = 00;
154         l_stream = (opj_stream_private_t*) opj_malloc(sizeof(opj_stream_private_t));
155         if (! l_stream) {
156                 return 00;
157         }
158
159         memset(l_stream,0,sizeof(opj_stream_private_t));
160         l_stream->m_buffer_size = p_buffer_size;
161         l_stream->m_stored_data = (OPJ_BYTE *) opj_malloc(p_buffer_size);
162         if (! l_stream->m_stored_data) {
163                 opj_free(l_stream);
164                 return 00;
165         }
166
167         l_stream->m_current_data = l_stream->m_stored_data;
168
169         if (l_is_input) {
170                 l_stream->m_status |= opj_stream_e_input;
171                 l_stream->m_opj_skip = opj_stream_read_skip;
172                 l_stream->m_opj_seek = opj_stream_read_seek;
173         }
174         else {
175                 l_stream->m_status |= opj_stream_e_output;
176                 l_stream->m_opj_skip = opj_stream_write_skip;
177                 l_stream->m_opj_seek = opj_stream_write_seek;
178         }
179
180         l_stream->m_read_fn = opj_stream_default_read;
181         l_stream->m_write_fn = opj_stream_default_write;
182         l_stream->m_skip_fn = opj_stream_default_skip;
183         l_stream->m_seek_fn = opj_stream_default_seek;
184
185         return (opj_stream_t *) l_stream;
186 }
187
188 opj_stream_t* OPJ_CALLCONV opj_stream_default_create(OPJ_BOOL l_is_input)
189 {
190         return opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE,l_is_input);
191 }
192
193 void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream)
194 {
195         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
196         
197         if (l_stream) {
198                 if (l_stream->m_free_user_data_fn) {
199                         l_stream->m_free_user_data_fn(l_stream->m_user_data);
200                 }
201                 opj_free(l_stream->m_stored_data);
202                 l_stream->m_stored_data = 00;
203                 opj_free(l_stream);
204         }
205 }
206
207 void OPJ_CALLCONV opj_stream_destroy_v3(opj_stream_t* p_stream)
208 {
209         opj_stream_destroy(p_stream);
210 }
211
212 void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream, opj_stream_read_fn p_function)
213 {
214         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
215
216         if ((!l_stream) || (! (l_stream->m_status & opj_stream_e_input))) {
217                 return;
218         }
219
220         l_stream->m_read_fn = p_function;
221 }
222
223 void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream, opj_stream_seek_fn p_function)
224 {
225         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
226         
227         if (!l_stream) {
228                 return;
229         }
230         l_stream->m_seek_fn = p_function;
231 }
232
233 void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream, opj_stream_write_fn p_function)
234 {
235         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
236         
237         if ((!l_stream )|| (! (l_stream->m_status & opj_stream_e_output))) {
238                 return;
239         }
240
241         l_stream->m_write_fn = p_function;
242 }
243
244 void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream, opj_stream_skip_fn p_function)
245 {
246         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
247         
248         if (! l_stream) {
249                 return;
250         }
251
252         l_stream->m_skip_fn = p_function;
253 }
254
255 void OPJ_CALLCONV opj_stream_set_user_data(opj_stream_t* p_stream, void * p_data)
256 {
257         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
258         if (!l_stream)
259                 return;
260         l_stream->m_user_data = p_data;
261 }
262
263 void OPJ_CALLCONV opj_stream_set_user_data_v3(opj_stream_t* p_stream, void * p_data, opj_stream_free_user_data_fn p_function)
264 {
265         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
266         if (!l_stream)
267                 return;
268         l_stream->m_user_data = p_data;
269   l_stream->m_free_user_data_fn = p_function;
270 }
271
272 void OPJ_CALLCONV opj_stream_set_user_data_length(opj_stream_t* p_stream, OPJ_UINT64 data_length)
273 {
274         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
275         if (!l_stream)
276                 return;
277         l_stream->m_user_data_length = data_length;
278 }
279
280 OPJ_SIZE_T opj_stream_read_data (opj_stream_private_t * p_stream,OPJ_BYTE * p_buffer, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
281 {
282         OPJ_SIZE_T l_read_nb_bytes = 0;
283         if (p_stream->m_bytes_in_buffer >= p_size) {
284                 memcpy(p_buffer,p_stream->m_current_data,p_size);
285                 p_stream->m_current_data += p_size;
286                 p_stream->m_bytes_in_buffer -= p_size;
287                 l_read_nb_bytes += p_size;
288                 p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
289                 return l_read_nb_bytes;
290         }
291
292         /* we are now in the case when the remaining data if not sufficient */
293         if (p_stream->m_status & opj_stream_e_end) {
294                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
295                 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
296                 p_stream->m_current_data += p_stream->m_bytes_in_buffer;
297                 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
298                 p_stream->m_bytes_in_buffer = 0;
299                 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
300         }
301
302         /* the flag is not set, we copy data and then do an actual read on the stream */
303         if (p_stream->m_bytes_in_buffer) {
304                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
305                 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
306                 p_stream->m_current_data = p_stream->m_stored_data;
307                 p_buffer += p_stream->m_bytes_in_buffer;
308                 p_size -= p_stream->m_bytes_in_buffer;
309                 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
310                 p_stream->m_bytes_in_buffer = 0;
311         }
312         else {
313     /* case where we are already at the end of the buffer
314        so reset the m_current_data to point to the start of the
315        stored buffer to get ready to read from disk*/
316                 p_stream->m_current_data = p_stream->m_stored_data;
317         }
318
319         while(1){
320                 /* we should read less than a chunk -> read a chunk */
321                 if (p_size < p_stream->m_buffer_size) {
322                         /* we should do an actual read on the media */
323                         p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_stream->m_stored_data,p_stream->m_buffer_size,p_stream->m_user_data);
324
325                         if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T)-1) {
326                                 /* end of stream */
327                                 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
328
329                                 p_stream->m_bytes_in_buffer = 0;
330                                 p_stream->m_status |= opj_stream_e_end;
331                                 /* end of stream */
332                                 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
333                         }
334                         else if (p_stream->m_bytes_in_buffer < p_size) {
335                                 /* not enough data */
336                                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
337                                 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
338                                 p_stream->m_current_data = p_stream->m_stored_data;
339                                 p_buffer += p_stream->m_bytes_in_buffer;
340                                 p_size -= p_stream->m_bytes_in_buffer;
341                                 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
342                                 p_stream->m_bytes_in_buffer = 0;
343                         }
344                         else {
345                                 l_read_nb_bytes += p_size;
346                                 memcpy(p_buffer,p_stream->m_current_data,p_size);
347                                 p_stream->m_current_data += p_size;
348                                 p_stream->m_bytes_in_buffer -= p_size;
349                                 p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
350                                 return l_read_nb_bytes;
351                         }
352                 }
353                 else {
354                         /* direct read on the dest buffer */
355                         p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_buffer,p_size,p_stream->m_user_data);
356
357                         if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T)-1) {
358                                 /*  end of stream */
359                                 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
360
361                                 p_stream->m_bytes_in_buffer = 0;
362                                 p_stream->m_status |= opj_stream_e_end;
363                                 /* end of stream */
364                                 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
365                         }
366                         else if (p_stream->m_bytes_in_buffer < p_size) {
367                                 /* not enough data */
368                                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
369                                 p_stream->m_current_data = p_stream->m_stored_data;
370                                 p_buffer += p_stream->m_bytes_in_buffer;
371                                 p_size -= p_stream->m_bytes_in_buffer;
372                                 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
373                                 p_stream->m_bytes_in_buffer = 0;
374                         }
375                         else {
376                                 /* we have read the exact size */
377                                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
378                                 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
379                                 p_stream->m_current_data = p_stream->m_stored_data;
380                                 p_stream->m_bytes_in_buffer = 0;
381                                 return l_read_nb_bytes;
382                         }
383                 }
384         }
385 }
386
387 OPJ_SIZE_T opj_stream_write_data (opj_stream_private_t * p_stream,
388                                                                   const OPJ_BYTE * p_buffer,
389                                                                   OPJ_SIZE_T p_size, 
390                                                                   opj_event_mgr_t * p_event_mgr)
391 {
392         OPJ_SIZE_T l_remaining_bytes = 0;
393         OPJ_SIZE_T l_write_nb_bytes = 0;
394
395         if (p_stream->m_status & opj_stream_e_error) {
396                 return (OPJ_SIZE_T)-1;
397         }
398
399         while(1) {
400                 l_remaining_bytes = p_stream->m_buffer_size - p_stream->m_bytes_in_buffer;
401                 
402                 /* we have more memory than required */
403                 if (l_remaining_bytes >= p_size) {
404                         memcpy(p_stream->m_current_data, p_buffer, p_size);
405                         
406                         p_stream->m_current_data += p_size;
407                         p_stream->m_bytes_in_buffer += p_size;
408                         l_write_nb_bytes += p_size;
409                         p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
410                         
411                         return l_write_nb_bytes;
412                 }
413
414                 /* we copy data and then do an actual read on the stream */
415                 if (l_remaining_bytes) {
416                         l_write_nb_bytes += l_remaining_bytes;
417                         
418                         memcpy(p_stream->m_current_data,p_buffer,l_remaining_bytes);
419                         
420                         p_stream->m_current_data = p_stream->m_stored_data;
421                         
422                         p_buffer += l_remaining_bytes;
423                         p_size -= l_remaining_bytes;
424                         p_stream->m_bytes_in_buffer += l_remaining_bytes;
425                         p_stream->m_byte_offset += (OPJ_OFF_T)l_remaining_bytes;
426                 }
427
428                 if (! opj_stream_flush(p_stream, p_event_mgr)) {
429                         return (OPJ_SIZE_T)-1;
430                 }
431         }
432
433 }
434
435 OPJ_BOOL opj_stream_flush (opj_stream_private_t * p_stream, opj_event_mgr_t * p_event_mgr)
436 {
437         /* the number of bytes written on the media. */
438         OPJ_SIZE_T l_current_write_nb_bytes = 0;
439
440         p_stream->m_current_data = p_stream->m_stored_data;
441
442         while (p_stream->m_bytes_in_buffer) {
443                 /* we should do an actual write on the media */
444                 l_current_write_nb_bytes = p_stream->m_write_fn(p_stream->m_current_data,
445                                                                                                                 p_stream->m_bytes_in_buffer,
446                                                                                                                 p_stream->m_user_data);
447                 
448                 if (l_current_write_nb_bytes == (OPJ_SIZE_T)-1) {
449                         p_stream->m_status |= opj_stream_e_error;
450                         opj_event_msg(p_event_mgr, EVT_INFO, "Error on writing stream!\n");
451
452                         return OPJ_FALSE;
453                 }
454
455                 p_stream->m_current_data += l_current_write_nb_bytes;
456                 p_stream->m_bytes_in_buffer -= l_current_write_nb_bytes;
457         }
458
459         p_stream->m_current_data = p_stream->m_stored_data;
460         
461         return OPJ_TRUE;
462 }
463
464 OPJ_OFF_T opj_stream_read_skip (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
465 {
466         OPJ_OFF_T l_skip_nb_bytes = 0;
467         OPJ_OFF_T l_current_skip_nb_bytes = 0;
468         
469         assert( p_size >= 0 );
470         
471         if (p_stream->m_bytes_in_buffer >= (OPJ_SIZE_T)p_size) {
472                 p_stream->m_current_data += p_size;
473                 /* it is safe to cast p_size to OPJ_SIZE_T since it is <= m_bytes_in_buffer
474                 which is of type OPJ_SIZE_T */
475                 p_stream->m_bytes_in_buffer -= (OPJ_SIZE_T)p_size;
476                 l_skip_nb_bytes += p_size;
477                 p_stream->m_byte_offset += l_skip_nb_bytes;
478                 return l_skip_nb_bytes;
479         }
480
481         /* we are now in the case when the remaining data if not sufficient */
482         if (p_stream->m_status & opj_stream_e_end) {
483                 l_skip_nb_bytes += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
484                 p_stream->m_current_data += p_stream->m_bytes_in_buffer;
485                 p_stream->m_bytes_in_buffer = 0;
486                 p_stream->m_byte_offset += l_skip_nb_bytes;
487                 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) -1;
488         }
489
490         /* the flag is not set, we copy data and then do an actual skip on the stream */
491         if (p_stream->m_bytes_in_buffer) {
492                 l_skip_nb_bytes += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
493                 p_stream->m_current_data = p_stream->m_stored_data;
494                 p_size -= (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
495                 p_stream->m_bytes_in_buffer = 0;
496         }
497
498         while (p_size > 0) {
499                 /* we should do an actual skip on the media */
500                 l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
501                 if (l_current_skip_nb_bytes == (OPJ_OFF_T) -1) {
502                         opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
503
504                         p_stream->m_status |= opj_stream_e_end;
505                         p_stream->m_byte_offset += l_skip_nb_bytes;
506                         /* end if stream */
507                         return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) -1;
508                 }
509                 p_size -= l_current_skip_nb_bytes;
510                 l_skip_nb_bytes += l_current_skip_nb_bytes;
511         }
512
513         p_stream->m_byte_offset += l_skip_nb_bytes;
514         
515         return l_skip_nb_bytes;
516 }
517
518 OPJ_OFF_T opj_stream_write_skip (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
519 {
520         OPJ_BOOL l_is_written = 0;
521         OPJ_OFF_T l_current_skip_nb_bytes = 0;
522         OPJ_OFF_T l_skip_nb_bytes = 0;
523
524         if (p_stream->m_status & opj_stream_e_error) {
525                 return (OPJ_OFF_T) -1;
526         }
527
528         /* we should flush data */
529         l_is_written = opj_stream_flush (p_stream, p_event_mgr);
530         if (! l_is_written) {
531                 p_stream->m_status |= opj_stream_e_error;
532                 p_stream->m_bytes_in_buffer = 0;
533                 return (OPJ_OFF_T) -1;
534         }
535         /* then skip */
536
537         while (p_size > 0) {
538                 /* we should do an actual skip on the media */
539                 l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
540                 
541                 if (l_current_skip_nb_bytes == (OPJ_OFF_T)-1) {
542                         opj_event_msg(p_event_mgr, EVT_INFO, "Stream error!\n");
543
544                         p_stream->m_status |= opj_stream_e_error;
545                         p_stream->m_byte_offset += l_skip_nb_bytes;
546                         /* end if stream */
547                         return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T)-1;
548                 }
549                 p_size -= l_current_skip_nb_bytes;
550                 l_skip_nb_bytes += l_current_skip_nb_bytes;
551         }
552
553         p_stream->m_byte_offset += l_skip_nb_bytes;
554         
555         return l_skip_nb_bytes;
556 }
557
558 OPJ_OFF_T opj_stream_tell (const opj_stream_private_t * p_stream)
559 {
560         return p_stream->m_byte_offset;
561 }
562
563 OPJ_OFF_T opj_stream_get_number_byte_left (const opj_stream_private_t * p_stream)
564 {
565   assert( p_stream->m_byte_offset >= 0 );
566   assert( p_stream->m_user_data_length >= (OPJ_UINT64)p_stream->m_byte_offset);
567   return p_stream->m_user_data_length ?
568                                 (OPJ_OFF_T)(p_stream->m_user_data_length) - p_stream->m_byte_offset :
569                                 0;
570 }
571
572 OPJ_OFF_T opj_stream_skip (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
573 {
574         assert(p_size >= 0);
575         return p_stream->m_opj_skip(p_stream,p_size,p_event_mgr);
576 }
577
578 OPJ_BOOL opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
579 {
580         OPJ_ARG_NOT_USED(p_event_mgr);
581         p_stream->m_current_data = p_stream->m_stored_data;
582         p_stream->m_bytes_in_buffer = 0;
583
584         if( !(p_stream->m_seek_fn(p_size,p_stream->m_user_data)) ) {
585                 p_stream->m_status |= opj_stream_e_end;
586                 return OPJ_FALSE;
587         }
588         else {
589                 /* reset stream status */
590                 p_stream->m_status &= (~opj_stream_e_end);
591                 p_stream->m_byte_offset = p_size;
592
593         }
594
595         return OPJ_TRUE;
596 }
597
598 OPJ_BOOL opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
599 {
600         if (! opj_stream_flush(p_stream,p_event_mgr)) {
601                 p_stream->m_status |= opj_stream_e_error;
602                 return OPJ_FALSE;
603         }
604
605         p_stream->m_current_data = p_stream->m_stored_data;
606         p_stream->m_bytes_in_buffer = 0;
607
608         if (! p_stream->m_seek_fn(p_size,p_stream->m_user_data)) {
609                 p_stream->m_status |= opj_stream_e_error;
610                 return OPJ_FALSE;
611         }
612         else {
613                 p_stream->m_byte_offset = p_size;
614         }
615
616         return OPJ_TRUE;
617 }
618
619 OPJ_BOOL opj_stream_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr)
620 {
621         assert(p_size >= 0);
622         return p_stream->m_opj_seek(p_stream,p_size,p_event_mgr);
623 }
624
625 OPJ_BOOL opj_stream_has_seek (const opj_stream_private_t * p_stream)
626 {
627         return p_stream->m_seek_fn != opj_stream_default_seek;
628 }
629
630 OPJ_SIZE_T opj_stream_default_read (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
631 {
632         OPJ_ARG_NOT_USED(p_buffer);
633         OPJ_ARG_NOT_USED(p_nb_bytes);
634         OPJ_ARG_NOT_USED(p_user_data);
635         return (OPJ_SIZE_T) -1;
636 }
637
638 OPJ_SIZE_T opj_stream_default_write (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
639 {
640         OPJ_ARG_NOT_USED(p_buffer);
641         OPJ_ARG_NOT_USED(p_nb_bytes);
642         OPJ_ARG_NOT_USED(p_user_data);
643         return (OPJ_SIZE_T) -1;
644 }
645
646 OPJ_OFF_T opj_stream_default_skip (OPJ_OFF_T p_nb_bytes, void * p_user_data)
647 {
648         OPJ_ARG_NOT_USED(p_nb_bytes);
649         OPJ_ARG_NOT_USED(p_user_data);
650         return (OPJ_OFF_T) -1;
651 }
652
653 OPJ_BOOL opj_stream_default_seek (OPJ_OFF_T p_nb_bytes, void * p_user_data)
654 {
655         OPJ_ARG_NOT_USED(p_nb_bytes);
656         OPJ_ARG_NOT_USED(p_user_data);
657         return OPJ_FALSE;
658 }