mj2/wrap_j2k_in_mj2.c

   1 /*
   2  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   3  * Copyright (c) 2002-2007, Professor Benoit Macq
   4  * Copyright (c) 2003-2007, Francois-Olivier Devaux
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include "openjpeg.h"
  34 #include "j2k.h"
  35 #include "jp2.h"
  36 #include "cio.h"
  37 #include "mj2.h"
  38
  39 static int int_ceildiv(int a, int b) {
  40         return (a + b - 1) / b;
  41 }
  42
  43 /**
  44 Size of memory first allocated for MOOV box
  45 */
  46 #define TEMP_BUF 10000
  47
  48
  49 /* -------------------------------------------------------------------------- */
  50
  51 /**
  52 sample error callback expecting a FILE* client object
  53 */
  54 void error_callback(const char *msg, void *client_data) {
  55         FILE *stream = (FILE*)client_data;
  56         fprintf(stream, "[ERROR] %s", msg);
  57 }
  58 /**
  59 sample warning callback expecting a FILE* client object
  60 */
  61 void warning_callback(const char *msg, void *client_data) {
  62         FILE *stream = (FILE*)client_data;
  63         fprintf(stream, "[WARNING] %s", msg);
  64 }
  65 /**
  66 sample debug callback expecting a FILE* client object
  67 */
  68 void info_callback(const char *msg, void *client_data) {
  69         FILE *stream = (FILE*)client_data;
  70         fprintf(stream, "[INFO] %s", msg);
  71 }
  72
  73 /* -------------------------------------------------------------------------- */
  74
  75
  76
  77 static void read_siz_marker(FILE *file, opj_image_t *image)
  78 {
  79   int len,i;
  80   char buf, buf2[2];
  81   unsigned char *siz_buffer;
  82         opj_cio_t *cio;
  83
  84   fseek(file, 0, SEEK_SET);
  85   do {
  86     fread(&buf,1,1, file);
  87     if (buf==(char)0xff)
  88       fread(&buf,1,1, file);
  89   }
  90   while (!(buf==(char)0x51));
  91
  92   fread(buf2,2,1,file);         /* Lsiz                */
  93   len = ((buf2[0])<<8) + buf2[1];
  94
  95   siz_buffer = (unsigned char*) malloc(len * sizeof(unsigned char));
  96   fread(siz_buffer,len, 1, file);
  97         cio = opj_cio_open(NULL, siz_buffer, len);
  98
  99   cio_read(cio, 2);                     /* Rsiz (capabilities) */
 100   image->x1 = cio_read(cio, 4); /* Xsiz                */
 101   image->y1 = cio_read(cio, 4); /* Ysiz                */
 102   image->x0 = cio_read(cio, 4); /* X0siz               */
 103   image->y0 = cio_read(cio, 4); /* Y0siz               */
 104   cio_skip(cio, 16);                    /* XTsiz, YTsiz, XT0siz, YT0siz        */
 105
 106   image->numcomps = cio_read(cio,2);    /* Csiz                */
 107   image->comps =
 108     (opj_image_comp_t *) malloc(image->numcomps * sizeof(opj_image_comp_t));
 109
 110   for (i = 0; i < image->numcomps; i++) {
 111     int tmp;
 112     tmp = cio_read(cio,1);              /* Ssiz_i          */
 113     image->comps[i].prec = (tmp & 0x7f) + 1;
 114     image->comps[i].sgnd = tmp >> 7;
 115     image->comps[i].dx = cio_read(cio,1);       /* XRsiz_i         */
 116     image->comps[i].dy = cio_read(cio,1);       /* YRsiz_i         */
 117     image->comps[i].resno_decoded = 0;  /* number of resolution decoded */
 118     image->comps[i].factor = 0; /* reducing factor by component */
 119   }
 120   fseek(file, 0, SEEK_SET);
 121         opj_cio_close(cio);
 122   free(siz_buffer);
 123 }
 124
 125 static void setparams(opj_mj2_t *movie, opj_image_t *image) {
 126   int i, depth_0, depth, sign;
 127
 128   movie->tk[0].sample_rate = 25;
 129   movie->tk[0].w = int_ceildiv(image->x1 - image->x0, image->comps[0].dx);
 130   movie->tk[0].h = int_ceildiv(image->y1 - image->y0, image->comps[0].dy);
 131   mj2_init_stdmovie(movie);
 132
 133   movie->tk[0].depth = image->comps[0].prec;
 134
 135   if (image->numcomps==3) {
 136     if ((image->comps[0].dx == 1) && (image->comps[1].dx == 1) && (image->comps[1].dx == 1))
 137       movie->tk[0].CbCr_subsampling_dx = 1;
 138     else if ((image->comps[0].dx == 1) && (image->comps[1].dx == 2) && (image->comps[1].dx == 2))
 139       movie->tk[0].CbCr_subsampling_dx = 2;
 140     else
 141       fprintf(stderr,"Image component sizes are incoherent\n");
 142
 143     if ((image->comps[0].dy == 1) && (image->comps[1].dy == 1) && (image->comps[1].dy == 1))
 144       movie->tk[0].CbCr_subsampling_dy = 1;
 145     else if ((image->comps[0].dy == 1) && (image->comps[1].dy == 2) && (image->comps[1].dy == 2))
 146       movie->tk[0].CbCr_subsampling_dy = 2;
 147     else
 148       fprintf(stderr,"Image component sizes are incoherent\n");
 149   }
 150
 151   movie->tk[0].sample_rate = 25;
 152
 153   movie->tk[0].jp2_struct.numcomps = image->numcomps;   // NC
 154
 155         /* Init Standard jp2 structure */
 156
 157         movie->tk[0].jp2_struct.comps =
 158     (opj_jp2_comps_t *) malloc(movie->tk[0].jp2_struct.numcomps * sizeof(opj_jp2_comps_t));
 159   movie->tk[0].jp2_struct.precedence = 0;   /* PRECEDENCE*/
 160   movie->tk[0].jp2_struct.approx = 0;   /* APPROX*/
 161   movie->tk[0].jp2_struct.brand = JP2_JP2;      /* BR         */
 162   movie->tk[0].jp2_struct.minversion = 0;       /* MinV       */
 163   movie->tk[0].jp2_struct.numcl = 1;
 164   movie->tk[0].jp2_struct.cl = (unsigned int *) malloc(movie->tk[0].jp2_struct.numcl * sizeof(int));
 165   movie->tk[0].jp2_struct.cl[0] = JP2_JP2;      /* CL0 : JP2  */
 166   movie->tk[0].jp2_struct.C = 7;      /* C : Always 7*/
 167   movie->tk[0].jp2_struct.UnkC = 0;      /* UnkC, colorspace specified in colr box*/
 168   movie->tk[0].jp2_struct.IPR = 0;      /* IPR, no intellectual property*/
 169   movie->tk[0].jp2_struct.w = int_ceildiv(image->x1 - image->x0, image->comps[0].dx);
 170   movie->tk[0].jp2_struct.h = int_ceildiv(image->y1 - image->y0, image->comps[0].dy);
 171
 172   depth_0 = image->comps[0].prec - 1;
 173   sign = image->comps[0].sgnd;
 174   movie->tk[0].jp2_struct.bpc = depth_0 + (sign << 7);
 175
 176   for (i = 1; i < image->numcomps; i++) {
 177     depth = image->comps[i].prec - 1;
 178     sign = image->comps[i].sgnd;
 179     if (depth_0 != depth)
 180       movie->tk[0].jp2_struct.bpc = 255;
 181   }
 182
 183   for (i = 0; i < image->numcomps; i++)
 184     movie->tk[0].jp2_struct.comps[i].bpcc =
 185     image->comps[i].prec - 1 + (image->comps[i].sgnd << 7);
 186
 187   if ((image->numcomps == 1 || image->numcomps == 3)
 188     && (movie->tk[0].jp2_struct.bpc != 255))
 189     movie->tk[0].jp2_struct.meth = 1;
 190   else
 191     movie->tk[0].jp2_struct.meth = 2;
 192
 193   if (image->numcomps == 1)
 194     movie->tk[0].jp2_struct.enumcs = 17;  // Grayscale
 195
 196   else   if ((image->comps[0].dx == 1) && (image->comps[1].dx == 1) && (image->comps[1].dx == 1) &&
 197     (image->comps[0].dy == 1) && (image->comps[1].dy == 1) && (image->comps[1].dy == 1))
 198     movie->tk[0].jp2_struct.enumcs = 16;    // RGB
 199
 200   else   if ((image->comps[0].dx == 1) && (image->comps[1].dx == 2) && (image->comps[1].dx == 2) &&
 201     (image->comps[0].dy == 1) && (image->comps[1].dy == 2) && (image->comps[1].dy == 2))
 202     movie->tk[0].jp2_struct.enumcs = 18;  // YUV
 203
 204   else
 205     movie->tk[0].jp2_struct.enumcs = 0; // Unkown profile */
 206 }
 207
 208 int main(int argc, char *argv[]) {
 209         opj_cinfo_t* cinfo;
 210         opj_event_mgr_t event_mgr;              /* event manager */
 211   unsigned int snum;
 212   opj_mj2_t *movie;
 213   mj2_sample_t *sample;
 214   unsigned char* frame_codestream;
 215   FILE *mj2file, *j2kfile;
 216   char j2kfilename[50];
 217   unsigned char *buf;
 218   int offset, mdat_initpos;
 219   opj_image_t img;
 220         opj_cio_t *cio;
 221         mj2_cparameters_t parameters;
 222
 223   if (argc != 3) {
 224     printf("Bad syntax: Usage: MJ2_Wrapper source_location mj2_filename\n");
 225     printf("Example: MJ2_Wrapper input/input output.mj2\n");
 226     return 1;
 227   }
 228
 229   mj2file = fopen(argv[2], "wb");
 230
 231   if (!mj2file) {
 232     fprintf(stderr, "failed to open %s for writing\n", argv[2]);
 233     return 1;
 234   }
 235
 236         /*
 237         configure the event callbacks (not required)
 238         setting of each callback is optionnal
 239         */
 240         memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
 241         event_mgr.error_handler = error_callback;
 242         event_mgr.warning_handler = warning_callback;
 243         event_mgr.info_handler = info_callback;
 244
 245         /* get a MJ2 decompressor handle */
 246         cinfo = mj2_create_compress();
 247
 248         /* catch events using our callbacks and give a local context */
 249         opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
 250
 251         /* setup the decoder encoding parameters using user parameters */
 252         movie = (opj_mj2_t*) cinfo->mj2_handle;
 253         mj2_setup_encoder((opj_mj2_t*)cinfo->mj2_handle, &parameters);
 254
 255
 256         /* Writing JP, FTYP and MDAT boxes
 257         Assuming that the JP and FTYP boxes won't be longer than 300 bytes */
 258
 259   buf = (unsigned char*) malloc (300 * sizeof(unsigned char));
 260   cio = opj_cio_open(movie->cinfo, buf, 300);
 261   mj2_write_jp(cio);
 262   mj2_write_ftyp(movie, cio);
 263   mdat_initpos = cio_tell(cio);
 264   cio_skip(cio, 4);
 265   cio_write(cio,MJ2_MDAT, 4);
 266   fwrite(buf,cio_tell(cio),1,mj2file);
 267   free(buf);
 268
 269   // Insert each j2k codestream in a JP2C box
 270   snum=0;
 271   offset = 0;
 272   while(1)
 273   {
 274     sample = &movie->tk[0].sample[snum];
 275     sprintf(j2kfilename,"%s_%05d.j2k",argv[1],snum);
 276     j2kfile = fopen(j2kfilename, "rb");
 277     if (!j2kfile) {
 278       if (snum==0) {  // Could not open a single codestream
 279                                 fprintf(stderr, "failed to open %s for reading\n",j2kfilename);
 280                                 return 1;
 281       }
 282       else {          // Tried to open a inexistant codestream
 283                                 fprintf(stdout,"%d frames are being added to the MJ2 file\n",snum);
 284                                 break;
 285       }
 286     }
 287
 288     // Calculating offset for samples and chunks
 289     offset += cio_tell(cio);
 290     sample->offset = offset;
 291     movie->tk[0].chunk[snum].offset = offset;  // There will be one sample per chunk
 292
 293     // Calculating sample size
 294     fseek(j2kfile,0,SEEK_END);
 295     sample->sample_size = ftell(j2kfile) + 8; // Sample size is codestream + JP2C box header
 296     fseek(j2kfile,0,SEEK_SET);
 297
 298     // Reading siz marker of j2k image for the first codestream
 299     if (snum==0)
 300       read_siz_marker(j2kfile, &img);
 301
 302     // Writing JP2C box header
 303     frame_codestream = (unsigned char*) malloc (sample->sample_size+8);
 304                 cio = opj_cio_open(movie->cinfo, frame_codestream, sample->sample_size);
 305     cio_write(cio,sample->sample_size, 4);  // Sample size
 306     cio_write(cio,JP2_JP2C, 4); // JP2C
 307
 308     // Writing codestream from J2K file to MJ2 file
 309     fread(frame_codestream+8,sample->sample_size-8,1,j2kfile);
 310     fwrite(frame_codestream,sample->sample_size,1,mj2file);
 311     cio_skip(cio, sample->sample_size-8);
 312
 313     // Ending loop
 314     fclose(j2kfile);
 315     snum++;
 316     movie->tk[0].sample = (mj2_sample_t*)
 317                 realloc(movie->tk[0].sample, (snum+1) * sizeof(mj2_sample_t));
 318     movie->tk[0].chunk = (mj2_chunk_t*)
 319                 realloc(movie->tk[0].chunk, (snum+1) * sizeof(mj2_chunk_t));
 320     free(frame_codestream);
 321   }
 322
 323   // Writing the MDAT box length in header
 324   offset += cio_tell(cio);
 325   buf = (unsigned char*) malloc (4 * sizeof(unsigned char));
 326         cio = opj_cio_open(movie->cinfo, buf, 4);
 327   cio_write(cio,offset-mdat_initpos,4);
 328   fseek(mj2file,(long)mdat_initpos,SEEK_SET);
 329   fwrite(buf,4,1,mj2file);
 330   fseek(mj2file,0,SEEK_END);
 331   free(buf);
 332
 333   // Setting movie parameters
 334   movie->tk[0].num_samples=snum;
 335   movie->tk[0].num_chunks=snum;
 336   setparams(movie, &img);
 337
 338   // Writing MOOV box
 339         buf = (unsigned char*) malloc ((TEMP_BUF+snum*20) * sizeof(unsigned char));
 340         cio = opj_cio_open(movie->cinfo, buf, (TEMP_BUF+snum*20));
 341         mj2_write_moov(movie, cio);
 342   fwrite(buf,cio_tell(cio),1,mj2file);
 343
 344   // Ending program
 345   fclose(mj2file);
 346   free(img.comps);
 347   opj_cio_close(cio);
 348   mj2_destroy_compress(movie);
 349
 350   return 0;
 351 }