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,
48 OPJ_UINT32 p_nb_bytes)
50 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(
51 OPJ_UINT32) - p_nb_bytes;
53 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
55 memcpy(p_buffer, l_data_ptr, p_nb_bytes);
58 void opj_write_bytes_LE(OPJ_BYTE * p_buffer, OPJ_UINT32 p_value,
59 OPJ_UINT32 p_nb_bytes)
61 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes - 1;
64 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
66 for (i = 0; i < p_nb_bytes; ++i) {
67 *(p_buffer++) = *(l_data_ptr--);
71 void opj_read_bytes_BE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value,
72 OPJ_UINT32 p_nb_bytes)
74 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
76 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
79 memcpy(l_data_ptr + sizeof(OPJ_UINT32) - p_nb_bytes, p_buffer, p_nb_bytes);
82 void opj_read_bytes_LE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value,
83 OPJ_UINT32 p_nb_bytes)
85 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + p_nb_bytes - 1;
88 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
91 for (i = 0; i < p_nb_bytes; ++i) {
92 *(l_data_ptr--) = *(p_buffer++);
96 void opj_write_double_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
98 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
99 memcpy(p_buffer, l_data_ptr, sizeof(OPJ_FLOAT64));
102 void opj_write_double_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
104 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(
107 for (i = 0; i < sizeof(OPJ_FLOAT64); ++i) {
108 *(p_buffer++) = *(l_data_ptr--);
112 void opj_read_double_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
114 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
115 memcpy(l_data_ptr, p_buffer, sizeof(OPJ_FLOAT64));
118 void opj_read_double_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
120 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT64) - 1;
122 for (i = 0; i < sizeof(OPJ_FLOAT64); ++i) {
123 *(l_data_ptr--) = *(p_buffer++);
127 void opj_write_float_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
129 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
130 memcpy(p_buffer, l_data_ptr, sizeof(OPJ_FLOAT32));
133 void opj_write_float_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
135 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(
138 for (i = 0; i < sizeof(OPJ_FLOAT32); ++i) {
139 *(p_buffer++) = *(l_data_ptr--);
143 void opj_read_float_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
145 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
146 memcpy(l_data_ptr, p_buffer, sizeof(OPJ_FLOAT32));
149 void opj_read_float_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
151 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT32) - 1;
153 for (i = 0; i < sizeof(OPJ_FLOAT32); ++i) {
154 *(l_data_ptr--) = *(p_buffer++);
158 opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size,
161 opj_stream_private_t * l_stream = 00;
162 l_stream = (opj_stream_private_t*) opj_calloc(1, sizeof(opj_stream_private_t));
167 l_stream->m_buffer_size = p_buffer_size;
168 l_stream->m_stored_data = (OPJ_BYTE *) opj_malloc(p_buffer_size);
169 if (! l_stream->m_stored_data) {
174 l_stream->m_current_data = l_stream->m_stored_data;
177 l_stream->m_status |= OPJ_STREAM_STATUS_INPUT;
178 l_stream->m_opj_skip = opj_stream_read_skip;
179 l_stream->m_opj_seek = opj_stream_read_seek;
181 l_stream->m_status |= OPJ_STREAM_STATUS_OUTPUT;
182 l_stream->m_opj_skip = opj_stream_write_skip;
183 l_stream->m_opj_seek = opj_stream_write_seek;
186 l_stream->m_read_fn = opj_stream_default_read;
187 l_stream->m_write_fn = opj_stream_default_write;
188 l_stream->m_skip_fn = opj_stream_default_skip;
189 l_stream->m_seek_fn = opj_stream_default_seek;
191 return (opj_stream_t *) l_stream;
194 opj_stream_t* OPJ_CALLCONV opj_stream_default_create(OPJ_BOOL l_is_input)
196 return opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE, l_is_input);
199 void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream)
201 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
204 if (l_stream->m_free_user_data_fn) {
205 l_stream->m_free_user_data_fn(l_stream->m_user_data);
207 opj_free(l_stream->m_stored_data);
208 l_stream->m_stored_data = 00;
213 void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream,
214 opj_stream_read_fn p_function)
216 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
218 if ((!l_stream) || (!(l_stream->m_status & OPJ_STREAM_STATUS_INPUT))) {
222 l_stream->m_read_fn = p_function;
225 void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream,
226 opj_stream_seek_fn p_function)
228 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
233 l_stream->m_seek_fn = p_function;
236 void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream,
237 opj_stream_write_fn p_function)
239 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
241 if ((!l_stream) || (!(l_stream->m_status & OPJ_STREAM_STATUS_OUTPUT))) {
245 l_stream->m_write_fn = p_function;
248 void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream,
249 opj_stream_skip_fn p_function)
251 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
257 l_stream->m_skip_fn = p_function;
260 void OPJ_CALLCONV opj_stream_set_user_data(opj_stream_t* p_stream,
261 void * p_data, opj_stream_free_user_data_fn p_function)
263 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
267 l_stream->m_user_data = p_data;
268 l_stream->m_free_user_data_fn = p_function;
271 void OPJ_CALLCONV opj_stream_set_user_data_length(opj_stream_t* p_stream,
272 OPJ_UINT64 data_length)
274 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
278 l_stream->m_user_data_length = data_length;
281 OPJ_SIZE_T opj_stream_read_data(opj_stream_private_t * p_stream,
282 OPJ_BYTE * p_buffer, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
284 OPJ_SIZE_T l_read_nb_bytes = 0;
285 if (p_stream->m_bytes_in_buffer >= p_size) {
286 memcpy(p_buffer, p_stream->m_current_data, p_size);
287 p_stream->m_current_data += p_size;
288 p_stream->m_bytes_in_buffer -= p_size;
289 l_read_nb_bytes += p_size;
290 p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
291 return l_read_nb_bytes;
294 /* we are now in the case when the remaining data if not sufficient */
295 if (p_stream->m_status & OPJ_STREAM_STATUS_END) {
296 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
297 memcpy(p_buffer, p_stream->m_current_data, p_stream->m_bytes_in_buffer);
298 p_stream->m_current_data += p_stream->m_bytes_in_buffer;
299 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
300 p_stream->m_bytes_in_buffer = 0;
301 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T) - 1;
304 /* the flag is not set, we copy data and then do an actual read on the stream */
305 if (p_stream->m_bytes_in_buffer) {
306 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
307 memcpy(p_buffer, p_stream->m_current_data, p_stream->m_bytes_in_buffer);
308 p_stream->m_current_data = p_stream->m_stored_data;
309 p_buffer += p_stream->m_bytes_in_buffer;
310 p_size -= p_stream->m_bytes_in_buffer;
311 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
312 p_stream->m_bytes_in_buffer = 0;
314 /* case where we are already at the end of the buffer
315 so reset the m_current_data to point to the start of the
316 stored buffer to get ready to read from disk*/
317 p_stream->m_current_data = p_stream->m_stored_data;
321 /* we should read less than a chunk -> read a chunk */
322 if (p_size < p_stream->m_buffer_size) {
323 /* we should do an actual read on the media */
324 p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_stream->m_stored_data,
325 p_stream->m_buffer_size, p_stream->m_user_data);
327 if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T) - 1) {
329 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
331 p_stream->m_bytes_in_buffer = 0;
332 p_stream->m_status |= OPJ_STREAM_STATUS_END;
334 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T) - 1;
335 } else if (p_stream->m_bytes_in_buffer < p_size) {
336 /* not enough data */
337 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
338 memcpy(p_buffer, p_stream->m_current_data, p_stream->m_bytes_in_buffer);
339 p_stream->m_current_data = p_stream->m_stored_data;
340 p_buffer += p_stream->m_bytes_in_buffer;
341 p_size -= p_stream->m_bytes_in_buffer;
342 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
343 p_stream->m_bytes_in_buffer = 0;
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;
353 /* direct read on the dest buffer */
354 p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_buffer, p_size,
355 p_stream->m_user_data);
357 if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T) - 1) {
359 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
361 p_stream->m_bytes_in_buffer = 0;
362 p_stream->m_status |= OPJ_STREAM_STATUS_END;
364 return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T) - 1;
365 } else if (p_stream->m_bytes_in_buffer < p_size) {
366 /* not enough data */
367 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
368 p_stream->m_current_data = p_stream->m_stored_data;
369 p_buffer += p_stream->m_bytes_in_buffer;
370 p_size -= p_stream->m_bytes_in_buffer;
371 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
372 p_stream->m_bytes_in_buffer = 0;
374 /* we have read the exact size */
375 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
376 p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
377 p_stream->m_current_data = p_stream->m_stored_data;
378 p_stream->m_bytes_in_buffer = 0;
379 return l_read_nb_bytes;
385 OPJ_SIZE_T opj_stream_write_data(opj_stream_private_t * p_stream,
386 const OPJ_BYTE * p_buffer,
388 opj_event_mgr_t * p_event_mgr)
390 OPJ_SIZE_T l_remaining_bytes = 0;
391 OPJ_SIZE_T l_write_nb_bytes = 0;
393 if (p_stream->m_status & OPJ_STREAM_STATUS_ERROR) {
394 return (OPJ_SIZE_T) - 1;
398 l_remaining_bytes = p_stream->m_buffer_size - p_stream->m_bytes_in_buffer;
400 /* we have more memory than required */
401 if (l_remaining_bytes >= p_size) {
402 memcpy(p_stream->m_current_data, p_buffer, p_size);
404 p_stream->m_current_data += p_size;
405 p_stream->m_bytes_in_buffer += p_size;
406 l_write_nb_bytes += p_size;
407 p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
409 return l_write_nb_bytes;
412 /* we copy data and then do an actual read on the stream */
413 if (l_remaining_bytes) {
414 l_write_nb_bytes += l_remaining_bytes;
416 memcpy(p_stream->m_current_data, p_buffer, l_remaining_bytes);
418 p_stream->m_current_data = p_stream->m_stored_data;
420 p_buffer += l_remaining_bytes;
421 p_size -= l_remaining_bytes;
422 p_stream->m_bytes_in_buffer += l_remaining_bytes;
423 p_stream->m_byte_offset += (OPJ_OFF_T)l_remaining_bytes;
426 if (! opj_stream_flush(p_stream, p_event_mgr)) {
427 return (OPJ_SIZE_T) - 1;
433 OPJ_BOOL opj_stream_flush(opj_stream_private_t * p_stream,
434 opj_event_mgr_t * p_event_mgr)
436 /* the number of bytes written on the media. */
437 OPJ_SIZE_T l_current_write_nb_bytes = 0;
439 p_stream->m_current_data = p_stream->m_stored_data;
441 while (p_stream->m_bytes_in_buffer) {
442 /* we should do an actual write on the media */
443 l_current_write_nb_bytes = p_stream->m_write_fn(p_stream->m_current_data,
444 p_stream->m_bytes_in_buffer,
445 p_stream->m_user_data);
447 if (l_current_write_nb_bytes == (OPJ_SIZE_T) - 1) {
448 p_stream->m_status |= OPJ_STREAM_STATUS_ERROR;
449 opj_event_msg(p_event_mgr, EVT_INFO, "Error on writing stream!\n");
454 p_stream->m_current_data += l_current_write_nb_bytes;
455 p_stream->m_bytes_in_buffer -= l_current_write_nb_bytes;
458 p_stream->m_current_data = p_stream->m_stored_data;
463 OPJ_OFF_T opj_stream_read_skip(opj_stream_private_t * p_stream,
464 OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
466 OPJ_OFF_T l_skip_nb_bytes = 0;
467 OPJ_OFF_T l_current_skip_nb_bytes = 0;
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;
481 /* we are now in the case when the remaining data if not sufficient */
482 if (p_stream->m_status & OPJ_STREAM_STATUS_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;
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;
499 /* Check if we are going beyond the end of file. Most skip_fn do not */
500 /* check that, but we must be careful not to advance m_byte_offset */
501 /* beyond m_user_data_length, otherwise */
502 /* opj_stream_get_number_byte_left() will assert. */
503 if ((OPJ_UINT64)(p_stream->m_byte_offset + l_skip_nb_bytes + p_size) >
504 p_stream->m_user_data_length) {
505 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
507 p_stream->m_byte_offset += l_skip_nb_bytes;
508 l_skip_nb_bytes = (OPJ_OFF_T)(p_stream->m_user_data_length -
509 (OPJ_UINT64)p_stream->m_byte_offset);
511 opj_stream_read_seek(p_stream, (OPJ_OFF_T)p_stream->m_user_data_length,
513 p_stream->m_status |= OPJ_STREAM_STATUS_END;
516 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) - 1;
519 /* we should do an actual skip on the media */
520 l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
521 if (l_current_skip_nb_bytes == (OPJ_OFF_T) - 1) {
522 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
524 p_stream->m_status |= OPJ_STREAM_STATUS_END;
525 p_stream->m_byte_offset += l_skip_nb_bytes;
527 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) - 1;
529 p_size -= l_current_skip_nb_bytes;
530 l_skip_nb_bytes += l_current_skip_nb_bytes;
533 p_stream->m_byte_offset += l_skip_nb_bytes;
535 return l_skip_nb_bytes;
538 OPJ_OFF_T opj_stream_write_skip(opj_stream_private_t * p_stream,
539 OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
541 OPJ_BOOL l_is_written = 0;
542 OPJ_OFF_T l_current_skip_nb_bytes = 0;
543 OPJ_OFF_T l_skip_nb_bytes = 0;
545 if (p_stream->m_status & OPJ_STREAM_STATUS_ERROR) {
546 return (OPJ_OFF_T) - 1;
549 /* we should flush data */
550 l_is_written = opj_stream_flush(p_stream, p_event_mgr);
551 if (! l_is_written) {
552 p_stream->m_status |= OPJ_STREAM_STATUS_ERROR;
553 p_stream->m_bytes_in_buffer = 0;
554 return (OPJ_OFF_T) - 1;
559 /* we should do an actual skip on the media */
560 l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
562 if (l_current_skip_nb_bytes == (OPJ_OFF_T) - 1) {
563 opj_event_msg(p_event_mgr, EVT_INFO, "Stream error!\n");
565 p_stream->m_status |= OPJ_STREAM_STATUS_ERROR;
566 p_stream->m_byte_offset += l_skip_nb_bytes;
568 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) - 1;
570 p_size -= l_current_skip_nb_bytes;
571 l_skip_nb_bytes += l_current_skip_nb_bytes;
574 p_stream->m_byte_offset += l_skip_nb_bytes;
576 return l_skip_nb_bytes;
579 OPJ_OFF_T opj_stream_tell(const opj_stream_private_t * p_stream)
581 return p_stream->m_byte_offset;
584 OPJ_OFF_T opj_stream_get_number_byte_left(const opj_stream_private_t * p_stream)
586 assert(p_stream->m_byte_offset >= 0);
587 assert(p_stream->m_user_data_length >= (OPJ_UINT64)p_stream->m_byte_offset);
588 return p_stream->m_user_data_length ?
589 (OPJ_OFF_T)(p_stream->m_user_data_length) - p_stream->m_byte_offset :
593 OPJ_OFF_T opj_stream_skip(opj_stream_private_t * p_stream, OPJ_OFF_T p_size,
594 opj_event_mgr_t * p_event_mgr)
597 return p_stream->m_opj_skip(p_stream, p_size, p_event_mgr);
600 OPJ_BOOL opj_stream_read_seek(opj_stream_private_t * p_stream, OPJ_OFF_T p_size,
601 opj_event_mgr_t * p_event_mgr)
603 OPJ_ARG_NOT_USED(p_event_mgr);
604 p_stream->m_current_data = p_stream->m_stored_data;
605 p_stream->m_bytes_in_buffer = 0;
607 if (!(p_stream->m_seek_fn(p_size, p_stream->m_user_data))) {
608 p_stream->m_status |= OPJ_STREAM_STATUS_END;
611 /* reset stream status */
612 p_stream->m_status &= (~OPJ_STREAM_STATUS_END);
613 p_stream->m_byte_offset = p_size;
620 OPJ_BOOL opj_stream_write_seek(opj_stream_private_t * p_stream,
621 OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
623 if (! opj_stream_flush(p_stream, p_event_mgr)) {
624 p_stream->m_status |= OPJ_STREAM_STATUS_ERROR;
628 p_stream->m_current_data = p_stream->m_stored_data;
629 p_stream->m_bytes_in_buffer = 0;
631 if (! p_stream->m_seek_fn(p_size, p_stream->m_user_data)) {
632 p_stream->m_status |= OPJ_STREAM_STATUS_ERROR;
635 p_stream->m_byte_offset = p_size;
641 OPJ_BOOL opj_stream_seek(opj_stream_private_t * p_stream, OPJ_OFF_T p_size,
642 struct opj_event_mgr * p_event_mgr)
645 return p_stream->m_opj_seek(p_stream, p_size, p_event_mgr);
648 OPJ_BOOL opj_stream_has_seek(const opj_stream_private_t * p_stream)
650 return p_stream->m_seek_fn != opj_stream_default_seek;
653 OPJ_SIZE_T opj_stream_default_read(void * p_buffer, OPJ_SIZE_T p_nb_bytes,
656 OPJ_ARG_NOT_USED(p_buffer);
657 OPJ_ARG_NOT_USED(p_nb_bytes);
658 OPJ_ARG_NOT_USED(p_user_data);
659 return (OPJ_SIZE_T) - 1;
662 OPJ_SIZE_T opj_stream_default_write(void * p_buffer, OPJ_SIZE_T p_nb_bytes,
665 OPJ_ARG_NOT_USED(p_buffer);
666 OPJ_ARG_NOT_USED(p_nb_bytes);
667 OPJ_ARG_NOT_USED(p_user_data);
668 return (OPJ_SIZE_T) - 1;
671 OPJ_OFF_T opj_stream_default_skip(OPJ_OFF_T p_nb_bytes, void * p_user_data)
673 OPJ_ARG_NOT_USED(p_nb_bytes);
674 OPJ_ARG_NOT_USED(p_user_data);
675 return (OPJ_OFF_T) - 1;
678 OPJ_BOOL opj_stream_default_seek(OPJ_OFF_T p_nb_bytes, void * p_user_data)
680 OPJ_ARG_NOT_USED(p_nb_bytes);
681 OPJ_ARG_NOT_USED(p_user_data);