libopenjpeg/cio.c

   1 /*
   2  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   3  * Copyright (c) 2002-2007, Professor Benoit Macq
   4  * Copyright (c) 2001-2003, David Janssens
   5  * Copyright (c) 2002-2003, Yannick Verschueren
   6  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
   7  * Copyright (c) 2005, Herve Drolon, FreeImage Team
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "opj_includes.h"
  33
  34 /* ----------------------------------------------------------------------- */
  35
  36 opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length) {
  37         opj_cp_t *cp = NULL;
  38         opj_cio_t *cio = (opj_cio_t*)opj_malloc(sizeof(opj_cio_t));
  39         if(!cio) return NULL;
  40         cio->cinfo = cinfo;
  41         if(buffer && length) {
  42                 /* wrap a user buffer containing the encoded image */
  43                 cio->openmode = OPJ_STREAM_READ;
  44                 cio->buffer = buffer;
  45                 cio->length = length;
  46         }
  47         else if(!buffer && !length && cinfo) {
  48                 /* allocate a buffer for the encoded image */
  49                 cio->openmode = OPJ_STREAM_WRITE;
  50                 switch(cinfo->codec_format) {
  51                         case CODEC_J2K:
  52                                 cp = ((opj_j2k_t*)cinfo->j2k_handle)->cp;
  53                                 break;
  54                         case CODEC_JP2:
  55                                 cp = ((opj_jp2_t*)cinfo->jp2_handle)->j2k->cp;
  56                                 break;
  57                         default:
  58                                 opj_free(cio);
  59                                 return NULL;
  60                 }
  61                 cio->length = (unsigned int) (0.1625 * cp->img_size + 2000); /* 0.1625 = 1.3/8 and 2000 bytes as a minimum for headers */
  62                 cio->buffer = (unsigned char *)opj_malloc(cio->length);
  63                 if(!cio->buffer) {
  64                         opj_event_msg(cio->cinfo, EVT_ERROR, "Error allocating memory for compressed bitstream\n");
  65                         opj_free(cio);
  66                         return NULL;
  67                 }
  68         }
  69         else {
  70                 opj_free(cio);
  71                 return NULL;
  72         }
  73
  74         /* Initialize byte IO */
  75         cio->start = cio->buffer;
  76         cio->end = cio->buffer + cio->length;
  77         cio->bp = cio->buffer;
  78
  79         return cio;
  80 }
  81
  82 void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio) {
  83         if(cio) {
  84                 if(cio->openmode == OPJ_STREAM_WRITE) {
  85                         /* destroy the allocated buffer */
  86                         opj_free(cio->buffer);
  87                 }
  88                 /* destroy the cio */
  89                 opj_free(cio);
  90         }
  91 }
  92
  93
  94 /* ----------------------------------------------------------------------- */
  95
  96 /*
  97  * Get position in byte stream.
  98  */
  99 int OPJ_CALLCONV cio_tell(opj_cio_t *cio) {
 100         return cio->bp - cio->start;
 101 }
 102
 103 /*
 104  * Set position in byte stream.
 105  *
 106  * pos : position, in number of bytes, from the beginning of the stream
 107  */
 108 void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos) {
 109         cio->bp = cio->start + pos;
 110 }
 111
 112 /*
 113  * Number of bytes left before the end of the stream.
 114  */
 115 int cio_numbytesleft(opj_cio_t *cio) {
 116         return cio->end - cio->bp;
 117 }
 118
 119 /*
 120  * Get pointer to the current position in the stream.
 121  */
 122 unsigned char *cio_getbp(opj_cio_t *cio) {
 123         return cio->bp;
 124 }
 125
 126 /*
 127  * Write a byte.
 128  */
 129 opj_bool cio_byteout(opj_cio_t *cio, unsigned char v) {
 130         if (cio->bp >= cio->end) {
 131                 opj_event_msg(cio->cinfo, EVT_ERROR, "write error\n");
 132                 return OPJ_FALSE;
 133         }
 134         *cio->bp++ = v;
 135         return OPJ_TRUE;
 136 }
 137
 138 /*
 139  * Read a byte.
 140  */
 141 unsigned char cio_bytein(opj_cio_t *cio) {
 142         if (cio->bp >= cio->end) {
 143                 opj_event_msg(cio->cinfo, EVT_ERROR, "read error: passed the end of the codestream (start = %d, current = %d, end = %d\n", cio->start, cio->bp, cio->end);
 144                 return 0;
 145         }
 146         return *cio->bp++;
 147 }
 148
 149 /*
 150  * Write some bytes.
 151  *
 152  * v : value to write
 153  * n : number of bytes to write
 154  */
 155 unsigned int cio_write(opj_cio_t *cio, unsigned long long int v, int n) {
 156         int i;
 157         for (i = n - 1; i >= 0; i--) {
 158                 if( !cio_byteout(cio, (unsigned char) ((v >> (i << 3)) & 0xff)) )
 159                         return 0;
 160         }
 161         return n;
 162 }
 163
 164 /*
 165  * Read some bytes.
 166  *
 167  * n : number of bytes to read
 168  *
 169  * return : value of the n bytes read
 170  */
 171 unsigned int cio_read(opj_cio_t *cio, int n) {
 172         int i;
 173         unsigned int v;
 174         v = 0;
 175         for (i = n - 1; i >= 0; i--) {
 176                 v += cio_bytein(cio) << (i << 3);
 177         }
 178         return v;
 179 }
 180
 181 /*
 182  * Skip some bytes.
 183  *
 184  * n : number of bytes to skip
 185  */
 186 void cio_skip(opj_cio_t *cio, int n) {
 187         cio->bp += n;
 188 }
 189
 190
 191 /* ----------------------------------------------------------------------- */
 192
 193
 194 /**
 195  * Write some bytes to the given data buffer, this function is used in Big Endian cpus.
 196  * @param p_buffer              pointer the data buffer to write data to.
 197  * @param p_value               the value to write
 198  * @param p_nb_bytes    the number of bytes to write
 199 */
 200 void opj_write_bytes_BE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes)
 201 {
 202         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes;
 203
 204         assert(p_nb_bytes > 0 && p_nb_bytes <=  sizeof(OPJ_UINT32));
 205
 206         memcpy(p_buffer,l_data_ptr,p_nb_bytes);
 207 }
 208
 209 /**
 210  * Write some bytes to the given data buffer, this function is used in Little Endian cpus.
 211  * @param p_buffer              pointer the data buffer to write data to.
 212  * @param p_value               the value to write
 213  * @param p_nb_bytes    the number of bytes to write
 214  * @return                              the number of bytes written or -1 if an error occured
 215 */
 216 void opj_write_bytes_LE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes)
 217 {
 218         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes - 1;
 219         OPJ_UINT32 i;
 220
 221         assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
 222
 223         for     (i=0;i<p_nb_bytes;++i) {
 224                 *(p_buffer++) = *(l_data_ptr--);
 225         }
 226 }
 227
 228 /**
 229  * Reads some bytes from the given data buffer, this function is used in Big Endian cpus.
 230  * @param p_buffer              pointer the data buffer to read data from.
 231  * @param p_value               pointer to the value that will store the data.
 232  * @param p_nb_bytes    the nb bytes to read.
 233  * @return                              the number of bytes read or -1 if an error occured.
 234  */
 235 void opj_read_bytes_BE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes)
 236 {
 237         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
 238
 239         assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
 240
 241         *p_value = 0;
 242         memcpy(l_data_ptr+4-p_nb_bytes,p_buffer,p_nb_bytes);
 243 }
 244
 245 /**
 246  * Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
 247  * @param p_buffer              pointer the data buffer to read data from.
 248  * @param p_value               pointer to the value that will store the data.
 249  * @param p_nb_bytes    the nb bytes to read.
 250  * @return                              the number of bytes read or -1 if an error occured.
 251  */
 252 void opj_read_bytes_LE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes)
 253 {
 254         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + p_nb_bytes-1;
 255         OPJ_UINT32 i;
 256
 257         assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
 258
 259         *p_value = 0;
 260         for (i=0;i<p_nb_bytes;++i) {
 261                 *(l_data_ptr--) = *(p_buffer++);
 262         }
 263 }
 264
 265 /**
 266  * Write some bytes to the given data buffer, this function is used in Big Endian cpus.
 267  * @param p_buffer              pointer the data buffer to write data to.
 268  * @param p_value               the value to write
 269  * @return                              the number of bytes written or -1 if an error occured
 270  */
 271 void opj_write_double_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
 272 {
 273         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
 274         memcpy(p_buffer,l_data_ptr,sizeof(OPJ_FLOAT64));
 275 }
 276
 277 /**
 278  * Write some bytes to the given data buffer, this function is used in Little Endian cpus.
 279  * @param p_buffer              pointer the data buffer to write data to.
 280  * @param p_value               the value to write
 281  */
 282 void opj_write_double_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
 283 {
 284         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(OPJ_FLOAT64) - 1;
 285         OPJ_UINT32 i;
 286         for     (i=0;i<sizeof(OPJ_FLOAT64);++i) {
 287                 *(p_buffer++) = *(l_data_ptr--);
 288         }
 289 }
 290
 291 /**
 292  * Reads some bytes from the given data buffer, this function is used in Big Endian cpus.
 293  * @param p_buffer              pointer the data buffer to read data from.
 294  * @param p_value               pointer to the value that will store the data.
 295  */
 296 void opj_read_double_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
 297 {
 298         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
 299         memcpy(l_data_ptr,p_buffer,sizeof(OPJ_FLOAT64));
 300 }
 301
 302
 303 /**
 304  * Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
 305  * @param p_buffer              pointer the data buffer to read data from.
 306  * @param p_value               pointer to the value that will store the data.
 307  */
 308 void opj_read_double_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
 309 {
 310         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT64)-1;
 311         OPJ_UINT32 i;
 312         for (i=0;i<sizeof(OPJ_FLOAT64);++i) {
 313                 *(l_data_ptr--) = *(p_buffer++);
 314         }
 315 }
 316
 317 /**
 318  * Write some bytes to the given data buffer, this function is used in Big Endian cpus.
 319  * @param p_buffer              pointer the data buffer to write data to.
 320  * @param p_value               the value to write
 321  * @return                              the number of bytes written or -1 if an error occured
 322  */
 323 void opj_write_float_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
 324 {
 325         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
 326         memcpy(p_buffer,l_data_ptr,sizeof(OPJ_FLOAT32));
 327 }
 328
 329 /**
 330  * Write some bytes to the given data buffer, this function is used in Little Endian cpus.
 331  * @param p_buffer              pointer the data buffer to write data to.
 332  * @param p_value               the value to write
 333  */
 334 void opj_write_float_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
 335 {
 336         const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(OPJ_FLOAT32) - 1;
 337         OPJ_UINT32 i;
 338         for     (i=0;i<sizeof(OPJ_FLOAT32);++i) {
 339                 *(p_buffer++) = *(l_data_ptr--);
 340         }
 341 }
 342
 343 /**
 344  * Reads some bytes from the given data buffer, this function is used in Big Endian cpus.
 345  * @param p_buffer              pointer the data buffer to read data from.
 346  * @param p_value               pointer to the value that will store the data.
 347  */
 348 void opj_read_float_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
 349 {
 350         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
 351         memcpy(l_data_ptr,p_buffer,sizeof(OPJ_FLOAT32));
 352 }
 353
 354
 355 /**
 356  * Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
 357  * @param p_buffer              pointer the data buffer to read data from.
 358  * @param p_value               pointer to the value that will store the data.
 359  */
 360 void opj_read_float_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
 361 {
 362         OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT32)-1;
 363         OPJ_UINT32 i;
 364         for     (i=0;i<sizeof(OPJ_FLOAT32);++i) {
 365                 *(l_data_ptr--) = *(p_buffer++);
 366         }
 367 }
 368
 369
 370 /**
 371  * Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
 372  * @return a stream object.
 373 */
 374 opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size,opj_bool l_is_input)
 375 {
 376         opj_stream_private_t * l_stream = 00;
 377         l_stream = (opj_stream_private_t*) opj_malloc(sizeof(opj_stream_private_t));
 378         if (! l_stream) {
 379                 return 00;
 380         }
 381
 382         memset(l_stream,0,sizeof(opj_stream_private_t));
 383         l_stream->m_buffer_size = p_buffer_size;
 384         l_stream->m_stored_data = (OPJ_BYTE *) opj_malloc(p_buffer_size);
 385         if (! l_stream->m_stored_data) {
 386                 opj_free(l_stream);
 387                 return 00;
 388         }
 389
 390         l_stream->m_current_data = l_stream->m_stored_data;
 391
 392         if (l_is_input) {
 393                 l_stream->m_status |= opj_stream_e_input;
 394                 l_stream->m_opj_skip = opj_stream_read_skip;
 395                 l_stream->m_opj_seek = opj_stream_read_seek;
 396         }
 397         else {
 398                 l_stream->m_status |= opj_stream_e_output;
 399                 l_stream->m_opj_skip = opj_stream_write_skip;
 400                 l_stream->m_opj_seek = opj_stream_write_seek;
 401         }
 402
 403         l_stream->m_read_fn = opj_stream_default_read;
 404         l_stream->m_write_fn = opj_stream_default_write;
 405         l_stream->m_skip_fn = opj_stream_default_skip;
 406         l_stream->m_seek_fn = opj_stream_default_seek;
 407
 408         return (opj_stream_t *) l_stream;
 409 }
 410
 411 /**
 412  * Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
 413  * @return a stream object.
 414 */
 415 opj_stream_t* OPJ_CALLCONV opj_stream_default_create(opj_bool l_is_input)
 416 {
 417         return opj_stream_create(J2K_STREAM_CHUNK_SIZE,l_is_input);
 418 }
 419
 420 /**
 421  * Destroys a stream created by opj_create_stream. This function does NOT close the abstract stream. If needed the user must
 422  * close its own implementation of the stream.
 423  */
 424 OPJ_API void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream)
 425 {
 426         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 427         if (l_stream) {
 428                 opj_free(l_stream->m_stored_data);
 429                 l_stream->m_stored_data = 00;
 430                 opj_free(l_stream);
 431         }
 432 }
 433
 434 /**
 435  * Sets the given function to be used as a read function.
 436  * @param               p_stream        the stream to modify
 437  * @param               p_function      the function to use a read function.
 438 */
 439 OPJ_API void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream, opj_stream_read_fn p_function)
 440 {
 441         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 442
 443         if ((!l_stream) || (! (l_stream->m_status & opj_stream_e_input))) {
 444                 return;
 445         }
 446
 447         l_stream->m_read_fn = p_function;
 448 }
 449
 450 OPJ_API void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream, opj_stream_seek_fn p_function)
 451 {
 452         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 453         if
 454                 (!l_stream)
 455         {
 456                 return;
 457         }
 458         l_stream->m_seek_fn = p_function;
 459 }
 460
 461 /**
 462  * Sets the given function to be used as a write function.
 463  * @param               p_stream        the stream to modify
 464  * @param               p_function      the function to use a write function.
 465 */
 466 OPJ_API void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream, opj_stream_write_fn p_function)
 467 {
 468         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 469         if
 470                 ((!l_stream )|| (! (l_stream->m_status & opj_stream_e_output)))
 471         {
 472                 return;
 473         }
 474         l_stream->m_write_fn = p_function;
 475 }
 476
 477 /**
 478  * Sets the given function to be used as a skip function.
 479  * @param               p_stream        the stream to modify
 480  * @param               p_function      the function to use a skip function.
 481 */
 482 OPJ_API void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream, opj_stream_skip_fn p_function)
 483 {
 484         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 485         if
 486                 (! l_stream)
 487         {
 488                 return;
 489         }
 490         l_stream->m_skip_fn = p_function;
 491 }
 492
 493 /**
 494  * Sets the given data to be used as a user data for the stream.
 495  * @param               p_stream        the stream to modify
 496  * @param               p_data          the data to set.
 497 */
 498 OPJ_API void OPJ_CALLCONV opj_stream_set_user_data(opj_stream_t* p_stream, void * p_data)
 499 {
 500         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 501         l_stream->m_user_data = p_data;
 502 }
 503
 504 /**
 505  * Sets the given data to be used as a user data for the stream.
 506  * @param               p_stream        the stream to modify
 507  * @param               p_data          the data to set.
 508 */
 509 OPJ_API void OPJ_CALLCONV opj_stream_set_user_data_length(opj_stream_t* p_stream, OPJ_UINT64 data_length)
 510 {
 511         opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 512         l_stream->m_user_data_length = data_length;
 513 }
 514
 515 /**
 516  * Reads some bytes from the stream.
 517  * @param               p_stream        the stream to read data from.
 518  * @param               p_buffer        pointer to the data buffer that will receive the data.
 519  * @param               p_size          number of bytes to read.
 520  * @param               p_event_mgr     the user event manager to be notified of special events.
 521  * @return              the number of bytes read, or -1 if an error occured or if the stream is at the end.
 522  */
 523 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)
 524 {
 525         OPJ_SIZE_T l_read_nb_bytes = 0;
 526         if (p_stream->m_bytes_in_buffer >= p_size) {
 527                 memcpy(p_buffer,p_stream->m_current_data,p_size);
 528                 p_stream->m_current_data += p_size;
 529                 p_stream->m_bytes_in_buffer -= p_size;
 530                 l_read_nb_bytes += p_size;
 531                 p_stream->m_byte_offset += p_size;
 532                 return l_read_nb_bytes;
 533         }
 534
 535         /* we are now in the case when the remaining data if not sufficient */
 536         if (p_stream->m_status & opj_stream_e_end) {
 537                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
 538                 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
 539                 p_stream->m_current_data += p_stream->m_bytes_in_buffer;
 540                 p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
 541                 p_stream->m_bytes_in_buffer = 0;
 542                 return l_read_nb_bytes ? l_read_nb_bytes : -1;
 543         }
 544
 545         /* the flag is not set, we copy data and then do an actual read on the stream */
 546         if (p_stream->m_bytes_in_buffer) {
 547                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
 548                 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
 549                 p_stream->m_current_data = p_stream->m_stored_data;
 550                 p_buffer += p_stream->m_bytes_in_buffer;
 551                 p_size -= p_stream->m_bytes_in_buffer;
 552                 p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
 553                 p_stream->m_bytes_in_buffer = 0;
 554         }
 555         else {
 556     /* case where we are already at the end of the buffer
 557        so reset the m_current_data to point to the start of the
 558        stored buffer to get ready to read from disk*/
 559                 p_stream->m_current_data = p_stream->m_stored_data;
 560         }
 561
 562
 563         while(1){
 564                 /* we should read less than a chunk -> read a chunk */
 565                 if (p_size < p_stream->m_buffer_size) {
 566                         /* we should do an actual read on the media */
 567                         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);
 568
 569                         if (p_stream->m_bytes_in_buffer == -1) {
 570                                 /* end of stream */
 571                                 opj_event_msg_v2(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
 572
 573                                 p_stream->m_bytes_in_buffer = 0;
 574                                 p_stream->m_status |= opj_stream_e_end;
 575                                 /* end of stream */
 576                                 return l_read_nb_bytes ? l_read_nb_bytes : -1;
 577                         }
 578                         else if (p_stream->m_bytes_in_buffer < p_size) {
 579                                 /* not enough data */
 580                                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
 581                                 memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
 582                                 p_stream->m_current_data = p_stream->m_stored_data;
 583                                 p_buffer += p_stream->m_bytes_in_buffer;
 584                                 p_size -= p_stream->m_bytes_in_buffer;
 585                                 p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
 586                                 p_stream->m_bytes_in_buffer = 0;
 587                         }
 588                         else {
 589                                 l_read_nb_bytes += p_size;
 590                                 memcpy(p_buffer,p_stream->m_current_data,p_size);
 591                                 p_stream->m_current_data += p_size;
 592                                 p_stream->m_bytes_in_buffer -= p_size;
 593                                 p_stream->m_byte_offset += p_size;
 594                                 return l_read_nb_bytes;
 595                         }
 596                 }
 597                 else {
 598                         /* direct read on the dest buffer */
 599                         p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_buffer,p_size,p_stream->m_user_data);
 600
 601                         if (p_stream->m_bytes_in_buffer == -1) {
 602                                 /*  end of stream */
 603                                 opj_event_msg_v2(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
 604
 605                                 p_stream->m_bytes_in_buffer = 0;
 606                                 p_stream->m_status |= opj_stream_e_end;
 607                                 /* end of stream */
 608                                 return l_read_nb_bytes ? l_read_nb_bytes : -1;
 609                         }
 610                         else if (p_stream->m_bytes_in_buffer < p_size) {
 611                                 /* not enough data */
 612                                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
 613                                 p_stream->m_current_data = p_stream->m_stored_data;
 614                                 p_buffer += p_stream->m_bytes_in_buffer;
 615                                 p_size -= p_stream->m_bytes_in_buffer;
 616                                 p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
 617                                 p_stream->m_bytes_in_buffer = 0;
 618                         }
 619                         else {
 620                                 /* we have read the exact size */
 621                                 l_read_nb_bytes += p_stream->m_bytes_in_buffer;
 622                                 p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
 623                                 p_stream->m_current_data = p_stream->m_stored_data;
 624                                 p_stream->m_bytes_in_buffer = 0;
 625                                 return l_read_nb_bytes;
 626                         }
 627                 }
 628         }
 629 }
 630
 631 /**
 632  * Writes some bytes from the stream.
 633  * @param               p_stream        the stream to write data to.
 634  * @param               p_buffer        pointer to the data buffer holds the data to be writtent.
 635  * @param               p_size          number of bytes to write.
 636  * @param               p_event_mgr     the user event manager to be notified of special events.
 637  * @return              the number of bytes writtent, or -1 if an error occured.
 638  */
 639 OPJ_SIZE_T opj_stream_write_data (opj_stream_private_t * p_stream,const OPJ_BYTE * p_buffer,OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
 640 {
 641         OPJ_SIZE_T l_remaining_bytes = 0;
 642         OPJ_SIZE_T l_write_nb_bytes = 0;
 643
 644         if
 645                 (p_stream->m_status & opj_stream_e_error)
 646         {
 647                 return -1;
 648         }
 649
 650         while(1)
 651         {
 652                 l_remaining_bytes = p_stream->m_buffer_size - p_stream->m_bytes_in_buffer;
 653                 // we have more memory than required
 654                 if
 655                         (l_remaining_bytes >= p_size)
 656                 {
 657                         memcpy(p_stream->m_current_data,p_buffer,p_size);
 658                         p_stream->m_current_data += p_size;
 659                         p_stream->m_bytes_in_buffer += p_size;
 660                         l_write_nb_bytes += p_size;
 661                         p_stream->m_byte_offset += p_size;
 662                         return l_write_nb_bytes;
 663                 }
 664
 665                 // we copy data and then do an actual read on the stream
 666                 if
 667                         (l_remaining_bytes)
 668                 {
 669                         l_write_nb_bytes += l_remaining_bytes;
 670                         memcpy(p_stream->m_current_data,p_buffer,l_remaining_bytes);
 671                         p_stream->m_current_data = p_stream->m_stored_data;
 672                         p_buffer += l_remaining_bytes;
 673                         p_size -= l_remaining_bytes;
 674                         p_stream->m_bytes_in_buffer += l_remaining_bytes;
 675                         p_stream->m_byte_offset += l_remaining_bytes;
 676                 }
 677                 if
 678                         (! opj_stream_flush(p_stream, p_event_mgr))
 679                 {
 680                         return -1;
 681                 }
 682         }
 683
 684 }
 685
 686 /**
 687  * Writes the content of the stream buffer to the stream.
 688  * @param               p_stream        the stream to write data to.
 689  * @param               p_event_mgr     the user event manager to be notified of special events.
 690  * @return              the number of bytes written, or -1 if an error occured.
 691  */
 692 opj_bool opj_stream_flush (opj_stream_private_t * p_stream, opj_event_mgr_t * p_event_mgr)
 693 {
 694         // the number of bytes written on the media.
 695         OPJ_SIZE_T l_current_write_nb_bytes = 0;
 696         p_stream->m_current_data = p_stream->m_stored_data;
 697
 698         while
 699                 (p_stream->m_bytes_in_buffer)
 700         {
 701                 // we should do an actual write on the media
 702                 l_current_write_nb_bytes = p_stream->m_write_fn(p_stream->m_current_data,p_stream->m_bytes_in_buffer,p_stream->m_user_data);
 703                 if
 704                         (l_current_write_nb_bytes == -1)
 705                 {
 706                         p_stream->m_status |= opj_stream_e_error;
 707                         opj_event_msg_v2(p_event_mgr, EVT_INFO, "Error on writting stream!\n");
 708
 709                         return EXIT_FAILURE;
 710                 }
 711                 p_stream->m_current_data += l_current_write_nb_bytes;
 712                 p_stream->m_bytes_in_buffer -= l_current_write_nb_bytes;
 713         }
 714         p_stream->m_current_data = p_stream->m_stored_data;
 715         return EXIT_SUCCESS;
 716 }
 717
 718 /**
 719  * Skips a number of bytes from the stream.
 720  * @param               p_stream        the stream to skip data from.
 721  * @param               p_size          the number of bytes to skip.
 722  * @param               p_event_mgr     the user event manager to be notified of special events.
 723  * @return              the number of bytes skipped, or -1 if an error occured.
 724  */
 725 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)
 726 {
 727         OPJ_OFF_T l_skip_nb_bytes = 0;
 728         OPJ_OFF_T l_current_skip_nb_bytes = 0;
 729
 730         if
 731                 (p_stream->m_bytes_in_buffer >= p_size)
 732         {
 733                 p_stream->m_current_data += p_size;
 734                 // it is safe to cast p_size to OPJ_SIZE_T since it is <= m_bytes_in_buffer
 735                 // which is of type OPJ_SIZE_T
 736                 p_stream->m_bytes_in_buffer -= (OPJ_SIZE_T)p_size;
 737                 l_skip_nb_bytes += p_size;
 738                 p_stream->m_byte_offset += l_skip_nb_bytes;
 739                 return l_skip_nb_bytes;
 740         }
 741
 742         // we are now in the case when the remaining data if not sufficient
 743         if
 744                 (p_stream->m_status & opj_stream_e_end)
 745         {
 746                 l_skip_nb_bytes += p_stream->m_bytes_in_buffer;
 747                 p_stream->m_current_data += p_stream->m_bytes_in_buffer;
 748                 p_stream->m_bytes_in_buffer = 0;
 749                 p_stream->m_byte_offset += l_skip_nb_bytes;
 750                 return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) -1;
 751         }
 752
 753         // the flag is not set, we copy data and then do an actual skip on the stream
 754         if
 755                 (p_stream->m_bytes_in_buffer)
 756         {
 757                 l_skip_nb_bytes += p_stream->m_bytes_in_buffer;
 758                 p_stream->m_current_data = p_stream->m_stored_data;
 759                 p_size -= p_stream->m_bytes_in_buffer;
 760                 p_stream->m_bytes_in_buffer = 0;
 761         }
 762
 763         while
 764                 (p_size > 0)
 765         {
 766                 // we should do an actual skip on the media
 767                 l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
 768                 if
 769                         (l_current_skip_nb_bytes == (OPJ_OFF_T) -1)
 770                 {
 771                         opj_event_msg_v2(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
 772
 773                         p_stream->m_status |= opj_stream_e_end;
 774                         p_stream->m_byte_offset += l_skip_nb_bytes;
 775                         // end if stream
 776                         return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) -1;
 777                 }
 778                 p_size -= l_current_skip_nb_bytes;
 779                 l_skip_nb_bytes += l_current_skip_nb_bytes;
 780         }
 781         p_stream->m_byte_offset += l_skip_nb_bytes;
 782         return l_skip_nb_bytes;
 783 }
 784
 785 /**
 786  * Skips a number of bytes from the stream.
 787  * @param               p_stream        the stream to skip data from.
 788  * @param               p_size          the number of bytes to skip.
 789  * @param               p_event_mgr     the user event manager to be notified of special events.
 790  * @return              the number of bytes skipped, or -1 if an error occured.
 791  */
 792 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)
 793 {
 794         opj_bool l_is_written = 0;
 795         OPJ_OFF_T l_current_skip_nb_bytes = 0;
 796         OPJ_OFF_T l_skip_nb_bytes = 0;
 797
 798         if
 799                 (p_stream->m_status & opj_stream_e_error)
 800         {
 801                 return (OPJ_OFF_T) -1;
 802         }
 803
 804         // we should flush data
 805         l_is_written = opj_stream_flush (p_stream, p_event_mgr);
 806         if
 807                 (! l_is_written)
 808         {
 809                 p_stream->m_status |= opj_stream_e_error;
 810                 p_stream->m_bytes_in_buffer = 0;
 811                 p_stream->m_current_data = p_stream->m_current_data;
 812                 return (OPJ_OFF_T) -1;
 813         }
 814         // then skip
 815
 816         while
 817                 (p_size > 0)
 818         {
 819                 // we should do an actual skip on the media
 820                 l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
 821                 if
 822                         (l_current_skip_nb_bytes == (OPJ_OFF_T)-1)
 823                 {
 824                         opj_event_msg_v2(p_event_mgr, EVT_INFO, "Stream error!\n");
 825
 826                         p_stream->m_status |= opj_stream_e_error;
 827                         p_stream->m_byte_offset += l_skip_nb_bytes;
 828                         // end if stream
 829                         return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T)-1;
 830                 }
 831                 p_size -= l_current_skip_nb_bytes;
 832                 l_skip_nb_bytes += l_current_skip_nb_bytes;
 833         }
 834         p_stream->m_byte_offset += l_skip_nb_bytes;
 835         return l_skip_nb_bytes;
 836 }
 837
 838 /**
 839  * Tells the byte offset on the stream (similar to ftell).
 840  *
 841  * @param               p_stream        the stream to get the information from.
 842  *
 843  * @return              the current position of the stream.
 844  */
 845 OPJ_OFF_T opj_stream_tell (const opj_stream_private_t * p_stream)
 846 {
 847         return p_stream->m_byte_offset;
 848 }
 849
 850
 851 /**
 852  * Get the number of bytes left before the end of the stream (similar to cio_numbytesleft).
 853  *
 854  * @param               p_stream        the stream to get the information from.
 855  *
 856  * @return              Number of bytes left before the end of the stream.
 857  */
 858 OPJ_OFF_T opj_stream_get_number_byte_left (const opj_stream_private_t * p_stream)
 859 {
 860         return p_stream->m_user_data_length ?
 861                                 p_stream->m_user_data_length - p_stream->m_byte_offset :
 862                                 0;
 863 }
 864
 865 /**
 866  * Skips a number of bytes from the stream.
 867  * @param               p_stream        the stream to skip data from.
 868  * @param               p_size          the number of bytes to skip.
 869  * @param               p_event_mgr     the user event manager to be notified of special events.
 870  * @return              the number of bytes skipped, or -1 if an error occured.
 871  */
 872 OPJ_OFF_T opj_stream_skip (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
 873 {
 874         assert(p_size >= 0);
 875         return p_stream->m_opj_skip(p_stream,p_size,p_event_mgr);
 876 }
 877
 878
 879 /**
 880  * Skips a number of bytes from the stream.
 881  * @param               p_stream        the stream to skip data from.
 882  * @param               p_size          the number of bytes to skip.
 883  * @param               p_event_mgr     the user event manager to be notified of special events.
 884  * @return              the number of bytes skipped, or -1 if an error occured.
 885  */
 886 opj_bool opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
 887 {
 888         OPJ_ARG_NOT_USED(p_event_mgr);
 889         p_stream->m_current_data = p_stream->m_stored_data;
 890         p_stream->m_bytes_in_buffer = 0;
 891
 892         if( p_stream->m_seek_fn(p_size,p_stream->m_user_data)) {
 893                 p_stream->m_status |= opj_stream_e_end;
 894                 return EXIT_FAILURE;
 895         }
 896         else {
 897                 // reset stream status
 898                 p_stream->m_status &= (~opj_stream_e_end);
 899                 p_stream->m_byte_offset = p_size;
 900
 901         }
 902
 903         return EXIT_SUCCESS;
 904 }
 905
 906 /**
 907  * Skips a number of bytes from the stream.
 908  * @param               p_stream        the stream to skip data from.
 909  * @param               p_size          the number of bytes to skip.
 910  * @param               p_event_mgr     the user event manager to be notified of special events.
 911  * @return              the number of bytes skipped, or -1 if an error occured.
 912  */
 913 opj_bool opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
 914 {
 915         if
 916                 (! opj_stream_flush(p_stream,p_event_mgr))
 917         {
 918                 p_stream->m_status |= opj_stream_e_error;
 919                 return EXIT_FAILURE;
 920         }
 921
 922         p_stream->m_current_data = p_stream->m_stored_data;
 923         p_stream->m_bytes_in_buffer = 0;
 924
 925         if
 926                 (! p_stream->m_seek_fn(p_size,p_stream->m_user_data))
 927         {
 928                 p_stream->m_status |= opj_stream_e_error;
 929                 return EXIT_FAILURE;
 930         }
 931         else
 932         {
 933                 p_stream->m_byte_offset = p_size;
 934         }
 935         return EXIT_SUCCESS;
 936 }
 937
 938
 939 /**
 940  * Seeks a number of bytes from the stream.
 941  * @param               p_stream        the stream to skip data from.
 942  * @param               p_size          the number of bytes to skip.
 943  * @param               p_event_mgr     the user event manager to be notified of special events.
 944  * @return              true if the stream is seekable.
 945  */
 946 opj_bool opj_stream_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr)
 947 {
 948         assert(p_size >= 0);
 949         return p_stream->m_opj_seek(p_stream,p_size,p_event_mgr);
 950 }
 951
 952 /**
 953  * Tells if the given stream is seekable.
 954  */
 955 opj_bool opj_stream_has_seek (const opj_stream_private_t * p_stream)
 956 {
 957         return p_stream->m_seek_fn != opj_stream_default_seek;
 958 }
 959
 960 OPJ_SIZE_T opj_stream_default_read (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
 961 {
 962         OPJ_ARG_NOT_USED(p_buffer);
 963         OPJ_ARG_NOT_USED(p_nb_bytes);
 964         OPJ_ARG_NOT_USED(p_user_data);
 965         return (OPJ_SIZE_T) -1;
 966 }
 967
 968 OPJ_SIZE_T opj_stream_default_write (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
 969 {
 970         OPJ_ARG_NOT_USED(p_buffer);
 971         OPJ_ARG_NOT_USED(p_nb_bytes);
 972         OPJ_ARG_NOT_USED(p_user_data);
 973         return (OPJ_SIZE_T) -1;
 974 }
 975
 976 OPJ_OFF_T opj_stream_default_skip (OPJ_OFF_T p_nb_bytes, void * p_user_data)
 977 {
 978         OPJ_ARG_NOT_USED(p_nb_bytes);
 979         OPJ_ARG_NOT_USED(p_user_data);
 980         return (OPJ_OFF_T) -1;
 981 }
 982
 983 opj_bool opj_stream_default_seek (OPJ_OFF_T p_nb_bytes, void * p_user_data)
 984 {
 985         OPJ_ARG_NOT_USED(p_nb_bytes);
 986         OPJ_ARG_NOT_USED(p_user_data);
 987         return EXIT_FAILURE;
 988 }