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.
OPJ_BYTE * 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);
/**
* 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 );
-
-/**
-Write the FTYP box - File type box
-@param jp2 JP2 handle
-@param cio Output buffer stream
-*/
-static void jp2_write_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 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 void jp2_write_jp(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.
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager);
+/**
+ * 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
* 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 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 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 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;
*
* @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 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 )
{
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];
/* JP2 encoder interface */
/* ----------------------------------------------------------------------- */
-void jp2_setup_encoder( opj_jp2_v2_t *jp2,
- opj_cparameters_t *parameters,
- opj_image_t *image,
- opj_event_mgr_t * p_manager)
+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;
}
-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);
}
* 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);
* 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;
* 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 */
}
*
* @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 (! opj_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 (! opj_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 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);
*
* @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);
* 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);
* 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 */
* @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