*/
#include "opj_includes.h"
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h> /* PRIi64 */
+#endif
/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
/*@{*/
* @param p_header_size the size of the data contained in the POC marker.
* @param p_manager the user event manager.
*/
+#if 0
static opj_bool j2k_read_ppm_v2 (
opj_j2k_v2_t *p_j2k,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
struct opj_event_mgr * p_manager
);
+#endif
static opj_bool j2k_read_ppm_v3 (
opj_j2k_v2_t *p_j2k,
* @param p_header_size the size of the data contained in the SOD marker.
* @param p_manager the user event manager.
*/
+#if 0
static opj_bool j2k_read_eoc_v2 (
opj_j2k_v2_t *p_j2k,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager
) ;
+#endif
*/
static OPJ_UINT32 j2k_get_num_tp_v2( opj_cp_v2_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno);
+/** mem allocation for TLM marker*/
+static int j2k_calculate_tp(opj_cp_t *cp,int img_numcomp,opj_image_t *image,opj_j2k_t *j2k );
+
/**
* Calculates the total number of tile parts needed by the encoder to
* encode such an image. If not enough memory is available, then the function return false.
case 'R':
tpnum *= l_current_poc->resE;
break;
- // precinct wise
+ /* precinct wise */
case 'P':
tpnum *= l_current_poc->prcE;
break;
/* UniPG>> */
#ifdef USE_JPWL
/* update markers struct */
+/*
j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOC, p_stream_tell(p_stream) - 2, 2);
+*/
+ assert( 0 && "TODO" );
#endif /* USE_JPWL */
/* <<UniPG */
}
static void j2k_write_siz(opj_j2k_t *j2k) {
- int i;
+ OPJ_UINT32 i;
int lenp, len;
opj_cio_t *cio = j2k->cio;
l_current_ptr+=2;
for (i = 0; i < l_image->numcomps; ++i) {
- // TODO here with MCT ?
+ /* TODO here with MCT ? */
opj_write_bytes(l_current_ptr, l_img_comp->prec - 1 + (l_img_comp->sgnd << 7), 1); /* Ssiz_i */
++l_current_ptr;
}
static void j2k_read_siz(opj_j2k_t *j2k) {
- int len, i;
+ int len;
+ OPJ_UINT32 i;
opj_cio_t *cio = j2k->cio;
opj_image_t *image = j2k->image;
cp->tx0 = cio_read(cio, 4); /* XT0siz */
cp->ty0 = cio_read(cio, 4); /* YT0siz */
+ /* the following code triggers: */
+ /* warning: comparison of unsigned expression < 0 is always false */
+#if 0
if ((image->x0<0)||(image->x1<0)||(image->y0<0)||(image->y1<0)) {
opj_event_msg(j2k->cinfo, EVT_ERROR,
"%s: invalid image size (x0:%d, x1:%d, y0:%d, y1:%d)\n",
image->x0,image->x1,image->y0,image->y1);
return;
}
+#endif
image->numcomps = cio_read(cio, 2); /* Csiz */
return;
}
}
- if (image->numcomps != ((len - 38) / 3)) {
+ assert( len >= 38 );
+ if (image->numcomps != (OPJ_UINT32)((len - 38) / 3)) {
opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
"JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
image->numcomps, ((len - 38) / 3));
}
/* we try to correct */
opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
- if (image->numcomps < ((len - 38) / 3)) {
+ if (image->numcomps < (OPJ_UINT32)((len - 38) / 3)) {
len = 38 + 3 * image->numcomps;
opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
len);
}
#endif /* USE_JPWL */
- for (i = 0; i < cp->tw * cp->th; i++) {
+ for (i = 0; i < (OPJ_UINT32)cp->tw * cp->th; i++) {
cp->tcps[i].POC = 0;
cp->tcps[i].numpocs = 0;
cp->tcps[i].first = 1;
cp->ppm_store = 0;
j2k->default_tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
- for (i = 0; i < cp->tw * cp->th; i++) {
+ for (i = 0; i < (OPJ_UINT32)cp->tw * cp->th; i++) {
cp->tcps[i].tccps = (opj_tccp_t*) opj_malloc(image->numcomps * sizeof(opj_tccp_t));
}
j2k->tile_data = (unsigned char**) opj_calloc(cp->tw * cp->th, sizeof(unsigned char*));
assert(p_j2k != 00);
assert(p_manager != 00);
assert(p_header_data != 00);
+ (void)p_header_size;
return OPJ_TRUE;
}
static void j2k_write_cox(opj_j2k_t *j2k, int compno) {
- int i;
+ OPJ_UINT32 i;
opj_cp_t *cp = j2k->cp;
opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
}
static void j2k_read_cox(opj_j2k_t *j2k, int compno) {
- int i;
+ OPJ_UINT32 i;
opj_cp_t *cp = j2k->cp;
opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
tccp->numresolutions = cio_read(cio, 1) + 1; /* SPcox (D) */
/* If user wants to remove more resolutions than the codestream contains, return error*/
- if (cp->reduce >= tccp->numresolutions) {
+ assert(cp->reduce >= 0);
+ if ((OPJ_UINT32)cp->reduce >= tccp->numresolutions) {
opj_event_msg(j2k->cinfo, EVT_ERROR, "Error decoding component %d.\nThe number of resolutions to remove is higher than the number "
"of resolutions of this component\nModify the cp_reduce parameter.\n\n", compno);
j2k->state |= J2K_STATE_ERR;
}
static void j2k_read_cod(opj_j2k_t *j2k) {
- int len, i, pos;
+ int len, pos;
+ OPJ_UINT32 i;
opj_cio_t *cio = j2k->cio;
opj_cp_t *cp = j2k->cp;
static void j2k_read_qcd(opj_j2k_t *j2k) {
- int len, i, pos;
+ int len, pos;
+ OPJ_UINT32 i;
opj_cio_t *cio = j2k->cio;
opj_image_t *image = j2k->image;
static OPJ_UINT32 backup_compno = 0;
/* compno is negative or larger than the number of components!!! */
- if ((l_comp_no < 0) || (l_comp_no >= l_num_comp)) {
+ if (/*(l_comp_no < 0) ||*/ (l_comp_no >= l_num_comp)) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
l_comp_no, l_num_comp);
* @param p_header_size the size of the data contained in the POC marker.
* @param p_manager the user event manager.
*/
+#if 0
opj_bool j2k_read_ppm_v2 (
opj_j2k_v2_t *p_j2k,
OPJ_BYTE * p_header_data,
return OPJ_TRUE;
}
+#endif
/* UniPG>> */
#ifdef USE_JPWL
/* update markers struct */
+/*
j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOT, p_j2k->sot_start, len + 2);
+*/
+ assert( 0 && "TODO" );
#endif /* USE_JPWL */
* p_data_written = 12;
static void j2k_read_sot(opj_j2k_t *j2k) {
- int len, tileno, totlen, partno, numparts, i;
+ int len, tileno, totlen, partno, numparts;
+ OPJ_UINT32 i;
opj_tcp_t *tcp = NULL;
char status = 0;
cp->tileno_size++;
} else {
i = 0;
- while (i < cp->tileno_size && status == 0) {
+ assert(cp->tileno_size >= 0);
+ while (i < (OPJ_UINT32)cp->tileno_size && status == 0) {
status = cp->tileno[i] == tileno ? 1 : 0;
i++;
}
if (l_cp->correct) {
/* totlen is negative or larger than the bytes left!!! */
- if ((l_tot_len < 0) || (l_tot_len > p_header_size ) ) { /* FIXME it seems correct; for info in V1 -> (p_stream_numbytesleft(p_stream) + 8))) { */
+ if (/*(l_tot_len < 0) ||*/ (l_tot_len > p_header_size ) ) { /* FIXME it seems correct; for info in V1 -> (p_stream_numbytesleft(p_stream) + 8))) { */
opj_event_msg_v2(p_manager, EVT_ERROR,
"JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
l_tot_len, p_header_size ); /* FIXME it seems correct; for info in V1 -> p_stream_numbytesleft(p_stream) + 8); */
|| (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
|| (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
}
- else
- p_j2k->m_specific_param.m_decoder.m_skip_data =
- (p_j2k->m_current_tile_number != p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
+ else {
+ assert( p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec >= 0 );
+ p_j2k->m_specific_param.m_decoder.m_skip_data =
+ (p_j2k->m_current_tile_number != (OPJ_UINT32)p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
+ }
/* Index */
if (p_j2k->cstr_index)
/* UniPG>> */
#ifdef USE_JPWL
/* update markers struct */
- j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2);
+ /*j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2);
+*/
+ assert( 0 && "TODO" );
#endif /* USE_JPWL */
/* <<UniPG */
/*}*/
}
-OPJ_FLOAT32 get_tp_stride (opj_tcp_v2_t * p_tcp)
+static OPJ_FLOAT32 get_tp_stride (opj_tcp_v2_t * p_tcp)
{
return (OPJ_FLOAT32) ((p_tcp->m_nb_tile_parts - 1) * 14);
}
-OPJ_FLOAT32 get_default_stride (opj_tcp_v2_t * p_tcp)
+static OPJ_FLOAT32 get_default_stride (opj_tcp_v2_t * p_tcp)
{
+ (void)p_tcp;
return 0;
}
* @param p_header_size the size of the data contained in the SOD marker.
* @param p_manager the user event manager.
*/
+#if 0
opj_bool j2k_read_eoc_v2 ( opj_j2k_v2_t *p_j2k,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager )
tcd_destroy_v2(l_tcd);
return OPJ_TRUE;
}
+#endif
/**
* Gets the offset of the header.
#ifdef USE_JPWL
/* preparation of JPWL marker segments */
+#if 0
if(cp->epc_on) {
/* encode according to JPWL */
jpwl_encode(p_j2k, p_stream, image);
}
+#endif
+ assert( 0 && "TODO" );
#endif /* USE_JPWL */
return OPJ_TRUE;
return j2k;
}
-opj_j2k_v2_t* j2k_create_compress_v2()
+opj_j2k_v2_t* j2k_create_compress_v2(void)
{
opj_j2k_v2_t *l_j2k = (opj_j2k_v2_t*) opj_malloc(sizeof(opj_j2k_v2_t));
if (!l_j2k) {
}
void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image) {
- int i, j, tileno, numpocs_tile;
+ OPJ_UINT32 i,j;
+ int tileno, numpocs_tile;
opj_cp_t *cp = NULL;
if(!j2k || !parameters || ! image) {
*/
if (parameters->jpwl_epc_on) {
- int i;
+ OPJ_UINT32 i;
/* set JPWL on */
cp->epc_on = OPJ_TRUE;
for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
opj_tcp_t *tcp = &cp->tcps[tileno];
tcp->numlayers = parameters->tcp_numlayers;
- for (j = 0; j < tcp->numlayers; j++) {
+ assert ( tcp->numlayers >= 0 );
+ for (j = 0; j < (OPJ_UINT32)tcp->numlayers; j++) {
if(cp->cinema){
if (cp->fixed_quality) {
tcp->distoratio[j] = parameters->tcp_distoratio[j];
if (parameters->numpocs) {
/* initialisation of POC */
tcp->POC = 1;
- for (i = 0; i < parameters->numpocs; i++) {
+ assert( parameters->numpocs >= 0 );
+ for (i = 0; i < (OPJ_UINT32)parameters->numpocs; i++) {
if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) {
opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
tcp_poc->resno0 = parameters->POC[numpocs_tile].resno0;
tccp->qmfbid = parameters->irreversible ? 0 : 1;
tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
tccp->numgbits = 2;
- if (i == parameters->roi_compno) {
+ assert(parameters->roi_compno >= 0);
+ if (i == (OPJ_UINT32)parameters->roi_compno) {
tccp->roishift = parameters->roi_shift;
} else {
tccp->roishift = 0;
}else{
if (parameters->csty & J2K_CCP_CSTY_PRT) {
int p = 0;
- for (j = tccp->numresolutions - 1; j >= 0; j--) {
+ assert(tccp->numresolutions > 0);
+ for (j = (OPJ_UINT32)(tccp->numresolutions - 1); (int)j >= 0; j--) {
if (p < parameters->res_spec) {
if (parameters->prcw_init[p] < 1) {
}
opj_bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
- int tileno, compno;
+ int tileno;
+ OPJ_UINT32 compno;
opj_cp_t *cp = NULL;
opj_tcd_t *tcd = NULL; /* TCD component */
/* INDEX >> */
j2k->cstr_info = cstr_info;
if (cstr_info) {
- int compno;
+ OPJ_UINT32 compno;
cstr_info->tile = (opj_tile_info_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tile_info_t));
cstr_info->image_w = image->x1 - image->x0;
cstr_info->image_h = image->y1 - image->y0;
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager)
{
+ (void)p_j2k;
+ (void)p_stream;
+ (void)p_manager;
return OPJ_TRUE;
}
/* preconditions*/
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_read_header_procedure);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_read_header_procedure);
/* DEVELOPER CORNER, add your custom procedures */
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_copy_default_tcp_and_create_tcd);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_copy_default_tcp_and_create_tcd);
}
/* preconditions*/
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_build_decoder);
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_decoding_validation);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_build_decoder);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_decoding_validation);
/* DEVELOPER CORNER, add your custom validation procedure */
}
{
/* add here initialization of cp
copy paste of setup_decoder */
+ (void)p_j2k;
+ (void)p_stream;
+ (void)p_manager;
return OPJ_TRUE;
}
{
/* add here initialization of cp
copy paste of setup_encoder */
+ (void)p_j2k;
+ (void)p_stream;
+ (void)p_manager;
return OPJ_TRUE;
}
* l_start_y_dest, l_width_dest, l_height_dest) which will be modified
* by this input area.
* */
- if ( l_x0_dest < l_res->x0 ) {
+ assert( l_res->x0 >= 0);
+ assert( l_res->x1 >= 0);
+ if ( l_x0_dest < (OPJ_UINT32)l_res->x0 ) {
l_start_x_dest = l_res->x0 - l_x0_dest;
l_offset_x0_src = 0;
- if ( l_x1_dest >= l_res->x1 ) {
+ if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) {
l_width_dest = l_width_src;
l_offset_x1_src = 0;
}
l_start_x_dest = 0 ;
l_offset_x0_src = l_x0_dest - l_res->x0;
- if ( l_x1_dest >= l_res->x1 ) {
+ if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) {
l_width_dest = l_width_src - l_offset_x0_src;
l_offset_x1_src = 0;
}
}
}
- if ( l_y0_dest < l_res->y0 ) {
+ if ( l_y0_dest < (OPJ_UINT32)l_res->y0 ) {
l_start_y_dest = l_res->y0 - l_y0_dest;
l_offset_y0_src = 0;
- if ( l_y1_dest >= l_res->y1 ) {
+ if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) {
l_height_dest = l_height_src;
l_offset_y1_src = 0;
}
l_start_y_dest = 0 ;
l_offset_y0_src = l_y0_dest - l_res->y0;
- if ( l_y1_dest >= l_res->y1 ) {
+ if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) {
l_height_dest = l_height_src - l_offset_y0_src;
l_offset_y1_src = 0;
}
/* Check if the positions provided by the user are correct */
/* Left */
- if (p_start_x > l_image->x1 ) {
+ assert(p_start_x > 0 );
+ assert(p_start_y > 0 );
+
+ if ((OPJ_UINT32)p_start_x > l_image->x1 ) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"Left position of the decoded area (region_x0=%d) is outside the image area (Xsiz=%d).\n",
p_start_x, l_image->x1);
return OPJ_FALSE;
}
- else if (p_start_x < l_image->x0){
+ else if ((OPJ_UINT32)p_start_x < l_image->x0){
opj_event_msg_v2(p_manager, EVT_WARNING,
"Left position of the decoded area (region_x0=%d) is outside the image area (XOsiz=%d).\n",
p_start_x, l_image->x0);
}
/* Up */
- if (p_start_y > l_image->y1){
+ if ((OPJ_UINT32)p_start_y > l_image->y1){
opj_event_msg_v2(p_manager, EVT_ERROR,
"Up position of the decoded area (region_y0=%d) is outside the image area (Ysiz=%d).\n",
p_start_y, l_image->y1);
return OPJ_FALSE;
}
- else if (p_start_y < l_image->y0){
+ else if ((OPJ_UINT32)p_start_y < l_image->y0){
opj_event_msg_v2(p_manager, EVT_WARNING,
"Up position of the decoded area (region_y0=%d) is outside the image area (YOsiz=%d).\n",
p_start_y, l_image->y0);
}
/* Right */
- if (p_end_x < l_image->x0) {
+ assert((OPJ_UINT32)p_end_x > 0);
+ assert((OPJ_UINT32)p_end_y > 0);
+ if ((OPJ_UINT32)p_end_x < l_image->x0) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"Right position of the decoded area (region_x1=%d) is outside the image area (XOsiz=%d).\n",
p_end_x, l_image->x0);
return OPJ_FALSE;
}
- else if (p_end_x > l_image->x1) {
+ else if ((OPJ_UINT32)p_end_x > l_image->x1) {
opj_event_msg_v2(p_manager, EVT_WARNING,
"Right position of the decoded area (region_x1=%d) is outside the image area (Xsiz=%d).\n",
p_end_x, l_image->x1);
}
/* Bottom */
- if (p_end_y < l_image->y0) {
+ if ((OPJ_UINT32)p_end_y < l_image->y0) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"Bottom position of the decoded area (region_y1=%d) is outside the image area (YOsiz=%d).\n",
p_end_y, l_image->y0);
return OPJ_FALSE;
}
- if (p_end_y > l_image->y1){
+ if ((OPJ_UINT32)p_end_y > l_image->y1){
opj_event_msg_v2(p_manager, EVT_WARNING,
"Bottom position of the decoded area (region_y1=%d) is outside the image area (Ysiz=%d).\n",
p_end_y, l_image->y1);
*
* @return a handle to a J2K decompressor if successful, NULL otherwise.
*/
-opj_j2k_v2_t* j2k_create_decompress_v2()
+opj_j2k_v2_t* j2k_create_decompress_v2(void)
{
opj_j2k_v2_t *l_j2k = (opj_j2k_v2_t*) opj_malloc(sizeof(opj_j2k_v2_t));
if (!l_j2k) {
if (l_cp->correct) {
/* if JPWL is on, we check whether there are too many subbands */
- if ((l_num_band < 0) || (l_num_band >= J2K_MAXBANDS)) {
+ if (/*(l_num_band < 0) ||*/ (l_num_band >= J2K_MAXBANDS)) {
opj_event_msg_v2(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
"JPWL: bad number of subbands in Sqcx (%d)\n",
l_num_band);
fprintf(out_stream, "Codestream index from main header: {\n");
- fprintf(out_stream, "\t Main header start position=%" OPJ_OFF_F "d\n"
- "\t Main header end position=%" OPJ_OFF_F "d\n",
+ fprintf(out_stream, "\t Main header start position=%" PRIi64 "\n"
+ "\t Main header end position=%" PRIi64 "\n",
cstr_index->main_head_start, cstr_index->main_head_end);
fprintf(out_stream, "\t Marker list: {\n");
if (cstr_index->marker){
for (it_marker=0; it_marker < cstr_index->marknum ; it_marker++){
- fprintf(out_stream, "\t\t type=%#x, pos=%" OPJ_OFF_F "d, len=%d\n",
+ fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
cstr_index->marker[it_marker].type,
cstr_index->marker[it_marker].pos,
cstr_index->marker[it_marker].len );
if (cstr_index->tile_index[it_tile].tp_index){
for (it_tile_part =0; it_tile_part < nb_of_tile_part; it_tile_part++){
- fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" OPJ_OFF_F "d, end_header=%" OPJ_OFF_F "d, end_pos=%" OPJ_OFF_F "d.\n",
+ fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" PRIi64 ", end_header=%" PRIi64 ", end_pos=%" PRIi64 ".\n",
it_tile_part,
cstr_index->tile_index[it_tile].tp_index[it_tile_part].start_pos,
cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_header,
if (cstr_index->tile_index[it_tile].marker){
for (it_marker=0; it_marker < cstr_index->tile_index[it_tile].marknum ; it_marker++){
- fprintf(out_stream, "\t\t type=%#x, pos=%" OPJ_OFF_F "d, len=%d\n",
+ fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
cstr_index->tile_index[it_tile].marker[it_marker].type,
cstr_index->tile_index[it_tile].marker[it_marker].pos,
cstr_index->tile_index[it_tile].marker[it_marker].len );
for (compno = 0; compno < numcomps; compno++) {
opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
- OPJ_INT32 resno, bandno, numbands;
+ OPJ_UINT32 resno;
+ OPJ_INT32 bandno, numbands;
/* coding style*/
fprintf(out_stream, "\t\t comp %d {\n", compno);
fprintf(out_stream, "%s numcomps=%d\n", tab, img_header->numcomps);
if (img_header->comps){
- int compno;
+ OPJ_UINT32 compno;
for (compno = 0; compno < img_header->numcomps; compno++) {
fprintf(out_stream, "%s\t component %d {\n", tab, compno);
j2k_dump_image_comp_header(&(img_header->comps[compno]), dev_dump_flag, out_stream);
return l_cstr_index;
}
-opj_bool j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k)
+static opj_bool j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k)
{
OPJ_UINT32 it_tile=0;
/**
* Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
*/
-void j2k_setup_decoding (opj_j2k_v2_t *p_j2k)
+static void j2k_setup_decoding (opj_j2k_v2_t *p_j2k)
{
/* preconditions*/
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_decode_tiles);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_decode_tiles);
/* DEVELOPER CORNER, add your custom procedures */
}
/*
* Read and decode one tile.
*/
-opj_bool j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k,
+static opj_bool j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k,
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager)
{
/**
* Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures.
*/
-void j2k_setup_decoding_tile (opj_j2k_v2_t *p_j2k)
+static void j2k_setup_decoding_tile (opj_j2k_v2_t *p_j2k)
{
/* preconditions*/
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_decode_one_tile);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_decode_one_tile);
/* DEVELOPER CORNER, add your custom procedures */
}
return OPJ_FALSE;
}
- if ( (tile_index < 0) && (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th) ){
+ if ( /*(tile_index < 0) &&*/ (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th) ){
opj_event_msg_v2(p_manager, EVT_ERROR, "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index, (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1);
return OPJ_FALSE;
}
opj_image_t * p_image,
opj_event_mgr_t * p_manager)
{
- // preconditions
+ /* preconditions */
assert(p_j2k != 00);
assert(p_stream != 00);
assert(p_manager != 00);
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager )
{
+ (void)p_stream;
if (p_tile_index != p_j2k->m_current_tile_number) {
opj_event_msg_v2(p_manager, EVT_ERROR, "The given tile index does not match." );
return OPJ_FALSE;
assert(p_j2k != 00);
/* DEVELOPER CORNER, insert your custom procedures */
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_eoc );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_eoc );
if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_updated_tlm);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_updated_tlm);
}
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_epc );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_end_encoding );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_destroy_header_memory);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_epc );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_end_encoding );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_destroy_header_memory);
}
/**
/* preconditions */
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_build_encoder);
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_encoding_validation);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_build_encoder);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_encoding_validation);
/* DEVELOPER CORNER, add your custom validation procedure */
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_mct_validation);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_mct_validation);
}
/* preconditions */
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_init_info );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_soc_v2 );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_siz_v2 );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_cod_v2 );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_qcd_v2 );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_init_info );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_soc_v2 );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_siz_v2 );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_cod_v2 );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_qcd_v2 );
if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_image_components );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_tlm );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_image_components );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_tlm );
if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == CINEMA4K_24) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_poc );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_poc );
}
}
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_regions);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_regions);
if (p_j2k->m_cp.comment != 00) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_com);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_com);
}
/* DEVELOPER CORNER, insert your custom procedures */
if (p_j2k->m_cp.rsiz & MCT) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_mct_data_group );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_mct_data_group );
}
/* End of Developer Corner */
if (p_j2k->cstr_index) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_get_end_header );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_get_end_header );
}
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_create_tcd);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_update_rates);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_create_tcd);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_update_rates);
}
assert(p_j2k != 00);
assert(p_manager != 00);
assert(p_stream != 00);
+ (void)l_cstr_info;
/* TODO mergeV2: check this part which use cstr_info */
/*l_cstr_info = p_j2k->cstr_info;
projects / openjpeg.git / blobdiff