applications/codec/index.c

   1 /*\r
   2  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium\r
   3  * Copyright (c) 2002-2007, Professor Benoit Macq\r
   4  * Copyright (c) 2003-2007, Francois-Olivier Devaux \r
   5  * All rights reserved.\r
   6  *\r
   7  * Redistribution and use in source and binary forms, with or without\r
   8  * modification, are permitted provided that the following conditions\r
   9  * are met:\r
  10  * 1. Redistributions of source code must retain the above copyright\r
  11  *    notice, this list of conditions and the following disclaimer.\r
  12  * 2. Redistributions in binary form must reproduce the above copyright\r
  13  *    notice, this list of conditions and the following disclaimer in the\r
  14  *    documentation and/or other materials provided with the distribution.\r
  15  *\r
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
  26  * POSSIBILITY OF SUCH DAMAGE.\r
  27  */\r
  28 \r
  29 #include <stdio.h>\r
  30 #include <math.h>\r
  31 #include <string.h>\r
  32 #include <stdlib.h>\r
  33 \r
  34 #include "openjpeg.h"\r
  35 #include "index.h"\r
  36 \r
  37 /* ------------------------------------------------------------------------------------ */\r
  38 \r
  39 /**\r
  40 Write a structured index to a file\r
  41 @param cstr_info Codestream information \r
  42 @param index Index filename\r
  43 @return Returns 0 if successful, returns 1 otherwise\r
  44 */\r
  45 int write_index_file(opj_codestream_info_t *cstr_info, char *index) {\r
  46         int tileno, compno, layno, resno, precno, pack_nb, x, y;\r
  47         FILE *stream = NULL;\r
  48         double total_disto = 0;\r
  49 /* UniPG>> */\r
  50         int tilepartno;\r
  51         char disto_on, numpix_on;\r
  52 \r
  53 #ifdef USE_JPWL\r
  54         if (!strcmp(index, JPWL_PRIVATEINDEX_NAME))\r
  55                 return 0;\r
  56 #endif /* USE_JPWL */\r
  57 /* <<UniPG */\r
  58 \r
  59         if (!cstr_info)         \r
  60                 return 1;\r
  61 \r
  62         stream = fopen(index, "w");\r
  63         if (!stream) {\r
  64                 fprintf(stderr, "failed to open index file [%s] for writing\n", index);\r
  65                 return 1;\r
  66         }\r
  67         \r
  68         if (cstr_info->tile[0].distotile)\r
  69                 disto_on = 1;\r
  70         else \r
  71                 disto_on = 0;\r
  72 \r
  73         if (cstr_info->tile[0].numpix)\r
  74                 numpix_on = 1;\r
  75         else \r
  76                 numpix_on = 0;\r
  77 \r
  78         fprintf(stream, "%d %d\n", cstr_info->image_w, cstr_info->image_h);\r
  79         fprintf(stream, "%d\n", cstr_info->prog);\r
  80         fprintf(stream, "%d %d\n", cstr_info->tile_x, cstr_info->tile_y);\r
  81         fprintf(stream, "%d %d\n", cstr_info->tw, cstr_info->th);\r
  82         fprintf(stream, "%d\n", cstr_info->numcomps);\r
  83         fprintf(stream, "%d\n", cstr_info->numlayers);\r
  84         fprintf(stream, "%d\n", cstr_info->numdecompos[0]); /* based on component 0 */\r
  85 \r
  86         for (resno = cstr_info->numdecompos[0]; resno >= 0; resno--) {\r
  87                 fprintf(stream, "[%d,%d] ", \r
  88                         (1 << cstr_info->tile[0].pdx[resno]), (1 << cstr_info->tile[0].pdx[resno]));    /* based on tile 0 and component 0 */\r
  89         }\r
  90 \r
  91         fprintf(stream, "\n");\r
  92 /* UniPG>> */\r
  93         fprintf(stream, "%d\n", cstr_info->main_head_start);\r
  94 /* <<UniPG */\r
  95         fprintf(stream, "%d\n", cstr_info->main_head_end);\r
  96         fprintf(stream, "%d\n", cstr_info->codestream_size);\r
  97         \r
  98         fprintf(stream, "\nINFO ON TILES\n");\r
  99         fprintf(stream, "tileno start_pos  end_hd  end_tile   nbparts");\r
 100         if (disto_on)\r
 101                 fprintf(stream,"         disto");\r
 102         if (numpix_on)\r
 103                 fprintf(stream,"     nbpix");\r
 104         if (disto_on && numpix_on)\r
 105                 fprintf(stream,"  disto/nbpix");\r
 106         fprintf(stream, "\n");\r
 107 \r
 108         for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {\r
 109                 fprintf(stream, "%4d %9d %9d %9d %9d", \r
 110                         cstr_info->tile[tileno].tileno,\r
 111                         cstr_info->tile[tileno].start_pos,\r
 112                         cstr_info->tile[tileno].end_header,\r
 113                         cstr_info->tile[tileno].end_pos,\r
 114                         cstr_info->tile[tileno].num_tps);\r
 115                 if (disto_on)\r
 116                         fprintf(stream," %9e", cstr_info->tile[tileno].distotile);\r
 117                 if (numpix_on)\r
 118                         fprintf(stream," %9d", cstr_info->tile[tileno].numpix);\r
 119                 if (disto_on && numpix_on)\r
 120                         fprintf(stream," %9e", cstr_info->tile[tileno].distotile / cstr_info->tile[tileno].numpix);\r
 121                 fprintf(stream, "\n");\r
 122         }\r
 123                 \r
 124         for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {\r
 125                 int start_pos, end_ph_pos, end_pos;\r
 126                 double disto = 0;\r
 127                 int max_numdecompos = 0;\r
 128                 pack_nb = 0;\r
 129 \r
 130                 for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 131                         if (max_numdecompos < cstr_info->numdecompos[compno])\r
 132                                 max_numdecompos = cstr_info->numdecompos[compno];\r
 133                 }       \r
 134 \r
 135                 fprintf(stream, "\nTILE %d DETAILS\n", tileno); \r
 136                 fprintf(stream, "part_nb tileno  start_pack num_packs  start_pos end_tph_pos   end_pos\n");\r
 137                 for (tilepartno = 0; tilepartno < cstr_info->tile[tileno].num_tps; tilepartno++)\r
 138                         fprintf(stream, "%4d %9d   %9d %9d  %9d %11d %9d\n",\r
 139                                 tilepartno, tileno,\r
 140                                 cstr_info->tile[tileno].tp[tilepartno].tp_start_pack,\r
 141                                 cstr_info->tile[tileno].tp[tilepartno].tp_numpacks,\r
 142                                 cstr_info->tile[tileno].tp[tilepartno].tp_start_pos,\r
 143                                 cstr_info->tile[tileno].tp[tilepartno].tp_end_header,\r
 144                                 cstr_info->tile[tileno].tp[tilepartno].tp_end_pos\r
 145                                 );\r
 146 \r
 147                 if (cstr_info->prog == LRCP) {  /* LRCP */\r
 148                         fprintf(stream, "LRCP\npack_nb tileno layno resno compno precno start_pos end_ph_pos end_pos");\r
 149                         if (disto_on)\r
 150                                 fprintf(stream, " disto");\r
 151                         fprintf(stream,"\n");\r
 152 \r
 153                         for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 154                                 for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 155                                         for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 156                                                 int prec_max;\r
 157                                                 if (resno > cstr_info->numdecompos[compno])\r
 158                                                         break;\r
 159                                                 prec_max = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 160                                                 for (precno = 0; precno < prec_max; precno++) {\r
 161                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 162                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 163                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 164                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 165                                                         fprintf(stream, "%4d %6d %7d %5d %6d  %6d    %6d     %6d %7d",\r
 166                                                                 pack_nb, tileno, layno, resno, compno, precno, start_pos, end_ph_pos, end_pos);\r
 167                                                         if (disto_on)\r
 168                                                                 fprintf(stream, " %8e", disto);\r
 169                                                         fprintf(stream, "\n");\r
 170                                                         total_disto += disto;\r
 171                                                         pack_nb++;\r
 172                                                 }\r
 173                                         }\r
 174                                 }\r
 175                         }\r
 176                 } /* LRCP */\r
 177 \r
 178                 else if (cstr_info->prog == RLCP) {     /* RLCP */                      \r
 179                         fprintf(stream, "RLCP\npack_nb tileno resno layno compno precno start_pos end_ph_pos end_pos\n");\r
 180                         if (disto_on)\r
 181                                 fprintf(stream, " disto");\r
 182                         fprintf(stream,"\n");\r
 183 \r
 184                         for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 185                                 for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 186                                         for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 187                                                 int prec_max; \r
 188                                                 if (resno > cstr_info->numdecompos[compno])\r
 189                                                         break;\r
 190                                                 prec_max = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 191                                                 for (precno = 0; precno < prec_max; precno++) {\r
 192                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 193                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 194                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 195                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 196                                                         fprintf(stream, "%4d %6d %5d %7d %6d %6d %9d   %9d %7d",\r
 197                                                                 pack_nb, tileno, resno, layno, compno, precno, start_pos, end_ph_pos, end_pos);\r
 198                                                         if (disto_on)\r
 199                                                                 fprintf(stream, " %8e", disto);\r
 200                                                         fprintf(stream, "\n");\r
 201                                                         total_disto += disto;\r
 202                                                         pack_nb++;\r
 203                                                 }\r
 204                                         }\r
 205                                 }\r
 206                         }\r
 207                 } /* RLCP */\r
 208 \r
 209                 else if (cstr_info->prog == RPCL) {     /* RPCL */\r
 210 \r
 211                         fprintf(stream, "RPCL\npack_nb tileno resno precno compno layno start_pos end_ph_pos end_pos"); \r
 212                         if (disto_on)\r
 213                                 fprintf(stream, " disto");\r
 214                         fprintf(stream,"\n");\r
 215 \r
 216                         for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 217                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 218                                 for (precno = 0; precno < numprec; precno++) {                                                          \r
 219                                         /* I suppose components have same XRsiz, YRsiz */\r
 220                                         int x0 = cstr_info->tile_Ox + tileno - (int)floor((float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;\r
 221                                         int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;\r
 222                                         int x1 = x0 + cstr_info->tile_x;\r
 223                                         int y1 = y0 + cstr_info->tile_y;\r
 224                                         for (compno = 0; compno < cstr_info->numcomps; compno++) {                                      \r
 225                                                 int pcnx = cstr_info->tile[tileno].pw[resno];\r
 226                                                 int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );\r
 227                                                 int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );\r
 228                                                 int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;\r
 229                                                 int precno_y = (int) floor( (float)precno/(float)pcnx );\r
 230                                                 if (resno > cstr_info->numdecompos[compno])\r
 231                                                         break;\r
 232                                                 for(y = y0; y < y1; y++) {                                                      \r
 233                                                         if (precno_y*pcy == y ) {\r
 234                                                                 for (x = x0; x < x1; x++) {                                                                     \r
 235                                                                         if (precno_x*pcx == x ) {\r
 236                                                                                 for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 237                                                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 238                                                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 239                                                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 240                                                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 241                                                                                         fprintf(stream, "%4d %6d %5d %6d %6d %7d %9d   %9d %7d",\r
 242                                                                                                 pack_nb, tileno, resno, precno, compno, layno, start_pos, end_ph_pos, end_pos); \r
 243                                                                                         if (disto_on)\r
 244                                                                                                 fprintf(stream, " %8e", disto);\r
 245                                                                                         fprintf(stream, "\n");\r
 246                                                                                         total_disto += disto;\r
 247                                                                                         pack_nb++; \r
 248                                                                                 }\r
 249                                                                         }\r
 250                                                                 }/* x = x0..x1 */\r
 251                                                         } \r
 252                                                 }  /* y = y0..y1 */\r
 253                                         } /* precno */\r
 254                                 } /* compno */\r
 255                         } /* resno */\r
 256                 } /* RPCL */\r
 257 \r
 258                 else if (cstr_info->prog == PCRL) {     /* PCRL */\r
 259                         /* I suppose components have same XRsiz, YRsiz */\r
 260                         int x0 = cstr_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;\r
 261                         int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;\r
 262                         int x1 = x0 + cstr_info->tile_x;\r
 263                         int y1 = y0 + cstr_info->tile_y;\r
 264 \r
 265                         // Count the maximum number of precincts \r
 266                         int max_numprec = 0;\r
 267                         for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 268                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 269                                 if (numprec > max_numprec)\r
 270                                         max_numprec = numprec;\r
 271                         }\r
 272 \r
 273                         fprintf(stream, "PCRL\npack_nb tileno precno compno resno layno start_pos end_ph_pos end_pos"); \r
 274                         if (disto_on)\r
 275                                 fprintf(stream, " disto");\r
 276                         fprintf(stream,"\n");\r
 277 \r
 278                         for (precno = 0; precno < max_numprec; precno++) {\r
 279                                 for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 280                                         for (resno = 0; resno < cstr_info->numdecompos[compno] + 1; resno++) {\r
 281                                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 282                                                 int pcnx = cstr_info->tile[tileno].pw[resno];\r
 283                                                 int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );\r
 284                                                 int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );\r
 285                                                 int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;\r
 286                                                 int precno_y = (int) floor( (float)precno/(float)pcnx );\r
 287                                                 if (precno >= numprec)\r
 288                                                         continue;\r
 289                                                 for(y = y0; y < y1; y++) {                                                      \r
 290                                                         if (precno_y*pcy == y ) {\r
 291                                                                 for (x = x0; x < x1; x++) {                                                                     \r
 292                                                                         if (precno_x*pcx == x ) {\r
 293                                                                                 for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 294                                                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 295                                                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 296                                                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 297                                                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 298                                                                                         fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d   %9d %7d",\r
 299                                                                                                 pack_nb, tileno, precno, compno, resno, layno, start_pos, end_ph_pos, end_pos); \r
 300                                                                                         if (disto_on)\r
 301                                                                                                 fprintf(stream, " %8e", disto);\r
 302                                                                                         fprintf(stream, "\n");\r
 303                                                                                         total_disto += disto;\r
 304                                                                                         pack_nb++; \r
 305                                                                                 }\r
 306                                                                         }\r
 307                                                                 }/* x = x0..x1 */\r
 308                                                         } \r
 309                                                 }  /* y = y0..y1 */\r
 310                                         } /* resno */\r
 311                                 } /* compno */\r
 312                         } /* precno */\r
 313                 } /* PCRL */\r
 314 \r
 315                 else {  /* CPRL */\r
 316                         // Count the maximum number of precincts \r
 317                         int max_numprec = 0;\r
 318                         for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 319                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 320                                 if (numprec > max_numprec)\r
 321                                         max_numprec = numprec;\r
 322                         }\r
 323 \r
 324                         fprintf(stream, "CPRL\npack_nb tileno compno precno resno layno start_pos end_ph_pos end_pos"); \r
 325                         if (disto_on)\r
 326                                 fprintf(stream, " disto");\r
 327                         fprintf(stream,"\n");\r
 328 \r
 329                         for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 330                                 /* I suppose components have same XRsiz, YRsiz */\r
 331                                 int x0 = cstr_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;\r
 332                                 int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;\r
 333                                 int x1 = x0 + cstr_info->tile_x;\r
 334                                 int y1 = y0 + cstr_info->tile_y;\r
 335 \r
 336                                 for (precno = 0; precno < max_numprec; precno++) {\r
 337                                         for (resno = 0; resno < cstr_info->numdecompos[compno] + 1; resno++) {\r
 338                                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 339                                                 int pcnx = cstr_info->tile[tileno].pw[resno];\r
 340                                                 int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );\r
 341                                                 int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );\r
 342                                                 int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;\r
 343                                                 int precno_y = (int) floor( (float)precno/(float)pcnx );\r
 344                                                 if (precno >= numprec)\r
 345                                                         continue;\r
 346 \r
 347                                                 for(y = y0; y < y1; y++) {\r
 348                                                         if (precno_y*pcy == y ) {\r
 349                                                                 for (x = x0; x < x1; x++) {\r
 350                                                                         if (precno_x*pcx == x ) {\r
 351                                                                                 for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 352                                                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 353                                                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 354                                                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 355                                                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 356                                                                                         fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d   %9d %7d",\r
 357                                                                                                 pack_nb, tileno, compno, precno, resno, layno, start_pos, end_ph_pos, end_pos); \r
 358                                                                                         if (disto_on)\r
 359                                                                                                 fprintf(stream, " %8e", disto);\r
 360                                                                                         fprintf(stream, "\n");\r
 361                                                                                         total_disto += disto;\r
 362                                                                                         pack_nb++; \r
 363                                                                                 }\r
 364                                                                         }\r
 365                                                                 }/* x = x0..x1 */\r
 366                                                         }\r
 367                                                 } /* y = y0..y1 */\r
 368                                         } /* resno */\r
 369                                 } /* precno */\r
 370                         } /* compno */\r
 371                 } /* CPRL */   \r
 372         } /* tileno */\r
 373         \r
 374         if (disto_on) {\r
 375                 fprintf(stream, "%8e\n", cstr_info->D_max); /* SE max */        \r
 376                 fprintf(stream, "%.8e\n", total_disto); /* SE totale */\r
 377         }\r
 378 /* UniPG>> */\r
 379         /* print the markers' list */\r
 380         if (cstr_info->marknum) {\r
 381                 fprintf(stream, "\nMARKER LIST\n");\r
 382                 fprintf(stream, "%d\n", cstr_info->marknum);\r
 383                 fprintf(stream, "type\tstart_pos    length\n");\r
 384                 for (x = 0; x < cstr_info->marknum; x++)\r
 385                         fprintf(stream, "%X\t%9d %9d\n", cstr_info->marker[x].type, cstr_info->marker[x].pos, cstr_info->marker[x].len);\r
 386         }\r
 387 /* <<UniPG */\r
 388         fclose(stream);\r
 389 \r
 390         fprintf(stderr,"Generated index file %s\n", index);\r
 391 \r
 392         return 0;\r
 393 }\r
 394 \r
 395 /* ------------------------------------------------------------------------------------ */\r
 396 \r
 397 /**\r
 398 Write a structured index to a file\r
 399 @param cstr_info Codestream information\r
 400 @param index Index filename\r
 401 @return Returns 0 if successful, returns 1 otherwise\r
 402 */\r
 403 int write_index_file_v2(FILE* stream, opj_codestream_info_t *cstr_info) {\r
 404         int tileno, compno, layno, resno, precno, pack_nb, x, y;\r
 405         double total_disto = 0;\r
 406 /* UniPG>> */\r
 407         int tilepartno;\r
 408         char disto_on, numpix_on;\r
 409 \r
 410 #ifdef USE_JPWL\r
 411         if (!strcmp(index, JPWL_PRIVATEINDEX_NAME))\r
 412                 return EXIT_SUCCESS;\r
 413 #endif /* USE_JPWL */\r
 414 /* <<UniPG */\r
 415 \r
 416         if (!cstr_info)\r
 417                 return EXIT_FAILURE;\r
 418 \r
 419         if (!stream)\r
 420                 return EXIT_FAILURE;\r
 421 \r
 422         if (cstr_info->tile[0].distotile)\r
 423                 disto_on = 1;\r
 424         else\r
 425                 disto_on = 0;\r
 426 \r
 427         if (cstr_info->tile[0].numpix)\r
 428                 numpix_on = 1;\r
 429         else\r
 430                 numpix_on = 0;\r
 431 \r
 432         fprintf(stream, "%d %d\n", cstr_info->image_w, cstr_info->image_h);\r
 433         fprintf(stream, "%d\n", cstr_info->prog);\r
 434         fprintf(stream, "%d %d\n", cstr_info->tile_x, cstr_info->tile_y);\r
 435         fprintf(stream, "%d %d\n", cstr_info->tw, cstr_info->th);\r
 436         fprintf(stream, "%d\n", cstr_info->numcomps);\r
 437         fprintf(stream, "%d\n", cstr_info->numlayers);\r
 438         fprintf(stream, "%d\n", cstr_info->numdecompos[0]); /* based on component 0 */\r
 439 \r
 440         for (resno = cstr_info->numdecompos[0]; resno >= 0; resno--) {\r
 441                 fprintf(stream, "[%d,%d] ",\r
 442                         (1 << cstr_info->tile[0].pdx[resno]), (1 << cstr_info->tile[0].pdx[resno]));    /* based on tile 0 and component 0 */\r
 443         }\r
 444 \r
 445         fprintf(stream, "\n");\r
 446 /* UniPG>> */\r
 447         fprintf(stream, "%d\n", cstr_info->main_head_start);\r
 448 /* <<UniPG */\r
 449         fprintf(stream, "%d\n", cstr_info->main_head_end);\r
 450         fprintf(stream, "%d\n", cstr_info->codestream_size);\r
 451 \r
 452         fprintf(stream, "\nINFO ON TILES\n");\r
 453         fprintf(stream, "tileno start_pos  end_hd  end_tile   nbparts");\r
 454         if (disto_on)\r
 455                 fprintf(stream,"         disto");\r
 456         if (numpix_on)\r
 457                 fprintf(stream,"     nbpix");\r
 458         if (disto_on && numpix_on)\r
 459                 fprintf(stream,"  disto/nbpix");\r
 460         fprintf(stream, "\n");\r
 461 \r
 462         for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {\r
 463                 fprintf(stream, "%4d %9d %9d %9d %9d",\r
 464                         cstr_info->tile[tileno].tileno,\r
 465                         cstr_info->tile[tileno].start_pos,\r
 466                         cstr_info->tile[tileno].end_header,\r
 467                         cstr_info->tile[tileno].end_pos,\r
 468                         cstr_info->tile[tileno].num_tps);\r
 469                 if (disto_on)\r
 470                         fprintf(stream," %9e", cstr_info->tile[tileno].distotile);\r
 471                 if (numpix_on)\r
 472                         fprintf(stream," %9d", cstr_info->tile[tileno].numpix);\r
 473                 if (disto_on && numpix_on)\r
 474                         fprintf(stream," %9e", cstr_info->tile[tileno].distotile / cstr_info->tile[tileno].numpix);\r
 475                 fprintf(stream, "\n");\r
 476                 }\r
 477 \r
 478         for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {\r
 479                 int start_pos, end_ph_pos, end_pos;\r
 480                 double disto = 0;\r
 481                 int max_numdecompos = 0;\r
 482                 pack_nb = 0;\r
 483 \r
 484                 for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 485                         if (max_numdecompos < cstr_info->numdecompos[compno])\r
 486                                 max_numdecompos = cstr_info->numdecompos[compno];\r
 487                 }\r
 488 \r
 489                 fprintf(stream, "\nTILE %d DETAILS\n", tileno);\r
 490                 fprintf(stream, "part_nb tileno  start_pack num_packs  start_pos end_tph_pos   end_pos\n");\r
 491                 for (tilepartno = 0; tilepartno < cstr_info->tile[tileno].num_tps; tilepartno++)\r
 492                         fprintf(stream, "%4d %9d   %9d %9d  %9d %11d %9d\n",\r
 493                                 tilepartno, tileno,\r
 494                                 cstr_info->tile[tileno].tp[tilepartno].tp_start_pack,\r
 495                                 cstr_info->tile[tileno].tp[tilepartno].tp_numpacks,\r
 496                                 cstr_info->tile[tileno].tp[tilepartno].tp_start_pos,\r
 497                                 cstr_info->tile[tileno].tp[tilepartno].tp_end_header,\r
 498                                 cstr_info->tile[tileno].tp[tilepartno].tp_end_pos\r
 499                                 );\r
 500 \r
 501                 if (cstr_info->prog == LRCP) {  /* LRCP */\r
 502                         fprintf(stream, "LRCP\npack_nb tileno layno resno compno precno start_pos end_ph_pos end_pos");\r
 503                         if (disto_on)\r
 504                                 fprintf(stream, " disto");\r
 505                         fprintf(stream,"\n");\r
 506 \r
 507                         for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 508                                 for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 509                                         for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 510                                                 int prec_max;\r
 511                                                 if (resno > cstr_info->numdecompos[compno])\r
 512                                                         break;\r
 513                                                 prec_max = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 514                                                 for (precno = 0; precno < prec_max; precno++) {\r
 515                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 516                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 517                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 518                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 519                                                         fprintf(stream, "%4d %6d %7d %5d %6d  %6d    %6d     %6d %7d",\r
 520                                                                 pack_nb, tileno, layno, resno, compno, precno, start_pos, end_ph_pos, end_pos);\r
 521                                                         if (disto_on)\r
 522                                                                 fprintf(stream, " %8e", disto);\r
 523                                                         fprintf(stream, "\n");\r
 524                                                         total_disto += disto;\r
 525                                                         pack_nb++;\r
 526                                                 }\r
 527                                         }\r
 528                                 }\r
 529                         }\r
 530                 } /* LRCP */\r
 531 \r
 532                 else if (cstr_info->prog == RLCP) {     /* RLCP */\r
 533                         fprintf(stream, "RLCP\npack_nb tileno resno layno compno precno start_pos end_ph_pos end_pos\n");\r
 534                         if (disto_on)\r
 535                                 fprintf(stream, " disto");\r
 536                         fprintf(stream,"\n");\r
 537 \r
 538                         for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 539                                 for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 540                                         for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 541                                                 int prec_max;\r
 542                                                 if (resno > cstr_info->numdecompos[compno])\r
 543                                                         break;\r
 544                                                 prec_max = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 545                                                 for (precno = 0; precno < prec_max; precno++) {\r
 546                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 547                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 548                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 549                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 550                                                         fprintf(stream, "%4d %6d %5d %7d %6d %6d %9d   %9d %7d",\r
 551                                                                 pack_nb, tileno, resno, layno, compno, precno, start_pos, end_ph_pos, end_pos);\r
 552                                                         if (disto_on)\r
 553                                                                 fprintf(stream, " %8e", disto);\r
 554                                                         fprintf(stream, "\n");\r
 555                                                         total_disto += disto;\r
 556                                                         pack_nb++;\r
 557                                                 }\r
 558                                         }\r
 559                                 }\r
 560                         }\r
 561                 } /* RLCP */\r
 562 \r
 563                 else if (cstr_info->prog == RPCL) {     /* RPCL */\r
 564 \r
 565                         fprintf(stream, "RPCL\npack_nb tileno resno precno compno layno start_pos end_ph_pos end_pos");\r
 566                         if (disto_on)\r
 567                                 fprintf(stream, " disto");\r
 568                         fprintf(stream,"\n");\r
 569 \r
 570                         for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 571                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 572                                 for (precno = 0; precno < numprec; precno++) {\r
 573                                         /* I suppose components have same XRsiz, YRsiz */\r
 574                                         int x0 = cstr_info->tile_Ox + tileno - (int)floor((float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;\r
 575                                         int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;\r
 576                                         int x1 = x0 + cstr_info->tile_x;\r
 577                                         int y1 = y0 + cstr_info->tile_y;\r
 578                                         for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 579                                                 int pcnx = cstr_info->tile[tileno].pw[resno];\r
 580                                                 int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );\r
 581                                                 int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );\r
 582                                                 int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;\r
 583                                                 int precno_y = (int) floor( (float)precno/(float)pcnx );\r
 584                                                 if (resno > cstr_info->numdecompos[compno])\r
 585                                                         break;\r
 586                                                 for(y = y0; y < y1; y++) {\r
 587                                                         if (precno_y*pcy == y ) {\r
 588                                                                 for (x = x0; x < x1; x++) {\r
 589                                                                         if (precno_x*pcx == x ) {\r
 590                                                                                 for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 591                                                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 592                                                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 593                                                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 594                                                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 595                                                                                         fprintf(stream, "%4d %6d %5d %6d %6d %7d %9d   %9d %7d",\r
 596                                                                                                 pack_nb, tileno, resno, precno, compno, layno, start_pos, end_ph_pos, end_pos);\r
 597                                                                                         if (disto_on)\r
 598                                                                                                 fprintf(stream, " %8e", disto);\r
 599                                                                                         fprintf(stream, "\n");\r
 600                                                                                         total_disto += disto;\r
 601                                                                                         pack_nb++;\r
 602                                                                                 }\r
 603                                                                         }\r
 604                                                                 }/* x = x0..x1 */\r
 605                                                         }\r
 606                                                 }  /* y = y0..y1 */\r
 607                                         } /* precno */\r
 608                                 } /* compno */\r
 609                         } /* resno */\r
 610                 } /* RPCL */\r
 611 \r
 612                 else if (cstr_info->prog == PCRL) {     /* PCRL */\r
 613                         /* I suppose components have same XRsiz, YRsiz */\r
 614                         int x0 = cstr_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;\r
 615                         int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;\r
 616                         int x1 = x0 + cstr_info->tile_x;\r
 617                         int y1 = y0 + cstr_info->tile_y;\r
 618 \r
 619                         // Count the maximum number of precincts\r
 620                         int max_numprec = 0;\r
 621                         for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 622                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 623                                 if (numprec > max_numprec)\r
 624                                         max_numprec = numprec;\r
 625                         }\r
 626 \r
 627                         fprintf(stream, "PCRL\npack_nb tileno precno compno resno layno start_pos end_ph_pos end_pos");\r
 628                         if (disto_on)\r
 629                                 fprintf(stream, " disto");\r
 630                         fprintf(stream,"\n");\r
 631 \r
 632                         for (precno = 0; precno < max_numprec; precno++) {\r
 633                                 for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 634                                         for (resno = 0; resno < cstr_info->numdecompos[compno] + 1; resno++) {\r
 635                                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 636                                                 int pcnx = cstr_info->tile[tileno].pw[resno];\r
 637                                                 int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );\r
 638                                                 int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );\r
 639                                                 int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;\r
 640                                                 int precno_y = (int) floor( (float)precno/(float)pcnx );\r
 641                                                 if (precno >= numprec)\r
 642                                                         continue;\r
 643                                                 for(y = y0; y < y1; y++) {\r
 644                                                         if (precno_y*pcy == y ) {\r
 645                                                                 for (x = x0; x < x1; x++) {\r
 646                                                                         if (precno_x*pcx == x ) {\r
 647                                                                                 for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 648                                                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 649                                                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 650                                                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 651                                                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 652                                                                                         fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d   %9d %7d",\r
 653                                                                                                 pack_nb, tileno, precno, compno, resno, layno, start_pos, end_ph_pos, end_pos);\r
 654                                                                                         if (disto_on)\r
 655                                                                                                 fprintf(stream, " %8e", disto);\r
 656                                                                                         fprintf(stream, "\n");\r
 657                                                                                         total_disto += disto;\r
 658                                                                                         pack_nb++;\r
 659                                                                                 }\r
 660                                                                         }\r
 661                                                                 }/* x = x0..x1 */\r
 662                                                         }\r
 663                                                 }  /* y = y0..y1 */\r
 664                                         } /* resno */\r
 665                                 } /* compno */\r
 666                         } /* precno */\r
 667                 } /* PCRL */\r
 668 \r
 669                 else {  /* CPRL */\r
 670                         // Count the maximum number of precincts\r
 671                         int max_numprec = 0;\r
 672                         for (resno = 0; resno < max_numdecompos + 1; resno++) {\r
 673                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 674                                 if (numprec > max_numprec)\r
 675                                         max_numprec = numprec;\r
 676                         }\r
 677 \r
 678                         fprintf(stream, "CPRL\npack_nb tileno compno precno resno layno start_pos end_ph_pos end_pos");\r
 679                         if (disto_on)\r
 680                                 fprintf(stream, " disto");\r
 681                         fprintf(stream,"\n");\r
 682 \r
 683                         for (compno = 0; compno < cstr_info->numcomps; compno++) {\r
 684                                 /* I suppose components have same XRsiz, YRsiz */\r
 685                                 int x0 = cstr_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;\r
 686                                 int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;\r
 687                                 int x1 = x0 + cstr_info->tile_x;\r
 688                                 int y1 = y0 + cstr_info->tile_y;\r
 689 \r
 690                                 for (precno = 0; precno < max_numprec; precno++) {\r
 691                                         for (resno = 0; resno < cstr_info->numdecompos[compno] + 1; resno++) {\r
 692                                                 int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];\r
 693                                                 int pcnx = cstr_info->tile[tileno].pw[resno];\r
 694                                                 int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );\r
 695                                                 int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );\r
 696                                                 int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;\r
 697                                                 int precno_y = (int) floor( (float)precno/(float)pcnx );\r
 698                                                 if (precno >= numprec)\r
 699                                                         continue;\r
 700 \r
 701                                                 for(y = y0; y < y1; y++) {\r
 702                                                         if (precno_y*pcy == y ) {\r
 703                                                                 for (x = x0; x < x1; x++) {\r
 704                                                                         if (precno_x*pcx == x ) {\r
 705                                                                                 for (layno = 0; layno < cstr_info->numlayers; layno++) {\r
 706                                                                                         start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;\r
 707                                                                                         end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;\r
 708                                                                                         end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;\r
 709                                                                                         disto = cstr_info->tile[tileno].packet[pack_nb].disto;\r
 710                                                                                         fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d   %9d %7d",\r
 711                                                                                                 pack_nb, tileno, compno, precno, resno, layno, start_pos, end_ph_pos, end_pos);\r
 712                                                                                         if (disto_on)\r
 713                                                                                                 fprintf(stream, " %8e", disto);\r
 714                                                                                         fprintf(stream, "\n");\r
 715                                                                                         total_disto += disto;\r
 716                                                                                         pack_nb++;\r
 717                                                                                 }\r
 718                                                                         }\r
 719                                                                 }/* x = x0..x1 */\r
 720                                                         }\r
 721                                                 } /* y = y0..y1 */\r
 722                                         } /* resno */\r
 723                                 } /* precno */\r
 724                         } /* compno */\r
 725                 } /* CPRL */\r
 726         } /* tileno */\r
 727 \r
 728         if (disto_on) {\r
 729                 fprintf(stream, "%8e\n", cstr_info->D_max); /* SE max */\r
 730                 fprintf(stream, "%.8e\n", total_disto); /* SE totale */\r
 731         }\r
 732 /* UniPG>> */\r
 733         /* print the markers' list */\r
 734         if (cstr_info->marknum) {\r
 735                 fprintf(stream, "\nMARKER LIST\n");\r
 736                 fprintf(stream, "%d\n", cstr_info->marknum);\r
 737                 fprintf(stream, "type\tstart_pos    length\n");\r
 738                 for (x = 0; x < cstr_info->marknum; x++)\r
 739                         fprintf(stream, "%X\t%9d %9d\n", cstr_info->marker[x].type, cstr_info->marker[x].pos, cstr_info->marker[x].len);\r
 740         }\r
 741 /* <<UniPG */\r
 742 \r
 743         return EXIT_SUCCESS;\r
 744 }\r
 745 \r
 746 /* ------------------------------------------------------------------------------------ */\r
 747 \r
 748 /**\r
 749 Dump the file info structure into a file\r
 750 @param  stream          output stream\r
 751 @param  file_info       informations read into the JPG2000 file\r
 752 @return Returns 0 if successful, returns 1 otherwise\r
 753 */\r
 754 int dump_file_info(FILE* stream, opj_file_info_t *file_info)\r
 755 {\r
 756         /* IMAGE HEADER */\r
 757         if ( file_info->file_info_flag & OPJ_IMG_INFO ) {\r
 758                 opj_image_header_t img_header = file_info->img_info;\r
 759                 int compno;\r
 760 \r
 761                 fprintf(stream, "Image info {\n");\r
 762                 fprintf(stream, "\t x0=%d, y0=%d\n",img_header.x0, img_header.y0);\r
 763                 fprintf(stream, "\t x1=%d, y1=%d\n",img_header.x1, img_header.y1);\r
 764                 fprintf(stream, "\t numcomps=%d\n", img_header.numcomps);\r
 765                 for (compno = 0; compno < img_header.numcomps; compno++) {\r
 766                         opj_image_comp_header_t comp = img_header.comps[compno];\r
 767 \r
 768                         fprintf(stream, "\t component %d {\n", compno);\r
 769                         fprintf(stream, "\t\t dx=%d, dy=%d\n", comp.dx, comp.dy);\r
 770                         fprintf(stream, "\t\t prec=%d\n", comp.prec);\r
 771                         fprintf(stream, "\t\t sgnd=%d\n", comp.sgnd);\r
 772                         fprintf(stream, "\t}\n");\r
 773                 }\r
 774                 fprintf(stream, "}\n");\r
 775         }\r
 776 \r
 777         /* CODESTREAM INFO */\r
 778         if ( file_info->file_info_flag & OPJ_J2K_INFO ) {\r
 779                 opj_codestream_info_v2_t cstr_info = file_info->codestream_info;\r
 780                 int tileno, compno, layno, bandno, resno, numbands;\r
 781 \r
 782                 fprintf(stream, "Codestream info {\n");\r
 783                 fprintf(stream, "\t tx0=%d, ty0=%d\n", cstr_info.tx0, cstr_info.ty0);\r
 784                 fprintf(stream, "\t tdx=%d, tdy=%d\n", cstr_info.tdx, cstr_info.tdy);\r
 785                 fprintf(stream, "\t tw=%d, th=%d\n", cstr_info.tw, cstr_info.th);\r
 786 \r
 787                 for (tileno = 0; tileno < cstr_info.tw * cstr_info.th; tileno++) {\r
 788                         opj_tile_info_v2_t tile_info = cstr_info.tile[tileno];\r
 789 \r
 790                         fprintf(stream, "\t tile %d {\n", tileno);\r
 791                         fprintf(stream, "\t\t csty=%x\n", tile_info.csty);\r
 792                         fprintf(stream, "\t\t prg=%d\n", tile_info.prg);\r
 793                         fprintf(stream, "\t\t numlayers=%d\n", tile_info.numlayers);\r
 794                         fprintf(stream, "\t\t mct=%d\n", tile_info.mct);\r
 795                         fprintf(stream, "\t\t rates=");\r
 796 \r
 797                         for (layno = 0; layno < tile_info.numlayers; layno++) {\r
 798                                 fprintf(stream, "%.1f ", tile_info.rates[layno]);\r
 799                         }\r
 800                         fprintf(stream, "\n");\r
 801 \r
 802                         for (compno = 0; compno < cstr_info.numcomps; compno++) {\r
 803                                 opj_tccp_info_t tccp_info = tile_info.tccp_info[compno];\r
 804 \r
 805                                 fprintf(stream, "\t\t comp %d {\n", compno);\r
 806                                 fprintf(stream, "\t\t\t csty=%x\n", tccp_info.csty);\r
 807                                 fprintf(stream, "\t\t\t numresolutions=%d\n", tccp_info.numresolutions);\r
 808                                 fprintf(stream, "\t\t\t cblkw=%d\n", tccp_info.cblkw);\r
 809                                 fprintf(stream, "\t\t\t cblkh=%d\n", tccp_info.cblkh);\r
 810                                 fprintf(stream, "\t\t\t cblksty=%x\n", tccp_info.cblksty);\r
 811                                 fprintf(stream, "\t\t\t qmfbid=%d\n", tccp_info.qmfbid);\r
 812                                 fprintf(stream, "\t\t\t qntsty=%d\n", tccp_info.qntsty);\r
 813                                 fprintf(stream, "\t\t\t numgbits=%d\n", tccp_info.numgbits);\r
 814                                 fprintf(stream, "\t\t\t roishift=%d\n", tccp_info.roishift);\r
 815 \r
 816 #ifdef TODO_MSD\r
 817                                 fprintf(stream, "\t\t\t stepsizes=");\r
 818                                 numbands = tccp_info->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : tccp_info->numresolutions * 3 - 2;\r
 819                                 for (bandno = 0; bandno < numbands; bandno++) {\r
 820                                         fprintf(stream, "(%d,%d) ", tccp_info->stepsizes[bandno].mant,\r
 821                                                 tccp_info->stepsizes[bandno].expn);\r
 822                                 }\r
 823                                 fprintf(stream, "\n");\r
 824 \r
 825                                 if (tccp_info->csty & J2K_CCP_CSTY_PRT) {\r
 826                                         fprintf(stream, "      prcw=");\r
 827                                         for (resno = 0; resno < tccp_info->numresolutions; resno++) {\r
 828                                                 fprintf(stream, "%d ", tccp_info->prcw[resno]);\r
 829                                         }\r
 830                                         fprintf(stream, "\n");\r
 831 \r
 832                                         fprintf(stream, "      prch=");\r
 833                                         for (resno = 0; resno < tccp_info->numresolutions; resno++) {\r
 834                                                 fprintf(stream, "%d ", tccp_info->prch[resno]);\r
 835                                         }\r
 836                                         fprintf(stream, "\n");\r
 837                                 }\r
 838 #endif\r
 839                                 fprintf(stream, "\t\t\t }\n");\r
 840                         } /*end of component*/\r
 841                         fprintf(stream, "\t\t }\n");\r
 842                 } /*end of tile */\r
 843                 fprintf(stream, "\t }\n");\r
 844         }\r
 845 \r
 846         if ( file_info->file_info_flag & OPJ_JP2_INFO ) {\r
 847                 // not yet coded\r
 848         }\r
 849         return EXIT_SUCCESS;\r
 850 }\r