applications/jpip/tools/indexer/ext_libopenjpeg/thix_manager.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) 2003-2004, Yannick Verschueren
   7  * Copyright (c) 2010-2011, Kaori Hagihara
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*! \file
  33  *  \brief Modification of jpip.c from 2KAN indexer
  34  */
  35
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include "indexbox_manager.h"
  40 #include "cio_ext.h"
  41 #include "cio.h"
  42
  43 /*
  44  * Write tile-part headers mhix box
  45  *
  46  * @param[in] coff      offset of j2k codestream
  47  * @param[in] cstr_info codestream information
  48  * @param[in] tileno    tile number
  49  * @param[in] cio       file output handle
  50  * @return              length of mhix box
  51  */
  52 int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio);
  53
  54 int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
  55 {
  56   int len, lenp, i;
  57   int tileno;
  58   opj_jp2_box_t *box;
  59
  60   lenp = 0;
  61   box = (opj_jp2_box_t *)calloc( cstr_info.tw*cstr_info.th, sizeof(opj_jp2_box_t));
  62
  63   for ( i = 0; i < 2 ; i++ ){
  64     if (i)
  65       cio_seek( cio, lenp);
  66
  67     lenp = cio_tell( cio);
  68     cio_skip( cio, 4);              /* L [at the end] */
  69     cio_write( cio, JPIP_THIX, 4);  /* THIX           */
  70     write_manf( i, cstr_info.tw*cstr_info.th, box, cio);
  71
  72     for (tileno = 0; tileno < cstr_info.tw*cstr_info.th; tileno++){
  73       box[tileno].length = write_tilemhix( coff, cstr_info, tileno, cio);
  74       box[tileno].type = JPIP_MHIX;
  75     }
  76
  77     len = cio_tell( cio)-lenp;
  78     cio_seek( cio, lenp);
  79     cio_write( cio, len, 4);        /* L              */
  80     cio_seek( cio, lenp+len);
  81   }
  82
  83   free(box);
  84
  85   return len;
  86 }
  87
  88
  89 /*
  90  * Find tile markers
  91  *
  92  * @param[in]  coff     offset of j2k codestream
  93  * @param[in]  startpos tile start byte position
  94  * @param[in]  endpos   tile end position
  95  * @param[in]  cio      file output handle
  96  * @param[out] marknum  pointer to number of markers
  97  * @return              found marker information array
  98  */
  99 opj_marker_info_t * find_tile_markers( int coff, int startpos, int endpos, opj_cio_t *cio, int *marknum);
 100
 101 int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio)
 102 {
 103   int i;
 104   opj_tile_info_t tile;
 105   opj_tp_info_t tp;
 106   int marknum;
 107   int len, lenp;
 108   opj_marker_info_t *marker;
 109
 110   lenp = cio_tell( cio);
 111   cio_skip( cio, 4);                               /* L [at the end]                    */
 112   cio_write( cio, JPIP_MHIX, 4);                   /* MHIX                              */
 113
 114   tile = cstr_info.tile[tileno];
 115   tp = tile.tp[0];
 116
 117   cio_ext_write( cio, tp.tp_end_header-tp.tp_start_pos+1, 8);  /* TLEN                              */
 118
 119   marker = find_tile_markers( coff, tile.start_pos, tile.end_header, cio, &marknum);
 120
 121   for( i=0; i<marknum; i++){             /* Marker restricted to 1 apparition */
 122     cio_write( cio, marker[i].type, 2);
 123     cio_write( cio, 0, 2);
 124     cio_ext_write( cio, marker[i].pos, 8);
 125     cio_write( cio, marker[i].len, 2);
 126   }
 127
 128   free( marker);
 129
 130   len = cio_tell( cio) - lenp;
 131   cio_seek( cio, lenp);
 132   cio_write( cio, len, 4);        /* L           */
 133   cio_seek( cio, lenp+len);
 134
 135   return len;
 136 }
 137
 138
 139 /*
 140  * Get tile marker size
 141  *
 142  * @param[in] type marker type
 143  * @param[in] cio  file input handle
 144  * @return         marker size
 145  */
 146 unsigned short get_tile_markersize( unsigned short type, opj_cio_t *cio);
 147
 148 opj_marker_info_t * find_tile_markers( int coff, int startpos, int endpos, opj_cio_t *cio, int *marknum)
 149 {
 150   int org_pos, pos;
 151   opj_marker_info_t *marker, *tmp;
 152   int max_num_of_markers = 100;
 153
 154   marker = (opj_marker_info_t *)malloc( max_num_of_markers*sizeof(opj_marker_info_t));
 155   if( !marker){
 156     fprintf( stderr, "malloc error for marker in find_tile_markers()\n");
 157     exit(-1);
 158   }
 159   (*marknum) = 0;
 160
 161   org_pos = cio_tell( cio);
 162   cio_seek( cio, coff+startpos);
 163   pos = startpos;
 164
 165   while( pos < coff+endpos){
 166     if( *marknum >= max_num_of_markers){
 167       tmp = marker;
 168       marker = (opj_marker_info_t *)malloc( (max_num_of_markers+100)*sizeof(opj_marker_info_t));
 169       memcpy( marker, tmp, max_num_of_markers*sizeof(opj_marker_info_t));
 170       free( tmp);
 171       max_num_of_markers += 100;
 172     }
 173
 174     marker[*marknum].type = cio_read( cio, 2);
 175     marker[*marknum].pos  = cio_tell( cio)-coff;
 176     marker[*marknum].len  = get_tile_markersize( marker[*marknum].type, cio);
 177     cio_skip( cio, marker[*marknum].len);
 178
 179     (*marknum)++;
 180     pos += 2+marker[*marknum].len;
 181   }
 182
 183   cio_seek( cio, org_pos);
 184
 185   return marker;
 186 }
 187
 188 unsigned short get_tile_markersize( unsigned short type, opj_cio_t *cio)
 189 {
 190   unsigned short siz;
 191   int pos;
 192
 193   siz = 0;
 194
 195   switch( type){
 196   case J2K_MS_SOD:
 197   case J2K_MS_EOC:
 198   case J2K_MS_EPH:
 199     siz = 0;
 200     break;
 201   default:
 202     pos = cio_tell( cio);
 203     siz = cio_read( cio, 2);
 204     cio_seek( cio, pos);
 205     break;
 206   }
 207   return siz;
 208 }