/** @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);*/
/**
*/
static opj_bool opj_jp2_read_ihdr( opj_jp2_v2_t *jp2,
OPJ_BYTE *p_image_header_data,
- OPJ_INT32 p_image_header_size,
+ 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);
-
/**
* Writes the Image Header box - Image Header box.
*
*
* @return the data being copied.
*/
-static unsigned char * jp2_write_ihdr_v2( opj_jp2_v2_t *jp2,
- unsigned int * p_nb_bytes_written );
-
-static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
+static OPJ_BYTE * opj_jp2_write_ihdr(opj_jp2_v2_t *jp2,
+ OPJ_UINT32 * p_nb_bytes_written );
/**
* Writes the Bit per Component box.
*
* @return the data being copied.
*/
-static unsigned char * jp2_write_bpcc_v2( opj_jp2_v2_t *jp2,
- unsigned int * p_nb_bytes_written );
+static OPJ_BYTE * opj_jp2_write_bpcc( opj_jp2_v2_t *jp2,
+ OPJ_UINT32 * p_nb_bytes_written );
/**
* 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 jp2_read_cdef_v2( opj_jp2_v2_t * jp2,
- unsigned char * p_cdef_header_data,
- OPJ_UINT32 p_cdef_header_size,
- 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
-*/
+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 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 );
/**
* Writes the Colour Specification box.
*
*
* @return the data being copied.
*/
-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
-@param jp2 JP2 handle
-@param cio Input buffer stream
-@return Returns true if successful, returns false otherwise
-*/
-static opj_bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
+static OPJ_BYTE * opj_jp2_write_colr( opj_jp2_v2_t *jp2,
+ OPJ_UINT32 * p_nb_bytes_written );
/**
* Writes a FTYP box - File type box
*
* @return true if writting was successful.
*/
-static opj_bool jp2_write_ftyp_v2( opj_jp2_v2_t *jp2,
- struct opj_stream_private *cio,
- struct opj_event_mgr * p_manager );
+static opj_bool opj_jp2_write_ftyp( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager );
/**
* Reads a 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 writting was successful.
*/
-opj_bool jp2_skip_jp2c( opj_jp2_v2_t *jp2,
- struct opj_stream_private *cio,
- struct opj_event_mgr * p_manager );
+opj_bool opj_jp2_skip_jp2c( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager );
/**
* Reads the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
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);
-
-
/**
* Writes the Jpeg2000 codestream Header box - JP2C Header box. This function must be called AFTER the coding has been done.
*
*
* @return true if writting was successful.
*/
-static opj_bool jp2_write_jp2c_v2( opj_jp2_v2_t *jp2,
- 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);
+static opj_bool opj_jp2_write_jp2c( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager );
/**
* 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);
+ * Writes a jpeg2000 file signature box.
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager the user event manager.
+ *
+ * @return true if writting was successful.
+ */
+static opj_bool opj_jp2_write_jp( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager );
+
/**
Apply collected palette data
@param color Collector for profile, cdef and pclr data
@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 writting header after the codestream.
* Developpers wanting to extend the library can add their own writting procedures.
*/
-static void jp2_setup_end_header_writting (opj_jp2_v2_t *jp2);
+static void opj_jp2_setup_end_header_writting (opj_jp2_v2_t *jp2);
/**
* 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
* are valid. Developpers wanting to extend the library can add their own validation procedures.
*/
-static void jp2_setup_encoding_validation (opj_jp2_v2_t *jp2);
+static void opj_jp2_setup_encoding_validation (opj_jp2_v2_t *jp2);
/**
* Sets up the procedures to do on writting header. Developpers wanting to extend the library can add their own writting procedures.
*/
-static void jp2_setup_header_writting (opj_jp2_v2_t *jp2);
+static void opj_jp2_setup_header_writting (opj_jp2_v2_t *jp2);
/**
* The default validation procedure without any extension.
*
* @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_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,opj_jp2_read_ihdr},
- {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_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];
*/
opj_bool opj_jp2_read_ihdr( opj_jp2_v2_t *jp2,
OPJ_BYTE *p_image_header_data,
- OPJ_INT32 p_image_header_size,
+ OPJ_UINT32 p_image_header_size,
opj_event_mgr_t * p_manager )
{
/* preconditions */
return OPJ_TRUE;
}
-static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
- opj_jp2_box_t box;
-
- box.init_pos = cio_tell(cio);
- cio_skip(cio, 4);
- cio_write(cio, JP2_IHDR, 4); /* IHDR */
-
- cio_write(cio, jp2->h, 4); /* HEIGHT */
- cio_write(cio, jp2->w, 4); /* WIDTH */
- cio_write(cio, jp2->numcomps, 2); /* NC */
-
- cio_write(cio, jp2->bpc, 1); /* BPC */
-
- cio_write(cio, jp2->C, 1); /* C : Always 7 */
- cio_write(cio, jp2->UnkC, 1); /* UnkC, colorspace unknown */
- cio_write(cio, jp2->IPR, 1); /* IPR, no intellectual property */
-
- box.length = cio_tell(cio) - box.init_pos;
- cio_seek(cio, box.init_pos);
- cio_write(cio, box.length, 4); /* L */
- cio_seek(cio, box.init_pos + box.length);
-}
-
/**
* Writes the Image Header box - Image Header box.
*
*
* @return the data being copied.
*/
-static unsigned char * jp2_write_ihdr_v2( opj_jp2_v2_t *jp2,
- unsigned int * p_nb_bytes_written )
+OPJ_BYTE * opj_jp2_write_ihdr(opj_jp2_v2_t *jp2,
+ OPJ_UINT32 * p_nb_bytes_written
+ )
{
unsigned char * l_ihdr_data,* l_current_ihdr_ptr;
return l_ihdr_data;
}
-static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
- unsigned int i;
- opj_jp2_box_t box;
-
- box.init_pos = cio_tell(cio);
- cio_skip(cio, 4);
- cio_write(cio, JP2_BPCC, 4); /* BPCC */
-
- for (i = 0; i < jp2->numcomps; i++) {
- cio_write(cio, jp2->comps[i].bpcc, 1);
- }
-
- box.length = cio_tell(cio) - box.init_pos;
- cio_seek(cio, box.init_pos);
- cio_write(cio, box.length, 4); /* L */
- cio_seek(cio, box.init_pos + box.length);
-}
-
-
/**
* Writes the Bit per Component box.
*
*
* @return the data being copied.
*/
-unsigned char * jp2_write_bpcc_v2( opj_jp2_v2_t *jp2,
- unsigned int * p_nb_bytes_written )
+OPJ_BYTE * opj_jp2_write_bpcc( opj_jp2_v2_t *jp2,
+ OPJ_UINT32 * p_nb_bytes_written
+ )
{
unsigned int i;
/* room for 8 bytes for box and 1 byte for each component */
*
* @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;
return OPJ_TRUE;
}
-static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio) {
- opj_jp2_box_t box;
-
- box.init_pos = cio_tell(cio);
- cio_skip(cio, 4);
- cio_write(cio, JP2_COLR, 4); /* COLR */
-
- cio_write(cio, jp2->meth, 1); /* METH */
- cio_write(cio, jp2->precedence, 1); /* PRECEDENCE */
- cio_write(cio, jp2->approx, 1); /* APPROX */
-
- if(jp2->meth == 2)
- jp2->enumcs = 0;
-
- cio_write(cio, jp2->enumcs, 4); /* EnumCS */
-
- box.length = cio_tell(cio) - box.init_pos;
- cio_seek(cio, box.init_pos);
- cio_write(cio, box.length, 4); /* L */
- cio_seek(cio, box.init_pos + box.length);
-}
-
/**
* Writes the Colour Specification box.
*
*
* @return the data being copied.
*/
-unsigned char *jp2_write_colr_v2( opj_jp2_v2_t *jp2,
- unsigned int * p_nb_bytes_written )
+OPJ_BYTE * opj_jp2_write_colr( opj_jp2_v2_t *jp2,
+ OPJ_UINT32 * p_nb_bytes_written
+ )
{
/* room for 8 bytes for box 3 for common data and variable upon profile*/
unsigned int l_colr_size = 11;
}/* 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;
jp2_pclr->channel_size = channel_size;
jp2_pclr->entries = entries;
jp2_pclr->nr_entries = nr_entries;
- jp2_pclr->nr_channels = nr_channels;
+ jp2_pclr->nr_channels = (OPJ_BYTE) l_value;
jp2_pclr->cmap = NULL;
jp2->color.jp2_pclr = jp2_pclr;
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;
}
-void jp2_write_jp2h(opj_jp2_t *jp2, opj_cio_t *cio) {
- opj_jp2_box_t box;
-
- box.init_pos = cio_tell(cio);
- cio_skip(cio, 4);
- cio_write(cio, JP2_JP2H, 4); /* JP2H */
-
- jp2_write_ihdr(jp2, cio);
-
- if (jp2->bpc == 255) {
- jp2_write_bpcc(jp2, cio);
- }
- jp2_write_colr(jp2, cio);
-
- box.length = cio_tell(cio) - box.init_pos;
- cio_seek(cio, box.init_pos);
- cio_write(cio, box.length, 4); /* L */
- cio_seek(cio, box.init_pos + box.length);
-}
-
/**
* Writes the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
*
*
* @return true if writting was successful.
*/
-opj_bool jp2_write_jp2h_v2( opj_jp2_v2_t *jp2,
- opj_stream_private_t *cio,
- opj_event_mgr_t * p_manager )
+opj_bool opj_jp2_write_jp2h(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *stream,
+ opj_event_mgr_t * p_manager
+ )
{
opj_jp2_img_header_writer_handler_t l_writers [3];
opj_jp2_img_header_writer_handler_t * l_current_writer;
unsigned char l_jp2h_data [8];
// preconditions
- assert(cio != 00);
+ assert(stream != 00);
assert(jp2 != 00);
assert(p_manager != 00);
if (jp2->bpc == 255) {
l_nb_pass = 3;
- l_writers[0].handler = jp2_write_ihdr_v2;
- l_writers[1].handler = jp2_write_bpcc_v2;
- l_writers[2].handler = jp2_write_colr_v2;
+ l_writers[0].handler = opj_jp2_write_ihdr;
+ l_writers[1].handler = opj_jp2_write_bpcc;
+ l_writers[2].handler = opj_jp2_write_colr;
}
else {
l_nb_pass = 2;
- l_writers[0].handler = jp2_write_ihdr_v2;
- l_writers[1].handler = jp2_write_colr_v2;
+ l_writers[0].handler = opj_jp2_write_ihdr;
+ l_writers[1].handler = opj_jp2_write_colr;
}
/* write box header */
opj_write_bytes(l_jp2h_data,l_jp2h_size,4);
/* write super box data on stream */
- if (opj_stream_write_data(cio,l_jp2h_data,8,p_manager) != 8) {
+ if (opj_stream_write_data(stream,l_jp2h_data,8,p_manager) != 8) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Stream error while writing JP2 Header box\n");
l_result = OPJ_FALSE;
}
if (l_result) {
l_current_writer = l_writers;
for (i=0;i<l_nb_pass;++i) {
- if (opj_stream_write_data(cio,l_current_writer->m_data,l_current_writer->m_size,p_manager) != l_current_writer->m_size) {
+ if (opj_stream_write_data(stream,l_current_writer->m_data,l_current_writer->m_size,p_manager) != l_current_writer->m_size) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Stream error while writting JP2 Header box\n");
l_result = OPJ_FALSE;
break;
return l_result;
}
-static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
- unsigned int i;
- opj_jp2_box_t box;
-
- box.init_pos = cio_tell(cio);
- cio_skip(cio, 4);
- cio_write(cio, JP2_FTYP, 4); /* FTYP */
-
- cio_write(cio, jp2->brand, 4); /* BR */
- cio_write(cio, jp2->minversion, 4); /* MinV */
-
- for (i = 0; i < jp2->numcl; i++) {
- cio_write(cio, jp2->cl[i], 4); /* CL */
- }
-
- box.length = cio_tell(cio) - box.init_pos;
- cio_seek(cio, box.init_pos);
- cio_write(cio, box.length, 4); /* L */
- cio_seek(cio, box.init_pos + box.length);
-}
-
/**
* Writes a FTYP box - File type box
*
*
* @return true if writting was successful.
*/
-opj_bool jp2_write_ftyp_v2( opj_jp2_v2_t *jp2,
+opj_bool opj_jp2_write_ftyp(opj_jp2_v2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager )
{
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;
-
- opj_j2k_t *j2k = jp2->j2k;
-
- box.init_pos = cio_tell(cio);
- cio_skip(cio, 4);
- cio_write(cio, JP2_JP2C, 4); /* JP2C */
-
- /* J2K encoding */
- j2k_codestream_offset = cio_tell(cio);
- if(!j2k_encode(j2k, cio, image, cstr_info)) {
- opj_event_msg(j2k->cinfo, EVT_ERROR, "Failed to encode image\n");
- return 0;
- }
- j2k_codestream_length = cio_tell(cio) - j2k_codestream_offset;
-
- jp2->j2k_codestream_offset = j2k_codestream_offset;
- jp2->j2k_codestream_length = j2k_codestream_length;
-
- box.length = 8 + jp2->j2k_codestream_length;
- cio_seek(cio, box.init_pos);
- cio_write(cio, box.length, 4); /* L */
- cio_seek(cio, box.init_pos + box.length);
-
- return box.length;
-}
-
/**
* Writes the Jpeg2000 codestream Header box - JP2C Header box.
*
*
* @return true if writting was successful.
*/
-opj_bool jp2_write_jp2c_v2( opj_jp2_v2_t *jp2,
+opj_bool opj_jp2_write_jp2c(opj_jp2_v2_t *jp2,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager )
{
- unsigned int j2k_codestream_exit;
- unsigned char l_data_header [8];
+ OPJ_OFF_T j2k_codestream_exit;
+ OPJ_BYTE l_data_header [8];
// preconditions
assert(jp2 != 00);
assert(opj_stream_has_seek(cio));
j2k_codestream_exit = opj_stream_tell(cio);
- opj_write_bytes(l_data_header,j2k_codestream_exit - jp2->j2k_codestream_offset,4); /* size of codestream */
+ opj_write_bytes(l_data_header,
+ (OPJ_UINT32) (j2k_codestream_exit - jp2->j2k_codestream_offset),
+ 4); /* size of codestream */
opj_write_bytes(l_data_header + 4,JP2_JP2C,4); /* JP2C */
if (! opj_stream_seek(cio,jp2->j2k_codestream_offset,p_manager)) {
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;
-
- box.init_pos = cio_tell(cio);
- cio_skip(cio, 4);
- cio_write(cio, JP2_JP, 4); /* JP2 signature */
- cio_write(cio, 0x0d0a870a, 4);
-
- box.length = cio_tell(cio) - box.init_pos;
- cio_seek(cio, box.init_pos);
- cio_write(cio, box.length, 4); /* L */
- cio_seek(cio, box.init_pos + box.length);
-}
-
/**
* Writes a jpeg2000 file signature box.
*
*
* @return true if writting was successful.
*/
-opj_bool jp2_write_jp_v2( opj_jp2_v2_t *jp2,
- opj_stream_private_t *cio,
- opj_event_mgr_t * p_manager )
+opj_bool opj_jp2_write_jp( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager )
{
/* 12 bytes will be read */
unsigned char l_signature_data [12];
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 encoder interface */
/* ----------------------------------------------------------------------- */
-opj_jp2_t* jp2_create_compress(opj_common_ptr cinfo) {
- opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t));
- if(jp2) {
- jp2->cinfo = cinfo;
- /* create the J2K codec */
- jp2->j2k = j2k_create_compress(cinfo);
- if(jp2->j2k == NULL) {
- jp2_destroy_compress(jp2);
- return NULL;
- }
- }
- return jp2;
-}
-
-void jp2_destroy_compress(opj_jp2_t *jp2) {
- if(jp2) {
- /* destroy the J2K codec */
- j2k_destroy_compress(jp2->j2k);
-
- if(jp2->comps) {
- opj_free(jp2->comps);
- }
- if(jp2->cl) {
- opj_free(jp2->cl);
- }
- opj_free(jp2);
- }
-}
-
-void jp2_setup_encoder( opj_jp2_v2_t *jp2,
- opj_cparameters_t *parameters,
- opj_image_t *image,
- opj_event_mgr_t * p_manager) {
- int i;
+void opj_jp2_setup_encoder( opj_jp2_v2_t *jp2,
+ opj_cparameters_t *parameters,
+ opj_image_t *image,
+ opj_event_mgr_t * p_manager)
+{
+ OPJ_UINT32 i;
int depth_0, sign;
if(!jp2 || !parameters || !image)
}
-opj_bool opj_jp2_encode_v2( opj_jp2_v2_t *jp2,
- opj_stream_private_t *stream,
- opj_event_mgr_t * p_manager)
+opj_bool opj_jp2_encode(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *stream,
+ opj_event_mgr_t * p_manager)
{
return j2k_encode_v2(jp2->j2k, stream, p_manager);
}
-opj_bool opj_jp2_encode(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
-
- int pos_iptr, pos_cidx, pos_jp2c, len_jp2c, len_cidx, end_pos, pos_fidx, len_fidx;
- pos_jp2c = pos_iptr = -1; /* remove a warning */
-
- /* JP2 encoding */
-
- /* JPEG 2000 Signature box */
- jp2_write_jp(cio);
- /* File Type box */
- jp2_write_ftyp(jp2, cio);
- /* JP2 Header box */
- jp2_write_jp2h(jp2, cio);
-
- if( jp2->jpip_on){
- pos_iptr = cio_tell( cio);
- cio_skip( cio, 24); /* IPTR further ! */
-
- pos_jp2c = cio_tell( cio);
- }
-
- /* J2K encoding */
- if(!(len_jp2c = jp2_write_jp2c( jp2, cio, image, cstr_info))){
- opj_event_msg(jp2->cinfo, EVT_ERROR, "Failed to encode image\n");
- return OPJ_FALSE;
- }
-
- if( jp2->jpip_on){
- pos_cidx = cio_tell( cio);
-
- len_cidx = write_cidx( pos_jp2c+8, cio, image, *cstr_info, len_jp2c-8);
-
- pos_fidx = cio_tell( cio);
- len_fidx = write_fidx( pos_jp2c, len_jp2c, pos_cidx, len_cidx, cio);
-
- end_pos = cio_tell( cio);
-
- cio_seek( cio, pos_iptr);
- write_iptr( pos_fidx, len_fidx, cio);
- cio_seek( cio, end_pos);
- }
-
- return OPJ_TRUE;
-}
/**
* Ends the decompression procedures and possibiliy add data to be read after the
* codestream.
*/
-opj_bool jp2_end_decompress(opj_jp2_v2_t *jp2, opj_stream_private_t *cio, opj_event_mgr_t * p_manager)
+opj_bool opj_jp2_end_decompress(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
{
/* preconditions */
assert(jp2 != 00);
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;
}
* Ends the compression procedures and possibility add data to be read after the
* codestream.
*/
-opj_bool jp2_end_compress( opj_jp2_v2_t *jp2,
- opj_stream_private_t *cio,
- opj_event_mgr_t * p_manager)
+opj_bool opj_jp2_end_compress( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
{
/* preconditions */
assert(jp2 != 00);
assert(p_manager != 00);
/* customization of the end encoding */
- jp2_setup_end_header_writting(jp2);
+ opj_jp2_setup_end_header_writting(jp2);
if (! j2k_end_compress(jp2->j2k,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 writing header after the codestream.
* Developers wanting to extend the library can add their own writing procedures.
*/
-void jp2_setup_end_header_writting (opj_jp2_v2_t *jp2)
+void opj_jp2_setup_end_header_writting (opj_jp2_v2_t *jp2)
{
/* preconditions */
assert(jp2 != 00);
- opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)jp2_write_jp2c_v2 );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp2c );
/* DEVELOPER CORNER, add your custom procedures */
}
* 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;
}
*
* @return true if the codec is valid.
*/
-opj_bool jp2_start_compress(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_start_compress(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *stream,
+ opj_image_t * p_image,
+ opj_event_mgr_t * p_manager
+ )
{
/* preconditions */
assert(jp2 != 00);
- assert(cio != 00);
+ assert(stream != 00);
assert(p_manager != 00);
/* customization of the validation */
- jp2_setup_encoding_validation (jp2);
+ opj_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,stream,p_manager)) {
return OPJ_FALSE;
}
/* customization of the encoding */
- jp2_setup_header_writting(jp2);
+ opj_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,stream,p_manager)) {
return OPJ_FALSE;
}
- return j2k_start_compress(jp2->j2k,cio,p_image,p_manager);
+ return j2k_start_compress(jp2->j2k,stream,p_image,p_manager);
}
/**
*
* @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 writting was successful.
*/
-opj_bool jp2_skip_jp2c( opj_jp2_v2_t *jp2,
- struct opj_stream_private *stream,
- struct opj_event_mgr * p_manager )
+opj_bool opj_jp2_skip_jp2c( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *stream,
+ opj_event_mgr_t * p_manager )
{
/* preconditions */
assert(jp2 != 00);
/* 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;
*
* @return true if the box is valid.
*/
-opj_bool jp2_read_header( struct opj_stream_private *p_stream,
- opj_jp2_v2_t *jp2,
- opj_image_t** p_image,
- struct opj_event_mgr * p_manager
- )
+opj_bool opj_jp2_read_header( opj_stream_private_t *p_stream,
+ opj_jp2_v2_t *jp2,
+ opj_image_t ** p_image,
+ opj_event_mgr_t * p_manager
+ )
{
/* preconditions */
assert(jp2 != 00);
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;
}
* Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
* are valid. Developers wanting to extend the library can add their own validation procedures.
*/
-void jp2_setup_encoding_validation (opj_jp2_v2_t *jp2)
+void opj_jp2_setup_encoding_validation (opj_jp2_v2_t *jp2)
{
/* 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 writting header.
* Developers wanting to extend the library can add their own writing procedures.
*/
-void jp2_setup_header_writting (opj_jp2_v2_t *jp2)
+void opj_jp2_setup_header_writting (opj_jp2_v2_t *jp2)
{
/* preconditions */
assert(jp2 != 00);
- opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)jp2_write_jp_v2 );
- opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)jp2_write_ftyp_v2 );
- opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)jp2_write_jp2h_v2 );
- opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)jp2_skip_jp2c );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_ftyp );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp2h );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_skip_jp2c );
/* DEVELOPER CORNER, insert your custom procedures */
* 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 */
}
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
-opj_bool jp2_read_tile_header( opj_jp2_v2_t * p_jp2,
- OPJ_UINT32 * p_tile_index,
- OPJ_UINT32 * p_data_size,
- OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
- OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
- OPJ_UINT32 * p_nb_comps,
- opj_bool * p_go_on,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager )
+opj_bool opj_jp2_read_tile_header ( opj_jp2_v2_t * p_jp2,
+ OPJ_UINT32 * p_tile_index,
+ OPJ_UINT32 * p_data_size,
+ OPJ_INT32 * p_tile_x0,
+ OPJ_INT32 * p_tile_y0,
+ OPJ_INT32 * p_tile_x1,
+ OPJ_INT32 * p_tile_y1,
+ OPJ_UINT32 * p_nb_comps,
+ opj_bool * p_go_on,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
{
return j2k_read_tile_header(p_jp2->j2k,
p_tile_index,
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
-opj_bool jp2_write_tile ( opj_jp2_v2_t *p_jp2,
- OPJ_UINT32 p_tile_index,
- OPJ_BYTE * p_data,
- OPJ_UINT32 p_data_size,
- struct opj_stream_private *p_stream,
- struct opj_event_mgr * p_manager )
+opj_bool opj_jp2_write_tile ( opj_jp2_v2_t *p_jp2,
+ OPJ_UINT32 p_tile_index,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 p_data_size,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+
{
return j2k_write_tile (p_jp2->j2k,p_tile_index,p_data,p_data_size,p_stream,p_manager);
}
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
-opj_bool jp2_decode_tile (
- opj_jp2_v2_t * p_jp2,
- OPJ_UINT32 p_tile_index,
- OPJ_BYTE * p_data,
- OPJ_UINT32 p_data_size,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager
- )
+opj_bool opj_jp2_decode_tile ( opj_jp2_v2_t * p_jp2,
+ OPJ_UINT32 p_tile_index,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 p_data_size,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
{
return j2k_decode_tile (p_jp2->j2k,p_tile_index,p_data,p_data_size,p_stream,p_manager);
}
*
* @param jp2 a jpeg2000 file decompressor.
*/
-void jp2_destroy(opj_jp2_v2_t *jp2)
+void opj_jp2_destroy(opj_jp2_v2_t *jp2)
{
if (jp2) {
/* destroy the J2K codec */
*
* @return true if the area could be set.
*/
-opj_bool jp2_set_decode_area( opj_jp2_v2_t *p_jp2,
- opj_image_t* p_image,
- OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
- OPJ_INT32 p_end_x, OPJ_INT32 p_end_y,
- struct opj_event_mgr * p_manager )
+opj_bool opj_jp2_set_decode_area( opj_jp2_v2_t *p_jp2,
+ opj_image_t* p_image,
+ OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
+ OPJ_INT32 p_end_x, OPJ_INT32 p_end_y,
+ opj_event_mgr_t * p_manager
+ )
{
return j2k_set_decode_area(p_jp2->j2k, p_image, p_start_x, p_start_y, p_end_x, p_end_y, p_manager);
}
*
* @return true if succeed.
*/
-opj_bool jp2_get_tile( opj_jp2_v2_t *jp2,
- opj_stream_private_t *p_stream,
- opj_image_t* p_image,
- struct opj_event_mgr * p_manager,
- OPJ_UINT32 tile_index )
+opj_bool opj_jp2_get_tile( opj_jp2_v2_t *p_jp2,
+ opj_stream_private_t *p_stream,
+ opj_image_t* p_image,
+ opj_event_mgr_t * p_manager,
+ OPJ_UINT32 tile_index
+ )
{
if (!p_image)
return OPJ_FALSE;
opj_event_msg_v2(p_manager, EVT_WARNING, "JP2 box which are after the codestream will not be read by this function.\n");
- if (! j2k_get_tile(jp2->j2k, p_stream, p_image, p_manager, tile_index) ){
+ if (! j2k_get_tile(p_jp2->j2k, p_stream, p_image, p_manager, tile_index) ){
opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to decode the codestream in the JP2 file\n");
return OPJ_FALSE;
}
/* Set Image Color Space */
- if (jp2->enumcs == 16)
+ if (p_jp2->enumcs == 16)
p_image->color_space = CLRSPC_SRGB;
- else if (jp2->enumcs == 17)
+ else if (p_jp2->enumcs == 17)
p_image->color_space = CLRSPC_GRAY;
- else if (jp2->enumcs == 18)
+ else if (p_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(p_jp2->color.jp2_cdef) {
+ jp2_apply_cdef(p_image, &(p_jp2->color));
}
- if(jp2->color.jp2_pclr) {
+ if(p_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));
+ if( !p_jp2->color.jp2_pclr->cmap)
+ jp2_free_pclr(&(p_jp2->color));
else
- jp2_apply_pclr(p_image, &(jp2->color));
+ jp2_apply_pclr(p_image, &(p_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;
+ if(p_jp2->color.icc_profile_buf) {
+ p_image->icc_profile_buf = p_jp2->color.icc_profile_buf;
+ p_image->icc_profile_len = p_jp2->color.icc_profile_len;
+ p_jp2->color.icc_profile_buf = NULL;
}
return OPJ_TRUE;
/* JP2 encoder interface */
/* ----------------------------------------------------------------------- */
-opj_jp2_v2_t* jp2_create(opj_bool p_is_decoder)
+opj_jp2_v2_t* opj_jp2_create(opj_bool p_is_decoder)
{
opj_jp2_v2_t *jp2 = (opj_jp2_v2_t*)opj_malloc(sizeof(opj_jp2_v2_t));
if (jp2) {
}
if (jp2->j2k == 00) {
- jp2_destroy(jp2);
+ opj_jp2_destroy(jp2);
return 00;
}
/* validation list creation */
jp2->m_validation_list = opj_procedure_list_create();
if (! jp2->m_validation_list) {
- jp2_destroy(jp2);
+ opj_jp2_destroy(jp2);
return 00;
}
/* execution list creation */
jp2->m_procedure_list = opj_procedure_list_create();
if (! jp2->m_procedure_list) {
- jp2_destroy(jp2);
+ opj_jp2_destroy(jp2);
return 00;
}
}
return j2k_get_cstr_info(p_jp2->j2k);
}
-opj_bool jp2_set_decoded_resolution_factor(opj_jp2_v2_t *p_jp2, OPJ_UINT32 res_factor, opj_event_mgr_t * p_manager)
+opj_bool opj_jp2_set_decoded_resolution_factor(opj_jp2_v2_t *p_jp2,
+ OPJ_UINT32 res_factor,
+ opj_event_mgr_t * p_manager)
{
return j2k_set_decoded_resolution_factor(p_jp2->j2k, res_factor, p_manager);
}
projects / openjpeg.git / blobdiff