corrade-vassal – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 vero 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 "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 opj_bool latest, opj_bool packed, opj_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) : OPJ_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 = OPJ_TRUE; /* ready */
174 jwmarker[*jwmarker_num].pos_ready = OPJ_TRUE; /* ready */
175 jwmarker[*jwmarker_num].parms_ready = OPJ_TRUE; /* ready */
176 jwmarker[*jwmarker_num].data_ready = OPJ_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, opj_bool latest, opj_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 opj_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, opj_bool esd_on, opj_bool red_on, opj_bool epb_on, opj_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 opj_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 OPJ_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 OPJ_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 OPJ_TRUE;
543 }
544  
545  
546 opj_bool jpwl_correct(opj_j2k_t *j2k) {
547  
548 opj_cio_t *cio = j2k->cio;
549 opj_bool status;
550 static opj_bool mh_done = OPJ_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 = OPJ_TRUE;
596 return OPJ_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 = OPJ_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 (OPJ_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 OPJ_TRUE;
631 }
632 }
633  
634 return OPJ_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 OPJ_TRUE;
656 }
657  
658 /* nope, no EPBs probably, or they are so damaged that we can give up */
659 return OPJ_FALSE;
660  
661 return OPJ_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 opj_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 opj_bool errflag = OPJ_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 OPJ_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 OPJ_FALSE;
804 break;
805  
806 default:
807 /* unknown type */
808 opj_event_msg(j2k->cinfo, EVT_ERROR, "Unknown expected EPB type\n");
809 return OPJ_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 = OPJ_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 OPJ_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 OPJ_FALSE;*/
868 errflag = OPJ_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 OPJ_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 OPJ_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 OPJ_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 = OPJ_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 = OPJ_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 = OPJ_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 OPJ_FALSE;*/
1114 errflag = OPJ_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 OPJ_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,
1204 unsigned char addrm, unsigned char ad_size,
1205 unsigned char senst, int se_size, int tileno,
1206 unsigned long int svalnum, void *sensval) {
1207  
1208 jpwl_esd_ms_t *esd = NULL;
1209  
1210 /* Alloc space */
1211 if (!(esd = (jpwl_esd_ms_t *) opj_malloc((size_t) 1 * sizeof (jpwl_esd_ms_t)))) {
1212 opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not allocate room for ESD MS\n");
1213 return NULL;
1214 };
1215  
1216 /* if relative sensitivity, activate byte range mode */
1217 if (senst == 0)
1218 addrm = 1;
1219  
1220 /* size of sensval's ... */
1221 if ((ad_size != 0) && (ad_size != 2) && (ad_size != 4)) {
1222 opj_event_msg(j2k->cinfo, EVT_ERROR, "Address size %d for ESD MS is forbidden\n", ad_size);
1223 return NULL;
1224 }
1225 if ((se_size != 1) && (se_size != 2)) {
1226 opj_event_msg(j2k->cinfo, EVT_ERROR, "Sensitivity size %d for ESD MS is forbidden\n", se_size);
1227 return NULL;
1228 }
1229  
1230 /* ... depends on the addressing mode */
1231 switch (addrm) {
1232  
1233 /* packet mode */
1234 case (0):
1235 ad_size = 0; /* as per the standard */
1236 esd->sensval_size = (unsigned int)se_size;
1237 break;
1238  
1239 /* byte range */
1240 case (1):
1241 /* auto sense address size */
1242 if (ad_size == 0)
1243 /* if there are more than 66% of (2^16 - 1) bytes, switch to 4 bytes
1244 (we keep space for possible EPBs being inserted) */
1245 ad_size = (j2k->cstr_info->codestream_size > (1 * 65535 / 3)) ? 4 : 2;
1246 esd->sensval_size = ad_size + ad_size + se_size;
1247 break;
1248  
1249 /* packet range */
1250 case (2):
1251 /* auto sense address size */
1252 if (ad_size == 0)
1253 /* if there are more than 2^16 - 1 packets, switch to 4 bytes */
1254 ad_size = (j2k->cstr_info->packno > 65535) ? 4 : 2;
1255 esd->sensval_size = ad_size + ad_size + se_size;
1256 break;
1257  
1258 case (3):
1259 opj_event_msg(j2k->cinfo, EVT_ERROR, "Address mode %d for ESD MS is unimplemented\n", addrm);
1260 return NULL;
1261  
1262 default:
1263 opj_event_msg(j2k->cinfo, EVT_ERROR, "Address mode %d for ESD MS is forbidden\n", addrm);
1264 return NULL;
1265 }
1266  
1267 /* set or unset sensitivity values */
1268 if (svalnum <= 0) {
1269  
1270 switch (senst) {
1271  
1272 /* just based on the portions of a codestream */
1273 case (0):
1274 /* MH + no. of THs + no. of packets */
1275 svalnum = 1 + (j2k->cstr_info->tw * j2k->cstr_info->th) * (1 + j2k->cstr_info->packno);
1276 break;
1277  
1278 /* all the ones that are based on the packets */
1279 default:
1280 if (tileno < 0)
1281 /* MH: all the packets and all the tiles info is written */
1282 svalnum = j2k->cstr_info->tw * j2k->cstr_info->th * j2k->cstr_info->packno;
1283 else
1284 /* TPH: only that tile info is written */
1285 svalnum = j2k->cstr_info->packno;
1286 break;
1287  
1288 }
1289 }
1290  
1291 /* fill private fields */
1292 esd->senst = senst;
1293 esd->ad_size = ad_size;
1294 esd->se_size = se_size;
1295 esd->addrm = addrm;
1296 esd->svalnum = svalnum;
1297 esd->numcomps = j2k->image->numcomps;
1298 esd->tileno = tileno;
1299  
1300 /* Set the ESD parameters */
1301 /* length, excluding data field */
1302 if (esd->numcomps < 257)
1303 esd->Lesd = 4 + (unsigned short int) (esd->svalnum * esd->sensval_size);
1304 else
1305 esd->Lesd = 5 + (unsigned short int) (esd->svalnum * esd->sensval_size);
1306  
1307 /* component data field */
1308 if (comp >= 0)
1309 esd->Cesd = comp;
1310 else
1311 /* we are averaging */
1312 esd->Cesd = 0;
1313  
1314 /* Pesd field */
1315 esd->Pesd = 0x00;
1316 esd->Pesd |= (esd->addrm & 0x03) << 6; /* addressing mode */
1317 esd->Pesd |= (esd->senst & 0x07) << 3; /* sensitivity type */
1318 esd->Pesd |= ((esd->se_size >> 1) & 0x01) << 2; /* sensitivity size */
1319 esd->Pesd |= ((esd->ad_size >> 2) & 0x01) << 1; /* addressing size */
1320 esd->Pesd |= (comp < 0) ? 0x01 : 0x00; /* averaging components */
1321  
1322 /* if pointer to sensval is NULL, we can fill data field by ourselves */
1323 if (!sensval) {
1324  
1325 /* old code moved to jpwl_esd_fill() */
1326 esd->data = NULL;
1327  
1328 } else {
1329 /* we set the data field as the sensitivity values poinnter passed to the function */
1330 esd->data = (unsigned char *) sensval;
1331 }
1332  
1333 return (esd);
1334 }
1335  
1336 opj_bool jpwl_esd_fill(opj_j2k_t *j2k, jpwl_esd_ms_t *esd, unsigned char *buf) {
1337  
1338 int i;
1339 unsigned long int vv;
1340 unsigned long int addr1 = 0L, addr2 = 0L;
1341 double dvalue = 0.0, Omax2, tmp, TSE = 0.0, MSE, oldMSE = 0.0, PSNR, oldPSNR = 0.0;
1342 unsigned short int pfpvalue;
1343 unsigned long int addrmask = 0x00000000;
1344 opj_bool doneMH = OPJ_FALSE, doneTPH = OPJ_FALSE;
1345  
1346 /* sensitivity values in image info are as follows:
1347 - for each tile, distotile is the starting distortion for that tile, sum of all components
1348 - for each packet in a tile, disto is the distortion reduction caused by that packet to that tile
1349 - the TSE for a single tile should be given by distotile - sum(disto) , for all components
1350 - the MSE for a single tile is given by TSE / nbpix , for all components
1351 - the PSNR for a single tile is given by 10*log10( Omax^2 / MSE) , for all components
1352 (Omax is given by 2^bpp - 1 for unsigned images and by 2^(bpp - 1) - 1 for signed images
1353 */
1354  
1355 /* browse all components and find Omax */
1356 Omax2 = 0.0;
1357 for (i = 0; i < j2k->image->numcomps; i++) {
1358 tmp = pow(2.0, (double) (j2k->image->comps[i].sgnd ?
1359 (j2k->image->comps[i].bpp - 1) : (j2k->image->comps[i].bpp))) - 1;
1360 if (tmp > Omax2)
1361 Omax2 = tmp;
1362 }
1363 Omax2 = Omax2 * Omax2;
1364  
1365 /* if pointer of esd->data is not null, simply write down all the values byte by byte */
1366 if (esd->data) {
1367 for (i = 0; i < (int) esd->svalnum; i++)
1368 *(buf++) = esd->data[i];
1369 return OPJ_TRUE;
1370 }
1371  
1372 /* addressing mask */
1373 if (esd->ad_size == 2)
1374 addrmask = 0x0000FFFF; /* two bytes */
1375 else
1376 addrmask = 0xFFFFFFFF; /* four bytes */
1377  
1378 /* set on precise point where sensitivity starts */
1379 if (esd->numcomps < 257)
1380 buf += 6;
1381 else
1382 buf += 7;
1383  
1384 /* let's fill the data fields */
1385 for (vv = (esd->tileno < 0) ? 0 : (j2k->cstr_info->packno * esd->tileno); vv < esd->svalnum; vv++) {
1386  
1387 int thistile = vv / j2k->cstr_info->packno, thispacket = vv % j2k->cstr_info->packno;
1388  
1389 /* skip for the hack some lines below */
1390 if (thistile == j2k->cstr_info->tw * j2k->cstr_info->th)
1391 break;
1392  
1393 /* starting tile distortion */
1394 if (thispacket == 0) {
1395 TSE = j2k->cstr_info->tile[thistile].distotile;
1396 oldMSE = TSE / j2k->cstr_info->tile[thistile].numpix;
1397 oldPSNR = 10.0 * log10(Omax2 / oldMSE);
1398 }
1399  
1400 /* TSE */
1401 TSE -= j2k->cstr_info->tile[thistile].packet[thispacket].disto;
1402  
1403 /* MSE */
1404 MSE = TSE / j2k->cstr_info->tile[thistile].numpix;
1405  
1406 /* PSNR */
1407 PSNR = 10.0 * log10(Omax2 / MSE);
1408  
1409 /* fill the address range */
1410 switch (esd->addrm) {
1411  
1412 /* packet mode */
1413 case (0):
1414 /* nothing, there is none */
1415 break;
1416  
1417 /* byte range */
1418 case (1):
1419 /* start address of packet */
1420 addr1 = (j2k->cstr_info->tile[thistile].packet[thispacket].start_pos) & addrmask;
1421 /* end address of packet */
1422 addr2 = (j2k->cstr_info->tile[thistile].packet[thispacket].end_pos) & addrmask;
1423 break;
1424  
1425 /* packet range */
1426 case (2):
1427 /* not implemented here */
1428 opj_event_msg(j2k->cinfo, EVT_WARNING, "Addressing mode packet_range is not implemented\n");
1429 break;
1430  
1431 /* unknown addressing method */
1432 default:
1433 /* not implemented here */
1434 opj_event_msg(j2k->cinfo, EVT_WARNING, "Unknown addressing mode\n");
1435 break;
1436  
1437 }
1438  
1439 /* hack for writing relative sensitivity of MH and TPHs */
1440 if ((esd->senst == 0) && (thispacket == 0)) {
1441  
1442 /* possible MH */
1443 if ((thistile == 0) && !doneMH) {
1444 /* we have to manage MH addresses */
1445 addr1 = 0; /* start of MH */
1446 addr2 = j2k->cstr_info->main_head_end; /* end of MH */
1447 /* set special dvalue for this MH */
1448 dvalue = -10.0;
1449 doneMH = OPJ_TRUE; /* don't come here anymore */
1450 vv--; /* wrap back loop counter */
1451  
1452 } else if (!doneTPH) {
1453 /* we have to manage TPH addresses */
1454 addr1 = j2k->cstr_info->tile[thistile].start_pos;
1455 addr2 = j2k->cstr_info->tile[thistile].end_header;
1456 /* set special dvalue for this TPH */
1457 dvalue = -1.0;
1458 doneTPH = OPJ_TRUE; /* don't come here till the next tile */
1459 vv--; /* wrap back loop counter */
1460 }
1461  
1462 } else
1463 doneTPH = OPJ_FALSE; /* reset TPH counter */
1464  
1465 /* write the addresses to the buffer */
1466 switch (esd->ad_size) {
1467  
1468 case (0):
1469 /* do nothing */
1470 break;
1471  
1472 case (2):
1473 /* two bytes */
1474 *(buf++) = (unsigned char) (addr1 >> 8);
1475 *(buf++) = (unsigned char) (addr1 >> 0);
1476 *(buf++) = (unsigned char) (addr2 >> 8);
1477 *(buf++) = (unsigned char) (addr2 >> 0);
1478 break;
1479  
1480 case (4):
1481 /* four bytes */
1482 *(buf++) = (unsigned char) (addr1 >> 24);
1483 *(buf++) = (unsigned char) (addr1 >> 16);
1484 *(buf++) = (unsigned char) (addr1 >> 8);
1485 *(buf++) = (unsigned char) (addr1 >> 0);
1486 *(buf++) = (unsigned char) (addr2 >> 24);
1487 *(buf++) = (unsigned char) (addr2 >> 16);
1488 *(buf++) = (unsigned char) (addr2 >> 8);
1489 *(buf++) = (unsigned char) (addr2 >> 0);
1490 break;
1491  
1492 default:
1493 /* do nothing */
1494 break;
1495 }
1496  
1497  
1498 /* let's fill the value field */
1499 switch (esd->senst) {
1500  
1501 /* relative sensitivity */
1502 case (0):
1503 /* we just write down the packet ordering */
1504 if (dvalue == -10)
1505 /* MH */
1506 dvalue = MAX_V1 + 1000.0; /* this will cause pfpvalue set to 0xFFFF */
1507 else if (dvalue == -1)
1508 /* TPH */
1509 dvalue = MAX_V1 + 1000.0; /* this will cause pfpvalue set to 0xFFFF */
1510 else
1511 /* packet: first is most important, and then in decreasing order
1512 down to the last, which counts for 1 */
1513 dvalue = jpwl_pfp_to_double((unsigned short) (j2k->cstr_info->packno - thispacket), esd->se_size);
1514 break;
1515  
1516 /* MSE */
1517 case (1):
1518 /* !!! WRONG: let's put here disto field of packets !!! */
1519 dvalue = MSE;
1520 break;
1521  
1522 /* MSE reduction */
1523 case (2):
1524 dvalue = oldMSE - MSE;
1525 oldMSE = MSE;
1526 break;
1527  
1528 /* PSNR */
1529 case (3):
1530 dvalue = PSNR;
1531 break;
1532  
1533 /* PSNR increase */
1534 case (4):
1535 dvalue = PSNR - oldPSNR;
1536 oldPSNR = PSNR;
1537 break;
1538  
1539 /* MAXERR */
1540 case (5):
1541 dvalue = 0.0;
1542 opj_event_msg(j2k->cinfo, EVT_WARNING, "MAXERR sensitivity mode is not implemented\n");
1543 break;
1544  
1545 /* TSE */
1546 case (6):
1547 dvalue = TSE;
1548 break;
1549  
1550 /* reserved */
1551 case (7):
1552 dvalue = 0.0;
1553 opj_event_msg(j2k->cinfo, EVT_WARNING, "Reserved sensitivity mode is not implemented\n");
1554 break;
1555  
1556 default:
1557 dvalue = 0.0;
1558 break;
1559 }
1560  
1561 /* compute the pseudo-floating point value */
1562 pfpvalue = jpwl_double_to_pfp(dvalue, esd->se_size);
1563  
1564 /* write the pfp value to the buffer */
1565 switch (esd->se_size) {
1566  
1567 case (1):
1568 /* one byte */
1569 *(buf++) = (unsigned char) (pfpvalue >> 0);
1570 break;
1571  
1572 case (2):
1573 /* two bytes */
1574 *(buf++) = (unsigned char) (pfpvalue >> 8);
1575 *(buf++) = (unsigned char) (pfpvalue >> 0);
1576 break;
1577 }
1578  
1579 }
1580  
1581 return OPJ_TRUE;
1582 }
1583  
1584 void jpwl_esd_write(opj_j2k_t *j2k, jpwl_esd_ms_t *esd, unsigned char *buf) {
1585  
1586 /* Marker */
1587 *(buf++) = (unsigned char) (J2K_MS_ESD >> 8);
1588 *(buf++) = (unsigned char) (J2K_MS_ESD >> 0);
1589  
1590 /* Lesd */
1591 *(buf++) = (unsigned char) (esd->Lesd >> 8);
1592 *(buf++) = (unsigned char) (esd->Lesd >> 0);
1593  
1594 /* Cesd */
1595 if (esd->numcomps >= 257)
1596 *(buf++) = (unsigned char) (esd->Cesd >> 8);
1597 *(buf++) = (unsigned char) (esd->Cesd >> 0);
1598  
1599 /* Pesd */
1600 *(buf++) = (unsigned char) (esd->Pesd >> 0);
1601  
1602 /* Data */
1603 if (esd->numcomps < 257)
1604 memset(buf, 0xAA, (size_t) esd->Lesd - 4);
1605 /*memcpy(buf, esd->data, (size_t) esd->Lesd - 4);*/
1606 else
1607 memset(buf, 0xAA, (size_t) esd->Lesd - 5);
1608 /*memcpy(buf, esd->data, (size_t) esd->Lesd - 5);*/
1609  
1610 /* update markers struct */
1611 j2k_add_marker(j2k->cstr_info, J2K_MS_ESD, -1, esd->Lesd + 2);
1612  
1613 }
1614  
1615 unsigned short int jpwl_double_to_pfp(double V, int bytes) {
1616  
1617 unsigned short int em, e, m;
1618  
1619 switch (bytes) {
1620  
1621 case (1):
1622  
1623 if (V < MIN_V1) {
1624 e = 0x0000;
1625 m = 0x0000;
1626 } else if (V > MAX_V1) {
1627 e = 0x000F;
1628 m = 0x000F;
1629 } else {
1630 e = (unsigned short int) (floor(log(V) * 1.44269504088896) / 4.0);
1631 m = (unsigned short int) (0.5 + (V / (pow(2.0, (double) (4 * e)))));
1632 }
1633 em = ((e & 0x000F) << 4) + (m & 0x000F);
1634 break;
1635  
1636 case (2):
1637  
1638 if (V < MIN_V2) {
1639 e = 0x0000;
1640 m = 0x0000;
1641 } else if (V > MAX_V2) {
1642 e = 0x001F;
1643 m = 0x07FF;
1644 } else {
1645 e = (unsigned short int) floor(log(V) * 1.44269504088896) + 15;
1646 m = (unsigned short int) (0.5 + 2048.0 * ((V / (pow(2.0, (double) e - 15.0))) - 1.0));
1647 }
1648 em = ((e & 0x001F) << 11) + (m & 0x07FF);
1649 break;
1650  
1651 default:
1652  
1653 em = 0x0000;
1654 break;
1655 };
1656  
1657 return em;
1658 }
1659  
1660 double jpwl_pfp_to_double(unsigned short int em, int bytes) {
1661  
1662 double V;
1663  
1664 switch (bytes) {
1665  
1666 case 1:
1667 V = (double) (em & 0x0F) * pow(2.0, (double) (em & 0xF0));
1668 break;
1669  
1670 case 2:
1671  
1672 V = pow(2.0, (double) ((em & 0xF800) >> 11) - 15.0) * (1.0 + (double) (em & 0x07FF) / 2048.0);
1673 break;
1674  
1675 default:
1676 V = 0.0;
1677 break;
1678  
1679 }
1680  
1681 return V;
1682  
1683 }
1684  
1685 opj_bool jpwl_update_info(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int jwmarker_num) {
1686  
1687 int mm;
1688 unsigned long int addlen;
1689  
1690 opj_codestream_info_t *info = j2k->cstr_info;
1691 int tileno, tpno, packno, numtiles = info->th * info->tw, numpacks = info->packno;
1692  
1693 if (!j2k || !jwmarker ) {
1694 opj_event_msg(j2k->cinfo, EVT_ERROR, "J2K handle or JPWL markers list badly allocated\n");
1695 return OPJ_FALSE;
1696 }
1697  
1698 /* main_head_end: how many markers are there before? */
1699 addlen = 0;
1700 for (mm = 0; mm < jwmarker_num; mm++)
1701 if (jwmarker[mm].pos < (unsigned long int) info->main_head_end)
1702 addlen += jwmarker[mm].len + 2;
1703 info->main_head_end += addlen;
1704  
1705 /* codestream_size: always increment with all markers */
1706 addlen = 0;
1707 for (mm = 0; mm < jwmarker_num; mm++)
1708 addlen += jwmarker[mm].len + 2;
1709 info->codestream_size += addlen;
1710  
1711 /* navigate through all the tiles */
1712 for (tileno = 0; tileno < numtiles; tileno++) {
1713  
1714 /* start_pos: increment with markers before SOT */
1715 addlen = 0;
1716 for (mm = 0; mm < jwmarker_num; mm++)
1717 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].start_pos)
1718 addlen += jwmarker[mm].len + 2;
1719 info->tile[tileno].start_pos += addlen;
1720  
1721 /* end_header: increment with markers before of it */
1722 addlen = 0;
1723 for (mm = 0; mm < jwmarker_num; mm++)
1724 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].end_header)
1725 addlen += jwmarker[mm].len + 2;
1726 info->tile[tileno].end_header += addlen;
1727  
1728 /* end_pos: increment with markers before the end of this tile */
1729 /* code is disabled, since according to JPWL no markers can be beyond TPH */
1730 addlen = 0;
1731 for (mm = 0; mm < jwmarker_num; mm++)
1732 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].end_pos)
1733 addlen += jwmarker[mm].len + 2;
1734 info->tile[tileno].end_pos += addlen;
1735  
1736 /* navigate through all the tile parts */
1737 for (tpno = 0; tpno < info->tile[tileno].num_tps; tpno++) {
1738  
1739 /* start_pos: increment with markers before SOT */
1740 addlen = 0;
1741 for (mm = 0; mm < jwmarker_num; mm++)
1742 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].tp[tpno].tp_start_pos)
1743 addlen += jwmarker[mm].len + 2;
1744 info->tile[tileno].tp[tpno].tp_start_pos += addlen;
1745  
1746 /* end_header: increment with markers before of it */
1747 addlen = 0;
1748 for (mm = 0; mm < jwmarker_num; mm++)
1749 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].tp[tpno].tp_end_header)
1750 addlen += jwmarker[mm].len + 2;
1751 info->tile[tileno].tp[tpno].tp_end_header += addlen;
1752  
1753 /* end_pos: increment with markers before the end of this tile part */
1754 addlen = 0;
1755 for (mm = 0; mm < jwmarker_num; mm++)
1756 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].tp[tpno].tp_end_pos)
1757 addlen += jwmarker[mm].len + 2;
1758 info->tile[tileno].tp[tpno].tp_end_pos += addlen;
1759  
1760 }
1761  
1762 /* navigate through all the packets in this tile */
1763 for (packno = 0; packno < numpacks; packno++) {
1764  
1765 /* start_pos: increment with markers before the packet */
1766 /* disabled for the same reason as before */
1767 addlen = 0;
1768 for (mm = 0; mm < jwmarker_num; mm++)
1769 if (jwmarker[mm].pos <= (unsigned long int) info->tile[tileno].packet[packno].start_pos)
1770 addlen += jwmarker[mm].len + 2;
1771 info->tile[tileno].packet[packno].start_pos += addlen;
1772  
1773 /* end_ph_pos: increment with markers before the packet */
1774 /* disabled for the same reason as before */
1775 /*addlen = 0;
1776 for (mm = 0; mm < jwmarker_num; mm++)
1777 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].packet[packno].end_ph_pos)
1778 addlen += jwmarker[mm].len + 2;*/
1779 info->tile[tileno].packet[packno].end_ph_pos += addlen;
1780  
1781 /* end_pos: increment if marker is before the end of packet */
1782 /* disabled for the same reason as before */
1783 /*addlen = 0;
1784 for (mm = 0; mm < jwmarker_num; mm++)
1785 if (jwmarker[mm].pos < (unsigned long int) info->tile[tileno].packet[packno].end_pos)
1786 addlen += jwmarker[mm].len + 2;*/
1787 info->tile[tileno].packet[packno].end_pos += addlen;
1788  
1789 }
1790 }
1791  
1792 /* reorder the markers list */
1793  
1794 return OPJ_TRUE;
1795 }
1796  
1797 #endif /* USE_JPWL */