src/lib/openjpip/openjpip.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   5  * Copyright (c) 2002-2011, Professor Benoit Macq
   6  * Copyright (c) 2010-2011, Kaori Hagihara
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <stdlib.h>
  32 #include "openjpip.h"
  33 #include "jpip_parser.h"
  34 #include "channel_manager.h"
  35 #include "byte_manager.h"
  36 #ifdef _WIN32
  37 #include <io.h>
  38 #else
  39 #include <unistd.h>
  40 #endif
  41
  42 #ifdef SERVER
  43 #include "auxtrans_manager.h"
  44 #endif
  45
  46 #include <stdio.h>
  47 #include "dec_clientmsg_handler.h"
  48 #include "jpipstream_manager.h"
  49
  50 #include <string.h>
  51 #include <sys/types.h>
  52 #include <sys/stat.h>
  53 #include <fcntl.h>
  54 #include "jp2k_encoder.h"
  55
  56 #ifdef SERVER
  57
  58 server_record_t * init_JPIPserver( int tcp_auxport, int udp_auxport)
  59 {
  60   server_record_t *record = (server_record_t *)opj_malloc( sizeof(server_record_t));
  61
  62   record->sessionlist = gene_sessionlist();
  63   record->targetlist  = gene_targetlist();
  64   record->auxtrans = init_aux_transport( tcp_auxport, udp_auxport);
  65
  66   return record;
  67 }
  68
  69 void terminate_JPIPserver( server_record_t **rec)
  70 {
  71   delete_sessionlist( &(*rec)->sessionlist);
  72   delete_targetlist( &(*rec)->targetlist);
  73   close_aux_transport( (*rec)->auxtrans);
  74
  75   opj_free( *rec);
  76 }
  77
  78 QR_t * parse_querystring( const char *query_string)
  79 {
  80   QR_t *qr;
  81
  82   qr = (QR_t *)opj_malloc( sizeof(QR_t));
  83
  84   qr->query = parse_query( query_string);
  85   qr->msgqueue = NULL;
  86   qr->channel = NULL;
  87
  88   return qr;
  89 }
  90
  91 bool process_JPIPrequest( server_record_t *rec, QR_t *qr)
  92 {
  93   target_param_t *target = NULL;
  94   session_param_t *cursession = NULL;
  95   channel_param_t *curchannel = NULL;
  96
  97   if( qr->query->target || qr->query->tid){
  98     if( !identify_target( *(qr->query), rec->targetlist, &target))
  99       return false;
 100   }
 101
 102   if( qr->query->cid){
 103     if( !associate_channel( *(qr->query), rec->sessionlist, &cursession, &curchannel))
 104       return false;
 105     qr->channel = curchannel;
 106   }
 107
 108   if( qr->query->cnew != non){
 109     if( !open_channel( *(qr->query), rec->sessionlist, rec->auxtrans, target, &cursession, &curchannel))
 110       return false;
 111     qr->channel = curchannel;
 112   }
 113
 114   if( qr->query->cclose)
 115     if( !close_channel( *(qr->query), rec->sessionlist, &cursession, &curchannel))
 116       return false;
 117
 118   if( (qr->query->fx > 0 && qr->query->fy > 0) || qr->query->box_type[0][0] != 0 || qr->query->len > 0)
 119     if( !gene_JPIPstream( *(qr->query), target, cursession, curchannel, &qr->msgqueue))
 120       return false;
 121
 122   return true;
 123 }
 124
 125 void add_EORmsg( int fd, QR_t *qr);
 126
 127 void send_responsedata( server_record_t *rec, QR_t *qr)
 128 {
 129   int fd;
 130   const char tmpfname[] = "tmpjpipstream.jpp";
 131   Byte_t *jpipstream;
 132   Byte8_t len_of_jpipstream;
 133
 134   if( (fd = open( tmpfname, O_RDWR|O_CREAT|O_EXCL, S_IRWXU)) == -1){
 135     fprintf( FCGI_stderr, "file open error %s", tmpfname);
 136     fprintf( FCGI_stdout, "Status: 503\r\n");
 137     fprintf( FCGI_stdout, "Reason: Implementation failed\r\n");
 138     return;
 139   }
 140
 141   recons_stream_from_msgqueue( qr->msgqueue, fd);
 142
 143   add_EORmsg( fd, qr); /* needed at least for tcp and udp */
 144
 145   len_of_jpipstream = (Byte8_t)get_filesize( fd);
 146   jpipstream = fetch_bytes( fd, 0, len_of_jpipstream);
 147
 148   close( fd);
 149   remove( tmpfname);
 150
 151   fprintf( FCGI_stdout, "\r\n");
 152
 153   if( len_of_jpipstream){
 154
 155     if( qr->channel)
 156       if( qr->channel->aux == tcp || qr->channel->aux == udp){
 157         send_responsedata_on_aux( qr->channel->aux==tcp, rec->auxtrans, qr->channel->cid, jpipstream, len_of_jpipstream, 1000); /* 1KB per frame*/
 158         return;
 159       }
 160
 161     if( fwrite( jpipstream, len_of_jpipstream, 1, FCGI_stdout) != 1)
 162       fprintf( FCGI_stderr, "Error: failed to write jpipstream\n");
 163   }
 164
 165   opj_free( jpipstream);
 166
 167   return;
 168 }
 169
 170 void add_EORmsg( int fd, QR_t *qr)
 171 {
 172   unsigned char EOR[3];
 173
 174   if( qr->channel){
 175     EOR[0] = 0x00;
 176     EOR[1] = is_allsent( *(qr->channel->cachemodel)) ? 0x01 : 0x02;
 177     EOR[2] = 0x00;
 178     if( write( fd, EOR, 3) != 3)
 179       fprintf( FCGI_stderr, "Error: failed to write EOR message\n");
 180   }
 181 }
 182
 183 void end_QRprocess( server_record_t *rec, QR_t **qr)
 184 {
 185   /* TODO: record client preferences if necessary*/
 186   (void)rec; /* unused */
 187   delete_query( &((*qr)->query));
 188   delete_msgqueue( &((*qr)->msgqueue));
 189   opj_free( *qr);
 190 }
 191
 192
 193 void local_log( bool query, bool messages, bool sessions, bool targets, QR_t *qr, server_record_t *rec)
 194 {
 195   if( query)
 196     print_queryparam( *qr->query);
 197
 198   if( messages)
 199     print_msgqueue( qr->msgqueue);
 200
 201   if( sessions)
 202     print_allsession( rec->sessionlist);
 203
 204   if( targets)
 205     print_alltarget( rec->targetlist);
 206 }
 207
 208 #endif /*SERVER*/
 209
 210 #ifndef SERVER
 211
 212 dec_server_record_t * init_dec_server( int port)
 213 {
 214   dec_server_record_t *record = (dec_server_record_t *)opj_malloc( sizeof(dec_server_record_t));
 215
 216   record->cachelist = gene_cachelist();
 217   record->jpipstream = NULL;
 218   record->jpipstreamlen = 0;
 219   record->msgqueue = gene_msgqueue( true, NULL);
 220   record->listening_socket = open_listeningsocket( (uint16_t)port);
 221
 222   return record;
 223 }
 224
 225 void terminate_dec_server( dec_server_record_t **rec)
 226 {
 227   delete_cachelist( &(*rec)->cachelist);
 228   opj_free( (*rec)->jpipstream);
 229
 230   if( (*rec)->msgqueue)
 231     delete_msgqueue( &((*rec)->msgqueue));
 232
 233   if( close_socket( (*rec)->listening_socket) != 0)
 234     perror("close");
 235
 236   opj_free( *rec);
 237 }
 238
 239 client_t accept_connection( dec_server_record_t *rec)
 240 {
 241   client_t client;
 242
 243   client = accept_socket( rec->listening_socket);
 244   if( client == -1)
 245     fprintf( stderr, "error: failed to connect to client\n");
 246
 247   return client;
 248 }
 249
 250 bool handle_clientreq( client_t client, dec_server_record_t *rec)
 251 {
 252   bool quit = false;
 253   msgtype_t msgtype = identify_clientmsg( client);
 254
 255   switch( msgtype){
 256   case JPIPSTREAM:
 257     handle_JPIPstreamMSG( client, rec->cachelist, &rec->jpipstream, &rec->jpipstreamlen, rec->msgqueue);
 258     break;
 259
 260   case PNMREQ:
 261     handle_PNMreqMSG( client, rec->jpipstream, rec->msgqueue, rec->cachelist);
 262     break;
 263
 264   case XMLREQ:
 265     handle_XMLreqMSG( client, rec->jpipstream, rec->cachelist);
 266     break;
 267
 268   case TIDREQ:
 269     handle_TIDreqMSG( client, rec->cachelist);
 270     break;
 271
 272   case CIDREQ:
 273     handle_CIDreqMSG( client, rec->cachelist);
 274     break;
 275
 276   case CIDDST:
 277     handle_dstCIDreqMSG( client, rec->cachelist);
 278     break;
 279
 280   case SIZREQ:
 281     handle_SIZreqMSG( client, rec->jpipstream, rec->msgqueue, rec->cachelist);
 282     break;
 283
 284   case JP2SAVE:
 285     handle_JP2saveMSG( client, rec->cachelist, rec->msgqueue, rec->jpipstream);
 286     break;
 287
 288   case QUIT:
 289     quit = true;
 290     save_codestream( rec->jpipstream, rec->jpipstreamlen, "jpt");
 291     break;
 292   case MSGERROR:
 293     break;
 294   }
 295
 296   fprintf( stderr, "\t end of the connection\n\n");
 297   if( close_socket(client) != 0){
 298     perror("close");
 299     return false;
 300   }
 301
 302   if( quit)
 303     return false;
 304
 305   return true;
 306 }
 307
 308
 309 jpip_dec_param_t * init_jpipdecoder( bool jp2)
 310 {
 311   jpip_dec_param_t *dec;
 312
 313   dec = (jpip_dec_param_t *)opj_calloc( 1, sizeof(jpip_dec_param_t));
 314
 315   dec->msgqueue = gene_msgqueue( true, NULL);
 316
 317   if( jp2)
 318     dec->metadatalist = gene_metadatalist();
 319
 320   return dec;
 321 }
 322
 323
 324 bool fread_jpip( const char fname[], jpip_dec_param_t *dec)
 325 {
 326   int infd;
 327
 328   if(( infd = open( fname, O_RDONLY)) == -1){
 329     fprintf( stderr, "file %s not exist\n", fname);
 330     return false;
 331   }
 332
 333   if(!(dec->jpiplen = (Byte8_t)get_filesize(infd)))
 334     return false;
 335
 336   dec->jpipstream = (Byte_t *)opj_malloc( dec->jpiplen);
 337
 338   if( read( infd, dec->jpipstream, dec->jpiplen) != (int)dec->jpiplen){
 339     fprintf( stderr, "file reading error\n");
 340     opj_free( dec->jpipstream);
 341     return false;
 342   }
 343
 344   close(infd);
 345
 346   return true;
 347 }
 348
 349 void decode_jpip( jpip_dec_param_t *dec)
 350 {
 351   parse_JPIPstream( dec->jpipstream, dec->jpiplen, 0, dec->msgqueue);
 352
 353   if( dec->metadatalist){ /* JP2 encoding*/
 354     parse_metamsg( dec->msgqueue, dec->jpipstream, dec->jpiplen, dec->metadatalist);
 355     dec->ihdrbox = gene_ihdrbox( dec->metadatalist, dec->jpipstream);
 356
 357     dec->jp2kstream = recons_jp2( dec->msgqueue, dec->jpipstream, dec->msgqueue->first->csn, &dec->jp2klen);
 358   }
 359   else /* J2k encoding  */
 360     /* Notice: arguments fw, fh need to be set for LRCP, PCRL, CPRL*/
 361     dec->jp2kstream = recons_j2k( dec->msgqueue, dec->jpipstream, dec->msgqueue->first->csn, 0, 0, &dec->jp2klen);
 362 }
 363
 364 bool fwrite_jp2k( const char fname[], jpip_dec_param_t *dec)
 365 {
 366   int outfd;
 367
 368 #ifdef _WIN32
 369   if(( outfd = open( fname, O_WRONLY|O_CREAT, _S_IREAD | _S_IWRITE)) == -1){
 370 #else
 371  if(( outfd = open( fname, O_WRONLY|O_CREAT, S_IRWXU|S_IRWXG)) == -1){
 372 #endif
 373    fprintf( stderr, "file %s open error\n", fname);
 374    return false;
 375  }
 376
 377  if( write( outfd, dec->jp2kstream, dec->jp2klen) != (int)dec->jp2klen)
 378    fprintf( stderr, "j2k file write error\n");
 379
 380  close(outfd);
 381
 382  return true;
 383 }
 384
 385 void output_log( bool messages, bool metadata, bool ihdrbox, jpip_dec_param_t *dec)
 386 {
 387   if( messages)
 388     print_msgqueue( dec->msgqueue);
 389
 390   if( metadata)
 391     print_allmetadata( dec->metadatalist);
 392
 393   if( ihdrbox){
 394     printf("W*H: %d*%d\n", dec->ihdrbox->height, dec->ihdrbox->width);
 395     printf("NC: %d, bpc: %d\n", dec->ihdrbox->nc, dec->ihdrbox->bpc);
 396   }
 397 }
 398
 399 void destroy_jpipdecoder( jpip_dec_param_t **dec)
 400 {
 401   opj_free( (*dec)->jpipstream);
 402   delete_msgqueue( &(*dec)->msgqueue);
 403   if( (*dec)->metadatalist){
 404     delete_metadatalist( &(*dec)->metadatalist);
 405     opj_free( (*dec)->ihdrbox);
 406   }
 407
 408   opj_free( (*dec)->jp2kstream);
 409   opj_free( *dec);
 410 }
 411
 412 index_t * get_index_from_JP2file( int fd)
 413 {
 414   char *data;
 415
 416   /* Check resource is a JP family file.*/
 417   if( lseek( fd, 0, SEEK_SET)==-1){
 418     fprintf( stderr, "Error: File broken (lseek error)\n");
 419     return NULL;
 420   }
 421
 422   data = (char *)opj_malloc( 12); /* size of header*/
 423   if( read( fd, data, 12) != 12){
 424     opj_free( data);
 425     fprintf( stderr, "Error: File broken (read error)\n");
 426     return NULL;
 427   }
 428
 429   if( *data || *(data + 1) || *(data + 2) ||
 430       *(data + 3) != 12 || strncmp (data + 4, "jP  \r\n\x87\n", 8)){
 431     opj_free( data);
 432     fprintf( stderr, "Error: No JPEG 2000 Signature box in this file\n");
 433     return NULL;
 434   }
 435   opj_free( data);
 436
 437   return parse_jp2file( fd);
 438 }
 439
 440 void destroy_index( index_t **idx)
 441 {
 442   delete_index( idx);
 443 }
 444
 445 void output_index( index_t *index)
 446 {
 447   print_index( *index);
 448 }
 449
 450 /* ---------------------------------------------------------------------- */
 451 /* COMPRESSION FUNCTIONS*/
 452 typedef struct opj_decompression
 453 {
 454         /** Main header reading function handler*/
 455         opj_bool (*opj_read_header) (   struct opj_stream_private * cio,
 456                                                                         void * p_codec,
 457                                                                         opj_image_t **p_image,
 458                                                                         struct opj_event_mgr * p_manager);
 459         /** Decoding function */
 460         opj_bool (*opj_decode) (        void * p_codec,
 461                                                                 struct opj_stream_private *p_cio,
 462                                                                 opj_image_t *p_image,
 463                                                                 struct opj_event_mgr * p_manager);
 464         /** FIXME DOC */
 465         opj_bool (*opj_read_tile_header)(       void * p_codec,
 466                                                                                 OPJ_UINT32 * p_tile_index,
 467                                                                                 OPJ_UINT32* p_data_size,
 468                                                                                 OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
 469                                                                                 OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
 470                                                                                 OPJ_UINT32 * p_nb_comps,
 471                                                                                 opj_bool * p_should_go_on,
 472                                                                                 struct opj_stream_private *p_cio,
 473                                                                                 struct opj_event_mgr * p_manager);
 474         /** FIXME DOC */
 475         opj_bool (*opj_decode_tile_data)(       void * p_codec,
 476                                                                                 OPJ_UINT32 p_tile_index,
 477                                                                                 OPJ_BYTE * p_data,
 478                                                                                 OPJ_UINT32 p_data_size,
 479                                                                                 struct opj_stream_private *p_cio,
 480                                                                                 struct opj_event_mgr * p_manager);
 481         /** Reading function used after codestream if necessary */
 482         opj_bool (* opj_end_decompress) (       void *p_codec,
 483                                                                                 struct opj_stream_private *cio,
 484                                                                                 struct opj_event_mgr * p_manager);
 485         /** Codec destroy function handler*/
 486         void (*opj_destroy) (void * p_codec);
 487         /** Setup decoder function handler */
 488         void (*opj_setup_decoder) (void * p_codec, opj_dparameters_t * p_param);
 489         /** Set decode area function handler */
 490         opj_bool (*opj_set_decode_area) (       void * p_codec,
 491                                                                                 opj_image_t* p_image,
 492                                                                                 OPJ_INT32 p_start_x, OPJ_INT32 p_end_x,
 493                                                                                 OPJ_INT32 p_start_y, OPJ_INT32 p_end_y,
 494                                                                                 struct opj_event_mgr * p_manager);
 495
 496         /** Get tile function */
 497         opj_bool (*opj_get_decoded_tile) (      void *p_codec,
 498                                                                                 opj_stream_private_t *p_cio,
 499                                                                                 opj_image_t *p_image,
 500                                                                                 struct opj_event_mgr * p_manager,
 501                                                                                 OPJ_UINT32 tile_index);
 502
 503         /** Set the decoded resolution factor */
 504         opj_bool (*opj_set_decoded_resolution_factor) ( void * p_codec,
 505                                                     OPJ_UINT32 res_factor,
 506                                                     opj_event_mgr_t * p_manager);
 507
 508 }opj_decompression_t;
 509
 510 typedef struct opj_compression
 511 {
 512         opj_bool (* opj_start_compress) (       void *p_codec,
 513                                                                                 struct opj_stream_private *cio,
 514                                                                                 struct opj_image * p_image,
 515                                                                                 struct opj_event_mgr * p_manager);
 516
 517         opj_bool (* opj_encode) (       void * p_codec,
 518                                                                 struct opj_stream_private *p_cio,
 519                                                                 struct opj_event_mgr * p_manager);
 520
 521         opj_bool (* opj_write_tile) (   void * p_codec,
 522                                                                         OPJ_UINT32 p_tile_index,
 523                                                                         OPJ_BYTE * p_data,
 524                                                                         OPJ_UINT32 p_data_size,
 525                                                                         struct opj_stream_private * p_cio,
 526                                                                         struct opj_event_mgr * p_manager);
 527
 528         opj_bool (* opj_end_compress) ( void * p_codec,
 529                                                                         struct opj_stream_private *p_cio,
 530                                                                         struct opj_event_mgr * p_manager);
 531
 532         void (* opj_destroy) (void * p_codec);
 533
 534         void (*opj_setup_encoder) (     void * p_codec,
 535                                                                 opj_cparameters_t * p_param,
 536                                                                 struct opj_image * p_image,
 537                                                                 struct opj_event_mgr * p_manager);
 538
 539 }opj_compression_t;
 540
 541 typedef struct opj_codec_private
 542 {
 543         /** FIXME DOC */
 544         union
 545     {
 546         opj_decompression_t m_decompression;
 547         opj_compression_t m_compression;
 548     } m_codec_data;
 549     /** FIXME DOC*/
 550         void * m_codec;
 551         /** Event handler */
 552         opj_event_mgr_t m_event_mgr;
 553         /** Flag to indicate if the codec is used to decode or encode*/
 554         opj_bool is_decompressor;
 555         void (*opj_dump_codec) (void * p_codec, OPJ_INT32 info_flag, FILE* output_stream);
 556         opj_codestream_info_v2_t* (*opj_get_codec_info)(void* p_codec);
 557         opj_codestream_index_t* (*opj_get_codec_index)(void* p_codec);
 558 }
 559 opj_codec_private_t;
 560
 561 static opj_bool opj_jp2_write_jp(       opj_jp2_v2_t *jp2,
 562                                             opj_stream_private_t *cio,
 563                                                 opj_event_mgr_t * p_manager )
 564 {
 565         /* 12 bytes will be read */
 566         unsigned char l_signature_data [12];
 567
 568         /* preconditions */
 569         assert(cio != 00);
 570         assert(jp2 != 00);
 571         assert(p_manager != 00);
 572
 573         /* write box length */
 574         opj_write_bytes(l_signature_data,12,4);
 575         /* writes box type */
 576         opj_write_bytes(l_signature_data+4,JP2_JP,4);
 577         /* writes magic number*/
 578         opj_write_bytes(l_signature_data+8,0x0d0a870a,4);
 579
 580         if (opj_stream_write_data(cio,l_signature_data,12,p_manager) != 12) {
 581                 return OPJ_FALSE;
 582         }
 583
 584         return OPJ_TRUE;
 585 }
 586
 587 static opj_bool opj_jp2_write_ftyp(opj_jp2_v2_t *jp2,
 588                                                         opj_stream_private_t *cio,
 589                                                         opj_event_mgr_t * p_manager )
 590 {
 591         unsigned int i;
 592         unsigned int l_ftyp_size = 16 + 4 * jp2->numcl;
 593         unsigned char * l_ftyp_data, * l_current_data_ptr;
 594         opj_bool l_result;
 595
 596         /* preconditions */
 597         assert(cio != 00);
 598         assert(jp2 != 00);
 599         assert(p_manager != 00);
 600
 601         l_ftyp_data = (unsigned char *) opj_malloc(l_ftyp_size);
 602
 603         if (l_ftyp_data == 00) {
 604                 opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to handle ftyp data\n");
 605                 return OPJ_FALSE;
 606         }
 607
 608         memset(l_ftyp_data,0,l_ftyp_size);
 609
 610         l_current_data_ptr = l_ftyp_data;
 611
 612         opj_write_bytes(l_current_data_ptr, l_ftyp_size,4); /* box size */
 613         l_current_data_ptr += 4;
 614
 615         opj_write_bytes(l_current_data_ptr, JP2_FTYP,4); /* FTYP */
 616         l_current_data_ptr += 4;
 617
 618         opj_write_bytes(l_current_data_ptr, jp2->brand,4); /* BR */
 619         l_current_data_ptr += 4;
 620
 621         opj_write_bytes(l_current_data_ptr, jp2->minversion,4); /* MinV */
 622         l_current_data_ptr += 4;
 623
 624         for (i = 0; i < jp2->numcl; i++)  {
 625                 opj_write_bytes(l_current_data_ptr, jp2->cl[i],4);      /* CL */
 626         }
 627
 628         l_result = (opj_stream_write_data(cio,l_ftyp_data,l_ftyp_size,p_manager) == l_ftyp_size);
 629         if (! l_result)
 630         {
 631                 opj_event_msg_v2(p_manager, EVT_ERROR, "Error while writing ftyp data to stream\n");
 632         }
 633
 634         opj_free(l_ftyp_data);
 635
 636         return l_result;
 637 }
 638
 639 static opj_bool opj_jp2_default_validation (    opj_jp2_v2_t * jp2,
 640                                         opj_stream_private_t *cio,
 641                                         opj_event_mgr_t * p_manager
 642                                         )
 643 {
 644         opj_bool l_is_valid = OPJ_TRUE;
 645         unsigned int i;
 646
 647         /* preconditions */
 648         assert(jp2 != 00);
 649         assert(cio != 00);
 650         assert(p_manager != 00);
 651
 652         /* JPEG2000 codec validation */
 653         /*TODO*/
 654
 655         /* STATE checking */
 656         /* make sure the state is at 0 */
 657         l_is_valid &= (jp2->jp2_state == JP2_STATE_NONE);
 658
 659         /* make sure not reading a jp2h ???? WEIRD */
 660         l_is_valid &= (jp2->jp2_img_state == JP2_IMG_STATE_NONE);
 661
 662         /* POINTER validation */
 663         /* make sure a j2k codec is present */
 664         l_is_valid &= (jp2->j2k != 00);
 665
 666         /* make sure a procedure list is present */
 667         l_is_valid &= (jp2->m_procedure_list != 00);
 668
 669         /* make sure a validation list is present */
 670         l_is_valid &= (jp2->m_validation_list != 00);
 671
 672         /* PARAMETER VALIDATION */
 673         /* number of components */
 674         l_is_valid &= (jp2->numcl > 0);
 675         /* width */
 676         l_is_valid &= (jp2->h > 0);
 677         /* height */
 678         l_is_valid &= (jp2->w > 0);
 679         /* precision */
 680         for (i = 0; i < jp2->numcomps; ++i)     {
 681                 l_is_valid &= (jp2->comps[i].bpcc > 0);
 682         }
 683
 684         /* METH */
 685         l_is_valid &= ((jp2->meth > 0) && (jp2->meth < 3));
 686
 687         /* stream validation */
 688         /* back and forth is needed */
 689         l_is_valid &= opj_stream_has_seek(cio);
 690
 691         return l_is_valid;
 692 }
 693
 694 static void opj_jp2_setup_encoding_validation (opj_jp2_v2_t *jp2)
 695 {
 696         /* preconditions */
 697         assert(jp2 != 00);
 698
 699         opj_procedure_list_add_procedure(jp2->m_validation_list, (opj_procedure)opj_jp2_default_validation);
 700         /* DEVELOPER CORNER, add your custom validation procedure */
 701 }
 702
 703 static opj_bool opj_jp2_skip_jp2c(      opj_jp2_v2_t *jp2,
 704                                                 opj_stream_private_t *stream,
 705                                                 opj_event_mgr_t * p_manager )
 706 {
 707         /* preconditions */
 708         assert(jp2 != 00);
 709         assert(stream != 00);
 710         assert(p_manager != 00);
 711
 712         jp2->j2k_codestream_offset = opj_stream_tell(stream);
 713
 714         if (opj_stream_skip(stream,8,p_manager) != 8) {
 715                 return OPJ_FALSE;
 716         }
 717
 718         return OPJ_TRUE;
 719 }
 720
 721 static opj_bool opj_jpip_skip_iptr(     opj_jp2_v2_t *jp2,
 722                                                 opj_stream_private_t *stream,
 723                                                 opj_event_mgr_t * p_manager )
 724 {
 725         /* preconditions */
 726         assert(jp2 != 00);
 727         assert(stream != 00);
 728         assert(p_manager != 00);
 729
 730         jp2->jpip_iptr_offset = opj_stream_tell(stream);
 731
 732         if (opj_stream_skip(stream,24,p_manager) != 24) {
 733                 return OPJ_FALSE;
 734         }
 735
 736         return OPJ_TRUE;
 737 }
 738
 739 void opj_jpip_setup_header_writing (opj_jp2_v2_t *jp2)
 740 {
 741         /* preconditions */
 742         assert(jp2 != 00);
 743
 744         opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp );
 745         opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_ftyp );
 746         opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp2h );
 747         opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_skip_iptr );
 748         opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_skip_jp2c );
 749
 750         /* DEVELOPER CORNER, insert your custom procedures */
 751
 752 }
 753
 754 static opj_bool opj_jp2_exec (  opj_jp2_v2_t * jp2,
 755                                 opj_procedure_list_t * p_procedure_list,
 756                                 opj_stream_private_t *stream,
 757                                 opj_event_mgr_t * p_manager
 758                                 )
 759
 760 {
 761         opj_bool (** l_procedure) (opj_jp2_v2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *) = 00;
 762         opj_bool l_result = OPJ_TRUE;
 763         OPJ_UINT32 l_nb_proc, i;
 764
 765         /* preconditions */
 766         assert(p_procedure_list != 00);
 767         assert(jp2 != 00);
 768         assert(stream != 00);
 769         assert(p_manager != 00);
 770
 771         l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
 772         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);
 773
 774         for     (i=0;i<l_nb_proc;++i) {
 775                 l_result = l_result && (*l_procedure) (jp2,stream,p_manager);
 776                 ++l_procedure;
 777         }
 778
 779         /* and clear the procedure list at the end. */
 780         opj_procedure_list_clear(p_procedure_list);
 781         return l_result;
 782 }
 783
 784 opj_bool opj_jpip_start_compress(opj_jp2_v2_t *jp2,
 785                                 opj_stream_private_t *stream,
 786                                 opj_image_t * p_image,
 787                                 opj_event_mgr_t * p_manager
 788                                 )
 789 {
 790         /* preconditions */
 791         assert(jp2 != 00);
 792         assert(stream != 00);
 793         assert(p_manager != 00);
 794
 795         /* customization of the validation */
 796         opj_jp2_setup_encoding_validation (jp2);
 797
 798         /* validation of the parameters codec */
 799         if (! opj_jp2_exec(jp2,jp2->m_validation_list,stream,p_manager)) {
 800                 return OPJ_FALSE;
 801         }
 802
 803         /* customization of the encoding */
 804         opj_jpip_setup_header_writing(jp2);
 805
 806         /* write header */
 807         if (! opj_jp2_exec (jp2,jp2->m_procedure_list,stream,p_manager)) {
 808                 return OPJ_FALSE;
 809         }
 810
 811         return opj_j2k_start_compress(jp2->j2k,stream,p_image,p_manager);
 812 }
 813
 814 static opj_bool opj_jpip_write_iptr(opj_jp2_v2_t *jp2,
 815                                                         opj_stream_private_t *cio,
 816                                                         opj_event_mgr_t * p_manager )
 817 {
 818         OPJ_OFF_T j2k_codestream_exit;
 819         OPJ_BYTE l_data_header [24];
 820
 821         /* preconditions */
 822         assert(jp2 != 00);
 823         assert(cio != 00);
 824         assert(p_manager != 00);
 825         assert(opj_stream_has_seek(cio));
 826
 827         j2k_codestream_exit = opj_stream_tell(cio);
 828         opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
 829         opj_write_bytes(l_data_header + 4,JPIP_IPTR,4);                                                                    /* IPTR */
 830 #if 0
 831         opj_write_bytes(l_data_header + 4 + 4, 0, 8); /* offset */
 832         opj_write_bytes(l_data_header + 8 + 8, 0, 8); /* length */
 833 #else
 834   opj_write_double(l_data_header + 4 + 4, 0); /* offset */
 835   opj_write_double(l_data_header + 8 + 8, 0); /* length */
 836 #endif
 837
 838         if (! opj_stream_seek(cio,jp2->jpip_iptr_offset,p_manager)) {
 839                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
 840                 return OPJ_FALSE;
 841         }
 842
 843         if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
 844                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
 845                 return OPJ_FALSE;
 846         }
 847
 848         if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
 849                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
 850                 return OPJ_FALSE;
 851         }
 852
 853         return OPJ_TRUE;
 854 }
 855
 856 static opj_bool opj_jpip_write_fidx(opj_jp2_v2_t *jp2,
 857                                                         opj_stream_private_t *cio,
 858                                                         opj_event_mgr_t * p_manager )
 859 {
 860         OPJ_OFF_T j2k_codestream_exit;
 861         OPJ_BYTE l_data_header [24];
 862
 863         /* preconditions */
 864         assert(jp2 != 00);
 865         assert(cio != 00);
 866         assert(p_manager != 00);
 867         assert(opj_stream_has_seek(cio));
 868
 869         opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
 870         opj_write_bytes(l_data_header + 4,JPIP_FIDX,4);                                                                    /* IPTR */
 871   opj_write_double(l_data_header + 4 + 4, 0); /* offset */
 872   opj_write_double(l_data_header + 8 + 8, 0); /* length */
 873
 874         if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
 875                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
 876                 return OPJ_FALSE;
 877         }
 878
 879         j2k_codestream_exit = opj_stream_tell(cio);
 880         if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
 881                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
 882                 return OPJ_FALSE;
 883         }
 884
 885         return OPJ_TRUE;
 886 }
 887
 888 static opj_bool opj_jpip_write_cidx(opj_jp2_v2_t *jp2,
 889                                                         opj_stream_private_t *cio,
 890                                                         opj_event_mgr_t * p_manager )
 891 {
 892         OPJ_OFF_T j2k_codestream_exit;
 893         OPJ_BYTE l_data_header [24];
 894
 895         /* preconditions */
 896         assert(jp2 != 00);
 897         assert(cio != 00);
 898         assert(p_manager != 00);
 899         assert(opj_stream_has_seek(cio));
 900
 901         j2k_codestream_exit = opj_stream_tell(cio);
 902         opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
 903         opj_write_bytes(l_data_header + 4,JPIP_CIDX,4);                                                                    /* IPTR */
 904 #if 0
 905         opj_write_bytes(l_data_header + 4 + 4, 0, 8); /* offset */
 906         opj_write_bytes(l_data_header + 8 + 8, 0, 8); /* length */
 907 #else
 908   opj_write_double(l_data_header + 4 + 4, 0); /* offset */
 909   opj_write_double(l_data_header + 8 + 8, 0); /* length */
 910 #endif
 911
 912         if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
 913                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
 914                 return OPJ_FALSE;
 915         }
 916
 917         if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
 918                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
 919                 return OPJ_FALSE;
 920         }
 921
 922         j2k_codestream_exit = opj_stream_tell(cio);
 923         if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
 924                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
 925                 return OPJ_FALSE;
 926         }
 927
 928         return OPJ_TRUE;
 929 }
 930
 931 static void write_prxy_v2( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_stream_private_t *cio,
 932               opj_event_mgr_t * p_manager )
 933 {
 934   OPJ_BYTE l_data_header [8];
 935   int len, lenp;
 936
 937 #if 0
 938   lenp = cio_tell( cio);
 939   cio_skip( cio, 4);              /* L [at the end] */
 940   cio_write( cio, JPIP_PRXY, 4);  /* IPTR           */
 941 #else
 942   lenp = opj_stream_tell(cio);
 943   opj_stream_skip(cio, 4, p_manager);         /* L [at the end] */
 944   opj_write_bytes(l_data_header,JPIP_PRXY,4); /* IPTR           */
 945   opj_stream_write_data(cio,l_data_header,4,p_manager);
 946 #endif
 947
 948 #if 0
 949   cio_write( cio, offset_jp2c, 8); /* OOFF           */
 950   cio_write( cio, length_jp2c, 4); /* OBH part 1     */
 951   cio_write( cio, JP2_JP2C, 4);    /* OBH part 2     */
 952 #else
 953   opj_write_bytes( l_data_header, offset_jp2c, 8); /* OOFF           */
 954   opj_stream_write_data(cio,l_data_header,8,p_manager);
 955   opj_write_bytes( l_data_header, length_jp2c, 4); /* OBH part 1     */
 956   opj_write_bytes( l_data_header+4, JP2_JP2C, 4);  /* OBH part 2     */
 957   opj_stream_write_data(cio,l_data_header,8,p_manager);
 958 #endif
 959
 960 #if 0
 961   cio_write( cio, 1,1);           /* NI             */
 962 #else
 963   opj_write_bytes( l_data_header, 1, 1);/* NI             */
 964   opj_stream_write_data(cio,l_data_header,1,p_manager);
 965 #endif
 966
 967 #if 0
 968   cio_write( cio, offset_idx, 8);  /* IOFF           */
 969   cio_write( cio, length_idx, 4);  /* IBH part 1     */
 970   cio_write( cio, JPIP_CIDX, 4);   /* IBH part 2     */
 971 #else
 972   opj_write_bytes( l_data_header, offset_idx, 8);  /* IOFF           */
 973   opj_stream_write_data(cio,l_data_header,8,p_manager);
 974   opj_write_bytes( l_data_header, length_idx, 4);  /* IBH part 1     */
 975   opj_write_bytes( l_data_header+4, JPIP_CIDX, 4);   /* IBH part 2     */
 976   opj_stream_write_data(cio,l_data_header,8,p_manager);
 977 #endif
 978
 979 #if 0
 980   len = cio_tell( cio)-lenp;
 981   cio_seek( cio, lenp);
 982   cio_write( cio, len, 4);        /* L              */
 983   cio_seek( cio, lenp+len);
 984 #else
 985   len = opj_stream_tell(cio)-lenp;
 986   opj_stream_skip(cio, lenp, p_manager);
 987   opj_write_bytes(l_data_header,len,4);/* L              */
 988   opj_stream_write_data(cio,l_data_header,4,p_manager);
 989   opj_stream_seek(cio, lenp+len,p_manager);
 990 #endif
 991 }
 992
 993
 994 static int write_fidx_v2( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_stream_private_t *cio,
 995               opj_event_mgr_t * p_manager )
 996 {
 997   OPJ_BYTE l_data_header [4];
 998   int len, lenp;
 999
1000 #if 0
1001   lenp = cio_tell( cio);
1002   cio_skip( cio, 4);              /* L [at the end] */
1003   cio_write( cio, JPIP_FIDX, 4);  /* IPTR           */
1004 #else
1005   lenp = opj_stream_tell(cio);
1006   opj_stream_skip(cio, 4, p_manager);
1007   opj_write_bytes(l_data_header,JPIP_FIDX,4); /* FIDX */
1008   opj_stream_write_data(cio,l_data_header,4,p_manager);
1009 #endif
1010
1011   write_prxy_v2( offset_jp2c, length_jp2c, offset_idx, length_idx, cio,p_manager);
1012
1013 #if 0
1014   len = cio_tell( cio)-lenp;
1015   cio_seek( cio, lenp);
1016   cio_write( cio, len, 4);        /* L              */
1017   cio_seek( cio, lenp+len);
1018 #else
1019   len = opj_stream_tell(cio)-lenp;
1020   opj_stream_skip(cio, lenp, p_manager);
1021   opj_write_bytes(l_data_header,len,4);/* L              */
1022   opj_stream_write_data(cio,l_data_header,4,p_manager);
1023   opj_stream_seek(cio, lenp+len,p_manager);
1024 #endif
1025
1026   return len;
1027 }
1028
1029 static opj_bool opj_jpip_write_jp2c(opj_jp2_v2_t *jp2,
1030                                                         opj_stream_private_t *cio,
1031                                                         opj_event_mgr_t * p_manager )
1032 {
1033         OPJ_OFF_T j2k_codestream_exit;
1034         OPJ_BYTE l_data_header [8];
1035   OPJ_UINT32 len_jp2c;
1036   int len_cidx;
1037   int len_fidx;
1038   int pos_jp2c;
1039   int pos_fidx;
1040   int pos_cidx;
1041
1042         /* preconditions */
1043         assert(jp2 != 00);
1044         assert(cio != 00);
1045         assert(p_manager != 00);
1046         assert(opj_stream_has_seek(cio));
1047
1048         j2k_codestream_exit = opj_stream_tell(cio);
1049   len_jp2c = j2k_codestream_exit - jp2->j2k_codestream_offset;
1050   pos_jp2c = jp2->j2k_codestream_offset;
1051         opj_write_bytes(l_data_header, len_jp2c, 4); /* size of codestream */
1052         opj_write_bytes(l_data_header + 4,JP2_JP2C,4);                                                                     /* JP2C */
1053
1054         if (! opj_stream_seek(cio,jp2->j2k_codestream_offset,p_manager)) {
1055                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
1056                 return OPJ_FALSE;
1057         }
1058
1059         if (opj_stream_write_data(cio,l_data_header,8,p_manager) != 8) {
1060                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
1061                 return OPJ_FALSE;
1062         }
1063
1064         if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
1065                 opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
1066                 return OPJ_FALSE;
1067         }
1068
1069   /* CIDX */
1070   pos_cidx = opj_stream_tell( cio);
1071   len_cidx = write_cidx_v2( pos_jp2c+8, cio, jp2_get_cstr_info(jp2), len_jp2c-8);
1072
1073   /* FIDX */
1074   pos_fidx = opj_stream_tell( cio);
1075   len_fidx = write_fidx_v2( pos_jp2c, len_jp2c, pos_cidx, len_cidx, cio, p_manager);
1076
1077         return OPJ_TRUE;
1078 }
1079
1080 static void opj_jp2_setup_end_header_writing (opj_jp2_v2_t *jp2)
1081 {
1082         /* preconditions */
1083         assert(jp2 != 00);
1084
1085         opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_iptr );
1086         opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_jp2c );
1087 #if 0
1088   opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_cidx );
1089   opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_fidx );
1090 #endif
1091         /* DEVELOPER CORNER, add your custom procedures */
1092 }
1093
1094 opj_bool opj_jpip_end_compress( opj_jp2_v2_t *jp2,
1095                                                             opj_stream_private_t *cio,
1096                                                             opj_event_mgr_t * p_manager
1097                                 )
1098 {
1099         /* preconditions */
1100         assert(jp2 != 00);
1101         assert(cio != 00);
1102         assert(p_manager != 00);
1103
1104         /* customization of the end encoding */
1105         opj_jp2_setup_end_header_writing(jp2);
1106
1107         if (! opj_j2k_end_compress(jp2->j2k,cio,p_manager)) {
1108                 return OPJ_FALSE;
1109         }
1110
1111         /* write header */
1112         return opj_jp2_exec(jp2,jp2->m_procedure_list,cio,p_manager);
1113 }
1114
1115
1116 opj_codec_t* OPJ_CALLCONV opj_jpip_create_compress(OPJ_CODEC_FORMAT p_format)
1117 {
1118         opj_codec_private_t *l_codec = 00;
1119
1120         l_codec = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));
1121         if (!l_codec) {
1122                 return 00;
1123         }
1124         memset(l_codec, 0, sizeof(opj_codec_private_t));
1125
1126         l_codec->is_decompressor = 0;
1127
1128         switch(p_format) {
1129                 case CODEC_JP2:
1130                         /* get a JP2 decoder handle */
1131                         l_codec->m_codec_data.m_compression.opj_encode = (opj_bool (*) (void *,
1132                                                                                                                                                         struct opj_stream_private *,
1133                                                                                                                                                         struct opj_event_mgr * )) opj_jp2_encode;
1134
1135                         l_codec->m_codec_data.m_compression.opj_end_compress = (opj_bool (*) (  void *,
1136                                                                                                                                                                         struct opj_stream_private *,
1137                                                                                                                                                                         struct opj_event_mgr *)) opj_jpip_end_compress;
1138
1139                         l_codec->m_codec_data.m_compression.opj_start_compress = (opj_bool (*) (void *,
1140                                                                                                                                                                         struct opj_stream_private *,
1141                                                                                                                                                                         struct opj_image * ,
1142                                                                                                                                                                         struct opj_event_mgr *))  opj_jpip_start_compress;
1143
1144                         l_codec->m_codec_data.m_compression.opj_write_tile = (opj_bool (*) (void *,
1145                                                                                                                                                                 OPJ_UINT32,
1146                                                                                                                                                                 OPJ_BYTE*,
1147                                                                                                                                                                 OPJ_UINT32,
1148                                                                                                                                                                 struct opj_stream_private *,
1149                                                                                                                                                                 struct opj_event_mgr *)) opj_jp2_write_tile;
1150
1151                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_jp2_destroy;
1152
1153                         l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
1154                                                                                                                                                                 opj_cparameters_t *,
1155                                                                                                                                                                 struct opj_image *,
1156                                                                                                                                                                 struct opj_event_mgr * )) opj_jp2_setup_encoder;
1157
1158                         l_codec->m_codec = opj_jp2_create(OPJ_FALSE);
1159                         if (! l_codec->m_codec) {
1160                                 opj_free(l_codec);
1161                                 return 00;
1162                         }
1163
1164                         break;
1165
1166                 case CODEC_UNKNOWN:
1167                 case CODEC_JPT:
1168                 default:
1169                         opj_free(l_codec);
1170                         return 00;
1171         }
1172
1173         opj_set_default_event_handler(&(l_codec->m_event_mgr));
1174         return (opj_codec_t*) l_codec;
1175 }
1176
1177 #endif /*SERVER*/