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 } 684
