opj_free(cio);
return NULL;
}
- cio->length = (unsigned int) (0.1625 * cp->img_size + 2000); /* 0.1625 = 1.3/8 and 2000 bytes as a minimum for headers */
- cio->buffer = (unsigned char *)opj_malloc(cio->length);
+ cio->length = (int) (0.1625 * cp->img_size + 2000); /* 0.1625 = 1.3/8 and 2000 bytes as a minimum for headers */
+ assert(cio->length >= 0);
+ cio->buffer = (unsigned char *)opj_malloc((OPJ_SIZE_T)cio->length);
if(!cio->buffer) {
opj_event_msg(cio->cinfo, EVT_ERROR, "Error allocating memory for compressed bitstream\n");
opj_free(cio);
/*
* Get position in byte stream.
*/
-int OPJ_CALLCONV cio_tell(opj_cio_t *cio) {
+OPJ_OFF_T OPJ_CALLCONV cio_tell(opj_cio_t *cio) {
return cio->bp - cio->start;
}
/*
* Number of bytes left before the end of the stream.
*/
-int cio_numbytesleft(opj_cio_t *cio) {
- return cio->end - cio->bp;
+OPJ_SIZE_T cio_numbytesleft(opj_cio_t *cio) {
+ const ptrdiff_t diff = cio->end - cio->bp;
+ assert( diff >= 0 );
+ return (OPJ_SIZE_T)diff;
}
/*
if( !cio_byteout(cio, (unsigned char) ((v >> (i << 3)) & 0xff)) )
return 0;
}
- return n;
+ assert( n >= 0 );
+ return (unsigned int)n;
}
/*
*/
unsigned int cio_read(opj_cio_t *cio, int n) {
int i;
- unsigned int v;
- v = 0;
+ unsigned int v = 0;
for (i = n - 1; i >= 0; i--) {
- v += cio_bytein(cio) << (i << 3);
+ const unsigned int c = cio_bytein(cio);
+ v += c << (i << 3);
}
return v;
}
* Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
* @return a stream object.
*/
-opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_UINT32 p_size,opj_bool l_is_input)
+opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size,opj_bool l_is_input)
{
opj_stream_private_t * l_stream = 00;
l_stream = (opj_stream_private_t*) opj_malloc(sizeof(opj_stream_private_t));
}
memset(l_stream,0,sizeof(opj_stream_private_t));
- l_stream->m_buffer_size = p_size;
- l_stream->m_stored_data = (OPJ_BYTE *) opj_malloc(p_size);
+ l_stream->m_buffer_size = p_buffer_size;
+ l_stream->m_stored_data = (OPJ_BYTE *) opj_malloc(p_buffer_size);
if (! l_stream->m_stored_data) {
opj_free(l_stream);
return 00;
OPJ_API void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
+
if (l_stream) {
opj_free(l_stream->m_stored_data);
l_stream->m_stored_data = 00;
OPJ_API void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream, opj_stream_seek_fn p_function)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
- if
- (!l_stream)
- {
+
+ if (!l_stream) {
return;
}
l_stream->m_seek_fn = p_function;
OPJ_API void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream, opj_stream_write_fn p_function)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
- if
- ((!l_stream )|| (! (l_stream->m_status & opj_stream_e_output)))
- {
+
+ if ((!l_stream )|| (! (l_stream->m_status & opj_stream_e_output))) {
return;
}
+
l_stream->m_write_fn = p_function;
}
OPJ_API void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream, opj_stream_skip_fn p_function)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
- if
- (! l_stream)
- {
+
+ if (! l_stream) {
return;
}
+
l_stream->m_skip_fn = p_function;
}
* @param p_stream the stream to modify
* @param p_data the data to set.
*/
-OPJ_API void OPJ_CALLCONV opj_stream_set_user_data_length(opj_stream_t* p_stream, OPJ_UINT32 data_length)
+OPJ_API void OPJ_CALLCONV opj_stream_set_user_data_length(opj_stream_t* p_stream, OPJ_UINT64 data_length)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
-
l_stream->m_user_data_length = data_length;
}
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes read, or -1 if an error occured or if the stream is at the end.
*/
-OPJ_UINT32 opj_stream_read_data (opj_stream_private_t * p_stream,OPJ_BYTE * p_buffer, OPJ_UINT32 p_size, opj_event_mgr_t * p_event_mgr)
+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)
{
- OPJ_UINT32 l_read_nb_bytes = 0;
+ OPJ_SIZE_T l_read_nb_bytes = 0;
if (p_stream->m_bytes_in_buffer >= p_size) {
memcpy(p_buffer,p_stream->m_current_data,p_size);
p_stream->m_current_data += p_size;
p_stream->m_bytes_in_buffer -= p_size;
l_read_nb_bytes += p_size;
- p_stream->m_byte_offset += p_size;
+ p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
return l_read_nb_bytes;
}
l_read_nb_bytes += p_stream->m_bytes_in_buffer;
memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
p_stream->m_current_data += p_stream->m_bytes_in_buffer;
- p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
+ p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
- return l_read_nb_bytes ? l_read_nb_bytes : -1;
+ return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
}
/* the flag is not set, we copy data and then do an actual read on the stream */
p_stream->m_current_data = p_stream->m_stored_data;
p_buffer += p_stream->m_bytes_in_buffer;
p_size -= p_stream->m_bytes_in_buffer;
- p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
+ p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
}
else {
/* we should do an actual read on the media */
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);
- if (p_stream->m_bytes_in_buffer == -1) {
+ if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T)-1) {
/* end of stream */
opj_event_msg_v2(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
p_stream->m_bytes_in_buffer = 0;
p_stream->m_status |= opj_stream_e_end;
/* end of stream */
- return l_read_nb_bytes ? l_read_nb_bytes : -1;
+ return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
}
else if (p_stream->m_bytes_in_buffer < p_size) {
/* not enough data */
p_stream->m_current_data = p_stream->m_stored_data;
p_buffer += p_stream->m_bytes_in_buffer;
p_size -= p_stream->m_bytes_in_buffer;
- p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
+ p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
}
else {
memcpy(p_buffer,p_stream->m_current_data,p_size);
p_stream->m_current_data += p_size;
p_stream->m_bytes_in_buffer -= p_size;
- p_stream->m_byte_offset += p_size;
+ p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
return l_read_nb_bytes;
}
}
/* direct read on the dest buffer */
p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_buffer,p_size,p_stream->m_user_data);
- if (p_stream->m_bytes_in_buffer == -1) {
+ if (p_stream->m_bytes_in_buffer == (OPJ_SIZE_T)-1) {
/* end of stream */
opj_event_msg_v2(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
p_stream->m_bytes_in_buffer = 0;
p_stream->m_status |= opj_stream_e_end;
/* end of stream */
- return l_read_nb_bytes ? l_read_nb_bytes : -1;
+ return l_read_nb_bytes ? l_read_nb_bytes : (OPJ_SIZE_T)-1;
}
else if (p_stream->m_bytes_in_buffer < p_size) {
/* not enough data */
p_stream->m_current_data = p_stream->m_stored_data;
p_buffer += p_stream->m_bytes_in_buffer;
p_size -= p_stream->m_bytes_in_buffer;
- p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
+ p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
}
else {
/* we have read the exact size */
l_read_nb_bytes += p_stream->m_bytes_in_buffer;
- p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
+ p_stream->m_byte_offset += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
p_stream->m_current_data = p_stream->m_stored_data;
p_stream->m_bytes_in_buffer = 0;
return l_read_nb_bytes;
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes writtent, or -1 if an error occured.
*/
-OPJ_UINT32 opj_stream_write_data (opj_stream_private_t * p_stream,const OPJ_BYTE * p_buffer,OPJ_UINT32 p_size, opj_event_mgr_t * p_event_mgr)
+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)
{
- OPJ_UINT32 l_remaining_bytes = 0;
- OPJ_UINT32 l_write_nb_bytes = 0;
+ OPJ_SIZE_T l_remaining_bytes = 0;
+ OPJ_SIZE_T l_write_nb_bytes = 0;
- if
- (p_stream->m_status & opj_stream_e_error)
- {
- return -1;
+ if (p_stream->m_status & opj_stream_e_error) {
+ return (OPJ_SIZE_T)-1;
}
- while(1)
- {
+ while(1) {
l_remaining_bytes = p_stream->m_buffer_size - p_stream->m_bytes_in_buffer;
- // we have more memory than required
- if
- (l_remaining_bytes >= p_size)
- {
- memcpy(p_stream->m_current_data,p_buffer,p_size);
+
+ /* we have more memory than required */
+ if (l_remaining_bytes >= p_size) {
+ memcpy(p_stream->m_current_data, p_buffer, p_size);
+
p_stream->m_current_data += p_size;
p_stream->m_bytes_in_buffer += p_size;
l_write_nb_bytes += p_size;
- p_stream->m_byte_offset += p_size;
+ p_stream->m_byte_offset += (OPJ_OFF_T)p_size;
+
return l_write_nb_bytes;
}
- // we copy data and then do an actual read on the stream
- if
- (l_remaining_bytes)
- {
+ /* we copy data and then do an actual read on the stream */
+ if (l_remaining_bytes) {
l_write_nb_bytes += l_remaining_bytes;
+
memcpy(p_stream->m_current_data,p_buffer,l_remaining_bytes);
+
p_stream->m_current_data = p_stream->m_stored_data;
+
p_buffer += l_remaining_bytes;
p_size -= l_remaining_bytes;
p_stream->m_bytes_in_buffer += l_remaining_bytes;
- p_stream->m_byte_offset += l_remaining_bytes;
+ p_stream->m_byte_offset += (OPJ_OFF_T)l_remaining_bytes;
}
- if
- (! opj_stream_flush(p_stream, p_event_mgr))
- {
- return -1;
+
+ if (! opj_stream_flush(p_stream, p_event_mgr)) {
+ return (OPJ_SIZE_T)-1;
}
}
*/
opj_bool opj_stream_flush (opj_stream_private_t * p_stream, opj_event_mgr_t * p_event_mgr)
{
- // the number of bytes written on the media.
- OPJ_UINT32 l_current_write_nb_bytes = 0;
+ /* the number of bytes written on the media. */
+ OPJ_SIZE_T l_current_write_nb_bytes = 0;
+
p_stream->m_current_data = p_stream->m_stored_data;
- while
- (p_stream->m_bytes_in_buffer)
- {
- // we should do an actual write on the media
- 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);
- if
- (l_current_write_nb_bytes == -1)
- {
+ while (p_stream->m_bytes_in_buffer) {
+ /* we should do an actual write on the media */
+ 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);
+
+ if (l_current_write_nb_bytes == (OPJ_SIZE_T)-1) {
p_stream->m_status |= opj_stream_e_error;
opj_event_msg_v2(p_event_mgr, EVT_INFO, "Error on writting stream!\n");
- return EXIT_FAILURE;
+ return OPJ_FALSE;
}
+
p_stream->m_current_data += l_current_write_nb_bytes;
p_stream->m_bytes_in_buffer -= l_current_write_nb_bytes;
}
+
p_stream->m_current_data = p_stream->m_stored_data;
- return EXIT_SUCCESS;
+
+ return OPJ_TRUE;
}
/**
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/
-OPJ_SIZE_T opj_stream_read_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
+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)
{
- OPJ_SIZE_T l_skip_nb_bytes = 0;
- OPJ_SIZE_T l_current_skip_nb_bytes = 0;
-
- if
- (p_stream->m_bytes_in_buffer >= p_size)
- {
+ OPJ_OFF_T l_skip_nb_bytes = 0;
+ OPJ_OFF_T l_current_skip_nb_bytes = 0;
+
+ assert( p_size >= 0 );
+
+ if (p_stream->m_bytes_in_buffer >= (OPJ_SIZE_T)p_size) {
p_stream->m_current_data += p_size;
- p_stream->m_bytes_in_buffer -= p_size;
+ /* it is safe to cast p_size to OPJ_SIZE_T since it is <= m_bytes_in_buffer
+ which is of type OPJ_SIZE_T */
+ p_stream->m_bytes_in_buffer -= (OPJ_SIZE_T)p_size;
l_skip_nb_bytes += p_size;
p_stream->m_byte_offset += l_skip_nb_bytes;
return l_skip_nb_bytes;
}
- // we are now in the case when the remaining data if not sufficient
- if
- (p_stream->m_status & opj_stream_e_end)
- {
- l_skip_nb_bytes += p_stream->m_bytes_in_buffer;
+ /* we are now in the case when the remaining data if not sufficient */
+ if (p_stream->m_status & opj_stream_e_end) {
+ l_skip_nb_bytes += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
p_stream->m_current_data += p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
p_stream->m_byte_offset += l_skip_nb_bytes;
- return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_SIZE_T) -1;
+ return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) -1;
}
- // the flag is not set, we copy data and then do an actual skip on the stream
- if
- (p_stream->m_bytes_in_buffer)
- {
- l_skip_nb_bytes += p_stream->m_bytes_in_buffer;
+ /* the flag is not set, we copy data and then do an actual skip on the stream */
+ if (p_stream->m_bytes_in_buffer) {
+ l_skip_nb_bytes += (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
p_stream->m_current_data = p_stream->m_stored_data;
- p_size -= p_stream->m_bytes_in_buffer;
+ p_size -= (OPJ_OFF_T)p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
}
- while
- (p_size > 0)
- {
- // we should do an actual skip on the media
+ while (p_size > 0) {
+ /* we should do an actual skip on the media */
l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
- if
- (l_current_skip_nb_bytes == (OPJ_SIZE_T) -1)
- {
+ if (l_current_skip_nb_bytes == (OPJ_OFF_T) -1) {
opj_event_msg_v2(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
p_stream->m_status |= opj_stream_e_end;
p_stream->m_byte_offset += l_skip_nb_bytes;
- // end if stream
- return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_SIZE_T) -1;
+ /* end if stream */
+ return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T) -1;
}
p_size -= l_current_skip_nb_bytes;
l_skip_nb_bytes += l_current_skip_nb_bytes;
}
+
p_stream->m_byte_offset += l_skip_nb_bytes;
+
return l_skip_nb_bytes;
}
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/
-OPJ_SIZE_T opj_stream_write_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
+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)
{
opj_bool l_is_written = 0;
- OPJ_SIZE_T l_current_skip_nb_bytes = 0;
- OPJ_SIZE_T l_skip_nb_bytes = 0;
+ OPJ_OFF_T l_current_skip_nb_bytes = 0;
+ OPJ_OFF_T l_skip_nb_bytes = 0;
- if
- (p_stream->m_status & opj_stream_e_error)
- {
- return (OPJ_SIZE_T) -1;
+ if (p_stream->m_status & opj_stream_e_error) {
+ return (OPJ_OFF_T) -1;
}
- // we should flush data
+ /* we should flush data */
l_is_written = opj_stream_flush (p_stream, p_event_mgr);
- if
- (! l_is_written)
- {
+ if (! l_is_written) {
p_stream->m_status |= opj_stream_e_error;
p_stream->m_bytes_in_buffer = 0;
p_stream->m_current_data = p_stream->m_current_data;
- return (OPJ_SIZE_T) -1;
+ return (OPJ_OFF_T) -1;
}
- // then skip
+ /* then skip */
- while
- (p_size > 0)
- {
- // we should do an actual skip on the media
+ while (p_size > 0) {
+ /* we should do an actual skip on the media */
l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
- if
- (l_current_skip_nb_bytes == (OPJ_SIZE_T)-1)
- {
+
+ if (l_current_skip_nb_bytes == (OPJ_OFF_T)-1) {
opj_event_msg_v2(p_event_mgr, EVT_INFO, "Stream error!\n");
p_stream->m_status |= opj_stream_e_error;
p_stream->m_byte_offset += l_skip_nb_bytes;
- // end if stream
- return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_SIZE_T)-1;
+ /* end if stream */
+ return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_OFF_T)-1;
}
p_size -= l_current_skip_nb_bytes;
l_skip_nb_bytes += l_current_skip_nb_bytes;
}
+
p_stream->m_byte_offset += l_skip_nb_bytes;
+
return l_skip_nb_bytes;
}
*
* @return the current position of the stream.
*/
-OPJ_SIZE_T opj_stream_tell (const opj_stream_private_t * p_stream)
+OPJ_OFF_T opj_stream_tell (const opj_stream_private_t * p_stream)
{
return p_stream->m_byte_offset;
}
*
* @return Number of bytes left before the end of the stream.
*/
-OPJ_SIZE_T opj_stream_get_number_byte_left (const opj_stream_private_t * p_stream)
+OPJ_OFF_T opj_stream_get_number_byte_left (const opj_stream_private_t * p_stream)
{
- return p_stream->m_user_data_length ?
- p_stream->m_user_data_length - p_stream->m_byte_offset :
+ assert( p_stream->m_byte_offset >= 0 );
+ assert( p_stream->m_user_data_length >= (OPJ_UINT64)p_stream->m_byte_offset);
+ return p_stream->m_user_data_length ?
+ (OPJ_OFF_T)(p_stream->m_user_data_length) - p_stream->m_byte_offset :
0;
}
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/
-OPJ_SIZE_T opj_stream_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
+OPJ_OFF_T opj_stream_skip (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
{
+ assert(p_size >= 0);
return p_stream->m_opj_skip(p_stream,p_size,p_event_mgr);
}
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/
-opj_bool opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
+opj_bool opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
{
+ OPJ_ARG_NOT_USED(p_event_mgr);
p_stream->m_current_data = p_stream->m_stored_data;
p_stream->m_bytes_in_buffer = 0;
- if( p_stream->m_seek_fn(p_size,p_stream->m_user_data)) {
+ if( !(p_stream->m_seek_fn(p_size,p_stream->m_user_data)) ) {
p_stream->m_status |= opj_stream_e_end;
- return EXIT_FAILURE;
+ return OPJ_FALSE;
}
else {
- // reset stream status
+ /* reset stream status */
p_stream->m_status &= (~opj_stream_e_end);
p_stream->m_byte_offset = p_size;
}
- return EXIT_SUCCESS;
+ return OPJ_TRUE;
}
/**
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/
-opj_bool opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
+opj_bool opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, opj_event_mgr_t * p_event_mgr)
{
- if
- (! opj_stream_flush(p_stream,p_event_mgr))
- {
+ if (! opj_stream_flush(p_stream,p_event_mgr)) {
p_stream->m_status |= opj_stream_e_error;
- return EXIT_FAILURE;
+ return OPJ_FALSE;
}
p_stream->m_current_data = p_stream->m_stored_data;
p_stream->m_bytes_in_buffer = 0;
- if
- (! p_stream->m_seek_fn(p_size,p_stream->m_user_data))
- {
+ if (! p_stream->m_seek_fn(p_size,p_stream->m_user_data)) {
p_stream->m_status |= opj_stream_e_error;
- return EXIT_FAILURE;
+ return OPJ_FALSE;
}
- else
- {
+ else {
p_stream->m_byte_offset = p_size;
}
- return EXIT_SUCCESS;
+
+ return OPJ_TRUE;
}
* @param p_event_mgr the user event manager to be notified of special events.
* @return true if the stream is seekable.
*/
-opj_bool opj_stream_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr)
+opj_bool opj_stream_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr)
{
+ assert(p_size >= 0);
return p_stream->m_opj_seek(p_stream,p_size,p_event_mgr);
}
return p_stream->m_seek_fn != opj_stream_default_seek;
}
-
-
-
-
-OPJ_UINT32 opj_stream_default_read (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data)
+OPJ_SIZE_T opj_stream_default_read (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
{
- return (OPJ_UINT32) -1;
-}
-OPJ_UINT32 opj_stream_default_write (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data)
-{
- return (OPJ_UINT32) -1;
+ OPJ_ARG_NOT_USED(p_buffer);
+ OPJ_ARG_NOT_USED(p_nb_bytes);
+ OPJ_ARG_NOT_USED(p_user_data);
+ return (OPJ_SIZE_T) -1;
}
-OPJ_SIZE_T opj_stream_default_skip (OPJ_SIZE_T p_nb_bytes, void * p_user_data)
+
+OPJ_SIZE_T opj_stream_default_write (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
{
+ OPJ_ARG_NOT_USED(p_buffer);
+ OPJ_ARG_NOT_USED(p_nb_bytes);
+ OPJ_ARG_NOT_USED(p_user_data);
return (OPJ_SIZE_T) -1;
}
-opj_bool opj_stream_default_seek (OPJ_SIZE_T p_nb_bytes, void * p_user_data)
+OPJ_OFF_T opj_stream_default_skip (OPJ_OFF_T p_nb_bytes, void * p_user_data)
{
- return EXIT_FAILURE;
+ OPJ_ARG_NOT_USED(p_nb_bytes);
+ OPJ_ARG_NOT_USED(p_user_data);
+ return (OPJ_OFF_T) -1;
}
-
-
-
+opj_bool opj_stream_default_seek (OPJ_OFF_T p_nb_bytes, void * p_user_data)
+{
+ OPJ_ARG_NOT_USED(p_nb_bytes);
+ OPJ_ARG_NOT_USED(p_user_data);
+ return OPJ_FALSE;
+}
projects / openjpeg.git / blobdiff