! : changed
+ : added
+November 30, 2011
+* [jmalik] implement Large File support in the library :
+ - fix portability layer for windows (need WIN32)
+ - include opj_config.h before any system header (index)
+ - change types related to buffer size to OPJ_SIZE_T, for anything sent to memcpy, fread, fwrite
+ - change types related to index in stream to OPJ_OFF_T, thus resolving to a 64 bit signed integer
+ - change types related to size of stream to OPJ_UINT64_T
+ - change calls to fseek/ftell to LFS-capable OPJ_SEEK/OPJ_TELL
+
November 29, 2011
* [mickael] fix error with new way to detect kdu_expand
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
* POSSIBILITY OF SUCH DAMAGE.\r
*/\r
+#include "opj_config.h"\r
\r
#include <stdio.h>\r
#include <math.h>\r
* 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;
* @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;
* @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)
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;
+ OPJ_SIZE_T l_current_write_nb_bytes = 0;
p_stream->m_current_data = p_stream->m_stored_data;
while
* @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;
+ OPJ_OFF_T l_skip_nb_bytes = 0;
+ OPJ_OFF_T l_current_skip_nb_bytes = 0;
if
(p_stream->m_bytes_in_buffer >= 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;
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
// 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)
+ (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;
+ 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;
* @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;
+ return (OPJ_OFF_T) -1;
}
// we should flush data
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
// 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)
+ (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;
+ 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;
*
* @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 :
* @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;
* @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))
* @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_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_UINT32 opj_stream_default_write (void * p_buffer, OPJ_UINT32 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)
{
- 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_OFF_T opj_stream_default_skip (OPJ_OFF_T p_nb_bytes, void * p_user_data)
{
- return (OPJ_SIZE_T) -1;
+ 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_SIZE_T p_nb_bytes, void * p_user_data)
+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 EXIT_FAILURE;
}
-
-
-
-
/**
* User data length
*/
- OPJ_UINT32 m_user_data_length;
+ OPJ_UINT64 m_user_data_length;
/**
* Pointer to actual read function (NULL at the initialization of the cio.
*/
OPJ_BYTE * m_current_data;
- OPJ_SIZE_T (* m_opj_skip)(struct opj_stream_private * ,OPJ_SIZE_T , struct opj_event_mgr *);
+ OPJ_OFF_T (* m_opj_skip)(struct opj_stream_private * ,OPJ_OFF_T , struct opj_event_mgr *);
- opj_bool (* m_opj_seek) (struct opj_stream_private * , OPJ_SIZE_T , struct opj_event_mgr *);
+ opj_bool (* m_opj_seek) (struct opj_stream_private * , OPJ_OFF_T , struct opj_event_mgr *);
/**
* number of bytes containing in the buffer.
*/
- OPJ_UINT32 m_bytes_in_buffer;
+ OPJ_SIZE_T m_bytes_in_buffer;
/**
- * The number of bytes read/written.
+ * The number of bytes read/written from the beginning of the stream
*/
- OPJ_SIZE_T m_byte_offset;
+ OPJ_OFF_T m_byte_offset;
/**
* The size of the buffer.
*/
- OPJ_UINT32 m_buffer_size;
+ OPJ_SIZE_T m_buffer_size;
/**
* Flags to tell the status of the stream.
* @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, struct opj_event_mgr * 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, struct opj_event_mgr * p_event_mgr);
/**
* Writes some bytes to the stream.
* @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, struct opj_event_mgr * 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, struct opj_event_mgr * p_event_mgr);
/**
* Writes the content of the stream buffer to the stream.
* @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, struct opj_event_mgr * p_event_mgr);
+OPJ_OFF_T opj_stream_skip (opj_stream_private_t * p_stream,OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr);
/**
* Tells the byte offset on the stream (similar to ftell).
*
* @return the current position o fthe 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 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);
/**
* Skips a number of bytes from the stream.
* @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, struct opj_event_mgr * p_event_mgr);
+OPJ_OFF_T opj_stream_write_skip (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr);
/**
* Skips a number of bytes from the stream.
* @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, struct opj_event_mgr * p_event_mgr);
+OPJ_OFF_T opj_stream_read_skip (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr);
/**
* Skips a number of bytes from the stream.
* @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, struct opj_event_mgr * p_event_mgr);
+opj_bool opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr);
/**
* Skips a number of bytes from the stream.
* @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, struct opj_event_mgr * p_event_mgr);
+opj_bool opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_OFF_T p_size, struct opj_event_mgr * p_event_mgr);
/**
* Seeks a number of bytes from the stream.
* @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);
/**
* Tells if the given stream is seekable.
*/
opj_bool opj_stream_has_seek (const opj_stream_private_t * p_stream);
-OPJ_UINT32 opj_stream_default_read (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data);
-OPJ_UINT32 opj_stream_default_write (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data);
-OPJ_SIZE_T opj_stream_default_skip (OPJ_SIZE_T p_nb_bytes, void * p_user_data);
-opj_bool opj_stream_default_seek (OPJ_SIZE_T 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);
+OPJ_SIZE_T opj_stream_default_write (void * p_buffer, 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);
+opj_bool opj_stream_default_seek (OPJ_OFF_T p_nb_bytes, void * p_user_data);
*/
static void j2k_add_mhmarker(opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);
-static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_UINT32 pos, OPJ_UINT32 len) ;
+static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) ;
/**
Add tile header marker information
@param tileno tile index number
*/
static void j2k_add_tlmarker( int tileno, opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);
-static void j2k_add_tlmarker_v2(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_UINT32 pos, OPJ_UINT32 len);
+static void j2k_add_tlmarker_v2(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len);
/**
* Reads an unknown marker
p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSIZ;
/* FIXME move it in a index structure included in p_j2k*/
- p_j2k->cstr_index->main_head_start = (OPJ_UINT32) opj_stream_tell(p_stream) - 2;
+ p_j2k->cstr_index->main_head_start = opj_stream_tell(p_stream) - 2;
opj_event_msg_v2(p_manager, EVT_INFO, "Start to read j2k main header (%d).\n", p_j2k->cstr_index->main_head_start);
l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
- if (p_j2k->m_specific_param.m_decoder.m_last_tile_part)
- p_j2k->m_specific_param.m_decoder.m_sot_length = opj_stream_get_number_byte_left(p_stream) - 2;
+ if (p_j2k->m_specific_param.m_decoder.m_last_tile_part) {
+ // opj_stream_get_number_byte_left returns OPJ_OFF_T
+ // but we are in the last tile part,
+ // so its result will fit on OPJ_UINT32 unless we find
+ // a file with a single tile part of more than 4 GB...
+ p_j2k->m_specific_param.m_decoder.m_sot_length = (OPJ_UINT32)(opj_stream_get_number_byte_left(p_stream) - 2);
+ }
else
p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
l_tile_len = &l_tcp->m_data_size;
if (! *l_current_data) {
- *l_current_data = (OPJ_BYTE*) opj_malloc/*FIXME V2 -> my_opj_malloc*/(p_j2k->m_specific_param.m_decoder.m_sot_length);
+ *l_current_data = (OPJ_BYTE*) opj_malloc(p_j2k->m_specific_param.m_decoder.m_sot_length);
}
else {
- *l_current_data = (OPJ_BYTE*) opj_realloc/*FIXME V2 -> my_opj_realloc*/(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
+ *l_current_data = (OPJ_BYTE*) opj_realloc(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
}
if (*l_current_data == 00) {
/* Index */
l_cstr_index = p_j2k->cstr_index;
if (l_cstr_index) {
- OPJ_SIZE_T l_current_pos = opj_stream_tell(p_stream) - 2;
- OPJ_UINT32 l_current_tile_part =l_cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno;
+ OPJ_OFF_T l_current_pos = opj_stream_tell(p_stream) - 2;
+
+ OPJ_UINT32 l_current_tile_part = l_cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno;
l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_header =
l_current_pos;
l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_pos =
/*l_cstr_index->packno = 0;*/
}
-
-
-
-
-
-
l_current_read_size = opj_stream_read_data( p_stream,
*l_current_data + *l_tile_len,
p_j2k->m_specific_param.m_decoder.m_sot_length,
}
-static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_UINT32 pos, OPJ_UINT32 len) {
+static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) {
if (!cstr_index)
return;
cstr_info->tile[tileno].marknum++;
}
-static void j2k_add_tlmarker_v2(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_UINT32 pos, OPJ_UINT32 len)
+static void j2k_add_tlmarker_v2(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len)
{
if (!cstr_index)
*
* @return the handler associated with the id.
*/
-const opj_dec_memory_marker_handler_t * j2k_get_marker_handler (const OPJ_UINT32 p_id)
+const opj_dec_memory_marker_handler_t * j2k_get_marker_handler (OPJ_UINT32 p_id)
{
const opj_dec_memory_marker_handler_t *e;
for (e = j2k_memory_marker_handler_tab; e->id != 0; ++e) {
l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
if (! l_tcp->m_data) {
- j2k_tcp_destroy(&(p_j2k->m_cp.tcps[p_tile_index]));
+ j2k_tcp_destroy(&l_tcp);
return OPJ_FALSE;
}
if (!j2k_allocate_tile_element_cstr_index(p_j2k))
return OPJ_FALSE;
}
-
/* Move into the codestream to the first SOT used to decode the desired tile */
l_tile_no_to_dec = p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec;
if (p_j2k->cstr_index->tile_index)
if(p_j2k->cstr_index->tile_index->tp_index)
{
if ( ! p_j2k->cstr_index->tile_index[l_tile_no_to_dec].nb_tps) {
- /* not build the index for this tile, so we will move to the last SOT read*/
+ /* the index for this tile has not been built,
+ * so move to the last SOT read */
if ( opj_stream_read_seek(p_stream, p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos+2, p_manager) ){
opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n");
return OPJ_FALSE;
/** Index of the tile to decode (used in get_tile) */
OPJ_INT32 m_tile_ind_to_dec;
/** Position of the last SOT marker read */
- OPJ_UINT32 m_last_sot_read_pos;
+ OPJ_OFF_T m_last_sot_read_pos;
/**
* Indicate that the current tile-part is assume as the last tile part of the codestream.
/* ---------------------------------------------------------------------- */
-OPJ_UINT32 opj_read_from_file (void * p_buffer, OPJ_UINT32 p_nb_bytes, FILE * p_file)
+OPJ_SIZE_T opj_read_from_file (void * p_buffer, OPJ_SIZE_T p_nb_bytes, FILE * p_file)
{
- OPJ_UINT32 l_nb_read = fread(p_buffer,1,p_nb_bytes,p_file);
+ OPJ_SIZE_T l_nb_read = fread(p_buffer,1,p_nb_bytes,p_file);
return l_nb_read ? l_nb_read : -1;
}
-OPJ_UINT32 opj_get_data_length_from_file (FILE * p_file)
+OPJ_UINT64 opj_get_data_length_from_file (FILE * p_file)
{
- OPJ_UINT32 file_length = 0;
+ OPJ_OFF_T file_length = 0;
- fseek(p_file, 0, SEEK_END);
- file_length = ftell(p_file);
- fseek(p_file, 0, SEEK_SET);
+ OPJ_FSEEK(p_file, 0, SEEK_END);
+ file_length = (OPJ_UINT64)OPJ_FTELL(p_file);
+ OPJ_FSEEK(p_file, 0, SEEK_SET);
return file_length;
}
-OPJ_UINT32 opj_write_from_file (void * p_buffer, OPJ_UINT32 p_nb_bytes, FILE * p_file)
+OPJ_SIZE_T opj_write_from_file (void * p_buffer, OPJ_SIZE_T p_nb_bytes, FILE * p_file)
{
return fwrite(p_buffer,1,p_nb_bytes,p_file);
}
-OPJ_SIZE_T opj_skip_from_file (OPJ_SIZE_T p_nb_bytes, FILE * p_user_data)
+OPJ_OFF_T opj_skip_from_file (OPJ_OFF_T p_nb_bytes, FILE * p_user_data)
{
- if (fseek(p_user_data,p_nb_bytes,SEEK_CUR)) {
+ if (OPJ_FSEEK(p_user_data,p_nb_bytes,SEEK_CUR)) {
return -1;
}
return p_nb_bytes;
}
-opj_bool opj_seek_from_file (OPJ_SIZE_T p_nb_bytes, FILE * p_user_data)
+opj_bool opj_seek_from_file (OPJ_OFF_T p_nb_bytes, FILE * p_user_data)
{
- if (fseek(p_user_data,p_nb_bytes,SEEK_SET)) {
+ if (OPJ_FSEEK(p_user_data,p_nb_bytes,SEEK_SET)) {
return EXIT_FAILURE;
}
return opj_stream_create_file_stream(p_file,J2K_STREAM_CHUNK_SIZE,p_is_read_stream);
}
-opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (FILE * p_file, OPJ_UINT32 p_size, opj_bool p_is_read_stream)
+opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (FILE * p_file, OPJ_SIZE_T p_size, opj_bool p_is_read_stream)
{
opj_stream_t* l_stream = 00;
/*
* FIXME DOC
*/
-typedef OPJ_UINT32 (* opj_stream_read_fn) (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data) ;
-typedef OPJ_UINT32 (* opj_stream_write_fn) (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data) ;
-typedef OPJ_SIZE_T (* opj_stream_skip_fn) (OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
-typedef opj_bool (* opj_stream_seek_fn) (OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
+typedef OPJ_SIZE_T (* opj_stream_read_fn) (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
+typedef OPJ_SIZE_T (* opj_stream_write_fn) (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
+typedef OPJ_OFF_T (* opj_stream_skip_fn) (OPJ_OFF_T p_nb_bytes, void * p_user_data) ;
+typedef opj_bool (* opj_stream_seek_fn) (OPJ_OFF_T p_nb_bytes, void * p_user_data) ;
/*
* JPEG2000 Stream.
* */
typedef struct opj_packet_info {
/** packet start position (including SOP marker if it exists) */
- int start_pos;
+ OPJ_OFF_T start_pos;
/** end of packet header position (including EPH marker if it exists)*/
- int end_ph_pos;
+ OPJ_OFF_T end_ph_pos;
/** packet end position */
- int end_pos;
+ OPJ_OFF_T end_pos;
/** packet distorsion */
double disto;
} opj_packet_info_t;
/** marker type */
unsigned short int type;
/** position in codestream */
- int pos;
+ OPJ_OFF_T pos;
/** length, marker val included */
int len;
} opj_marker_info_t;
*/
typedef struct opj_tp_index {
/** start position */
- OPJ_UINT32 start_pos;
+ OPJ_OFF_T start_pos;
/** end position of the header */
- OPJ_UINT32 end_header;
+ OPJ_OFF_T end_header;
/** end position */
- OPJ_UINT32 end_pos;
-
-
-
+ OPJ_OFF_T end_pos;
} opj_tp_index_t;
*/
typedef struct opj_codestream_index_ {
/** main header start position (SOC position) */
- OPJ_UINT32 main_head_start;
+ OPJ_OFF_T main_head_start;
/** main header end position (first SOT position) */
- OPJ_UINT32 main_head_end;
+ OPJ_OFF_T main_head_end;
/** codestream's size */
- OPJ_UINT32 codestream_size;
+ OPJ_UINT64 codestream_size;
/* UniPG>> */
/** number of markers */
* @return a stream object.
*/
OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_default_create(opj_bool p_is_input);
-OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_UINT32 p_size, opj_bool p_is_input);
+OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size, opj_bool p_is_input);
/**
* Destroys a stream created by opj_create_stream. This function does NOT close the abstract stream. If needed the user must
* @param p_stream the stream to modify
* @param data_length length of the user_data.
*/
-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);
/**
#endif
-#if defined(MSWINDOWS) && !defined(Windows95) && !defined(__BORLANDC__) && \
+#if defined(WIN32) && !defined(Windows95) && !defined(__BORLANDC__) && \
!(defined(_MSC_VER) && _MSC_VER < 1400) && \
!(defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x800)
/*
ADD_EXECUTABLE(compare_dump_files ${compare_dump_files_SRCS})
+ADD_EXECUTABLE(j2k_random_tile_access j2k_random_tile_access.c)
+TARGET_LINK_LIBRARIES(j2k_random_tile_access ${OPENJPEG_LIBRARY_NAME})
+
ADD_EXECUTABLE(compareRAWimages ${compareRAWimages_SRCS})
# No image send to the dashboard if lib PNG is not available.
--- /dev/null
+/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
+ * Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2006-2007, Parvatha Elangovan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "opj_config.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <strings.h>
+#define _stricmp strcasecmp
+#define _strnicmp strncasecmp
+#endif /* _WIN32 */
+
+#include "openjpeg.h"
+#include "format_defs.h"
+
+/* -------------------------------------------------------------------------- */
+int get_file_format(const char *filename) {
+ unsigned int i;
+ static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp","tif", "raw", "tga", "png", "j2k", "jp2", "jpt", "j2c", "jpc" };
+ static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, RAW_DFMT, TGA_DFMT, PNG_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT, J2K_CFMT, J2K_CFMT };
+ char * ext = strrchr(filename, '.');
+ if (ext == NULL)
+ return -1;
+ ext++;
+ if(ext) {
+ for(i = 0; i < sizeof(format)/sizeof(*format); i++) {
+ if(_strnicmp(ext, extension[i], 3) == 0) {
+ return format[i];
+ }
+ }
+ }
+
+ return -1;
+}
+
+/* -------------------------------------------------------------------------- */
+
+/**
+sample error callback expecting a FILE* client object
+*/
+void error_callback(const char *msg, void *client_data) {
+ FILE *stream = (FILE*)client_data;
+ fprintf(stream, "[ERROR] %s", msg);
+}
+/**
+sample warning callback expecting a FILE* client object
+*/
+void warning_callback(const char *msg, void *client_data) {
+ FILE *stream = (FILE*)client_data;
+ fprintf(stream, "[WARNING] %s", msg);
+}
+/**
+sample debug callback expecting no client object
+*/
+void info_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[INFO] %s", msg);
+}
+
+
+/* -------------------------------------------------------------------------- */
+#define JP2_RFC3745_MAGIC "\x00\x00\x00\x0c\x6a\x50\x20\x20\x0d\x0a\x87\x0a"
+#define JP2_MAGIC "\x0d\x0a\x87\x0a"
+/* position 45: "\xff\x52" */
+#define J2K_CODESTREAM_MAGIC "\xff\x4f\xff\x51"
+
+static int infile_format(const char *fname)
+{
+ FILE *reader;
+ const char *s, *magic_s;
+ int ext_format, magic_format;
+ unsigned char buf[12];
+ unsigned int l_nb_read;
+
+ reader = fopen(fname, "rb");
+
+ if (reader == NULL)
+ return -1;
+
+ memset(buf, 0, 12);
+ l_nb_read = fread(buf, 1, 12, reader);
+ fclose(reader);
+ if (l_nb_read != 12)
+ return -1;
+
+
+
+ ext_format = get_file_format(fname);
+
+ if (ext_format == JPT_CFMT)
+ return JPT_CFMT;
+
+ if (memcmp(buf, JP2_RFC3745_MAGIC, 12) == 0 || memcmp(buf, JP2_MAGIC, 4) == 0) {
+ magic_format = JP2_CFMT;
+ magic_s = ".jp2";
+ }
+ else if (memcmp(buf, J2K_CODESTREAM_MAGIC, 4) == 0) {
+ magic_format = J2K_CFMT;
+ magic_s = ".j2k or .jpc or .j2c";
+ }
+ else
+ return -1;
+
+ if (magic_format == ext_format)
+ return ext_format;
+
+ s = fname + strlen(fname) - 4;
+
+ fputs("\n===========================================\n", stderr);
+ fprintf(stderr, "The extension of this file is incorrect.\n"
+ "FOUND %s. SHOULD BE %s\n", s, magic_s);
+ fputs("===========================================\n", stderr);
+
+ return magic_format;
+}
+
+/* -------------------------------------------------------------------------- */
+/**
+ * J2K_RANDOM_TILE_ACCESS MAIN
+ */
+/* -------------------------------------------------------------------------- */
+int main(int argc, char **argv)
+{
+ FILE *fsrc = NULL;
+
+ opj_dparameters_t parameters; /* decompression parameters */
+ opj_event_mgr_t event_mgr; /* event manager */
+ opj_image_t* image = NULL;
+ opj_stream_t *cio = NULL; /* Stream */
+ opj_codec_t* dinfo = NULL; /* Handle to a decompressor */
+ opj_codestream_info_v2_t* cstr_info = NULL;
+
+ if (argc != 2) {
+ fprintf(stderr, "Usage: %s <input_file>\n", argv[0]);
+ return EXIT_FAILURE;
+ }
+
+ /* Set event mgr */
+ event_mgr.error_handler = error_callback;
+ event_mgr.warning_handler = warning_callback;
+ event_mgr.info_handler = info_callback;
+ opj_initialize_default_event_handler(&event_mgr, 1);
+
+ /* Set decoding parameters to default values */
+ opj_set_default_decoder_parameters(¶meters);
+
+ strncpy(parameters.infile, argv[1], OPJ_PATH_LEN - 1);
+
+ /* read the input file */
+ /* ------------------- */
+ fsrc = fopen(parameters.infile, "rb");
+ if (!fsrc) {
+ fprintf(stderr, "ERROR -> failed to open %s for reading\n", parameters.infile);
+ return EXIT_FAILURE;
+ }
+
+ /* decode the JPEG2000 stream */
+ /* -------------------------- */
+ parameters.decod_format = infile_format(parameters.infile);
+
+ switch(parameters.decod_format) {
+ case J2K_CFMT: /* JPEG-2000 codestream */
+ {
+ /* Get a decoder handle */
+ dinfo = opj_create_decompress_v2(CODEC_J2K);
+ break;
+ }
+ case JP2_CFMT: /* JPEG 2000 compressed image data */
+ {
+ /* Get a decoder handle */
+ dinfo = opj_create_decompress_v2(CODEC_JP2);
+ break;
+ }
+ case JPT_CFMT: /* JPEG 2000, JPIP */
+ {
+ /* Get a decoder handle */
+ dinfo = opj_create_decompress_v2(CODEC_JPT);
+ break;
+ }
+ default:
+ fprintf(stderr,
+ "Unrecognized format for input %s [accept only *.j2k, *.jp2, *.jpc or *.jpt]\n\n",
+ parameters.infile);
+ return EXIT_FAILURE;
+ }
+
+ cio = opj_stream_create_default_file_stream(fsrc,1);
+ if (!cio){
+ fclose(fsrc);
+ fprintf(stderr, "ERROR -> failed to create the stream from the file\n");
+ return EXIT_FAILURE;
+ }
+
+ /* Setup the decoder decoding parameters using user parameters */
+ if ( !opj_setup_decoder_v2(dinfo, ¶meters, &event_mgr) ){
+ fprintf(stderr, "ERROR -> j2k_dump: failed to setup the decoder\n");
+ opj_stream_destroy(cio);
+ fclose(fsrc);
+ opj_destroy_codec(dinfo);
+ return EXIT_FAILURE;
+ }
+
+ /* Read the main header of the codestream and if necessary the JP2 boxes*/
+ if(! opj_read_header(cio, dinfo, &image)){
+ fprintf(stderr, "ERROR -> j2k_to_image: failed to read the header\n");
+ opj_stream_destroy(cio);
+ fclose(fsrc);
+ opj_destroy_codec(dinfo);
+ opj_image_destroy(image);
+ return EXIT_FAILURE;
+ }
+
+ /* Extract some info from the code stream */
+ cstr_info = opj_get_cstr_info(dinfo);
+
+ fprintf(stdout, "The file contains %dx%d tiles\n", cstr_info->tw, cstr_info->th);
+
+ OPJ_UINT32 tile_ul = 0;
+ OPJ_UINT32 tile_ur = cstr_info->tw - 1;
+ OPJ_UINT32 tile_lr = cstr_info->tw * cstr_info->th - 1;
+ OPJ_UINT32 tile_ll = tile_lr - cstr_info->tw;
+
+#define TEST_TILE( tile_index ) \
+ fprintf(stdout, "Decoding tile %d ...\n", tile_index); \
+ if(!opj_get_decoded_tile(dinfo, cio, image, tile_index )){ \
+ fprintf(stderr, "ERROR -> j2k_to_image: failed to decode tile %d\n", tile_index); \
+ opj_stream_destroy(cio); \
+ opj_destroy_cstr_info_v2(cstr_info); \
+ opj_destroy_codec(dinfo); \
+ opj_image_destroy(image); \
+ fclose(fsrc); \
+ return EXIT_FAILURE; \
+ } \
+ fprintf(stdout, "Tile %d is decoded successfully\n", tile_index);
+
+ TEST_TILE(tile_ul)
+ TEST_TILE(tile_lr)
+ TEST_TILE(tile_ul)
+ TEST_TILE(tile_ll)
+ TEST_TILE(tile_ur)
+ TEST_TILE(tile_lr)
+
+ /* Close the byte stream */
+ opj_stream_destroy(cio);
+
+ /* Destroy code stream info */
+ opj_destroy_cstr_info_v2(cstr_info);
+
+ /* Free remaining structures */
+ opj_destroy_codec(dinfo);
+
+ /* Free image data structure */
+ opj_image_destroy(image);
+
+ /* Close the input file */
+ fclose(fsrc);
+
+ return EXIT_SUCCESS;
+}
+//end main
+
+
+
+
projects / openjpeg.git / commitdiff