libopenjpeg/jpwl/jpwl_lib.c

   1 /*
   2  * Copyright (c) 2001-2003, David Janssens
   3  * Copyright (c) 2002-2003, Yannick Verschueren
   4  * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
   5  * Copyright (c) 2005, Herve Drolon, FreeImage Team
   6  * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
   7  * Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy
   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 #ifdef USE_JPWL
  33
  34 #include "../libopenjpeg/opj_includes.h"
  35 #include <limits.h>
  36
  37 /** Minimum and maximum values for the double->pfp conversion */
  38 #define MIN_V1 0.0
  39 #define MAX_V1 17293822569102704640.0
  40 #define MIN_V2 0.000030517578125
  41 #define MAX_V2 131040.0
  42
  43 /** conversion between a double precision floating point
  44 number and the corresponding pseudo-floating point used
  45 to represent sensitivity values
  46 @param V the double precision value
  47 @param bytes the number of bytes of the representation
  48 @return the pseudo-floating point value (cast accordingly)
  49 */
  50 unsigned short int jpwl_double_to_pfp(double V, int bytes);
  51
  52 /** conversion between a pseudo-floating point used
  53 to represent sensitivity values and the corresponding
  54 double precision floating point number
  55 @param em the pseudo-floating point value (cast accordingly)
  56 @param bytes the number of bytes of the representation
  57 @return the double precision value
  58 */
  59 double jpwl_pfp_to_double(unsigned short int em, int bytes);
  60
  61         /*-------------------------------------------------------------*/
  62
  63 int jpwl_markcomp(const void *arg1, const void *arg2)
  64 {
  65    /* Compare the two markers' positions */
  66    double diff = (((jpwl_marker_t *) arg1)->dpos - ((jpwl_marker_t *) arg2)->dpos);
  67
  68    if (diff == 0.0)
  69            return (0);
  70    else if (diff < 0)
  71            return (-1);
  72    else
  73            return (+1);
  74 }
  75
  76 int jpwl_epbs_add(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int *jwmarker_num,
  77                                   bool latest, bool packed, bool insideMH, int *idx, int hprot,
  78                                   double place_pos, int tileno,
  79                                   unsigned long int pre_len, unsigned long int post_len) {
  80
  81         jpwl_epb_ms_t *epb_mark = NULL;
  82
  83         int k_pre, k_post, n_pre, n_post;
  84
  85         unsigned long int L1, L2, dL4, max_postlen, epbs_len = 0;
  86
  87         /* We find RS(n,k) for EPB parms and pre-data, if any */
  88         if (insideMH && (*idx == 0)) {
  89                 /* First EPB in MH */
  90                 k_pre = 64;
  91                 n_pre = 160;
  92         } else if (!insideMH && (*idx == 0)) {
  93                 /* First EPB in TH */
  94                 k_pre = 25;
  95                 n_pre = 80;
  96         } else {
  97                 /* Following EPBs in MH or TH */
  98                 k_pre = 13;
  99                 n_pre = 40;
 100         };
 101
 102         /* Find lengths, Figs. B3 and B4 */
 103         /* size of pre data: pre_buf(pre_len) + EPB(2) + Lepb(2) + Depb(1) + LDPepb(4) + Pepb(4) */
 104         L1 = pre_len + 13;
 105
 106         /* size of pre-data redundancy */
 107         /*   (redundancy per codeword)       *     (number of codewords, rounded up)   */
 108         L2 = (n_pre - k_pre) * (unsigned long int) ceil((double) L1 / (double) k_pre);
 109
 110         /* Find protection type for post data and its associated redundancy field length*/
 111         if ((hprot == 16) || (hprot == 32)) {
 112                 /* there is a CRC for post-data */
 113                 k_post = post_len;
 114                 n_post = post_len + (hprot >> 3);
 115                 /*L3 = hprot >> 3;*/ /* 2 (CRC-16) or 4 (CRC-32) bytes */
 116
 117         } else if ((hprot >= 37) && (hprot <= 128)) {
 118                 /* there is a RS for post-data */
 119                 k_post = 32;
 120                 n_post = hprot;
 121
 122         } else {
 123                 /* Use predefined codes */
 124                 n_post = n_pre;
 125                 k_post = k_pre;
 126         };
 127
 128         /* Create the EPB(s) */
 129         while (post_len > 0) {
 130
 131                 /* maximum postlen in order to respect EPB size
 132                 (we use JPWL_MAXIMUM_EPB_ROOM instead of 65535 for keeping room for EPB parms)*/
 133                 /*      (message word size)    *            (number of containable parity words)  */
 134                 max_postlen = k_post * (unsigned long int) floor((double) JPWL_MAXIMUM_EPB_ROOM / (double) (n_post - k_post));
 135
 136                 /* maximum postlen in order to respect EPB size */
 137                 if (*idx == 0)
 138                         /* (we use (JPWL_MAXIMUM_EPB_ROOM - L2) instead of 65535 for keeping room for EPB parms + pre-data) */
 139                         /*      (message word size)    *                   (number of containable parity words)  */
 140                         max_postlen = k_post * (unsigned long int) floor((double) (JPWL_MAXIMUM_EPB_ROOM - L2) / (double) (n_post - k_post));
 141
 142                 else
 143                         /* (we use JPWL_MAXIMUM_EPB_ROOM instead of 65535 for keeping room for EPB parms) */
 144                         /*      (message word size)    *            (number of containable parity words)  */
 145                         max_postlen = k_post * (unsigned long int) floor((double) JPWL_MAXIMUM_EPB_ROOM / (double) (n_post - k_post));
 146
 147                 /* null protection case */
 148                 /* the max post length can be as large as the LDPepb field can host */
 149                 if (hprot == 0)
 150                         max_postlen = INT_MAX;
 151
 152                 /* length to use */
 153                 dL4 = min(max_postlen, post_len);
 154
 155                 if ((epb_mark = jpwl_epb_create(
 156                         j2k, /* this encoder handle */
 157                         latest ? (dL4 < max_postlen) : false, /* is it the latest? */
 158                         packed, /* is it packed? */
 159                         tileno, /* we are in TPH */
 160                         *idx, /* its index */
 161                         hprot, /* protection type parameters of following data */
 162                         0, /* pre-data: nothing for now */
 163                         dL4 /* post-data: the stub computed previously */
 164                         ))) {
 165
 166                         /* Add this marker to the 'insertanda' list */
 167                         if (*jwmarker_num < JPWL_MAX_NO_MARKERS) {
 168                                 jwmarker[*jwmarker_num].id = J2K_MS_EPB; /* its type */
 169                                 jwmarker[*jwmarker_num].m.epbmark = epb_mark; /* the EPB */
 170                                 jwmarker[*jwmarker_num].pos = (int) place_pos; /* after SOT */
 171                                 jwmarker[*jwmarker_num].dpos = place_pos + 0.0000001 * (double)(*idx); /* not very first! */
 172                                 jwmarker[*jwmarker_num].len = epb_mark->Lepb; /* its length */
 173                                 jwmarker[*jwmarker_num].len_ready = true; /* ready */
 174                                 jwmarker[*jwmarker_num].pos_ready = true; /* ready */
 175                                 jwmarker[*jwmarker_num].parms_ready = true; /* ready */
 176                                 jwmarker[*jwmarker_num].data_ready = false; /* not ready */
 177                                 (*jwmarker_num)++;
 178                         }
 179
 180                         /* increment epb index */
 181                         (*idx)++;
 182
 183                         /* decrease postlen */
 184                         post_len -= dL4;
 185
 186                         /* increase the total length of EPBs */
 187                         epbs_len += epb_mark->Lepb + 2;
 188
 189                 } else {
 190                         /* ooops, problems */
 191                         opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH EPB for UEP in tile %d\n", tileno);
 192                 };
 193         }
 194
 195         return epbs_len;
 196 }
 197
 198
 199 jpwl_epb_ms_t *jpwl_epb_create(opj_j2k_t *j2k, bool latest, bool packed, int tileno, int idx, int hprot,
 200                                                   unsigned long int pre_len, unsigned long int post_len) {
 201
 202         jpwl_epb_ms_t *epb = NULL;
 203         /*unsigned short int data_len = 0;*/
 204         unsigned short int L2, L3;
 205         unsigned long int L1, L4;
 206         /*unsigned char *predata_in = NULL;*/
 207
 208         bool insideMH = (tileno == -1);
 209
 210         /* Alloc space */
 211         if (!(epb = (jpwl_epb_ms_t *) opj_malloc((size_t) 1 * sizeof (jpwl_epb_ms_t)))) {
 212                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not allocate room for one EPB MS\n");
 213                 return NULL;
 214         };
 215
 216         /* We set RS(n,k) for EPB parms and pre-data, if any */
 217         if (insideMH && (idx == 0)) {
 218                 /* First EPB in MH */
 219                 epb->k_pre = 64;
 220                 epb->n_pre = 160;
 221         } else if (!insideMH && (idx == 0)) {
 222                 /* First EPB in TH */
 223                 epb->k_pre = 25;
 224                 epb->n_pre = 80;
 225         } else {
 226                 /* Following EPBs in MH or TH */
 227                 epb->k_pre = 13;
 228                 epb->n_pre = 40;
 229         };
 230
 231         /* Find lengths, Figs. B3 and B4 */
 232         /* size of pre data: pre_buf(pre_len) + EPB(2) + Lepb(2) + Depb(1) + LDPepb(4) + Pepb(4) */
 233         L1 = pre_len + 13;
 234         epb->pre_len = pre_len;
 235
 236         /* size of pre-data redundancy */
 237         /*   (redundancy per codeword)       *               (number of codewords, rounded up)   */
 238         L2 = (epb->n_pre - epb->k_pre) * (unsigned short int) ceil((double) L1 / (double) epb->k_pre);
 239
 240         /* length of post-data */
 241         L4 = post_len;
 242         epb->post_len = post_len;
 243
 244         /* Find protection type for post data and its associated redundancy field length*/
 245         if ((hprot == 16) || (hprot == 32)) {
 246                 /* there is a CRC for post-data */
 247                 epb->Pepb = 0x10000000 | ((unsigned long int) hprot >> 5); /* 0=CRC-16, 1=CRC-32 */
 248                 epb->k_post = post_len;
 249                 epb->n_post = post_len + (hprot >> 3);
 250                 /*L3 = hprot >> 3;*/ /* 2 (CRC-16) or 4 (CRC-32) bytes */
 251
 252         } else if ((hprot >= 37) && (hprot <= 128)) {
 253                 /* there is a RS for post-data */
 254                 epb->Pepb = 0x20000020 | (((unsigned long int) hprot & 0x000000FF) << 8);
 255                 epb->k_post = 32;
 256                 epb->n_post = hprot;
 257
 258         } else if (hprot == 1) {
 259                 /* Use predefined codes */
 260                 epb->Pepb = (unsigned long int) 0x00000000;
 261                 epb->n_post = epb->n_pre;
 262                 epb->k_post = epb->k_pre;
 263
 264         } else if (hprot == 0) {
 265                 /* Placeholder EPB: only protects its parameters, no protection method */
 266                 epb->Pepb = (unsigned long int) 0xFFFFFFFF;
 267                 epb->n_post = 1;
 268                 epb->k_post = 1;
 269
 270         } else {
 271                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Invalid protection value for EPB h = %d\n", hprot);
 272                 return NULL;
 273         }
 274
 275         epb->hprot = hprot;
 276
 277         /*   (redundancy per codeword)          *                (number of codewords, rounded up) */
 278         L3 = (epb->n_post - epb->k_post) * (unsigned short int) ceil((double) L4 / (double) epb->k_post);
 279
 280         /* private fields */
 281         epb->tileno = tileno;
 282
 283         /* Fill some fields of the EPB */
 284
 285         /* total length of the EPB MS (less the EPB marker itself): */
 286         /* Lepb(2) + Depb(1) + LDPepb(4) + Pepb(4) + pre_redundancy + post-redundancy */
 287         epb->Lepb = 11 + L2 + L3;
 288
 289         /* EPB style */
 290         epb->Depb = ((packed & 0x0001) << 7) | ((latest & 0x0001) << 6) | (idx & 0x003F);
 291
 292         /* length of data protected by EPB: */
 293         epb->LDPepb = L1 + L4;
 294
 295         return epb;
 296 }
 297
 298 void jpwl_epb_write(opj_j2k_t *j2k, jpwl_epb_ms_t *epb, unsigned char *buf) {
 299
 300         /* Marker */
 301         *(buf++) = (unsigned char) (J2K_MS_EPB >> 8);
 302         *(buf++) = (unsigned char) (J2K_MS_EPB >> 0);
 303
 304         /* Lepb */
 305         *(buf++) = (unsigned char) (epb->Lepb >> 8);
 306         *(buf++) = (unsigned char) (epb->Lepb >> 0);
 307
 308         /* Depb */
 309         *(buf++) = (unsigned char) (epb->Depb >> 0);
 310
 311         /* LDPepb */
 312         *(buf++) = (unsigned char) (epb->LDPepb >> 24);
 313         *(buf++) = (unsigned char) (epb->LDPepb >> 16);
 314         *(buf++) = (unsigned char) (epb->LDPepb >> 8);
 315         *(buf++) = (unsigned char) (epb->LDPepb >> 0);
 316
 317         /* Pepb */
 318         *(buf++) = (unsigned char) (epb->Pepb >> 24);
 319         *(buf++) = (unsigned char) (epb->Pepb >> 16);
 320         *(buf++) = (unsigned char) (epb->Pepb >> 8);
 321         *(buf++) = (unsigned char) (epb->Pepb >> 0);
 322
 323         /* Data */
 324         /*memcpy(buf, epb->data, (size_t) epb->Lepb - 11);*/
 325         memset(buf, 0, (size_t) epb->Lepb - 11);
 326
 327         /* update markers struct */
 328         j2k_add_marker(j2k->cstr_info, J2K_MS_EPB, -1, epb->Lepb + 2);
 329
 330 };
 331
 332
 333 jpwl_epc_ms_t *jpwl_epc_create(opj_j2k_t *j2k, bool esd_on, bool red_on, bool epb_on, bool info_on) {
 334
 335         jpwl_epc_ms_t *epc = NULL;
 336
 337         /* Alloc space */
 338         if (!(epc = (jpwl_epc_ms_t *) opj_malloc((size_t) 1 * sizeof (jpwl_epc_ms_t)))) {
 339                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not allocate room for EPC MS\n");
 340                 return NULL;
 341         };
 342
 343         /* Set the EPC parameters */
 344         epc->esd_on = esd_on;
 345         epc->epb_on = epb_on;
 346         epc->red_on = red_on;
 347         epc->info_on = info_on;
 348
 349         /* Fill the EPC fields with default values */
 350         epc->Lepc = 9;
 351         epc->Pcrc = 0x0000;
 352         epc->DL = 0x00000000;
 353         epc->Pepc = ((j2k->cp->esd_on & 0x0001) << 4) | ((j2k->cp->red_on & 0x0001) << 5) |
 354                 ((j2k->cp->epb_on & 0x0001) << 6) | ((j2k->cp->info_on & 0x0001) << 7);
 355
 356         return (epc);
 357 }
 358
 359 bool jpwl_epb_fill(opj_j2k_t *j2k, jpwl_epb_ms_t *epb, unsigned char *buf, unsigned char *post_buf) {
 360
 361         unsigned long int L1, L2, L3, L4;
 362         int remaining;
 363         unsigned long int P, NN_P;
 364
 365         /* Operating buffer */
 366         static unsigned char codeword[NN], *parityword;
 367
 368         unsigned char *L1_buf, *L2_buf;
 369         /* these ones are static, since we need to keep memory of
 370          the exact place from one call to the other */
 371         static unsigned char *L3_buf, *L4_buf;
 372
 373         /* some consistency check */
 374         if (!buf) {
 375                 opj_event_msg(j2k->cinfo, EVT_ERROR, "There is no operating buffer for EPBs\n");
 376                 return false;
 377         }
 378
 379         if (!post_buf && !L4_buf) {
 380                 opj_event_msg(j2k->cinfo, EVT_ERROR, "There is no operating buffer for EPBs data\n");
 381                 return false;
 382         }
 383
 384         /*
 385          * Compute parity bytes on pre-data, ALWAYS present (at least only for EPB parms)
 386          */
 387
 388         /* Initialize RS structures */
 389         P = epb->n_pre - epb->k_pre;
 390         NN_P = NN - P;
 391         memset(codeword, 0, NN);
 392         parityword = codeword + NN_P;
 393         init_rs(NN_P);
 394
 395         /* pre-data begins pre_len bytes before of EPB buf */
 396         L1_buf = buf - epb->pre_len;
 397         L1 = epb->pre_len + 13;
 398
 399         /* redundancy for pre-data begins immediately after EPB parms */
 400         L2_buf = buf + 13;
 401         L2 = (epb->n_pre - epb->k_pre) * (unsigned short int) ceil((double) L1 / (double) epb->k_pre);
 402
 403         /* post-data
 404            the position of L4 buffer can be:
 405              1) passed as a parameter: in that case use it
 406              2) null: in that case use the previous (static) one
 407         */
 408         if (post_buf)
 409                 L4_buf = post_buf;
 410         L4 = epb->post_len;
 411
 412         /* post-data redundancy begins immediately after pre-data redundancy */
 413         L3_buf = L2_buf + L2;
 414         L3 = (epb->n_post - epb->k_post) * (unsigned short int) ceil((double) L4 / (double) epb->k_post);
 415
 416         /* let's check whether EPB length is sufficient to contain all these data */
 417         if (epb->Lepb < (11 + L2 + L3))
 418                 opj_event_msg(j2k->cinfo, EVT_ERROR, "There is no room in EPB data field for writing redundancy data\n");
 419         /*printf("Env. %d, nec. %d (%d + %d)\n", epb->Lepb - 11, L2 + L3, L2, L3);*/
 420
 421         /* Compute redundancy of pre-data message words */
 422         remaining = L1;
 423         while (remaining) {
 424
 425                 /* copy message data into codeword buffer */
 426                 if (remaining < epb->k_pre) {
 427                         /* the last message word is zero-padded */
 428                         memset(codeword, 0, NN);
 429                         memcpy(codeword, L1_buf, remaining);
 430                         L1_buf += remaining;
 431                         remaining = 0;
 432
 433                 } else {
 434                         memcpy(codeword, L1_buf, epb->k_pre);
 435                         L1_buf += epb->k_pre;
 436                         remaining -= epb->k_pre;
 437
 438                 }
 439
 440                 /* Encode the buffer and obtain parity bytes */
 441                 if (encode_rs(codeword, parityword))
 442                         opj_event_msg(j2k->cinfo, EVT_WARNING,
 443                                 "Possible encoding error in codeword @ position #%d\n", (L1_buf - buf) / epb->k_pre);
 444
 445                 /* copy parity bytes only in redundancy buffer */
 446                 memcpy(L2_buf, parityword, P);
 447
 448                 /* advance parity buffer */
 449                 L2_buf += P;
 450         }
 451
 452         /*
 453          * Compute parity bytes on post-data, may be absent if there are no data
 454          */
 455         /*printf("Hprot is %d (tileno=%d, k_pre=%d, n_pre=%d, k_post=%d, n_post=%d, pre_len=%d, post_len=%d)\n",
 456                 epb->hprot, epb->tileno, epb->k_pre, epb->n_pre, epb->k_post, epb->n_post, epb->pre_len,
 457                 epb->post_len);*/
 458         if (epb->hprot < 0) {
 459
 460                 /* there should be no EPB */
 461
 462         } else if (epb->hprot == 0) {
 463
 464                 /* no protection for the data */
 465                 /* advance anyway */
 466                 L4_buf += epb->post_len;
 467
 468         } else if (epb->hprot == 16) {
 469
 470                 /* CRC-16 */
 471                 unsigned short int mycrc = 0x0000;
 472
 473                 /* compute the CRC field (excluding itself) */
 474                 remaining = L4;
 475                 while (remaining--)
 476                         jpwl_updateCRC16(&mycrc, *(L4_buf++));
 477
 478                 /* write the CRC field */
 479                 *(L3_buf++) = (unsigned char) (mycrc >> 8);
 480                 *(L3_buf++) = (unsigned char) (mycrc >> 0);
 481
 482         } else if (epb->hprot == 32) {
 483
 484                 /* CRC-32 */
 485                 unsigned long int mycrc = 0x00000000;
 486
 487                 /* compute the CRC field (excluding itself) */
 488                 remaining = L4;
 489                 while (remaining--)
 490                         jpwl_updateCRC32(&mycrc, *(L4_buf++));
 491
 492                 /* write the CRC field */
 493                 *(L3_buf++) = (unsigned char) (mycrc >> 24);
 494                 *(L3_buf++) = (unsigned char) (mycrc >> 16);
 495                 *(L3_buf++) = (unsigned char) (mycrc >> 8);
 496                 *(L3_buf++) = (unsigned char) (mycrc >> 0);
 497
 498         } else {
 499
 500                 /* RS */
 501
 502                 /* Initialize RS structures */
 503                 P = epb->n_post - epb->k_post;
 504                 NN_P = NN - P;
 505                 memset(codeword, 0, NN);
 506                 parityword = codeword + NN_P;
 507                 init_rs(NN_P);
 508
 509                 /* Compute redundancy of post-data message words */
 510                 remaining = L4;
 511                 while (remaining) {
 512
 513                         /* copy message data into codeword buffer */
 514                         if (remaining < epb->k_post) {
 515                                 /* the last message word is zero-padded */
 516                                 memset(codeword, 0, NN);
 517                                 memcpy(codeword, L4_buf, remaining);
 518                                 L4_buf += remaining;
 519                                 remaining = 0;
 520
 521                         } else {
 522                                 memcpy(codeword, L4_buf, epb->k_post);
 523                                 L4_buf += epb->k_post;
 524                                 remaining -= epb->k_post;
 525
 526                         }
 527
 528                         /* Encode the buffer and obtain parity bytes */
 529                         if (encode_rs(codeword, parityword))
 530                                 opj_event_msg(j2k->cinfo, EVT_WARNING,
 531                                         "Possible encoding error in codeword @ position #%d\n", (L4_buf - buf) / epb->k_post);
 532
 533                         /* copy parity bytes only in redundancy buffer */
 534                         memcpy(L3_buf, parityword, P);
 535
 536                         /* advance parity buffer */
 537                         L3_buf += P;
 538                 }
 539
 540         }
 541
 542         return true;
 543 }
 544
 545
 546 bool jpwl_correct(opj_j2k_t *j2k) {
 547
 548         opj_cio_t *cio = j2k->cio;
 549         bool status;
 550         static bool mh_done = false;
 551         int mark_pos, id, len, skips, sot_pos;
 552         unsigned long int Psot = 0;
 553
 554         /* go back to marker position */
 555         mark_pos = cio_tell(cio) - 2;
 556         cio_seek(cio, mark_pos);
 557
 558         if ((j2k->state == J2K_STATE_MHSOC) && !mh_done) {
 559
 560                 int mark_val = 0, skipnum = 0;
 561
 562                 /*
 563                   COLOR IMAGE
 564                   first thing to do, if we are here, is to look whether
 565                   51 (skipnum) positions ahead there is an EPB, in case of MH
 566                 */
 567                 /*
 568                   B/W IMAGE
 569                   first thing to do, if we are here, is to look whether
 570                   45 (skipnum) positions ahead there is an EPB, in case of MH
 571                 */
 572                 /*       SIZ   SIZ_FIELDS     SIZ_COMPS               FOLLOWING_MARKER */
 573                 skipnum = 2  +     38     + 3 * j2k->cp->exp_comps  +         2;
 574                 if ((cio->bp + skipnum) < cio->end) {
 575
 576                         cio_skip(cio, skipnum);
 577
 578                         /* check that you are not going beyond the end of codestream */
 579
 580                         /* call EPB corrector */
 581                         status = jpwl_epb_correct(j2k,     /* J2K decompressor handle */
 582                                                                           cio->bp, /* pointer to EPB in codestream buffer */
 583                                                                           0,       /* EPB type: MH */
 584                                                                           skipnum,      /* length of pre-data */
 585                                                                           -1,      /* length of post-data: -1 means auto */
 586                                                                           NULL,
 587                                                                           NULL
 588                                                                          );
 589
 590                         /* read the marker value */
 591                         mark_val = (*(cio->bp) << 8) | *(cio->bp + 1);
 592
 593                         if (status && (mark_val == J2K_MS_EPB)) {
 594                                 /* we found it! */
 595                                 mh_done = true;
 596                                 return true;
 597                         }
 598
 599                         /* Disable correction in case of missing or bad head EPB */
 600                         /* We can't do better! */
 601                         /* PATCHED: 2008-01-25 */
 602                         /* MOVED UP: 2008-02-01 */
 603                         if (!status) {
 604                                 j2k->cp->correct = false;
 605                                 opj_event_msg(j2k->cinfo, EVT_WARNING, "Couldn't find the MH EPB: disabling JPWL\n");
 606                         }
 607
 608                 }
 609
 610         }
 611
 612         if (true /*(j2k->state == J2K_STATE_TPHSOT) || (j2k->state == J2K_STATE_TPH)*/) {
 613                 /* else, look if 12 positions ahead there is an EPB, in case of TPH */
 614                 cio_seek(cio, mark_pos);
 615                 if ((cio->bp + 12) < cio->end) {
 616
 617                         cio_skip(cio, 12);
 618
 619                         /* call EPB corrector */
 620                         status = jpwl_epb_correct(j2k,     /* J2K decompressor handle */
 621                                                                           cio->bp, /* pointer to EPB in codestream buffer */
 622                                                                           1,       /* EPB type: TPH */
 623                                                                           12,      /* length of pre-data */
 624                                                                           -1,      /* length of post-data: -1 means auto */
 625                                                                           NULL,
 626                                                                           NULL
 627                                                                          );
 628                         if (status)
 629                                 /* we found it! */
 630                                 return true;
 631                 }
 632         }
 633
 634         return false;
 635
 636         /* for now, don't use this code */
 637
 638         /* else, look if here is an EPB, in case of other */
 639         if (mark_pos > 64) {
 640                 /* it cannot stay before the first MH EPB */
 641                 cio_seek(cio, mark_pos);
 642                 cio_skip(cio, 0);
 643
 644                 /* call EPB corrector */
 645                 status = jpwl_epb_correct(j2k,     /* J2K decompressor handle */
 646                                                                   cio->bp, /* pointer to EPB in codestream buffer */
 647                                                                   2,       /* EPB type: TPH */
 648                                                                   0,       /* length of pre-data */
 649                                                                   -1,      /* length of post-data: -1 means auto */
 650                                                                   NULL,
 651                                                                   NULL
 652                                                                  );
 653                 if (status)
 654                         /* we found it! */
 655                         return true;
 656         }
 657
 658         /* nope, no EPBs probably, or they are so damaged that we can give up */
 659         return false;
 660
 661         return true;
 662
 663         /* AN ATTEMPT OF PARSER */
 664         /* NOT USED ACTUALLY    */
 665
 666         /* go to the beginning of the file */
 667         cio_seek(cio, 0);
 668
 669         /* let's begin */
 670         j2k->state = J2K_STATE_MHSOC;
 671
 672         /* cycle all over the markers */
 673         while (cio_tell(cio) < cio->length) {
 674
 675                 /* read the marker */
 676                 mark_pos = cio_tell(cio);
 677                 id = cio_read(cio, 2);
 678
 679                 /* details */
 680                 printf("Marker@%d: %X\n", cio_tell(cio) - 2, id);
 681
 682                 /* do an action in response to the read marker */
 683                 switch (id) {
 684
 685                 /* short markers */
 686
 687                         /* SOC */
 688                 case J2K_MS_SOC:
 689                         j2k->state = J2K_STATE_MHSIZ;
 690                         len = 0;
 691                         skips = 0;
 692                         break;
 693
 694                         /* EOC */
 695                 case J2K_MS_EOC:
 696                         j2k->state = J2K_STATE_MT;
 697                         len = 0;
 698                         skips = 0;
 699                         break;
 700
 701                         /* particular case of SOD */
 702                 case J2K_MS_SOD:
 703                         len = Psot - (mark_pos - sot_pos) - 2;
 704                         skips = len;
 705                         break;
 706
 707                 /* long markers */
 708
 709                         /* SOT */
 710                 case J2K_MS_SOT:
 711                         j2k->state = J2K_STATE_TPH;
 712                         sot_pos = mark_pos; /* position of SOT */
 713                         len = cio_read(cio, 2); /* read the length field */
 714                         cio_skip(cio, 2); /* this field is unnecessary */
 715                         Psot = cio_read(cio, 4); /* tile length */
 716                         skips = len - 8;
 717                         break;
 718
 719                         /* remaining */
 720                 case J2K_MS_SIZ:
 721                         j2k->state = J2K_STATE_MH;
 722                         /* read the length field */
 723                         len = cio_read(cio, 2);
 724                         skips = len - 2;
 725                         break;
 726
 727                         /* remaining */
 728                 default:
 729                         /* read the length field */
 730                         len = cio_read(cio, 2);
 731                         skips = len - 2;
 732                         break;
 733
 734                 }
 735
 736                 /* skip to marker's end */
 737                 cio_skip(cio, skips);
 738
 739         }
 740
 741
 742 }
 743
 744 bool jpwl_epb_correct(opj_j2k_t *j2k, unsigned char *buffer, int type, int pre_len, int post_len, int *conn,
 745                                           unsigned char **L4_bufp) {
 746
 747         /* Operating buffer */
 748         unsigned char codeword[NN], *parityword;
 749
 750         unsigned long int P, NN_P;
 751         unsigned long int L1, L4;
 752         int remaining, n_pre, k_pre, n_post, k_post;
 753
 754         int status, tt;
 755
 756         int orig_pos = cio_tell(j2k->cio);
 757
 758         unsigned char *L1_buf, *L2_buf;
 759         unsigned char *L3_buf, *L4_buf;
 760
 761         unsigned long int LDPepb, Pepb;
 762         unsigned short int Lepb;
 763         unsigned char Depb;
 764         char str1[25] = "";
 765         int myconn, errnum = 0;
 766         bool errflag = false;
 767
 768         opj_cio_t *cio = j2k->cio;
 769
 770         /* check for common errors */
 771         if (!buffer) {
 772                 opj_event_msg(j2k->cinfo, EVT_ERROR, "The EPB pointer is a NULL buffer\n");
 773                 return false;
 774         }
 775
 776         /* set bignesses */
 777         L1 = pre_len + 13;
 778
 779         /* pre-data correction */
 780         switch (type) {
 781
 782         case 0:
 783                 /* MH EPB */
 784                 k_pre = 64;
 785                 n_pre = 160;
 786                 break;
 787
 788         case 1:
 789                 /* TPH EPB */
 790                 k_pre = 25;
 791                 n_pre = 80;
 792                 break;
 793
 794         case 2:
 795                 /* other EPBs */
 796                 k_pre = 13;
 797                 n_pre = 40;
 798                 break;
 799
 800         case 3:
 801                 /* automatic setup */
 802                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Auto. setup not yet implemented\n");
 803                 return false;
 804                 break;
 805
 806         default:
 807                 /* unknown type */
 808                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Unknown expected EPB type\n");
 809                 return false;
 810                 break;
 811
 812         }
 813
 814         /* Initialize RS structures */
 815         P = n_pre - k_pre;
 816         NN_P = NN - P;
 817         tt = (int) floor((float) P / 2.0F); /* correction capability of the code */
 818         memset(codeword, 0, NN);
 819         parityword = codeword + NN_P;
 820         init_rs(NN_P);
 821
 822         /* Correct pre-data message words */
 823         L1_buf = buffer - pre_len;
 824         L2_buf = buffer + 13;
 825         remaining = L1;
 826         while (remaining) {
 827
 828                 /* always zero-pad codewords */
 829                 /* (this is required, since after decoding the zeros in the long codeword
 830                     could change, and keep unchanged in subsequent calls) */
 831                 memset(codeword, 0, NN);
 832
 833                 /* copy codeword buffer into message bytes */
 834                 if (remaining < k_pre)
 835                         memcpy(codeword, L1_buf, remaining);
 836                 else
 837                         memcpy(codeword, L1_buf, k_pre);
 838
 839                 /* copy redundancy buffer in parity bytes */
 840                 memcpy(parityword, L2_buf, P);
 841
 842                 /* Decode the buffer and possibly obtain corrected bytes */
 843                 status = eras_dec_rs(codeword, NULL, 0);
 844                 if (status == -1) {
 845                         /*if (conn == NULL)
 846                                 opj_event_msg(j2k->cinfo, EVT_WARNING,
 847                                         "Possible decoding error in codeword @ position #%d\n", (L1_buf - buffer) / k_pre);*/
 848                         errflag = true;
 849                         /* we can try to safely get out from the function:
 850                           if we are here, either this is not an EPB or the first codeword
 851                           is too damaged to be helpful */
 852                         /*return false;*/
 853
 854                 } else if (status == 0) {
 855                         /*if (conn == NULL)
 856                                 opj_event_msg(j2k->cinfo, EVT_INFO, "codeword is correctly decoded\n");*/
 857
 858                 } else if (status <= tt) {
 859                         /* it has corrected 0 <= errs <= tt */
 860                         /*if (conn == NULL)
 861                                 opj_event_msg(j2k->cinfo, EVT_WARNING, "%d errors corrected in codeword\n", status);*/
 862                         errnum += status;
 863
 864                 } else {
 865                         /*if (conn == NULL)
 866                                 opj_event_msg(j2k->cinfo, EVT_WARNING, "EPB correction capability exceeded\n");
 867                         return false;*/
 868                         errflag = true;
 869                 }
 870
 871
 872                 /* advance parity buffer */
 873                 if ((status >= 0) && (status <= tt))
 874                         /* copy back corrected parity only if all is OK */
 875                         memcpy(L2_buf, parityword, P);
 876                 L2_buf += P;
 877
 878                 /* advance message buffer */
 879                 if (remaining < k_pre) {
 880                         if ((status >= 0) && (status <= tt))
 881                                 /* copy back corrected data only if all is OK */
 882                                 memcpy(L1_buf, codeword, remaining);
 883                         L1_buf += remaining;
 884                         remaining = 0;
 885
 886                 } else {
 887                         if ((status >= 0) && (status <= tt))
 888                                 /* copy back corrected data only if all is OK */
 889                                 memcpy(L1_buf, codeword, k_pre);
 890                         L1_buf += k_pre;
 891                         remaining -= k_pre;
 892
 893                 }
 894         }
 895
 896         /* print summary */
 897         if (!conn) {
 898
 899                 /*if (errnum)
 900                         opj_event_msg(j2k->cinfo, EVT_INFO, "+ %d symbol errors corrected (Ps=%.1e)\n", errnum,
 901                                 (float) errnum / ((float) n_pre * (float) L1 / (float) k_pre));*/
 902                 if (errflag) {
 903                         /*opj_event_msg(j2k->cinfo, EVT_INFO, "+ there were unrecoverable errors\n");*/
 904                         return false;
 905                 }
 906
 907         }
 908
 909         /* presumably, now, EPB parameters are correct */
 910         /* let's get them */
 911
 912         /* Simply read the EPB parameters */
 913         if (conn)
 914                 cio->bp = buffer;
 915         cio_skip(cio, 2); /* the marker */
 916         Lepb = cio_read(cio, 2);
 917         Depb = cio_read(cio, 1);
 918         LDPepb = cio_read(cio, 4);
 919         Pepb = cio_read(cio, 4);
 920
 921         /* What does Pepb tells us about the protection method? */
 922         if (((Pepb & 0xF0000000) >> 28) == 0)
 923                 sprintf(str1, "pred"); /* predefined */
 924         else if (((Pepb & 0xF0000000) >> 28) == 1)
 925                 sprintf(str1, "crc-%lu", 16 * ((Pepb & 0x00000001) + 1)); /* CRC mode */
 926         else if (((Pepb & 0xF0000000) >> 28) == 2)
 927                 sprintf(str1, "rs(%lu,32)", (Pepb & 0x0000FF00) >> 8); /* RS mode */
 928         else if (Pepb == 0xFFFFFFFF)
 929                 sprintf(str1, "nometh"); /* RS mode */
 930         else
 931                 sprintf(str1, "unknown"); /* unknown */
 932
 933         /* Now we write them to screen */
 934         if (!conn && post_len)
 935                 opj_event_msg(j2k->cinfo, EVT_INFO,
 936                         "EPB(%d): (%sl, %sp, %u), %lu, %s\n",
 937                         cio_tell(cio) - 13,
 938                         (Depb & 0x40) ? "" : "n", /* latest EPB or not? */
 939                         (Depb & 0x80) ? "" : "n", /* packed or unpacked EPB? */
 940                         (Depb & 0x3F), /* EPB index value */
 941                         LDPepb, /*length of the data protected by the EPB */
 942                         str1); /* protection method */
 943
 944
 945         /* well, we need to investigate how long is the connected length of packed EPBs */
 946         myconn = Lepb + 2;
 947         if ((Depb & 0x40) == 0) /* not latest in header */
 948                 jpwl_epb_correct(j2k,      /* J2K decompressor handle */
 949                                              buffer + Lepb + 2,   /* pointer to next EPB in codestream buffer */
 950                                              2,     /* EPB type: should be of other type */
 951                                              0,  /* only EPB fields */
 952                                              0, /* do not look after */
 953                                                  &myconn,
 954                                                  NULL
 955                                              );
 956         if (conn)
 957                 *conn += myconn;
 958
 959         /*if (!conn)
 960                 printf("connected = %d\n", myconn);*/
 961
 962         /*cio_seek(j2k->cio, orig_pos);
 963         return true;*/
 964
 965         /* post-data
 966            the position of L4 buffer is at the end of currently connected EPBs
 967         */
 968         if (!(L4_bufp))
 969                 L4_buf = buffer + myconn;
 970         else if (!(*L4_bufp))
 971                 L4_buf = buffer + myconn;
 972         else
 973                 L4_buf = *L4_bufp;
 974         if (post_len == -1)
 975                 L4 = LDPepb - pre_len - 13;
 976         else if (post_len == 0)
 977                 L4 = 0;
 978         else
 979                 L4 = post_len;
 980
 981         L3_buf = L2_buf;
 982
 983         /* Do a further check here on the read parameters */
 984         if (L4 > (unsigned long) cio_numbytesleft(j2k->cio))
 985                 /* overflow */
 986                 return false;
 987
 988         /* we are ready for decoding the remaining data */
 989         if (((Pepb & 0xF0000000) >> 28) == 1) {
 990                 /* CRC here */
 991                 if ((16 * ((Pepb & 0x00000001) + 1)) == 16) {
 992
 993                         /* CRC-16 */
 994                         unsigned short int mycrc = 0x0000, filecrc = 0x0000;
 995
 996                         /* compute the CRC field */
 997                         remaining = L4;
 998                         while (remaining--)
 999                                 jpwl_updateCRC16(&mycrc, *(L4_buf++));
1000
1001                         /* read the CRC field */
1002                         filecrc = *(L3_buf++) << 8;
1003                         filecrc |= *(L3_buf++);
1004
1005                         /* check the CRC field */
1006                         if (mycrc == filecrc) {
1007                                 if (conn == NULL)
1008                                         opj_event_msg(j2k->cinfo, EVT_INFO, "- CRC is OK\n");
1009                         } else {
1010                                 if (conn == NULL)
1011                                         opj_event_msg(j2k->cinfo, EVT_WARNING, "- CRC is KO (r=%d, c=%d)\n", filecrc, mycrc);
1012                                 errflag = true;
1013                         }
1014                 }
1015
1016                 if ((16 * ((Pepb & 0x00000001) + 1)) == 32) {
1017
1018                         /* CRC-32 */
1019                         unsigned long int mycrc = 0x00000000, filecrc = 0x00000000;
1020
1021                         /* compute the CRC field */
1022                         remaining = L4;
1023                         while (remaining--)
1024                                 jpwl_updateCRC32(&mycrc, *(L4_buf++));
1025
1026                         /* read the CRC field */
1027                         filecrc = *(L3_buf++) << 24;
1028                         filecrc |= *(L3_buf++) << 16;
1029                         filecrc |= *(L3_buf++) << 8;
1030                         filecrc |= *(L3_buf++);
1031
1032                         /* check the CRC field */
1033                         if (mycrc == filecrc) {
1034                                 if (conn == NULL)
1035                                         opj_event_msg(j2k->cinfo, EVT_INFO, "- CRC is OK\n");
1036                         } else {
1037                                 if (conn == NULL)
1038                                         opj_event_msg(j2k->cinfo, EVT_WARNING, "- CRC is KO (r=%d, c=%d)\n", filecrc, mycrc);
1039                                 errflag = true;
1040                         }
1041                 }
1042
1043         } else if (Pepb == 0xFFFFFFFF) {
1044                 /* no method */
1045
1046                 /* advance without doing anything */
1047                 remaining = L4;
1048                 while (remaining--)
1049                         L4_buf++;
1050
1051         } else if ((((Pepb & 0xF0000000) >> 28) == 2) || (((Pepb & 0xF0000000) >> 28) == 0)) {
1052                 /* RS coding here */
1053
1054                 if (((Pepb & 0xF0000000) >> 28) == 0) {
1055
1056                         k_post = k_pre;
1057                         n_post = n_pre;
1058
1059                 } else {
1060
1061                         k_post = 32;
1062                         n_post = (Pepb & 0x0000FF00) >> 8;
1063                 }
1064
1065                 /* Initialize RS structures */
1066                 P = n_post - k_post;
1067                 NN_P = NN - P;
1068                 tt = (int) floor((float) P / 2.0F); /* again, correction capability */
1069                 memset(codeword, 0, NN);
1070                 parityword = codeword + NN_P;
1071                 init_rs(NN_P);
1072
1073                 /* Correct post-data message words */
1074                 /*L4_buf = buffer + Lepb + 2;*/
1075                 L3_buf = L2_buf;
1076                 remaining = L4;
1077                 while (remaining) {
1078
1079                         /* always zero-pad codewords */
1080                         /* (this is required, since after decoding the zeros in the long codeword
1081                                 could change, and keep unchanged in subsequent calls) */
1082                         memset(codeword, 0, NN);
1083
1084                         /* copy codeword buffer into message bytes */
1085                         if (remaining < k_post)
1086                                 memcpy(codeword, L4_buf, remaining);
1087                         else
1088                                 memcpy(codeword, L4_buf, k_post);
1089
1090                         /* copy redundancy buffer in parity bytes */
1091                         memcpy(parityword, L3_buf, P);
1092
1093                         /* Decode the buffer and possibly obtain corrected bytes */
1094                         status = eras_dec_rs(codeword, NULL, 0);
1095                         if (status == -1) {
1096                                 /*if (conn == NULL)
1097                                         opj_event_msg(j2k->cinfo, EVT_WARNING,
1098                                                 "Possible decoding error in codeword @ position #%d\n", (L4_buf - (buffer + Lepb + 2)) / k_post);*/
1099                                 errflag = true;
1100
1101                         } else if (status == 0) {
1102                                 /*if (conn == NULL)
1103                                         opj_event_msg(j2k->cinfo, EVT_INFO, "codeword is correctly decoded\n");*/
1104
1105                         } else if (status <= tt) {
1106                                 /*if (conn == NULL)
1107                                         opj_event_msg(j2k->cinfo, EVT_WARNING, "%d errors corrected in codeword\n", status);*/
1108                                 errnum += status;
1109
1110                         } else {
1111                                 /*if (conn == NULL)
1112                                         opj_event_msg(j2k->cinfo, EVT_WARNING, "EPB correction capability exceeded\n");
1113                                 return false;*/
1114                                 errflag = true;
1115                         }
1116
1117
1118                         /* advance parity buffer */
1119                         if ((status >= 0) && (status <= tt))
1120                                 /* copy back corrected data only if all is OK */
1121                                 memcpy(L3_buf, parityword, P);
1122                         L3_buf += P;
1123
1124                         /* advance message buffer */
1125                         if (remaining < k_post) {
1126                                 if ((status >= 0) && (status <= tt))
1127                                         /* copy back corrected data only if all is OK */
1128                                         memcpy(L4_buf, codeword, remaining);
1129                                 L4_buf += remaining;
1130                                 remaining = 0;
1131
1132                         } else {
1133                                 if ((status >= 0) && (status <= tt))
1134                                         /* copy back corrected data only if all is OK */
1135                                         memcpy(L4_buf, codeword, k_post);
1136                                 L4_buf += k_post;
1137                                 remaining -= k_post;
1138
1139                         }
1140                 }
1141         }
1142
1143         /* give back the L4_buf address */
1144         if (L4_bufp)
1145                 *L4_bufp = L4_buf;
1146
1147         /* print summary */
1148         if (!conn) {
1149
1150                 if (errnum)
1151                         opj_event_msg(j2k->cinfo, EVT_INFO, "- %d symbol errors corrected (Ps=%.1e)\n", errnum,
1152                                 (float) errnum / (float) LDPepb);
1153                 if (errflag)
1154                         opj_event_msg(j2k->cinfo, EVT_INFO, "- there were unrecoverable errors\n");
1155
1156         }
1157
1158         cio_seek(j2k->cio, orig_pos);
1159
1160         return true;
1161 }
1162
1163 void jpwl_epc_write(opj_j2k_t *j2k, jpwl_epc_ms_t *epc, unsigned char *buf) {
1164
1165         /* Marker */
1166         *(buf++) = (unsigned char) (J2K_MS_EPC >> 8);
1167         *(buf++) = (unsigned char) (J2K_MS_EPC >> 0);
1168
1169         /* Lepc */
1170         *(buf++) = (unsigned char) (epc->Lepc >> 8);
1171         *(buf++) = (unsigned char) (epc->Lepc >> 0);
1172
1173         /* Pcrc */
1174         *(buf++) = (unsigned char) (epc->Pcrc >> 8);
1175         *(buf++) = (unsigned char) (epc->Pcrc >> 0);
1176
1177         /* DL */
1178         *(buf++) = (unsigned char) (epc->DL >> 24);
1179         *(buf++) = (unsigned char) (epc->DL >> 16);
1180         *(buf++) = (unsigned char) (epc->DL >> 8);
1181         *(buf++) = (unsigned char) (epc->DL >> 0);
1182
1183         /* Pepc */
1184         *(buf++) = (unsigned char) (epc->Pepc >> 0);
1185
1186         /* Data */
1187         /*memcpy(buf, epc->data, (size_t) epc->Lepc - 9);*/
1188         memset(buf, 0, (size_t) epc->Lepc - 9);
1189
1190         /* update markers struct */
1191         j2k_add_marker(j2k->cstr_info, J2K_MS_EPC, -1, epc->Lepc + 2);
1192
1193 };
1194
1195 int jpwl_esds_add(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int *jwmarker_num,
1196                                   int comps, unsigned char addrm, unsigned char ad_size,
1197                                   unsigned char senst, unsigned char se_size,
1198                                   double place_pos, int tileno) {
1199
1200         return 0;
1201 }
1202
1203 jpwl_esd_ms_t *jpwl_esd_create(opj_j2k_t *j2k, int comp, unsigned char addrm, unsigned char ad_size,
1204                                                                 unsigned char senst, unsigned char se_size, int tileno,
1205                                                                 unsigned long int svalnum, void *sensval) {
1206
1207         jpwl_esd_ms_t *esd = NULL;
1208
1209         /* Alloc space */
1210         if (!(esd = (jpwl_esd_ms_t *) opj_malloc((size_t) 1 * sizeof (jpwl_esd_ms_t)))) {
1211                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not allocate room for ESD MS\n");
1212                 return NULL;
1213         };
1214
1215         /* if relative sensitivity, activate byte range mode */
1216         if (senst == 0)
1217                 addrm = 1;
1218
1219         /* size of sensval's ... */
1220         if ((ad_size != 0) && (ad_size != 2) && (ad_size != 4)) {
1221                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Address size %d for ESD MS is forbidden\n", ad_size);
1222                 return NULL;
1223         }
1224         if ((se_size != 1) && (se_size != 2)) {
1225                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Sensitivity size %d for ESD MS is forbidden\n", se_size);
1226                 return NULL;
1227         }
1228
1229         /* ... depends on the addressing mode */
1230         switch (addrm) {
1231
1232         /* packet mode */
1233         case (0):
1234                 ad_size = 0; /* as per the standard */
1235                 esd->sensval_size = se_size;
1236                 break;
1237
1238         /* byte range */
1239         case (1):
1240                 /* auto sense address size */
1241                 if (ad_size == 0)
1242                         /* if there are more than 66% of (2^16 - 1) bytes, switch to 4 bytes
1243                          (we keep space for possible EPBs being inserted) */
1244                         ad_size = (j2k->cstr_info->codestream_size > (1 * 65535 / 3)) ? 4 : 2;
1245                 esd->sensval_size = ad_size + ad_size + se_size;
1246                 break;
1247
1248         /* packet range */
1249         case (2):
1250                 /* auto sense address size */
1251                 if (ad_size == 0)
1252                         /* if there are more than 2^16 - 1 packets, switch to 4 bytes */
1253                         ad_size = (j2k->cstr_info->packno > 65535) ? 4 : 2;
1254                 esd->sensval_size = ad_size + ad_size + se_size;
1255                 break;
1256
1257         case (3):
1258                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Address mode %d for ESD MS is unimplemented\n", addrm);
1259                 return NULL;
1260
1261         default:
1262                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Address mode %d for ESD MS is forbidden\n", addrm);
1263                 return NULL;
1264         }
1265
1266         /* set or unset sensitivity values */
1267         if (svalnum <= 0) {
1268
1269                 switch (senst) {
1270
1271                 /* just based on the portions of a codestream */
1272                 case (0):
1273                         /* MH + no. of THs + no. of packets */
1274                         svalnum = 1 + (j2k->cstr_info->tw * j2k->cstr_info->th) * (1 + j2k->cstr_info->packno);
1275                         break;
1276
1277                 /* all the ones that are based on the packets */
1278                 default:
1279                         if (tileno < 0)
1280                                 /* MH: all the packets and all the tiles info is written */
1281                                 svalnum = j2k->cstr_info->tw * j2k->cstr_info->th * j2k->cstr_info->packno;
1282                         else
1283                                 /* TPH: only that tile info is written */
1284                                 svalnum = j2k->cstr_info->packno;
1285                         break;
1286
1287                 }
1288         }
1289
1290         /* fill private fields */
1291         esd->senst = senst;
1292         esd->ad_size = ad_size;
1293         esd->se_size = se_size;
1294         esd->addrm = addrm;
1295         esd->svalnum = svalnum;
1296         esd->numcomps = j2k->image->numcomps;
1297         esd->tileno = tileno;
1298
1299         /* Set the ESD parameters */
1300         /* length, excluding data field */
1301         if (esd->numcomps < 257)
1302                 esd->Lesd = 4 + (unsigned short int) (esd->svalnum * esd->sensval_size);
1303         else
1304                 esd->Lesd = 5 + (unsigned short int) (esd->svalnum * esd->sensval_size);
1305
1306         /* component data field */
1307         if (comp >= 0)
1308                 esd->Cesd = comp;
1309         else
1310                 /* we are averaging */
1311                 esd->Cesd = 0;
1312
1313         /* Pesd field */
1314         esd->Pesd = 0x00;
1315         esd->Pesd |= (esd->addrm & 0x03) << 6; /* addressing mode */
1316         esd->Pesd |= (esd->senst & 0x07) << 3; /* sensitivity type */
1317         esd->Pesd |= ((esd->se_size >> 1) & 0x01) << 2; /* sensitivity size */
1318         esd->Pesd |= ((esd->ad_size >> 2) & 0x01) << 1; /* addressing size */
1319         esd->Pesd |= (comp < 0) ? 0x01 : 0x00; /* averaging components */
1320
1321         /* if pointer to sensval is NULL, we can fill data field by ourselves */
1322         if (!sensval) {
1323
1324                 /* old code moved to jpwl_esd_fill() */
1325                 esd->data = NULL;
1326
1327         } else {
1328                         /* we set the data field as the sensitivity values poinnter passed to the function */
1329                         esd->data = (unsigned char *) sensval;
1330         }
1331
1332         return (esd);
1333 }
1334
1335 bool jpwl_esd_fill(opj_j2k_t *j2k, jpwl_esd_ms_t *esd, unsigned char *buf) {
1336
1337         int i;
1338         unsigned long int vv;
1339         unsigned long int addr1 = 0L, addr2 = 0L;
1340         double dvalue = 0.0, Omax2, tmp, TSE = 0.0, MSE, oldMSE = 0.0, PSNR, oldPSNR = 0.0;
1341         unsigned short int pfpvalue;
1342         unsigned long int addrmask = 0x00000000;
1343         bool doneMH = false, doneTPH = false;
1344
1345         /* sensitivity values in image info are as follows:
1346                 - for each tile, distotile is the starting distortion for that tile, sum of all components
1347                 - for each packet in a tile, disto is the distortion reduction caused by that packet to that tile
1348                 - the TSE for a single tile should be given by   distotile - sum(disto)  , for all components
1349                 - the MSE for a single tile is given by     TSE / nbpix    , for all components
1350                 - the PSNR for a single tile is given by   10*log10( Omax^2 / MSE)    , for all components
1351                   (Omax is given by    2^bpp - 1    for unsigned images and by    2^(bpp - 1) - 1    for signed images
1352         */
1353
1354         /* browse all components and find Omax */
1355         Omax2 = 0.0;
1356         for (i = 0; i < j2k->image->numcomps; i++) {
1357                 tmp = pow(2.0, (double) (j2k->image->comps[i].sgnd ?
1358                         (j2k->image->comps[i].bpp - 1) : (j2k->image->comps[i].bpp))) - 1;
1359                 if (tmp > Omax2)
1360                         Omax2 = tmp;
1361         }
1362         Omax2 = Omax2 * Omax2;
1363
1364         /* if pointer of esd->data is not null, simply write down all the values byte by byte */
1365         if (esd->data) {
1366                 for (i = 0; i < (int) esd->svalnum; i++)
1367                         *(buf++) = esd->data[i];
1368                 return true;
1369         }
1370
1371         /* addressing mask */
1372         if (esd->ad_size == 2)
1373                 addrmask = 0x0000FFFF; /* two bytes */
1374         else
1375                 addrmask = 0xFFFFFFFF; /* four bytes */
1376
1377         /* set on precise point where sensitivity starts */
1378         if (esd->numcomps < 257)
1379                 buf += 6;
1380         else
1381                 buf += 7;
1382
1383         /* let's fill the data fields */
1384         for (vv = (esd->tileno < 0) ? 0 : (j2k->cstr_info->packno * esd->tileno); vv < esd->svalnum; vv++) {
1385
1386                 int thistile = vv / j2k->cstr_info->packno, thispacket = vv % j2k->cstr_info->packno;
1387
1388                 /* skip for the hack some lines below */
1389                 if (thistile == j2k->cstr_info->tw * j2k->cstr_info->th)
1390                         break;
1391
1392                 /* starting tile distortion */
1393                 if (thispacket == 0) {
1394                         TSE = j2k->cstr_info->tile[thistile].distotile;
1395                         oldMSE = TSE / j2k->cstr_info->tile[thistile].numpix;
1396                         oldPSNR = 10.0 * log10(Omax2 / oldMSE);
1397                 }
1398
1399                 /* TSE */
1400                 TSE -= j2k->cstr_info->tile[thistile].packet[thispacket].disto;
1401
1402                 /* MSE */
1403                 MSE = TSE / j2k->cstr_info->tile[thistile].numpix;
1404
1405                 /* PSNR */
1406                 PSNR = 10.0 * log10(Omax2 / MSE);
1407
1408                 /* fill the address range */
1409                 switch (esd->addrm) {
1410
1411                 /* packet mode */
1412                 case (0):
1413                         /* nothing, there is none */
1414                         break;
1415
1416                 /* byte range */
1417                 case (1):
1418                         /* start address of packet */
1419                         addr1 = (j2k->cstr_info->tile[thistile].packet[thispacket].start_pos) & addrmask;
1420                         /* end address of packet */
1421                         addr2 = (j2k->cstr_info->tile[thistile].packet[thispacket].end_pos) & addrmask;
1422                         break;
1423
1424                 /* packet range */
1425                 case (2):
1426                         /* not implemented here */
1427                         opj_event_msg(j2k->cinfo, EVT_WARNING, "Addressing mode packet_range is not implemented\n");
1428                         break;
1429
1430                 /* unknown addressing method */
1431                 default:
1432                         /* not implemented here */
1433                         opj_event_msg(j2k->cinfo, EVT_WARNING, "Unknown addressing mode\n");
1434                         break;
1435
1436                 }
1437
1438                 /* hack for writing relative sensitivity of MH and TPHs */
1439                 if ((esd->senst == 0) && (thispacket == 0)) {
1440
1441                         /* possible MH */
1442                         if ((thistile == 0) && !doneMH) {
1443                                 /* we have to manage MH addresses */
1444                                 addr1 = 0; /* start of MH */
1445                                 addr2 = j2k->cstr_info->main_head_end; /* end of MH */
1446                                 /* set special dvalue for this MH */
1447                                 dvalue = -10.0;
1448                                 doneMH = true; /* don't come here anymore */
1449                                 vv--; /* wrap back loop counter */
1450
1451                         } else if (!doneTPH) {
1452                                 /* we have to manage TPH addresses */
1453                                 addr1 = j2k->cstr_info->tile[thistile].start_pos;
1454                                 addr2 = j2k->cstr_info->tile[thistile].end_header;
1455                                 /* set special dvalue for this TPH */
1456                                 dvalue = -1.0;
1457                                 doneTPH = true; /* don't come here till the next tile */
1458                                 vv--; /* wrap back loop counter */
1459                         }
1460
1461                 } else
1462                         doneTPH = false; /* reset TPH counter */
1463
1464                 /* write the addresses to the buffer */
1465                 switch (esd->ad_size) {
1466
1467                 case (0):
1468                         /* do nothing */
1469                         break;
1470
1471                 case (2):
1472                         /* two bytes */
1473                         *(buf++) = (unsigned char) (addr1 >> 8);
1474                         *(buf++) = (unsigned char) (addr1 >> 0);
1475                         *(buf++) = (unsigned char) (addr2 >> 8);
1476                         *(buf++) = (unsigned char) (addr2 >> 0);
1477                         break;
1478
1479                 case (4):
1480                         /* four bytes */
1481                         *(buf++) = (unsigned char) (addr1 >> 24);
1482                         *(buf++) = (unsigned char) (addr1 >> 16);
1483                         *(buf++) = (unsigned char) (addr1 >> 8);
1484                         *(buf++) = (unsigned char) (addr1 >> 0);
1485                         *(buf++) = (unsigned char) (addr2 >> 24);
1486                         *(buf++) = (unsigned char) (addr2 >> 16);
1487                         *(buf++) = (unsigned char) (addr2 >> 8);
1488                         *(buf++) = (unsigned char) (addr2 >> 0);
1489                         break;
1490
1491                 default:
1492                         /* do nothing */
1493                         break;
1494                 }
1495
1496
1497                 /* let's fill the value field */
1498                 switch (esd->senst) {
1499
1500                 /* relative sensitivity */
1501                 case (0):
1502                         /* we just write down the packet ordering */
1503                         if (dvalue == -10)
1504                                 /* MH */
1505                                 dvalue = MAX_V1 + 1000.0; /* this will cause pfpvalue set to 0xFFFF */
1506                         else if (dvalue == -1)
1507                                 /* TPH */
1508                                 dvalue = MAX_V1 + 1000.0; /* this will cause pfpvalue set to 0xFFFF */
1509                         else
1510                                 /* packet: first is most important, and then in decreasing order
1511                                 down to the last, which counts for 1 */
1512                                 dvalue = jpwl_pfp_to_double((unsigned short) (j2k->cstr_info->packno - thispacket), esd->se_size);
1513                         break;
1514
1515                 /* MSE */
1516                 case (1):
1517                         /* !!! WRONG: let's put here disto field of packets !!! */
1518                         dvalue = MSE;
1519                         break;
1520
1521                 /* MSE reduction */
1522                 case (2):
1523                         dvalue = oldMSE - MSE;
1524                         oldMSE = MSE;
1525                         break;
1526
1527                 /* PSNR */
1528                 case (3):
1529                         dvalue = PSNR;
1530                         break;
1531
1532                 /* PSNR increase */
1533                 case (4):
1534                         dvalue = PSNR - oldPSNR;
1535                         oldPSNR = PSNR;
1536                         break;
1537
1538                 /* MAXERR */
1539                 case (5):
1540                         dvalue = 0.0;
1541                         opj_event_msg(j2k->cinfo, EVT_WARNING, "MAXERR sensitivity mode is not implemented\n");
1542                         break;
1543
1544                 /* TSE */
1545                 case (6):
1546                         dvalue = TSE;
1547                         break;
1548
1549                 /* reserved */
1550                 case (7):
1551                         dvalue = 0.0;
1552                         opj_event_msg(j2k->cinfo, EVT_WARNING, "Reserved sensitivity mode is not implemented\n");
1553                         break;
1554
1555                 default:
1556                         dvalue = 0.0;
1557                         break;
1558                 }
1559
1560                 /* compute the pseudo-floating point value */
1561                 pfpvalue = jpwl_double_to_pfp(dvalue, esd->se_size);
1562
1563                 /* write the pfp value to the buffer */
1564                 switch (esd->se_size) {
1565
1566                 case (1):
1567                         /* one byte */
1568                         *(buf++) = (unsigned char) (pfpvalue >> 0);
1569                         break;
1570
1571                 case (2):
1572                         /* two bytes */
1573                         *(buf++) = (unsigned char) (pfpvalue >> 8);
1574                         *(buf++) = (unsigned char) (pfpvalue >> 0);
1575                         break;
1576                 }
1577
1578         }
1579
1580         return true;
1581 }
1582
1583 void jpwl_esd_write(opj_j2k_t *j2k, jpwl_esd_ms_t *esd, unsigned char *buf) {
1584
1585         /* Marker */
1586         *(buf++) = (unsigned char) (J2K_MS_ESD >> 8);
1587         *(buf++) = (unsigned char) (J2K_MS_ESD >> 0);
1588
1589         /* Lesd */
1590         *(buf++) = (unsigned char) (esd->Lesd >> 8);
1591         *(buf++) = (unsigned char) (esd->Lesd >> 0);
1592
1593         /* Cesd */
1594         if (esd->numcomps >= 257)
1595                 *(buf++) = (unsigned char) (esd->Cesd >> 8);
1596         *(buf++) = (unsigned char) (esd->Cesd >> 0);
1597
1598         /* Pesd */
1599         *(buf++) = (unsigned char) (esd->Pesd >> 0);
1600
1601         /* Data */
1602         if (esd->numcomps < 257)
1603                 memset(buf, 0xAA, (size_t) esd->Lesd - 4);
1604                 /*memcpy(buf, esd->data, (size_t) esd->Lesd - 4);*/
1605         else
1606                 memset(buf, 0xAA, (size_t) esd->Lesd - 5);
1607                 /*memcpy(buf, esd->data, (size_t) esd->Lesd - 5);*/
1608
1609         /* update markers struct */
1610         j2k_add_marker(j2k->cstr_info, J2K_MS_ESD, -1, esd->Lesd + 2);
1611
1612 }
1613
1614 unsigned short int jpwl_double_to_pfp(double V, int bytes) {
1615
1616         unsigned short int em, e, m;
1617
1618         switch (bytes) {
1619
1620         case (1):
1621
1622                 if (V < MIN_V1) {
1623                         e = 0x0000;
1624                         m = 0x0000;
1625                 } else if (V > MAX_V1) {
1626                         e = 0x000F;
1627                         m = 0x000F;
1628                 } else {
1629                         e = (unsigned short int) (floor(log(V) * 1.44269504088896) / 4.0);
1630                         m = (unsigned short int) (0.5 + (V / (pow(2.0, (double) (4 * e)))));
1631                 }
1632                 em = ((e & 0x000F) << 4) + (m & 0x000F);
1633                 break;
1634
1635         case (2):
1636
1637                 if (V < MIN_V2) {
1638                         e = 0x0000;
1639                         m = 0x0000;
1640                 } else if (V > MAX_V2) {
1641                         e = 0x001F;
1642                         m = 0x07FF;
1643                 } else {
1644                         e = (unsigned short int) floor(log(V) * 1.44269504088896) + 15;
1645                         m = (unsigned short int) (0.5 + 2048.0 * ((V / (pow(2.0, (double) e - 15.0))) - 1.0));
1646                 }
1647                 em = ((e & 0x001F) << 11) + (m & 0x07FF);
1648                 break;
1649
1650         default:
1651
1652                 em = 0x0000;
1653                 break;
1654         };
1655
1656         return em;
1657 }
1658
1659 double jpwl_pfp_to_double(unsigned short int em, int bytes) {
1660
1661         double V;
1662
1663         switch (bytes) {
1664
1665         case 1:
1666                 V = (double) (em & 0x0F) * pow(2.0, (double) (em & 0xF0));
1667                 break;
1668
1669         case 2:
1670
1671                 V = pow(2.0, (double) ((em & 0xF800) >> 11) - 15.0) * (1.0 + (double) (em & 0x07FF) / 2048.0);
1672                 break;
1673
1674         default:
1675                 V = 0.0;
1676                 break;
1677
1678         }
1679
1680         return V;
1681
1682 }
1683
1684 bool jpwl_update_info(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int jwmarker_num) {
1685
1686         int mm;
1687         unsigned long int addlen;
1688
1689         opj_codestream_info_t *info = j2k->cstr_info;
1690         int tileno, tpno, packno, numtiles = info->th * info->tw, numpacks = info->packno;
1691
1692         if (!j2k || !jwmarker ) {
1693                 opj_event_msg(j2k->cinfo, EVT_ERROR, "J2K handle or JPWL markers list badly allocated\n");
1694                 return false;
1695         }
1696
1697         /* main_head_end: how many markers are there before? */
1698         addlen = 0;
1699         for (mm = 0; mm < jwmarker_num; mm++)
1700                 if (jwmarker[mm].pos < (unsigned long int) info->main_head_end)
1701                         addlen += jwmarker[mm].len + 2;
1702         info->main_head_end += addlen;
1703
1704         /* codestream_size: always increment with all markers */
1705         addlen = 0;
1706         for (mm = 0; mm < jwmarker_num; mm++)
1707                 addlen += jwmarker[mm].len + 2;
1708         info->codestream_size += addlen;
1709
1710         /* navigate through all the tiles */
1711         for (tileno = 0; tileno < numtiles; tileno++) {
1712
1713                 /* start_pos: increment with markers before SOT */
1714                 addlen = 0;
1715                 for (mm = 0; mm < jwmarker_num; mm++)
1716                         if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].start_pos)
1717                                 addlen += jwmarker[mm].len + 2;
1718                 info->tile[tileno].start_pos += addlen;
1719
1720                 /* end_header: increment with markers before of it */
1721                 addlen = 0;
1722                 for (mm = 0; mm < jwmarker_num; mm++)
1723                         if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].end_header)
1724                                 addlen += jwmarker[mm].len + 2;
1725                 info->tile[tileno].end_header += addlen;
1726
1727                 /* end_pos: increment with markers before the end of this tile */
1728                 /* code is disabled, since according to JPWL no markers can be beyond TPH */
1729                 addlen = 0;
1730                 for (mm = 0; mm < jwmarker_num; mm++)
1731                         if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].end_pos)
1732                                 addlen += jwmarker[mm].len + 2;
1733                 info->tile[tileno].end_pos += addlen;
1734
1735                 /* navigate through all the tile parts */
1736                 for (tpno = 0; tpno < info->tile[tileno].num_tps; tpno++) {
1737
1738                         /* start_pos: increment with markers before SOT */
1739                         addlen = 0;
1740                         for (mm = 0; mm < jwmarker_num; mm++)
1741                                 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].tp[tpno].tp_start_pos)
1742                                         addlen += jwmarker[mm].len + 2;
1743                         info->tile[tileno].tp[tpno].tp_start_pos += addlen;
1744
1745                         /* end_header: increment with markers before of it */
1746                         addlen = 0;
1747                         for (mm = 0; mm < jwmarker_num; mm++)
1748                                 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].tp[tpno].tp_end_header)
1749                                         addlen += jwmarker[mm].len + 2;
1750                         info->tile[tileno].tp[tpno].tp_end_header += addlen;
1751
1752                         /* end_pos: increment with markers before the end of this tile part */
1753                         addlen = 0;
1754                         for (mm = 0; mm < jwmarker_num; mm++)
1755                                 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].tp[tpno].tp_end_pos)
1756                                         addlen += jwmarker[mm].len + 2;
1757                         info->tile[tileno].tp[tpno].tp_end_pos += addlen;
1758
1759                 }
1760
1761                 /* navigate through all the packets in this tile */
1762                 for (packno = 0; packno < numpacks; packno++) {
1763
1764                         /* start_pos: increment with markers before the packet */
1765                         /* disabled for the same reason as before */
1766                         addlen = 0;
1767                         for (mm = 0; mm < jwmarker_num; mm++)
1768                                 if (jwmarker[mm].pos <= (unsigned long int) info->tile[tileno].packet[packno].start_pos)
1769                                         addlen += jwmarker[mm].len + 2;
1770                         info->tile[tileno].packet[packno].start_pos += addlen;
1771
1772                         /* end_ph_pos: increment with markers before the packet */
1773                         /* disabled for the same reason as before */
1774                         /*addlen = 0;
1775                         for (mm = 0; mm < jwmarker_num; mm++)
1776                                 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].packet[packno].end_ph_pos)
1777                                         addlen += jwmarker[mm].len + 2;*/
1778                         info->tile[tileno].packet[packno].end_ph_pos += addlen;
1779
1780                         /* end_pos: increment if marker is before the end of packet */
1781                         /* disabled for the same reason as before */
1782                         /*addlen = 0;
1783                         for (mm = 0; mm < jwmarker_num; mm++)
1784                                 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].packet[packno].end_pos)
1785                                         addlen += jwmarker[mm].len + 2;*/
1786                         info->tile[tileno].packet[packno].end_pos += addlen;
1787
1788                 }
1789         }
1790
1791         /* reorder the markers list */
1792
1793         return true;
1794 }
1795
1796 #endif /* USE_JPWL */