src/lib/openjp2/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 }