server_record_t * init_JPIPserver( int tcp_auxport, int udp_auxport)
{
- server_record_t *record = (server_record_t *)malloc( sizeof(server_record_t));
+ server_record_t *record = (server_record_t *)opj_malloc( sizeof(server_record_t));
record->sessionlist = gene_sessionlist();
record->targetlist = gene_targetlist();
delete_targetlist( &(*rec)->targetlist);
close_aux_transport( (*rec)->auxtrans);
- free( *rec);
+ opj_free( *rec);
}
QR_t * parse_querystring( const char *query_string)
{
QR_t *qr;
- qr = (QR_t *)malloc( sizeof(QR_t));
+ qr = (QR_t *)opj_malloc( sizeof(QR_t));
qr->query = parse_query( query_string);
qr->msgqueue = NULL;
fprintf( FCGI_stderr, "Error: failed to write jpipstream\n");
}
- free( jpipstream);
+ opj_free( jpipstream);
return;
}
(void)rec; /* unused */
delete_query( &((*qr)->query));
delete_msgqueue( &((*qr)->msgqueue));
- free( *qr);
+ opj_free( *qr);
}
dec_server_record_t * init_dec_server( int port)
{
- dec_server_record_t *record = (dec_server_record_t *)malloc( sizeof(dec_server_record_t));
+ dec_server_record_t *record = (dec_server_record_t *)opj_malloc( sizeof(dec_server_record_t));
record->cachelist = gene_cachelist();
record->jpipstream = NULL;
void terminate_dec_server( dec_server_record_t **rec)
{
delete_cachelist( &(*rec)->cachelist);
- free( (*rec)->jpipstream);
+ opj_free( (*rec)->jpipstream);
if( (*rec)->msgqueue)
delete_msgqueue( &((*rec)->msgqueue));
if( close_socket( (*rec)->listening_socket) != 0)
perror("close");
- free( *rec);
+ opj_free( *rec);
}
client_t accept_connection( dec_server_record_t *rec)
{
jpip_dec_param_t *dec;
- dec = (jpip_dec_param_t *)calloc( 1, sizeof(jpip_dec_param_t));
+ dec = (jpip_dec_param_t *)opj_calloc( 1, sizeof(jpip_dec_param_t));
dec->msgqueue = gene_msgqueue( true, NULL);
if(!(dec->jpiplen = (Byte8_t)get_filesize(infd)))
return false;
- dec->jpipstream = (Byte_t *)malloc( dec->jpiplen);
+ dec->jpipstream = (Byte_t *)opj_malloc( dec->jpiplen);
if( read( infd, dec->jpipstream, dec->jpiplen) != (int)dec->jpiplen){
fprintf( stderr, "file reading error\n");
- free( dec->jpipstream);
+ opj_free( dec->jpipstream);
return false;
}
void destroy_jpipdecoder( jpip_dec_param_t **dec)
{
- free( (*dec)->jpipstream);
+ opj_free( (*dec)->jpipstream);
delete_msgqueue( &(*dec)->msgqueue);
if( (*dec)->metadatalist){
delete_metadatalist( &(*dec)->metadatalist);
- free( (*dec)->ihdrbox);
+ opj_free( (*dec)->ihdrbox);
}
- free( (*dec)->jp2kstream);
- free( *dec);
+ opj_free( (*dec)->jp2kstream);
+ opj_free( *dec);
}
index_t * get_index_from_JP2file( int fd)
return NULL;
}
- data = (char *)malloc( 12); /* size of header*/
+ data = (char *)opj_malloc( 12); /* size of header*/
if( read( fd, data, 12) != 12){
- free( data);
+ opj_free( data);
fprintf( stderr, "Error: File broken (read error)\n");
return NULL;
}
if( *data || *(data + 1) || *(data + 2) ||
*(data + 3) != 12 || strncmp (data + 4, "jP \r\n\x87\n", 8)){
- free( data);
+ opj_free( data);
fprintf( stderr, "Error: No JPEG 2000 Signature box in this file\n");
return NULL;
}
- free( data);
+ opj_free( data);
return parse_jp2file( fd);
}
print_index( *index);
}
+/* ---------------------------------------------------------------------- */
+/* COMPRESSION FUNCTIONS*/
+typedef struct opj_decompression
+{
+ /** Main header reading function handler*/
+ opj_bool (*opj_read_header) ( struct opj_stream_private * cio,
+ void * p_codec,
+ opj_image_t **p_image,
+ struct opj_event_mgr * p_manager);
+ /** Decoding function */
+ opj_bool (*opj_decode) ( void * p_codec,
+ struct opj_stream_private *p_cio,
+ opj_image_t *p_image,
+ struct opj_event_mgr * p_manager);
+ /** FIXME DOC */
+ opj_bool (*opj_read_tile_header)( void * p_codec,
+ 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_should_go_on,
+ struct opj_stream_private *p_cio,
+ struct opj_event_mgr * p_manager);
+ /** FIXME DOC */
+ opj_bool (*opj_decode_tile_data)( void * p_codec,
+ OPJ_UINT32 p_tile_index,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 p_data_size,
+ struct opj_stream_private *p_cio,
+ struct opj_event_mgr * p_manager);
+ /** Reading function used after codestream if necessary */
+ opj_bool (* opj_end_decompress) ( void *p_codec,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager);
+ /** Codec destroy function handler*/
+ void (*opj_destroy) (void * p_codec);
+ /** Setup decoder function handler */
+ void (*opj_setup_decoder) (void * p_codec, opj_dparameters_t * p_param);
+ /** Set decode area function handler */
+ opj_bool (*opj_set_decode_area) ( void * p_codec,
+ opj_image_t* p_image,
+ OPJ_INT32 p_start_x, OPJ_INT32 p_end_x,
+ OPJ_INT32 p_start_y, OPJ_INT32 p_end_y,
+ struct opj_event_mgr * p_manager);
+
+ /** Get tile function */
+ opj_bool (*opj_get_decoded_tile) ( void *p_codec,
+ opj_stream_private_t *p_cio,
+ opj_image_t *p_image,
+ struct opj_event_mgr * p_manager,
+ OPJ_UINT32 tile_index);
+
+ /** Set the decoded resolution factor */
+ opj_bool (*opj_set_decoded_resolution_factor) ( void * p_codec,
+ OPJ_UINT32 res_factor,
+ opj_event_mgr_t * p_manager);
+
+}opj_decompression_t;
+
+typedef struct opj_compression
+{
+ opj_bool (* opj_start_compress) ( void *p_codec,
+ struct opj_stream_private *cio,
+ struct opj_image * p_image,
+ struct opj_event_mgr * p_manager);
+
+ opj_bool (* opj_encode) ( void * p_codec,
+ struct opj_stream_private *p_cio,
+ struct opj_event_mgr * p_manager);
+
+ opj_bool (* opj_write_tile) ( void * p_codec,
+ OPJ_UINT32 p_tile_index,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 p_data_size,
+ struct opj_stream_private * p_cio,
+ struct opj_event_mgr * p_manager);
+
+ opj_bool (* opj_end_compress) ( void * p_codec,
+ struct opj_stream_private *p_cio,
+ struct opj_event_mgr * p_manager);
+
+ void (* opj_destroy) (void * p_codec);
+
+ void (*opj_setup_encoder) ( void * p_codec,
+ opj_cparameters_t * p_param,
+ struct opj_image * p_image,
+ struct opj_event_mgr * p_manager);
+
+}opj_compression_t;
+
+typedef struct opj_codec_private
+{
+ /** FIXME DOC */
+ union
+ {
+ opj_decompression_t m_decompression;
+ opj_compression_t m_compression;
+ } m_codec_data;
+ /** FIXME DOC*/
+ void * m_codec;
+ /** Event handler */
+ opj_event_mgr_t m_event_mgr;
+ /** Flag to indicate if the codec is used to decode or encode*/
+ opj_bool is_decompressor;
+ void (*opj_dump_codec) (void * p_codec, OPJ_INT32 info_flag, FILE* output_stream);
+ opj_codestream_info_v2_t* (*opj_get_codec_info)(void* p_codec);
+ opj_codestream_index_t* (*opj_get_codec_index)(void* p_codec);
+}
+opj_codec_private_t;
+
+static 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];
+
+ /* preconditions */
+ assert(cio != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ /* write box length */
+ opj_write_bytes(l_signature_data,12,4);
+ /* writes box type */
+ opj_write_bytes(l_signature_data+4,JP2_JP,4);
+ /* writes magic number*/
+ opj_write_bytes(l_signature_data+8,0x0d0a870a,4);
+
+ if (opj_stream_write_data(cio,l_signature_data,12,p_manager) != 12) {
+ return OPJ_FALSE;
+ }
+
+ return OPJ_TRUE;
+}
+
+static opj_bool opj_jp2_write_ftyp(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager )
+{
+ unsigned int i;
+ unsigned int l_ftyp_size = 16 + 4 * jp2->numcl;
+ unsigned char * l_ftyp_data, * l_current_data_ptr;
+ opj_bool l_result;
+
+ /* preconditions */
+ assert(cio != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ l_ftyp_data = (unsigned char *) opj_malloc(l_ftyp_size);
+
+ if (l_ftyp_data == 00) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to handle ftyp data\n");
+ return OPJ_FALSE;
+ }
+
+ memset(l_ftyp_data,0,l_ftyp_size);
+
+ l_current_data_ptr = l_ftyp_data;
+
+ opj_write_bytes(l_current_data_ptr, l_ftyp_size,4); /* box size */
+ l_current_data_ptr += 4;
+
+ opj_write_bytes(l_current_data_ptr, JP2_FTYP,4); /* FTYP */
+ l_current_data_ptr += 4;
+
+ opj_write_bytes(l_current_data_ptr, jp2->brand,4); /* BR */
+ l_current_data_ptr += 4;
+
+ opj_write_bytes(l_current_data_ptr, jp2->minversion,4); /* MinV */
+ l_current_data_ptr += 4;
+
+ for (i = 0; i < jp2->numcl; i++) {
+ opj_write_bytes(l_current_data_ptr, jp2->cl[i],4); /* CL */
+ }
+
+ l_result = (opj_stream_write_data(cio,l_ftyp_data,l_ftyp_size,p_manager) == l_ftyp_size);
+ if (! l_result)
+ {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error while writing ftyp data to stream\n");
+ }
+
+ opj_free(l_ftyp_data);
+
+ return l_result;
+}
+
+static 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;
+
+ /* preconditions */
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+
+ /* JPEG2000 codec validation */
+ /*TODO*/
+
+ /* STATE checking */
+ /* make sure the state is at 0 */
+ l_is_valid &= (jp2->jp2_state == JP2_STATE_NONE);
+
+ /* make sure not reading a jp2h ???? WEIRD */
+ l_is_valid &= (jp2->jp2_img_state == JP2_IMG_STATE_NONE);
+
+ /* POINTER validation */
+ /* make sure a j2k codec is present */
+ l_is_valid &= (jp2->j2k != 00);
+
+ /* make sure a procedure list is present */
+ l_is_valid &= (jp2->m_procedure_list != 00);
+
+ /* make sure a validation list is present */
+ l_is_valid &= (jp2->m_validation_list != 00);
+
+ /* PARAMETER VALIDATION */
+ /* number of components */
+ l_is_valid &= (jp2->numcl > 0);
+ /* width */
+ l_is_valid &= (jp2->h > 0);
+ /* height */
+ l_is_valid &= (jp2->w > 0);
+ /* precision */
+ for (i = 0; i < jp2->numcomps; ++i) {
+ l_is_valid &= (jp2->comps[i].bpcc > 0);
+ }
+
+ /* METH */
+ l_is_valid &= ((jp2->meth > 0) && (jp2->meth < 3));
+
+ /* stream validation */
+ /* back and forth is needed */
+ l_is_valid &= opj_stream_has_seek(cio);
+
+ return l_is_valid;
+}
+
+static 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)opj_jp2_default_validation);
+ /* DEVELOPER CORNER, add your custom validation procedure */
+}
+
+static 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);
+ assert(stream != 00);
+ assert(p_manager != 00);
+
+ jp2->j2k_codestream_offset = opj_stream_tell(stream);
+
+ if (opj_stream_skip(stream,8,p_manager) != 8) {
+ return OPJ_FALSE;
+ }
+
+ return OPJ_TRUE;
+}
+
+static opj_bool opj_jpip_skip_iptr( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *stream,
+ opj_event_mgr_t * p_manager )
+{
+ /* preconditions */
+ assert(jp2 != 00);
+ assert(stream != 00);
+ assert(p_manager != 00);
+
+ jp2->jpip_iptr_offset = opj_stream_tell(stream);
+
+ if (opj_stream_skip(stream,24,p_manager) != 24) {
+ return OPJ_FALSE;
+ }
+
+ return OPJ_TRUE;
+}
+
+void opj_jpip_setup_header_writing (opj_jp2_v2_t *jp2)
+{
+ /* preconditions */
+ assert(jp2 != 00);
+
+ 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_jpip_skip_iptr );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_skip_jp2c );
+
+ /* DEVELOPER CORNER, insert your custom procedures */
+
+}
+
+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;
+ OPJ_UINT32 l_nb_proc, i;
+
+ /* preconditions */
+ assert(p_procedure_list != 00);
+ assert(jp2 != 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,stream,p_manager);
+ ++l_procedure;
+ }
+
+ /* and clear the procedure list at the end. */
+ opj_procedure_list_clear(p_procedure_list);
+ return l_result;
+}
+
+opj_bool opj_jpip_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(stream != 00);
+ assert(p_manager != 00);
+
+ /* customization of the validation */
+ opj_jp2_setup_encoding_validation (jp2);
+
+ /* validation of the parameters codec */
+ if (! opj_jp2_exec(jp2,jp2->m_validation_list,stream,p_manager)) {
+ return OPJ_FALSE;
+ }
+
+ /* customization of the encoding */
+ opj_jpip_setup_header_writing(jp2);
+
+ /* write header */
+ if (! opj_jp2_exec (jp2,jp2->m_procedure_list,stream,p_manager)) {
+ return OPJ_FALSE;
+ }
+
+ return opj_j2k_start_compress(jp2->j2k,stream,p_image,p_manager);
+}
+
+static opj_bool opj_jpip_write_iptr(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager )
+{
+ OPJ_OFF_T j2k_codestream_exit;
+ OPJ_BYTE l_data_header [24];
+
+ /* preconditions */
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+ assert(opj_stream_has_seek(cio));
+
+ j2k_codestream_exit = opj_stream_tell(cio);
+ opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
+ opj_write_bytes(l_data_header + 4,JPIP_IPTR,4); /* IPTR */
+#if 0
+ opj_write_bytes(l_data_header + 4 + 4, 0, 8); /* offset */
+ opj_write_bytes(l_data_header + 8 + 8, 0, 8); /* length */
+#else
+ opj_write_double(l_data_header + 4 + 4, 0); /* offset */
+ opj_write_double(l_data_header + 8 + 8, 0); /* length */
+#endif
+
+ if (! opj_stream_seek(cio,jp2->jpip_iptr_offset,p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ return OPJ_TRUE;
+}
+
+static opj_bool opj_jpip_write_fidx(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager )
+{
+ OPJ_OFF_T j2k_codestream_exit;
+ OPJ_BYTE l_data_header [24];
+
+ /* preconditions */
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+ assert(opj_stream_has_seek(cio));
+
+ opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
+ opj_write_bytes(l_data_header + 4,JPIP_FIDX,4); /* IPTR */
+ opj_write_double(l_data_header + 4 + 4, 0); /* offset */
+ opj_write_double(l_data_header + 8 + 8, 0); /* length */
+
+ if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ j2k_codestream_exit = opj_stream_tell(cio);
+ if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ return OPJ_TRUE;
+}
+
+static opj_bool opj_jpip_write_cidx(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager )
+{
+ OPJ_OFF_T j2k_codestream_exit;
+ OPJ_BYTE l_data_header [24];
+
+ /* preconditions */
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+ assert(opj_stream_has_seek(cio));
+
+ j2k_codestream_exit = opj_stream_tell(cio);
+ opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
+ opj_write_bytes(l_data_header + 4,JPIP_CIDX,4); /* IPTR */
+#if 0
+ opj_write_bytes(l_data_header + 4 + 4, 0, 8); /* offset */
+ opj_write_bytes(l_data_header + 8 + 8, 0, 8); /* length */
+#else
+ opj_write_double(l_data_header + 4 + 4, 0); /* offset */
+ opj_write_double(l_data_header + 8 + 8, 0); /* length */
+#endif
+
+ if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ j2k_codestream_exit = opj_stream_tell(cio);
+ if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ return OPJ_TRUE;
+}
+
+static void write_prxy_v2( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager )
+{
+ OPJ_BYTE l_data_header [8];
+ int len, lenp;
+
+#if 0
+ lenp = cio_tell( cio);
+ cio_skip( cio, 4); /* L [at the end] */
+ cio_write( cio, JPIP_PRXY, 4); /* IPTR */
+#else
+ lenp = opj_stream_tell(cio);
+ opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
+ opj_write_bytes(l_data_header,JPIP_PRXY,4); /* IPTR */
+ opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+
+#if 0
+ cio_write( cio, offset_jp2c, 8); /* OOFF */
+ cio_write( cio, length_jp2c, 4); /* OBH part 1 */
+ cio_write( cio, JP2_JP2C, 4); /* OBH part 2 */
+#else
+ opj_write_bytes( l_data_header, offset_jp2c, 8); /* OOFF */
+ opj_stream_write_data(cio,l_data_header,8,p_manager);
+ opj_write_bytes( l_data_header, length_jp2c, 4); /* OBH part 1 */
+ opj_write_bytes( l_data_header+4, JP2_JP2C, 4); /* OBH part 2 */
+ opj_stream_write_data(cio,l_data_header,8,p_manager);
+#endif
+
+#if 0
+ cio_write( cio, 1,1); /* NI */
+#else
+ opj_write_bytes( l_data_header, 1, 1);/* NI */
+ opj_stream_write_data(cio,l_data_header,1,p_manager);
+#endif
+
+#if 0
+ cio_write( cio, offset_idx, 8); /* IOFF */
+ cio_write( cio, length_idx, 4); /* IBH part 1 */
+ cio_write( cio, JPIP_CIDX, 4); /* IBH part 2 */
+#else
+ opj_write_bytes( l_data_header, offset_idx, 8); /* IOFF */
+ opj_stream_write_data(cio,l_data_header,8,p_manager);
+ opj_write_bytes( l_data_header, length_idx, 4); /* IBH part 1 */
+ opj_write_bytes( l_data_header+4, JPIP_CIDX, 4); /* IBH part 2 */
+ opj_stream_write_data(cio,l_data_header,8,p_manager);
+#endif
+
+#if 0
+ len = cio_tell( cio)-lenp;
+ cio_seek( cio, lenp);
+ cio_write( cio, len, 4); /* L */
+ cio_seek( cio, lenp+len);
+#else
+ len = opj_stream_tell(cio)-lenp;
+ opj_stream_skip(cio, lenp, p_manager);
+ opj_write_bytes(l_data_header,len,4);/* L */
+ opj_stream_write_data(cio,l_data_header,4,p_manager);
+ opj_stream_seek(cio, lenp+len,p_manager);
+#endif
+}
+
+
+static int write_fidx_v2( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager )
+{
+ OPJ_BYTE l_data_header [4];
+ int len, lenp;
+
+#if 0
+ lenp = cio_tell( cio);
+ cio_skip( cio, 4); /* L [at the end] */
+ cio_write( cio, JPIP_FIDX, 4); /* IPTR */
+#else
+ lenp = opj_stream_tell(cio);
+ opj_stream_skip(cio, 4, p_manager);
+ opj_write_bytes(l_data_header,JPIP_FIDX,4); /* FIDX */
+ opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+
+ write_prxy_v2( offset_jp2c, length_jp2c, offset_idx, length_idx, cio,p_manager);
+
+#if 0
+ len = cio_tell( cio)-lenp;
+ cio_seek( cio, lenp);
+ cio_write( cio, len, 4); /* L */
+ cio_seek( cio, lenp+len);
+#else
+ len = opj_stream_tell(cio)-lenp;
+ opj_stream_skip(cio, lenp, p_manager);
+ opj_write_bytes(l_data_header,len,4);/* L */
+ opj_stream_write_data(cio,l_data_header,4,p_manager);
+ opj_stream_seek(cio, lenp+len,p_manager);
+#endif
+
+ return len;
+}
+
+static opj_bool opj_jpip_write_jp2c(opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager )
+{
+ OPJ_OFF_T j2k_codestream_exit;
+ OPJ_BYTE l_data_header [8];
+ OPJ_UINT32 len_jp2c;
+ int len_cidx;
+ int len_fidx;
+ int pos_jp2c;
+ int pos_fidx;
+ int pos_cidx;
+
+ /* preconditions */
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+ assert(opj_stream_has_seek(cio));
+
+ j2k_codestream_exit = opj_stream_tell(cio);
+ len_jp2c = j2k_codestream_exit - jp2->j2k_codestream_offset;
+ pos_jp2c = jp2->j2k_codestream_offset;
+ opj_write_bytes(l_data_header, len_jp2c, 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)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ if (opj_stream_write_data(cio,l_data_header,8,p_manager) != 8) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return OPJ_FALSE;
+ }
+
+ /* CIDX */
+ pos_cidx = opj_stream_tell( cio);
+ len_cidx = write_cidx_v2( pos_jp2c+8, cio, jp2_get_cstr_info(jp2), len_jp2c-8);
+
+ /* FIDX */
+ pos_fidx = opj_stream_tell( cio);
+ len_fidx = write_fidx_v2( pos_jp2c, len_jp2c, pos_cidx, len_cidx, cio, p_manager);
+
+ return OPJ_TRUE;
+}
+
+static void opj_jp2_setup_end_header_writing (opj_jp2_v2_t *jp2)
+{
+ /* preconditions */
+ assert(jp2 != 00);
+
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_iptr );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_jp2c );
+#if 0
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_cidx );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_fidx );
+#endif
+ /* DEVELOPER CORNER, add your custom procedures */
+}
+
+opj_bool opj_jpip_end_compress( opj_jp2_v2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
+{
+ /* preconditions */
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+
+ /* customization of the end encoding */
+ opj_jp2_setup_end_header_writing(jp2);
+
+ if (! opj_j2k_end_compress(jp2->j2k,cio,p_manager)) {
+ return OPJ_FALSE;
+ }
+
+ /* write header */
+ return opj_jp2_exec(jp2,jp2->m_procedure_list,cio,p_manager);
+}
+
+
+opj_codec_t* OPJ_CALLCONV opj_jpip_create_compress(OPJ_CODEC_FORMAT p_format)
+{
+ opj_codec_private_t *l_codec = 00;
+
+ l_codec = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));
+ if (!l_codec) {
+ return 00;
+ }
+ memset(l_codec, 0, sizeof(opj_codec_private_t));
+
+ l_codec->is_decompressor = 0;
+
+ switch(p_format) {
+ case CODEC_JP2:
+ /* get a JP2 decoder handle */
+ l_codec->m_codec_data.m_compression.opj_encode = (opj_bool (*) (void *,
+ struct opj_stream_private *,
+ struct opj_event_mgr * )) opj_jp2_encode;
+
+ l_codec->m_codec_data.m_compression.opj_end_compress = (opj_bool (*) ( void *,
+ struct opj_stream_private *,
+ struct opj_event_mgr *)) opj_jpip_end_compress;
+
+ l_codec->m_codec_data.m_compression.opj_start_compress = (opj_bool (*) (void *,
+ struct opj_stream_private *,
+ struct opj_image * ,
+ struct opj_event_mgr *)) opj_jpip_start_compress;
+
+ l_codec->m_codec_data.m_compression.opj_write_tile = (opj_bool (*) (void *,
+ OPJ_UINT32,
+ OPJ_BYTE*,
+ OPJ_UINT32,
+ struct opj_stream_private *,
+ struct opj_event_mgr *)) opj_jp2_write_tile;
+
+ l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_jp2_destroy;
+
+ l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) ( void *,
+ opj_cparameters_t *,
+ struct opj_image *,
+ struct opj_event_mgr * )) opj_jp2_setup_encoder;
+
+ l_codec->m_codec = opj_jp2_create(OPJ_FALSE);
+ if (! l_codec->m_codec) {
+ opj_free(l_codec);
+ return 00;
+ }
+
+ break;
+
+ case CODEC_UNKNOWN:
+ case CODEC_JPT:
+ default:
+ opj_free(l_codec);
+ return 00;
+ }
+
+ opj_set_default_event_handler(&(l_codec->m_event_mgr));
+ return (opj_codec_t*) l_codec;
+}
+
#endif /*SERVER*/
projects / openjpeg.git / blobdiff