Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/openjpeg/src/lib/openjp2/cio.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
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,
48 OPJ_UINT32 p_nb_bytes)
49 {
50 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(
51 OPJ_UINT32) - p_nb_bytes;
52
53 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
54
55 memcpy(p_buffer, l_data_ptr, p_nb_bytes);
56 }
57
58 void opj_write_bytes_LE(OPJ_BYTE * p_buffer, OPJ_UINT32 p_value,
59 OPJ_UINT32 p_nb_bytes)
60 {
61 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes - 1;
62 OPJ_UINT32 i;
63
64 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
65
66 for (i = 0; i < p_nb_bytes; ++i) {
67 *(p_buffer++) = *(l_data_ptr--);
68 }
69 }
70
71 void opj_read_bytes_BE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value,
72 OPJ_UINT32 p_nb_bytes)
73 {
74 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
75
76 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
77
78 *p_value = 0;
79 memcpy(l_data_ptr + sizeof(OPJ_UINT32) - p_nb_bytes, p_buffer, p_nb_bytes);
80 }
81
82 void opj_read_bytes_LE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value,
83 OPJ_UINT32 p_nb_bytes)
84 {
85 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + p_nb_bytes - 1;
86 OPJ_UINT32 i;
87
88 assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
89
90 *p_value = 0;
91 for (i = 0; i < p_nb_bytes; ++i) {
92 *(l_data_ptr--) = *(p_buffer++);
93 }
94 }
95
96 void opj_write_double_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
97 {
98 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
99 memcpy(p_buffer, l_data_ptr, sizeof(OPJ_FLOAT64));
100 }
101
102 void opj_write_double_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
103 {
104 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(
105 OPJ_FLOAT64) - 1;
106 OPJ_UINT32 i;
107 for (i = 0; i < sizeof(OPJ_FLOAT64); ++i) {
108 *(p_buffer++) = *(l_data_ptr--);
109 }
110 }
111
112 void opj_read_double_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
113 {
114 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
115 memcpy(l_data_ptr, p_buffer, sizeof(OPJ_FLOAT64));
116 }
117
118 void opj_read_double_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
119 {
120 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT64) - 1;
121 OPJ_UINT32 i;
122 for (i = 0; i < sizeof(OPJ_FLOAT64); ++i) {
123 *(l_data_ptr--) = *(p_buffer++);
124 }
125 }
126
127 void opj_write_float_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
128 {
129 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
130 memcpy(p_buffer, l_data_ptr, sizeof(OPJ_FLOAT32));
131 }
132
133 void opj_write_float_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
134 {
135 const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(
136 OPJ_FLOAT32) - 1;
137 OPJ_UINT32 i;
138 for (i = 0; i < sizeof(OPJ_FLOAT32); ++i) {
139 *(p_buffer++) = *(l_data_ptr--);
140 }
141 }
142
143 void opj_read_float_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
144 {
145 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
146 memcpy(l_data_ptr, p_buffer, sizeof(OPJ_FLOAT32));
147 }
148
149 void opj_read_float_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
150 {
151 OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT32) - 1;
152 OPJ_UINT32 i;
153 for (i = 0; i < sizeof(OPJ_FLOAT32); ++i) {
154 *(l_data_ptr--) = *(p_buffer++);
155 }
156 }
157
158 opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size,
159 OPJ_BOOL l_is_input)
160 {
161 opj_stream_private_t * l_stream = 00;
162 l_stream = (opj_stream_private_t*) opj_calloc(1, sizeof(opj_stream_private_t));
163 if (! l_stream) {
164 return 00;
165 }
166
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) {
170 opj_free(l_stream);
171 return 00;
172 }
173
174 l_stream->m_current_data = l_stream->m_stored_data;
175
176 if (l_is_input) {
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;
180 } else {
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;
184 }
185
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;
190
191 return (opj_stream_t *) l_stream;
192 }
193
194 opj_stream_t* OPJ_CALLCONV opj_stream_default_create(OPJ_BOOL l_is_input)
195 {
196 return opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE, l_is_input);
197 }
198
199 void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream)
200 {
201 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
202
203 if (l_stream) {
204 if (l_stream->m_free_user_data_fn) {
205 l_stream->m_free_user_data_fn(l_stream->m_user_data);
206 }
207 opj_free(l_stream->m_stored_data);
208 l_stream->m_stored_data = 00;
209 opj_free(l_stream);
210 }
211 }
212
213 void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream,
214 opj_stream_read_fn p_function)
215 {
216 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
217
218 if ((!l_stream) || (!(l_stream->m_status & OPJ_STREAM_STATUS_INPUT))) {
219 return;
220 }
221
222 l_stream->m_read_fn = p_function;
223 }
224
225 void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream,
226 opj_stream_seek_fn p_function)
227 {
228 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
229
230 if (!l_stream) {
231 return;
232 }
233 l_stream->m_seek_fn = p_function;
234 }
235
236 void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream,
237 opj_stream_write_fn p_function)
238 {
239 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
240
241 if ((!l_stream) || (!(l_stream->m_status & OPJ_STREAM_STATUS_OUTPUT))) {
242 return;
243 }
244
245 l_stream->m_write_fn = p_function;
246 }
247
248 void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream,
249 opj_stream_skip_fn p_function)
250 {
251 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
252
253 if (! l_stream) {
254 return;
255 }
256
257 l_stream->m_skip_fn = p_function;
258 }
259
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)
262 {
263 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
264 if (!l_stream) {
265 return;
266 }
267 l_stream->m_user_data = p_data;
268 l_stream->m_free_user_data_fn = p_function;
269 }
270
271 void OPJ_CALLCONV opj_stream_set_user_data_length(opj_stream_t* p_stream,
272 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 }
278 l_stream->m_user_data_length = data_length;
279 }
280
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)
283 {
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;
292 }
293
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;
302 }
303
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;
313 } else {
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;
318 }
319
320 for (;;) {
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);
326
327 if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T) - 1) {
328 /* end of stream */
329 opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
330
331 p_stream->m_bytes_in_buffer = 0;
332 p_stream->m_status |= OPJ_STREAM_STATUS_END;
333 /* end of stream */
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;
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 } else {
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);
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_STATUS_END;
363 /* end of stream */
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;
373 } else {
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;
380 }
381 }
382 }
383 }
384
385 OPJ_SIZE_T opj_stream_write_data(opj_stream_private_t * p_stream,
386 const OPJ_BYTE * p_buffer,
387 OPJ_SIZE_T p_size,
388 opj_event_mgr_t * p_event_mgr)
389 {
390 OPJ_SIZE_T l_remaining_bytes = 0;
391 OPJ_SIZE_T l_write_nb_bytes = 0;
392
393 if (p_stream->m_status & OPJ_STREAM_STATUS_ERROR) {
394 return (OPJ_SIZE_T) - 1;
395 }
396
397 for (;;) {
398 l_remaining_bytes = p_stream->m_buffer_size - p_stream->m_bytes_in_buffer;
399
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);
403
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;
408
409 return l_write_nb_bytes;
410 }
411
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;
415
416 memcpy(p_stream->m_current_data, p_buffer, l_remaining_bytes);
417
418 p_stream->m_current_data = p_stream->m_stored_data;
419
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;
424 }
425
426 if (! opj_stream_flush(p_stream, p_event_mgr)) {
427 return (OPJ_SIZE_T) - 1;
428 }
429 }
430
431 }
432
433 OPJ_BOOL opj_stream_flush(opj_stream_private_t * p_stream,
434 opj_event_mgr_t * p_event_mgr)
435 {
436 /* the number of bytes written on the media. */
437 OPJ_SIZE_T l_current_write_nb_bytes = 0;
438
439 p_stream->m_current_data = p_stream->m_stored_data;
440
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);
446
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");
450
451 return OPJ_FALSE;
452 }
453
454 p_stream->m_current_data += l_current_write_nb_bytes;
455 p_stream->m_bytes_in_buffer -= l_current_write_nb_bytes;
456 }
457
458 p_stream->m_current_data = p_stream->m_stored_data;
459
460 return OPJ_TRUE;
461 }
462
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)
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_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;
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 /* 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");
506
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);
510
511 opj_stream_read_seek(p_stream, (OPJ_OFF_T)p_stream->m_user_data_length,
512 p_event_mgr);
513 p_stream->m_status |= OPJ_STREAM_STATUS_END;
514
515 /* end if stream */
516 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) - 1;
517 }
518
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");
523
524 p_stream->m_status |= OPJ_STREAM_STATUS_END;
525 p_stream->m_byte_offset += l_skip_nb_bytes;
526 /* end if stream */
527 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) - 1;
528 }
529 p_size -= l_current_skip_nb_bytes;
530 l_skip_nb_bytes += l_current_skip_nb_bytes;
531 }
532
533 p_stream->m_byte_offset += l_skip_nb_bytes;
534
535 return l_skip_nb_bytes;
536 }
537
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)
540 {
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;
544
545 if (p_stream->m_status & OPJ_STREAM_STATUS_ERROR) {
546 return (OPJ_OFF_T) - 1;
547 }
548
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;
555 }
556 /* then skip */
557
558 while (p_size > 0) {
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);
561
562 if (l_current_skip_nb_bytes == (OPJ_OFF_T) - 1) {
563 opj_event_msg(p_event_mgr, EVT_INFO, "Stream error!\n");
564
565 p_stream->m_status |= OPJ_STREAM_STATUS_ERROR;
566 p_stream->m_byte_offset += l_skip_nb_bytes;
567 /* end if stream */
568 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) - 1;
569 }
570 p_size -= l_current_skip_nb_bytes;
571 l_skip_nb_bytes += l_current_skip_nb_bytes;
572 }
573
574 p_stream->m_byte_offset += l_skip_nb_bytes;
575
576 return l_skip_nb_bytes;
577 }
578
579 OPJ_OFF_T opj_stream_tell(const opj_stream_private_t * p_stream)
580 {
581 return p_stream->m_byte_offset;
582 }
583
584 OPJ_OFF_T opj_stream_get_number_byte_left(const opj_stream_private_t * p_stream)
585 {
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 :
590 0;
591 }
592
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)
595 {
596 assert(p_size >= 0);
597 return p_stream->m_opj_skip(p_stream, p_size, p_event_mgr);
598 }
599
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)
602 {
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;
606
607 if (!(p_stream->m_seek_fn(p_size, p_stream->m_user_data))) {
608 p_stream->m_status |= OPJ_STREAM_STATUS_END;
609 return OPJ_FALSE;
610 } else {
611 /* reset stream status */
612 p_stream->m_status &= (~OPJ_STREAM_STATUS_END);
613 p_stream->m_byte_offset = p_size;
614
615 }
616
617 return OPJ_TRUE;
618 }
619
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)
622 {
623 if (! opj_stream_flush(p_stream, p_event_mgr)) {
624 p_stream->m_status |= OPJ_STREAM_STATUS_ERROR;
625 return OPJ_FALSE;
626 }
627
628 p_stream->m_current_data = p_stream->m_stored_data;
629 p_stream->m_bytes_in_buffer = 0;
630
631 if (! p_stream->m_seek_fn(p_size, p_stream->m_user_data)) {
632 p_stream->m_status |= OPJ_STREAM_STATUS_ERROR;
633 return OPJ_FALSE;
634 } else {
635 p_stream->m_byte_offset = p_size;
636 }
637
638 return OPJ_TRUE;
639 }
640
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)
643 {
644 assert(p_size >= 0);
645 return p_stream->m_opj_seek(p_stream, p_size, p_event_mgr);
646 }
647
648 OPJ_BOOL opj_stream_has_seek(const opj_stream_private_t * p_stream)
649 {
650 return p_stream->m_seek_fn != opj_stream_default_seek;
651 }
652
653 OPJ_SIZE_T opj_stream_default_read(void * p_buffer, OPJ_SIZE_T p_nb_bytes,
654 void * p_user_data)
655 {
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;
660 }
661
662 OPJ_SIZE_T opj_stream_default_write(void * p_buffer, OPJ_SIZE_T p_nb_bytes,
663 void * p_user_data)
664 {
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;
669 }
670
671 OPJ_OFF_T opj_stream_default_skip(OPJ_OFF_T p_nb_bytes, void * p_user_data)
672 {
673 OPJ_ARG_NOT_USED(p_nb_bytes);
674 OPJ_ARG_NOT_USED(p_user_data);
675 return (OPJ_OFF_T) - 1;
676 }
677
678 OPJ_BOOL opj_stream_default_seek(OPJ_OFF_T p_nb_bytes, void * p_user_data)
679 {
680 OPJ_ARG_NOT_USED(p_nb_bytes);
681 OPJ_ARG_NOT_USED(p_user_data);
682 return OPJ_FALSE;
683 }