/** @name Local static functions */
/*@{*/
-/**
-Read box headers
-@param cinfo Codec context info
-@param cio Input stream
-@param box
-@return Returns true if successful, returns false otherwise
-*/
-static opj_bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box);
+
/*static void jp2_write_url(opj_cio_t *cio, char *Idx_file);*/
-/**
-Read the IHDR box - Image Header box
-@param jp2 JP2 handle
-@param cio Input buffer stream
-@return Returns true if successful, returns false otherwise
-*/
-static opj_bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
/**
* Reads a IHDR box - Image Header box
* @param p_image_header_size the size of the image header
* @param p_manager the user event manager.
*
- * @return true if the image header is valid, fale else.
+ * @return true if the image header is valid, false else.
*/
-static opj_bool jp2_read_ihdr_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_image_header_data,
- unsigned int p_image_header_size,
- struct opj_event_mgr * p_manager
- );
+static opj_bool opj_jp2_read_ihdr( opj_jp2_v2_t *jp2,
+ OPJ_BYTE *p_image_header_data,
+ OPJ_UINT32 p_image_header_size,
+ opj_event_mgr_t * p_manager );
static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
static unsigned char * jp2_write_bpcc_v2( opj_jp2_v2_t *jp2,
unsigned int * p_nb_bytes_written );
-static opj_bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
-
/**
* Reads a Bit per Component box.
*
*
* @return true if the bpc header is valid, fale else.
*/
-static opj_bool jp2_read_bpcc_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_bpc_header_data,
- unsigned int p_bpc_header_size,
- struct opj_event_mgr * p_manager
- );
+static opj_bool opj_jp2_read_bpcc( opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_bpc_header_data,
+ OPJ_UINT32 p_bpc_header_size,
+ opj_event_mgr_t * p_manager );
-static opj_bool jp2_read_cdef_v2( opj_jp2_v2_t * jp2,
- unsigned char * p_cdef_header_data,
+static opj_bool opj_jp2_read_cdef( opj_jp2_v2_t * jp2,
+ OPJ_BYTE * p_cdef_header_data,
OPJ_UINT32 p_cdef_header_size,
- opj_event_mgr_t * p_manager
- );
+ opj_event_mgr_t * p_manager );
static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio);
-/**
-Write the FTYP box - File type box
-@param jp2 JP2 handle
-@param cio Output buffer stream
-*/
-
/**
* Writes the Colour Specification box.
*
static unsigned char *jp2_write_colr_v2(opj_jp2_v2_t *jp2,
unsigned int * p_nb_bytes_written );
-static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
/**
-Read the FTYP box - File type box
+Write the FTYP box - File type box
@param jp2 JP2 handle
-@param cio Input buffer stream
-@return Returns true if successful, returns false otherwise
+@param cio Output buffer stream
*/
-static opj_bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
+static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
+
/**
* Writes a FTYP box - File type box
*
* @return true if the FTYP box is valid.
*/
-static opj_bool jp2_read_ftyp_v2( opj_jp2_v2_t *jp2,
- unsigned char * p_header_data,
+static opj_bool opj_jp2_read_ftyp( opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
- struct opj_event_mgr * p_manager );
+ opj_event_mgr_t * p_manager );
/**
* Skips the Jpeg2000 Codestream Header box - JP2C Header box.
*
* @return true if the JP2 Header box was successfully reconized.
*/
-static opj_bool jp2_read_jp2h_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_header_data,
- unsigned int p_header_size,
- struct opj_event_mgr * p_manager
- );
+static opj_bool opj_jp2_read_jp2h( opj_jp2_v2_t *jp2,
+ OPJ_BYTE *p_header_data,
+ OPJ_UINT32 p_header_size,
+ opj_event_mgr_t * p_manager );
static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
struct opj_stream_private *cio,
struct opj_event_mgr * p_manager );
-static opj_bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset);
static void jp2_write_jp(opj_cio_t *cio);
-/**
-Read the JP box - JPEG 2000 signature
-@param jp2 JP2 handle
-@param cio Input buffer stream
-@return Returns true if successful, returns false otherwise
-*/
-static opj_bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio);
/**
* Reads a jpeg2000 file signature box.
*
* @return true if the file signature box is valid.
*/
-static opj_bool jp2_read_jp_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_header_data,
- unsigned int p_header_size,
- struct opj_event_mgr * p_manager
- );
+static opj_bool opj_jp2_read_jp(opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ opj_event_mgr_t * p_manager);
/**
-Decode the structure of a JP2 file
-@param jp2 JP2 handle
-@param cio Input buffer stream
-@param color Collector for profile, cdef and pclr data
-@return Returns true if successful, returns false otherwise
-*/
-static opj_bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_color_t *color);
-/**
Apply collected palette data
@param color Collector for profile, cdef and pclr data
@param image
@param color Collector for profile, cdef and pclr data
@return Returns true if successful, returns false otherwise
*/
-static opj_bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_box_t *box, opj_jp2_color_t *color);
-
-static opj_bool jp2_read_pclr_v2( opj_jp2_v2_t *jp2,
- unsigned char * p_pclr_header_data,
- OPJ_UINT32 p_pclr_header_size,
- opj_event_mgr_t * p_manager
- );
+static opj_bool opj_jp2_read_pclr( opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_pclr_header_data,
+ OPJ_UINT32 p_pclr_header_size,
+ opj_event_mgr_t * p_manager );
/**
Collect component mapping data
@param color Collector for profile, cdef and pclr data
@return Returns true if successful, returns false otherwise
*/
-static opj_bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_box_t *box, opj_jp2_color_t *color);
-
-static opj_bool jp2_read_cmap_v2( opj_jp2_v2_t * jp2,
- unsigned char * p_cmap_header_data,
- OPJ_UINT32 p_cmap_header_size,
- opj_event_mgr_t * p_manager
- );
-
-/**
-Collect colour specification data
-@param jp2 JP2 handle
-@param cio Input buffer stream
-@param box
-@param color Collector for profile, cdef and pclr data
-@return Returns true if successful, returns false otherwise
-*/
-static opj_bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_box_t *box, opj_jp2_color_t *color);
+static opj_bool opj_jp2_read_cmap( opj_jp2_v2_t * jp2,
+ OPJ_BYTE * p_cmap_header_data,
+ OPJ_UINT32 p_cmap_header_size,
+ opj_event_mgr_t * p_manager );
/**
* Reads the Color Specification box.
*
* @return true if the bpc header is valid, fale else.
*/
-static opj_bool jp2_read_colr_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_colr_header_data,
- OPJ_UINT32 p_colr_header_size,
- struct opj_event_mgr * p_manager
- );
+static opj_bool opj_jp2_read_colr( opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_colr_header_data,
+ OPJ_UINT32 p_colr_header_size,
+ opj_event_mgr_t * p_manager );
/**
Write file Index (superbox)
* Sets up the procedures to do on reading header after the codestream.
* Developpers wanting to extend the library can add their own writting procedures.
*/
-static void jp2_setup_end_header_reading (opj_jp2_v2_t *jp2);
+static void opj_jp2_setup_end_header_reading (opj_jp2_v2_t *jp2);
/**
* Reads a jpeg2000 file header structure.
*
* @return true if the box is valid.
*/
-opj_bool jp2_read_header_procedure(
- opj_jp2_v2_t *jp2,
- struct opj_stream_private *cio,
- struct opj_event_mgr * p_manager
- );
+static opj_bool opj_jp2_read_header_procedure( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *stream,
+ opj_event_mgr_t * p_manager );
/**
* Excutes the given procedures on the given codec.
*
* @param p_procedure_list the list of procedures to execute
* @param jp2 the jpeg2000 file codec to execute the procedures on.
- * @param cio the stream to execute the procedures on.
+ * @param stream the stream to execute the procedures on.
* @param p_manager the user manager.
*
* @return true if all the procedures were successfully executed.
*/
-static opj_bool jp2_exec (
- opj_jp2_v2_t * jp2,
- struct opj_procedure_list * p_procedure_list,
- struct opj_stream_private *cio,
- struct opj_event_mgr * p_manager
- );
+static opj_bool opj_jp2_exec ( opj_jp2_v2_t * jp2,
+ opj_procedure_list_t * p_procedure_list,
+ opj_stream_private_t *stream,
+ opj_event_mgr_t * p_manager );
/**
* Reads a box header. The box is the way data is packed inside a jpeg2000 file structure.
*
* @return true if the box is reconized, false otherwise
*/
-static opj_bool jp2_read_boxhdr_v2(
- opj_jp2_box_t *box,
- OPJ_UINT32 * p_number_bytes_read,
- struct opj_stream_private *cio,
- struct opj_event_mgr * p_manager
- );
-
-/**
- * Finds the execution function related to the given box id.
- *
- * @param p_id the id of the handler to fetch.
- *
- * @return the given handler or NULL if it could not be found.
- */
-static const opj_jp2_header_handler_t * jp2_find_handler (int p_id );
+static opj_bool opj_jp2_read_boxhdr(opj_jp2_box_t *box,
+ OPJ_UINT32 * p_number_bytes_read,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager);
/**
* Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
*
* @return true if the parameters are correct.
*/
-opj_bool jp2_default_validation ( opj_jp2_v2_t * jp2,
- struct opj_stream_private *cio,
- struct opj_event_mgr * p_manager );
+opj_bool opj_jp2_default_validation ( opj_jp2_v2_t * jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager );
/**
* Finds the image execution function related to the given box id.
*
* @return the given handler or NULL if it could not be found.
*/
-static const opj_jp2_header_handler_t * jp2_img_find_handler (int p_id);
+static const opj_jp2_header_handler_t * opj_jp2_img_find_handler (OPJ_UINT32 p_id);
+
+/**
+ * Finds the execution function related to the given box id.
+ *
+ * @param p_id the id of the handler to fetch.
+ *
+ * @return the given handler or NULL if it could not be found.
+ */
+static const opj_jp2_header_handler_t * opj_jp2_find_handler (OPJ_UINT32 p_id );
const opj_jp2_header_handler_t jp2_header [] =
{
- {JP2_JP,jp2_read_jp_v2},
- {JP2_FTYP,jp2_read_ftyp_v2},
- {JP2_JP2H,jp2_read_jp2h_v2}
+ {JP2_JP,opj_jp2_read_jp},
+ {JP2_FTYP,opj_jp2_read_ftyp},
+ {JP2_JP2H,opj_jp2_read_jp2h}
};
const opj_jp2_header_handler_t jp2_img_header [] =
{
- {JP2_IHDR,jp2_read_ihdr_v2},
- {JP2_COLR,jp2_read_colr_v2},
- {JP2_BPCC,jp2_read_bpcc_v2},
- {JP2_PCLR,jp2_read_pclr_v2},
- {JP2_CMAP,jp2_read_cmap_v2},
- {JP2_CDEF,jp2_read_cdef_v2}
+ {JP2_IHDR,opj_jp2_read_ihdr},
+ {JP2_COLR,opj_jp2_read_colr},
+ {JP2_BPCC,opj_jp2_read_bpcc},
+ {JP2_PCLR,opj_jp2_read_pclr},
+ {JP2_CMAP,opj_jp2_read_cmap},
+ {JP2_CDEF,opj_jp2_read_cdef}
};
*
* @return true if the box is reconized, false otherwise
*/
-static opj_bool jp2_read_boxhdr_char(
- opj_jp2_box_t *box,
- OPJ_BYTE * p_data,
- OPJ_UINT32 * p_number_bytes_read,
- OPJ_UINT32 p_box_max_size,
- struct opj_event_mgr * p_manager
- );
+static opj_bool opj_jp2_read_boxhdr_char( opj_jp2_box_t *box,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_number_bytes_read,
+ OPJ_UINT32 p_box_max_size,
+ opj_event_mgr_t * p_manager );
/**
* Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
* are valid. Developpers wanting to extend the library can add their own validation procedures.
*/
-static void jp2_setup_decoding_validation (opj_jp2_v2_t *jp2);
+static void opj_jp2_setup_decoding_validation (opj_jp2_v2_t *jp2);
/**
* Sets up the procedures to do on reading header.
* Developpers wanting to extend the library can add their own writting procedures.
*/
-static void jp2_setup_header_reading (opj_jp2_v2_t *jp2);
+static void opj_jp2_setup_header_reading (opj_jp2_v2_t *jp2);
/* ----------------------------------------------------------------------- */
-static opj_bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box) {
- box->init_pos = cio_tell(cio);
- box->length = cio_read(cio, 4);
- box->type = cio_read(cio, 4);
- if (box->length == 1) {
- if (cio_read(cio, 4) != 0) {
- opj_event_msg(cinfo, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
- return OPJ_FALSE;
- }
- box->length = cio_read(cio, 4);
- if (box->length == 0)
- box->length = cio_numbytesleft(cio) + 12;
- }
- else if (box->length == 0) {
- box->length = cio_numbytesleft(cio) + 8;
- }
-
- return OPJ_TRUE;
-}
-
/**
* Reads a box header. The box is the way data is packed inside a jpeg2000 file structure.
*
*
* @return true if the box is reconized, false otherwise
*/
-opj_bool jp2_read_boxhdr_v2(opj_jp2_box_t *box, OPJ_UINT32 * p_number_bytes_read, opj_stream_private_t *cio, opj_event_mgr_t * p_manager)
+ opj_bool opj_jp2_read_boxhdr(opj_jp2_box_t *box,
+ OPJ_UINT32 * p_number_bytes_read,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
{
/* read header from file */
unsigned char l_data_header [8];
}
#endif
-static opj_bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
- opj_jp2_box_t box;
-
- opj_common_ptr cinfo = jp2->cinfo;
-
- jp2_read_boxhdr(cinfo, cio, &box);
- if (JP2_IHDR != box.type) {
- opj_event_msg(cinfo, EVT_ERROR, "Expected IHDR Marker\n");
- return OPJ_FALSE;
- }
-
- jp2->h = cio_read(cio, 4); /* HEIGHT */
- jp2->w = cio_read(cio, 4); /* WIDTH */
- jp2->numcomps = cio_read(cio, 2); /* NC */
- jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
-
- jp2->bpc = cio_read(cio, 1); /* BPC */
-
- jp2->C = cio_read(cio, 1); /* C */
- jp2->UnkC = cio_read(cio, 1); /* UnkC */
- jp2->IPR = cio_read(cio, 1); /* IPR */
-
- if (cio_tell(cio) - box.init_pos != box.length) {
- opj_event_msg(cinfo, EVT_ERROR, "Error with IHDR Box\n");
- return OPJ_FALSE;
- }
-
- return OPJ_TRUE;
-}
/**
* Reads a IHDR box - Image Header box
*
* @return true if the image header is valid, fale else.
*/
-opj_bool jp2_read_ihdr_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_image_header_data,
- unsigned int p_image_header_size,
- opj_event_mgr_t * p_manager
- )
+opj_bool opj_jp2_read_ihdr( opj_jp2_v2_t *jp2,
+ OPJ_BYTE *p_image_header_data,
+ OPJ_UINT32 p_image_header_size,
+ opj_event_mgr_t * p_manager )
{
/* preconditions */
assert(p_image_header_data != 00);
p_image_header_data += 4;
opj_read_bytes(p_image_header_data,&(jp2->w),4); /* WIDTH */
p_image_header_data += 4;
- opj_read_bytes(p_image_header_data,&(jp2->numcomps),2); /* NC */
+ opj_read_bytes(p_image_header_data,&(jp2->numcomps),2); /* NC */
p_image_header_data += 2;
/* allocate memory for components */
}
-
-static opj_bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
- unsigned int i;
- opj_jp2_box_t box;
-
- opj_common_ptr cinfo = jp2->cinfo;
-
- jp2_read_boxhdr(cinfo, cio, &box);
- if (JP2_BPCC != box.type) {
- opj_event_msg(cinfo, EVT_ERROR, "Expected BPCC Marker\n");
- return OPJ_FALSE;
- }
-
- for (i = 0; i < jp2->numcomps; i++) {
- jp2->comps[i].bpcc = cio_read(cio, 1);
- }
-
- if (cio_tell(cio) - box.init_pos != box.length) {
- opj_event_msg(cinfo, EVT_ERROR, "Error with BPCC Box\n");
- return OPJ_FALSE;
- }
-
- return OPJ_TRUE;
-}
-
/**
* Reads a Bit per Component box.
*
*
* @return true if the bpc header is valid, false otherwise.
*/
-opj_bool jp2_read_bpcc_v2( opj_jp2_v2_t *jp2,
- unsigned char * p_bpc_header_data,
- unsigned int p_bpc_header_size,
- opj_event_mgr_t * p_manager
- )
+opj_bool opj_jp2_read_bpcc( opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_bpc_header_data,
+ OPJ_UINT32 p_bpc_header_size,
+ opj_event_mgr_t * p_manager
+ )
{
OPJ_UINT32 i;
}/* apply_pclr() */
-
-static opj_bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_box_t *box, opj_jp2_color_t *color)
-{
- opj_jp2_pclr_t *jp2_pclr;
- unsigned char *channel_size, *channel_sign;
- unsigned int *entries;
- unsigned short nr_entries, nr_channels;
- unsigned short i, j;
- unsigned char uc;
-
- OPJ_ARG_NOT_USED(box);
- OPJ_ARG_NOT_USED(jp2);
-
-/* Part 1, I.5.3.4: 'There shall be at most one Palette box inside
- * a JP2 Header box' :
-*/
- if(color->jp2_pclr) return OPJ_FALSE;
-
- nr_entries = (unsigned short)cio_read(cio, 2); /* NE */
- nr_channels = (unsigned short)cio_read(cio, 1);/* NPC */
-
- entries = (unsigned int*)
- opj_malloc(nr_channels * nr_entries * sizeof(unsigned int));
- channel_size = (unsigned char*)opj_malloc(nr_channels);
- channel_sign = (unsigned char*)opj_malloc(nr_channels);
-
- jp2_pclr = (opj_jp2_pclr_t*)opj_malloc(sizeof(opj_jp2_pclr_t));
- jp2_pclr->channel_sign = channel_sign;
- jp2_pclr->channel_size = channel_size;
- jp2_pclr->entries = entries;
- jp2_pclr->nr_entries = nr_entries;
- jp2_pclr->nr_channels = nr_channels;
- jp2_pclr->cmap = NULL;
-
- color->jp2_pclr = jp2_pclr;
-
- for(i = 0; i < nr_channels; ++i)
- {
- uc = cio_read(cio, 1); /* Bi */
- channel_size[i] = (uc & 0x7f) + 1;
- channel_sign[i] = (uc & 0x80)?1:0;
- }
-
- for(j = 0; j < nr_entries; ++j)
- {
- for(i = 0; i < nr_channels; ++i)
- {
-/* Cji */
- *entries++ = cio_read(cio, (channel_size[i]+7)>>3);
- }
- }
-
- return OPJ_TRUE;
-}/* jp2_read_pclr() */
-
/**
* Reads a palette box.
*
*
* @return true if the bpc header is valid, fale else.
*/
-opj_bool jp2_read_pclr_v2( opj_jp2_v2_t *jp2,
- unsigned char * p_pclr_header_data,
- OPJ_UINT32 p_pclr_header_size,
- opj_event_mgr_t * p_manager
- ){
+opj_bool opj_jp2_read_pclr( opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_pclr_header_data,
+ OPJ_UINT32 p_pclr_header_size,
+ opj_event_mgr_t * p_manager
+ )
+{
opj_jp2_pclr_t *jp2_pclr;
OPJ_BYTE *channel_size, *channel_sign;
OPJ_UINT32 *entries;
return OPJ_TRUE;
}
-
-static opj_bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_box_t *box, opj_jp2_color_t *color)
-{
- opj_jp2_cmap_comp_t *cmap;
- unsigned short i, nr_channels;
-
- OPJ_ARG_NOT_USED(box);
- OPJ_ARG_NOT_USED(jp2);
-
-/* Need nr_channels: */
- if(color->jp2_pclr == NULL) return OPJ_FALSE;
-
-/* Part 1, I.5.3.5: 'There shall be at most one Component Mapping box
- * inside a JP2 Header box' :
-*/
- if(color->jp2_pclr->cmap) return OPJ_FALSE;
-
- nr_channels = color->jp2_pclr->nr_channels;
- cmap = (opj_jp2_cmap_comp_t*)
- opj_malloc(nr_channels * sizeof(opj_jp2_cmap_comp_t));
-
- for(i = 0; i < nr_channels; ++i)
- {
- cmap[i].cmp = (unsigned short)cio_read(cio, 2);
- cmap[i].mtyp = cio_read(cio, 1);
- cmap[i].pcol = cio_read(cio, 1);
-
- }
- color->jp2_pclr->cmap = cmap;
-
- return OPJ_TRUE;
-
-}/* jp2_read_cmap() */
-
/**
* Reads the Component Mapping box.
*
*
* @return true if the cdef header is valid, false else.
*/
-static opj_bool jp2_read_cmap_v2( opj_jp2_v2_t * jp2,
- unsigned char * p_cmap_header_data,
- OPJ_UINT32 p_cmap_header_size,
- opj_event_mgr_t * p_manager
- )
+opj_bool opj_jp2_read_cmap( opj_jp2_v2_t * jp2,
+ OPJ_BYTE * p_cmap_header_data,
+ OPJ_UINT32 p_cmap_header_size,
+ opj_event_mgr_t * p_manager
+ )
{
opj_jp2_cmap_comp_t *cmap;
OPJ_BYTE i, nr_channels;
}/* jp2_apply_cdef() */
-static opj_bool jp2_read_cdef(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_box_t *box, opj_jp2_color_t *color)
-{
- opj_jp2_cdef_info_t *info;
- unsigned short i, n;
-
- OPJ_ARG_NOT_USED(box);
- OPJ_ARG_NOT_USED(jp2);
-
-/* Part 1, I.5.3.6: 'The shall be at most one Channel Definition box
- * inside a JP2 Header box.'
-*/
- if(color->jp2_cdef) return OPJ_FALSE;
-
- if((n = (unsigned short)cio_read(cio, 2)) == 0) return OPJ_FALSE; /* szukw000: FIXME */
-
- info = (opj_jp2_cdef_info_t*)
- opj_malloc(n * sizeof(opj_jp2_cdef_info_t));
-
- color->jp2_cdef = (opj_jp2_cdef_t*)opj_malloc(sizeof(opj_jp2_cdef_t));
- color->jp2_cdef->info = info;
- color->jp2_cdef->n = n;
-
- for(i = 0; i < n; ++i)
- {
- info[i].cn = (unsigned short)cio_read(cio, 2);
- info[i].typ = (unsigned short)cio_read(cio, 2);
- info[i].asoc = (unsigned short)cio_read(cio, 2);
-
- }
- return OPJ_TRUE;
-}/* jp2_read_cdef() */
-
/**
* Reads the Component Definition box.
*
*
* @return true if the cdef header is valid, false else.
*/
-static opj_bool jp2_read_cdef_v2( opj_jp2_v2_t * jp2,
- unsigned char * p_cdef_header_data,
+opj_bool opj_jp2_read_cdef( opj_jp2_v2_t * jp2,
+ OPJ_BYTE * p_cdef_header_data,
OPJ_UINT32 p_cdef_header_size,
- opj_event_mgr_t * p_manager
- )
+ opj_event_mgr_t * p_manager
+ )
{
opj_jp2_cdef_info_t *cdef_info;
unsigned short i;
return OPJ_TRUE;
}
-
-static opj_bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_box_t *box, opj_jp2_color_t *color)
-{
- int skip_len;
- opj_common_ptr cinfo;
-
-/* Part 1, I.5.3.3 : 'A conforming JP2 reader shall ignore all Colour
- * Specification boxes after the first.'
-*/
- if(color->jp2_has_colr) return OPJ_FALSE;
-
- cinfo = jp2->cinfo;
-
- jp2->meth = cio_read(cio, 1); /* METH */
- jp2->precedence = cio_read(cio, 1); /* PRECEDENCE */
- jp2->approx = cio_read(cio, 1); /* APPROX */
-
- if (jp2->meth == 1)
- {
- jp2->enumcs = cio_read(cio, 4); /* EnumCS */
- }
- else
- if (jp2->meth == 2)
- {
-/* skip PROFILE */
- skip_len = box->init_pos + box->length - cio_tell(cio);
- if (skip_len < 0)
- {
- opj_event_msg(cinfo, EVT_ERROR, "Error with COLR box size\n");
- return OPJ_FALSE;
- }
- if(skip_len > 0)
- {
- unsigned char *start;
-
- start = cio_getbp(cio);
- color->icc_profile_buf = (unsigned char*)opj_malloc(skip_len);
- color->icc_profile_len = skip_len;
-
- cio_skip(cio, box->init_pos + box->length - cio_tell(cio));
-
- memcpy(color->icc_profile_buf, start, skip_len);
- }
- }
-
- if (cio_tell(cio) - box->init_pos != box->length)
- {
- opj_event_msg(cinfo, EVT_ERROR, "Error with COLR Box\n");
- return OPJ_FALSE;
- }
- color->jp2_has_colr = 1;
-
- return OPJ_TRUE;
-}/* jp2_read_colr() */
-
/**
* Reads the Colour Specification box.
*
*
* @return true if the bpc header is valid, fale else.
*/
-static opj_bool jp2_read_colr_v2( opj_jp2_v2_t * jp2,
- unsigned char * p_colr_header_data,
- OPJ_UINT32 p_colr_header_size,
- opj_event_mgr_t * p_manager
- )
+opj_bool opj_jp2_read_colr( opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_colr_header_data,
+ OPJ_UINT32 p_colr_header_size,
+ opj_event_mgr_t * p_manager
+ )
{
OPJ_UINT32 l_value;
return OPJ_TRUE;
}
-opj_bool jp2_read_jp2h(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_color_t *color)
-{
- opj_jp2_box_t box;
- int jp2h_end;
-
- opj_common_ptr cinfo = jp2->cinfo;
-
- jp2_read_boxhdr(cinfo, cio, &box);
- do
- {
- if (JP2_JP2H != box.type)
- {
- if (box.type == JP2_JP2C)
- {
- opj_event_msg(cinfo, EVT_ERROR, "Expected JP2H Marker\n");
- return OPJ_FALSE;
- }
- cio_skip(cio, box.length - 8);
-
- if(cio->bp >= cio->end) return OPJ_FALSE;
-
- jp2_read_boxhdr(cinfo, cio, &box);
- }
- } while(JP2_JP2H != box.type);
-
- if (!jp2_read_ihdr(jp2, cio))
- return OPJ_FALSE;
- jp2h_end = box.init_pos + box.length;
-
- if (jp2->bpc == 255)
- {
- if (!jp2_read_bpcc(jp2, cio))
- return OPJ_FALSE;
- }
- jp2_read_boxhdr(cinfo, cio, &box);
-
- while(cio_tell(cio) < jp2h_end)
- {
- if(box.type == JP2_COLR)
- {
- if( !jp2_read_colr(jp2, cio, &box, color))
- {
- cio_seek(cio, box.init_pos + 8);
- cio_skip(cio, box.length - 8);
- }
- jp2_read_boxhdr(cinfo, cio, &box);
- continue;
- }
- if(box.type == JP2_CDEF && !jp2->ignore_pclr_cmap_cdef)
- {
- if( !jp2_read_cdef(jp2, cio, &box, color))
- {
- cio_seek(cio, box.init_pos + 8);
- cio_skip(cio, box.length - 8);
- }
- jp2_read_boxhdr(cinfo, cio, &box);
- continue;
- }
- if(box.type == JP2_PCLR && !jp2->ignore_pclr_cmap_cdef)
- {
- if( !jp2_read_pclr(jp2, cio, &box, color))
- {
- cio_seek(cio, box.init_pos + 8);
- cio_skip(cio, box.length - 8);
- }
- jp2_read_boxhdr(cinfo, cio, &box);
- continue;
- }
- if(box.type == JP2_CMAP && !jp2->ignore_pclr_cmap_cdef)
- {
- if( !jp2_read_cmap(jp2, cio, &box, color))
- {
- cio_seek(cio, box.init_pos + 8);
- cio_skip(cio, box.length - 8);
- }
- jp2_read_boxhdr(cinfo, cio, &box);
- continue;
- }
- cio_seek(cio, box.init_pos + 8);
- cio_skip(cio, box.length - 8);
- jp2_read_boxhdr(cinfo, cio, &box);
-
- }/* while(cio_tell(cio) < box_end) */
-
- cio_seek(cio, jp2h_end);
-
-/* Part 1, I.5.3.3 : 'must contain at least one' */
- return (color->jp2_has_colr == 1);
-
-}/* jp2_read_jp2h() */
-
-opj_image_t* opj_jp2_decode(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_codestream_info_t *cstr_info)
-{
- opj_common_ptr cinfo;
- opj_image_t *image = NULL;
- opj_jp2_color_t color;
-
- if(!jp2 || !cio)
- {
- return NULL;
- }
- memset(&color, 0, sizeof(opj_jp2_color_t));
- cinfo = jp2->cinfo;
-
-/* JP2 decoding */
- if(!jp2_read_struct(jp2, cio, &color))
- {
- free_color_data(&color);
- opj_event_msg(cinfo, EVT_ERROR, "Failed to decode jp2 structure\n");
- return NULL;
- }
-
-/* J2K decoding */
- image = j2k_decode(jp2->j2k, cio, cstr_info);
-
- if(!image)
- {
- free_color_data(&color);
- opj_event_msg(cinfo, EVT_ERROR, "Failed to decode J2K image\n");
- return NULL;
- }
-
- if (!jp2->ignore_pclr_cmap_cdef){
-
- /* Set Image Color Space */
- if (jp2->enumcs == 16)
- image->color_space = CLRSPC_SRGB;
- else if (jp2->enumcs == 17)
- image->color_space = CLRSPC_GRAY;
- else if (jp2->enumcs == 18)
- image->color_space = CLRSPC_SYCC;
- else
- image->color_space = CLRSPC_UNKNOWN;
-
- if(color.jp2_cdef)
- {
- jp2_apply_cdef(image, &color);
- }
- if(color.jp2_pclr)
- {
-/* Part 1, I.5.3.4: Either both or none : */
- if( !color.jp2_pclr->cmap)
- jp2_free_pclr(&color);
- else
- jp2_apply_pclr(image, &color);
- }
- if(color.icc_profile_buf)
- {
- image->icc_profile_buf = color.icc_profile_buf;
- color.icc_profile_buf = NULL;
- image->icc_profile_len = color.icc_profile_len;
- }
- }
-
- return image;
-
-}/* opj_jp2_decode() */
-opj_bool jp2_decode_v2( opj_jp2_v2_t *jp2,
- struct opj_stream_private *cio,
- opj_image_t* p_image,
- struct opj_event_mgr * p_manager)
+opj_bool opj_jp2_decode(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *p_stream,
+ opj_image_t* p_image,
+ opj_event_mgr_t * p_manager)
{
if (!p_image)
return OPJ_FALSE;
/* J2K decoding */
- if( ! j2k_decode_v2(jp2->j2k, cio, p_image, p_manager) ) {
+ if( ! opj_j2k_decode(jp2->j2k, p_stream, p_image, p_manager) ) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to decode the codestream in the JP2 file\n");
return OPJ_FALSE;
}
+
+ if (!jp2->ignore_pclr_cmap_cdef){
- /* Set Image Color Space */
- if (jp2->enumcs == 16)
- p_image->color_space = CLRSPC_SRGB;
- else if (jp2->enumcs == 17)
- p_image->color_space = CLRSPC_GRAY;
- else if (jp2->enumcs == 18)
- p_image->color_space = CLRSPC_SYCC;
- else
- p_image->color_space = CLRSPC_UNKNOWN;
-
- /* Apply the color space if needed */
- if(jp2->color.jp2_cdef) {
- jp2_apply_cdef(p_image, &(jp2->color));
- }
-
- if(jp2->color.jp2_pclr) {
- /* Part 1, I.5.3.4: Either both or none : */
- if( !jp2->color.jp2_pclr->cmap)
- jp2_free_pclr(&(jp2->color));
- else
- jp2_apply_pclr(p_image, &(jp2->color));
- }
-
- if(jp2->color.icc_profile_buf) {
- p_image->icc_profile_buf = jp2->color.icc_profile_buf;
- p_image->icc_profile_len = jp2->color.icc_profile_len;
- jp2->color.icc_profile_buf = NULL;
- }
+ /* Set Image Color Space */
+ if (jp2->enumcs == 16)
+ p_image->color_space = CLRSPC_SRGB;
+ else if (jp2->enumcs == 17)
+ p_image->color_space = CLRSPC_GRAY;
+ else if (jp2->enumcs == 18)
+ p_image->color_space = CLRSPC_SYCC;
+ else
+ p_image->color_space = CLRSPC_UNKNOWN;
+
+ /* Apply the color space if needed */
+ if(jp2->color.jp2_cdef) {
+ jp2_apply_cdef(p_image, &(jp2->color));
+ }
+
+ if(jp2->color.jp2_pclr) {
+ /* Part 1, I.5.3.4: Either both or none : */
+ if( !jp2->color.jp2_pclr->cmap)
+ jp2_free_pclr(&(jp2->color));
+ else
+ jp2_apply_pclr(p_image, &(jp2->color));
+ }
+
+ if(jp2->color.icc_profile_buf) {
+ p_image->icc_profile_buf = jp2->color.icc_profile_buf;
+ p_image->icc_profile_len = jp2->color.icc_profile_len;
+ jp2->color.icc_profile_buf = NULL;
+ }
+ }
return OPJ_TRUE;
}
return l_result;
}
-static opj_bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
- int i;
- opj_jp2_box_t box;
-
- opj_common_ptr cinfo = jp2->cinfo;
-
- jp2_read_boxhdr(cinfo, cio, &box);
-
- if (JP2_FTYP != box.type) {
- opj_event_msg(cinfo, EVT_ERROR, "Expected FTYP Marker\n");
- return OPJ_FALSE;
- }
-
- jp2->brand = cio_read(cio, 4); /* BR */
- jp2->minversion = cio_read(cio, 4); /* MinV */
- jp2->numcl = (box.length - 16) / 4;
- jp2->cl = (unsigned int *) opj_malloc(jp2->numcl * sizeof(unsigned int));
-
- for (i = 0; i < (int)jp2->numcl; i++) {
- jp2->cl[i] = cio_read(cio, 4); /* CLi */
- }
-
- if (cio_tell(cio) - box.init_pos != box.length) {
- opj_event_msg(cinfo, EVT_ERROR, "Error with FTYP Box\n");
- return OPJ_FALSE;
- }
-
- return OPJ_TRUE;
-}
-
static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
unsigned int j2k_codestream_offset, j2k_codestream_length;
opj_jp2_box_t box;
return OPJ_TRUE;
}
-static opj_bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset) {
- opj_jp2_box_t box;
-
- opj_common_ptr cinfo = jp2->cinfo;
-
- jp2_read_boxhdr(cinfo, cio, &box);
- do {
- if(JP2_JP2C != box.type) {
- cio_skip(cio, box.length - 8);
- jp2_read_boxhdr(cinfo, cio, &box);
- }
- } while(JP2_JP2C != box.type);
-
- *j2k_codestream_offset = cio_tell(cio);
- *j2k_codestream_length = box.length - 8;
-
- return OPJ_TRUE;
-}
-
static void jp2_write_jp(opj_cio_t *cio) {
opj_jp2_box_t box;
return OPJ_TRUE;
}
-static opj_bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio) {
- opj_jp2_box_t box;
-
- opj_common_ptr cinfo = jp2->cinfo;
-
- jp2_read_boxhdr(cinfo, cio, &box);
- if (JP2_JP != box.type) {
- opj_event_msg(cinfo, EVT_ERROR, "Expected JP Marker\n");
- return OPJ_FALSE;
- }
- if (0x0d0a870a != cio_read(cio, 4)) {
- opj_event_msg(cinfo, EVT_ERROR, "Error with JP Marker\n");
- return OPJ_FALSE;
- }
- if (cio_tell(cio) - box.init_pos != box.length) {
- opj_event_msg(cinfo, EVT_ERROR, "Error with JP Box size\n");
- return OPJ_FALSE;
- }
-
- return OPJ_TRUE;
-}
-
-
-static opj_bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio,
- opj_jp2_color_t *color) {
- if (!jp2_read_jp(jp2, cio))
- return OPJ_FALSE;
- if (!jp2_read_ftyp(jp2, cio))
- return OPJ_FALSE;
- if (!jp2_read_jp2h(jp2, cio, color))
- return OPJ_FALSE;
- if (!jp2_read_jp2c(jp2, cio, &jp2->j2k_codestream_length, &jp2->j2k_codestream_offset))
- return OPJ_FALSE;
-
- return OPJ_TRUE;
-}
-
-
static int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
{
int len, lenp;
/* JP2 decoder interface */
/* ----------------------------------------------------------------------- */
-opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo) {
- opj_jp2_t *jp2 = (opj_jp2_t*) opj_calloc(1, sizeof(opj_jp2_t));
- if(jp2) {
- jp2->cinfo = cinfo;
- /* create the J2K codec */
- jp2->j2k = j2k_create_decompress(cinfo);
- if(jp2->j2k == NULL) {
- jp2_destroy_decompress(jp2);
- return NULL;
- }
- }
- return jp2;
-}
-
-void jp2_destroy_decompress(opj_jp2_t *jp2) {
- if(jp2) {
- /* destroy the J2K codec */
- j2k_destroy_decompress(jp2->j2k);
-
- if(jp2->comps) {
- opj_free(jp2->comps);
- }
- if(jp2->cl) {
- opj_free(jp2->cl);
- }
- opj_free(jp2);
- }
-}
-
-void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters) {
- /* setup the J2K codec */
- j2k_setup_decoder(jp2->j2k, parameters);
- /* further JP2 initializations go here */
- jp2->ignore_pclr_cmap_cdef = parameters->flags & OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG;
-}
-void jp2_setup_decoder_v2(opj_jp2_v2_t *jp2, opj_dparameters_t *parameters)
+void opj_jp2_setup_decoder(opj_jp2_v2_t *jp2, opj_dparameters_t *parameters)
{
/* setup the J2K codec */
- j2k_setup_decoder_v2(jp2->j2k, parameters);
+ opj_j2k_setup_decoder(jp2->j2k, parameters);
/* further JP2 initializations go here */
jp2->color.jp2_has_colr = 0;
+ jp2->ignore_pclr_cmap_cdef = parameters->flags & OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG;
}
assert(p_manager != 00);
/* customization of the end encoding */
- jp2_setup_end_header_reading(jp2);
+ opj_jp2_setup_end_header_reading(jp2);
/* write header */
- if (! jp2_exec (jp2,jp2->m_procedure_list,cio,p_manager)) {
+ if (! opj_jp2_exec (jp2,jp2->m_procedure_list,cio,p_manager)) {
return OPJ_FALSE;
}
}
/* write header */
- return jp2_exec(jp2,jp2->m_procedure_list,cio,p_manager);
+ return opj_jp2_exec(jp2,jp2->m_procedure_list,cio,p_manager);
}
* Sets up the procedures to do on reading header after the codestream.
* Developers wanting to extend the library can add their own writing procedures.
*/
-void jp2_setup_end_header_reading (opj_jp2_v2_t *jp2)
+void opj_jp2_setup_end_header_reading (opj_jp2_v2_t *jp2)
{
/* preconditions */
assert(jp2 != 00);
- opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)jp2_read_header_procedure );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_read_header_procedure );
/* DEVELOPER CORNER, add your custom procedures */
}
*
* @return true if the parameters are correct.
*/
-opj_bool jp2_default_validation ( opj_jp2_v2_t * jp2,
- opj_stream_private_t *cio,
- opj_event_mgr_t * p_manager )
+opj_bool opj_jp2_default_validation ( opj_jp2_v2_t * jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
{
opj_bool l_is_valid = OPJ_TRUE;
unsigned int i;
/**
* Reads a jpeg2000 file header structure.
*
- * @param cio the stream to read data from.
+ * @param stream the stream to read data from.
* @param jp2 the jpeg2000 file header structure.
* @param p_manager the user event manager.
*
* @return true if the box is valid.
*/
-opj_bool jp2_read_header_procedure(
- opj_jp2_v2_t *jp2,
- opj_stream_private_t *cio,
- opj_event_mgr_t * p_manager)
+static opj_bool opj_jp2_read_header_procedure( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *stream,
+ opj_event_mgr_t * p_manager
+ )
{
opj_jp2_box_t box;
OPJ_UINT32 l_nb_bytes_read;
unsigned char * l_current_data = 00;
/* preconditions */
- assert(cio != 00);
+ assert(stream != 00);
assert(jp2 != 00);
assert(p_manager != 00);
}
memset(l_current_data, 0 , l_last_data_size);
- while (jp2_read_boxhdr_v2(&box,&l_nb_bytes_read,cio,p_manager)) {
+ while (opj_jp2_read_boxhdr(&box,&l_nb_bytes_read,stream,p_manager)) {
/* is it the codestream box ? */
if (box.type == JP2_JP2C) {
if (jp2->jp2_state & JP2_STATE_HEADER) {
return OPJ_FALSE;
}
- l_current_handler = jp2_find_handler(box.type);
+ l_current_handler = opj_jp2_find_handler(box.type);
l_current_data_size = box.length - l_nb_bytes_read;
if (l_current_handler != 00) {
l_last_data_size = l_current_data_size;
}
- l_nb_bytes_read = opj_stream_read_data(cio,l_current_data,l_current_data_size,p_manager);
+ l_nb_bytes_read = opj_stream_read_data(stream,l_current_data,l_current_data_size,p_manager);
if (l_nb_bytes_read != l_current_data_size) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with reading JPEG2000 box, stream error\n");
return OPJ_FALSE;
}
else {
jp2->jp2_state |= JP2_STATE_UNKNOWN;
- if (opj_stream_skip(cio,l_current_data_size,p_manager) != l_current_data_size) {
+ if (opj_stream_skip(stream,l_current_data_size,p_manager) != l_current_data_size) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with skipping JPEG2000 box, stream error\n");
opj_free(l_current_data);
return OPJ_FALSE;
*
* @param p_procedure_list the list of procedures to execute
* @param jp2 the jpeg2000 file codec to execute the procedures on.
- * @param cio the stream to execute the procedures on.
+ * @param stream the stream to execute the procedures on.
* @param p_manager the user manager.
*
* @return true if all the procedures were successfully executed.
*/
-opj_bool jp2_exec (
- opj_jp2_v2_t * jp2,
- opj_procedure_list_t * p_procedure_list,
- opj_stream_private_t *cio,
- opj_event_mgr_t * p_manager
- )
+static opj_bool opj_jp2_exec ( opj_jp2_v2_t * jp2,
+ opj_procedure_list_t * p_procedure_list,
+ opj_stream_private_t *stream,
+ opj_event_mgr_t * p_manager
+ )
+
{
opj_bool (** l_procedure) (opj_jp2_v2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *) = 00;
opj_bool l_result = OPJ_TRUE;
/* preconditions */
assert(p_procedure_list != 00);
assert(jp2 != 00);
- assert(cio != 00);
+ assert(stream != 00);
assert(p_manager != 00);
l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
l_procedure = (opj_bool (**) (opj_jp2_v2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
for (i=0;i<l_nb_proc;++i) {
- l_result = l_result && (*l_procedure) (jp2,cio,p_manager);
+ l_result = l_result && (*l_procedure) (jp2,stream,p_manager);
++l_procedure;
}
jp2_setup_encoding_validation (jp2);
/* validation of the parameters codec */
- if (! jp2_exec(jp2,jp2->m_validation_list,cio,p_manager)) {
+ if (! opj_jp2_exec(jp2,jp2->m_validation_list,cio,p_manager)) {
return OPJ_FALSE;
}
jp2_setup_header_writting(jp2);
/* write header */
- if (! jp2_exec (jp2,jp2->m_procedure_list,cio,p_manager)) {
+ if (! opj_jp2_exec (jp2,jp2->m_procedure_list,cio,p_manager)) {
return OPJ_FALSE;
}
*
* @return the given handler or 00 if it could not be found.
*/
-const opj_jp2_header_handler_t * jp2_find_handler (int p_id)
+const opj_jp2_header_handler_t * opj_jp2_find_handler (OPJ_UINT32 p_id)
{
OPJ_UINT32 i, l_handler_size = sizeof(jp2_header) / sizeof(opj_jp2_header_handler_t);
*
* @return the given handler or 00 if it could not be found.
*/
-static const opj_jp2_header_handler_t * jp2_img_find_handler (
- int p_id
- )
+static const opj_jp2_header_handler_t * opj_jp2_img_find_handler (OPJ_UINT32 p_id)
{
OPJ_UINT32 i, l_handler_size = sizeof(jp2_img_header) / sizeof(opj_jp2_header_handler_t);
for (i=0;i<l_handler_size;++i)
*
* @return true if the file signature box is valid.
*/
-opj_bool jp2_read_jp_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_header_data,
- unsigned int p_header_size,
- opj_event_mgr_t * p_manager
- )
+static opj_bool opj_jp2_read_jp(opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ opj_event_mgr_t * p_manager
+ )
+
{
unsigned int l_magic_number;
*
* @return true if the FTYP box is valid.
*/
-opj_bool jp2_read_ftyp_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_header_data,
- unsigned int p_header_size,
- opj_event_mgr_t * p_manager
- )
+static opj_bool opj_jp2_read_ftyp( opj_jp2_v2_t *jp2,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ opj_event_mgr_t * p_manager
+ )
{
OPJ_UINT32 i, l_remaining_bytes;
*
* @return true if the JP2 Header box was successfully reconized.
*/
-opj_bool jp2_read_jp2h_v2(
- opj_jp2_v2_t *jp2,
- unsigned char * p_header_data,
- unsigned int p_header_size,
- opj_event_mgr_t * p_manager
- )
+static opj_bool opj_jp2_read_jp2h( opj_jp2_v2_t *jp2,
+ OPJ_BYTE *p_header_data,
+ OPJ_UINT32 p_header_size,
+ opj_event_mgr_t * p_manager
+ )
{
OPJ_UINT32 l_box_size=0, l_current_data_size = 0;
opj_jp2_box_t box;
/* iterate while remaining data */
while (p_header_size > 0) {
- if (! jp2_read_boxhdr_char(&box,p_header_data,&l_box_size,p_header_size, p_manager)) {
+ if (! opj_jp2_read_boxhdr_char(&box,p_header_data,&l_box_size,p_header_size, p_manager)) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Stream error while reading JP2 Header box\n");
return OPJ_FALSE;
}
return OPJ_FALSE;
}
- l_current_handler = jp2_img_find_handler(box.type);
+ l_current_handler = opj_jp2_img_find_handler(box.type);
l_current_data_size = box.length - l_box_size;
p_header_data += l_box_size;
*
* @return true if the box is reconized, false otherwise
*/
-static opj_bool jp2_read_boxhdr_char(
- opj_jp2_box_t *box,
- OPJ_BYTE * p_data,
- OPJ_UINT32 * p_number_bytes_read,
- OPJ_UINT32 p_box_max_size,
- opj_event_mgr_t * p_manager
- )
+opj_bool opj_jp2_read_boxhdr_char( opj_jp2_box_t *box,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_number_bytes_read,
+ OPJ_UINT32 p_box_max_size,
+ opj_event_mgr_t * p_manager
+ )
{
OPJ_UINT32 l_value;
assert(p_manager != 00);
/* customization of the validation */
- jp2_setup_decoding_validation (jp2);
+ opj_jp2_setup_decoding_validation (jp2);
/* customization of the encoding */
- jp2_setup_header_reading(jp2);
+ opj_jp2_setup_header_reading(jp2);
/* validation of the parameters codec */
- if (! jp2_exec(jp2,jp2->m_validation_list,p_stream,p_manager)) {
+ if (! opj_jp2_exec(jp2,jp2->m_validation_list,p_stream,p_manager)) {
return OPJ_FALSE;
}
/* read header */
- if (! jp2_exec (jp2,jp2->m_procedure_list,p_stream,p_manager)) {
+ if (! opj_jp2_exec (jp2,jp2->m_procedure_list,p_stream,p_manager)) {
return OPJ_FALSE;
}
/* preconditions */
assert(jp2 != 00);
- opj_procedure_list_add_procedure(jp2->m_validation_list, (opj_procedure)jp2_default_validation);
+ opj_procedure_list_add_procedure(jp2->m_validation_list, (opj_procedure)opj_jp2_default_validation);
/* DEVELOPER CORNER, add your custom validation procedure */
}
* Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
* are valid. Developpers wanting to extend the library can add their own validation procedures.
*/
-void jp2_setup_decoding_validation (opj_jp2_v2_t *jp2)
+void opj_jp2_setup_decoding_validation (opj_jp2_v2_t *jp2)
{
/* preconditions */
assert(jp2 != 00);
* Sets up the procedures to do on reading header.
* Developpers wanting to extend the library can add their own writting procedures.
*/
-void jp2_setup_header_reading (opj_jp2_v2_t *jp2)
+void opj_jp2_setup_header_reading (opj_jp2_v2_t *jp2)
{
/* preconditions */
assert(jp2 != 00);
- opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)jp2_read_header_procedure );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_read_header_procedure );
/* DEVELOPER CORNER, add your custom procedures */
}
jp2->j2k = j2k_create_compress_v2();
}
else {
- jp2->j2k = j2k_create_decompress_v2();
+ jp2->j2k = opj_j2k_create_decompress();
}
if (jp2->j2k == 00) {
projects / openjpeg.git / blobdiff