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.
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.
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
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.
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.
40 #include "opj_includes.h"
42 /* ----------------------------------------------------------------------- */
45 /* ----------------------------------------------------------------------- */
47 void opj_write_bytes_BE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes)
49 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes;
51 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
53 memcpy(p_buffer,l_data_ptr,p_nb_bytes);
56 void opj_write_bytes_LE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes)
58 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes - 1;
61 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
63 for (i=0;i<p_nb_bytes;++i) {
64 *(p_buffer++) = *(l_data_ptr--);
68 void opj_read_bytes_BE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes)
70 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
72 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
75 memcpy(l_data_ptr+4-p_nb_bytes,p_buffer,p_nb_bytes);
78 void opj_read_bytes_LE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes)
80 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + p_nb_bytes-1;
83 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
86 for (i=0;i<p_nb_bytes;++i) {
87 *(l_data_ptr--) = *(p_buffer++);
91 void opj_write_double_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
93 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
94 memcpy(p_buffer,l_data_ptr,sizeof(OPJ_FLOAT64));
97 void opj_write_double_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
99 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(OPJ_FLOAT64) - 1;
101 for (i=0;i<sizeof(OPJ_FLOAT64);++i) {
102 *(p_buffer++) = *(l_data_ptr--);
106 void opj_read_double_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
108 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
109 memcpy(l_data_ptr,p_buffer,sizeof(OPJ_FLOAT64));
112 void opj_read_double_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
114 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT64)-1;
116 for (i=0;i<sizeof(OPJ_FLOAT64);++i) {
117 *(l_data_ptr--) = *(p_buffer++);
121 void opj_write_float_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
123 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
124 memcpy(p_buffer,l_data_ptr,sizeof(OPJ_FLOAT32));
127 void opj_write_float_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
129 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(OPJ_FLOAT32) - 1;
131 for (i=0;i<sizeof(OPJ_FLOAT32);++i) {
132 *(p_buffer++) = *(l_data_ptr--);
136 void opj_read_float_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
138 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
139 memcpy(l_data_ptr,p_buffer,sizeof(OPJ_FLOAT32));
142 void opj_read_float_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
144 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT32)-1;
146 for (i=0;i<sizeof(OPJ_FLOAT32);++i) {
147 *(l_data_ptr--) = *(p_buffer++);
151 opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size,OPJ_BOOL l_is_input)
153 opj_stream_private_t * l_stream = 00;
154 l_stream = (opj_stream_private_t*) opj_malloc(sizeof(opj_stream_private_t));
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) {
167 l_stream->m_current_data = l_stream->m_stored_data;
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;
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;
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;
185 return (opj_stream_t *) l_stream;
188 opj_stream_t* OPJ_CALLCONV opj_stream_default_create(OPJ_BOOL l_is_input)
190 return opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE,l_is_input);
193 void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream)
195 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
198 if (l_stream->m_free_user_data_fn) {
199 l_stream->m_free_user_data_fn(l_stream->m_user_data);
201 opj_free(l_stream->m_stored_data);
202 l_stream->m_stored_data = 00;
207 void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream, opj_stream_read_fn p_function)
209 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
211 if ((!l_stream) || (! (l_stream->m_status & opj_stream_e_input))) {
215 l_stream->m_read_fn = p_function;
218 void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream, opj_stream_seek_fn p_function)
220 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
225 l_stream->m_seek_fn = p_function;
228 void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream, opj_stream_write_fn p_function)
230 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
232 if ((!l_stream )|| (! (l_stream->m_status & opj_stream_e_output))) {
236 l_stream->m_write_fn = p_function;
239 void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream, opj_stream_skip_fn p_function)
241 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
247 l_stream->m_skip_fn = p_function;
250 void OPJ_CALLCONV opj_stream_set_user_data(opj_stream_t* p_stream, void * p_data, opj_stream_free_user_data_fn p_function)
252 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
255 l_stream->m_user_data = p_data;
256 l_stream->m_free_user_data_fn = p_function;
259 void OPJ_CALLCONV opj_stream_set_user_data_length(opj_stream_t* p_stream, OPJ_UINT64 data_length)
261 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
264 l_stream->m_user_data_length = data_length;
267 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)
269 OPJ_SIZE_T l_read_nb_bytes = 0;
270 if (p_stream->m_bytes_in_buffer >= p_size) {
271 memcpy(p_buffer,p_stream->m_current_data,p_size);
272 p_stream->m_current_data += p_size;
273 p_stream->m_bytes_in_buffer -= p_size;
274 l_read_nb_bytes += p_size;
275 p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
276 return l_read_nb_bytes;
279 /* we are now in the case when the remaining data if not sufficient */
280 if (p_stream->m_status & opj_stream_e_end) {
281 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
282 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
283 p_stream->m_current_data += p_stream->m_bytes_in_buffer;
284 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
285 p_stream->m_bytes_in_buffer = 0;
286 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
289 /* the flag is not set, we copy data and then do an actual read on the stream */
290 if (p_stream->m_bytes_in_buffer) {
291 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
292 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
293 p_stream->m_current_data = p_stream->m_stored_data;
294 p_buffer += p_stream->m_bytes_in_buffer;
295 p_size -= p_stream->m_bytes_in_buffer;
296 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
297 p_stream->m_bytes_in_buffer = 0;
300 /* case where we are already at the end of the buffer
301 so reset the m_current_data to point to the start of the
302 stored buffer to get ready to read from disk*/
303 p_stream->m_current_data = p_stream->m_stored_data;
307 /* we should read less than a chunk -> read a chunk */
308 if (p_size < p_stream->m_buffer_size) {
309 /* we should do an actual read on the media */
310 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);
312 if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T)-1) {
314 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
316 p_stream->m_bytes_in_buffer = 0;
317 p_stream->m_status |= opj_stream_e_end;
319 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
321 else if (p_stream->m_bytes_in_buffer < p_size) {
322 /* not enough data */
323 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
324 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
325 p_stream->m_current_data = p_stream->m_stored_data;
326 p_buffer += p_stream->m_bytes_in_buffer;
327 p_size -= p_stream->m_bytes_in_buffer;
328 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
329 p_stream->m_bytes_in_buffer = 0;
332 l_read_nb_bytes += p_size;
333 memcpy(p_buffer,p_stream->m_current_data,p_size);
334 p_stream->m_current_data += p_size;
335 p_stream->m_bytes_in_buffer -= p_size;
336 p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
337 return l_read_nb_bytes;
341 /* direct read on the dest buffer */
342 p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_buffer,p_size,p_stream->m_user_data);
344 if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T)-1) {
346 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
348 p_stream->m_bytes_in_buffer = 0;
349 p_stream->m_status |= opj_stream_e_end;
351 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
353 else if (p_stream->m_bytes_in_buffer < p_size) {
354 /* not enough data */
355 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
356 p_stream->m_current_data = p_stream->m_stored_data;
357 p_buffer += p_stream->m_bytes_in_buffer;
358 p_size -= p_stream->m_bytes_in_buffer;
359 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
360 p_stream->m_bytes_in_buffer = 0;
363 /* we have read the exact size */
364 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
365 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
366 p_stream->m_current_data = p_stream->m_stored_data;
367 p_stream->m_bytes_in_buffer = 0;
368 return l_read_nb_bytes;
374 OPJ_SIZE_T opj_stream_write_data (opj_stream_private_t * p_stream,
375 const OPJ_BYTE * p_buffer,
377 opj_event_mgr_t * p_event_mgr)
379 OPJ_SIZE_T l_remaining_bytes = 0;
380 OPJ_SIZE_T l_write_nb_bytes = 0;
382 if (p_stream->m_status & opj_stream_e_error) {
383 return (OPJ_SIZE_T)-1;
387 l_remaining_bytes = p_stream->m_buffer_size - p_stream->m_bytes_in_buffer;
389 /* we have more memory than required */
390 if (l_remaining_bytes >= p_size) {
391 memcpy(p_stream->m_current_data, p_buffer, p_size);
393 p_stream->m_current_data += p_size;
394 p_stream->m_bytes_in_buffer += p_size;
395 l_write_nb_bytes += p_size;
396 p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
398 return l_write_nb_bytes;
401 /* we copy data and then do an actual read on the stream */
402 if (l_remaining_bytes) {
403 l_write_nb_bytes += l_remaining_bytes;
405 memcpy(p_stream->m_current_data,p_buffer,l_remaining_bytes);
407 p_stream->m_current_data = p_stream->m_stored_data;
409 p_buffer += l_remaining_bytes;
410 p_size -= l_remaining_bytes;
411 p_stream->m_bytes_in_buffer += l_remaining_bytes;
412 p_stream->m_byte_offset += (OPJ_OFF_T)l_remaining_bytes;
415 if (! opj_stream_flush(p_stream, p_event_mgr)) {
416 return (OPJ_SIZE_T)-1;
422 OPJ_BOOL opj_stream_flush (opj_stream_private_t * p_stream, opj_event_mgr_t * p_event_mgr)
424 /* the number of bytes written on the media. */
425 OPJ_SIZE_T l_current_write_nb_bytes = 0;
427 p_stream->m_current_data = p_stream->m_stored_data;
429 while (p_stream->m_bytes_in_buffer) {
430 /* we should do an actual write on the media */
431 l_current_write_nb_bytes = p_stream->m_write_fn(p_stream->m_current_data,
432 p_stream->m_bytes_in_buffer,
433 p_stream->m_user_data);
435 if (l_current_write_nb_bytes == (OPJ_SIZE_T)-1) {
436 p_stream->m_status |= opj_stream_e_error;
437 opj_event_msg(p_event_mgr, EVT_INFO, "Error on writing stream!\n");
442 p_stream->m_current_data += l_current_write_nb_bytes;
443 p_stream->m_bytes_in_buffer -= l_current_write_nb_bytes;
446 p_stream->m_current_data = p_stream->m_stored_data;
451 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)
453 OPJ_OFF_T l_skip_nb_bytes = 0;
454 OPJ_OFF_T l_current_skip_nb_bytes = 0;
456 assert( p_size >= 0 );
458 if (p_stream->m_bytes_in_buffer >= (OPJ_SIZE_T)p_size) {
459 p_stream->m_current_data += p_size;
460 /* it is safe to cast p_size to OPJ_SIZE_T since it is <= m_bytes_in_buffer
461 which is of type OPJ_SIZE_T */
462 p_stream->m_bytes_in_buffer -= (OPJ_SIZE_T)p_size;
463 l_skip_nb_bytes += p_size;
464 p_stream->m_byte_offset += l_skip_nb_bytes;
465 return l_skip_nb_bytes;
468 /* we are now in the case when the remaining data if not sufficient */
469 if (p_stream->m_status & opj_stream_e_end) {
470 l_skip_nb_bytes += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
471 p_stream->m_current_data += p_stream->m_bytes_in_buffer;
472 p_stream->m_bytes_in_buffer = 0;
473 p_stream->m_byte_offset += l_skip_nb_bytes;
474 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) -1;
477 /* the flag is not set, we copy data and then do an actual skip on the stream */
478 if (p_stream->m_bytes_in_buffer) {
479 l_skip_nb_bytes += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
480 p_stream->m_current_data = p_stream->m_stored_data;
481 p_size -= (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
482 p_stream->m_bytes_in_buffer = 0;
486 /* we should do an actual skip on the media */
487 l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
488 if (l_current_skip_nb_bytes == (OPJ_OFF_T) -1) {
489 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
491 p_stream->m_status |= opj_stream_e_end;
492 p_stream->m_byte_offset += l_skip_nb_bytes;
494 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) -1;
496 p_size -= l_current_skip_nb_bytes;
497 l_skip_nb_bytes += l_current_skip_nb_bytes;
500 p_stream->m_byte_offset += l_skip_nb_bytes;
502 return l_skip_nb_bytes;
505 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)
507 OPJ_BOOL l_is_written = 0;
508 OPJ_OFF_T l_current_skip_nb_bytes = 0;
509 OPJ_OFF_T l_skip_nb_bytes = 0;
511 if (p_stream->m_status & opj_stream_e_error) {
512 return (OPJ_OFF_T) -1;
515 /* we should flush data */
516 l_is_written = opj_stream_flush (p_stream, p_event_mgr);
517 if (! l_is_written) {
518 p_stream->m_status |= opj_stream_e_error;
519 p_stream->m_bytes_in_buffer = 0;
520 return (OPJ_OFF_T) -1;
525 /* we should do an actual skip on the media */
526 l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
528 if (l_current_skip_nb_bytes == (OPJ_OFF_T)-1) {
529 opj_event_msg(p_event_mgr, EVT_INFO, "Stream error!\n");
531 p_stream->m_status |= opj_stream_e_error;
532 p_stream->m_byte_offset += l_skip_nb_bytes;
534 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T)-1;
536 p_size -= l_current_skip_nb_bytes;
537 l_skip_nb_bytes += l_current_skip_nb_bytes;
540 p_stream->m_byte_offset += l_skip_nb_bytes;
542 return l_skip_nb_bytes;
545 OPJ_OFF_T opj_stream_tell (const opj_stream_private_t * p_stream)
547 return p_stream->m_byte_offset;
550 OPJ_OFF_T opj_stream_get_number_byte_left (const opj_stream_private_t * p_stream)
552 assert( p_stream->m_byte_offset >= 0 );
553 assert( p_stream->m_user_data_length >= (OPJ_UINT64)p_stream->m_byte_offset);
554 return p_stream->m_user_data_length ?
555 (OPJ_OFF_T)(p_stream->m_user_data_length) - p_stream->m_byte_offset :
559 OPJ_OFF_T opj_stream_skip (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
562 return p_stream->m_opj_skip(p_stream,p_size,p_event_mgr);
565 OPJ_BOOL opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
567 OPJ_ARG_NOT_USED(p_event_mgr);
568 p_stream->m_current_data = p_stream->m_stored_data;
569 p_stream->m_bytes_in_buffer = 0;
571 if( !(p_stream->m_seek_fn(p_size,p_stream->m_user_data)) ) {
572 p_stream->m_status |= opj_stream_e_end;
576 /* reset stream status */
577 p_stream->m_status &= (~opj_stream_e_end);
578 p_stream->m_byte_offset = p_size;
585 OPJ_BOOL opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
587 if (! opj_stream_flush(p_stream,p_event_mgr)) {
588 p_stream->m_status |= opj_stream_e_error;
592 p_stream->m_current_data = p_stream->m_stored_data;
593 p_stream->m_bytes_in_buffer = 0;
595 if (! p_stream->m_seek_fn(p_size,p_stream->m_user_data)) {
596 p_stream->m_status |= opj_stream_e_error;
600 p_stream->m_byte_offset = p_size;
606 OPJ_BOOL opj_stream_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr)
609 return p_stream->m_opj_seek(p_stream,p_size,p_event_mgr);
612 OPJ_BOOL opj_stream_has_seek (const opj_stream_private_t * p_stream)
614 return p_stream->m_seek_fn != opj_stream_default_seek;
617 OPJ_SIZE_T opj_stream_default_read (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
619 OPJ_ARG_NOT_USED(p_buffer);
620 OPJ_ARG_NOT_USED(p_nb_bytes);
621 OPJ_ARG_NOT_USED(p_user_data);
622 return (OPJ_SIZE_T) -1;
625 OPJ_SIZE_T opj_stream_default_write (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
627 OPJ_ARG_NOT_USED(p_buffer);
628 OPJ_ARG_NOT_USED(p_nb_bytes);
629 OPJ_ARG_NOT_USED(p_user_data);
630 return (OPJ_SIZE_T) -1;
633 OPJ_OFF_T opj_stream_default_skip (OPJ_OFF_T p_nb_bytes, void * p_user_data)
635 OPJ_ARG_NOT_USED(p_nb_bytes);
636 OPJ_ARG_NOT_USED(p_user_data);
637 return (OPJ_OFF_T) -1;
640 OPJ_BOOL opj_stream_default_seek (OPJ_OFF_T p_nb_bytes, void * p_user_data)
642 OPJ_ARG_NOT_USED(p_nb_bytes);
643 OPJ_ARG_NOT_USED(p_user_data);