summaryrefslogtreecommitdiff
path: root/third_party
diff options
context:
space:
mode:
authorNicolas Pena <npm@chromium.org>2017-10-23 10:30:46 -0400
committerChromium commit bot <commit-bot@chromium.org>2017-10-23 22:40:23 +0000
commit826480cf599f61fe0366ab2bd5803dd53c9d0562 (patch)
treed42bca4255a2ecf484b8498b08c6132dbcffe86a /third_party
parentebdba614b9683ddd1d50e8960639bc54c9d4bb7a (diff)
downloadpdfium-826480cf599f61fe0366ab2bd5803dd53c9d0562.tar.xz
Upgrade LibopenJPEG to 2.3chromium/3249
Bug: Change-Id: I4c968a4e5f41037d80e5dc64a1297cd2cbda31b1 Reviewed-on: https://pdfium-review.googlesource.com/16350 Reviewed-by: dsinclair <dsinclair@chromium.org> Commit-Queue: Nicolás Peña Moreno <npm@chromium.org>
Diffstat (limited to 'third_party')
-rw-r--r--third_party/BUILD.gn2
-rw-r--r--third_party/libopenjpeg20/0003-dwt-decode.patch103
-rw-r--r--third_party/libopenjpeg20/0005-jp2_apply_pclr.patch15
-rw-r--r--third_party/libopenjpeg20/0006-tcd_init_tile.patch26
-rw-r--r--third_party/libopenjpeg20/0011-j2k_update_image_data.patch14
-rw-r--r--third_party/libopenjpeg20/0012-mct_sse.patch4
-rw-r--r--third_party/libopenjpeg20/0033-undefined-shift-opj_t1_dec_clnpass.patch14
-rw-r--r--third_party/libopenjpeg20/0035-opj_image_data_free.patch26
-rw-r--r--third_party/libopenjpeg20/CMakeLists.txt3
-rw-r--r--third_party/libopenjpeg20/README.pdfium2
-rw-r--r--third_party/libopenjpeg20/dwt.c1438
-rw-r--r--third_party/libopenjpeg20/dwt.h9
-rw-r--r--third_party/libopenjpeg20/image.c2
-rw-r--r--third_party/libopenjpeg20/j2k.c997
-rw-r--r--third_party/libopenjpeg20/j2k.h25
-rw-r--r--third_party/libopenjpeg20/jp2.c43
-rw-r--r--third_party/libopenjpeg20/jp2.h21
-rw-r--r--third_party/libopenjpeg20/mct.c22
-rw-r--r--third_party/libopenjpeg20/mct.h12
-rw-r--r--third_party/libopenjpeg20/mqc.c2
-rw-r--r--third_party/libopenjpeg20/mqc.h8
-rw-r--r--third_party/libopenjpeg20/mqc_inl.h2
-rw-r--r--third_party/libopenjpeg20/openjpeg.c42
-rw-r--r--third_party/libopenjpeg20/openjpeg.h54
-rw-r--r--third_party/libopenjpeg20/opj_codec.h5
-rw-r--r--third_party/libopenjpeg20/opj_config.h2
-rw-r--r--third_party/libopenjpeg20/opj_config_private.h2
-rw-r--r--third_party/libopenjpeg20/opj_includes.h3
-rw-r--r--third_party/libopenjpeg20/opj_intmath.h31
-rw-r--r--third_party/libopenjpeg20/sparse_array.c346
-rw-r--r--third_party/libopenjpeg20/sparse_array.h141
-rw-r--r--third_party/libopenjpeg20/t1.c297
-rw-r--r--third_party/libopenjpeg20/t1.h4
-rw-r--r--third_party/libopenjpeg20/t2.c95
-rw-r--r--third_party/libopenjpeg20/t2.h11
-rw-r--r--third_party/libopenjpeg20/tcd.c748
-rw-r--r--third_party/libopenjpeg20/tcd.h88
-rw-r--r--third_party/libopenjpeg20/thread.c11
38 files changed, 3698 insertions, 972 deletions
diff --git a/third_party/BUILD.gn b/third_party/BUILD.gn
index 3411b656ef..4a7d15f961 100644
--- a/third_party/BUILD.gn
+++ b/third_party/BUILD.gn
@@ -388,6 +388,8 @@ static_library("fx_libopenjpeg") {
"libopenjpeg20/openjpeg.c",
"libopenjpeg20/opj_clock.c",
"libopenjpeg20/pi.c",
+ "libopenjpeg20/sparse_array.c",
+ "libopenjpeg20/sparse_array.h",
"libopenjpeg20/t1.c",
"libopenjpeg20/t2.c",
"libopenjpeg20/tcd.c",
diff --git a/third_party/libopenjpeg20/0003-dwt-decode.patch b/third_party/libopenjpeg20/0003-dwt-decode.patch
index 48e1b8956e..631219a8b3 100644
--- a/third_party/libopenjpeg20/0003-dwt-decode.patch
+++ b/third_party/libopenjpeg20/0003-dwt-decode.patch
@@ -1,26 +1,25 @@
diff --git a/third_party/libopenjpeg20/dwt.c b/third_party/libopenjpeg20/dwt.c
-index f3994ca7b..8bf23b6d6 100644
+index 83c148002..1455ee84a 100644
--- a/third_party/libopenjpeg20/dwt.c
+++ b/third_party/libopenjpeg20/dwt.c
-@@ -63,9 +63,6 @@
+@@ -62,8 +62,6 @@
+
/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
/*@{*/
-
-#define OPJ_WS(i) v->mem[(i)*2]
-#define OPJ_WD(i) v->mem[(1+(i)*2)]
--
+
#ifdef __AVX2__
/** Number of int32 values in a AVX2 register */
- #define VREG_INT_COUNT 8
-@@ -82,6 +79,7 @@
+@@ -81,6 +79,7 @@
typedef struct dwt_local {
OPJ_INT32* mem;
+ OPJ_SIZE_T mem_count;
- OPJ_INT32 dn;
- OPJ_INT32 sn;
- OPJ_INT32 cas;
-@@ -129,13 +127,15 @@ static void opj_dwt_deinterleave_v(OPJ_INT32 *a, OPJ_INT32 *b, OPJ_INT32 dn,
+ OPJ_INT32 dn; /* number of elements in high pass band */
+ OPJ_INT32 sn; /* number of elements in low pass band */
+ OPJ_INT32 cas; /* 0 = start on even coord, 1 = start on odd coord */
+@@ -132,13 +131,14 @@ static void opj_dwt_deinterleave_v(OPJ_INT32 *a, OPJ_INT32 *b, OPJ_INT32 dn,
/**
Forward 5-3 wavelet transform in 1-D
*/
@@ -28,7 +27,6 @@ index f3994ca7b..8bf23b6d6 100644
- OPJ_INT32 cas);
+static void opj_dwt_encode_1(OPJ_INT32 *a, OPJ_SIZE_T a_count, OPJ_INT32 dn,
+ OPJ_INT32 sn, OPJ_INT32 cas);
-+
/**
Forward 9-7 wavelet transform in 1-D
*/
@@ -37,16 +35,20 @@ index f3994ca7b..8bf23b6d6 100644
+static void opj_dwt_encode_1_real(OPJ_INT32 *a, OPJ_SIZE_T a_count,
+ OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas);
+
+
/**
Explicit calculation of the Quantization Stepsizes
- */
-@@ -145,10 +145,10 @@ static void opj_dwt_encode_stepsize(OPJ_INT32 stepsize, OPJ_INT32 numbps,
+@@ -149,14 +149,14 @@ static void opj_dwt_encode_stepsize(OPJ_INT32 stepsize, OPJ_INT32 numbps,
Inverse wavelet transform in 2-D.
*/
static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
- opj_tcd_tilecomp_t* tilec, OPJ_UINT32 i);
+ const opj_tcd_tilecomp_t* tilec, OPJ_UINT32 i);
+ static OPJ_BOOL opj_dwt_decode_partial_tile(
+ opj_tcd_tilecomp_t* tilec,
+ OPJ_UINT32 numres);
+
-static OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
- void (*p_function)(OPJ_INT32 *, OPJ_INT32, OPJ_INT32, OPJ_INT32));
+static OPJ_BOOL opj_dwt_encode_procedure(const opj_tcd_tilecomp_t * tilec,
@@ -54,7 +56,7 @@ index f3994ca7b..8bf23b6d6 100644
static OPJ_UINT32 opj_dwt_max_resolution(opj_tcd_resolution_t* OPJ_RESTRICT r,
OPJ_UINT32 i);
-@@ -184,13 +184,20 @@ static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k,
+@@ -205,13 +205,20 @@ static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w,
/*@}*/
@@ -81,7 +83,7 @@ index f3994ca7b..8bf23b6d6 100644
/* <summary> */
/* This table contains the norms of the 5-3 wavelets for different bands. */
-@@ -319,8 +326,8 @@ static void opj_dwt_interleave_v(const opj_dwt_t* v, OPJ_INT32 *a, OPJ_INT32 x)
+@@ -344,8 +351,8 @@ static void opj_dwt_interleave_v(const opj_dwt_t* v, OPJ_INT32 *a, OPJ_INT32 x)
/* <summary> */
/* Forward 5-3 wavelet transform in 1-D. */
/* </summary> */
@@ -92,7 +94,7 @@ index f3994ca7b..8bf23b6d6 100644
{
OPJ_INT32 i;
-@@ -351,8 +358,8 @@ static void opj_dwt_encode_1(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn,
+@@ -376,8 +383,8 @@ static void opj_dwt_encode_1(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn,
/* <summary> */
/* Inverse 5-3 wavelet transform in 1-D. */
/* </summary> */
@@ -103,7 +105,7 @@ index f3994ca7b..8bf23b6d6 100644
{
OPJ_INT32 i;
-@@ -381,7 +388,7 @@ static void opj_dwt_decode_1_(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn,
+@@ -406,7 +413,7 @@ static void opj_dwt_decode_1_(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn,
static void opj_dwt_decode_1(const opj_dwt_t *v)
{
@@ -112,7 +114,7 @@ index f3994ca7b..8bf23b6d6 100644
}
#endif /* STANDARD_SLOW_VERSION */
-@@ -1010,8 +1017,8 @@ static void opj_idwt53_v(const opj_dwt_t *dwt,
+@@ -1037,8 +1044,8 @@ static void opj_idwt53_v(const opj_dwt_t *dwt,
/* <summary> */
/* Forward 9-7 wavelet transform in 1-D. */
/* </summary> */
@@ -123,7 +125,7 @@ index f3994ca7b..8bf23b6d6 100644
{
OPJ_INT32 i;
if (!cas) {
-@@ -1079,8 +1086,8 @@ static void opj_dwt_encode_stepsize(OPJ_INT32 stepsize, OPJ_INT32 numbps,
+@@ -1106,8 +1113,8 @@ static void opj_dwt_encode_stepsize(OPJ_INT32 stepsize, OPJ_INT32 numbps,
/* <summary> */
/* Forward 5-3 wavelet transform in 2-D. */
/* </summary> */
@@ -134,15 +136,15 @@ index f3994ca7b..8bf23b6d6 100644
{
OPJ_INT32 i, j, k;
OPJ_INT32 *a = 00;
-@@ -1090,6 +1097,7 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
+@@ -1117,6 +1124,7 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
OPJ_INT32 rw; /* width of the resolution level computed */
OPJ_INT32 rh; /* height of the resolution level computed */
-+ size_t l_data_count;
- size_t l_data_size;
++ OPJ_SIZE_T l_data_count;
+ OPJ_SIZE_T l_data_size;
opj_tcd_resolution_t * l_cur_res = 0;
-@@ -1102,13 +1110,13 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
+@@ -1129,13 +1137,13 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
l_cur_res = tilec->resolutions + l;
l_last_res = l_cur_res - 1;
@@ -159,7 +161,7 @@ index f3994ca7b..8bf23b6d6 100644
bj = (OPJ_INT32*)opj_malloc(l_data_size);
/* l_data_size is equal to 0 when numresolutions == 1 but bj is not used */
/* in that case, so do not error out */
-@@ -1140,7 +1148,7 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
+@@ -1167,7 +1175,7 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
bj[k] = aj[k * w];
}
@@ -168,7 +170,7 @@ index f3994ca7b..8bf23b6d6 100644
opj_dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
}
-@@ -1153,7 +1161,7 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
+@@ -1180,7 +1188,7 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,
for (k = 0; k < rw; k++) {
bj[k] = aj[k];
}
@@ -177,7 +179,7 @@ index f3994ca7b..8bf23b6d6 100644
opj_dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
}
-@@ -1332,7 +1340,7 @@ static void opj_dwt_decode_v_func(void* user_data, opj_tls_t* tls)
+@@ -1379,7 +1387,7 @@ static void opj_dwt_decode_v_func(void* user_data, opj_tls_t* tls)
/* Inverse wavelet transform in 2-D. */
/* </summary> */
static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
@@ -186,7 +188,7 @@ index f3994ca7b..8bf23b6d6 100644
{
opj_dwt_t h;
opj_dwt_t v;
-@@ -1352,22 +1360,23 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
+@@ -1401,22 +1409,23 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
return OPJ_TRUE;
}
num_threads = opj_thread_pool_get_thread_count(tp);
@@ -213,3 +215,50 @@ index f3994ca7b..8bf23b6d6 100644
v.mem = h.mem;
while (--numres) {
+@@ -1594,7 +1603,8 @@ static void opj_dwt_interleave_partial_v(OPJ_INT32 *dest,
+ OPJ_UNUSED(ret);
+ }
+
+-static void opj_dwt_decode_partial_1(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn,
++static void opj_dwt_decode_partial_1(OPJ_INT32 *a, OPJ_SIZE_T a_count,
++ OPJ_INT32 dn, OPJ_INT32 sn,
+ OPJ_INT32 cas,
+ OPJ_INT32 win_l_x0,
+ OPJ_INT32 win_l_x1,
+@@ -1974,16 +1984,16 @@ static OPJ_BOOL opj_dwt_decode_partial_tile(
+ opj_sparse_array_int32_free(sa);
+ return OPJ_TRUE;
+ }
+- h_mem_size = opj_dwt_max_resolution(tr, numres);
++ h.mem_count = opj_dwt_max_resolution(tr, numres);
+ /* overflow check */
+ /* in vertical pass, we process 4 columns at a time */
+- if (h_mem_size > (SIZE_MAX / (4 * sizeof(OPJ_INT32)))) {
++ if (h.mem_count > (SIZE_MAX / (4 * sizeof(OPJ_INT32)))) {
+ /* FIXME event manager error callback */
+ opj_sparse_array_int32_free(sa);
+ return OPJ_FALSE;
+ }
+
+- h_mem_size *= 4 * sizeof(OPJ_INT32);
++ h_mem_size = h.mem_count * 4 * sizeof(OPJ_INT32);
+ h.mem = (OPJ_INT32*)opj_aligned_32_malloc(h_mem_size);
+ if (! h.mem) {
+ /* FIXME event manager error callback */
+@@ -1991,6 +2001,7 @@ static OPJ_BOOL opj_dwt_decode_partial_tile(
+ return OPJ_FALSE;
+ }
+
++ v.mem_count = h.mem_count;
+ v.mem = h.mem;
+
+ for (resno = 1; resno < numres; resno ++) {
+@@ -2101,7 +2112,7 @@ static OPJ_BOOL opj_dwt_decode_partial_tile(
+ win_ll_x1,
+ win_hl_x0,
+ win_hl_x1);
+- opj_dwt_decode_partial_1(h.mem, h.dn, h.sn, h.cas,
++ opj_dwt_decode_partial_1(h.mem, h.mem_count, h.dn, h.sn, h.cas,
+ (OPJ_INT32)win_ll_x0,
+ (OPJ_INT32)win_ll_x1,
+ (OPJ_INT32)win_hl_x0,
diff --git a/third_party/libopenjpeg20/0005-jp2_apply_pclr.patch b/third_party/libopenjpeg20/0005-jp2_apply_pclr.patch
index c852bd057d..c8caea853c 100644
--- a/third_party/libopenjpeg20/0005-jp2_apply_pclr.patch
+++ b/third_party/libopenjpeg20/0005-jp2_apply_pclr.patch
@@ -1,17 +1,8 @@
diff --git a/third_party/libopenjpeg20/jp2.c b/third_party/libopenjpeg20/jp2.c
-index 882f1b649..3ace09654 100644
+index da4e05f82..c9562f705 100644
--- a/third_party/libopenjpeg20/jp2.c
+++ b/third_party/libopenjpeg20/jp2.c
-@@ -969,7 +969,7 @@ static OPJ_BOOL opj_jp2_check_color(opj_image_t *image, opj_jp2_color_t *color,
- opj_event_msg(p_manager, EVT_ERROR,
- "Invalid component/palette index for direct mapping %d.\n", pcol);
- is_sane = OPJ_FALSE;
-- } else if (pcol_usage[pcol] && cmap[i].mtyp == 1) {
-+ } else if (pcol_usage[pcol] && cmap[i].mtyp != 0) {
- opj_event_msg(p_manager, EVT_ERROR, "Component %d is mapped twice.\n", pcol);
- is_sane = OPJ_FALSE;
- } else if (cmap[i].mtyp == 0 && cmap[i].pcol != 0) {
-@@ -1064,8 +1064,8 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
+@@ -1073,8 +1073,8 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
assert(pcol == 0);
new_comps[i] = old_comps[cmp];
} else {
@@ -22,7 +13,7 @@ index 882f1b649..3ace09654 100644
}
/* Palette mapping: */
-@@ -1093,19 +1093,19 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
+@@ -1102,19 +1102,19 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
pcol = cmap[i].pcol;
src = old_comps[cmp].data;
assert(src); /* verified above */
diff --git a/third_party/libopenjpeg20/0006-tcd_init_tile.patch b/third_party/libopenjpeg20/0006-tcd_init_tile.patch
index 967e2e4379..8c37fc2733 100644
--- a/third_party/libopenjpeg20/0006-tcd_init_tile.patch
+++ b/third_party/libopenjpeg20/0006-tcd_init_tile.patch
@@ -1,16 +1,16 @@
diff --git a/third_party/libopenjpeg20/tcd.c b/third_party/libopenjpeg20/tcd.c
-index dd9faced5..f0710cd14 100644
+index 1dd15405d..acc28dd55 100644
--- a/third_party/libopenjpeg20/tcd.c
+++ b/third_party/libopenjpeg20/tcd.c
-@@ -788,7 +788,10 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no,
- l_tilec->x1 = opj_int_ceildiv(l_tile->x1, (OPJ_INT32)l_image_comp->dx);
- l_tilec->y1 = opj_int_ceildiv(l_tile->y1, (OPJ_INT32)l_image_comp->dy);
- /*fprintf(stderr, "\tTile compo border = %d,%d,%d,%d\n", l_tilec->x0, l_tilec->y0,l_tilec->x1,l_tilec->y1);*/
--
-+ if (l_tilec->x0 >= l_tilec->x1 || l_tilec->y0 >= l_tilec->y1) {
-+ opj_event_msg(manager, EVT_ERROR, "Invalid tile data\n");
-+ return OPJ_FALSE;
-+ }
- /* compute l_data_size with overflow check */
- l_data_size = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0);
- /* issue 733, l_data_size == 0U, probably something wrong should be checked before getting here */
+@@ -818,6 +818,11 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no,
+ if (isEncoder) {
+ OPJ_SIZE_T l_tile_data_size;
+
++ if (l_tilec->x0 >= l_tilec->x1 || l_tilec->y0 >= l_tilec->y1) {
++ opj_event_msg(manager, EVT_ERROR, "Invalid tile data\n");
++ return OPJ_FALSE;
++ }
++
+ /* compute l_data_size with overflow check */
+ OPJ_SIZE_T w = (OPJ_SIZE_T)(l_tilec->x1 - l_tilec->x0);
+ OPJ_SIZE_T h = (OPJ_SIZE_T)(l_tilec->y1 - l_tilec->y0);
diff --git a/third_party/libopenjpeg20/0011-j2k_update_image_data.patch b/third_party/libopenjpeg20/0011-j2k_update_image_data.patch
index 7990fc78a3..b61324a6b4 100644
--- a/third_party/libopenjpeg20/0011-j2k_update_image_data.patch
+++ b/third_party/libopenjpeg20/0011-j2k_update_image_data.patch
@@ -1,17 +1,17 @@
diff --git a/third_party/libopenjpeg20/j2k.c b/third_party/libopenjpeg20/j2k.c
-index 44de79a75..8e35b33ee 100644
+index ad6e1b86f..bf1cb4f36 100644
--- a/third_party/libopenjpeg20/j2k.c
+++ b/third_party/libopenjpeg20/j2k.c
-@@ -8914,6 +8914,12 @@ static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data,
+@@ -9086,6 +9086,12 @@ static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd,
* */
- assert(l_res->x0 >= 0);
- assert(l_res->x1 >= 0);
+ assert(res_x0 >= 0);
+ assert(res_x1 >= 0);
+
+ /* Prevent bad casting to unsigned values in the subsequent lines. */
-+ if ( l_res->x0 < 0 || l_res->x1 < 0 || l_res->y0 < 0 || l_res->y1 < 0 ) {
++ if ( res_x0 < 0 || res_x1 < 0 || res_y0 < 0 || res_y1 < 0 ) {
+ return OPJ_FALSE;
+ }
+
- if (l_x0_dest < (OPJ_UINT32)l_res->x0) {
- l_start_x_dest = (OPJ_UINT32)l_res->x0 - l_x0_dest;
+ if (l_x0_dest < (OPJ_UINT32)res_x0) {
+ l_start_x_dest = (OPJ_UINT32)res_x0 - l_x0_dest;
l_offset_x0_src = 0;
diff --git a/third_party/libopenjpeg20/0012-mct_sse.patch b/third_party/libopenjpeg20/0012-mct_sse.patch
index 168b9123e4..9bc2e6f0dc 100644
--- a/third_party/libopenjpeg20/0012-mct_sse.patch
+++ b/third_party/libopenjpeg20/0012-mct_sse.patch
@@ -1,5 +1,5 @@
diff --git a/third_party/libopenjpeg20/mct.c b/third_party/libopenjpeg20/mct.c
-index 8c82ee20a..20b9e121b 100644
+index b79d4b87c..81ec223d8 100644
--- a/third_party/libopenjpeg20/mct.c
+++ b/third_party/libopenjpeg20/mct.c
@@ -37,13 +37,16 @@
@@ -50,7 +50,7 @@ index 8c82ee20a..20b9e121b 100644
OPJ_INT32* OPJ_RESTRICT c0,
OPJ_INT32* OPJ_RESTRICT c1,
@@ -389,7 +392,7 @@ void opj_mct_decode_real(
- OPJ_UINT32 n)
+ OPJ_SIZE_T n)
{
OPJ_UINT32 i;
-#ifdef __SSE__
diff --git a/third_party/libopenjpeg20/0033-undefined-shift-opj_t1_dec_clnpass.patch b/third_party/libopenjpeg20/0033-undefined-shift-opj_t1_dec_clnpass.patch
deleted file mode 100644
index 58f04b0a24..0000000000
--- a/third_party/libopenjpeg20/0033-undefined-shift-opj_t1_dec_clnpass.patch
+++ /dev/null
@@ -1,14 +0,0 @@
-diff --git a/third_party/libopenjpeg20/t1.c b/third_party/libopenjpeg20/t1.c
-index 1ad850c77..d290c38d5 100644
---- a/third_party/libopenjpeg20/t1.c
-+++ b/third_party/libopenjpeg20/t1.c
-@@ -1387,6 +1387,9 @@ static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
- }
-
- bpno_plus_one = (OPJ_INT32)(roishift + cblk->numbps);
-+ if (bpno_plus_one > 30) {
-+ return OPJ_FALSE;
-+ }
- passtype = 2;
-
- opj_mqc_resetstates(mqc);
diff --git a/third_party/libopenjpeg20/0035-opj_image_data_free.patch b/third_party/libopenjpeg20/0035-opj_image_data_free.patch
index 8bd03a214e..bc674da378 100644
--- a/third_party/libopenjpeg20/0035-opj_image_data_free.patch
+++ b/third_party/libopenjpeg20/0035-opj_image_data_free.patch
@@ -1,30 +1,8 @@
-diff --git a/third_party/libopenjpeg20/image.c b/third_party/libopenjpeg20/image.c
-index e29172b2b..bf7a70194 100644
---- a/third_party/libopenjpeg20/image.c
-+++ b/third_party/libopenjpeg20/image.c
-@@ -180,7 +180,7 @@ void opj_copy_image_header(const opj_image_t* p_image_src,
- for (compno = 0; compno < p_image_dest->numcomps; compno++) {
- opj_image_comp_t *image_comp = &(p_image_dest->comps[compno]);
- if (image_comp->data) {
-- opj_free(image_comp->data);
-+ opj_image_data_free(image_comp->data);
- }
- }
- opj_free(p_image_dest->comps);
diff --git a/third_party/libopenjpeg20/jp2.c b/third_party/libopenjpeg20/jp2.c
-index 9178f3fd6..e7e2db8bb 100644
+index 298648a77..2374d459f 100644
--- a/third_party/libopenjpeg20/jp2.c
+++ b/third_party/libopenjpeg20/jp2.c
-@@ -1083,7 +1083,7 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
- if (!new_comps[i].data) {
- while (i > 0) {
- -- i;
-- opj_free(new_comps[i].data);
-+ opj_image_data_free(new_comps[i].data);
- }
- opj_free(new_comps);
- opj_event_msg(p_manager, EVT_ERROR,
-@@ -1107,7 +1107,7 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
+@@ -1116,7 +1116,7 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
/* Prevent null pointer access */
if (!src || !dst) {
for (j = 0; j < nr_channels; ++j) {
diff --git a/third_party/libopenjpeg20/CMakeLists.txt b/third_party/libopenjpeg20/CMakeLists.txt
index 7f16834660..800dc9aac7 100644
--- a/third_party/libopenjpeg20/CMakeLists.txt
+++ b/third_party/libopenjpeg20/CMakeLists.txt
@@ -13,6 +13,7 @@ set(OPENJPEG_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/cio.c
${CMAKE_CURRENT_SOURCE_DIR}/dwt.c
${CMAKE_CURRENT_SOURCE_DIR}/event.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/function_list.c
${CMAKE_CURRENT_SOURCE_DIR}/image.c
${CMAKE_CURRENT_SOURCE_DIR}/invert.c
${CMAKE_CURRENT_SOURCE_DIR}/j2k.c
@@ -23,11 +24,11 @@ set(OPENJPEG_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/opj_clock.c
${CMAKE_CURRENT_SOURCE_DIR}/pi.c
${CMAKE_CURRENT_SOURCE_DIR}/raw.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/sparse_array.c
${CMAKE_CURRENT_SOURCE_DIR}/t1.c
${CMAKE_CURRENT_SOURCE_DIR}/t2.c
${CMAKE_CURRENT_SOURCE_DIR}/tcd.c
${CMAKE_CURRENT_SOURCE_DIR}/tgt.c
- ${CMAKE_CURRENT_SOURCE_DIR}/function_list.c
)
if(BUILD_JPIP)
add_definitions(-DUSE_JPIP)
diff --git a/third_party/libopenjpeg20/README.pdfium b/third_party/libopenjpeg20/README.pdfium
index 143ca0fab3..b098bf6b73 100644
--- a/third_party/libopenjpeg20/README.pdfium
+++ b/third_party/libopenjpeg20/README.pdfium
@@ -1,6 +1,6 @@
Name: OpenJPEG
URL: http://www.openjpeg.org/
-Version: 2.2.0 (also update in opj_config*)
+Version: 2.3.0 (also update in opj_config*)
Security Critical: yes
License: 2-clause BSD
diff --git a/third_party/libopenjpeg20/dwt.c b/third_party/libopenjpeg20/dwt.c
index 8bf23b6d60..1455ee84a1 100644
--- a/third_party/libopenjpeg20/dwt.c
+++ b/third_party/libopenjpeg20/dwt.c
@@ -80,9 +80,9 @@
typedef struct dwt_local {
OPJ_INT32* mem;
OPJ_SIZE_T mem_count;
- OPJ_INT32 dn;
- OPJ_INT32 sn;
- OPJ_INT32 cas;
+ OPJ_INT32 dn; /* number of elements in high pass band */
+ OPJ_INT32 sn; /* number of elements in low pass band */
+ OPJ_INT32 cas; /* 0 = start on even coord, 1 = start on odd coord */
} opj_dwt_t;
typedef union {
@@ -91,9 +91,13 @@ typedef union {
typedef struct v4dwt_local {
opj_v4_t* wavelet ;
- OPJ_INT32 dn ;
- OPJ_INT32 sn ;
- OPJ_INT32 cas ;
+ OPJ_INT32 dn ; /* number of elements in high pass band */
+ OPJ_INT32 sn ; /* number of elements in low pass band */
+ OPJ_INT32 cas ; /* 0 = start on even coord, 1 = start on odd coord */
+ OPJ_UINT32 win_l_x0; /* start coord in low pass band */
+ OPJ_UINT32 win_l_x1; /* end coord in low pass band */
+ OPJ_UINT32 win_h_x0; /* start coord in high pass band */
+ OPJ_UINT32 win_h_x1; /* end coord in high pass band */
} opj_v4dwt_t ;
static const OPJ_FLOAT32 opj_dwt_alpha = 1.586134342f; /* 12994 */
@@ -129,13 +133,13 @@ Forward 5-3 wavelet transform in 1-D
*/
static void opj_dwt_encode_1(OPJ_INT32 *a, OPJ_SIZE_T a_count, OPJ_INT32 dn,
OPJ_INT32 sn, OPJ_INT32 cas);
-
/**
Forward 9-7 wavelet transform in 1-D
*/
static void opj_dwt_encode_1_real(OPJ_INT32 *a, OPJ_SIZE_T a_count,
OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas);
+
/**
Explicit calculation of the Quantization Stepsizes
*/
@@ -147,6 +151,10 @@ Inverse wavelet transform in 2-D.
static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
const opj_tcd_tilecomp_t* tilec, OPJ_UINT32 i);
+static OPJ_BOOL opj_dwt_decode_partial_tile(
+ opj_tcd_tilecomp_t* tilec,
+ OPJ_UINT32 numres);
+
static OPJ_BOOL opj_dwt_encode_procedure(const opj_tcd_tilecomp_t * tilec,
void(*p_function)(OPJ_INT32 *, OPJ_SIZE_T, OPJ_INT32, OPJ_INT32, OPJ_INT32));
@@ -158,25 +166,38 @@ static OPJ_UINT32 opj_dwt_max_resolution(opj_tcd_resolution_t* OPJ_RESTRICT r,
/* </summary> */
static void opj_v4dwt_decode(opj_v4dwt_t* OPJ_RESTRICT dwt);
-static void opj_v4dwt_interleave_h(opj_v4dwt_t* OPJ_RESTRICT w,
- OPJ_FLOAT32* OPJ_RESTRICT a, OPJ_INT32 x, OPJ_INT32 size);
+static void opj_v4dwt_interleave_h(opj_v4dwt_t* OPJ_RESTRICT dwt,
+ OPJ_FLOAT32* OPJ_RESTRICT a,
+ OPJ_UINT32 width,
+ OPJ_UINT32 remaining_height);
-static void opj_v4dwt_interleave_v(opj_v4dwt_t* OPJ_RESTRICT v,
- OPJ_FLOAT32* OPJ_RESTRICT a, OPJ_INT32 x, OPJ_INT32 nb_elts_read);
+static void opj_v4dwt_interleave_v(opj_v4dwt_t* OPJ_RESTRICT dwt,
+ OPJ_FLOAT32* OPJ_RESTRICT a,
+ OPJ_UINT32 width,
+ OPJ_UINT32 nb_elts_read);
#ifdef __SSE__
-static void opj_v4dwt_decode_step1_sse(opj_v4_t* w, OPJ_INT32 count,
+static void opj_v4dwt_decode_step1_sse(opj_v4_t* w,
+ OPJ_UINT32 start,
+ OPJ_UINT32 end,
const __m128 c);
-static void opj_v4dwt_decode_step2_sse(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k,
- OPJ_INT32 m, __m128 c);
+static void opj_v4dwt_decode_step2_sse(opj_v4_t* l, opj_v4_t* w,
+ OPJ_UINT32 start,
+ OPJ_UINT32 end,
+ OPJ_UINT32 m, __m128 c);
#else
-static void opj_v4dwt_decode_step1(opj_v4_t* w, OPJ_INT32 count,
+static void opj_v4dwt_decode_step1(opj_v4_t* w,
+ OPJ_UINT32 start,
+ OPJ_UINT32 end,
const OPJ_FLOAT32 c);
-static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k,
- OPJ_INT32 m, OPJ_FLOAT32 c);
+static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w,
+ OPJ_UINT32 start,
+ OPJ_UINT32 end,
+ OPJ_UINT32 m,
+ OPJ_FLOAT32 c);
#endif
@@ -202,6 +223,8 @@ static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k,
/* <summary> */
/* This table contains the norms of the 5-3 wavelets for different bands. */
/* </summary> */
+/* FIXME! the array should really be extended up to 33 resolution levels */
+/* See https://github.com/uclouvain/openjpeg/issues/493 */
static const OPJ_FLOAT64 opj_dwt_norms[4][10] = {
{1.000, 1.500, 2.750, 5.375, 10.68, 21.34, 42.67, 85.33, 170.7, 341.3},
{1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
@@ -212,6 +235,8 @@ static const OPJ_FLOAT64 opj_dwt_norms[4][10] = {
/* <summary> */
/* This table contains the norms of the 9-7 wavelets for different bands. */
/* </summary> */
+/* FIXME! the array should really be extended up to 33 resolution levels */
+/* See https://github.com/uclouvain/openjpeg/issues/493 */
static const OPJ_FLOAT64 opj_dwt_norms_real[4][10] = {
{1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9},
{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
@@ -265,7 +290,7 @@ static void opj_dwt_deinterleave_v(OPJ_INT32 *a, OPJ_INT32 *b, OPJ_INT32 dn,
l_src += 2;
} /* b[i*x]=a[2*i+cas]; */
- l_dest = b + sn * x;
+ l_dest = b + (OPJ_SIZE_T)sn * (OPJ_SIZE_T)x;
l_src = a + 1 - cas;
i = dn;
@@ -311,7 +336,7 @@ static void opj_dwt_interleave_v(const opj_dwt_t* v, OPJ_INT32 *a, OPJ_INT32 x)
bi += 2;
ai += x;
}
- ai = a + (v->sn * x);
+ ai = a + (v->sn * (OPJ_SIZE_T)x);
bi = v->mem + 1 - v->cas;
i = v->dn ;
while (i--) {
@@ -602,7 +627,7 @@ static
void opj_idwt53_v_final_memcpy(OPJ_INT32* tiledp_col,
const OPJ_INT32* tmp,
OPJ_INT32 len,
- OPJ_INT32 stride)
+ OPJ_SIZE_T stride)
{
OPJ_INT32 i;
for (i = 0; i < len; ++i) {
@@ -611,9 +636,9 @@ void opj_idwt53_v_final_memcpy(OPJ_INT32* tiledp_col,
PARALLEL_COLS_53 * sizeof(OPJ_INT32))
would do but would be a tiny bit slower.
We can take here advantage of our knowledge of alignment */
- STOREU(&tiledp_col[i * stride + 0],
+ STOREU(&tiledp_col[(OPJ_SIZE_T)i * stride + 0],
LOAD(&tmp[PARALLEL_COLS_53 * i + 0]));
- STOREU(&tiledp_col[i * stride + VREG_INT_COUNT],
+ STOREU(&tiledp_col[(OPJ_SIZE_T)i * stride + VREG_INT_COUNT],
LOAD(&tmp[PARALLEL_COLS_53 * i + VREG_INT_COUNT]));
}
}
@@ -625,12 +650,13 @@ static void opj_idwt53_v_cas0_mcols_SSE2_OR_AVX2(
const OPJ_INT32 sn,
const OPJ_INT32 len,
OPJ_INT32* tiledp_col,
- const OPJ_INT32 stride)
+ const OPJ_SIZE_T stride)
{
const OPJ_INT32* in_even = &tiledp_col[0];
- const OPJ_INT32* in_odd = &tiledp_col[sn * stride];
+ const OPJ_INT32* in_odd = &tiledp_col[(OPJ_SIZE_T)sn * stride];
- OPJ_INT32 i, j;
+ OPJ_INT32 i;
+ OPJ_SIZE_T j;
VREG d1c_0, d1n_0, s1n_0, s0c_0, s0n_0;
VREG d1c_1, d1n_1, s1n_1, s0c_1, s0n_1;
const VREG two = LOAD_CST(2);
@@ -647,7 +673,7 @@ static void opj_idwt53_v_cas0_mcols_SSE2_OR_AVX2(
/* Note: loads of input even/odd values must be done in a unaligned */
/* fashion. But stores in tmp can be done with aligned store, since */
/* the temporary buffer is properly aligned */
- assert((size_t)tmp % (sizeof(OPJ_INT32) * VREG_INT_COUNT) == 0);
+ assert((OPJ_SIZE_T)tmp % (sizeof(OPJ_INT32) * VREG_INT_COUNT) == 0);
s1n_0 = LOADU(in_even + 0);
s1n_1 = LOADU(in_even + VREG_INT_COUNT);
@@ -689,7 +715,7 @@ static void opj_idwt53_v_cas0_mcols_SSE2_OR_AVX2(
if (len & 1) {
VREG tmp_len_minus_1;
- s1n_0 = LOADU(in_even + ((len - 1) / 2) * stride);
+ s1n_0 = LOADU(in_even + (OPJ_SIZE_T)((len - 1) / 2) * stride);
/* tmp_len_minus_1 = s1n - ((d1n + 1) >> 1); */
tmp_len_minus_1 = SUB(s1n_0, SAR(ADD3(d1n_0, d1n_0, two), 2));
STORE(tmp + PARALLEL_COLS_53 * (len - 1), tmp_len_minus_1);
@@ -697,7 +723,7 @@ static void opj_idwt53_v_cas0_mcols_SSE2_OR_AVX2(
STORE(tmp + PARALLEL_COLS_53 * (len - 2),
ADD(d1n_0, SAR(ADD(s0n_0, tmp_len_minus_1), 1)));
- s1n_1 = LOADU(in_even + ((len - 1) / 2) * stride + VREG_INT_COUNT);
+ s1n_1 = LOADU(in_even + (OPJ_SIZE_T)((len - 1) / 2) * stride + VREG_INT_COUNT);
/* tmp_len_minus_1 = s1n - ((d1n + 1) >> 1); */
tmp_len_minus_1 = SUB(s1n_1, SAR(ADD3(d1n_1, d1n_1, two), 2));
STORE(tmp + PARALLEL_COLS_53 * (len - 1) + VREG_INT_COUNT,
@@ -725,15 +751,16 @@ static void opj_idwt53_v_cas1_mcols_SSE2_OR_AVX2(
const OPJ_INT32 sn,
const OPJ_INT32 len,
OPJ_INT32* tiledp_col,
- const OPJ_INT32 stride)
+ const OPJ_SIZE_T stride)
{
- OPJ_INT32 i, j;
+ OPJ_INT32 i;
+ OPJ_SIZE_T j;
VREG s1_0, s2_0, dc_0, dn_0;
VREG s1_1, s2_1, dc_1, dn_1;
const VREG two = LOAD_CST(2);
- const OPJ_INT32* in_even = &tiledp_col[sn * stride];
+ const OPJ_INT32* in_even = &tiledp_col[(OPJ_SIZE_T)sn * stride];
const OPJ_INT32* in_odd = &tiledp_col[0];
assert(len > 2);
@@ -748,7 +775,7 @@ static void opj_idwt53_v_cas1_mcols_SSE2_OR_AVX2(
/* Note: loads of input even/odd values must be done in a unaligned */
/* fashion. But stores in tmp can be done with aligned store, since */
/* the temporary buffer is properly aligned */
- assert((size_t)tmp % (sizeof(OPJ_INT32) * VREG_INT_COUNT) == 0);
+ assert((OPJ_SIZE_T)tmp % (sizeof(OPJ_INT32) * VREG_INT_COUNT) == 0);
s1_0 = LOADU(in_even + stride);
/* in_odd[0] - ((in_even[0] + s1 + 2) >> 2); */
@@ -793,9 +820,9 @@ static void opj_idwt53_v_cas1_mcols_SSE2_OR_AVX2(
if (!(len & 1)) {
/*dn = in_odd[(len / 2 - 1) * stride] - ((s1 + 1) >> 1); */
- dn_0 = SUB(LOADU(in_odd + (len / 2 - 1) * stride),
+ dn_0 = SUB(LOADU(in_odd + (OPJ_SIZE_T)(len / 2 - 1) * stride),
SAR(ADD3(s1_0, s1_0, two), 2));
- dn_1 = SUB(LOADU(in_odd + (len / 2 - 1) * stride + VREG_INT_COUNT),
+ dn_1 = SUB(LOADU(in_odd + (OPJ_SIZE_T)(len / 2 - 1) * stride + VREG_INT_COUNT),
SAR(ADD3(s1_1, s1_1, two), 2));
/* tmp[len - 2] = s1 + ((dn + dc) >> 1); */
@@ -835,7 +862,7 @@ static void opj_idwt3_v_cas0(OPJ_INT32* tmp,
const OPJ_INT32 sn,
const OPJ_INT32 len,
OPJ_INT32* tiledp_col,
- const OPJ_INT32 stride)
+ const OPJ_SIZE_T stride)
{
OPJ_INT32 i, j;
OPJ_INT32 d1c, d1n, s1n, s0c, s0n;
@@ -846,15 +873,15 @@ static void opj_idwt3_v_cas0(OPJ_INT32* tmp,
/* accesses and explicit interleaving. */
s1n = tiledp_col[0];
- d1n = tiledp_col[sn * stride];
+ d1n = tiledp_col[(OPJ_SIZE_T)sn * stride];
s0n = s1n - ((d1n + 1) >> 1);
for (i = 0, j = 0; i < (len - 3); i += 2, j++) {
d1c = d1n;
s0c = s0n;
- s1n = tiledp_col[(j + 1) * stride];
- d1n = tiledp_col[(sn + j + 1) * stride];
+ s1n = tiledp_col[(OPJ_SIZE_T)(j + 1) * stride];
+ d1n = tiledp_col[(OPJ_SIZE_T)(sn + j + 1) * stride];
s0n = s1n - ((d1c + d1n + 2) >> 2);
@@ -866,7 +893,7 @@ static void opj_idwt3_v_cas0(OPJ_INT32* tmp,
if (len & 1) {
tmp[len - 1] =
- tiledp_col[((len - 1) / 2) * stride] -
+ tiledp_col[(OPJ_SIZE_T)((len - 1) / 2) * stride] -
((d1n + 1) >> 1);
tmp[len - 2] = d1n + ((s0n + tmp[len - 1]) >> 1);
} else {
@@ -874,7 +901,7 @@ static void opj_idwt3_v_cas0(OPJ_INT32* tmp,
}
for (i = 0; i < len; ++i) {
- tiledp_col[i * stride] = tmp[i];
+ tiledp_col[(OPJ_SIZE_T)i * stride] = tmp[i];
}
}
@@ -885,11 +912,11 @@ static void opj_idwt3_v_cas1(OPJ_INT32* tmp,
const OPJ_INT32 sn,
const OPJ_INT32 len,
OPJ_INT32* tiledp_col,
- const OPJ_INT32 stride)
+ const OPJ_SIZE_T stride)
{
OPJ_INT32 i, j;
OPJ_INT32 s1, s2, dc, dn;
- const OPJ_INT32* in_even = &tiledp_col[sn * stride];
+ const OPJ_INT32* in_even = &tiledp_col[(OPJ_SIZE_T)sn * stride];
const OPJ_INT32* in_odd = &tiledp_col[0];
assert(len > 2);
@@ -902,9 +929,9 @@ static void opj_idwt3_v_cas1(OPJ_INT32* tmp,
tmp[0] = in_even[0] + dc;
for (i = 1, j = 1; i < (len - 2 - !(len & 1)); i += 2, j++) {
- s2 = in_even[(j + 1) * stride];
+ s2 = in_even[(OPJ_SIZE_T)(j + 1) * stride];
- dn = in_odd[j * stride] - ((s1 + s2 + 2) >> 2);
+ dn = in_odd[(OPJ_SIZE_T)j * stride] - ((s1 + s2 + 2) >> 2);
tmp[i ] = dc;
tmp[i + 1] = s1 + ((dn + dc) >> 1);
@@ -913,7 +940,7 @@ static void opj_idwt3_v_cas1(OPJ_INT32* tmp,
}
tmp[i] = dc;
if (!(len & 1)) {
- dn = in_odd[(len / 2 - 1) * stride] - ((s1 + 1) >> 1);
+ dn = in_odd[(OPJ_SIZE_T)(len / 2 - 1) * stride] - ((s1 + 1) >> 1);
tmp[len - 2] = s1 + ((dn + dc) >> 1);
tmp[len - 1] = dn;
} else {
@@ -921,7 +948,7 @@ static void opj_idwt3_v_cas1(OPJ_INT32* tmp,
}
for (i = 0; i < len; ++i) {
- tiledp_col[i * stride] = tmp[i];
+ tiledp_col[(OPJ_SIZE_T)i * stride] = tmp[i];
}
}
#endif /* !defined(STANDARD_SLOW_VERSION) */
@@ -932,7 +959,7 @@ static void opj_idwt3_v_cas1(OPJ_INT32* tmp,
/* Performs interleave, inverse wavelet transform and copy back to buffer */
static void opj_idwt53_v(const opj_dwt_t *dwt,
OPJ_INT32* tiledp_col,
- OPJ_INT32 stride,
+ OPJ_SIZE_T stride,
OPJ_INT32 nb_cols)
{
#ifdef STANDARD_SLOW_VERSION
@@ -980,14 +1007,14 @@ static void opj_idwt53_v(const opj_dwt_t *dwt,
OPJ_INT32* out = dwt->mem;
for (c = 0; c < nb_cols; c++, tiledp_col++) {
OPJ_INT32 i;
- const OPJ_INT32* in_even = &tiledp_col[sn * stride];
+ const OPJ_INT32* in_even = &tiledp_col[(OPJ_SIZE_T)sn * stride];
const OPJ_INT32* in_odd = &tiledp_col[0];
out[1] = in_odd[0] - ((in_even[0] + 1) >> 1);
out[0] = in_even[0] + out[1];
for (i = 0; i < len; ++i) {
- tiledp_col[i * stride] = out[i];
+ tiledp_col[(OPJ_SIZE_T)i * stride] = out[i];
}
}
@@ -1097,8 +1124,8 @@ static INLINE OPJ_BOOL opj_dwt_encode_procedure(const opj_tcd_tilecomp_t * tilec
OPJ_INT32 rw; /* width of the resolution level computed */
OPJ_INT32 rh; /* height of the resolution level computed */
- size_t l_data_count;
- size_t l_data_size;
+ OPJ_SIZE_T l_data_count;
+ OPJ_SIZE_T l_data_size;
opj_tcd_resolution_t * l_cur_res = 0;
opj_tcd_resolution_t * l_last_res = 0;
@@ -1184,10 +1211,14 @@ OPJ_BOOL opj_dwt_encode(opj_tcd_tilecomp_t * tilec)
/* <summary> */
/* Inverse 5-3 wavelet transform in 2-D. */
/* </summary> */
-OPJ_BOOL opj_dwt_decode(opj_thread_pool_t* tp, opj_tcd_tilecomp_t* tilec,
+OPJ_BOOL opj_dwt_decode(opj_tcd_t *p_tcd, opj_tcd_tilecomp_t* tilec,
OPJ_UINT32 numres)
{
- return opj_dwt_decode_tile(tp, tilec, numres);
+ if (p_tcd->whole_tile_decoding) {
+ return opj_dwt_decode_tile(p_tcd->thread_pool, tilec, numres);
+ } else {
+ return opj_dwt_decode_partial_tile(tilec, numres);
+ }
}
@@ -1210,6 +1241,14 @@ OPJ_UINT32 opj_dwt_getgain(OPJ_UINT32 orient)
/* </summary> */
OPJ_FLOAT64 opj_dwt_getnorm(OPJ_UINT32 level, OPJ_UINT32 orient)
{
+ /* FIXME ! This is just a band-aid to avoid a buffer overflow */
+ /* but the array should really be extended up to 33 resolution levels */
+ /* See https://github.com/uclouvain/openjpeg/issues/493 */
+ if (orient == 0 && level >= 10) {
+ level = 9;
+ } else if (orient > 0 && level >= 9) {
+ level = 8;
+ }
return opj_dwt_norms[orient][level];
}
@@ -1235,6 +1274,14 @@ OPJ_UINT32 opj_dwt_getgain_real(OPJ_UINT32 orient)
/* </summary> */
OPJ_FLOAT64 opj_dwt_getnorm_real(OPJ_UINT32 level, OPJ_UINT32 orient)
{
+ /* FIXME ! This is just a band-aid to avoid a buffer overflow */
+ /* but the array should really be extended up to 33 resolution levels */
+ /* See https://github.com/uclouvain/openjpeg/issues/493 */
+ if (orient == 0 && level >= 10) {
+ level = 9;
+ } else if (orient > 0 && level >= 9) {
+ level = 8;
+ }
return opj_dwt_norms_real[orient][level];
}
@@ -1324,11 +1371,11 @@ static void opj_dwt_decode_v_func(void* user_data, opj_tls_t* tls)
job = (opj_dwd_decode_v_job_t*)user_data;
for (j = job->min_j; j + PARALLEL_COLS_53 <= job->max_j;
j += PARALLEL_COLS_53) {
- opj_idwt53_v(&job->v, &job->tiledp[j], (OPJ_INT32)job->w,
+ opj_idwt53_v(&job->v, &job->tiledp[j], (OPJ_SIZE_T)job->w,
PARALLEL_COLS_53);
}
if (j < job->max_j)
- opj_idwt53_v(&job->v, &job->tiledp[j], (OPJ_INT32)job->w,
+ opj_idwt53_v(&job->v, &job->tiledp[j], (OPJ_SIZE_T)job->w,
(OPJ_INT32)(job->max_j - j));
opj_aligned_free(job->v.mem);
@@ -1352,8 +1399,10 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
OPJ_UINT32 rh = (OPJ_UINT32)(tr->y1 -
tr->y0); /* height of the resolution level computed */
- OPJ_UINT32 w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
- size_t h_mem_size;
+ OPJ_UINT32 w = (OPJ_UINT32)(tilec->resolutions[tilec->minimum_num_resolutions -
+ 1].x1 -
+ tilec->resolutions[tilec->minimum_num_resolutions - 1].x0);
+ OPJ_SIZE_T h_mem_size;
int num_threads;
if (numres == 1U) {
@@ -1395,7 +1444,7 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
if (num_threads <= 1 || rh <= 1) {
for (j = 0; j < rh; ++j) {
- opj_idwt53_h(&h, &tiledp[j * w]);
+ opj_idwt53_h(&h, &tiledp[(OPJ_SIZE_T)j * w]);
}
} else {
OPJ_UINT32 num_jobs = (OPJ_UINT32)num_threads;
@@ -1447,10 +1496,10 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
if (num_threads <= 1 || rw <= 1) {
for (j = 0; j + PARALLEL_COLS_53 <= rw;
j += PARALLEL_COLS_53) {
- opj_idwt53_v(&v, &tiledp[j], (OPJ_INT32)w, PARALLEL_COLS_53);
+ opj_idwt53_v(&v, &tiledp[j], (OPJ_SIZE_T)w, PARALLEL_COLS_53);
}
if (j < rw) {
- opj_idwt53_v(&v, &tiledp[j], (OPJ_INT32)w, (OPJ_INT32)(rw - j));
+ opj_idwt53_v(&v, &tiledp[j], (OPJ_SIZE_T)w, (OPJ_INT32)(rw - j));
}
} else {
OPJ_UINT32 num_jobs = (OPJ_UINT32)num_threads;
@@ -1500,136 +1549,849 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
return OPJ_TRUE;
}
-static void opj_v4dwt_interleave_h(opj_v4dwt_t* OPJ_RESTRICT w,
- OPJ_FLOAT32* OPJ_RESTRICT a, OPJ_INT32 x, OPJ_INT32 size)
+static void opj_dwt_interleave_partial_h(OPJ_INT32 *dest,
+ OPJ_INT32 cas,
+ opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 sa_line,
+ OPJ_UINT32 sn,
+ OPJ_UINT32 win_l_x0,
+ OPJ_UINT32 win_l_x1,
+ OPJ_UINT32 win_h_x0,
+ OPJ_UINT32 win_h_x1)
+{
+ OPJ_BOOL ret;
+ ret = opj_sparse_array_int32_read(sa,
+ win_l_x0, sa_line,
+ win_l_x1, sa_line + 1,
+ dest + cas + 2 * win_l_x0,
+ 2, 0, OPJ_TRUE);
+ assert(ret);
+ ret = opj_sparse_array_int32_read(sa,
+ sn + win_h_x0, sa_line,
+ sn + win_h_x1, sa_line + 1,
+ dest + 1 - cas + 2 * win_h_x0,
+ 2, 0, OPJ_TRUE);
+ assert(ret);
+ OPJ_UNUSED(ret);
+}
+
+
+static void opj_dwt_interleave_partial_v(OPJ_INT32 *dest,
+ OPJ_INT32 cas,
+ opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 sa_col,
+ OPJ_UINT32 nb_cols,
+ OPJ_UINT32 sn,
+ OPJ_UINT32 win_l_y0,
+ OPJ_UINT32 win_l_y1,
+ OPJ_UINT32 win_h_y0,
+ OPJ_UINT32 win_h_y1)
+{
+ OPJ_BOOL ret;
+ ret = opj_sparse_array_int32_read(sa,
+ sa_col, win_l_y0,
+ sa_col + nb_cols, win_l_y1,
+ dest + cas * 4 + 2 * 4 * win_l_y0,
+ 1, 2 * 4, OPJ_TRUE);
+ assert(ret);
+ ret = opj_sparse_array_int32_read(sa,
+ sa_col, sn + win_h_y0,
+ sa_col + nb_cols, sn + win_h_y1,
+ dest + (1 - cas) * 4 + 2 * 4 * win_h_y0,
+ 1, 2 * 4, OPJ_TRUE);
+ assert(ret);
+ OPJ_UNUSED(ret);
+}
+
+static void opj_dwt_decode_partial_1(OPJ_INT32 *a, OPJ_SIZE_T a_count,
+ OPJ_INT32 dn, OPJ_INT32 sn,
+ OPJ_INT32 cas,
+ OPJ_INT32 win_l_x0,
+ OPJ_INT32 win_l_x1,
+ OPJ_INT32 win_h_x0,
+ OPJ_INT32 win_h_x1)
+{
+ OPJ_INT32 i;
+
+ if (!cas) {
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
+
+ /* Naive version is :
+ for (i = win_l_x0; i < i_max; i++) {
+ OPJ_S(i) -= (OPJ_D_(i - 1) + OPJ_D_(i) + 2) >> 2;
+ }
+ for (i = win_h_x0; i < win_h_x1; i++) {
+ OPJ_D(i) += (OPJ_S_(i) + OPJ_S_(i + 1)) >> 1;
+ }
+ but the compiler doesn't manage to unroll it to avoid bound
+ checking in OPJ_S_ and OPJ_D_ macros
+ */
+
+ i = win_l_x0;
+ if (i < win_l_x1) {
+ OPJ_INT32 i_max;
+
+ /* Left-most case */
+ OPJ_S(i) -= (OPJ_D_(i - 1) + OPJ_D_(i) + 2) >> 2;
+ i ++;
+
+ i_max = win_l_x1;
+ if (i_max > dn) {
+ i_max = dn;
+ }
+ for (; i < i_max; i++) {
+ /* No bound checking */
+ OPJ_S(i) -= (OPJ_D(i - 1) + OPJ_D(i) + 2) >> 2;
+ }
+ for (; i < win_l_x1; i++) {
+ /* Right-most case */
+ OPJ_S(i) -= (OPJ_D_(i - 1) + OPJ_D_(i) + 2) >> 2;
+ }
+ }
+
+ i = win_h_x0;
+ if (i < win_h_x1) {
+ OPJ_INT32 i_max = win_h_x1;
+ if (i_max >= sn) {
+ i_max = sn - 1;
+ }
+ for (; i < i_max; i++) {
+ /* No bound checking */
+ OPJ_D(i) += (OPJ_S(i) + OPJ_S(i + 1)) >> 1;
+ }
+ for (; i < win_h_x1; i++) {
+ /* Right-most case */
+ OPJ_D(i) += (OPJ_S_(i) + OPJ_S_(i + 1)) >> 1;
+ }
+ }
+ }
+ } else {
+ if (!sn && dn == 1) { /* NEW : CASE ONE ELEMENT */
+ OPJ_S(0) /= 2;
+ } else {
+ for (i = win_l_x0; i < win_l_x1; i++) {
+ OPJ_D(i) -= (OPJ_SS_(i) + OPJ_SS_(i + 1) + 2) >> 2;
+ }
+ for (i = win_h_x0; i < win_h_x1; i++) {
+ OPJ_S(i) += (OPJ_DD_(i) + OPJ_DD_(i - 1)) >> 1;
+ }
+ }
+ }
+}
+
+#define OPJ_S_off(i,off) a[(OPJ_UINT32)(i)*2*4+off]
+#define OPJ_D_off(i,off) a[(1+(OPJ_UINT32)(i)*2)*4+off]
+#define OPJ_S__off(i,off) ((i)<0?OPJ_S_off(0,off):((i)>=sn?OPJ_S_off(sn-1,off):OPJ_S_off(i,off)))
+#define OPJ_D__off(i,off) ((i)<0?OPJ_D_off(0,off):((i)>=dn?OPJ_D_off(dn-1,off):OPJ_D_off(i,off)))
+#define OPJ_SS__off(i,off) ((i)<0?OPJ_S_off(0,off):((i)>=dn?OPJ_S_off(dn-1,off):OPJ_S_off(i,off)))
+#define OPJ_DD__off(i,off) ((i)<0?OPJ_D_off(0,off):((i)>=sn?OPJ_D_off(sn-1,off):OPJ_D_off(i,off)))
+
+static void opj_dwt_decode_partial_1_parallel(OPJ_INT32 *a,
+ OPJ_UINT32 nb_cols,
+ OPJ_INT32 dn, OPJ_INT32 sn,
+ OPJ_INT32 cas,
+ OPJ_INT32 win_l_x0,
+ OPJ_INT32 win_l_x1,
+ OPJ_INT32 win_h_x0,
+ OPJ_INT32 win_h_x1)
{
- OPJ_FLOAT32* OPJ_RESTRICT bi = (OPJ_FLOAT32*)(w->wavelet + w->cas);
- OPJ_INT32 count = w->sn;
- OPJ_INT32 i, k;
+ OPJ_INT32 i;
+ OPJ_UINT32 off;
+
+ (void)nb_cols;
+
+ if (!cas) {
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
+
+ /* Naive version is :
+ for (i = win_l_x0; i < i_max; i++) {
+ OPJ_S(i) -= (OPJ_D_(i - 1) + OPJ_D_(i) + 2) >> 2;
+ }
+ for (i = win_h_x0; i < win_h_x1; i++) {
+ OPJ_D(i) += (OPJ_S_(i) + OPJ_S_(i + 1)) >> 1;
+ }
+ but the compiler doesn't manage to unroll it to avoid bound
+ checking in OPJ_S_ and OPJ_D_ macros
+ */
+
+ i = win_l_x0;
+ if (i < win_l_x1) {
+ OPJ_INT32 i_max;
+
+ /* Left-most case */
+ for (off = 0; off < 4; off++) {
+ OPJ_S_off(i, off) -= (OPJ_D__off(i - 1, off) + OPJ_D__off(i, off) + 2) >> 2;
+ }
+ i ++;
+
+ i_max = win_l_x1;
+ if (i_max > dn) {
+ i_max = dn;
+ }
+
+#ifdef __SSE2__
+ if (i + 1 < i_max) {
+ const __m128i two = _mm_set1_epi32(2);
+ __m128i Dm1 = _mm_load_si128((__m128i * const)(a + 4 + (i - 1) * 8));
+ for (; i + 1 < i_max; i += 2) {
+ /* No bound checking */
+ __m128i S = _mm_load_si128((__m128i * const)(a + i * 8));
+ __m128i D = _mm_load_si128((__m128i * const)(a + 4 + i * 8));
+ __m128i S1 = _mm_load_si128((__m128i * const)(a + (i + 1) * 8));
+ __m128i D1 = _mm_load_si128((__m128i * const)(a + 4 + (i + 1) * 8));
+ S = _mm_sub_epi32(S,
+ _mm_srai_epi32(_mm_add_epi32(_mm_add_epi32(Dm1, D), two), 2));
+ S1 = _mm_sub_epi32(S1,
+ _mm_srai_epi32(_mm_add_epi32(_mm_add_epi32(D, D1), two), 2));
+ _mm_store_si128((__m128i*)(a + i * 8), S);
+ _mm_store_si128((__m128i*)(a + (i + 1) * 8), S1);
+ Dm1 = D1;
+ }
+ }
+#endif
+
+ for (; i < i_max; i++) {
+ /* No bound checking */
+ for (off = 0; off < 4; off++) {
+ OPJ_S_off(i, off) -= (OPJ_D_off(i - 1, off) + OPJ_D_off(i, off) + 2) >> 2;
+ }
+ }
+ for (; i < win_l_x1; i++) {
+ /* Right-most case */
+ for (off = 0; off < 4; off++) {
+ OPJ_S_off(i, off) -= (OPJ_D__off(i - 1, off) + OPJ_D__off(i, off) + 2) >> 2;
+ }
+ }
+ }
+
+ i = win_h_x0;
+ if (i < win_h_x1) {
+ OPJ_INT32 i_max = win_h_x1;
+ if (i_max >= sn) {
+ i_max = sn - 1;
+ }
+
+#ifdef __SSE2__
+ if (i + 1 < i_max) {
+ __m128i S = _mm_load_si128((__m128i * const)(a + i * 8));
+ for (; i + 1 < i_max; i += 2) {
+ /* No bound checking */
+ __m128i D = _mm_load_si128((__m128i * const)(a + 4 + i * 8));
+ __m128i S1 = _mm_load_si128((__m128i * const)(a + (i + 1) * 8));
+ __m128i D1 = _mm_load_si128((__m128i * const)(a + 4 + (i + 1) * 8));
+ __m128i S2 = _mm_load_si128((__m128i * const)(a + (i + 2) * 8));
+ D = _mm_add_epi32(D, _mm_srai_epi32(_mm_add_epi32(S, S1), 1));
+ D1 = _mm_add_epi32(D1, _mm_srai_epi32(_mm_add_epi32(S1, S2), 1));
+ _mm_store_si128((__m128i*)(a + 4 + i * 8), D);
+ _mm_store_si128((__m128i*)(a + 4 + (i + 1) * 8), D1);
+ S = S2;
+ }
+ }
+#endif
+
+ for (; i < i_max; i++) {
+ /* No bound checking */
+ for (off = 0; off < 4; off++) {
+ OPJ_D_off(i, off) += (OPJ_S_off(i, off) + OPJ_S_off(i + 1, off)) >> 1;
+ }
+ }
+ for (; i < win_h_x1; i++) {
+ /* Right-most case */
+ for (off = 0; off < 4; off++) {
+ OPJ_D_off(i, off) += (OPJ_S__off(i, off) + OPJ_S__off(i + 1, off)) >> 1;
+ }
+ }
+ }
+ }
+ } else {
+ if (!sn && dn == 1) { /* NEW : CASE ONE ELEMENT */
+ for (off = 0; off < 4; off++) {
+ OPJ_S_off(0, off) /= 2;
+ }
+ } else {
+ for (i = win_l_x0; i < win_l_x1; i++) {
+ for (off = 0; off < 4; off++) {
+ OPJ_D_off(i, off) -= (OPJ_SS__off(i, off) + OPJ_SS__off(i + 1, off) + 2) >> 2;
+ }
+ }
+ for (i = win_h_x0; i < win_h_x1; i++) {
+ for (off = 0; off < 4; off++) {
+ OPJ_S_off(i, off) += (OPJ_DD__off(i, off) + OPJ_DD__off(i - 1, off)) >> 1;
+ }
+ }
+ }
+ }
+}
+
+static void opj_dwt_get_band_coordinates(opj_tcd_tilecomp_t* tilec,
+ OPJ_UINT32 resno,
+ OPJ_UINT32 bandno,
+ OPJ_UINT32 tcx0,
+ OPJ_UINT32 tcy0,
+ OPJ_UINT32 tcx1,
+ OPJ_UINT32 tcy1,
+ OPJ_UINT32* tbx0,
+ OPJ_UINT32* tby0,
+ OPJ_UINT32* tbx1,
+ OPJ_UINT32* tby1)
+{
+ /* Compute number of decomposition for this band. See table F-1 */
+ OPJ_UINT32 nb = (resno == 0) ?
+ tilec->numresolutions - 1 :
+ tilec->numresolutions - resno;
+ /* Map above tile-based coordinates to sub-band-based coordinates per */
+ /* equation B-15 of the standard */
+ OPJ_UINT32 x0b = bandno & 1;
+ OPJ_UINT32 y0b = bandno >> 1;
+ if (tbx0) {
+ *tbx0 = (nb == 0) ? tcx0 :
+ (tcx0 <= (1U << (nb - 1)) * x0b) ? 0 :
+ opj_uint_ceildivpow2(tcx0 - (1U << (nb - 1)) * x0b, nb);
+ }
+ if (tby0) {
+ *tby0 = (nb == 0) ? tcy0 :
+ (tcy0 <= (1U << (nb - 1)) * y0b) ? 0 :
+ opj_uint_ceildivpow2(tcy0 - (1U << (nb - 1)) * y0b, nb);
+ }
+ if (tbx1) {
+ *tbx1 = (nb == 0) ? tcx1 :
+ (tcx1 <= (1U << (nb - 1)) * x0b) ? 0 :
+ opj_uint_ceildivpow2(tcx1 - (1U << (nb - 1)) * x0b, nb);
+ }
+ if (tby1) {
+ *tby1 = (nb == 0) ? tcy1 :
+ (tcy1 <= (1U << (nb - 1)) * y0b) ? 0 :
+ opj_uint_ceildivpow2(tcy1 - (1U << (nb - 1)) * y0b, nb);
+ }
+}
+
+static void opj_dwt_segment_grow(OPJ_UINT32 filter_width,
+ OPJ_UINT32 max_size,
+ OPJ_UINT32* start,
+ OPJ_UINT32* end)
+{
+ *start = opj_uint_subs(*start, filter_width);
+ *end = opj_uint_adds(*end, filter_width);
+ *end = opj_uint_min(*end, max_size);
+}
+
+
+static opj_sparse_array_int32_t* opj_dwt_init_sparse_array(
+ opj_tcd_tilecomp_t* tilec,
+ OPJ_UINT32 numres)
+{
+ opj_tcd_resolution_t* tr_max = &(tilec->resolutions[numres - 1]);
+ OPJ_UINT32 w = (OPJ_UINT32)(tr_max->x1 - tr_max->x0);
+ OPJ_UINT32 h = (OPJ_UINT32)(tr_max->y1 - tr_max->y0);
+ OPJ_UINT32 resno, bandno, precno, cblkno;
+ opj_sparse_array_int32_t* sa = opj_sparse_array_int32_create(
+ w, h, opj_uint_min(w, 64), opj_uint_min(h, 64));
+ if (sa == NULL) {
+ return NULL;
+ }
+
+ for (resno = 0; resno < numres; ++resno) {
+ opj_tcd_resolution_t* res = &tilec->resolutions[resno];
+
+ for (bandno = 0; bandno < res->numbands; ++bandno) {
+ opj_tcd_band_t* band = &res->bands[bandno];
+
+ for (precno = 0; precno < res->pw * res->ph; ++precno) {
+ opj_tcd_precinct_t* precinct = &band->precincts[precno];
+ for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
+ opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
+ if (cblk->decoded_data != NULL) {
+ OPJ_UINT32 x = (OPJ_UINT32)(cblk->x0 - band->x0);
+ OPJ_UINT32 y = (OPJ_UINT32)(cblk->y0 - band->y0);
+ OPJ_UINT32 cblk_w = (OPJ_UINT32)(cblk->x1 - cblk->x0);
+ OPJ_UINT32 cblk_h = (OPJ_UINT32)(cblk->y1 - cblk->y0);
+
+ if (band->bandno & 1) {
+ opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
+ x += (OPJ_UINT32)(pres->x1 - pres->x0);
+ }
+ if (band->bandno & 2) {
+ opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
+ y += (OPJ_UINT32)(pres->y1 - pres->y0);
+ }
+
+ if (!opj_sparse_array_int32_write(sa, x, y,
+ x + cblk_w, y + cblk_h,
+ cblk->decoded_data,
+ 1, cblk_w, OPJ_TRUE)) {
+ opj_sparse_array_int32_free(sa);
+ return NULL;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return sa;
+}
+
+
+static OPJ_BOOL opj_dwt_decode_partial_tile(
+ opj_tcd_tilecomp_t* tilec,
+ OPJ_UINT32 numres)
+{
+ opj_sparse_array_int32_t* sa;
+ opj_dwt_t h;
+ opj_dwt_t v;
+ OPJ_UINT32 resno;
+ /* This value matches the maximum left/right extension given in tables */
+ /* F.2 and F.3 of the standard. */
+ const OPJ_UINT32 filter_width = 2U;
+
+ opj_tcd_resolution_t* tr = tilec->resolutions;
+ opj_tcd_resolution_t* tr_max = &(tilec->resolutions[numres - 1]);
+
+ OPJ_UINT32 rw = (OPJ_UINT32)(tr->x1 -
+ tr->x0); /* width of the resolution level computed */
+ OPJ_UINT32 rh = (OPJ_UINT32)(tr->y1 -
+ tr->y0); /* height of the resolution level computed */
+
+ OPJ_SIZE_T h_mem_size;
+
+ /* Compute the intersection of the area of interest, expressed in tile coordinates */
+ /* with the tile coordinates */
+ OPJ_UINT32 win_tcx0 = tilec->win_x0;
+ OPJ_UINT32 win_tcy0 = tilec->win_y0;
+ OPJ_UINT32 win_tcx1 = tilec->win_x1;
+ OPJ_UINT32 win_tcy1 = tilec->win_y1;
+
+ if (tr_max->x0 == tr_max->x1 || tr_max->y0 == tr_max->y1) {
+ return OPJ_TRUE;
+ }
+
+ sa = opj_dwt_init_sparse_array(tilec, numres);
+ if (sa == NULL) {
+ return OPJ_FALSE;
+ }
+
+ if (numres == 1U) {
+ OPJ_BOOL ret = opj_sparse_array_int32_read(sa,
+ tr_max->win_x0 - (OPJ_UINT32)tr_max->x0,
+ tr_max->win_y0 - (OPJ_UINT32)tr_max->y0,
+ tr_max->win_x1 - (OPJ_UINT32)tr_max->x0,
+ tr_max->win_y1 - (OPJ_UINT32)tr_max->y0,
+ tilec->data_win,
+ 1, tr_max->win_x1 - tr_max->win_x0,
+ OPJ_TRUE);
+ assert(ret);
+ OPJ_UNUSED(ret);
+ opj_sparse_array_int32_free(sa);
+ return OPJ_TRUE;
+ }
+ h.mem_count = opj_dwt_max_resolution(tr, numres);
+ /* overflow check */
+ /* in vertical pass, we process 4 columns at a time */
+ if (h.mem_count > (SIZE_MAX / (4 * sizeof(OPJ_INT32)))) {
+ /* FIXME event manager error callback */
+ opj_sparse_array_int32_free(sa);
+ return OPJ_FALSE;
+ }
+
+ h_mem_size = h.mem_count * 4 * sizeof(OPJ_INT32);
+ h.mem = (OPJ_INT32*)opj_aligned_32_malloc(h_mem_size);
+ if (! h.mem) {
+ /* FIXME event manager error callback */
+ opj_sparse_array_int32_free(sa);
+ return OPJ_FALSE;
+ }
+
+ v.mem_count = h.mem_count;
+ v.mem = h.mem;
+
+ for (resno = 1; resno < numres; resno ++) {
+ OPJ_UINT32 i, j;
+ /* Window of interest subband-based coordinates */
+ OPJ_UINT32 win_ll_x0, win_ll_y0, win_ll_x1, win_ll_y1;
+ OPJ_UINT32 win_hl_x0, win_hl_x1;
+ OPJ_UINT32 win_lh_y0, win_lh_y1;
+ /* Window of interest tile-resolution-based coordinates */
+ OPJ_UINT32 win_tr_x0, win_tr_x1, win_tr_y0, win_tr_y1;
+ /* Tile-resolution subband-based coordinates */
+ OPJ_UINT32 tr_ll_x0, tr_ll_y0, tr_hl_x0, tr_lh_y0;
+
+ ++tr;
+
+ h.sn = (OPJ_INT32)rw;
+ v.sn = (OPJ_INT32)rh;
+
+ rw = (OPJ_UINT32)(tr->x1 - tr->x0);
+ rh = (OPJ_UINT32)(tr->y1 - tr->y0);
+
+ h.dn = (OPJ_INT32)(rw - (OPJ_UINT32)h.sn);
+ h.cas = tr->x0 % 2;
+
+ v.dn = (OPJ_INT32)(rh - (OPJ_UINT32)v.sn);
+ v.cas = tr->y0 % 2;
+
+ /* Get the subband coordinates for the window of interest */
+ /* LL band */
+ opj_dwt_get_band_coordinates(tilec, resno, 0,
+ win_tcx0, win_tcy0, win_tcx1, win_tcy1,
+ &win_ll_x0, &win_ll_y0,
+ &win_ll_x1, &win_ll_y1);
+
+ /* HL band */
+ opj_dwt_get_band_coordinates(tilec, resno, 1,
+ win_tcx0, win_tcy0, win_tcx1, win_tcy1,
+ &win_hl_x0, NULL, &win_hl_x1, NULL);
+
+ /* LH band */
+ opj_dwt_get_band_coordinates(tilec, resno, 2,
+ win_tcx0, win_tcy0, win_tcx1, win_tcy1,
+ NULL, &win_lh_y0, NULL, &win_lh_y1);
+
+ /* Beware: band index for non-LL0 resolution are 0=HL, 1=LH and 2=HH */
+ tr_ll_x0 = (OPJ_UINT32)tr->bands[1].x0;
+ tr_ll_y0 = (OPJ_UINT32)tr->bands[0].y0;
+ tr_hl_x0 = (OPJ_UINT32)tr->bands[0].x0;
+ tr_lh_y0 = (OPJ_UINT32)tr->bands[1].y0;
+
+ /* Substract the origin of the bands for this tile, to the subwindow */
+ /* of interest band coordinates, so as to get them relative to the */
+ /* tile */
+ win_ll_x0 = opj_uint_subs(win_ll_x0, tr_ll_x0);
+ win_ll_y0 = opj_uint_subs(win_ll_y0, tr_ll_y0);
+ win_ll_x1 = opj_uint_subs(win_ll_x1, tr_ll_x0);
+ win_ll_y1 = opj_uint_subs(win_ll_y1, tr_ll_y0);
+ win_hl_x0 = opj_uint_subs(win_hl_x0, tr_hl_x0);
+ win_hl_x1 = opj_uint_subs(win_hl_x1, tr_hl_x0);
+ win_lh_y0 = opj_uint_subs(win_lh_y0, tr_lh_y0);
+ win_lh_y1 = opj_uint_subs(win_lh_y1, tr_lh_y0);
+
+ opj_dwt_segment_grow(filter_width, (OPJ_UINT32)h.sn, &win_ll_x0, &win_ll_x1);
+ opj_dwt_segment_grow(filter_width, (OPJ_UINT32)h.dn, &win_hl_x0, &win_hl_x1);
+
+ opj_dwt_segment_grow(filter_width, (OPJ_UINT32)v.sn, &win_ll_y0, &win_ll_y1);
+ opj_dwt_segment_grow(filter_width, (OPJ_UINT32)v.dn, &win_lh_y0, &win_lh_y1);
+
+ /* Compute the tile-resolution-based coordinates for the window of interest */
+ if (h.cas == 0) {
+ win_tr_x0 = opj_uint_min(2 * win_ll_x0, 2 * win_hl_x0 + 1);
+ win_tr_x1 = opj_uint_min(opj_uint_max(2 * win_ll_x1, 2 * win_hl_x1 + 1), rw);
+ } else {
+ win_tr_x0 = opj_uint_min(2 * win_hl_x0, 2 * win_ll_x0 + 1);
+ win_tr_x1 = opj_uint_min(opj_uint_max(2 * win_hl_x1, 2 * win_ll_x1 + 1), rw);
+ }
+
+ if (v.cas == 0) {
+ win_tr_y0 = opj_uint_min(2 * win_ll_y0, 2 * win_lh_y0 + 1);
+ win_tr_y1 = opj_uint_min(opj_uint_max(2 * win_ll_y1, 2 * win_lh_y1 + 1), rh);
+ } else {
+ win_tr_y0 = opj_uint_min(2 * win_lh_y0, 2 * win_ll_y0 + 1);
+ win_tr_y1 = opj_uint_min(opj_uint_max(2 * win_lh_y1, 2 * win_ll_y1 + 1), rh);
+ }
+
+ for (j = 0; j < rh; ++j) {
+ if ((j >= win_ll_y0 && j < win_ll_y1) ||
+ (j >= win_lh_y0 + (OPJ_UINT32)v.sn && j < win_lh_y1 + (OPJ_UINT32)v.sn)) {
+
+ /* Avoids dwt.c:1584:44 (in opj_dwt_decode_partial_1): runtime error: */
+ /* signed integer overflow: -1094795586 + -1094795586 cannot be represented in type 'int' */
+ /* on opj_decompress -i ../../openjpeg/MAPA.jp2 -o out.tif -d 0,0,256,256 */
+ /* This is less extreme than memsetting the whole buffer to 0 */
+ /* although we could potentially do better with better handling of edge conditions */
+ if (win_tr_x1 >= 1 && win_tr_x1 < rw) {
+ h.mem[win_tr_x1 - 1] = 0;
+ }
+ if (win_tr_x1 < rw) {
+ h.mem[win_tr_x1] = 0;
+ }
+
+ opj_dwt_interleave_partial_h(h.mem,
+ h.cas,
+ sa,
+ j,
+ (OPJ_UINT32)h.sn,
+ win_ll_x0,
+ win_ll_x1,
+ win_hl_x0,
+ win_hl_x1);
+ opj_dwt_decode_partial_1(h.mem, h.mem_count, h.dn, h.sn, h.cas,
+ (OPJ_INT32)win_ll_x0,
+ (OPJ_INT32)win_ll_x1,
+ (OPJ_INT32)win_hl_x0,
+ (OPJ_INT32)win_hl_x1);
+ if (!opj_sparse_array_int32_write(sa,
+ win_tr_x0, j,
+ win_tr_x1, j + 1,
+ h.mem + win_tr_x0,
+ 1, 0, OPJ_TRUE)) {
+ /* FIXME event manager error callback */
+ opj_sparse_array_int32_free(sa);
+ opj_aligned_free(h.mem);
+ return OPJ_FALSE;
+ }
+ }
+ }
+
+ for (i = win_tr_x0; i < win_tr_x1;) {
+ OPJ_UINT32 nb_cols = opj_uint_min(4U, win_tr_x1 - i);
+ opj_dwt_interleave_partial_v(v.mem,
+ v.cas,
+ sa,
+ i,
+ nb_cols,
+ (OPJ_UINT32)v.sn,
+ win_ll_y0,
+ win_ll_y1,
+ win_lh_y0,
+ win_lh_y1);
+ opj_dwt_decode_partial_1_parallel(v.mem, nb_cols, v.dn, v.sn, v.cas,
+ (OPJ_INT32)win_ll_y0,
+ (OPJ_INT32)win_ll_y1,
+ (OPJ_INT32)win_lh_y0,
+ (OPJ_INT32)win_lh_y1);
+ if (!opj_sparse_array_int32_write(sa,
+ i, win_tr_y0,
+ i + nb_cols, win_tr_y1,
+ v.mem + 4 * win_tr_y0,
+ 1, 4, OPJ_TRUE)) {
+ /* FIXME event manager error callback */
+ opj_sparse_array_int32_free(sa);
+ opj_aligned_free(h.mem);
+ return OPJ_FALSE;
+ }
+
+ i += nb_cols;
+ }
+ }
+ opj_aligned_free(h.mem);
+
+ {
+ OPJ_BOOL ret = opj_sparse_array_int32_read(sa,
+ tr_max->win_x0 - (OPJ_UINT32)tr_max->x0,
+ tr_max->win_y0 - (OPJ_UINT32)tr_max->y0,
+ tr_max->win_x1 - (OPJ_UINT32)tr_max->x0,
+ tr_max->win_y1 - (OPJ_UINT32)tr_max->y0,
+ tilec->data_win,
+ 1, tr_max->win_x1 - tr_max->win_x0,
+ OPJ_TRUE);
+ assert(ret);
+ OPJ_UNUSED(ret);
+ }
+ opj_sparse_array_int32_free(sa);
+ return OPJ_TRUE;
+}
+
+static void opj_v4dwt_interleave_h(opj_v4dwt_t* OPJ_RESTRICT dwt,
+ OPJ_FLOAT32* OPJ_RESTRICT a,
+ OPJ_UINT32 width,
+ OPJ_UINT32 remaining_height)
+{
+ OPJ_FLOAT32* OPJ_RESTRICT bi = (OPJ_FLOAT32*)(dwt->wavelet + dwt->cas);
+ OPJ_UINT32 i, k;
+ OPJ_UINT32 x0 = dwt->win_l_x0;
+ OPJ_UINT32 x1 = dwt->win_l_x1;
for (k = 0; k < 2; ++k) {
- if (count + 3 * x < size && ((size_t) a & 0x0f) == 0 &&
- ((size_t) bi & 0x0f) == 0 && (x & 0x0f) == 0) {
+ if (remaining_height >= 4 && ((OPJ_SIZE_T) a & 0x0f) == 0 &&
+ ((OPJ_SIZE_T) bi & 0x0f) == 0 && (width & 0x0f) == 0) {
/* Fast code path */
- for (i = 0; i < count; ++i) {
- OPJ_INT32 j = i;
+ for (i = x0; i < x1; ++i) {
+ OPJ_UINT32 j = i;
bi[i * 8 ] = a[j];
- j += x;
+ j += width;
bi[i * 8 + 1] = a[j];
- j += x;
+ j += width;
bi[i * 8 + 2] = a[j];
- j += x;
+ j += width;
bi[i * 8 + 3] = a[j];
}
} else {
/* Slow code path */
- for (i = 0; i < count; ++i) {
- OPJ_INT32 j = i;
+ for (i = x0; i < x1; ++i) {
+ OPJ_UINT32 j = i;
bi[i * 8 ] = a[j];
- j += x;
- if (j >= size) {
+ j += width;
+ if (remaining_height == 1) {
continue;
}
bi[i * 8 + 1] = a[j];
- j += x;
- if (j >= size) {
+ j += width;
+ if (remaining_height == 2) {
continue;
}
bi[i * 8 + 2] = a[j];
- j += x;
- if (j >= size) {
+ j += width;
+ if (remaining_height == 3) {
continue;
}
bi[i * 8 + 3] = a[j]; /* This one*/
}
}
- bi = (OPJ_FLOAT32*)(w->wavelet + 1 - w->cas);
- a += w->sn;
- size -= w->sn;
- count = w->dn;
+ bi = (OPJ_FLOAT32*)(dwt->wavelet + 1 - dwt->cas);
+ a += dwt->sn;
+ x0 = dwt->win_h_x0;
+ x1 = dwt->win_h_x1;
}
}
-static void opj_v4dwt_interleave_v(opj_v4dwt_t* OPJ_RESTRICT v,
- OPJ_FLOAT32* OPJ_RESTRICT a, OPJ_INT32 x, OPJ_INT32 nb_elts_read)
+static void opj_v4dwt_interleave_partial_h(opj_v4dwt_t* dwt,
+ opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 sa_line,
+ OPJ_UINT32 remaining_height)
{
- opj_v4_t* OPJ_RESTRICT bi = v->wavelet + v->cas;
- OPJ_INT32 i;
+ OPJ_UINT32 i;
+ for (i = 0; i < remaining_height; i++) {
+ OPJ_BOOL ret;
+ ret = opj_sparse_array_int32_read(sa,
+ dwt->win_l_x0, sa_line + i,
+ dwt->win_l_x1, sa_line + i + 1,
+ /* Nasty cast from float* to int32* */
+ (OPJ_INT32*)(dwt->wavelet + dwt->cas + 2 * dwt->win_l_x0) + i,
+ 8, 0, OPJ_TRUE);
+ assert(ret);
+ ret = opj_sparse_array_int32_read(sa,
+ (OPJ_UINT32)dwt->sn + dwt->win_h_x0, sa_line + i,
+ (OPJ_UINT32)dwt->sn + dwt->win_h_x1, sa_line + i + 1,
+ /* Nasty cast from float* to int32* */
+ (OPJ_INT32*)(dwt->wavelet + 1 - dwt->cas + 2 * dwt->win_h_x0) + i,
+ 8, 0, OPJ_TRUE);
+ assert(ret);
+ OPJ_UNUSED(ret);
+ }
+}
+
+static void opj_v4dwt_interleave_v(opj_v4dwt_t* OPJ_RESTRICT dwt,
+ OPJ_FLOAT32* OPJ_RESTRICT a,
+ OPJ_UINT32 width,
+ OPJ_UINT32 nb_elts_read)
+{
+ opj_v4_t* OPJ_RESTRICT bi = dwt->wavelet + dwt->cas;
+ OPJ_UINT32 i;
- for (i = 0; i < v->sn; ++i) {
- memcpy(&bi[i * 2], &a[i * x], (size_t)nb_elts_read * sizeof(OPJ_FLOAT32));
+ for (i = dwt->win_l_x0; i < dwt->win_l_x1; ++i) {
+ memcpy(&bi[i * 2], &a[i * (OPJ_SIZE_T)width],
+ (OPJ_SIZE_T)nb_elts_read * sizeof(OPJ_FLOAT32));
}
- a += v->sn * x;
- bi = v->wavelet + 1 - v->cas;
+ a += (OPJ_UINT32)dwt->sn * (OPJ_SIZE_T)width;
+ bi = dwt->wavelet + 1 - dwt->cas;
- for (i = 0; i < v->dn; ++i) {
- memcpy(&bi[i * 2], &a[i * x], (size_t)nb_elts_read * sizeof(OPJ_FLOAT32));
+ for (i = dwt->win_h_x0; i < dwt->win_h_x1; ++i) {
+ memcpy(&bi[i * 2], &a[i * (OPJ_SIZE_T)width],
+ (OPJ_SIZE_T)nb_elts_read * sizeof(OPJ_FLOAT32));
}
}
+static void opj_v4dwt_interleave_partial_v(opj_v4dwt_t* OPJ_RESTRICT dwt,
+ opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 sa_col,
+ OPJ_UINT32 nb_elts_read)
+{
+ OPJ_BOOL ret;
+ ret = opj_sparse_array_int32_read(sa,
+ sa_col, dwt->win_l_x0,
+ sa_col + nb_elts_read, dwt->win_l_x1,
+ (OPJ_INT32*)(dwt->wavelet + dwt->cas + 2 * dwt->win_l_x0),
+ 1, 8, OPJ_TRUE);
+ assert(ret);
+ ret = opj_sparse_array_int32_read(sa,
+ sa_col, (OPJ_UINT32)dwt->sn + dwt->win_h_x0,
+ sa_col + nb_elts_read, (OPJ_UINT32)dwt->sn + dwt->win_h_x1,
+ (OPJ_INT32*)(dwt->wavelet + 1 - dwt->cas + 2 * dwt->win_h_x0),
+ 1, 8, OPJ_TRUE);
+ assert(ret);
+ OPJ_UNUSED(ret);
+}
+
#ifdef __SSE__
-static void opj_v4dwt_decode_step1_sse(opj_v4_t* w, OPJ_INT32 count,
+static void opj_v4dwt_decode_step1_sse(opj_v4_t* w,
+ OPJ_UINT32 start,
+ OPJ_UINT32 end,
const __m128 c)
{
__m128* OPJ_RESTRICT vw = (__m128*) w;
- OPJ_INT32 i;
+ OPJ_UINT32 i;
/* 4x unrolled loop */
- for (i = 0; i < count >> 2; ++i) {
- *vw = _mm_mul_ps(*vw, c);
- vw += 2;
- *vw = _mm_mul_ps(*vw, c);
- vw += 2;
- *vw = _mm_mul_ps(*vw, c);
- vw += 2;
- *vw = _mm_mul_ps(*vw, c);
- vw += 2;
- }
- count &= 3;
- for (i = 0; i < count; ++i) {
- *vw = _mm_mul_ps(*vw, c);
- vw += 2;
+ vw += 2 * start;
+ for (i = start; i + 3 < end; i += 4, vw += 8) {
+ __m128 xmm0 = _mm_mul_ps(vw[0], c);
+ __m128 xmm2 = _mm_mul_ps(vw[2], c);
+ __m128 xmm4 = _mm_mul_ps(vw[4], c);
+ __m128 xmm6 = _mm_mul_ps(vw[6], c);
+ vw[0] = xmm0;
+ vw[2] = xmm2;
+ vw[4] = xmm4;
+ vw[6] = xmm6;
+ }
+ for (; i < end; ++i, vw += 2) {
+ vw[0] = _mm_mul_ps(vw[0], c);
}
}
-void opj_v4dwt_decode_step2_sse(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k,
- OPJ_INT32 m, __m128 c)
+static void opj_v4dwt_decode_step2_sse(opj_v4_t* l, opj_v4_t* w,
+ OPJ_UINT32 start,
+ OPJ_UINT32 end,
+ OPJ_UINT32 m,
+ __m128 c)
{
__m128* OPJ_RESTRICT vl = (__m128*) l;
__m128* OPJ_RESTRICT vw = (__m128*) w;
- OPJ_INT32 i;
+ OPJ_UINT32 i;
+ OPJ_UINT32 imax = opj_uint_min(end, m);
__m128 tmp1, tmp2, tmp3;
- tmp1 = vl[0];
- for (i = 0; i < m; ++i) {
+ if (start == 0) {
+ tmp1 = vl[0];
+ } else {
+ vw += start * 2;
+ tmp1 = vw[-3];
+ }
+
+ i = start;
+
+ /* 4x loop unrolling */
+ for (; i + 3 < imax; i += 4) {
+ __m128 tmp4, tmp5, tmp6, tmp7, tmp8, tmp9;
+ tmp2 = vw[-1];
+ tmp3 = vw[ 0];
+ tmp4 = vw[ 1];
+ tmp5 = vw[ 2];
+ tmp6 = vw[ 3];
+ tmp7 = vw[ 4];
+ tmp8 = vw[ 5];
+ tmp9 = vw[ 6];
+ vw[-1] = _mm_add_ps(tmp2, _mm_mul_ps(_mm_add_ps(tmp1, tmp3), c));
+ vw[ 1] = _mm_add_ps(tmp4, _mm_mul_ps(_mm_add_ps(tmp3, tmp5), c));
+ vw[ 3] = _mm_add_ps(tmp6, _mm_mul_ps(_mm_add_ps(tmp5, tmp7), c));
+ vw[ 5] = _mm_add_ps(tmp8, _mm_mul_ps(_mm_add_ps(tmp7, tmp9), c));
+ tmp1 = tmp9;
+ vw += 8;
+ }
+
+ for (; i < imax; ++i) {
tmp2 = vw[-1];
tmp3 = vw[ 0];
vw[-1] = _mm_add_ps(tmp2, _mm_mul_ps(_mm_add_ps(tmp1, tmp3), c));
tmp1 = tmp3;
vw += 2;
}
- vl = vw - 2;
- if (m >= k) {
- return;
- }
- c = _mm_add_ps(c, c);
- c = _mm_mul_ps(c, vl[0]);
- for (; m < k; ++m) {
- __m128 tmp = vw[-1];
- vw[-1] = _mm_add_ps(tmp, c);
- vw += 2;
+ if (m < end) {
+ assert(m + 1 == end);
+ c = _mm_add_ps(c, c);
+ c = _mm_mul_ps(c, vw[-2]);
+ vw[-1] = _mm_add_ps(vw[-1], c);
}
}
#else
-static void opj_v4dwt_decode_step1(opj_v4_t* w, OPJ_INT32 count,
+static void opj_v4dwt_decode_step1(opj_v4_t* w,
+ OPJ_UINT32 start,
+ OPJ_UINT32 end,
const OPJ_FLOAT32 c)
{
OPJ_FLOAT32* OPJ_RESTRICT fw = (OPJ_FLOAT32*) w;
- OPJ_INT32 i;
- for (i = 0; i < count; ++i) {
+ OPJ_UINT32 i;
+ for (i = start; i < end; ++i) {
OPJ_FLOAT32 tmp1 = fw[i * 8 ];
OPJ_FLOAT32 tmp2 = fw[i * 8 + 1];
OPJ_FLOAT32 tmp3 = fw[i * 8 + 2];
@@ -1641,13 +2403,21 @@ static void opj_v4dwt_decode_step1(opj_v4_t* w, OPJ_INT32 count,
}
}
-static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k,
- OPJ_INT32 m, OPJ_FLOAT32 c)
+static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w,
+ OPJ_UINT32 start,
+ OPJ_UINT32 end,
+ OPJ_UINT32 m,
+ OPJ_FLOAT32 c)
{
OPJ_FLOAT32* fl = (OPJ_FLOAT32*) l;
OPJ_FLOAT32* fw = (OPJ_FLOAT32*) w;
- OPJ_INT32 i;
- for (i = 0; i < m; ++i) {
+ OPJ_UINT32 i;
+ OPJ_UINT32 imax = opj_uint_min(end, m);
+ if (start > 0) {
+ fw += 8 * start;
+ fl = fw - 8;
+ }
+ for (i = start; i < imax; ++i) {
OPJ_FLOAT32 tmp1_1 = fl[0];
OPJ_FLOAT32 tmp1_2 = fl[1];
OPJ_FLOAT32 tmp1_3 = fl[2];
@@ -1667,27 +2437,13 @@ static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k,
fl = fw;
fw += 8;
}
- if (m < k) {
- OPJ_FLOAT32 c1;
- OPJ_FLOAT32 c2;
- OPJ_FLOAT32 c3;
- OPJ_FLOAT32 c4;
+ if (m < end) {
+ assert(m + 1 == end);
c += c;
- c1 = fl[0] * c;
- c2 = fl[1] * c;
- c3 = fl[2] * c;
- c4 = fl[3] * c;
- for (; m < k; ++m) {
- OPJ_FLOAT32 tmp1 = fw[-4];
- OPJ_FLOAT32 tmp2 = fw[-3];
- OPJ_FLOAT32 tmp3 = fw[-2];
- OPJ_FLOAT32 tmp4 = fw[-1];
- fw[-4] = tmp1 + c1;
- fw[-3] = tmp2 + c2;
- fw[-2] = tmp3 + c3;
- fw[-1] = tmp4 + c4;
- fw += 8;
- }
+ fw[-4] = fw[-4] + fl[0] * c;
+ fw[-3] = fw[-3] + fl[1] * c;
+ fw[-2] = fw[-2] + fl[2] * c;
+ fw[-1] = fw[-1] + fl[3] * c;
}
}
@@ -1713,27 +2469,47 @@ static void opj_v4dwt_decode(opj_v4dwt_t* OPJ_RESTRICT dwt)
b = 0;
}
#ifdef __SSE__
- opj_v4dwt_decode_step1_sse(dwt->wavelet + a, dwt->sn, _mm_set1_ps(opj_K));
- opj_v4dwt_decode_step1_sse(dwt->wavelet + b, dwt->dn, _mm_set1_ps(opj_c13318));
- opj_v4dwt_decode_step2_sse(dwt->wavelet + b, dwt->wavelet + a + 1, dwt->sn,
- opj_int_min(dwt->sn, dwt->dn - a), _mm_set1_ps(opj_dwt_delta));
- opj_v4dwt_decode_step2_sse(dwt->wavelet + a, dwt->wavelet + b + 1, dwt->dn,
- opj_int_min(dwt->dn, dwt->sn - b), _mm_set1_ps(opj_dwt_gamma));
- opj_v4dwt_decode_step2_sse(dwt->wavelet + b, dwt->wavelet + a + 1, dwt->sn,
- opj_int_min(dwt->sn, dwt->dn - a), _mm_set1_ps(opj_dwt_beta));
- opj_v4dwt_decode_step2_sse(dwt->wavelet + a, dwt->wavelet + b + 1, dwt->dn,
- opj_int_min(dwt->dn, dwt->sn - b), _mm_set1_ps(opj_dwt_alpha));
+ opj_v4dwt_decode_step1_sse(dwt->wavelet + a, dwt->win_l_x0, dwt->win_l_x1,
+ _mm_set1_ps(opj_K));
+ opj_v4dwt_decode_step1_sse(dwt->wavelet + b, dwt->win_h_x0, dwt->win_h_x1,
+ _mm_set1_ps(opj_c13318));
+ opj_v4dwt_decode_step2_sse(dwt->wavelet + b, dwt->wavelet + a + 1,
+ dwt->win_l_x0, dwt->win_l_x1,
+ (OPJ_UINT32)opj_int_min(dwt->sn, dwt->dn - a),
+ _mm_set1_ps(opj_dwt_delta));
+ opj_v4dwt_decode_step2_sse(dwt->wavelet + a, dwt->wavelet + b + 1,
+ dwt->win_h_x0, dwt->win_h_x1,
+ (OPJ_UINT32)opj_int_min(dwt->dn, dwt->sn - b),
+ _mm_set1_ps(opj_dwt_gamma));
+ opj_v4dwt_decode_step2_sse(dwt->wavelet + b, dwt->wavelet + a + 1,
+ dwt->win_l_x0, dwt->win_l_x1,
+ (OPJ_UINT32)opj_int_min(dwt->sn, dwt->dn - a),
+ _mm_set1_ps(opj_dwt_beta));
+ opj_v4dwt_decode_step2_sse(dwt->wavelet + a, dwt->wavelet + b + 1,
+ dwt->win_h_x0, dwt->win_h_x1,
+ (OPJ_UINT32)opj_int_min(dwt->dn, dwt->sn - b),
+ _mm_set1_ps(opj_dwt_alpha));
#else
- opj_v4dwt_decode_step1(dwt->wavelet + a, dwt->sn, opj_K);
- opj_v4dwt_decode_step1(dwt->wavelet + b, dwt->dn, opj_c13318);
- opj_v4dwt_decode_step2(dwt->wavelet + b, dwt->wavelet + a + 1, dwt->sn,
- opj_int_min(dwt->sn, dwt->dn - a), opj_dwt_delta);
- opj_v4dwt_decode_step2(dwt->wavelet + a, dwt->wavelet + b + 1, dwt->dn,
- opj_int_min(dwt->dn, dwt->sn - b), opj_dwt_gamma);
- opj_v4dwt_decode_step2(dwt->wavelet + b, dwt->wavelet + a + 1, dwt->sn,
- opj_int_min(dwt->sn, dwt->dn - a), opj_dwt_beta);
- opj_v4dwt_decode_step2(dwt->wavelet + a, dwt->wavelet + b + 1, dwt->dn,
- opj_int_min(dwt->dn, dwt->sn - b), opj_dwt_alpha);
+ opj_v4dwt_decode_step1(dwt->wavelet + a, dwt->win_l_x0, dwt->win_l_x1,
+ opj_K);
+ opj_v4dwt_decode_step1(dwt->wavelet + b, dwt->win_h_x0, dwt->win_h_x1,
+ opj_c13318);
+ opj_v4dwt_decode_step2(dwt->wavelet + b, dwt->wavelet + a + 1,
+ dwt->win_l_x0, dwt->win_l_x1,
+ (OPJ_UINT32)opj_int_min(dwt->sn, dwt->dn - a),
+ opj_dwt_delta);
+ opj_v4dwt_decode_step2(dwt->wavelet + a, dwt->wavelet + b + 1,
+ dwt->win_h_x0, dwt->win_h_x1,
+ (OPJ_UINT32)opj_int_min(dwt->dn, dwt->sn - b),
+ opj_dwt_gamma);
+ opj_v4dwt_decode_step2(dwt->wavelet + b, dwt->wavelet + a + 1,
+ dwt->win_l_x0, dwt->win_l_x1,
+ (OPJ_UINT32)opj_int_min(dwt->sn, dwt->dn - a),
+ opj_dwt_beta);
+ opj_v4dwt_decode_step2(dwt->wavelet + a, dwt->wavelet + b + 1,
+ dwt->win_h_x0, dwt->win_h_x1,
+ (OPJ_UINT32)opj_int_min(dwt->dn, dwt->sn - b),
+ opj_dwt_alpha);
#endif
}
@@ -1741,8 +2517,9 @@ static void opj_v4dwt_decode(opj_v4dwt_t* OPJ_RESTRICT dwt)
/* <summary> */
/* Inverse 9-7 wavelet transform in 2-D. */
/* </summary> */
-OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
- OPJ_UINT32 numres)
+static
+OPJ_BOOL opj_dwt_decode_tile_97(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
+ OPJ_UINT32 numres)
{
opj_v4dwt_t h;
opj_v4dwt_t v;
@@ -1754,9 +2531,11 @@ OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
OPJ_UINT32 rh = (OPJ_UINT32)(res->y1 -
res->y0); /* height of the resolution level computed */
- OPJ_UINT32 w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
+ OPJ_UINT32 w = (OPJ_UINT32)(tilec->resolutions[tilec->minimum_num_resolutions -
+ 1].x1 -
+ tilec->resolutions[tilec->minimum_num_resolutions - 1].x0);
- size_t l_data_size;
+ OPJ_SIZE_T l_data_size;
l_data_size = opj_dwt_max_resolution(res, numres);
/* overflow check */
@@ -1779,9 +2558,7 @@ OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
while (--numres) {
OPJ_FLOAT32 * OPJ_RESTRICT aj = (OPJ_FLOAT32*) tilec->data;
- OPJ_UINT32 bufsize = (OPJ_UINT32)((tilec->x1 - tilec->x0) *
- (tilec->y1 - tilec->y0));
- OPJ_INT32 j;
+ OPJ_UINT32 j;
h.sn = (OPJ_INT32)rw;
v.sn = (OPJ_INT32)rh;
@@ -1796,53 +2573,59 @@ OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
h.dn = (OPJ_INT32)(rw - (OPJ_UINT32)h.sn);
h.cas = res->x0 % 2;
- for (j = (OPJ_INT32)rh; j > 3; j -= 4) {
- OPJ_INT32 k;
- opj_v4dwt_interleave_h(&h, aj, (OPJ_INT32)w, (OPJ_INT32)bufsize);
+ h.win_l_x0 = 0;
+ h.win_l_x1 = (OPJ_UINT32)h.sn;
+ h.win_h_x0 = 0;
+ h.win_h_x1 = (OPJ_UINT32)h.dn;
+ for (j = 0; j + 3 < rh; j += 4) {
+ OPJ_UINT32 k;
+ opj_v4dwt_interleave_h(&h, aj, w, rh - j);
opj_v4dwt_decode(&h);
- for (k = (OPJ_INT32)rw; --k >= 0;) {
- aj[k ] = h.wavelet[k].f[0];
- aj[k + (OPJ_INT32)w ] = h.wavelet[k].f[1];
- aj[k + (OPJ_INT32)w * 2] = h.wavelet[k].f[2];
- aj[k + (OPJ_INT32)w * 3] = h.wavelet[k].f[3];
+ for (k = 0; k < rw; k++) {
+ aj[k ] = h.wavelet[k].f[0];
+ aj[k + (OPJ_SIZE_T)w ] = h.wavelet[k].f[1];
+ aj[k + (OPJ_SIZE_T)w * 2] = h.wavelet[k].f[2];
+ aj[k + (OPJ_SIZE_T)w * 3] = h.wavelet[k].f[3];
}
aj += w * 4;
- bufsize -= w * 4;
}
- if (rh & 0x03) {
- OPJ_INT32 k;
- j = rh & 0x03;
- opj_v4dwt_interleave_h(&h, aj, (OPJ_INT32)w, (OPJ_INT32)bufsize);
+ if (j < rh) {
+ OPJ_UINT32 k;
+ opj_v4dwt_interleave_h(&h, aj, w, rh - j);
opj_v4dwt_decode(&h);
- for (k = (OPJ_INT32)rw; --k >= 0;) {
- switch (j) {
+ for (k = 0; k < rw; k++) {
+ switch (rh - j) {
case 3:
- aj[k + (OPJ_INT32)w * 2] = h.wavelet[k].f[2];
+ aj[k + (OPJ_SIZE_T)w * 2] = h.wavelet[k].f[2];
/* FALLTHRU */
case 2:
- aj[k + (OPJ_INT32)w ] = h.wavelet[k].f[1];
+ aj[k + (OPJ_SIZE_T)w ] = h.wavelet[k].f[1];
/* FALLTHRU */
case 1:
- aj[k ] = h.wavelet[k].f[0];
+ aj[k] = h.wavelet[k].f[0];
}
}
}
v.dn = (OPJ_INT32)(rh - (OPJ_UINT32)v.sn);
v.cas = res->y0 % 2;
+ v.win_l_x0 = 0;
+ v.win_l_x1 = (OPJ_UINT32)v.sn;
+ v.win_h_x0 = 0;
+ v.win_h_x1 = (OPJ_UINT32)v.dn;
aj = (OPJ_FLOAT32*) tilec->data;
- for (j = (OPJ_INT32)rw; j > 3; j -= 4) {
+ for (j = rw; j > 3; j -= 4) {
OPJ_UINT32 k;
- opj_v4dwt_interleave_v(&v, aj, (OPJ_INT32)w, 4);
+ opj_v4dwt_interleave_v(&v, aj, w, 4);
opj_v4dwt_decode(&v);
for (k = 0; k < rh; ++k) {
- memcpy(&aj[k * w], &v.wavelet[k], 4 * sizeof(OPJ_FLOAT32));
+ memcpy(&aj[k * (OPJ_SIZE_T)w], &v.wavelet[k], 4 * sizeof(OPJ_FLOAT32));
}
aj += 4;
}
@@ -1852,15 +2635,266 @@ OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
j = rw & 0x03;
- opj_v4dwt_interleave_v(&v, aj, (OPJ_INT32)w, j);
+ opj_v4dwt_interleave_v(&v, aj, w, j);
opj_v4dwt_decode(&v);
for (k = 0; k < rh; ++k) {
- memcpy(&aj[k * w], &v.wavelet[k], (size_t)j * sizeof(OPJ_FLOAT32));
+ memcpy(&aj[k * (OPJ_SIZE_T)w], &v.wavelet[k],
+ (OPJ_SIZE_T)j * sizeof(OPJ_FLOAT32));
+ }
+ }
+ }
+
+ opj_aligned_free(h.wavelet);
+ return OPJ_TRUE;
+}
+
+static
+OPJ_BOOL opj_dwt_decode_partial_97(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
+ OPJ_UINT32 numres)
+{
+ opj_sparse_array_int32_t* sa;
+ opj_v4dwt_t h;
+ opj_v4dwt_t v;
+ OPJ_UINT32 resno;
+ /* This value matches the maximum left/right extension given in tables */
+ /* F.2 and F.3 of the standard. Note: in opj_tcd_is_subband_area_of_interest() */
+ /* we currently use 3. */
+ const OPJ_UINT32 filter_width = 4U;
+
+ opj_tcd_resolution_t* tr = tilec->resolutions;
+ opj_tcd_resolution_t* tr_max = &(tilec->resolutions[numres - 1]);
+
+ OPJ_UINT32 rw = (OPJ_UINT32)(tr->x1 -
+ tr->x0); /* width of the resolution level computed */
+ OPJ_UINT32 rh = (OPJ_UINT32)(tr->y1 -
+ tr->y0); /* height of the resolution level computed */
+
+ OPJ_SIZE_T l_data_size;
+
+ /* Compute the intersection of the area of interest, expressed in tile coordinates */
+ /* with the tile coordinates */
+ OPJ_UINT32 win_tcx0 = tilec->win_x0;
+ OPJ_UINT32 win_tcy0 = tilec->win_y0;
+ OPJ_UINT32 win_tcx1 = tilec->win_x1;
+ OPJ_UINT32 win_tcy1 = tilec->win_y1;
+
+ if (tr_max->x0 == tr_max->x1 || tr_max->y0 == tr_max->y1) {
+ return OPJ_TRUE;
+ }
+
+ sa = opj_dwt_init_sparse_array(tilec, numres);
+ if (sa == NULL) {
+ return OPJ_FALSE;
+ }
+
+ if (numres == 1U) {
+ OPJ_BOOL ret = opj_sparse_array_int32_read(sa,
+ tr_max->win_x0 - (OPJ_UINT32)tr_max->x0,
+ tr_max->win_y0 - (OPJ_UINT32)tr_max->y0,
+ tr_max->win_x1 - (OPJ_UINT32)tr_max->x0,
+ tr_max->win_y1 - (OPJ_UINT32)tr_max->y0,
+ tilec->data_win,
+ 1, tr_max->win_x1 - tr_max->win_x0,
+ OPJ_TRUE);
+ assert(ret);
+ OPJ_UNUSED(ret);
+ opj_sparse_array_int32_free(sa);
+ return OPJ_TRUE;
+ }
+
+ l_data_size = opj_dwt_max_resolution(tr, numres);
+ /* overflow check */
+ if (l_data_size > (SIZE_MAX - 5U)) {
+ /* FIXME event manager error callback */
+ return OPJ_FALSE;
+ }
+ l_data_size += 5U;
+ /* overflow check */
+ if (l_data_size > (SIZE_MAX / sizeof(opj_v4_t))) {
+ /* FIXME event manager error callback */
+ return OPJ_FALSE;
+ }
+ h.wavelet = (opj_v4_t*) opj_aligned_malloc(l_data_size * sizeof(opj_v4_t));
+ if (!h.wavelet) {
+ /* FIXME event manager error callback */
+ return OPJ_FALSE;
+ }
+ v.wavelet = h.wavelet;
+
+ for (resno = 1; resno < numres; resno ++) {
+ OPJ_UINT32 j;
+ /* Window of interest subband-based coordinates */
+ OPJ_UINT32 win_ll_x0, win_ll_y0, win_ll_x1, win_ll_y1;
+ OPJ_UINT32 win_hl_x0, win_hl_x1;
+ OPJ_UINT32 win_lh_y0, win_lh_y1;
+ /* Window of interest tile-resolution-based coordinates */
+ OPJ_UINT32 win_tr_x0, win_tr_x1, win_tr_y0, win_tr_y1;
+ /* Tile-resolution subband-based coordinates */
+ OPJ_UINT32 tr_ll_x0, tr_ll_y0, tr_hl_x0, tr_lh_y0;
+
+ ++tr;
+
+ h.sn = (OPJ_INT32)rw;
+ v.sn = (OPJ_INT32)rh;
+
+ rw = (OPJ_UINT32)(tr->x1 - tr->x0);
+ rh = (OPJ_UINT32)(tr->y1 - tr->y0);
+
+ h.dn = (OPJ_INT32)(rw - (OPJ_UINT32)h.sn);
+ h.cas = tr->x0 % 2;
+
+ v.dn = (OPJ_INT32)(rh - (OPJ_UINT32)v.sn);
+ v.cas = tr->y0 % 2;
+
+ /* Get the subband coordinates for the window of interest */
+ /* LL band */
+ opj_dwt_get_band_coordinates(tilec, resno, 0,
+ win_tcx0, win_tcy0, win_tcx1, win_tcy1,
+ &win_ll_x0, &win_ll_y0,
+ &win_ll_x1, &win_ll_y1);
+
+ /* HL band */
+ opj_dwt_get_band_coordinates(tilec, resno, 1,
+ win_tcx0, win_tcy0, win_tcx1, win_tcy1,
+ &win_hl_x0, NULL, &win_hl_x1, NULL);
+
+ /* LH band */
+ opj_dwt_get_band_coordinates(tilec, resno, 2,
+ win_tcx0, win_tcy0, win_tcx1, win_tcy1,
+ NULL, &win_lh_y0, NULL, &win_lh_y1);
+
+ /* Beware: band index for non-LL0 resolution are 0=HL, 1=LH and 2=HH */
+ tr_ll_x0 = (OPJ_UINT32)tr->bands[1].x0;
+ tr_ll_y0 = (OPJ_UINT32)tr->bands[0].y0;
+ tr_hl_x0 = (OPJ_UINT32)tr->bands[0].x0;
+ tr_lh_y0 = (OPJ_UINT32)tr->bands[1].y0;
+
+ /* Substract the origin of the bands for this tile, to the subwindow */
+ /* of interest band coordinates, so as to get them relative to the */
+ /* tile */
+ win_ll_x0 = opj_uint_subs(win_ll_x0, tr_ll_x0);
+ win_ll_y0 = opj_uint_subs(win_ll_y0, tr_ll_y0);
+ win_ll_x1 = opj_uint_subs(win_ll_x1, tr_ll_x0);
+ win_ll_y1 = opj_uint_subs(win_ll_y1, tr_ll_y0);
+ win_hl_x0 = opj_uint_subs(win_hl_x0, tr_hl_x0);
+ win_hl_x1 = opj_uint_subs(win_hl_x1, tr_hl_x0);
+ win_lh_y0 = opj_uint_subs(win_lh_y0, tr_lh_y0);
+ win_lh_y1 = opj_uint_subs(win_lh_y1, tr_lh_y0);
+
+ opj_dwt_segment_grow(filter_width, (OPJ_UINT32)h.sn, &win_ll_x0, &win_ll_x1);
+ opj_dwt_segment_grow(filter_width, (OPJ_UINT32)h.dn, &win_hl_x0, &win_hl_x1);
+
+ opj_dwt_segment_grow(filter_width, (OPJ_UINT32)v.sn, &win_ll_y0, &win_ll_y1);
+ opj_dwt_segment_grow(filter_width, (OPJ_UINT32)v.dn, &win_lh_y0, &win_lh_y1);
+
+ /* Compute the tile-resolution-based coordinates for the window of interest */
+ if (h.cas == 0) {
+ win_tr_x0 = opj_uint_min(2 * win_ll_x0, 2 * win_hl_x0 + 1);
+ win_tr_x1 = opj_uint_min(opj_uint_max(2 * win_ll_x1, 2 * win_hl_x1 + 1), rw);
+ } else {
+ win_tr_x0 = opj_uint_min(2 * win_hl_x0, 2 * win_ll_x0 + 1);
+ win_tr_x1 = opj_uint_min(opj_uint_max(2 * win_hl_x1, 2 * win_ll_x1 + 1), rw);
+ }
+
+ if (v.cas == 0) {
+ win_tr_y0 = opj_uint_min(2 * win_ll_y0, 2 * win_lh_y0 + 1);
+ win_tr_y1 = opj_uint_min(opj_uint_max(2 * win_ll_y1, 2 * win_lh_y1 + 1), rh);
+ } else {
+ win_tr_y0 = opj_uint_min(2 * win_lh_y0, 2 * win_ll_y0 + 1);
+ win_tr_y1 = opj_uint_min(opj_uint_max(2 * win_lh_y1, 2 * win_ll_y1 + 1), rh);
+ }
+
+ h.win_l_x0 = win_ll_x0;
+ h.win_l_x1 = win_ll_x1;
+ h.win_h_x0 = win_hl_x0;
+ h.win_h_x1 = win_hl_x1;
+ for (j = 0; j + 3 < rh; j += 4) {
+ if ((j + 3 >= win_ll_y0 && j < win_ll_y1) ||
+ (j + 3 >= win_lh_y0 + (OPJ_UINT32)v.sn &&
+ j < win_lh_y1 + (OPJ_UINT32)v.sn)) {
+ opj_v4dwt_interleave_partial_h(&h, sa, j, opj_uint_min(4U, rh - j));
+ opj_v4dwt_decode(&h);
+ if (!opj_sparse_array_int32_write(sa,
+ win_tr_x0, j,
+ win_tr_x1, j + 4,
+ (OPJ_INT32*)&h.wavelet[win_tr_x0].f[0],
+ 4, 1, OPJ_TRUE)) {
+ /* FIXME event manager error callback */
+ opj_sparse_array_int32_free(sa);
+ opj_aligned_free(h.wavelet);
+ return OPJ_FALSE;
+ }
+ }
+ }
+
+ if (j < rh &&
+ ((j + 3 >= win_ll_y0 && j < win_ll_y1) ||
+ (j + 3 >= win_lh_y0 + (OPJ_UINT32)v.sn &&
+ j < win_lh_y1 + (OPJ_UINT32)v.sn))) {
+ opj_v4dwt_interleave_partial_h(&h, sa, j, rh - j);
+ opj_v4dwt_decode(&h);
+ if (!opj_sparse_array_int32_write(sa,
+ win_tr_x0, j,
+ win_tr_x1, rh,
+ (OPJ_INT32*)&h.wavelet[win_tr_x0].f[0],
+ 4, 1, OPJ_TRUE)) {
+ /* FIXME event manager error callback */
+ opj_sparse_array_int32_free(sa);
+ opj_aligned_free(h.wavelet);
+ return OPJ_FALSE;
+ }
+ }
+
+ v.win_l_x0 = win_ll_y0;
+ v.win_l_x1 = win_ll_y1;
+ v.win_h_x0 = win_lh_y0;
+ v.win_h_x1 = win_lh_y1;
+ for (j = win_tr_x0; j < win_tr_x1; j += 4) {
+ OPJ_UINT32 nb_elts = opj_uint_min(4U, win_tr_x1 - j);
+
+ opj_v4dwt_interleave_partial_v(&v, sa, j, nb_elts);
+ opj_v4dwt_decode(&v);
+
+ if (!opj_sparse_array_int32_write(sa,
+ j, win_tr_y0,
+ j + nb_elts, win_tr_y1,
+ (OPJ_INT32*)&h.wavelet[win_tr_y0].f[0],
+ 1, 4, OPJ_TRUE)) {
+ /* FIXME event manager error callback */
+ opj_sparse_array_int32_free(sa);
+ opj_aligned_free(h.wavelet);
+ return OPJ_FALSE;
}
}
}
+ {
+ OPJ_BOOL ret = opj_sparse_array_int32_read(sa,
+ tr_max->win_x0 - (OPJ_UINT32)tr_max->x0,
+ tr_max->win_y0 - (OPJ_UINT32)tr_max->y0,
+ tr_max->win_x1 - (OPJ_UINT32)tr_max->x0,
+ tr_max->win_y1 - (OPJ_UINT32)tr_max->y0,
+ tilec->data_win,
+ 1, tr_max->win_x1 - tr_max->win_x0,
+ OPJ_TRUE);
+ assert(ret);
+ OPJ_UNUSED(ret);
+ }
+ opj_sparse_array_int32_free(sa);
+
opj_aligned_free(h.wavelet);
return OPJ_TRUE;
}
+
+
+OPJ_BOOL opj_dwt_decode_real(opj_tcd_t *p_tcd,
+ opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
+ OPJ_UINT32 numres)
+{
+ if (p_tcd->whole_tile_decoding) {
+ return opj_dwt_decode_tile_97(tilec, numres);
+ } else {
+ return opj_dwt_decode_partial_97(tilec, numres);
+ }
+}
diff --git a/third_party/libopenjpeg20/dwt.h b/third_party/libopenjpeg20/dwt.h
index 3c997efd4c..4f63e524a6 100644
--- a/third_party/libopenjpeg20/dwt.h
+++ b/third_party/libopenjpeg20/dwt.h
@@ -63,11 +63,12 @@ OPJ_BOOL opj_dwt_encode(opj_tcd_tilecomp_t * tilec);
/**
Inverse 5-3 wavelet transform in 2-D.
Apply a reversible inverse DWT transform to a component of an image.
-@param tp Thread pool
+@param p_tcd TCD handle
@param tilec Tile component information (current tile)
@param numres Number of resolution levels to decode
*/
-OPJ_BOOL opj_dwt_decode(opj_thread_pool_t* tp, opj_tcd_tilecomp_t* tilec,
+OPJ_BOOL opj_dwt_decode(opj_tcd_t *p_tcd,
+ opj_tcd_tilecomp_t* tilec,
OPJ_UINT32 numres);
/**
@@ -92,10 +93,12 @@ OPJ_BOOL opj_dwt_encode_real(opj_tcd_tilecomp_t * tilec);
/**
Inverse 9-7 wavelet transform in 2-D.
Apply an irreversible inverse DWT transform to a component of an image.
+@param p_tcd TCD handle
@param tilec Tile component information (current tile)
@param numres Number of resolution levels to decode
*/
-OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
+OPJ_BOOL opj_dwt_decode_real(opj_tcd_t *p_tcd,
+ opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
OPJ_UINT32 numres);
/**
diff --git a/third_party/libopenjpeg20/image.c b/third_party/libopenjpeg20/image.c
index bf7a701942..13bcb8e45f 100644
--- a/third_party/libopenjpeg20/image.c
+++ b/third_party/libopenjpeg20/image.c
@@ -70,7 +70,7 @@ opj_image_t* OPJ_CALLCONV opj_image_create(OPJ_UINT32 numcmpts,
comp->sgnd = cmptparms[compno].sgnd;
if (comp->h != 0 &&
(OPJ_SIZE_T)comp->w > SIZE_MAX / comp->h / sizeof(OPJ_INT32)) {
- // TODO event manager
+ /* TODO event manager */
opj_image_destroy(image);
return NULL;
}
diff --git a/third_party/libopenjpeg20/j2k.c b/third_party/libopenjpeg20/j2k.c
index 1869833f76..784a0620a5 100644
--- a/third_party/libopenjpeg20/j2k.c
+++ b/third_party/libopenjpeg20/j2k.c
@@ -16,6 +16,7 @@
* Copyright (c) 2010-2011, Kaori Hagihara
* Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France
* Copyright (c) 2012, CS Systemes d'Information, France
+ * Copyright (c) 2017, IntoPIX SA <support@intopix.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -48,8 +49,6 @@
/** @name Local static functions */
/*@{*/
-#define OPJ_UNUSED(x) (void)x
-
/**
* Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
*/
@@ -137,7 +136,7 @@ static OPJ_BOOL opj_j2k_build_encoder(opj_j2k_t * p_j2k,
opj_event_mgr_t * p_manager);
/**
- * Creates a tile-coder decoder.
+ * Creates a tile-coder encoder.
*
* @param p_stream the stream to write data to.
* @param p_j2k J2K codec.
@@ -370,7 +369,7 @@ static OPJ_BOOL opj_j2k_pre_write_tile(opj_j2k_t * p_j2k,
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager);
-static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data,
+static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd,
opj_image_t* p_output_image);
static void opj_get_tile_dimensions(opj_image_t * l_image,
@@ -832,13 +831,15 @@ static OPJ_BOOL opj_j2k_write_tlm(opj_j2k_t *p_j2k,
* Writes the SOT marker (Start of tile-part)
*
* @param p_j2k J2K codec.
- * @param p_data FIXME DOC
- * @param p_data_written FIXME DOC
+ * @param p_data Output buffer
+ * @param p_total_data_size Output buffer size
+ * @param p_data_written Number of bytes written into stream
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
static OPJ_BOOL opj_j2k_write_sot(opj_j2k_t *p_j2k,
OPJ_BYTE * p_data,
+ OPJ_UINT32 p_total_data_size,
OPJ_UINT32 * p_data_written,
const opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager);
@@ -1305,7 +1306,7 @@ typedef struct j2k_prog_order {
char str_prog[5];
} j2k_prog_order_t;
-static j2k_prog_order_t j2k_prog_order_list[] = {
+static const j2k_prog_order_t j2k_prog_order_list[] = {
{OPJ_CPRL, "CPRL"},
{OPJ_LRCP, "LRCP"},
{OPJ_PCRL, "PCRL"},
@@ -1602,9 +1603,9 @@ static void opj_j2k_write_float_to_float64(const void * p_src_data,
}
}
-char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order)
+const char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order)
{
- j2k_prog_order_t *po;
+ const j2k_prog_order_t *po;
for (po = j2k_prog_order_list; po->enum_prog != -1; po++) {
if (po->enum_prog == prg_order) {
return po->str_prog;
@@ -2141,13 +2142,6 @@ static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k,
return OPJ_FALSE;
}
- /* testcase 1610.pdf.SIGSEGV.59c.681 */
- if ((0xFFFFFFFFU / l_image->x1) < l_image->y1) {
- opj_event_msg(p_manager, EVT_ERROR,
- "Prevent buffer overflow (x1: %d, y1: %d)\n", l_image->x1, l_image->y1);
- return OPJ_FALSE;
- }
-
/* testcase issue427-illegal-tile-offset.jp2 */
l_tx1 = opj_uint_adds(l_cp->tx0, l_cp->tdx); /* manage overflow */
l_ty1 = opj_uint_adds(l_cp->ty0, l_cp->tdy); /* manage overflow */
@@ -3504,11 +3498,10 @@ static OPJ_BOOL opj_j2k_read_poc(opj_j2k_t *p_j2k,
l_old_poc_nb = l_tcp->POC ? l_tcp->numpocs + 1 : 0;
l_current_poc_nb += l_old_poc_nb;
- if (l_current_poc_nb >= 32) {
+ if (l_current_poc_nb >= J2K_MAX_POCS) {
opj_event_msg(p_manager, EVT_ERROR, "Too many POCs %d\n", l_current_poc_nb);
return OPJ_FALSE;
}
- assert(l_current_poc_nb < 32);
/* now poc is in use.*/
l_tcp->POC = 1;
@@ -4197,6 +4190,7 @@ static OPJ_BOOL opj_j2k_write_tlm(opj_j2k_t *p_j2k,
static OPJ_BOOL opj_j2k_write_sot(opj_j2k_t *p_j2k,
OPJ_BYTE * p_data,
+ OPJ_UINT32 p_total_data_size,
OPJ_UINT32 * p_data_written,
const opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager
@@ -4208,7 +4202,12 @@ static OPJ_BOOL opj_j2k_write_sot(opj_j2k_t *p_j2k,
assert(p_stream != 00);
OPJ_UNUSED(p_stream);
- OPJ_UNUSED(p_manager);
+
+ if (p_total_data_size < 12) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Not enough bytes in output buffer to write SOT marker\n");
+ return OPJ_FALSE;
+ }
opj_write_bytes(p_data, J2K_MS_SOT,
2); /* SOT */
@@ -4300,6 +4299,10 @@ static OPJ_BOOL opj_j2k_read_sot(opj_j2k_t *p_j2k,
opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n");
return OPJ_FALSE;
}
+#ifdef DEBUG_VERBOSE
+ fprintf(stderr, "SOT %d %d %d %d\n",
+ p_j2k->m_current_tile_number, l_tot_len, l_current_part, l_num_parts);
+#endif
l_cp = &(p_j2k->m_cp);
@@ -4314,23 +4317,31 @@ static OPJ_BOOL opj_j2k_read_sot(opj_j2k_t *p_j2k,
l_tile_x = p_j2k->m_current_tile_number % l_cp->tw;
l_tile_y = p_j2k->m_current_tile_number / l_cp->tw;
- /* Fixes issue with id_000020,sig_06,src_001958,op_flip4,pos_149 */
- /* of https://github.com/uclouvain/openjpeg/issues/939 */
- /* We must avoid reading twice the same tile part number for a given tile */
- /* so as to avoid various issues, like opj_j2k_merge_ppt being called */
- /* several times. */
- /* ISO 15444-1 A.4.2 Start of tile-part (SOT) mandates that tile parts */
- /* should appear in increasing order. */
- if (l_tcp->m_current_tile_part_number + 1 != (OPJ_INT32)l_current_part) {
- opj_event_msg(p_manager, EVT_ERROR,
- "Invalid tile part index for tile number %d. "
- "Got %d, expected %d\n",
- p_j2k->m_current_tile_number,
- l_current_part,
- l_tcp->m_current_tile_part_number + 1);
- return OPJ_FALSE;
+ if (p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec < 0 ||
+ p_j2k->m_current_tile_number == (OPJ_UINT32)
+ p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec) {
+ /* Do only this check if we decode all tile part headers, or if */
+ /* we decode one precise tile. Otherwise the m_current_tile_part_number */
+ /* might not be valid */
+ /* Fixes issue with id_000020,sig_06,src_001958,op_flip4,pos_149 */
+ /* of https://github.com/uclouvain/openjpeg/issues/939 */
+ /* We must avoid reading twice the same tile part number for a given tile */
+ /* so as to avoid various issues, like opj_j2k_merge_ppt being called */
+ /* several times. */
+ /* ISO 15444-1 A.4.2 Start of tile-part (SOT) mandates that tile parts */
+ /* should appear in increasing order. */
+ if (l_tcp->m_current_tile_part_number + 1 != (OPJ_INT32)l_current_part) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Invalid tile part index for tile number %d. "
+ "Got %d, expected %d\n",
+ p_j2k->m_current_tile_number,
+ l_current_part,
+ l_tcp->m_current_tile_part_number + 1);
+ return OPJ_FALSE;
+ }
}
- ++ l_tcp->m_current_tile_part_number;
+
+ l_tcp->m_current_tile_part_number = (OPJ_INT32) l_current_part;
#ifdef USE_JPWL
if (l_cp->correct) {
@@ -4604,6 +4615,12 @@ static OPJ_BOOL opj_j2k_write_sod(opj_j2k_t *p_j2k,
OPJ_UNUSED(p_stream);
+ if (p_total_data_size < 4) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Not enough bytes in output buffer to write SOD marker\n");
+ return OPJ_FALSE;
+ }
+
opj_write_bytes(p_data, J2K_MS_SOD,
2); /* SOD */
p_data += 2;
@@ -4647,15 +4664,18 @@ static OPJ_BOOL opj_j2k_write_sod(opj_j2k_t *p_j2k,
if (p_j2k->m_specific_param.m_encoder.m_current_tile_part_number == 0) {
p_tile_coder->tcd_image->tiles->packno = 0;
+#ifdef deadcode
if (l_cstr_info) {
l_cstr_info->packno = 0;
}
+#endif
}
*p_data_written = 0;
if (! opj_tcd_encode_tile(p_tile_coder, p_j2k->m_current_tile_number, p_data,
- p_data_written, l_remaining_data, l_cstr_info)) {
+ p_data_written, l_remaining_data, l_cstr_info,
+ p_manager)) {
opj_event_msg(p_manager, EVT_ERROR, "Cannot encode tile\n");
return OPJ_FALSE;
}
@@ -5143,7 +5163,17 @@ static OPJ_BOOL opj_j2k_update_rates(opj_j2k_t *p_j2k,
++l_img_comp;
}
- l_tile_size = (OPJ_UINT32)(l_tile_size * 0.1625); /* 1.3/8 = 0.1625 */
+ /* TODO: where does this magic value come from ? */
+ /* This used to be 1.3 / 8, but with random data and very small code */
+ /* block sizes, this is not enough. For example with */
+ /* bin/test_tile_encoder 1 256 256 32 32 8 0 reversible_with_precinct.j2k 4 4 3 0 0 1 16 16 */
+ /* TODO revise this to take into account the overhead linked to the */
+ /* number of packets and number of code blocks in packets */
+ l_tile_size = (OPJ_UINT32)(l_tile_size * 1.4 / 8);
+
+ /* Arbitrary amount to make the following work: */
+ /* bin/test_tile_encoder 1 256 256 17 16 8 0 reversible_no_precinct.j2k 4 4 3 0 0 1 */
+ l_tile_size += 500;
l_tile_size += opj_j2k_get_specific_header_sizes(p_j2k);
@@ -6406,14 +6436,27 @@ OPJ_BOOL opj_j2k_set_threads(opj_j2k_t *j2k, OPJ_UINT32 num_threads)
static int opj_j2k_get_default_thread_count()
{
- const char* num_threads = getenv("OPJ_NUM_THREADS");
- if (num_threads == NULL || !opj_has_thread_support()) {
+ const char* num_threads_str = getenv("OPJ_NUM_THREADS");
+ int num_cpus;
+ int num_threads;
+
+ if (num_threads_str == NULL || !opj_has_thread_support()) {
return 0;
}
- if (strcmp(num_threads, "ALL_CPUS") == 0) {
- return opj_get_num_cpus();
+ num_cpus = opj_get_num_cpus();
+ if (strcmp(num_threads_str, "ALL_CPUS") == 0) {
+ return num_cpus;
+ }
+ if (num_cpus == 0) {
+ num_cpus = 32;
+ }
+ num_threads = atoi(num_threads_str);
+ if (num_threads < 0) {
+ num_threads = 0;
+ } else if (num_threads > 2 * num_cpus) {
+ num_threads = 2 * num_cpus;
}
- return atoi(num_threads);
+ return num_threads;
}
/* ----------------------------------------------------------------------- */
@@ -6572,10 +6615,16 @@ static void opj_j2k_set_cinema_parameters(opj_cparameters_t *parameters,
/* Precincts */
parameters->csty |= 0x01;
- parameters->res_spec = parameters->numresolution - 1;
- for (i = 0; i < parameters->res_spec; i++) {
- parameters->prcw_init[i] = 256;
- parameters->prch_init[i] = 256;
+ if (parameters->numresolution == 1) {
+ parameters->res_spec = 1;
+ parameters->prcw_init[0] = 128;
+ parameters->prch_init[0] = 128;
+ } else {
+ parameters->res_spec = parameters->numresolution - 1;
+ for (i = 0; i < parameters->res_spec; i++) {
+ parameters->prcw_init[i] = 256;
+ parameters->prch_init[i] = 256;
+ }
}
/* The progression order shall be CPRL */
@@ -6698,6 +6747,7 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
{
OPJ_UINT32 i, j, tileno, numpocs_tile;
opj_cp_t *cp = 00;
+ OPJ_UINT32 cblkw, cblkh;
if (!p_j2k || !parameters || ! image) {
return OPJ_FALSE;
@@ -6711,6 +6761,38 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
return OPJ_FALSE;
}
+ if (parameters->cblockw_init < 4 || parameters->cblockw_init > 1024) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Invalid value for cblockw_init: %d not a power of 2 in range [4,1024]\n",
+ parameters->cblockw_init);
+ return OPJ_FALSE;
+ }
+ if (parameters->cblockh_init < 4 || parameters->cblockh_init > 1024) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Invalid value for cblockh_init: %d not a power of 2 not in range [4,1024]\n",
+ parameters->cblockh_init);
+ return OPJ_FALSE;
+ }
+ if (parameters->cblockw_init * parameters->cblockh_init > 4096) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Invalid value for cblockw_init * cblockh_init: should be <= 4096\n");
+ return OPJ_FALSE;
+ }
+ cblkw = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockw_init);
+ cblkh = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockh_init);
+ if (parameters->cblockw_init != (1 << cblkw)) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Invalid value for cblockw_init: %d not a power of 2 in range [4,1024]\n",
+ parameters->cblockw_init);
+ return OPJ_FALSE;
+ }
+ if (parameters->cblockh_init != (1 << cblkh)) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Invalid value for cblockw_init: %d not a power of 2 in range [4,1024]\n",
+ parameters->cblockh_init);
+ return OPJ_FALSE;
+ }
+
/* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
cp = &(p_j2k->m_cp);
@@ -6769,25 +6851,91 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
}
}
+ /* If no explicit layers are provided, use lossless settings */
+ if (parameters->tcp_numlayers == 0) {
+ parameters->tcp_numlayers = 1;
+ parameters->cp_disto_alloc = 1;
+ parameters->tcp_rates[0] = 0;
+ }
+
+ if (parameters->cp_disto_alloc) {
+ /* Emit warnings if tcp_rates are not decreasing */
+ for (i = 1; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
+ OPJ_FLOAT32 rate_i_corr = parameters->tcp_rates[i];
+ OPJ_FLOAT32 rate_i_m_1_corr = parameters->tcp_rates[i - 1];
+ if (rate_i_corr <= 1.0) {
+ rate_i_corr = 1.0;
+ }
+ if (rate_i_m_1_corr <= 1.0) {
+ rate_i_m_1_corr = 1.0;
+ }
+ if (rate_i_corr >= rate_i_m_1_corr) {
+ if (rate_i_corr != parameters->tcp_rates[i] &&
+ rate_i_m_1_corr != parameters->tcp_rates[i - 1]) {
+ opj_event_msg(p_manager, EVT_WARNING,
+ "tcp_rates[%d]=%f (corrected as %f) should be strictly lesser "
+ "than tcp_rates[%d]=%f (corrected as %f)\n",
+ i, parameters->tcp_rates[i], rate_i_corr,
+ i - 1, parameters->tcp_rates[i - 1], rate_i_m_1_corr);
+ } else if (rate_i_corr != parameters->tcp_rates[i]) {
+ opj_event_msg(p_manager, EVT_WARNING,
+ "tcp_rates[%d]=%f (corrected as %f) should be strictly lesser "
+ "than tcp_rates[%d]=%f\n",
+ i, parameters->tcp_rates[i], rate_i_corr,
+ i - 1, parameters->tcp_rates[i - 1]);
+ } else if (rate_i_m_1_corr != parameters->tcp_rates[i - 1]) {
+ opj_event_msg(p_manager, EVT_WARNING,
+ "tcp_rates[%d]=%f should be strictly lesser "
+ "than tcp_rates[%d]=%f (corrected as %f)\n",
+ i, parameters->tcp_rates[i],
+ i - 1, parameters->tcp_rates[i - 1], rate_i_m_1_corr);
+ } else {
+ opj_event_msg(p_manager, EVT_WARNING,
+ "tcp_rates[%d]=%f should be strictly lesser "
+ "than tcp_rates[%d]=%f\n",
+ i, parameters->tcp_rates[i],
+ i - 1, parameters->tcp_rates[i - 1]);
+ }
+ }
+ }
+ } else if (parameters->cp_fixed_quality) {
+ /* Emit warnings if tcp_distoratio are not increasing */
+ for (i = 1; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
+ if (parameters->tcp_distoratio[i] < parameters->tcp_distoratio[i - 1] &&
+ !(i == (OPJ_UINT32)parameters->tcp_numlayers - 1 &&
+ parameters->tcp_distoratio[i] == 0)) {
+ opj_event_msg(p_manager, EVT_WARNING,
+ "tcp_distoratio[%d]=%f should be strictly greater "
+ "than tcp_distoratio[%d]=%f\n",
+ i, parameters->tcp_distoratio[i], i - 1,
+ parameters->tcp_distoratio[i - 1]);
+ }
+ }
+ }
+
/* see if max_codestream_size does limit input rate */
if (parameters->max_cs_size <= 0) {
if (parameters->tcp_rates[parameters->tcp_numlayers - 1] > 0) {
OPJ_FLOAT32 temp_size;
- temp_size = (OPJ_FLOAT32)(image->numcomps * image->comps[0].w *
- image->comps[0].h * image->comps[0].prec) /
- (parameters->tcp_rates[parameters->tcp_numlayers - 1] * 8 *
- (OPJ_FLOAT32)image->comps[0].dx * (OPJ_FLOAT32)image->comps[0].dy);
- parameters->max_cs_size = (int) floor(temp_size);
+ temp_size = (OPJ_FLOAT32)(((double)image->numcomps * image->comps[0].w *
+ image->comps[0].h * image->comps[0].prec) /
+ ((double)parameters->tcp_rates[parameters->tcp_numlayers - 1] * 8 *
+ image->comps[0].dx * image->comps[0].dy));
+ if (temp_size > INT_MAX) {
+ parameters->max_cs_size = INT_MAX;
+ } else {
+ parameters->max_cs_size = (int) floor(temp_size);
+ }
} else {
parameters->max_cs_size = 0;
}
} else {
OPJ_FLOAT32 temp_rate;
OPJ_BOOL cap = OPJ_FALSE;
- temp_rate = (OPJ_FLOAT32)(image->numcomps * image->comps[0].w *
- image->comps[0].h * image->comps[0].prec) /
- (OPJ_FLOAT32)(((OPJ_UINT32)parameters->max_cs_size) * 8 * image->comps[0].dx *
- image->comps[0].dy);
+ temp_rate = (OPJ_FLOAT32)(((double)image->numcomps * image->comps[0].w *
+ image->comps[0].h * image->comps[0].prec) /
+ (((double)parameters->max_cs_size) * 8 * image->comps[0].dx *
+ image->comps[0].dy));
for (i = 0; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) {
if (parameters->tcp_rates[i] < temp_rate) {
parameters->tcp_rates[i] = temp_rate;
@@ -7019,6 +7167,10 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
tcp->rates[j] = parameters->tcp_rates[j];
}
}
+ if (!cp->m_specific_param.m_enc.m_fixed_quality &&
+ tcp->rates[j] <= 1.0) {
+ tcp->rates[j] = 0.0; /* force lossless */
+ }
}
tcp->csty = (OPJ_UINT32)parameters->csty;
@@ -8080,7 +8232,7 @@ static OPJ_BOOL opj_j2k_copy_default_tcp_and_create_tcd(opj_j2k_t * p_j2k,
}
/* Create the current tile decoder*/
- p_j2k->m_tcd = (opj_tcd_t*)opj_tcd_create(OPJ_TRUE); /* FIXME why a cast ? */
+ p_j2k->m_tcd = opj_tcd_create(OPJ_TRUE);
if (! p_j2k->m_tcd) {
return OPJ_FALSE;
}
@@ -8126,6 +8278,11 @@ void opj_j2k_destroy(opj_j2k_t *p_j2k)
p_j2k->m_specific_param.m_decoder.m_header_data = 00;
p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
}
+
+ opj_free(p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode);
+ p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode = 00;
+ p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode = 0;
+
} else {
if (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data) {
@@ -8411,7 +8568,7 @@ static OPJ_BOOL opj_j2k_need_nb_tile_parts_correction(opj_stream_private_t
break;
}
- if ((l_tot_len == 0U) || (l_tot_len < 14U)) {
+ if (l_tot_len < 14U) {
/* last SOT until EOC or invalid Psot value */
/* assume all is OK */
if (! opj_stream_seek(p_stream, l_stream_pos_backup, p_manager)) {
@@ -8715,9 +8872,13 @@ OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k,
*p_tile_index = p_j2k->m_current_tile_number;
*p_go_on = OPJ_TRUE;
- *p_data_size = opj_tcd_get_decoded_tile_size(p_j2k->m_tcd);
- if (*p_data_size == UINT_MAX) {
- return OPJ_FALSE;
+ if (p_data_size) {
+ /* For internal use in j2k.c, we don't need this */
+ /* This is just needed for folks using the opj_read_tile_header() / opj_decode_tile_data() combo */
+ *p_data_size = opj_tcd_get_decoded_tile_size(p_j2k->m_tcd, OPJ_FALSE);
+ if (*p_data_size == UINT_MAX) {
+ return OPJ_FALSE;
+ }
}
*p_tile_x0 = p_j2k->m_tcd->tcd_image->tiles->x0;
*p_tile_y0 = p_j2k->m_tcd->tcd_image->tiles->y0;
@@ -8740,6 +8901,7 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
OPJ_UINT32 l_current_marker;
OPJ_BYTE l_data [2];
opj_tcp_t * l_tcp;
+ opj_image_t* l_image_for_bounds;
/* preconditions */
assert(p_stream != 00);
@@ -8757,7 +8919,20 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
return OPJ_FALSE;
}
+ /* When using the opj_read_tile_header / opj_decode_tile_data API */
+ /* such as in test_tile_decoder, m_output_image is NULL, so fall back */
+ /* to the full image dimension. This is a bit surprising that */
+ /* opj_set_decode_area() is only used to determinte intersecting tiles, */
+ /* but full tile decoding is done */
+ l_image_for_bounds = p_j2k->m_output_image ? p_j2k->m_output_image :
+ p_j2k->m_private_image;
if (! opj_tcd_decode_tile(p_j2k->m_tcd,
+ l_image_for_bounds->x0,
+ l_image_for_bounds->y0,
+ l_image_for_bounds->x1,
+ l_image_for_bounds->y1,
+ p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode,
+ p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode,
l_tcp->m_data,
l_tcp->m_data_size,
p_tile_index,
@@ -8816,26 +8991,24 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
return OPJ_TRUE;
}
-static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data,
+static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd,
opj_image_t* p_output_image)
{
- OPJ_UINT32 i, j, k = 0;
+ OPJ_UINT32 i, j;
OPJ_UINT32 l_width_src, l_height_src;
OPJ_UINT32 l_width_dest, l_height_dest;
OPJ_INT32 l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src;
- OPJ_SIZE_T l_start_offset_src, l_line_offset_src, l_end_offset_src ;
+ OPJ_SIZE_T l_start_offset_src;
OPJ_UINT32 l_start_x_dest, l_start_y_dest;
OPJ_UINT32 l_x0_dest, l_y0_dest, l_x1_dest, l_y1_dest;
- OPJ_SIZE_T l_start_offset_dest, l_line_offset_dest;
+ OPJ_SIZE_T l_start_offset_dest;
opj_image_comp_t * l_img_comp_src = 00;
opj_image_comp_t * l_img_comp_dest = 00;
opj_tcd_tilecomp_t * l_tilec = 00;
opj_image_t * l_image_src = 00;
- OPJ_UINT32 l_size_comp, l_remaining;
OPJ_INT32 * l_dest_ptr;
- opj_tcd_resolution_t* l_res = 00;
l_tilec = p_tcd->tcd_image->tiles->comps;
l_image_src = p_tcd->image;
@@ -8843,53 +9016,52 @@ static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data,
l_img_comp_dest = p_output_image->comps;
- for (i = 0; i < l_image_src->numcomps; i++) {
-
- /* Allocate output component buffer if necessary */
- if (!l_img_comp_dest->data) {
- OPJ_SIZE_T l_width = l_img_comp_dest->w;
- OPJ_SIZE_T l_height = l_img_comp_dest->h;
-
- if ((l_height == 0U) || (l_width > (SIZE_MAX / l_height)) ||
- l_width * l_height > SIZE_MAX / sizeof(OPJ_INT32)) {
- /* would overflow */
- return OPJ_FALSE;
- }
- l_img_comp_dest->data = (OPJ_INT32*) opj_image_data_alloc(l_width * l_height *
- sizeof(OPJ_INT32));
- if (! l_img_comp_dest->data) {
- return OPJ_FALSE;
- }
- /* Do we really need this memset ? */
- memset(l_img_comp_dest->data, 0, l_width * l_height * sizeof(OPJ_INT32));
- }
+ for (i = 0; i < l_image_src->numcomps;
+ i++, ++l_img_comp_dest, ++l_img_comp_src, ++l_tilec) {
+ OPJ_INT32 res_x0, res_x1, res_y0, res_y1;
+ OPJ_UINT32 src_data_stride;
+ const OPJ_INT32* p_src_data;
/* Copy info from decoded comp image to output image */
l_img_comp_dest->resno_decoded = l_img_comp_src->resno_decoded;
- /*-----*/
- /* Compute the precision of the output buffer */
- l_size_comp = l_img_comp_src->prec >> 3; /*(/ 8)*/
- l_remaining = l_img_comp_src->prec & 7; /* (%8) */
- l_res = l_tilec->resolutions + l_img_comp_src->resno_decoded;
-
- if (l_remaining) {
- ++l_size_comp;
+ if (p_tcd->whole_tile_decoding) {
+ opj_tcd_resolution_t* l_res = l_tilec->resolutions +
+ l_img_comp_src->resno_decoded;
+ res_x0 = l_res->x0;
+ res_y0 = l_res->y0;
+ res_x1 = l_res->x1;
+ res_y1 = l_res->y1;
+ src_data_stride = (OPJ_UINT32)(
+ l_tilec->resolutions[l_tilec->minimum_num_resolutions - 1].x1 -
+ l_tilec->resolutions[l_tilec->minimum_num_resolutions - 1].x0);
+ p_src_data = l_tilec->data;
+ } else {
+ opj_tcd_resolution_t* l_res = l_tilec->resolutions +
+ l_img_comp_src->resno_decoded;
+ res_x0 = (OPJ_INT32)l_res->win_x0;
+ res_y0 = (OPJ_INT32)l_res->win_y0;
+ res_x1 = (OPJ_INT32)l_res->win_x1;
+ res_y1 = (OPJ_INT32)l_res->win_y1;
+ src_data_stride = l_res->win_x1 - l_res->win_x0;
+ p_src_data = l_tilec->data_win;
}
- if (l_size_comp == 3) {
- l_size_comp = 4;
+ if (p_src_data == NULL) {
+ /* Happens for partial component decoding */
+ continue;
}
- /*-----*/
+
+ l_width_src = (OPJ_UINT32)(res_x1 - res_x0);
+ l_height_src = (OPJ_UINT32)(res_y1 - res_y0);
+
/* Current tile component size*/
/*if (i == 0) {
fprintf(stdout, "SRC: l_res_x0=%d, l_res_x1=%d, l_res_y0=%d, l_res_y1=%d\n",
- l_res->x0, l_res->x1, l_res->y0, l_res->y1);
+ res_x0, res_x1, res_y0, res_y1);
}*/
- l_width_src = (OPJ_UINT32)(l_res->x1 - l_res->x0);
- l_height_src = (OPJ_UINT32)(l_res->y1 - l_res->y0);
/* Border of the current output component*/
l_x0_dest = opj_uint_ceildivpow2(l_img_comp_dest->x0, l_img_comp_dest->factor);
@@ -8910,59 +9082,59 @@ static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data,
* l_start_y_dest, l_width_dest, l_height_dest) which will be modified
* by this input area.
* */
- assert(l_res->x0 >= 0);
- assert(l_res->x1 >= 0);
+ assert(res_x0 >= 0);
+ assert(res_x1 >= 0);
/* Prevent bad casting to unsigned values in the subsequent lines. */
- if ( l_res->x0 < 0 || l_res->x1 < 0 || l_res->y0 < 0 || l_res->y1 < 0 ) {
+ if ( res_x0 < 0 || res_x1 < 0 || res_y0 < 0 || res_y1 < 0 ) {
return OPJ_FALSE;
}
- if (l_x0_dest < (OPJ_UINT32)l_res->x0) {
- l_start_x_dest = (OPJ_UINT32)l_res->x0 - l_x0_dest;
+ if (l_x0_dest < (OPJ_UINT32)res_x0) {
+ l_start_x_dest = (OPJ_UINT32)res_x0 - l_x0_dest;
l_offset_x0_src = 0;
- if (l_x1_dest >= (OPJ_UINT32)l_res->x1) {
+ if (l_x1_dest >= (OPJ_UINT32)res_x1) {
l_width_dest = l_width_src;
l_offset_x1_src = 0;
} else {
- l_width_dest = l_x1_dest - (OPJ_UINT32)l_res->x0 ;
+ l_width_dest = l_x1_dest - (OPJ_UINT32)res_x0 ;
l_offset_x1_src = (OPJ_INT32)(l_width_src - l_width_dest);
}
} else {
l_start_x_dest = 0U;
- l_offset_x0_src = (OPJ_INT32)l_x0_dest - l_res->x0;
+ l_offset_x0_src = (OPJ_INT32)l_x0_dest - res_x0;
- if (l_x1_dest >= (OPJ_UINT32)l_res->x1) {
+ if (l_x1_dest >= (OPJ_UINT32)res_x1) {
l_width_dest = l_width_src - (OPJ_UINT32)l_offset_x0_src;
l_offset_x1_src = 0;
} else {
l_width_dest = l_img_comp_dest->w ;
- l_offset_x1_src = l_res->x1 - (OPJ_INT32)l_x1_dest;
+ l_offset_x1_src = res_x1 - (OPJ_INT32)l_x1_dest;
}
}
- if (l_y0_dest < (OPJ_UINT32)l_res->y0) {
- l_start_y_dest = (OPJ_UINT32)l_res->y0 - l_y0_dest;
+ if (l_y0_dest < (OPJ_UINT32)res_y0) {
+ l_start_y_dest = (OPJ_UINT32)res_y0 - l_y0_dest;
l_offset_y0_src = 0;
- if (l_y1_dest >= (OPJ_UINT32)l_res->y1) {
+ if (l_y1_dest >= (OPJ_UINT32)res_y1) {
l_height_dest = l_height_src;
l_offset_y1_src = 0;
} else {
- l_height_dest = l_y1_dest - (OPJ_UINT32)l_res->y0 ;
+ l_height_dest = l_y1_dest - (OPJ_UINT32)res_y0 ;
l_offset_y1_src = (OPJ_INT32)(l_height_src - l_height_dest);
}
} else {
l_start_y_dest = 0U;
- l_offset_y0_src = (OPJ_INT32)l_y0_dest - l_res->y0;
+ l_offset_y0_src = (OPJ_INT32)l_y0_dest - res_y0;
- if (l_y1_dest >= (OPJ_UINT32)l_res->y1) {
+ if (l_y1_dest >= (OPJ_UINT32)res_y1) {
l_height_dest = l_height_src - (OPJ_UINT32)l_offset_y0_src;
l_offset_y1_src = 0;
} else {
l_height_dest = l_img_comp_dest->h ;
- l_offset_y1_src = l_res->y1 - (OPJ_INT32)l_y1_dest;
+ l_offset_y1_src = res_y1 - (OPJ_INT32)l_y1_dest;
}
}
@@ -8978,124 +9150,172 @@ static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd, OPJ_BYTE * p_data,
/* Compute the input buffer offset */
l_start_offset_src = (OPJ_SIZE_T)l_offset_x0_src + (OPJ_SIZE_T)l_offset_y0_src
- * (OPJ_SIZE_T)l_width_src;
- l_line_offset_src = (OPJ_SIZE_T)l_offset_x1_src + (OPJ_SIZE_T)l_offset_x0_src;
- l_end_offset_src = (OPJ_SIZE_T)l_offset_y1_src * (OPJ_SIZE_T)l_width_src -
- (OPJ_SIZE_T)l_offset_x0_src;
+ * (OPJ_SIZE_T)src_data_stride;
/* Compute the output buffer offset */
l_start_offset_dest = (OPJ_SIZE_T)l_start_x_dest + (OPJ_SIZE_T)l_start_y_dest
* (OPJ_SIZE_T)l_img_comp_dest->w;
- l_line_offset_dest = (OPJ_SIZE_T)l_img_comp_dest->w - (OPJ_SIZE_T)l_width_dest;
+
+ /* Allocate output component buffer if necessary */
+ if (l_img_comp_dest->data == NULL &&
+ l_start_offset_src == 0 && l_start_offset_dest == 0 &&
+ src_data_stride == l_img_comp_dest->w &&
+ l_width_dest == l_img_comp_dest->w &&
+ l_height_dest == l_img_comp_dest->h) {
+ /* If the final image matches the tile buffer, then borrow it */
+ /* directly to save a copy */
+ if (p_tcd->whole_tile_decoding) {
+ l_img_comp_dest->data = l_tilec->data;
+ l_tilec->data = NULL;
+ } else {
+ l_img_comp_dest->data = l_tilec->data_win;
+ l_tilec->data_win = NULL;
+ }
+ continue;
+ } else if (l_img_comp_dest->data == NULL) {
+ OPJ_SIZE_T l_width = l_img_comp_dest->w;
+ OPJ_SIZE_T l_height = l_img_comp_dest->h;
+
+ if ((l_height == 0U) || (l_width > (SIZE_MAX / l_height)) ||
+ l_width * l_height > SIZE_MAX / sizeof(OPJ_INT32)) {
+ /* would overflow */
+ return OPJ_FALSE;
+ }
+ l_img_comp_dest->data = (OPJ_INT32*) opj_image_data_alloc(l_width * l_height *
+ sizeof(OPJ_INT32));
+ if (! l_img_comp_dest->data) {
+ return OPJ_FALSE;
+ }
+
+ if (l_img_comp_dest->w != l_width_dest ||
+ l_img_comp_dest->h != l_height_dest) {
+ memset(l_img_comp_dest->data, 0,
+ (OPJ_SIZE_T)l_img_comp_dest->w * l_img_comp_dest->h * sizeof(OPJ_INT32));
+ }
+ }
/* Move the output buffer to the first place where we will write*/
l_dest_ptr = l_img_comp_dest->data + l_start_offset_dest;
- /*if (i == 0) {
- fprintf(stdout, "COMPO[%d]:\n",i);
- fprintf(stdout, "SRC: l_start_x_src=%d, l_start_y_src=%d, l_width_src=%d, l_height_src=%d\n"
- "\t tile offset:%d, %d, %d, %d\n"
- "\t buffer offset: %d; %d, %d\n",
- l_res->x0, l_res->y0, l_width_src, l_height_src,
- l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src,
- l_start_offset_src, l_line_offset_src, l_end_offset_src);
-
- fprintf(stdout, "DEST: l_start_x_dest=%d, l_start_y_dest=%d, l_width_dest=%d, l_height_dest=%d\n"
- "\t start offset: %d, line offset= %d\n",
- l_start_x_dest, l_start_y_dest, l_width_dest, l_height_dest, l_start_offset_dest, l_line_offset_dest);
- }*/
+ {
+ const OPJ_INT32 * l_src_ptr = p_src_data;
+ l_src_ptr += l_start_offset_src;
- switch (l_size_comp) {
- case 1: {
- OPJ_CHAR * l_src_ptr = (OPJ_CHAR*) p_data;
- l_src_ptr += l_start_offset_src; /* Move to the first place where we will read*/
-
- if (l_img_comp_src->sgnd) {
- for (j = 0 ; j < l_height_dest ; ++j) {
- for (k = 0 ; k < l_width_dest ; ++k) {
- *(l_dest_ptr++) = (OPJ_INT32)(*
- (l_src_ptr++)); /* Copy only the data needed for the output image */
- }
+ for (j = 0; j < l_height_dest; ++j) {
+ memcpy(l_dest_ptr, l_src_ptr, l_width_dest * sizeof(OPJ_INT32));
+ l_dest_ptr += l_img_comp_dest->w;
+ l_src_ptr += src_data_stride;
+ }
+ }
- l_dest_ptr +=
- l_line_offset_dest; /* Move to the next place where we will write */
- l_src_ptr += l_line_offset_src ; /* Move to the next place where we will read */
- }
- } else {
- for (j = 0 ; j < l_height_dest ; ++j) {
- for (k = 0 ; k < l_width_dest ; ++k) {
- *(l_dest_ptr++) = (OPJ_INT32)((*(l_src_ptr++)) & 0xff);
- }
- l_dest_ptr += l_line_offset_dest;
- l_src_ptr += l_line_offset_src;
- }
- }
+ }
- l_src_ptr +=
- l_end_offset_src; /* Move to the end of this component-part of the input buffer */
- p_data = (OPJ_BYTE*)
- l_src_ptr; /* Keep the current position for the next component-part */
- }
- break;
- case 2: {
- OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_data;
- l_src_ptr += l_start_offset_src;
+ return OPJ_TRUE;
+}
- if (l_img_comp_src->sgnd) {
- for (j = 0; j < l_height_dest; ++j) {
- for (k = 0; k < l_width_dest; ++k) {
- OPJ_INT16 val;
- memcpy(&val, l_src_ptr, sizeof(val));
- l_src_ptr ++;
- *(l_dest_ptr++) = val;
- }
+static OPJ_BOOL opj_j2k_update_image_dimensions(opj_image_t* p_image,
+ opj_event_mgr_t * p_manager)
+{
+ OPJ_UINT32 it_comp;
+ OPJ_INT32 l_comp_x1, l_comp_y1;
+ opj_image_comp_t* l_img_comp = NULL;
- l_dest_ptr += l_line_offset_dest;
- l_src_ptr += l_line_offset_src ;
- }
- } else {
- for (j = 0; j < l_height_dest; ++j) {
- for (k = 0; k < l_width_dest; ++k) {
- OPJ_INT16 val;
- memcpy(&val, l_src_ptr, sizeof(val));
- l_src_ptr ++;
- *(l_dest_ptr++) = val & 0xffff;
- }
+ l_img_comp = p_image->comps;
+ for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
+ OPJ_INT32 l_h, l_w;
- l_dest_ptr += l_line_offset_dest;
- l_src_ptr += l_line_offset_src ;
- }
- }
+ l_img_comp->x0 = opj_uint_ceildiv(p_image->x0, l_img_comp->dx);
+ l_img_comp->y0 = opj_uint_ceildiv(p_image->y0, l_img_comp->dy);
+ l_comp_x1 = opj_int_ceildiv((OPJ_INT32)p_image->x1, (OPJ_INT32)l_img_comp->dx);
+ l_comp_y1 = opj_int_ceildiv((OPJ_INT32)p_image->y1, (OPJ_INT32)l_img_comp->dy);
- l_src_ptr += l_end_offset_src;
- p_data = (OPJ_BYTE*) l_src_ptr;
+ l_w = opj_int_ceildivpow2(l_comp_x1, (OPJ_INT32)l_img_comp->factor)
+ - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->x0, (OPJ_INT32)l_img_comp->factor);
+ if (l_w < 0) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Size x of the decoded component image is incorrect (comp[%d].w=%d).\n",
+ it_comp, l_w);
+ return OPJ_FALSE;
}
- break;
- case 4: {
- OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_data;
- l_src_ptr += l_start_offset_src;
+ l_img_comp->w = (OPJ_UINT32)l_w;
- for (j = 0; j < l_height_dest; ++j) {
- memcpy(l_dest_ptr, l_src_ptr, l_width_dest * sizeof(OPJ_INT32));
- l_dest_ptr += l_width_dest + l_line_offset_dest;
- l_src_ptr += l_width_dest + l_line_offset_src ;
- }
+ l_h = opj_int_ceildivpow2(l_comp_y1, (OPJ_INT32)l_img_comp->factor)
+ - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->y0, (OPJ_INT32)l_img_comp->factor);
+ if (l_h < 0) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Size y of the decoded component image is incorrect (comp[%d].h=%d).\n",
+ it_comp, l_h);
+ return OPJ_FALSE;
+ }
+ l_img_comp->h = (OPJ_UINT32)l_h;
+
+ l_img_comp++;
+ }
+
+ return OPJ_TRUE;
+}
+
+OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k,
+ OPJ_UINT32 numcomps,
+ const OPJ_UINT32* comps_indices,
+ opj_event_mgr_t * p_manager)
+{
+ OPJ_UINT32 i;
+ OPJ_BOOL* already_mapped;
+
+ if (p_j2k->m_private_image == NULL) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "opj_read_header() should be called before "
+ "opj_set_decoded_components().\n");
+ return OPJ_FALSE;
+ }
- l_src_ptr += l_end_offset_src;
- p_data = (OPJ_BYTE*) l_src_ptr;
+ already_mapped = (OPJ_BOOL*) opj_calloc(sizeof(OPJ_BOOL),
+ p_j2k->m_private_image->numcomps);
+ if (already_mapped == NULL) {
+ return OPJ_FALSE;
+ }
+
+ for (i = 0; i < numcomps; i++) {
+ if (comps_indices[i] >= p_j2k->m_private_image->numcomps) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Invalid component index: %u\n",
+ comps_indices[i]);
+ opj_free(already_mapped);
+ return OPJ_FALSE;
}
- break;
+ if (already_mapped[comps_indices[i]]) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Component index %u used several times\n",
+ comps_indices[i]);
+ opj_free(already_mapped);
+ return OPJ_FALSE;
}
+ already_mapped[comps_indices[i]] = OPJ_TRUE;
+ }
+ opj_free(already_mapped);
- ++l_img_comp_dest;
- ++l_img_comp_src;
- ++l_tilec;
+ opj_free(p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode);
+ if (numcomps) {
+ p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode =
+ (OPJ_UINT32*) opj_malloc(numcomps * sizeof(OPJ_UINT32));
+ if (p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode == NULL) {
+ p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode = 0;
+ return OPJ_FALSE;
+ }
+ memcpy(p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode,
+ comps_indices,
+ numcomps * sizeof(OPJ_UINT32));
+ } else {
+ p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode = NULL;
}
+ p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode = numcomps;
return OPJ_TRUE;
}
+
OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k,
opj_image_t* p_image,
OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
@@ -9104,18 +9324,27 @@ OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k,
{
opj_cp_t * l_cp = &(p_j2k->m_cp);
opj_image_t * l_image = p_j2k->m_private_image;
-
+ OPJ_BOOL ret;
OPJ_UINT32 it_comp;
- OPJ_INT32 l_comp_x1, l_comp_y1;
- opj_image_comp_t* l_img_comp = NULL;
+ if (p_j2k->m_cp.tw == 1 && p_j2k->m_cp.th == 1 &&
+ p_j2k->m_cp.tcps[0].m_data != NULL) {
+ /* In the case of a single-tiled image whose codestream we have already */
+ /* ingested, go on */
+ }
/* Check if we are read the main header */
- if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) {
+ else if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) {
opj_event_msg(p_manager, EVT_ERROR,
- "Need to decode the main header before begin to decode the remaining codestream");
+ "Need to decode the main header before begin to decode the remaining codestream.\n");
return OPJ_FALSE;
}
+ /* Update the comps[].factor member of the output image with the one */
+ /* of m_reduce */
+ for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
+ p_image->comps[it_comp].factor = p_j2k->m_cp.m_specific_param.m_dec.m_reduce;
+ }
+
if (!p_start_x && !p_start_y && !p_end_x && !p_end_y) {
opj_event_msg(p_manager, EVT_INFO,
"No decoded area parameters, set the decoded area to the whole image\n");
@@ -9125,7 +9354,12 @@ OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k,
p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
- return OPJ_TRUE;
+ p_image->x0 = l_image->x0;
+ p_image->y0 = l_image->y0;
+ p_image->x1 = l_image->x1;
+ p_image->y1 = l_image->y1;
+
+ return opj_j2k_update_image_dimensions(p_image, p_manager);
}
/* ----- */
@@ -9155,7 +9389,7 @@ OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k,
}
/* Up */
- if (p_start_x < 0) {
+ if (p_start_y < 0) {
opj_event_msg(p_manager, EVT_ERROR,
"Up position of the decoded area (region_y0=%d) should be >= 0.\n",
p_start_y);
@@ -9227,42 +9461,14 @@ OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k,
p_j2k->m_specific_param.m_decoder.m_discard_tiles = 1;
- l_img_comp = p_image->comps;
- for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
- OPJ_INT32 l_h, l_w;
-
- l_img_comp->x0 = opj_uint_ceildiv(p_image->x0, l_img_comp->dx);
- l_img_comp->y0 = opj_uint_ceildiv(p_image->y0, l_img_comp->dy);
- l_comp_x1 = opj_int_ceildiv((OPJ_INT32)p_image->x1, (OPJ_INT32)l_img_comp->dx);
- l_comp_y1 = opj_int_ceildiv((OPJ_INT32)p_image->y1, (OPJ_INT32)l_img_comp->dy);
-
- l_w = opj_int_ceildivpow2(l_comp_x1, (OPJ_INT32)l_img_comp->factor)
- - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->x0, (OPJ_INT32)l_img_comp->factor);
- if (l_w < 0) {
- opj_event_msg(p_manager, EVT_ERROR,
- "Size x of the decoded component image is incorrect (comp[%d].w=%d).\n",
- it_comp, l_w);
- return OPJ_FALSE;
- }
- l_img_comp->w = (OPJ_UINT32)l_w;
-
- l_h = opj_int_ceildivpow2(l_comp_y1, (OPJ_INT32)l_img_comp->factor)
- - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->y0, (OPJ_INT32)l_img_comp->factor);
- if (l_h < 0) {
- opj_event_msg(p_manager, EVT_ERROR,
- "Size y of the decoded component image is incorrect (comp[%d].h=%d).\n",
- it_comp, l_h);
- return OPJ_FALSE;
- }
- l_img_comp->h = (OPJ_UINT32)l_h;
+ ret = opj_j2k_update_image_dimensions(p_image, p_manager);
- l_img_comp++;
+ if (ret) {
+ opj_event_msg(p_manager, EVT_INFO, "Setting decoding area to %d,%d,%d,%d\n",
+ p_image->x0, p_image->y0, p_image->x1, p_image->y1);
}
- opj_event_msg(p_manager, EVT_INFO, "Setting decoding area to %d,%d,%d,%d\n",
- p_image->x0, p_image->y0, p_image->x1, p_image->y1);
-
- return OPJ_TRUE;
+ return ret;
}
opj_j2k_t* opj_j2k_create_decompress(void)
@@ -9552,9 +9758,10 @@ static OPJ_BOOL opj_j2k_read_SPCod_SPCoc(opj_j2k_t *p_j2k,
/* If user wants to remove more resolutions than the codestream contains, return error */
if (l_cp->m_specific_param.m_dec.m_reduce >= l_tccp->numresolutions) {
opj_event_msg(p_manager, EVT_ERROR,
- "Error decoding component %d.\nThe number of resolutions to remove is higher than the number "
- "of resolutions of this component\nModify the cp_reduce parameter.\n\n",
- compno);
+ "Error decoding component %d.\nThe number of resolutions "
+ "to remove (%d) is greater or equal than the number "
+ "of resolutions of this component (%d)\nModify the cp_reduce parameter.\n\n",
+ compno, l_cp->m_specific_param.m_dec.m_reduce, l_tccp->numresolutions);
p_j2k->m_specific_param.m_decoder.m_state |=
0x8000;/* FIXME J2K_DEC_STATE_ERR;*/
return OPJ_FALSE;
@@ -10448,10 +10655,8 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
{
OPJ_BOOL l_go_on = OPJ_TRUE;
OPJ_UINT32 l_current_tile_no;
- OPJ_UINT32 l_data_size, l_max_data_size;
OPJ_INT32 l_tile_x0, l_tile_y0, l_tile_x1, l_tile_y1;
OPJ_UINT32 l_nb_comps;
- OPJ_BYTE * l_current_data;
OPJ_UINT32 nr_tiles = 0;
/* Particular case for whole single tile decoding */
@@ -10461,12 +10666,11 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
p_j2k->m_output_image->x0 == 0 &&
p_j2k->m_output_image->y0 == 0 &&
p_j2k->m_output_image->x1 == p_j2k->m_cp.tdx &&
- p_j2k->m_output_image->y1 == p_j2k->m_cp.tdy &&
- p_j2k->m_output_image->comps[0].factor == 0) {
+ p_j2k->m_output_image->y1 == p_j2k->m_cp.tdy) {
OPJ_UINT32 i;
if (! opj_j2k_read_tile_header(p_j2k,
&l_current_tile_no,
- &l_data_size,
+ NULL,
&l_tile_x0, &l_tile_y0,
&l_tile_x1, &l_tile_y1,
&l_nb_comps,
@@ -10495,59 +10699,55 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
return OPJ_TRUE;
}
- l_current_data = (OPJ_BYTE*)opj_malloc(1000);
- if (! l_current_data) {
- opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tiles\n");
- return OPJ_FALSE;
- }
- l_max_data_size = 1000;
-
for (;;) {
- if (! opj_j2k_read_tile_header(p_j2k,
- &l_current_tile_no,
- &l_data_size,
- &l_tile_x0, &l_tile_y0,
- &l_tile_x1, &l_tile_y1,
- &l_nb_comps,
- &l_go_on,
- p_stream,
- p_manager)) {
- opj_free(l_current_data);
- return OPJ_FALSE;
- }
-
- if (! l_go_on) {
- break;
- }
-
- if (l_data_size > l_max_data_size) {
- OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data,
- l_data_size);
- if (! l_new_current_data) {
- opj_free(l_current_data);
- opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n",
- l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
+ if (p_j2k->m_cp.tw == 1 && p_j2k->m_cp.th == 1 &&
+ p_j2k->m_cp.tcps[0].m_data != NULL) {
+ l_current_tile_no = 0;
+ p_j2k->m_current_tile_number = 0;
+ p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_DATA;
+ } else {
+ if (! opj_j2k_read_tile_header(p_j2k,
+ &l_current_tile_no,
+ NULL,
+ &l_tile_x0, &l_tile_y0,
+ &l_tile_x1, &l_tile_y1,
+ &l_nb_comps,
+ &l_go_on,
+ p_stream,
+ p_manager)) {
return OPJ_FALSE;
}
- l_current_data = l_new_current_data;
- l_max_data_size = l_data_size;
+
+ if (! l_go_on) {
+ break;
+ }
}
- if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, l_current_data, l_data_size,
+ if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
p_stream, p_manager)) {
- opj_free(l_current_data);
opj_event_msg(p_manager, EVT_ERROR, "Failed to decode tile %d/%d\n",
l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
return OPJ_FALSE;
}
+
opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n",
l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
- if (! opj_j2k_update_image_data(p_j2k->m_tcd, l_current_data,
+ if (! opj_j2k_update_image_data(p_j2k->m_tcd,
p_j2k->m_output_image)) {
- opj_free(l_current_data);
return OPJ_FALSE;
}
+
+ if (p_j2k->m_cp.tw == 1 && p_j2k->m_cp.th == 1 &&
+ !(p_j2k->m_output_image->x0 == p_j2k->m_private_image->x0 &&
+ p_j2k->m_output_image->y0 == p_j2k->m_private_image->y0 &&
+ p_j2k->m_output_image->x1 == p_j2k->m_private_image->x1 &&
+ p_j2k->m_output_image->y1 == p_j2k->m_private_image->y1)) {
+ /* Keep current tcp data */
+ } else {
+ opj_j2k_tcp_data_destroy(&p_j2k->m_cp.tcps[l_current_tile_no]);
+ }
+
opj_event_msg(p_manager, EVT_INFO,
"Image data has been updated with tile %d.\n\n", l_current_tile_no + 1);
@@ -10560,8 +10760,6 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
}
}
- opj_free(l_current_data);
-
return OPJ_TRUE;
}
@@ -10594,24 +10792,14 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
OPJ_BOOL l_go_on = OPJ_TRUE;
OPJ_UINT32 l_current_tile_no;
OPJ_UINT32 l_tile_no_to_dec;
- OPJ_UINT32 l_data_size, l_max_data_size;
OPJ_INT32 l_tile_x0, l_tile_y0, l_tile_x1, l_tile_y1;
OPJ_UINT32 l_nb_comps;
- OPJ_BYTE * l_current_data;
OPJ_UINT32 l_nb_tiles;
OPJ_UINT32 i;
- l_current_data = (OPJ_BYTE*)opj_malloc(1000);
- if (! l_current_data) {
- opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode one tile\n");
- return OPJ_FALSE;
- }
- l_max_data_size = 1000;
-
/*Allocate and initialize some elements of codestrem index if not already done*/
if (!p_j2k->cstr_index->tile_index) {
if (!opj_j2k_allocate_tile_element_cstr_index(p_j2k)) {
- opj_free(l_current_data);
return OPJ_FALSE;
}
}
@@ -10626,7 +10814,6 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
if (!(opj_stream_read_seek(p_stream,
p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos + 2, p_manager))) {
opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
- opj_free(l_current_data);
return OPJ_FALSE;
}
} else {
@@ -10634,7 +10821,6 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
p_j2k->cstr_index->tile_index[l_tile_no_to_dec].tp_index[0].start_pos + 2,
p_manager))) {
opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
- opj_free(l_current_data);
return OPJ_FALSE;
}
}
@@ -10656,14 +10842,13 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
for (;;) {
if (! opj_j2k_read_tile_header(p_j2k,
&l_current_tile_no,
- &l_data_size,
+ NULL,
&l_tile_x0, &l_tile_y0,
&l_tile_x1, &l_tile_y1,
&l_nb_comps,
&l_go_on,
p_stream,
p_manager)) {
- opj_free(l_current_data);
return OPJ_FALSE;
}
@@ -10671,33 +10856,19 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
break;
}
- if (l_data_size > l_max_data_size) {
- OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data,
- l_data_size);
- if (! l_new_current_data) {
- opj_free(l_current_data);
- l_current_data = NULL;
- opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n",
- l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
- return OPJ_FALSE;
- }
- l_current_data = l_new_current_data;
- l_max_data_size = l_data_size;
- }
-
- if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, l_current_data, l_data_size,
+ if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
p_stream, p_manager)) {
- opj_free(l_current_data);
return OPJ_FALSE;
}
opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n",
l_current_tile_no + 1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
- if (! opj_j2k_update_image_data(p_j2k->m_tcd, l_current_data,
+ if (! opj_j2k_update_image_data(p_j2k->m_tcd,
p_j2k->m_output_image)) {
- opj_free(l_current_data);
return OPJ_FALSE;
}
+ opj_j2k_tcp_data_destroy(&p_j2k->m_cp.tcps[l_current_tile_no]);
+
opj_event_msg(p_manager, EVT_INFO,
"Image data has been updated with tile %d.\n\n", l_current_tile_no + 1);
@@ -10706,7 +10877,6 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
if (!(opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2,
p_manager))) {
opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n");
- opj_free(l_current_data);
return OPJ_FALSE;
}
break;
@@ -10718,8 +10888,6 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
}
- opj_free(l_current_data);
-
return OPJ_TRUE;
}
@@ -10742,20 +10910,105 @@ static OPJ_BOOL opj_j2k_setup_decoding_tile(opj_j2k_t *p_j2k,
return OPJ_TRUE;
}
+static OPJ_BOOL opj_j2k_move_data_from_codec_to_output_image(opj_j2k_t * p_j2k,
+ opj_image_t * p_image)
+{
+ OPJ_UINT32 compno;
+
+ /* Move data and copy one information from codec to output image*/
+ if (p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode > 0) {
+ opj_image_comp_t* newcomps =
+ (opj_image_comp_t*) opj_malloc(
+ p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode *
+ sizeof(opj_image_comp_t));
+ if (newcomps == NULL) {
+ opj_image_destroy(p_j2k->m_private_image);
+ p_j2k->m_private_image = NULL;
+ return OPJ_FALSE;
+ }
+ for (compno = 0; compno < p_image->numcomps; compno++) {
+ opj_image_data_free(p_image->comps[compno].data);
+ p_image->comps[compno].data = NULL;
+ }
+ for (compno = 0;
+ compno < p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode; compno++) {
+ OPJ_UINT32 src_compno =
+ p_j2k->m_specific_param.m_decoder.m_comps_indices_to_decode[compno];
+ memcpy(&(newcomps[compno]),
+ &(p_j2k->m_output_image->comps[src_compno]),
+ sizeof(opj_image_comp_t));
+ newcomps[compno].resno_decoded =
+ p_j2k->m_output_image->comps[src_compno].resno_decoded;
+ newcomps[compno].data = p_j2k->m_output_image->comps[src_compno].data;
+ p_j2k->m_output_image->comps[src_compno].data = NULL;
+ }
+ for (compno = 0; compno < p_image->numcomps; compno++) {
+ assert(p_j2k->m_output_image->comps[compno].data == NULL);
+ opj_image_data_free(p_j2k->m_output_image->comps[compno].data);
+ p_j2k->m_output_image->comps[compno].data = NULL;
+ }
+ p_image->numcomps = p_j2k->m_specific_param.m_decoder.m_numcomps_to_decode;
+ opj_free(p_image->comps);
+ p_image->comps = newcomps;
+ } else {
+ for (compno = 0; compno < p_image->numcomps; compno++) {
+ p_image->comps[compno].resno_decoded =
+ p_j2k->m_output_image->comps[compno].resno_decoded;
+ opj_image_data_free(p_image->comps[compno].data);
+ p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
+#if 0
+ char fn[256];
+ sprintf(fn, "/tmp/%d.raw", compno);
+ FILE *debug = fopen(fn, "wb");
+ fwrite(p_image->comps[compno].data, sizeof(OPJ_INT32),
+ p_image->comps[compno].w * p_image->comps[compno].h, debug);
+ fclose(debug);
+#endif
+ p_j2k->m_output_image->comps[compno].data = NULL;
+ }
+ }
+ return OPJ_TRUE;
+}
+
OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k,
opj_stream_private_t * p_stream,
opj_image_t * p_image,
opj_event_mgr_t * p_manager)
{
- OPJ_UINT32 compno;
-
if (!p_image) {
return OPJ_FALSE;
}
- p_j2k->m_output_image = opj_image_create0();
- if (!(p_j2k->m_output_image)) {
- return OPJ_FALSE;
+ /* Heuristics to detect sequence opj_read_header(), opj_set_decoded_resolution_factor() */
+ /* and finally opj_decode_image() without manual setting of comps[].factor */
+ /* We could potentially always execute it, if we don't allow people to do */
+ /* opj_read_header(), modify x0,y0,x1,y1 of returned image an call opj_decode_image() */
+ if (p_j2k->m_cp.m_specific_param.m_dec.m_reduce > 0 &&
+ p_j2k->m_private_image != NULL &&
+ p_j2k->m_private_image->numcomps > 0 &&
+ p_j2k->m_private_image->comps[0].factor ==
+ p_j2k->m_cp.m_specific_param.m_dec.m_reduce &&
+ p_image->numcomps > 0 &&
+ p_image->comps[0].factor == 0 &&
+ /* Don't mess with image dimension if the user has allocated it */
+ p_image->comps[0].data == NULL) {
+ OPJ_UINT32 it_comp;
+
+ /* Update the comps[].factor member of the output image with the one */
+ /* of m_reduce */
+ for (it_comp = 0; it_comp < p_image->numcomps; ++it_comp) {
+ p_image->comps[it_comp].factor = p_j2k->m_cp.m_specific_param.m_dec.m_reduce;
+ }
+ if (!opj_j2k_update_image_dimensions(p_image, p_manager)) {
+ return OPJ_FALSE;
+ }
+ }
+
+ if (p_j2k->m_output_image == NULL) {
+ p_j2k->m_output_image = opj_image_create0();
+ if (!(p_j2k->m_output_image)) {
+ return OPJ_FALSE;
+ }
}
opj_copy_image_header(p_image, p_j2k->m_output_image);
@@ -10772,22 +11025,7 @@ OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k,
}
/* Move data and copy one information from codec to output image*/
- for (compno = 0; compno < p_image->numcomps; compno++) {
- p_image->comps[compno].resno_decoded =
- p_j2k->m_output_image->comps[compno].resno_decoded;
- p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
-#if 0
- char fn[256];
- sprintf(fn, "/tmp/%d.raw", compno);
- FILE *debug = fopen(fn, "wb");
- fwrite(p_image->comps[compno].data, sizeof(OPJ_INT32),
- p_image->comps[compno].w * p_image->comps[compno].h, debug);
- fclose(debug);
-#endif
- p_j2k->m_output_image->comps[compno].data = NULL;
- }
-
- return OPJ_TRUE;
+ return opj_j2k_move_data_from_codec_to_output_image(p_j2k, p_image);
}
OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k,
@@ -10805,6 +11043,12 @@ OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k,
return OPJ_FALSE;
}
+ if (p_image->numcomps < p_j2k->m_private_image->numcomps) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Image has less components than codestream.\n");
+ return OPJ_FALSE;
+ }
+
if (/*(tile_index < 0) &&*/ (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th)) {
opj_event_msg(p_manager, EVT_ERROR,
"Tile index provided by the user is incorrect %d (max = %d) \n", tile_index,
@@ -10835,7 +11079,7 @@ OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k,
}
l_img_comp = p_image->comps;
- for (compno = 0; compno < p_image->numcomps; ++compno) {
+ for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno) {
OPJ_INT32 l_comp_x1, l_comp_y1;
l_img_comp->factor = p_j2k->m_private_image->comps[compno].factor;
@@ -10855,6 +11099,18 @@ OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k,
l_img_comp++;
}
+ if (p_image->numcomps > p_j2k->m_private_image->numcomps) {
+ /* Can happen when calling repeatdly opj_get_decoded_tile() on an
+ * image with a color palette, where color palette expansion is done
+ * later in jp2.c */
+ for (compno = p_j2k->m_private_image->numcomps; compno < p_image->numcomps;
+ ++compno) {
+ opj_image_data_free(p_image->comps[compno].data);
+ p_image->comps[compno].data = NULL;
+ }
+ p_image->numcomps = p_j2k->m_private_image->numcomps;
+ }
+
/* Destroy the previous output image*/
if (p_j2k->m_output_image) {
opj_image_destroy(p_j2k->m_output_image);
@@ -10882,20 +11138,7 @@ OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k,
}
/* Move data and copy one information from codec to output image*/
- for (compno = 0; compno < p_image->numcomps; compno++) {
- p_image->comps[compno].resno_decoded =
- p_j2k->m_output_image->comps[compno].resno_decoded;
-
- if (p_image->comps[compno].data) {
- opj_image_data_free(p_image->comps[compno].data);
- }
-
- p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
-
- p_j2k->m_output_image->comps[compno].data = NULL;
- }
-
- return OPJ_TRUE;
+ return opj_j2k_move_data_from_codec_to_output_image(p_j2k, p_image);
}
OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k,
@@ -10935,7 +11178,7 @@ OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k,
{
OPJ_UINT32 i, j;
OPJ_UINT32 l_nb_tiles;
- OPJ_UINT32 l_max_tile_size = 0, l_current_tile_size;
+ OPJ_SIZE_T l_max_tile_size = 0, l_current_tile_size;
OPJ_BYTE * l_current_data = 00;
OPJ_BOOL l_reuse_data = OPJ_FALSE;
opj_tcd_t* p_tcd = 00;
@@ -11001,6 +11244,12 @@ OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k,
l_current_data = l_new_current_data;
l_max_tile_size = l_current_tile_size;
}
+ if (l_current_data == NULL) {
+ /* Should not happen in practice, but will avoid Coverity to */
+ /* complain about a null pointer dereference */
+ assert(0);
+ return OPJ_FALSE;
+ }
/* copy image data (32 bit) to l_current_data as contiguous, all-component, zero offset buffer */
/* 32 bit components @ 8 bit precision get converted to 8 bit */
@@ -11470,7 +11719,8 @@ static OPJ_BOOL opj_j2k_write_first_tile_part(opj_j2k_t *p_j2k,
l_current_nb_bytes_written = 0;
l_begin_data = p_data;
- if (! opj_j2k_write_sot(p_j2k, p_data, &l_current_nb_bytes_written, p_stream,
+ if (! opj_j2k_write_sot(p_j2k, p_data, p_total_data_size,
+ &l_current_nb_bytes_written, p_stream,
p_manager)) {
return OPJ_FALSE;
}
@@ -11562,7 +11812,10 @@ static OPJ_BOOL opj_j2k_write_all_tile_parts(opj_j2k_t *p_j2k,
l_part_tile_size = 0;
l_begin_data = p_data;
- if (! opj_j2k_write_sot(p_j2k, p_data, &l_current_nb_bytes_written, p_stream,
+ if (! opj_j2k_write_sot(p_j2k, p_data,
+ p_total_data_size,
+ &l_current_nb_bytes_written,
+ p_stream,
p_manager)) {
return OPJ_FALSE;
}
@@ -11605,7 +11858,9 @@ static OPJ_BOOL opj_j2k_write_all_tile_parts(opj_j2k_t *p_j2k,
l_part_tile_size = 0;
l_begin_data = p_data;
- if (! opj_j2k_write_sot(p_j2k, p_data, &l_current_nb_bytes_written, p_stream,
+ if (! opj_j2k_write_sot(p_j2k, p_data,
+ p_total_data_size,
+ &l_current_nb_bytes_written, p_stream,
p_manager)) {
return OPJ_FALSE;
}
@@ -11793,7 +12048,7 @@ static OPJ_BOOL opj_j2k_init_info(opj_j2k_t *p_j2k,
}
/**
- * Creates a tile-coder decoder.
+ * Creates a tile-coder encoder.
*
* @param p_stream the stream to write data to.
* @param p_j2k J2K codec.
diff --git a/third_party/libopenjpeg20/j2k.h b/third_party/libopenjpeg20/j2k.h
index d61c96dba3..5d393c9813 100644
--- a/third_party/libopenjpeg20/j2k.h
+++ b/third_party/libopenjpeg20/j2k.h
@@ -107,6 +107,8 @@ The functions in J2K.C have for goal to read/write the several parts of the code
#endif /* USE_JPSEC */
/* <<UniPG */
+#define J2K_MAX_POCS 32 /**< Maximum number of POCs */
+
/* ----------------------------------------------------------------------- */
/**
@@ -251,7 +253,7 @@ typedef struct opj_tcp {
/** number of progression order changes */
OPJ_UINT32 numpocs;
/** progression order changes */
- opj_poc_t pocs[32];
+ opj_poc_t pocs[J2K_MAX_POCS];
/** number of ppt markers (reserved size) */
OPJ_UINT32 ppt_markers_count;
@@ -480,6 +482,10 @@ typedef struct opj_j2k_dec {
* SOD reader function. FIXME NOT USED for the moment
*/
OPJ_BOOL m_last_tile_part;
+
+ OPJ_UINT32 m_numcomps_to_decode;
+ OPJ_UINT32 *m_comps_indices_to_decode;
+
/** to tell that a tile can be decoded. */
OPJ_BITFIELD m_can_decode : 1;
OPJ_BITFIELD m_discard_tiles : 1;
@@ -617,7 +623,7 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
/**
Converts an enum type progression order to string type
*/
-char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order);
+const char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order);
/* ----------------------------------------------------------------------- */
/*@}*/
@@ -705,6 +711,21 @@ OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k,
opj_event_mgr_t * p_manager);
+/** Sets the indices of the components to decode.
+ *
+ * @param p_j2k the jpeg2000 codec.
+ * @param numcomps Number of components to decode.
+ * @param comps_indices Array of num_compts indices (numbering starting at 0)
+ * corresponding to the components to decode.
+ * @param p_manager Event manager
+ *
+ * @return OPJ_TRUE in case of success.
+ */
+OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k,
+ OPJ_UINT32 numcomps,
+ const OPJ_UINT32* comps_indices,
+ opj_event_mgr_t * p_manager);
+
/**
* Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
*
diff --git a/third_party/libopenjpeg20/jp2.c b/third_party/libopenjpeg20/jp2.c
index e7e2db8bb4..2374d459fd 100644
--- a/third_party/libopenjpeg20/jp2.c
+++ b/third_party/libopenjpeg20/jp2.c
@@ -162,7 +162,7 @@ static OPJ_BOOL opj_jp2_read_ftyp(opj_jp2_t *jp2,
opj_event_mgr_t * p_manager);
static OPJ_BOOL opj_jp2_skip_jp2c(opj_jp2_t *jp2,
- opj_stream_private_t *cio,
+ opj_stream_private_t *stream,
opj_event_mgr_t * p_manager);
/**
@@ -959,26 +959,35 @@ static OPJ_BOOL opj_jp2_check_color(opj_image_t *image, opj_jp2_color_t *color,
}
/* verify that no component is targeted more than once */
for (i = 0; i < nr_channels; i++) {
- OPJ_UINT16 pcol = cmap[i].pcol;
+ OPJ_BYTE mtyp = cmap[i].mtyp;
+ OPJ_BYTE pcol = cmap[i].pcol;
/* See ISO 15444-1 Table I.14 – MTYPi field values */
- if (cmap[i].mtyp != 0 && cmap[i].mtyp != 1) {
+ if (mtyp != 0 && mtyp != 1) {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid value for cmap[%d].mtyp = %d.\n", i,
- cmap[i].mtyp);
+ mtyp);
is_sane = OPJ_FALSE;
} else if (pcol >= nr_channels) {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid component/palette index for direct mapping %d.\n", pcol);
is_sane = OPJ_FALSE;
- } else if (pcol_usage[pcol] && cmap[i].mtyp != 0) {
+ } else if (pcol_usage[pcol] && mtyp == 1) {
opj_event_msg(p_manager, EVT_ERROR, "Component %d is mapped twice.\n", pcol);
is_sane = OPJ_FALSE;
- } else if (cmap[i].mtyp == 0 && cmap[i].pcol != 0) {
+ } else if (mtyp == 0 && pcol != 0) {
/* I.5.3.5 PCOL: If the value of the MTYP field for this channel is 0, then
* the value of this field shall be 0. */
opj_event_msg(p_manager, EVT_ERROR, "Direct use at #%d however pcol=%d.\n", i,
pcol);
is_sane = OPJ_FALSE;
+ } else if (mtyp == 1 && pcol != i) {
+ /* OpenJPEG implementation limitation. See assert(i == pcol); */
+ /* in opj_jp2_apply_pclr() */
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Implementation limitation: for palette mapping, "
+ "pcol[%d] should be equal to %d, but is equal "
+ "to %d.\n", i, i, pcol);
+ is_sane = OPJ_FALSE;
} else {
pcol_usage[pcol] = OPJ_TRUE;
}
@@ -1147,8 +1156,6 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
image->comps = new_comps;
image->numcomps = nr_channels;
- opj_jp2_free_pclr(color);
-
return OPJ_TRUE;
}/* apply_pclr() */
@@ -1615,6 +1622,11 @@ OPJ_BOOL opj_jp2_decode(opj_jp2_t *jp2,
return OPJ_FALSE;
}
+ if (jp2->j2k->m_specific_param.m_decoder.m_numcomps_to_decode) {
+ /* Bypass all JP2 component transforms */
+ return OPJ_TRUE;
+ }
+
if (!jp2->ignore_pclr_cmap_cdef) {
if (!opj_jp2_check_color(p_image, &(jp2->color), p_manager)) {
return OPJ_FALSE;
@@ -3078,6 +3090,16 @@ void opj_jp2_destroy(opj_jp2_t *jp2)
}
}
+OPJ_BOOL opj_jp2_set_decoded_components(opj_jp2_t *p_jp2,
+ OPJ_UINT32 numcomps,
+ const OPJ_UINT32* comps_indices,
+ opj_event_mgr_t * p_manager)
+{
+ return opj_j2k_set_decoded_components(p_jp2->j2k,
+ numcomps, comps_indices,
+ p_manager);
+}
+
OPJ_BOOL opj_jp2_set_decode_area(opj_jp2_t *p_jp2,
opj_image_t* p_image,
OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
@@ -3109,6 +3131,11 @@ OPJ_BOOL opj_jp2_get_tile(opj_jp2_t *p_jp2,
return OPJ_FALSE;
}
+ if (p_jp2->j2k->m_specific_param.m_decoder.m_numcomps_to_decode) {
+ /* Bypass all JP2 component transforms */
+ return OPJ_TRUE;
+ }
+
if (!opj_jp2_check_color(p_image, &(p_jp2->color), p_manager)) {
return OPJ_FALSE;
}
diff --git a/third_party/libopenjpeg20/jp2.h b/third_party/libopenjpeg20/jp2.h
index 3ff66ebecf..34abd5118e 100644
--- a/third_party/libopenjpeg20/jp2.h
+++ b/third_party/libopenjpeg20/jp2.h
@@ -235,6 +235,12 @@ Decoding parameters are returned in jp2->j2k->cp.
*/
void opj_jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters);
+/** Allocates worker threads for the compressor/decompressor.
+ *
+ * @param jp2 JP2 decompressor handle
+ * @param num_threads Number of threads.
+ * @return OPJ_TRUE in case of success.
+ */
OPJ_BOOL opj_jp2_set_threads(opj_jp2_t *jp2, OPJ_UINT32 num_threads);
/**
@@ -327,6 +333,21 @@ OPJ_BOOL opj_jp2_read_header(opj_stream_private_t *p_stream,
opj_image_t ** p_image,
opj_event_mgr_t * p_manager);
+/** Sets the indices of the components to decode.
+ *
+ * @param jp2 JP2 decompressor handle
+ * @param numcomps Number of components to decode.
+ * @param comps_indices Array of num_compts indices (numbering starting at 0)
+ * corresponding to the components to decode.
+ * @param p_manager Event manager;
+ *
+ * @return OPJ_TRUE in case of success.
+ */
+OPJ_BOOL opj_jp2_set_decoded_components(opj_jp2_t *jp2,
+ OPJ_UINT32 numcomps,
+ const OPJ_UINT32* comps_indices,
+ opj_event_mgr_t * p_manager);
+
/**
* Reads a tile header.
* @param p_jp2 the jpeg2000 codec.
diff --git a/third_party/libopenjpeg20/mct.c b/third_party/libopenjpeg20/mct.c
index 20b9e121b0..81ec223d85 100644
--- a/third_party/libopenjpeg20/mct.c
+++ b/third_party/libopenjpeg20/mct.c
@@ -80,7 +80,7 @@ void opj_mct_encode(
OPJ_INT32* OPJ_RESTRICT c0,
OPJ_INT32* OPJ_RESTRICT c1,
OPJ_INT32* OPJ_RESTRICT c2,
- OPJ_UINT32 n)
+ OPJ_SIZE_T n)
{
OPJ_SIZE_T i;
const OPJ_SIZE_T len = n;
@@ -122,7 +122,7 @@ void opj_mct_encode(
OPJ_INT32* OPJ_RESTRICT c0,
OPJ_INT32* OPJ_RESTRICT c1,
OPJ_INT32* OPJ_RESTRICT c2,
- OPJ_UINT32 n)
+ OPJ_SIZE_T n)
{
OPJ_SIZE_T i;
const OPJ_SIZE_T len = n;
@@ -149,7 +149,7 @@ void opj_mct_decode(
OPJ_INT32* OPJ_RESTRICT c0,
OPJ_INT32* OPJ_RESTRICT c1,
OPJ_INT32* OPJ_RESTRICT c2,
- OPJ_UINT32 n)
+ OPJ_SIZE_T n)
{
OPJ_SIZE_T i;
const OPJ_SIZE_T len = n;
@@ -184,7 +184,7 @@ void opj_mct_decode(
OPJ_INT32* OPJ_RESTRICT c0,
OPJ_INT32* OPJ_RESTRICT c1,
OPJ_INT32* OPJ_RESTRICT c2,
- OPJ_UINT32 n)
+ OPJ_SIZE_T n)
{
OPJ_UINT32 i;
for (i = 0; i < n; ++i) {
@@ -217,7 +217,7 @@ void opj_mct_encode_real(
OPJ_INT32* OPJ_RESTRICT c0,
OPJ_INT32* OPJ_RESTRICT c1,
OPJ_INT32* OPJ_RESTRICT c2,
- OPJ_UINT32 n)
+ OPJ_SIZE_T n)
{
OPJ_SIZE_T i;
const OPJ_SIZE_T len = n;
@@ -362,7 +362,7 @@ void opj_mct_encode_real(
OPJ_INT32* OPJ_RESTRICT c0,
OPJ_INT32* OPJ_RESTRICT c1,
OPJ_INT32* OPJ_RESTRICT c2,
- OPJ_UINT32 n)
+ OPJ_SIZE_T n)
{
OPJ_UINT32 i;
for (i = 0; i < n; ++i) {
@@ -389,7 +389,7 @@ void opj_mct_decode_real(
OPJ_FLOAT32* OPJ_RESTRICT c0,
OPJ_FLOAT32* OPJ_RESTRICT c1,
OPJ_FLOAT32* OPJ_RESTRICT c2,
- OPJ_UINT32 n)
+ OPJ_SIZE_T n)
{
OPJ_UINT32 i;
#ifdef USE_SSE
@@ -454,13 +454,13 @@ OPJ_FLOAT64 opj_mct_getnorm_real(OPJ_UINT32 compno)
OPJ_BOOL opj_mct_encode_custom(
OPJ_BYTE * pCodingdata,
- OPJ_UINT32 n,
+ OPJ_SIZE_T n,
OPJ_BYTE ** pData,
OPJ_UINT32 pNbComp,
OPJ_UINT32 isSigned)
{
OPJ_FLOAT32 * lMct = (OPJ_FLOAT32 *) pCodingdata;
- OPJ_UINT32 i;
+ OPJ_SIZE_T i;
OPJ_UINT32 j;
OPJ_UINT32 k;
OPJ_UINT32 lNbMatCoeff = pNbComp * pNbComp;
@@ -508,13 +508,13 @@ OPJ_BOOL opj_mct_encode_custom(
OPJ_BOOL opj_mct_decode_custom(
OPJ_BYTE * pDecodingData,
- OPJ_UINT32 n,
+ OPJ_SIZE_T n,
OPJ_BYTE ** pData,
OPJ_UINT32 pNbComp,
OPJ_UINT32 isSigned)
{
OPJ_FLOAT32 * lMct;
- OPJ_UINT32 i;
+ OPJ_SIZE_T i;
OPJ_UINT32 j;
OPJ_UINT32 k;
diff --git a/third_party/libopenjpeg20/mct.h b/third_party/libopenjpeg20/mct.h
index 0ed980e891..2e37ce7333 100644
--- a/third_party/libopenjpeg20/mct.h
+++ b/third_party/libopenjpeg20/mct.h
@@ -61,7 +61,7 @@ Apply a reversible multi-component transform to an image
@param n Number of samples for each component
*/
void opj_mct_encode(OPJ_INT32* OPJ_RESTRICT c0, OPJ_INT32* OPJ_RESTRICT c1,
- OPJ_INT32* OPJ_RESTRICT c2, OPJ_UINT32 n);
+ OPJ_INT32* OPJ_RESTRICT c2, OPJ_SIZE_T n);
/**
Apply a reversible multi-component inverse transform to an image
@param c0 Samples for luminance component
@@ -70,7 +70,7 @@ Apply a reversible multi-component inverse transform to an image
@param n Number of samples for each component
*/
void opj_mct_decode(OPJ_INT32* OPJ_RESTRICT c0, OPJ_INT32* OPJ_RESTRICT c1,
- OPJ_INT32* OPJ_RESTRICT c2, OPJ_UINT32 n);
+ OPJ_INT32* OPJ_RESTRICT c2, OPJ_SIZE_T n);
/**
Get norm of the basis function used for the reversible multi-component transform
@param compno Number of the component (0->Y, 1->U, 2->V)
@@ -86,7 +86,7 @@ Apply an irreversible multi-component transform to an image
@param n Number of samples for each component
*/
void opj_mct_encode_real(OPJ_INT32* OPJ_RESTRICT c0, OPJ_INT32* OPJ_RESTRICT c1,
- OPJ_INT32* OPJ_RESTRICT c2, OPJ_UINT32 n);
+ OPJ_INT32* OPJ_RESTRICT c2, OPJ_SIZE_T n);
/**
Apply an irreversible multi-component inverse transform to an image
@param c0 Samples for luminance component
@@ -95,7 +95,7 @@ Apply an irreversible multi-component inverse transform to an image
@param n Number of samples for each component
*/
void opj_mct_decode_real(OPJ_FLOAT32* OPJ_RESTRICT c0,
- OPJ_FLOAT32* OPJ_RESTRICT c1, OPJ_FLOAT32* OPJ_RESTRICT c2, OPJ_UINT32 n);
+ OPJ_FLOAT32* OPJ_RESTRICT c1, OPJ_FLOAT32* OPJ_RESTRICT c2, OPJ_SIZE_T n);
/**
Get norm of the basis function used for the irreversible multi-component transform
@param compno Number of the component (0->Y, 1->U, 2->V)
@@ -114,7 +114,7 @@ FIXME DOC
*/
OPJ_BOOL opj_mct_encode_custom(
OPJ_BYTE * p_coding_data,
- OPJ_UINT32 n,
+ OPJ_SIZE_T n,
OPJ_BYTE ** p_data,
OPJ_UINT32 p_nb_comp,
OPJ_UINT32 is_signed);
@@ -129,7 +129,7 @@ FIXME DOC
*/
OPJ_BOOL opj_mct_decode_custom(
OPJ_BYTE * pDecodingData,
- OPJ_UINT32 n,
+ OPJ_SIZE_T n,
OPJ_BYTE ** pData,
OPJ_UINT32 pNbComp,
OPJ_UINT32 isSigned);
diff --git a/third_party/libopenjpeg20/mqc.c b/third_party/libopenjpeg20/mqc.c
index 8f69e29e39..6299b171d8 100644
--- a/third_party/libopenjpeg20/mqc.c
+++ b/third_party/libopenjpeg20/mqc.c
@@ -79,7 +79,7 @@ static void opj_mqc_setbits(opj_mqc_t *mqc);
/* <summary> */
/* This array defines all the possible states for a context. */
/* </summary> */
-static opj_mqc_state_t mqc_states[47 * 2] = {
+static const opj_mqc_state_t mqc_states[47 * 2] = {
{0x5601, 0, &mqc_states[2], &mqc_states[3]},
{0x5601, 1, &mqc_states[3], &mqc_states[2]},
{0x3401, 0, &mqc_states[4], &mqc_states[12]},
diff --git a/third_party/libopenjpeg20/mqc.h b/third_party/libopenjpeg20/mqc.h
index ac3aff108e..69a2a79dc0 100644
--- a/third_party/libopenjpeg20/mqc.h
+++ b/third_party/libopenjpeg20/mqc.h
@@ -61,9 +61,9 @@ typedef struct opj_mqc_state {
/** the Most Probable Symbol (0 or 1) */
OPJ_UINT32 mps;
/** next state if the next encoded symbol is the MPS */
- struct opj_mqc_state *nmps;
+ const struct opj_mqc_state *nmps;
/** next state if the next encoded symbol is the LPS */
- struct opj_mqc_state *nlps;
+ const struct opj_mqc_state *nlps;
} opj_mqc_state_t;
#define MQC_NUMCTXS 19
@@ -87,9 +87,9 @@ typedef struct opj_mqc {
/** pointer to the end of the buffer */
OPJ_BYTE *end;
/** Array of contexts */
- opj_mqc_state_t *ctxs[MQC_NUMCTXS];
+ const opj_mqc_state_t *ctxs[MQC_NUMCTXS];
/** Active context */
- opj_mqc_state_t **curctx;
+ const opj_mqc_state_t **curctx;
/* lut_ctxno_zc shifted by (1 << 9) * bandno */
const OPJ_BYTE* lut_ctxno_zc_orient;
/** Original value of the 2 bytes at end[0] and end[1] */
diff --git a/third_party/libopenjpeg20/mqc_inl.h b/third_party/libopenjpeg20/mqc_inl.h
index d95d9492ae..310a3287fd 100644
--- a/third_party/libopenjpeg20/mqc_inl.h
+++ b/third_party/libopenjpeg20/mqc_inl.h
@@ -157,7 +157,7 @@ static INLINE OPJ_UINT32 opj_mqc_raw_decode(opj_mqc_t *mqc)
}
#define DOWNLOAD_MQC_VARIABLES(mqc, curctx, c, a, ct) \
- register opj_mqc_state_t **curctx = mqc->curctx; \
+ register const opj_mqc_state_t **curctx = mqc->curctx; \
register OPJ_UINT32 c = mqc->c; \
register OPJ_UINT32 a = mqc->a; \
register OPJ_UINT32 ct = mqc->ct
diff --git a/third_party/libopenjpeg20/openjpeg.c b/third_party/libopenjpeg20/openjpeg.c
index 4e649a74f3..7b12303423 100644
--- a/third_party/libopenjpeg20/openjpeg.c
+++ b/third_party/libopenjpeg20/openjpeg.c
@@ -245,6 +245,12 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
OPJ_UINT32 res_factor,
struct opj_event_mgr * p_manager)) opj_j2k_set_decoded_resolution_factor;
+ l_codec->m_codec_data.m_decompression.opj_set_decoded_components =
+ (OPJ_BOOL(*)(void * p_codec,
+ OPJ_UINT32 numcomps,
+ const OPJ_UINT32 * comps_indices,
+ struct opj_event_mgr * p_manager)) opj_j2k_set_decoded_components;
+
l_codec->opj_set_threads =
(OPJ_BOOL(*)(void * p_codec, OPJ_UINT32 num_threads)) opj_j2k_set_threads;
@@ -327,6 +333,12 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
OPJ_UINT32 res_factor,
opj_event_mgr_t * p_manager)) opj_jp2_set_decoded_resolution_factor;
+ l_codec->m_codec_data.m_decompression.opj_set_decoded_components =
+ (OPJ_BOOL(*)(void * p_codec,
+ OPJ_UINT32 numcomps,
+ const OPJ_UINT32 * comps_indices,
+ struct opj_event_mgr * p_manager)) opj_jp2_set_decoded_components;
+
l_codec->opj_set_threads =
(OPJ_BOOL(*)(void * p_codec, OPJ_UINT32 num_threads)) opj_jp2_set_threads;
@@ -426,6 +438,36 @@ OPJ_BOOL OPJ_CALLCONV opj_read_header(opj_stream_t *p_stream,
return OPJ_FALSE;
}
+
+OPJ_BOOL OPJ_CALLCONV opj_set_decoded_components(opj_codec_t *p_codec,
+ OPJ_UINT32 numcomps,
+ const OPJ_UINT32* comps_indices,
+ OPJ_BOOL apply_color_transforms)
+{
+ if (p_codec) {
+ opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
+
+ if (! l_codec->is_decompressor) {
+ opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
+ "Codec provided to the opj_set_decoded_components function is not a decompressor handler.\n");
+ return OPJ_FALSE;
+ }
+
+ if (apply_color_transforms) {
+ opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
+ "apply_color_transforms = OPJ_TRUE is not supported.\n");
+ return OPJ_FALSE;
+ }
+
+ return l_codec->m_codec_data.m_decompression.opj_set_decoded_components(
+ l_codec->m_codec,
+ numcomps,
+ comps_indices,
+ &(l_codec->m_event_mgr));
+ }
+ return OPJ_FALSE;
+}
+
OPJ_BOOL OPJ_CALLCONV opj_decode(opj_codec_t *p_codec,
opj_stream_t *p_stream,
opj_image_t* p_image)
diff --git a/third_party/libopenjpeg20/openjpeg.h b/third_party/libopenjpeg20/openjpeg.h
index e8dbe4ff7e..c119e8f897 100644
--- a/third_party/libopenjpeg20/openjpeg.h
+++ b/third_party/libopenjpeg20/openjpeg.h
@@ -381,9 +381,12 @@ typedef struct opj_cparameters {
OPJ_UINT32 numpocs;
/** number of layers */
int tcp_numlayers;
- /** rates of layers - might be subsequently limited by the max_cs_size field */
+ /** rates of layers - might be subsequently limited by the max_cs_size field.
+ * Should be decreasing. 1 can be
+ * used as last value to indicate the last layer is lossless. */
float tcp_rates[100];
- /** different psnr for successive layers */
+ /** different psnr for successive layers. Should be increasing. 0 can be
+ * used as last value to indicate the last layer is lossless. */
float tcp_distoratio[100];
/** number of resolutions */
int numresolution;
@@ -871,9 +874,9 @@ typedef struct opj_tccp_info {
OPJ_UINT32 csty;
/** number of resolutions */
OPJ_UINT32 numresolutions;
- /** code-blocks width */
+ /** log2 of code-blocks width */
OPJ_UINT32 cblkw;
- /** code-blocks height */
+ /** log2 of code-blocks height */
OPJ_UINT32 cblkh;
/** code-block coding style */
OPJ_UINT32 cblksty;
@@ -1337,9 +1340,50 @@ OPJ_API OPJ_BOOL OPJ_CALLCONV opj_read_header(opj_stream_t *p_stream,
opj_codec_t *p_codec,
opj_image_t **p_image);
+
+/** Restrict the number of components to decode.
+ *
+ * This function should be called after opj_read_header().
+ *
+ * This function enables to restrict the set of decoded components to the
+ * specified indices.
+ * Note that the current implementation (apply_color_transforms == OPJ_FALSE)
+ * is such that neither the multi-component transform at codestream level,
+ * nor JP2 channel transformations will be applied.
+ * Consequently the indices are relative to the codestream.
+ *
+ * Note: opj_decode_tile_data() should not be used together with opj_set_decoded_components().
+ *
+ * @param p_codec the jpeg2000 codec to read.
+ * @param numcomps Size of the comps_indices array.
+ * @param comps_indices Array of numcomps values representing the indices
+ * of the components to decode (relative to the
+ * codestream, starting at 0)
+ * @param apply_color_transforms Whether multi-component transform at codestream level
+ * or JP2 channel transformations should be applied.
+ * Currently this parameter should be set to OPJ_FALSE.
+ * Setting it to OPJ_TRUE will result in an error.
+ *
+ * @return OPJ_TRUE in case of success.
+ */
+OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_decoded_components(opj_codec_t *p_codec,
+ OPJ_UINT32 numcomps,
+ const OPJ_UINT32* comps_indices,
+ OPJ_BOOL apply_color_transforms);
+
/**
* Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
*
+ * The coordinates passed to this function should be expressed in the reference grid,
+ * that is to say at the highest resolution level, even if requesting the image at lower
+ * resolution levels.
+ *
+ * Generally opj_set_decode_area() should be followed by opj_decode(), and the
+ * codec cannot be re-used.
+ * In the particular case of an image made of a single tile, several sequences of
+ * calls to opoj_set_decode_area() and opj_decode() are allowed, and will bring
+ * performance improvements when reading an image by chunks.
+ *
* @param p_codec the jpeg2000 codec.
* @param p_image the decoded image previously setted by opj_read_header
* @param p_start_x the left position of the rectangle to decode (in image coordinates).
@@ -1443,6 +1487,8 @@ OPJ_API OPJ_BOOL OPJ_CALLCONV opj_read_tile_header(opj_codec_t *p_codec,
* Reads a tile data. This function is compulsory and allows one to decode tile data. opj_read_tile_header should be called before.
* The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
*
+ * Note: opj_decode_tile_data() should not be used together with opj_set_decoded_components().
+ *
* @param p_codec the jpeg2000 codec.
* @param p_tile_index the index of the tile being decoded, this should be the value set by opj_read_tile_header.
* @param p_data pointer to a memory block that will hold the decoded data.
diff --git a/third_party/libopenjpeg20/opj_codec.h b/third_party/libopenjpeg20/opj_codec.h
index 2dbeac9635..b962b12163 100644
--- a/third_party/libopenjpeg20/opj_codec.h
+++ b/third_party/libopenjpeg20/opj_codec.h
@@ -111,6 +111,11 @@ typedef struct opj_codec_private {
OPJ_UINT32 res_factor,
opj_event_mgr_t * p_manager);
+ /** Set the decoded components */
+ OPJ_BOOL(*opj_set_decoded_components)(void * p_codec,
+ OPJ_UINT32 num_comps,
+ const OPJ_UINT32* comps_indices,
+ opj_event_mgr_t * p_manager);
} m_decompression;
/**
diff --git a/third_party/libopenjpeg20/opj_config.h b/third_party/libopenjpeg20/opj_config.h
index efa08a121a..7384541439 100644
--- a/third_party/libopenjpeg20/opj_config.h
+++ b/third_party/libopenjpeg20/opj_config.h
@@ -12,5 +12,5 @@
/* Version number. */
#define OPJ_VERSION_MAJOR 2
-#define OPJ_VERSION_MINOR 2
+#define OPJ_VERSION_MINOR 3
#define OPJ_VERSION_BUILD 0
diff --git a/third_party/libopenjpeg20/opj_config_private.h b/third_party/libopenjpeg20/opj_config_private.h
index ecd02e7359..81b449d2e2 100644
--- a/third_party/libopenjpeg20/opj_config_private.h
+++ b/third_party/libopenjpeg20/opj_config_private.h
@@ -7,7 +7,7 @@
/* create opj_config_private.h for CMake */
#define OPJ_HAVE_INTTYPES_H 1
-#define OPJ_PACKAGE_VERSION "2.2.0"
+#define OPJ_PACKAGE_VERSION "2.3.0"
/* Not used by openjp2*/
/*#define HAVE_MEMORY_H 1*/
diff --git a/third_party/libopenjpeg20/opj_includes.h b/third_party/libopenjpeg20/opj_includes.h
index b33e63ceff..0a8628c96b 100644
--- a/third_party/libopenjpeg20/opj_includes.h
+++ b/third_party/libopenjpeg20/opj_includes.h
@@ -216,6 +216,8 @@ static INLINE long opj_lrintf(float f)
/* Type to use for bit-fields in internal headers */
typedef unsigned int OPJ_BITFIELD;
+#define OPJ_UNUSED(x) (void)x
+
#include "opj_inttypes.h"
#include "opj_clock.h"
#include "opj_malloc.h"
@@ -243,6 +245,7 @@ typedef unsigned int OPJ_BITFIELD;
#include "t2.h"
#include "mct.h"
#include "opj_intmath.h"
+#include "sparse_array.h"
#ifdef USE_JPIP
#include "cidx_manager.h"
diff --git a/third_party/libopenjpeg20/opj_intmath.h b/third_party/libopenjpeg20/opj_intmath.h
index cf97c15b12..ad13597661 100644
--- a/third_party/libopenjpeg20/opj_intmath.h
+++ b/third_party/libopenjpeg20/opj_intmath.h
@@ -96,6 +96,15 @@ static INLINE OPJ_UINT32 opj_uint_adds(OPJ_UINT32 a, OPJ_UINT32 b)
}
/**
+ Get the saturated difference of two unsigned integers
+ @return Returns saturated sum of a-b
+ */
+static INLINE OPJ_UINT32 opj_uint_subs(OPJ_UINT32 a, OPJ_UINT32 b)
+{
+ return (a >= b) ? a - b : 0;
+}
+
+/**
Clamp an integer inside an interval
@return
<ul>
@@ -115,6 +124,28 @@ static INLINE OPJ_INT32 opj_int_clamp(OPJ_INT32 a, OPJ_INT32 min,
}
return a;
}
+
+/**
+Clamp an integer inside an interval
+@return
+<ul>
+<li>Returns a if (min < a < max)
+<li>Returns max if (a > max)
+<li>Returns min if (a < min)
+</ul>
+*/
+static INLINE OPJ_INT64 opj_int64_clamp(OPJ_INT64 a, OPJ_INT64 min,
+ OPJ_INT64 max)
+{
+ if (a < min) {
+ return min;
+ }
+ if (a > max) {
+ return max;
+ }
+ return a;
+}
+
/**
@return Get absolute value of integer
*/
diff --git a/third_party/libopenjpeg20/sparse_array.c b/third_party/libopenjpeg20/sparse_array.c
new file mode 100644
index 0000000000..73192924ed
--- /dev/null
+++ b/third_party/libopenjpeg20/sparse_array.c
@@ -0,0 +1,346 @@
+/*
+ * The copyright in this software is being made available under the 2-clauses
+ * BSD License, included below. This software may be subject to other third
+ * party and contributor rights, including patent rights, and no such rights
+ * are granted under this license.
+ *
+ * Copyright (c) 2017, IntoPix SA <contact@intopix.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+
+struct opj_sparse_array_int32 {
+ OPJ_UINT32 width;
+ OPJ_UINT32 height;
+ OPJ_UINT32 block_width;
+ OPJ_UINT32 block_height;
+ OPJ_UINT32 block_count_hor;
+ OPJ_UINT32 block_count_ver;
+ OPJ_INT32** data_blocks;
+};
+
+opj_sparse_array_int32_t* opj_sparse_array_int32_create(OPJ_UINT32 width,
+ OPJ_UINT32 height,
+ OPJ_UINT32 block_width,
+ OPJ_UINT32 block_height)
+{
+ opj_sparse_array_int32_t* sa;
+
+ if (width == 0 || height == 0 || block_width == 0 || block_height == 0) {
+ return NULL;
+ }
+ if (block_width > ((OPJ_UINT32)~0U) / block_height / sizeof(OPJ_INT32)) {
+ return NULL;
+ }
+
+ sa = (opj_sparse_array_int32_t*) opj_calloc(1,
+ sizeof(opj_sparse_array_int32_t));
+ sa->width = width;
+ sa->height = height;
+ sa->block_width = block_width;
+ sa->block_height = block_height;
+ sa->block_count_hor = opj_uint_ceildiv(width, block_width);
+ sa->block_count_ver = opj_uint_ceildiv(height, block_height);
+ if (sa->block_count_hor > ((OPJ_UINT32)~0U) / sa->block_count_ver) {
+ opj_free(sa);
+ return NULL;
+ }
+ sa->data_blocks = (OPJ_INT32**) opj_calloc(sizeof(OPJ_INT32*),
+ sa->block_count_hor * sa->block_count_ver);
+ if (sa->data_blocks == NULL) {
+ opj_free(sa);
+ return NULL;
+ }
+
+ return sa;
+}
+
+void opj_sparse_array_int32_free(opj_sparse_array_int32_t* sa)
+{
+ if (sa) {
+ OPJ_UINT32 i;
+ for (i = 0; i < sa->block_count_hor * sa->block_count_ver; i++) {
+ if (sa->data_blocks[i]) {
+ opj_free(sa->data_blocks[i]);
+ }
+ }
+ opj_free(sa->data_blocks);
+ opj_free(sa);
+ }
+}
+
+OPJ_BOOL opj_sparse_array_is_region_valid(const opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 x0,
+ OPJ_UINT32 y0,
+ OPJ_UINT32 x1,
+ OPJ_UINT32 y1)
+{
+ return !(x0 >= sa->width || x1 <= x0 || x1 > sa->width ||
+ y0 >= sa->height || y1 <= y0 || y1 > sa->height);
+}
+
+static OPJ_BOOL opj_sparse_array_int32_read_or_write(
+ const opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 x0,
+ OPJ_UINT32 y0,
+ OPJ_UINT32 x1,
+ OPJ_UINT32 y1,
+ OPJ_INT32* buf,
+ OPJ_UINT32 buf_col_stride,
+ OPJ_UINT32 buf_line_stride,
+ OPJ_BOOL forgiving,
+ OPJ_BOOL is_read_op)
+{
+ OPJ_UINT32 y, block_y;
+ OPJ_UINT32 y_incr = 0;
+ const OPJ_UINT32 block_width = sa->block_width;
+
+ if (!opj_sparse_array_is_region_valid(sa, x0, y0, x1, y1)) {
+ return forgiving;
+ }
+
+ block_y = y0 / sa->block_height;
+ for (y = y0; y < y1; block_y ++, y += y_incr) {
+ OPJ_UINT32 x, block_x;
+ OPJ_UINT32 x_incr = 0;
+ OPJ_UINT32 block_y_offset;
+ y_incr = (y == y0) ? sa->block_height - (y0 % sa->block_height) :
+ sa->block_height;
+ block_y_offset = sa->block_height - y_incr;
+ y_incr = opj_uint_min(y_incr, y1 - y);
+ block_x = x0 / block_width;
+ for (x = x0; x < x1; block_x ++, x += x_incr) {
+ OPJ_UINT32 j;
+ OPJ_UINT32 block_x_offset;
+ OPJ_INT32* src_block;
+ x_incr = (x == x0) ? block_width - (x0 % block_width) : block_width;
+ block_x_offset = block_width - x_incr;
+ x_incr = opj_uint_min(x_incr, x1 - x);
+ src_block = sa->data_blocks[block_y * sa->block_count_hor + block_x];
+ if (is_read_op) {
+ if (src_block == NULL) {
+ if (buf_col_stride == 1) {
+ OPJ_INT32* dest_ptr = buf + (y - y0) * (OPJ_SIZE_T)buf_line_stride +
+ (x - x0) * buf_col_stride;
+ for (j = 0; j < y_incr; j++) {
+ memset(dest_ptr, 0, sizeof(OPJ_INT32) * x_incr);
+ dest_ptr += buf_line_stride;
+ }
+ } else {
+ OPJ_INT32* dest_ptr = buf + (y - y0) * (OPJ_SIZE_T)buf_line_stride +
+ (x - x0) * buf_col_stride;
+ for (j = 0; j < y_incr; j++) {
+ OPJ_UINT32 k;
+ for (k = 0; k < x_incr; k++) {
+ dest_ptr[k * buf_col_stride] = 0;
+ }
+ dest_ptr += buf_line_stride;
+ }
+ }
+ } else {
+ const OPJ_INT32* OPJ_RESTRICT src_ptr = src_block + block_y_offset *
+ (OPJ_SIZE_T)block_width + block_x_offset;
+ if (buf_col_stride == 1) {
+ OPJ_INT32* OPJ_RESTRICT dest_ptr = buf + (y - y0) * (OPJ_SIZE_T)buf_line_stride
+ +
+ (x - x0) * buf_col_stride;
+ if (x_incr == 4) {
+ /* Same code as general branch, but the compiler */
+ /* can have an efficient memcpy() */
+ (void)(x_incr); /* trick to silent cppcheck duplicateBranch warning */
+ for (j = 0; j < y_incr; j++) {
+ memcpy(dest_ptr, src_ptr, sizeof(OPJ_INT32) * x_incr);
+ dest_ptr += buf_line_stride;
+ src_ptr += block_width;
+ }
+ } else {
+ for (j = 0; j < y_incr; j++) {
+ memcpy(dest_ptr, src_ptr, sizeof(OPJ_INT32) * x_incr);
+ dest_ptr += buf_line_stride;
+ src_ptr += block_width;
+ }
+ }
+ } else {
+ OPJ_INT32* OPJ_RESTRICT dest_ptr = buf + (y - y0) * (OPJ_SIZE_T)buf_line_stride
+ +
+ (x - x0) * buf_col_stride;
+ if (x_incr == 1) {
+ for (j = 0; j < y_incr; j++) {
+ *dest_ptr = *src_ptr;
+ dest_ptr += buf_line_stride;
+ src_ptr += block_width;
+ }
+ } else if (y_incr == 1 && buf_col_stride == 2) {
+ OPJ_UINT32 k;
+ for (k = 0; k < (x_incr & ~3U); k += 4) {
+ dest_ptr[k * buf_col_stride] = src_ptr[k];
+ dest_ptr[(k + 1) * buf_col_stride] = src_ptr[k + 1];
+ dest_ptr[(k + 2) * buf_col_stride] = src_ptr[k + 2];
+ dest_ptr[(k + 3) * buf_col_stride] = src_ptr[k + 3];
+ }
+ for (; k < x_incr; k++) {
+ dest_ptr[k * buf_col_stride] = src_ptr[k];
+ }
+ } else if (x_incr >= 8 && buf_col_stride == 8) {
+ for (j = 0; j < y_incr; j++) {
+ OPJ_UINT32 k;
+ for (k = 0; k < (x_incr & ~3U); k += 4) {
+ dest_ptr[k * buf_col_stride] = src_ptr[k];
+ dest_ptr[(k + 1) * buf_col_stride] = src_ptr[k + 1];
+ dest_ptr[(k + 2) * buf_col_stride] = src_ptr[k + 2];
+ dest_ptr[(k + 3) * buf_col_stride] = src_ptr[k + 3];
+ }
+ for (; k < x_incr; k++) {
+ dest_ptr[k * buf_col_stride] = src_ptr[k];
+ }
+ dest_ptr += buf_line_stride;
+ src_ptr += block_width;
+ }
+ } else {
+ /* General case */
+ for (j = 0; j < y_incr; j++) {
+ OPJ_UINT32 k;
+ for (k = 0; k < x_incr; k++) {
+ dest_ptr[k * buf_col_stride] = src_ptr[k];
+ }
+ dest_ptr += buf_line_stride;
+ src_ptr += block_width;
+ }
+ }
+ }
+ }
+ } else {
+ if (src_block == NULL) {
+ src_block = (OPJ_INT32*) opj_calloc(1,
+ sa->block_width * sa->block_height * sizeof(OPJ_INT32));
+ if (src_block == NULL) {
+ return OPJ_FALSE;
+ }
+ sa->data_blocks[block_y * sa->block_count_hor + block_x] = src_block;
+ }
+
+ if (buf_col_stride == 1) {
+ OPJ_INT32* OPJ_RESTRICT dest_ptr = src_block + block_y_offset *
+ (OPJ_SIZE_T)block_width + block_x_offset;
+ const OPJ_INT32* OPJ_RESTRICT src_ptr = buf + (y - y0) *
+ (OPJ_SIZE_T)buf_line_stride + (x - x0) * buf_col_stride;
+ if (x_incr == 4) {
+ /* Same code as general branch, but the compiler */
+ /* can have an efficient memcpy() */
+ (void)(x_incr); /* trick to silent cppcheck duplicateBranch warning */
+ for (j = 0; j < y_incr; j++) {
+ memcpy(dest_ptr, src_ptr, sizeof(OPJ_INT32) * x_incr);
+ dest_ptr += block_width;
+ src_ptr += buf_line_stride;
+ }
+ } else {
+ for (j = 0; j < y_incr; j++) {
+ memcpy(dest_ptr, src_ptr, sizeof(OPJ_INT32) * x_incr);
+ dest_ptr += block_width;
+ src_ptr += buf_line_stride;
+ }
+ }
+ } else {
+ OPJ_INT32* OPJ_RESTRICT dest_ptr = src_block + block_y_offset *
+ (OPJ_SIZE_T)block_width + block_x_offset;
+ const OPJ_INT32* OPJ_RESTRICT src_ptr = buf + (y - y0) *
+ (OPJ_SIZE_T)buf_line_stride + (x - x0) * buf_col_stride;
+ if (x_incr == 1) {
+ for (j = 0; j < y_incr; j++) {
+ *dest_ptr = *src_ptr;
+ src_ptr += buf_line_stride;
+ dest_ptr += block_width;
+ }
+ } else if (x_incr >= 8 && buf_col_stride == 8) {
+ for (j = 0; j < y_incr; j++) {
+ OPJ_UINT32 k;
+ for (k = 0; k < (x_incr & ~3U); k += 4) {
+ dest_ptr[k] = src_ptr[k * buf_col_stride];
+ dest_ptr[k + 1] = src_ptr[(k + 1) * buf_col_stride];
+ dest_ptr[k + 2] = src_ptr[(k + 2) * buf_col_stride];
+ dest_ptr[k + 3] = src_ptr[(k + 3) * buf_col_stride];
+ }
+ for (; k < x_incr; k++) {
+ dest_ptr[k] = src_ptr[k * buf_col_stride];
+ }
+ src_ptr += buf_line_stride;
+ dest_ptr += block_width;
+ }
+ } else {
+ /* General case */
+ for (j = 0; j < y_incr; j++) {
+ OPJ_UINT32 k;
+ for (k = 0; k < x_incr; k++) {
+ dest_ptr[k] = src_ptr[k * buf_col_stride];
+ }
+ src_ptr += buf_line_stride;
+ dest_ptr += block_width;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return OPJ_TRUE;
+}
+
+OPJ_BOOL opj_sparse_array_int32_read(const opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 x0,
+ OPJ_UINT32 y0,
+ OPJ_UINT32 x1,
+ OPJ_UINT32 y1,
+ OPJ_INT32* dest,
+ OPJ_UINT32 dest_col_stride,
+ OPJ_UINT32 dest_line_stride,
+ OPJ_BOOL forgiving)
+{
+ return opj_sparse_array_int32_read_or_write(
+ (opj_sparse_array_int32_t*)sa, x0, y0, x1, y1,
+ dest,
+ dest_col_stride,
+ dest_line_stride,
+ forgiving,
+ OPJ_TRUE);
+}
+
+OPJ_BOOL opj_sparse_array_int32_write(opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 x0,
+ OPJ_UINT32 y0,
+ OPJ_UINT32 x1,
+ OPJ_UINT32 y1,
+ const OPJ_INT32* src,
+ OPJ_UINT32 src_col_stride,
+ OPJ_UINT32 src_line_stride,
+ OPJ_BOOL forgiving)
+{
+ return opj_sparse_array_int32_read_or_write(sa, x0, y0, x1, y1,
+ (OPJ_INT32*)src,
+ src_col_stride,
+ src_line_stride,
+ forgiving,
+ OPJ_FALSE);
+}
diff --git a/third_party/libopenjpeg20/sparse_array.h b/third_party/libopenjpeg20/sparse_array.h
new file mode 100644
index 0000000000..fd927eaa0b
--- /dev/null
+++ b/third_party/libopenjpeg20/sparse_array.h
@@ -0,0 +1,141 @@
+/*
+ * The copyright in this software is being made available under the 2-clauses
+ * BSD License, included below. This software may be subject to other third
+ * party and contributor rights, including patent rights, and no such rights
+ * are granted under this license.
+ *
+ * Copyright (c) 2017, IntoPix SA <contact@intopix.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "opj_includes.h"
+
+#ifndef OPJ_SPARSE_ARRAY_H
+#define OPJ_SPARSE_ARRAY_H
+/**
+@file sparse_array.h
+@brief Sparse array management
+
+The functions in this file manage sparse arrays. Sparse arrays are arrays with
+potential big dimensions, but with very few samples actually set. Such sparse
+arrays require allocating a low amount of memory, by just allocating memory
+for blocks of the array that are set. The minimum memory allocation unit is a
+a block. There is a trade-off to pick up an appropriate dimension for blocks.
+If it is too big, and pixels set are far from each other, too much memory will
+be used. If blocks are too small, the book-keeping costs of blocks will raise.
+*/
+
+/** @defgroup SPARSE_ARRAY SPARSE ARRAYS - Sparse arrays */
+/*@{*/
+
+/** Opaque type for sparse arrays that contain int32 values */
+typedef struct opj_sparse_array_int32 opj_sparse_array_int32_t;
+
+/** Creates a new sparse array.
+ * @param width total width of the array.
+ * @param height total height of the array
+ * @param block_width width of a block.
+ * @param block_height height of a block.
+ * @return a new sparse array instance, or NULL in case of failure.
+ */
+opj_sparse_array_int32_t* opj_sparse_array_int32_create(OPJ_UINT32 width,
+ OPJ_UINT32 height,
+ OPJ_UINT32 block_width,
+ OPJ_UINT32 block_height);
+
+/** Frees a sparse array.
+ * @param sa sparse array instance.
+ */
+void opj_sparse_array_int32_free(opj_sparse_array_int32_t* sa);
+
+/** Returns whether region bounds are valid (non empty and within array bounds)
+ * @param sa sparse array instance.
+ * @param x0 left x coordinate of the region.
+ * @param y0 top x coordinate of the region.
+ * @param x1 right x coordinate (not included) of the region. Must be greater than x0.
+ * @param y1 bottom y coordinate (not included) of the region. Must be greater than y0.
+ * @return OPJ_TRUE or OPJ_FALSE.
+ */
+OPJ_BOOL opj_sparse_array_is_region_valid(const opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 x0,
+ OPJ_UINT32 y0,
+ OPJ_UINT32 x1,
+ OPJ_UINT32 y1);
+
+/** Read the content of a rectangular region of the sparse array into a
+ * user buffer.
+ *
+ * Regions not written with opj_sparse_array_int32_write() are read as 0.
+ *
+ * @param sa sparse array instance.
+ * @param x0 left x coordinate of the region to read in the sparse array.
+ * @param y0 top x coordinate of the region to read in the sparse array.
+ * @param x1 right x coordinate (not included) of the region to read in the sparse array. Must be greater than x0.
+ * @param y1 bottom y coordinate (not included) of the region to read in the sparse array. Must be greater than y0.
+ * @param dest user buffer to fill. Must be at least sizeof(int32) * ( (y1 - y0 - 1) * dest_line_stride + (x1 - x0 - 1) * dest_col_stride + 1) bytes large.
+ * @param dest_col_stride spacing (in elements, not in bytes) in x dimension between consecutive elements of the user buffer.
+ * @param dest_line_stride spacing (in elements, not in bytes) in y dimension between consecutive elements of the user buffer.
+ * @param forgiving if set to TRUE and the region is invalid, OPJ_TRUE will still be returned.
+ * @return OPJ_TRUE in case of success.
+ */
+OPJ_BOOL opj_sparse_array_int32_read(const opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 x0,
+ OPJ_UINT32 y0,
+ OPJ_UINT32 x1,
+ OPJ_UINT32 y1,
+ OPJ_INT32* dest,
+ OPJ_UINT32 dest_col_stride,
+ OPJ_UINT32 dest_line_stride,
+ OPJ_BOOL forgiving);
+
+
+/** Write the content of a rectangular region into the sparse array from a
+ * user buffer.
+ *
+ * Blocks intersecting the region are allocated, if not already done.
+ *
+ * @param sa sparse array instance.
+ * @param x0 left x coordinate of the region to write into the sparse array.
+ * @param y0 top x coordinate of the region to write into the sparse array.
+ * @param x1 right x coordinate (not included) of the region to write into the sparse array. Must be greater than x0.
+ * @param y1 bottom y coordinate (not included) of the region to write into the sparse array. Must be greater than y0.
+ * @param src user buffer to fill. Must be at least sizeof(int32) * ( (y1 - y0 - 1) * src_line_stride + (x1 - x0 - 1) * src_col_stride + 1) bytes large.
+ * @param src_col_stride spacing (in elements, not in bytes) in x dimension between consecutive elements of the user buffer.
+ * @param src_line_stride spacing (in elements, not in bytes) in y dimension between consecutive elements of the user buffer.
+ * @param forgiving if set to TRUE and the region is invalid, OPJ_TRUE will still be returned.
+ * @return OPJ_TRUE in case of success.
+ */
+OPJ_BOOL opj_sparse_array_int32_write(opj_sparse_array_int32_t* sa,
+ OPJ_UINT32 x0,
+ OPJ_UINT32 y0,
+ OPJ_UINT32 x1,
+ OPJ_UINT32 y1,
+ const OPJ_INT32* src,
+ OPJ_UINT32 src_col_stride,
+ OPJ_UINT32 src_line_stride,
+ OPJ_BOOL forgiving);
+
+/*@}*/
+
+#endif /* OPJ_SPARSE_ARRAY_H */
diff --git a/third_party/libopenjpeg20/t1.c b/third_party/libopenjpeg20/t1.c
index bd1a880025..76744380f7 100644
--- a/third_party/libopenjpeg20/t1.c
+++ b/third_party/libopenjpeg20/t1.c
@@ -38,7 +38,20 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
+#define OPJ_SKIP_POISON
#include "opj_includes.h"
+
+#ifdef __SSE__
+#include <xmmintrin.h>
+#endif
+#ifdef __SSE2__
+#include <emmintrin.h>
+#endif
+
+#if defined(__GNUC__)
+#pragma GCC poison malloc calloc realloc free
+#endif
+
#include "t1_luts.h"
/** @defgroup T1 T1 - Implementation of the tier-1 coding */
@@ -335,7 +348,7 @@ static INLINE void opj_t1_enc_sigpass_step(opj_t1_t *t1,
if ((flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U))) == 0U &&
(flags & (T1_SIGMA_NEIGHBOURS << (ci * 3U))) != 0U) {
OPJ_UINT32 ctxt1 = opj_t1_getctxno_zc(mqc, flags >> (ci * 3U));
- v = opj_int_abs(*datap) & one ? 1 : 0;
+ v = (opj_int_abs(*datap) & one) ? 1 : 0;
#ifdef DEBUG_ENC_SIG
fprintf(stderr, " ctxt1=%d\n", ctxt1);
#endif
@@ -722,7 +735,7 @@ static INLINE void opj_t1_enc_refpass_step(opj_t1_t *t1,
OPJ_UINT32 ctxt = opj_t1_getctxno_mag(shift_flags);
*nmsedec += opj_t1_getnmsedec_ref((OPJ_UINT32)opj_int_abs(*datap),
(OPJ_UINT32)bpno);
- v = opj_int_abs(*datap) & one ? 1 : 0;
+ v = (opj_int_abs(*datap) & one) ? 1 : 0;
#ifdef DEBUG_ENC_REF
fprintf(stderr, " ctxt=%d\n", ctxt);
#endif
@@ -1052,6 +1065,7 @@ static void opj_t1_enc_clnpass_step(
for (ci = runlen; ci < lim; ++ci) {
OPJ_UINT32 vsc;
opj_flag_t flags;
+ OPJ_UINT32 ctxt1;
flags = *flagsp;
@@ -1060,12 +1074,12 @@ static void opj_t1_enc_clnpass_step(
}
if (!(flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U)))) {
- OPJ_UINT32 ctxt1 = opj_t1_getctxno_zc(mqc, flags >> (ci * 3U));
+ ctxt1 = opj_t1_getctxno_zc(mqc, flags >> (ci * 3U));
#ifdef DEBUG_ENC_CLN
printf(" ctxt1=%d\n", ctxt1);
#endif
opj_mqc_setcurctx(mqc, ctxt1);
- v = opj_int_abs(*datap) & one ? 1 : 0;
+ v = (opj_int_abs(*datap) & one) ? 1 : 0;
opj_mqc_encode(mqc, v);
if (v) {
OPJ_UINT32 ctxt2, spb;
@@ -1426,44 +1440,27 @@ static OPJ_BOOL opj_t1_allocate_buffers(
OPJ_UINT32 w,
OPJ_UINT32 h)
{
- size_t flagssize;
+ OPJ_UINT32 flagssize;
OPJ_UINT32 flags_stride;
+ /* No risk of overflow. Prior checks ensure those assert are met */
+ /* They are per the specification */
+ assert(w <= 1024);
+ assert(h <= 1024);
+ assert(w * h <= 4096);
+
/* encoder uses tile buffer, so no need to allocate */
if (!t1->encoder) {
- size_t datasize;
-
-#if (SIZE_MAX / 0xFFFFFFFFU) < 0xFFFFFFFFU /* UINT32_MAX */
- /* Overflow check */
- if ((w > 0U) && ((size_t)h > (SIZE_MAX / (size_t)w))) {
- /* FIXME event manager error callback */
- return OPJ_FALSE;
- }
-#endif
- datasize = (size_t)w * h;
+ OPJ_UINT32 datasize = w * h;
- /* Overflow check */
- if (datasize > (SIZE_MAX / sizeof(OPJ_INT32))) {
- /* FIXME event manager error callback */
- return OPJ_FALSE;
- }
-
- if (datasize > (size_t)t1->datasize) {
+ if (datasize > t1->datasize) {
opj_aligned_free(t1->data);
t1->data = (OPJ_INT32*) opj_aligned_malloc(datasize * sizeof(OPJ_INT32));
if (!t1->data) {
/* FIXME event manager error callback */
return OPJ_FALSE;
}
-#if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
- /* TODO remove this if t1->datasize type changes to size_t */
- /* Overflow check */
- if (datasize > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
- /* FIXME event manager error callback */
- return OPJ_FALSE;
- }
-#endif
- t1->datasize = (OPJ_UINT32)datasize;
+ t1->datasize = datasize;
}
/* memset first arg is declared to never be null by gcc */
if (t1->data != NULL) {
@@ -1471,40 +1468,18 @@ static OPJ_BOOL opj_t1_allocate_buffers(
}
}
- /* Overflow check */
- if (w > (0xFFFFFFFFU /* UINT32_MAX */ - 2U)) {
- /* FIXME event manager error callback */
- return OPJ_FALSE;
- }
flags_stride = w + 2U; /* can't be 0U */
-#if (SIZE_MAX - 3U) < 0xFFFFFFFFU /* UINT32_MAX */
- /* Overflow check */
- if (h > (0xFFFFFFFFU /* UINT32_MAX */ - 3U)) {
- /* FIXME event manager error callback */
- return OPJ_FALSE;
- }
-#endif
flagssize = (h + 3U) / 4U + 2U;
- /* Overflow check */
- if (flagssize > (SIZE_MAX / (size_t)flags_stride)) {
- /* FIXME event manager error callback */
- return OPJ_FALSE;
- }
- flagssize *= (size_t)flags_stride;
+ flagssize *= flags_stride;
{
- /* BIG FAT XXX */
opj_flag_t* p;
OPJ_UINT32 x;
OPJ_UINT32 flags_height = (h + 3U) / 4U;
- if (flagssize > (size_t)t1->flagssize) {
- /* Overflow check */
- if (flagssize > (SIZE_MAX / sizeof(opj_flag_t))) {
- /* FIXME event manager error callback */
- return OPJ_FALSE;
- }
+ if (flagssize > t1->flagssize) {
+
opj_aligned_free(t1->flags);
t1->flags = (opj_flag_t*) opj_aligned_malloc(flagssize * sizeof(
opj_flag_t));
@@ -1512,16 +1487,8 @@ static OPJ_BOOL opj_t1_allocate_buffers(
/* FIXME event manager error callback */
return OPJ_FALSE;
}
-#if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
- /* TODO remove this if t1->flagssize type changes to size_t */
- /* Overflow check */
- if (flagssize > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
- /* FIXME event manager error callback */
- return OPJ_FALSE;
- }
-#endif
}
- t1->flagssize = (OPJ_UINT32)flagssize;
+ t1->flagssize = flagssize;
memset(t1->flags, 0, flagssize * sizeof(opj_flag_t));
@@ -1610,6 +1577,7 @@ void opj_t1_destroy(opj_t1_t *p_t1)
}
typedef struct {
+ OPJ_BOOL whole_tile_decoding;
OPJ_UINT32 resno;
opj_tcd_cblk_dec_t* cblk;
opj_tcd_band_t* band;
@@ -1643,12 +1611,44 @@ static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
OPJ_UINT32 tile_w;
job = (opj_t1_cblk_decode_processing_job_t*) user_data;
- resno = job->resno;
+
cblk = job->cblk;
+
+ if (!job->whole_tile_decoding) {
+ cblk_w = (OPJ_UINT32)(cblk->x1 - cblk->x0);
+ cblk_h = (OPJ_UINT32)(cblk->y1 - cblk->y0);
+
+ cblk->decoded_data = (OPJ_INT32*)opj_aligned_malloc(cblk_w * cblk_h * sizeof(
+ OPJ_INT32));
+ if (cblk->decoded_data == NULL) {
+ if (job->p_manager_mutex) {
+ opj_mutex_lock(job->p_manager_mutex);
+ }
+ opj_event_msg(job->p_manager, EVT_ERROR,
+ "Cannot allocate cblk->decoded_data\n");
+ if (job->p_manager_mutex) {
+ opj_mutex_unlock(job->p_manager_mutex);
+ }
+ *(job->pret) = OPJ_FALSE;
+ opj_free(job);
+ return;
+ }
+ /* Zero-init required */
+ memset(cblk->decoded_data, 0, cblk_w * cblk_h * sizeof(OPJ_INT32));
+ } else if (cblk->decoded_data) {
+ /* Not sure if that code path can happen, but better be */
+ /* safe than sorry */
+ opj_aligned_free(cblk->decoded_data);
+ cblk->decoded_data = NULL;
+ }
+
+ resno = job->resno;
band = job->band;
tilec = job->tilec;
tccp = job->tccp;
- tile_w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
+ tile_w = (OPJ_UINT32)(tilec->resolutions[tilec->minimum_num_resolutions - 1].x1
+ -
+ tilec->resolutions[tilec->minimum_num_resolutions - 1].x0);
if (!*(job->pret)) {
opj_free(job);
@@ -1687,7 +1687,7 @@ static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
y += pres->y1 - pres->y0;
}
- datap = t1->data;
+ datap = cblk->decoded_data ? cblk->decoded_data : t1->data;
cblk_w = t1->w;
cblk_h = t1->h;
@@ -1712,9 +1712,49 @@ static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
}
}
}
- if (tccp->qmfbid == 1) {
- OPJ_INT32* OPJ_RESTRICT tiledp = &tilec->data[(OPJ_UINT32)y * tile_w +
- (OPJ_UINT32)x];
+
+ /* Both can be non NULL if for example decoding a full tile and then */
+ /* partially a tile. In which case partial decoding should be the */
+ /* priority */
+ assert((cblk->decoded_data != NULL) || (tilec->data != NULL));
+
+ if (cblk->decoded_data) {
+ OPJ_UINT32 cblk_size = cblk_w * cblk_h;
+ if (tccp->qmfbid == 1) {
+ for (i = 0; i < cblk_size; ++i) {
+ datap[i] /= 2;
+ }
+ } else { /* if (tccp->qmfbid == 0) */
+ i = 0;
+#ifdef __SSE2__
+ {
+ const __m128 xmm_stepsize = _mm_set1_ps(band->stepsize);
+ for (; i < (cblk_size & ~15U); i += 16) {
+ __m128 xmm0_data = _mm_cvtepi32_ps(_mm_load_si128((__m128i * const)(
+ datap + 0)));
+ __m128 xmm1_data = _mm_cvtepi32_ps(_mm_load_si128((__m128i * const)(
+ datap + 4)));
+ __m128 xmm2_data = _mm_cvtepi32_ps(_mm_load_si128((__m128i * const)(
+ datap + 8)));
+ __m128 xmm3_data = _mm_cvtepi32_ps(_mm_load_si128((__m128i * const)(
+ datap + 12)));
+ _mm_store_ps((float*)(datap + 0), _mm_mul_ps(xmm0_data, xmm_stepsize));
+ _mm_store_ps((float*)(datap + 4), _mm_mul_ps(xmm1_data, xmm_stepsize));
+ _mm_store_ps((float*)(datap + 8), _mm_mul_ps(xmm2_data, xmm_stepsize));
+ _mm_store_ps((float*)(datap + 12), _mm_mul_ps(xmm3_data, xmm_stepsize));
+ datap += 16;
+ }
+ }
+#endif
+ for (; i < cblk_size; ++i) {
+ OPJ_FLOAT32 tmp = ((OPJ_FLOAT32)(*datap)) * band->stepsize;
+ memcpy(datap, &tmp, sizeof(tmp));
+ datap++;
+ }
+ }
+ } else if (tccp->qmfbid == 1) {
+ OPJ_INT32* OPJ_RESTRICT tiledp = &tilec->data[(OPJ_SIZE_T)y * tile_w +
+ (OPJ_SIZE_T)x];
for (j = 0; j < cblk_h; ++j) {
i = 0;
for (; i < (cblk_w & ~(OPJ_UINT32)3U); i += 4U) {
@@ -1722,19 +1762,19 @@ static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
OPJ_INT32 tmp1 = datap[(j * cblk_w) + i + 1U];
OPJ_INT32 tmp2 = datap[(j * cblk_w) + i + 2U];
OPJ_INT32 tmp3 = datap[(j * cblk_w) + i + 3U];
- ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 0U] = tmp0 / 2;
- ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 1U] = tmp1 / 2;
- ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 2U] = tmp2 / 2;
- ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 3U] = tmp3 / 2;
+ ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i + 0U] = tmp0 / 2;
+ ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i + 1U] = tmp1 / 2;
+ ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i + 2U] = tmp2 / 2;
+ ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i + 3U] = tmp3 / 2;
}
for (; i < cblk_w; ++i) {
OPJ_INT32 tmp = datap[(j * cblk_w) + i];
- ((OPJ_INT32*)tiledp)[(j * tile_w) + i] = tmp / 2;
+ ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i] = tmp / 2;
}
}
} else { /* if (tccp->qmfbid == 0) */
- OPJ_FLOAT32* OPJ_RESTRICT tiledp = (OPJ_FLOAT32*) &tilec->data[(OPJ_UINT32)y *
- tile_w + (OPJ_UINT32)x];
+ OPJ_FLOAT32* OPJ_RESTRICT tiledp = (OPJ_FLOAT32*) &tilec->data[(OPJ_SIZE_T)y *
+ tile_w + (OPJ_SIZE_T)x];
for (j = 0; j < cblk_h; ++j) {
OPJ_FLOAT32* OPJ_RESTRICT tiledp2 = tiledp;
for (i = 0; i < cblk_w; ++i) {
@@ -1751,7 +1791,7 @@ static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
}
-void opj_t1_decode_cblks(opj_thread_pool_t* tp,
+void opj_t1_decode_cblks(opj_tcd_t* tcd,
volatile OPJ_BOOL* pret,
opj_tcd_tilecomp_t* tilec,
opj_tccp_t* tccp,
@@ -1760,8 +1800,14 @@ void opj_t1_decode_cblks(opj_thread_pool_t* tp,
OPJ_BOOL check_pterm
)
{
+ opj_thread_pool_t* tp = tcd->thread_pool;
OPJ_UINT32 resno, bandno, precno, cblkno;
+#ifdef DEBUG_VERBOSE
+ OPJ_UINT32 codeblocks_decoded = 0;
+ printf("Enter opj_t1_decode_cblks()\n");
+#endif
+
for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
opj_tcd_resolution_t* res = &tilec->resolutions[resno];
@@ -1771,16 +1817,77 @@ void opj_t1_decode_cblks(opj_thread_pool_t* tp,
for (precno = 0; precno < res->pw * res->ph; ++precno) {
opj_tcd_precinct_t* precinct = &band->precincts[precno];
+ if (!opj_tcd_is_subband_area_of_interest(tcd,
+ tilec->compno,
+ resno,
+ band->bandno,
+ (OPJ_UINT32)precinct->x0,
+ (OPJ_UINT32)precinct->y0,
+ (OPJ_UINT32)precinct->x1,
+ (OPJ_UINT32)precinct->y1)) {
+ for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
+ opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
+ if (cblk->decoded_data) {
+#ifdef DEBUG_VERBOSE
+ printf("Discarding codeblock %d,%d at resno=%d, bandno=%d\n",
+ cblk->x0, cblk->y0, resno, bandno);
+#endif
+ opj_aligned_free(cblk->decoded_data);
+ cblk->decoded_data = NULL;
+ }
+ }
+ continue;
+ }
+
for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
opj_t1_cblk_decode_processing_job_t* job;
+ if (!opj_tcd_is_subband_area_of_interest(tcd,
+ tilec->compno,
+ resno,
+ band->bandno,
+ (OPJ_UINT32)cblk->x0,
+ (OPJ_UINT32)cblk->y0,
+ (OPJ_UINT32)cblk->x1,
+ (OPJ_UINT32)cblk->y1)) {
+ if (cblk->decoded_data) {
+#ifdef DEBUG_VERBOSE
+ printf("Discarding codeblock %d,%d at resno=%d, bandno=%d\n",
+ cblk->x0, cblk->y0, resno, bandno);
+#endif
+ opj_aligned_free(cblk->decoded_data);
+ cblk->decoded_data = NULL;
+ }
+ continue;
+ }
+
+ if (!tcd->whole_tile_decoding) {
+ OPJ_UINT32 cblk_w = (OPJ_UINT32)(cblk->x1 - cblk->x0);
+ OPJ_UINT32 cblk_h = (OPJ_UINT32)(cblk->y1 - cblk->y0);
+ if (cblk->decoded_data != NULL) {
+#ifdef DEBUG_VERBOSE
+ printf("Reusing codeblock %d,%d at resno=%d, bandno=%d\n",
+ cblk->x0, cblk->y0, resno, bandno);
+#endif
+ continue;
+ }
+ if (cblk_w == 0 || cblk_h == 0) {
+ continue;
+ }
+#ifdef DEBUG_VERBOSE
+ printf("Decoding codeblock %d,%d at resno=%d, bandno=%d\n",
+ cblk->x0, cblk->y0, resno, bandno);
+#endif
+ }
+
job = (opj_t1_cblk_decode_processing_job_t*) opj_calloc(1,
sizeof(opj_t1_cblk_decode_processing_job_t));
if (!job) {
*pret = OPJ_FALSE;
return;
}
+ job->whole_tile_decoding = tcd->whole_tile_decoding;
job->resno = resno;
job->cblk = cblk;
job->band = band;
@@ -1792,6 +1899,9 @@ void opj_t1_decode_cblks(opj_thread_pool_t* tp,
job->check_pterm = check_pterm;
job->mustuse_cblkdatabuffer = opj_thread_pool_get_thread_count(tp) > 1;
opj_thread_pool_submit_job(tp, opj_t1_clbl_decode_processor, job);
+#ifdef DEBUG_VERBOSE
+ codeblocks_decoded ++;
+#endif
if (!(*pret)) {
return;
}
@@ -1800,6 +1910,9 @@ void opj_t1_decode_cblks(opj_thread_pool_t* tp,
} /* bandno */
} /* resno */
+#ifdef DEBUG_VERBOSE
+ printf("Leave opj_t1_decode_cblks(). Number decoded: %d\n", codeblocks_decoded);
+#endif
return;
}
@@ -1821,6 +1934,7 @@ static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
OPJ_BYTE* cblkdata = NULL;
OPJ_UINT32 cblkdataindex = 0;
OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */
+ OPJ_INT32* original_t1_data = NULL;
mqc->lut_ctxno_zc_orient = lut_ctxno_zc + (orient << 9);
@@ -1885,6 +1999,17 @@ static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
}
} else if (cblk->numchunks == 1) {
cblkdata = cblk->chunks[0].data;
+ } else {
+ /* Not sure if that can happen in practice, but avoid Coverity to */
+ /* think we will dereference a null cblkdta pointer */
+ return OPJ_TRUE;
+ }
+
+ /* For subtile decoding, directly decode in the decoded_data buffer of */
+ /* the code-block. Hack t1->data to point to it, and restore it later */
+ if (cblk->decoded_data) {
+ original_t1_data = t1->data;
+ t1->data = cblk->decoded_data;
}
for (segno = 0; segno < cblk->real_num_segs; ++segno) {
@@ -1966,6 +2091,11 @@ static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
}
}
+ /* Restore original t1->data is needed */
+ if (cblk->decoded_data) {
+ t1->data = original_t1_data;
+ }
+
return OPJ_TRUE;
}
@@ -2009,7 +2139,8 @@ OPJ_BOOL opj_t1_encode_cblks(opj_t1_t *t1,
OPJ_INT32* OPJ_RESTRICT tiledp;
OPJ_UINT32 cblk_w;
OPJ_UINT32 cblk_h;
- OPJ_UINT32 i, j, tileIndex = 0, tileLineAdvance;
+ OPJ_UINT32 i, j, tileLineAdvance;
+ OPJ_SIZE_T tileIndex = 0;
OPJ_INT32 x = cblk->x0 - band->x0;
OPJ_INT32 y = cblk->y0 - band->y0;
@@ -2033,7 +2164,7 @@ OPJ_BOOL opj_t1_encode_cblks(opj_t1_t *t1,
cblk_h = t1->h;
tileLineAdvance = tile_w - cblk_w;
- tiledp = &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
+ tiledp = &tilec->data[(OPJ_SIZE_T)y * tile_w + (OPJ_SIZE_T)x];
t1->data = tiledp;
t1->data_stride = tile_w;
if (tccp->qmfbid == 1) {
@@ -2155,6 +2286,10 @@ static void opj_t1_encode_cblk(opj_t1_t *t1,
cblk->numbps = max ? (OPJ_UINT32)((opj_int_floorlog2(max) + 1) -
T1_NMSEDEC_FRACBITS) : 0;
+ if (cblk->numbps == 0) {
+ cblk->totalpasses = 0;
+ return;
+ }
bpno = (OPJ_INT32)(cblk->numbps - 1);
passtype = 2;
diff --git a/third_party/libopenjpeg20/t1.h b/third_party/libopenjpeg20/t1.h
index 5aa6a07bf2..171dfb0a7a 100644
--- a/third_party/libopenjpeg20/t1.h
+++ b/third_party/libopenjpeg20/t1.h
@@ -230,7 +230,7 @@ OPJ_BOOL opj_t1_encode_cblks(opj_t1_t *t1,
/**
Decode the code-blocks of a tile
-@param tp Thread pool
+@param tcd TCD handle
@param pret Pointer to return value
@param tilec The tile to decode
@param tccp Tile coding parameters
@@ -238,7 +238,7 @@ Decode the code-blocks of a tile
@param p_manager_mutex mutex for the event manager
@param check_pterm whether PTERM correct termination should be checked
*/
-void opj_t1_decode_cblks(opj_thread_pool_t* tp,
+void opj_t1_decode_cblks(opj_tcd_t* tcd,
volatile OPJ_BOOL* pret,
opj_tcd_tilecomp_t* tilec,
opj_tccp_t* tccp,
diff --git a/third_party/libopenjpeg20/t2.c b/third_party/libopenjpeg20/t2.c
index c8cfcc26b7..6f956d1c7f 100644
--- a/third_party/libopenjpeg20/t2.c
+++ b/third_party/libopenjpeg20/t2.c
@@ -13,6 +13,7 @@
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR
* Copyright (c) 2012, CS Systemes d'Information, France
+ * Copyright (c) 2017, IntoPIX SA <support@intopix.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -68,6 +69,8 @@ Encode a packet of a tile to a destination buffer
@param p_data_written FIXME DOC
@param len Length of the destination buffer
@param cstr_info Codestream information structure
+@param p_t2_mode If == THRESH_CALC In Threshold calculation ,If == FINAL_PASS Final pass
+@param p_manager the user event manager
@return
*/
static OPJ_BOOL opj_t2_encode_packet(OPJ_UINT32 tileno,
@@ -77,7 +80,9 @@ static OPJ_BOOL opj_t2_encode_packet(OPJ_UINT32 tileno,
OPJ_BYTE *dest,
OPJ_UINT32 * p_data_written,
OPJ_UINT32 len,
- opj_codestream_info_t *cstr_info);
+ opj_codestream_info_t *cstr_info,
+ J2K_T2_MODE p_t2_mode,
+ opj_event_mgr_t *p_manager);
/**
Decode a packet of a tile from a source buffer
@@ -222,7 +227,8 @@ OPJ_BOOL opj_t2_encode_packets(opj_t2_t* p_t2,
OPJ_UINT32 p_tp_num,
OPJ_INT32 p_tp_pos,
OPJ_UINT32 p_pino,
- J2K_T2_MODE p_t2_mode)
+ J2K_T2_MODE p_t2_mode,
+ opj_event_mgr_t *p_manager)
{
OPJ_BYTE *l_current_data = p_dest;
OPJ_UINT32 l_nb_bytes = 0;
@@ -268,7 +274,10 @@ OPJ_BOOL opj_t2_encode_packets(opj_t2_t* p_t2,
l_nb_bytes = 0;
if (! opj_t2_encode_packet(p_tile_no, p_tile, l_tcp, l_current_pi,
- l_current_data, &l_nb_bytes, p_max_len, cstr_info)) {
+ l_current_data, &l_nb_bytes,
+ p_max_len, cstr_info,
+ p_t2_mode,
+ p_manager)) {
opj_pi_destroy(l_pi, l_nb_pocs);
return OPJ_FALSE;
}
@@ -306,7 +315,8 @@ OPJ_BOOL opj_t2_encode_packets(opj_t2_t* p_t2,
l_nb_bytes = 0;
if (! opj_t2_encode_packet(p_tile_no, p_tile, l_tcp, l_current_pi,
- l_current_data, &l_nb_bytes, p_max_len, cstr_info)) {
+ l_current_data, &l_nb_bytes, p_max_len,
+ cstr_info, p_t2_mode, p_manager)) {
opj_pi_destroy(l_pi, l_nb_pocs);
return OPJ_FALSE;
}
@@ -360,7 +370,8 @@ static void opj_null_jas_fprintf(FILE* file, const char * format, ...)
#define JAS_FPRINTF opj_null_jas_fprintf
#endif
-OPJ_BOOL opj_t2_decode_packets(opj_t2_t *p_t2,
+OPJ_BOOL opj_t2_decode_packets(opj_tcd_t* tcd,
+ opj_t2_t *p_t2,
OPJ_UINT32 p_tile_no,
opj_tcd_tile_t *p_tile,
OPJ_BYTE *p_src,
@@ -425,14 +436,54 @@ OPJ_BOOL opj_t2_decode_packets(opj_t2_t *p_t2,
memset(first_pass_failed, OPJ_TRUE, l_image->numcomps * sizeof(OPJ_BOOL));
while (opj_pi_next(l_current_pi)) {
+ OPJ_BOOL skip_packet = OPJ_FALSE;
JAS_FPRINTF(stderr,
"packet offset=00000166 prg=%d cmptno=%02d rlvlno=%02d prcno=%03d lyrno=%02d\n\n",
l_current_pi->poc.prg1, l_current_pi->compno, l_current_pi->resno,
l_current_pi->precno, l_current_pi->layno);
- if (l_tcp->num_layers_to_decode > l_current_pi->layno
- && l_current_pi->resno <
- p_tile->comps[l_current_pi->compno].minimum_num_resolutions) {
+ /* If the packet layer is greater or equal than the maximum */
+ /* number of layers, skip the packet */
+ if (l_current_pi->layno >= l_tcp->num_layers_to_decode) {
+ skip_packet = OPJ_TRUE;
+ }
+ /* If the packet resolution number is greater than the minimum */
+ /* number of resolution allowed, skip the packet */
+ else if (l_current_pi->resno >=
+ p_tile->comps[l_current_pi->compno].minimum_num_resolutions) {
+ skip_packet = OPJ_TRUE;
+ } else {
+ /* If no precincts of any band intersects the area of interest, */
+ /* skip the packet */
+ OPJ_UINT32 bandno;
+ opj_tcd_tilecomp_t *tilec = &p_tile->comps[l_current_pi->compno];
+ opj_tcd_resolution_t *res = &tilec->resolutions[l_current_pi->resno];
+
+ skip_packet = OPJ_TRUE;
+ for (bandno = 0; bandno < res->numbands; ++bandno) {
+ opj_tcd_band_t* band = &res->bands[bandno];
+ opj_tcd_precinct_t* prec = &band->precincts[l_current_pi->precno];
+
+ if (opj_tcd_is_subband_area_of_interest(tcd,
+ l_current_pi->compno,
+ l_current_pi->resno,
+ band->bandno,
+ (OPJ_UINT32)prec->x0,
+ (OPJ_UINT32)prec->y0,
+ (OPJ_UINT32)prec->x1,
+ (OPJ_UINT32)prec->y1)) {
+ skip_packet = OPJ_FALSE;
+ break;
+ }
+ }
+ /*
+ printf("packet cmptno=%02d rlvlno=%02d prcno=%03d lyrno=%02d -> %s\n",
+ l_current_pi->compno, l_current_pi->resno,
+ l_current_pi->precno, l_current_pi->layno, skip_packet ? "skipped" : "kept");
+ */
+ }
+
+ if (!skip_packet) {
l_nb_bytes_read = 0;
first_pass_failed[l_current_pi->compno] = OPJ_FALSE;
@@ -596,7 +647,9 @@ static OPJ_BOOL opj_t2_encode_packet(OPJ_UINT32 tileno,
OPJ_BYTE *dest,
OPJ_UINT32 * p_data_written,
OPJ_UINT32 length,
- opj_codestream_info_t *cstr_info)
+ opj_codestream_info_t *cstr_info,
+ J2K_T2_MODE p_t2_mode,
+ opj_event_mgr_t *p_manager)
{
OPJ_UINT32 bandno, cblkno;
OPJ_BYTE* c = dest;
@@ -618,6 +671,15 @@ static OPJ_BOOL opj_t2_encode_packet(OPJ_UINT32 tileno,
/* <SOP 0xff91> */
if (tcp->csty & J2K_CP_CSTY_SOP) {
+ if (length < 6) {
+ if (p_t2_mode == FINAL_PASS) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "opj_t2_encode_packet(): only %u bytes remaining in "
+ "output buffer. %u needed.\n",
+ length, 6);
+ }
+ return OPJ_FALSE;
+ }
c[0] = 255;
c[1] = 145;
c[2] = 0;
@@ -806,6 +868,15 @@ static OPJ_BOOL opj_t2_encode_packet(OPJ_UINT32 tileno,
/* <EPH 0xff92> */
if (tcp->csty & J2K_CP_CSTY_EPH) {
+ if (length < 2) {
+ if (p_t2_mode == FINAL_PASS) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "opj_t2_encode_packet(): only %u bytes remaining in "
+ "output buffer. %u needed.\n",
+ length, 2);
+ }
+ return OPJ_FALSE;
+ }
c[0] = 255;
c[1] = 146;
c += 2;
@@ -845,6 +916,12 @@ static OPJ_BOOL opj_t2_encode_packet(OPJ_UINT32 tileno,
}
if (layer->len > length) {
+ if (p_t2_mode == FINAL_PASS) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "opj_t2_encode_packet(): only %u bytes remaining in "
+ "output buffer. %u needed.\n",
+ length, layer->len);
+ }
return OPJ_FALSE;
}
diff --git a/third_party/libopenjpeg20/t2.h b/third_party/libopenjpeg20/t2.h
index 4013b9dbb3..66500b1699 100644
--- a/third_party/libopenjpeg20/t2.h
+++ b/third_party/libopenjpeg20/t2.h
@@ -13,6 +13,7 @@
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR
* Copyright (c) 2012, CS Systemes d'Information, France
+ * Copyright (c) 2017, IntoPIX SA <support@intopix.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -75,7 +76,8 @@ Encode the packets of a tile to a destination buffer
@param tpnum Tile part number of the current tile
@param tppos The position of the tile part flag in the progression order
@param pino FIXME DOC
-@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
+@param t2_mode If == THRESH_CALC In Threshold calculation ,If == FINAL_PASS Final pass
+@param p_manager the user event manager
*/
OPJ_BOOL opj_t2_encode_packets(opj_t2_t* t2,
OPJ_UINT32 tileno,
@@ -88,10 +90,12 @@ OPJ_BOOL opj_t2_encode_packets(opj_t2_t* t2,
OPJ_UINT32 tpnum,
OPJ_INT32 tppos,
OPJ_UINT32 pino,
- J2K_T2_MODE t2_mode);
+ J2K_T2_MODE t2_mode,
+ opj_event_mgr_t *p_manager);
/**
Decode the packets of a tile from a source buffer
+@param tcd TCD handle
@param t2 T2 handle
@param tileno number that identifies the tile for which to decode the packets
@param tile tile for which to decode the packets
@@ -103,7 +107,8 @@ Decode the packets of a tile from a source buffer
@return FIXME DOC
*/
-OPJ_BOOL opj_t2_decode_packets(opj_t2_t *t2,
+OPJ_BOOL opj_t2_decode_packets(opj_tcd_t* tcd,
+ opj_t2_t *t2,
OPJ_UINT32 tileno,
opj_tcd_tile_t *tile,
OPJ_BYTE *src,
diff --git a/third_party/libopenjpeg20/tcd.c b/third_party/libopenjpeg20/tcd.c
index 35d15e3d1f..7298fa3934 100644
--- a/third_party/libopenjpeg20/tcd.c
+++ b/third_party/libopenjpeg20/tcd.c
@@ -14,6 +14,7 @@
* Copyright (c) 2006-2007, Parvatha Elangovan
* Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR
* Copyright (c) 2012, CS Systemes d'Information, France
+ * Copyright (c) 2017, IntoPIX SA <support@intopix.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -180,12 +181,18 @@ static OPJ_BOOL opj_tcd_t2_encode(opj_tcd_t *p_tcd,
OPJ_BYTE * p_dest_data,
OPJ_UINT32 * p_data_written,
OPJ_UINT32 p_max_dest_size,
- opj_codestream_info_t *p_cstr_info);
+ opj_codestream_info_t *p_cstr_info,
+ opj_event_mgr_t *p_manager);
static OPJ_BOOL opj_tcd_rate_allocate_encode(opj_tcd_t *p_tcd,
OPJ_BYTE * p_dest_data,
OPJ_UINT32 p_max_dest_size,
- opj_codestream_info_t *p_cstr_info);
+ opj_codestream_info_t *p_cstr_info,
+ opj_event_mgr_t *p_manager);
+
+
+static OPJ_BOOL opj_tcd_is_whole_tilecomp_decoding(opj_tcd_t *tcd,
+ OPJ_UINT32 compno);
/* ----------------------------------------------------------------------- */
@@ -266,28 +273,33 @@ void opj_tcd_makelayer(opj_tcd_t *tcd,
n = cblk->numpassesinlayers;
- for (passno = cblk->numpassesinlayers; passno < cblk->totalpasses; passno++) {
- OPJ_UINT32 dr;
- OPJ_FLOAT64 dd;
- opj_tcd_pass_t *pass = &cblk->passes[passno];
-
- if (n == 0) {
- dr = pass->rate;
- dd = pass->distortiondec;
- } else {
- dr = pass->rate - cblk->passes[n - 1].rate;
- dd = pass->distortiondec - cblk->passes[n - 1].distortiondec;
- }
+ if (thresh < 0) {
+ /* Special value to indicate to use all passes */
+ n = cblk->totalpasses;
+ } else {
+ for (passno = cblk->numpassesinlayers; passno < cblk->totalpasses; passno++) {
+ OPJ_UINT32 dr;
+ OPJ_FLOAT64 dd;
+ opj_tcd_pass_t *pass = &cblk->passes[passno];
+
+ if (n == 0) {
+ dr = pass->rate;
+ dd = pass->distortiondec;
+ } else {
+ dr = pass->rate - cblk->passes[n - 1].rate;
+ dd = pass->distortiondec - cblk->passes[n - 1].distortiondec;
+ }
- if (!dr) {
- if (dd != 0) {
+ if (!dr) {
+ if (dd != 0) {
+ n = passno + 1;
+ }
+ continue;
+ }
+ if (thresh - (dd / dr) <
+ DBL_EPSILON) { /* do not rely on float equality, check with DBL_EPSILON margin */
n = passno + 1;
}
- continue;
- }
- if (thresh - (dd / dr) <
- DBL_EPSILON) { /* do not rely on float equality, check with DBL_EPSILON margin */
- n = passno + 1;
}
}
@@ -431,7 +443,8 @@ OPJ_BOOL opj_tcd_rateallocate(opj_tcd_t *tcd,
OPJ_BYTE *dest,
OPJ_UINT32 * p_data_written,
OPJ_UINT32 len,
- opj_codestream_info_t *cstr_info)
+ opj_codestream_info_t *cstr_info,
+ opj_event_mgr_t *p_manager)
{
OPJ_UINT32 compno, resno, bandno, precno, cblkno, layno;
OPJ_UINT32 passno;
@@ -563,7 +576,7 @@ OPJ_BOOL opj_tcd_rateallocate(opj_tcd_t *tcd,
if (OPJ_IS_CINEMA(cp->rsiz)) {
if (! opj_t2_encode_packets(t2, tcd->tcd_tileno, tcd_tile, layno + 1, dest,
p_data_written, maxlen, cstr_info, tcd->cur_tp_num, tcd->tp_pos, tcd->cur_pino,
- THRESH_CALC)) {
+ THRESH_CALC, p_manager)) {
lo = thresh;
continue;
@@ -593,7 +606,7 @@ OPJ_BOOL opj_tcd_rateallocate(opj_tcd_t *tcd,
} else {
if (! opj_t2_encode_packets(t2, tcd->tcd_tileno, tcd_tile, layno + 1, dest,
p_data_written, maxlen, cstr_info, tcd->cur_tp_num, tcd->tp_pos, tcd->cur_pino,
- THRESH_CALC)) {
+ THRESH_CALC, p_manager)) {
/* TODO: what to do with l ??? seek / tell ??? */
/* opj_event_msg(tcd->cinfo, EVT_INFO, "rate alloc: len=%d, max=%d\n", l, maxlen); */
lo = thresh;
@@ -609,7 +622,8 @@ OPJ_BOOL opj_tcd_rateallocate(opj_tcd_t *tcd,
opj_t2_destroy(t2);
} else {
- goodthresh = min;
+ /* Special value to indicate to use all passes */
+ goodthresh = -1;
}
if (cstr_info) { /* Threshold for Marcela Index */
@@ -665,6 +679,9 @@ void opj_tcd_destroy(opj_tcd_t *tcd)
opj_free(tcd->tcd_image);
tcd->tcd_image = 00;
}
+
+ opj_free(tcd->used_component);
+
opj_free(tcd);
}
}
@@ -675,7 +692,7 @@ OPJ_BOOL opj_alloc_tile_component_data(opj_tcd_tilecomp_t *l_tilec)
((l_tilec->data_size_needed > l_tilec->data_size) &&
(l_tilec->ownsData == OPJ_FALSE))) {
l_tilec->data = (OPJ_INT32 *) opj_image_data_alloc(l_tilec->data_size_needed);
- if (! l_tilec->data) {
+ if (!l_tilec->data && l_tilec->data_size_needed != 0) {
return OPJ_FALSE;
}
/*fprintf(stderr, "tAllocate data of tilec (int): %d x OPJ_UINT32n",l_data_size);*/
@@ -787,27 +804,9 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no,
l_tilec->y0 = opj_int_ceildiv(l_tile->y0, (OPJ_INT32)l_image_comp->dy);
l_tilec->x1 = opj_int_ceildiv(l_tile->x1, (OPJ_INT32)l_image_comp->dx);
l_tilec->y1 = opj_int_ceildiv(l_tile->y1, (OPJ_INT32)l_image_comp->dy);
+ l_tilec->compno = compno;
/*fprintf(stderr, "\tTile compo border = %d,%d,%d,%d\n", l_tilec->x0, l_tilec->y0,l_tilec->x1,l_tilec->y1);*/
- if (l_tilec->x0 >= l_tilec->x1 || l_tilec->y0 >= l_tilec->y1) {
- opj_event_msg(manager, EVT_ERROR, "Invalid tile data\n");
- return OPJ_FALSE;
- }
- /* compute l_data_size with overflow check */
- l_data_size = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0);
- /* issue 733, l_data_size == 0U, probably something wrong should be checked before getting here */
- if ((l_data_size > 0U) &&
- ((((OPJ_UINT32) - 1) / l_data_size) < (OPJ_UINT32)(l_tilec->y1 -
- l_tilec->y0))) {
- opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
- return OPJ_FALSE;
- }
- l_data_size = l_data_size * (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0);
- if ((((OPJ_UINT32) - 1) / (OPJ_UINT32)sizeof(OPJ_UINT32)) < l_data_size) {
- opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
- return OPJ_FALSE;
- }
- l_data_size = l_data_size * (OPJ_UINT32)sizeof(OPJ_UINT32);
l_tilec->numresolutions = l_tccp->numresolutions;
if (l_tccp->numresolutions < l_cp->m_specific_param.m_dec.m_reduce) {
l_tilec->minimum_num_resolutions = 1;
@@ -816,15 +815,44 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no,
l_cp->m_specific_param.m_dec.m_reduce;
}
- l_tilec->data_size_needed = l_data_size;
- if (p_tcd->m_is_decoder && !opj_alloc_tile_component_data(l_tilec)) {
- opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
- return OPJ_FALSE;
+ if (isEncoder) {
+ OPJ_SIZE_T l_tile_data_size;
+
+ if (l_tilec->x0 >= l_tilec->x1 || l_tilec->y0 >= l_tilec->y1) {
+ opj_event_msg(manager, EVT_ERROR, "Invalid tile data\n");
+ return OPJ_FALSE;
+ }
+
+ /* compute l_data_size with overflow check */
+ OPJ_SIZE_T w = (OPJ_SIZE_T)(l_tilec->x1 - l_tilec->x0);
+ OPJ_SIZE_T h = (OPJ_SIZE_T)(l_tilec->y1 - l_tilec->y0);
+
+ /* issue 733, l_data_size == 0U, probably something wrong should be checked before getting here */
+ if (h > 0 && w > SIZE_MAX / h) {
+ opj_event_msg(manager, EVT_ERROR, "Size of tile data exceeds system limits\n");
+ return OPJ_FALSE;
+ }
+ l_tile_data_size = w * h;
+
+ if (SIZE_MAX / sizeof(OPJ_UINT32) < l_tile_data_size) {
+ opj_event_msg(manager, EVT_ERROR, "Size of tile data exceeds system limits\n");
+ return OPJ_FALSE;
+ }
+ l_tile_data_size = l_tile_data_size * sizeof(OPJ_UINT32);
+
+ l_tilec->data_size_needed = l_tile_data_size;
}
l_data_size = l_tilec->numresolutions * (OPJ_UINT32)sizeof(
opj_tcd_resolution_t);
+ opj_image_data_free(l_tilec->data_win);
+ l_tilec->data_win = NULL;
+ l_tilec->win_x0 = 0;
+ l_tilec->win_y0 = 0;
+ l_tilec->win_x1 = 0;
+ l_tilec->win_y1 = 0;
+
if (l_tilec->resolutions == 00) {
l_tilec->resolutions = (opj_tcd_resolution_t *) opj_malloc(l_data_size);
if (! l_tilec->resolutions) {
@@ -873,6 +901,7 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no,
l_res->y0 = opj_int_ceildivpow2(l_tilec->y0, (OPJ_INT32)l_level_no);
l_res->x1 = opj_int_ceildivpow2(l_tilec->x1, (OPJ_INT32)l_level_no);
l_res->y1 = opj_int_ceildivpow2(l_tilec->y1, (OPJ_INT32)l_level_no);
+
/*fprintf(stderr, "\t\t\tres_x0= %d, res_y0 =%d, res_x1=%d, res_y1=%d\n", l_res->x0, l_res->y0, l_res->x1, l_res->y1);*/
/* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */
l_pdx = l_tccp->prcw[resno];
@@ -892,14 +921,14 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no,
/*fprintf(stderr, "\t\t\tres_pw=%d, res_ph=%d\n", l_res->pw, l_res->ph );*/
if ((l_res->pw != 0U) && ((((OPJ_UINT32) - 1) / l_res->pw) < l_res->ph)) {
- opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
+ opj_event_msg(manager, EVT_ERROR, "Size of tile data exceeds system limits\n");
return OPJ_FALSE;
}
l_nb_precincts = l_res->pw * l_res->ph;
if ((((OPJ_UINT32) - 1) / (OPJ_UINT32)sizeof(opj_tcd_precinct_t)) <
l_nb_precincts) {
- opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
+ opj_event_msg(manager, EVT_ERROR, "Size of tile data exceeds system limits\n");
return OPJ_FALSE;
}
l_nb_precinct_size = l_nb_precincts * (OPJ_UINT32)sizeof(opj_tcd_precinct_t);
@@ -1193,8 +1222,11 @@ static OPJ_BOOL opj_tcd_code_block_enc_allocate_data(opj_tcd_cblk_enc_t *
{
OPJ_UINT32 l_data_size;
- /* The +1 is needed for https://github.com/uclouvain/openjpeg/issues/835 */
- l_data_size = 1 + (OPJ_UINT32)((p_code_block->x1 - p_code_block->x0) *
+ /* +1 is needed for https://github.com/uclouvain/openjpeg/issues/835 */
+ /* and actually +2 required for https://github.com/uclouvain/openjpeg/issues/982 */
+ /* TODO: is there a theoretical upper-bound for the compressed code */
+ /* block size ? */
+ l_data_size = 2 + (OPJ_UINT32)((p_code_block->x1 - p_code_block->x0) *
(p_code_block->y1 - p_code_block->y0) * (OPJ_INT32)sizeof(OPJ_UINT32));
if (l_data_size > p_code_block->data_size) {
@@ -1250,6 +1282,9 @@ static OPJ_BOOL opj_tcd_code_block_dec_allocate(opj_tcd_cblk_dec_t *
OPJ_UINT32 l_numchunksalloc = p_code_block->numchunksalloc;
OPJ_UINT32 i;
+ opj_aligned_free(p_code_block->decoded_data);
+ p_code_block->decoded_data = 00;
+
memset(p_code_block, 0, sizeof(opj_tcd_cblk_dec_t));
p_code_block->segs = l_segs;
p_code_block->m_current_max_segs = l_current_max_segs;
@@ -1263,7 +1298,8 @@ static OPJ_BOOL opj_tcd_code_block_dec_allocate(opj_tcd_cblk_dec_t *
return OPJ_TRUE;
}
-OPJ_UINT32 opj_tcd_get_decoded_tile_size(opj_tcd_t *p_tcd)
+OPJ_UINT32 opj_tcd_get_decoded_tile_size(opj_tcd_t *p_tcd,
+ OPJ_BOOL take_into_account_partial_decoding)
{
OPJ_UINT32 i;
OPJ_UINT32 l_data_size = 0;
@@ -1277,6 +1313,7 @@ OPJ_UINT32 opj_tcd_get_decoded_tile_size(opj_tcd_t *p_tcd)
l_img_comp = p_tcd->image->comps;
for (i = 0; i < p_tcd->image->numcomps; ++i) {
+ OPJ_UINT32 w, h;
l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
l_remaining = l_img_comp->prec & 7; /* (%8) */
@@ -1289,8 +1326,17 @@ OPJ_UINT32 opj_tcd_get_decoded_tile_size(opj_tcd_t *p_tcd)
}
l_res = l_tile_comp->resolutions + l_tile_comp->minimum_num_resolutions - 1;
- l_temp = (OPJ_UINT32)((l_res->x1 - l_res->x0) * (l_res->y1 -
- l_res->y0)); /* x1*y1 can't overflow */
+ if (take_into_account_partial_decoding && !p_tcd->whole_tile_decoding) {
+ w = l_res->win_x1 - l_res->win_x0;
+ h = l_res->win_y1 - l_res->win_y0;
+ } else {
+ w = (OPJ_UINT32)(l_res->x1 - l_res->x0);
+ h = (OPJ_UINT32)(l_res->y1 - l_res->y0);
+ }
+ if (h > 0 && UINT_MAX / w < h) {
+ return UINT_MAX;
+ }
+ l_temp = w * h;
if (l_size_comp && UINT_MAX / l_size_comp < l_temp) {
return UINT_MAX;
}
@@ -1312,7 +1358,8 @@ OPJ_BOOL opj_tcd_encode_tile(opj_tcd_t *p_tcd,
OPJ_BYTE *p_dest,
OPJ_UINT32 * p_data_written,
OPJ_UINT32 p_max_length,
- opj_codestream_info_t *p_cstr_info)
+ opj_codestream_info_t *p_cstr_info,
+ opj_event_mgr_t *p_manager)
{
if (p_tcd->cur_tp_num == 0) {
@@ -1339,7 +1386,8 @@ OPJ_BOOL opj_tcd_encode_tile(opj_tcd_t *p_tcd,
p_cstr_info->tile[p_tile_no].pdy[i] = (int)l_tccp->prch[i];
}
p_cstr_info->tile[p_tile_no].packet = (opj_packet_info_t*) opj_calloc((
- size_t)p_cstr_info->numcomps * (size_t)p_cstr_info->numlayers * l_num_packs,
+ OPJ_SIZE_T)p_cstr_info->numcomps * (OPJ_SIZE_T)p_cstr_info->numlayers *
+ l_num_packs,
sizeof(opj_packet_info_t));
if (!p_cstr_info->tile[p_tile_no].packet) {
/* FIXME event manager error callback */
@@ -1374,7 +1422,8 @@ OPJ_BOOL opj_tcd_encode_tile(opj_tcd_t *p_tcd,
/* FIXME _ProfStop(PGROUP_T1); */
/* FIXME _ProfStart(PGROUP_RATE); */
- if (! opj_tcd_rate_allocate_encode(p_tcd, p_dest, p_max_length, p_cstr_info)) {
+ if (! opj_tcd_rate_allocate_encode(p_tcd, p_dest, p_max_length,
+ p_cstr_info, p_manager)) {
return OPJ_FALSE;
}
/* FIXME _ProfStop(PGROUP_RATE); */
@@ -1389,7 +1438,7 @@ OPJ_BOOL opj_tcd_encode_tile(opj_tcd_t *p_tcd,
/* FIXME _ProfStart(PGROUP_T2); */
if (! opj_tcd_t2_encode(p_tcd, p_dest, p_data_written, p_max_length,
- p_cstr_info)) {
+ p_cstr_info, p_manager)) {
return OPJ_FALSE;
}
/* FIXME _ProfStop(PGROUP_T2); */
@@ -1400,6 +1449,12 @@ OPJ_BOOL opj_tcd_encode_tile(opj_tcd_t *p_tcd,
}
OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
+ OPJ_UINT32 win_x0,
+ OPJ_UINT32 win_y0,
+ OPJ_UINT32 win_x1,
+ OPJ_UINT32 win_y1,
+ OPJ_UINT32 numcomps_to_decode,
+ const OPJ_UINT32 *comps_indices,
OPJ_BYTE *p_src,
OPJ_UINT32 p_max_length,
OPJ_UINT32 p_tile_no,
@@ -1408,8 +1463,131 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
)
{
OPJ_UINT32 l_data_read;
+ OPJ_UINT32 compno;
+
p_tcd->tcd_tileno = p_tile_no;
p_tcd->tcp = &(p_tcd->cp->tcps[p_tile_no]);
+ p_tcd->win_x0 = win_x0;
+ p_tcd->win_y0 = win_y0;
+ p_tcd->win_x1 = win_x1;
+ p_tcd->win_y1 = win_y1;
+ p_tcd->whole_tile_decoding = OPJ_TRUE;
+
+ opj_free(p_tcd->used_component);
+ p_tcd->used_component = NULL;
+
+ if (numcomps_to_decode) {
+ OPJ_BOOL* used_component = (OPJ_BOOL*) opj_calloc(sizeof(OPJ_BOOL),
+ p_tcd->image->numcomps);
+ if (used_component == NULL) {
+ return OPJ_FALSE;
+ }
+ for (compno = 0; compno < numcomps_to_decode; compno++) {
+ used_component[ comps_indices[compno] ] = OPJ_TRUE;
+ }
+
+ p_tcd->used_component = used_component;
+ }
+
+ for (compno = 0; compno < p_tcd->image->numcomps; compno++) {
+ if (p_tcd->used_component != NULL && !p_tcd->used_component[compno]) {
+ continue;
+ }
+
+ if (!opj_tcd_is_whole_tilecomp_decoding(p_tcd, compno)) {
+ p_tcd->whole_tile_decoding = OPJ_FALSE;
+ break;
+ }
+ }
+
+ if (p_tcd->whole_tile_decoding) {
+ for (compno = 0; compno < p_tcd->image->numcomps; compno++) {
+ opj_tcd_tilecomp_t* tilec = &(p_tcd->tcd_image->tiles->comps[compno]);
+ opj_tcd_resolution_t *l_res = &
+ (tilec->resolutions[tilec->minimum_num_resolutions - 1]);
+ OPJ_SIZE_T l_data_size;
+
+ /* compute l_data_size with overflow check */
+ OPJ_SIZE_T res_w = (OPJ_SIZE_T)(l_res->x1 - l_res->x0);
+ OPJ_SIZE_T res_h = (OPJ_SIZE_T)(l_res->y1 - l_res->y0);
+
+ if (p_tcd->used_component != NULL && !p_tcd->used_component[compno]) {
+ continue;
+ }
+
+ /* issue 733, l_data_size == 0U, probably something wrong should be checked before getting here */
+ if (res_h > 0 && res_w > SIZE_MAX / res_h) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Size of tile data exceeds system limits\n");
+ return OPJ_FALSE;
+ }
+ l_data_size = res_w * res_h;
+
+ if (SIZE_MAX / sizeof(OPJ_UINT32) < l_data_size) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Size of tile data exceeds system limits\n");
+ return OPJ_FALSE;
+ }
+ l_data_size *= sizeof(OPJ_UINT32);
+
+ tilec->data_size_needed = l_data_size;
+
+ if (!opj_alloc_tile_component_data(tilec)) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Size of tile data exceeds system limits\n");
+ return OPJ_FALSE;
+ }
+ }
+ } else {
+ /* Compute restricted tile-component and tile-resolution coordinates */
+ /* of the window of interest, but defer the memory allocation until */
+ /* we know the resno_decoded */
+ for (compno = 0; compno < p_tcd->image->numcomps; compno++) {
+ OPJ_UINT32 resno;
+ opj_tcd_tilecomp_t* tilec = &(p_tcd->tcd_image->tiles->comps[compno]);
+ opj_image_comp_t* image_comp = &(p_tcd->image->comps[compno]);
+
+ if (p_tcd->used_component != NULL && !p_tcd->used_component[compno]) {
+ continue;
+ }
+
+ /* Compute the intersection of the area of interest, expressed in tile coordinates */
+ /* with the tile coordinates */
+ tilec->win_x0 = opj_uint_max(
+ (OPJ_UINT32)tilec->x0,
+ opj_uint_ceildiv(p_tcd->win_x0, image_comp->dx));
+ tilec->win_y0 = opj_uint_max(
+ (OPJ_UINT32)tilec->y0,
+ opj_uint_ceildiv(p_tcd->win_y0, image_comp->dy));
+ tilec->win_x1 = opj_uint_min(
+ (OPJ_UINT32)tilec->x1,
+ opj_uint_ceildiv(p_tcd->win_x1, image_comp->dx));
+ tilec->win_y1 = opj_uint_min(
+ (OPJ_UINT32)tilec->y1,
+ opj_uint_ceildiv(p_tcd->win_y1, image_comp->dy));
+ if (tilec->win_x1 < tilec->win_x0 ||
+ tilec->win_y1 < tilec->win_y0) {
+ /* We should not normally go there. The circumstance is when */
+ /* the tile coordinates do not intersect the area of interest */
+ /* Upper level logic should not even try to decode that tile */
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Invalid tilec->win_xxx values\n");
+ return OPJ_FALSE;
+ }
+
+ for (resno = 0; resno < tilec->numresolutions; ++resno) {
+ opj_tcd_resolution_t *res = tilec->resolutions + resno;
+ res->win_x0 = opj_uint_ceildivpow2(tilec->win_x0,
+ tilec->numresolutions - 1 - resno);
+ res->win_y0 = opj_uint_ceildivpow2(tilec->win_y0,
+ tilec->numresolutions - 1 - resno);
+ res->win_x1 = opj_uint_ceildivpow2(tilec->win_x1,
+ tilec->numresolutions - 1 - resno);
+ res->win_y1 = opj_uint_ceildivpow2(tilec->win_y1,
+ tilec->numresolutions - 1 - resno);
+ }
+ }
+ }
#ifdef TODO_MSD /* FIXME */
/* INDEX >> */
@@ -1452,6 +1630,49 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
}
/* FIXME _ProfStop(PGROUP_T1); */
+
+ /* For subtile decoding, now we know the resno_decoded, we can allocate */
+ /* the tile data buffer */
+ if (!p_tcd->whole_tile_decoding) {
+ for (compno = 0; compno < p_tcd->image->numcomps; compno++) {
+ opj_tcd_tilecomp_t* tilec = &(p_tcd->tcd_image->tiles->comps[compno]);
+ opj_image_comp_t* image_comp = &(p_tcd->image->comps[compno]);
+ opj_tcd_resolution_t *res = tilec->resolutions + image_comp->resno_decoded;
+ OPJ_SIZE_T w = res->win_x1 - res->win_x0;
+ OPJ_SIZE_T h = res->win_y1 - res->win_y0;
+ OPJ_SIZE_T l_data_size;
+
+ opj_image_data_free(tilec->data_win);
+ tilec->data_win = NULL;
+
+ if (p_tcd->used_component != NULL && !p_tcd->used_component[compno]) {
+ continue;
+ }
+
+ if (w > 0 && h > 0) {
+ if (w > SIZE_MAX / h) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Size of tile data exceeds system limits\n");
+ return OPJ_FALSE;
+ }
+ l_data_size = w * h;
+ if (l_data_size > SIZE_MAX / sizeof(OPJ_INT32)) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Size of tile data exceeds system limits\n");
+ return OPJ_FALSE;
+ }
+ l_data_size *= sizeof(OPJ_INT32);
+
+ tilec->data_win = (OPJ_INT32*) opj_image_data_alloc(l_data_size);
+ if (tilec->data_win == NULL) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Size of tile data exceeds system limits\n");
+ return OPJ_FALSE;
+ }
+ }
+ }
+ }
+
/*----------------DWT---------------------*/
/* FIXME _ProfStart(PGROUP_DWT); */
@@ -1493,7 +1714,7 @@ OPJ_BOOL opj_tcd_update_tile_data(opj_tcd_t *p_tcd,
OPJ_UINT32 l_size_comp, l_remaining;
OPJ_UINT32 l_stride, l_width, l_height;
- l_data_size = opj_tcd_get_decoded_tile_size(p_tcd);
+ l_data_size = opj_tcd_get_decoded_tile_size(p_tcd, OPJ_TRUE);
if (l_data_size == UINT_MAX || l_data_size > p_dest_length) {
return OPJ_FALSE;
}
@@ -1502,12 +1723,23 @@ OPJ_BOOL opj_tcd_update_tile_data(opj_tcd_t *p_tcd,
l_img_comp = p_tcd->image->comps;
for (i = 0; i < p_tcd->image->numcomps; ++i) {
+ const OPJ_INT32* l_src_data;
l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
l_remaining = l_img_comp->prec & 7; /* (%8) */
l_res = l_tilec->resolutions + l_img_comp->resno_decoded;
- l_width = (OPJ_UINT32)(l_res->x1 - l_res->x0);
- l_height = (OPJ_UINT32)(l_res->y1 - l_res->y0);
- l_stride = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0) - l_width;
+ if (p_tcd->whole_tile_decoding) {
+ l_width = (OPJ_UINT32)(l_res->x1 - l_res->x0);
+ l_height = (OPJ_UINT32)(l_res->y1 - l_res->y0);
+ l_stride = (OPJ_UINT32)(l_tilec->resolutions[l_tilec->minimum_num_resolutions -
+ 1].x1 -
+ l_tilec->resolutions[l_tilec->minimum_num_resolutions - 1].x0) - l_width;
+ l_src_data = l_tilec->data;
+ } else {
+ l_width = l_res->win_x1 - l_res->win_x0;
+ l_height = l_res->win_y1 - l_res->win_y0;
+ l_stride = 0;
+ l_src_data = l_tilec->data_win;
+ }
if (l_remaining) {
++l_size_comp;
@@ -1520,7 +1752,7 @@ OPJ_BOOL opj_tcd_update_tile_data(opj_tcd_t *p_tcd,
switch (l_size_comp) {
case 1: {
OPJ_CHAR * l_dest_ptr = (OPJ_CHAR *) p_dest;
- const OPJ_INT32 * l_src_ptr = l_tilec->data;
+ const OPJ_INT32 * l_src_ptr = l_src_data;
if (l_img_comp->sgnd) {
for (j = 0; j < l_height; ++j) {
@@ -1542,7 +1774,7 @@ OPJ_BOOL opj_tcd_update_tile_data(opj_tcd_t *p_tcd,
}
break;
case 2: {
- const OPJ_INT32 * l_src_ptr = l_tilec->data;
+ const OPJ_INT32 * l_src_ptr = l_src_data;
OPJ_INT16 * l_dest_ptr = (OPJ_INT16 *) p_dest;
if (l_img_comp->sgnd) {
@@ -1570,7 +1802,7 @@ OPJ_BOOL opj_tcd_update_tile_data(opj_tcd_t *p_tcd,
break;
case 4: {
OPJ_INT32 * l_dest_ptr = (OPJ_INT32 *) p_dest;
- OPJ_INT32 * l_src_ptr = l_tilec->data;
+ const OPJ_INT32 * l_src_ptr = l_src_data;
for (j = 0; j < l_height; ++j) {
memcpy(l_dest_ptr, l_src_ptr, l_width * sizeof(OPJ_INT32));
@@ -1629,14 +1861,16 @@ static void opj_tcd_free_tile(opj_tcd_t *p_tcd)
l_res = l_tile_comp->resolutions;
if (l_res) {
- l_nb_resolutions = l_tile_comp->resolutions_size / sizeof(opj_tcd_resolution_t);
+ l_nb_resolutions = l_tile_comp->resolutions_size / (OPJ_UINT32)sizeof(
+ opj_tcd_resolution_t);
for (resno = 0; resno < l_nb_resolutions; ++resno) {
l_band = l_res->bands;
for (bandno = 0; bandno < 3; ++bandno) {
l_precinct = l_band->precincts;
if (l_precinct) {
- l_nb_precincts = l_band->precincts_data_size / sizeof(opj_tcd_precinct_t);
+ l_nb_precincts = l_band->precincts_data_size / (OPJ_UINT32)sizeof(
+ opj_tcd_precinct_t);
for (precno = 0; precno < l_nb_precincts; ++precno) {
opj_tgt_destroy(l_precinct->incltree);
l_precinct->incltree = 00;
@@ -1665,6 +1899,9 @@ static void opj_tcd_free_tile(opj_tcd_t *p_tcd)
l_tile_comp->data_size = 0;
l_tile_comp->data_size_needed = 0;
}
+
+ opj_image_data_free(l_tile_comp->data_win);
+
++l_tile_comp;
}
@@ -1691,6 +1928,7 @@ static OPJ_BOOL opj_tcd_t2_decode(opj_tcd_t *p_tcd,
}
if (! opj_t2_decode_packets(
+ p_tcd,
l_t2,
p_tcd->tcd_tileno,
p_tcd->tcd_image->tiles,
@@ -1727,14 +1965,17 @@ static OPJ_BOOL opj_tcd_t1_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
check_pterm = OPJ_TRUE;
}
- for (compno = 0; compno < l_tile->numcomps; ++compno) {
- opj_t1_decode_cblks(p_tcd->thread_pool, &ret, l_tile_comp, l_tccp,
+ for (compno = 0; compno < l_tile->numcomps;
+ ++compno, ++l_tile_comp, ++l_tccp) {
+ if (p_tcd->used_component != NULL && !p_tcd->used_component[compno]) {
+ continue;
+ }
+
+ opj_t1_decode_cblks(p_tcd, &ret, l_tile_comp, l_tccp,
p_manager, p_manager_mutex, check_pterm);
if (!ret) {
break;
}
- ++l_tile_comp;
- ++l_tccp;
}
opj_thread_pool_wait_completion(p_tcd->thread_pool, 0);
@@ -1753,38 +1994,29 @@ static OPJ_BOOL opj_tcd_dwt_decode(opj_tcd_t *p_tcd)
opj_tccp_t * l_tccp = p_tcd->tcp->tccps;
opj_image_comp_t * l_img_comp = p_tcd->image->comps;
- for (compno = 0; compno < l_tile->numcomps; compno++) {
- /*
- if (tcd->cp->reduce != 0) {
- tcd->image->comps[compno].resno_decoded =
- tile->comps[compno].numresolutions - tcd->cp->reduce - 1;
- if (tcd->image->comps[compno].resno_decoded < 0)
- {
- return false;
- }
+ for (compno = 0; compno < l_tile->numcomps;
+ compno++, ++l_tile_comp, ++l_img_comp, ++l_tccp) {
+ if (p_tcd->used_component != NULL && !p_tcd->used_component[compno]) {
+ continue;
}
- numres2decode = tcd->image->comps[compno].resno_decoded + 1;
- if(numres2decode > 0){
- */
if (l_tccp->qmfbid == 1) {
- if (! opj_dwt_decode(p_tcd->thread_pool, l_tile_comp,
+ if (! opj_dwt_decode(p_tcd, l_tile_comp,
l_img_comp->resno_decoded + 1)) {
return OPJ_FALSE;
}
} else {
- if (! opj_dwt_decode_real(l_tile_comp, l_img_comp->resno_decoded + 1)) {
+ if (! opj_dwt_decode_real(p_tcd, l_tile_comp,
+ l_img_comp->resno_decoded + 1)) {
return OPJ_FALSE;
}
}
- ++l_tile_comp;
- ++l_img_comp;
- ++l_tccp;
}
return OPJ_TRUE;
}
+
static OPJ_BOOL opj_tcd_mct_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
{
opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
@@ -1792,25 +2024,77 @@ static OPJ_BOOL opj_tcd_mct_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
opj_tcd_tilecomp_t * l_tile_comp = l_tile->comps;
OPJ_UINT32 l_samples, i;
- if (! l_tcp->mct) {
+ if (l_tcp->mct == 0 || p_tcd->used_component != NULL) {
return OPJ_TRUE;
}
- l_samples = (OPJ_UINT32)((l_tile_comp->x1 - l_tile_comp->x0) *
- (l_tile_comp->y1 - l_tile_comp->y0));
+ if (p_tcd->whole_tile_decoding) {
+ opj_tcd_resolution_t* res_comp0 = l_tile->comps[0].resolutions +
+ l_tile_comp->minimum_num_resolutions - 1;
+
+ /* A bit inefficient: we process more data than needed if */
+ /* resno_decoded < l_tile_comp->minimum_num_resolutions-1, */
+ /* but we would need to take into account a stride then */
+ l_samples = (OPJ_UINT32)((res_comp0->x1 - res_comp0->x0) *
+ (res_comp0->y1 - res_comp0->y0));
+ if (l_tile->numcomps >= 3) {
+ if (l_tile_comp->minimum_num_resolutions !=
+ l_tile->comps[1].minimum_num_resolutions ||
+ l_tile_comp->minimum_num_resolutions !=
+ l_tile->comps[2].minimum_num_resolutions) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Tiles don't all have the same dimension. Skip the MCT step.\n");
+ return OPJ_FALSE;
+ }
+ }
+ if (l_tile->numcomps >= 3) {
+ opj_tcd_resolution_t* res_comp1 = l_tile->comps[1].resolutions +
+ l_tile_comp->minimum_num_resolutions - 1;
+ opj_tcd_resolution_t* res_comp2 = l_tile->comps[2].resolutions +
+ l_tile_comp->minimum_num_resolutions - 1;
+ /* testcase 1336.pdf.asan.47.376 */
+ if (p_tcd->image->comps[0].resno_decoded !=
+ p_tcd->image->comps[1].resno_decoded ||
+ p_tcd->image->comps[0].resno_decoded !=
+ p_tcd->image->comps[2].resno_decoded ||
+ (OPJ_SIZE_T)(res_comp1->x1 - res_comp1->x0) *
+ (OPJ_SIZE_T)(res_comp1->y1 - res_comp1->y0) != l_samples ||
+ (OPJ_SIZE_T)(res_comp2->x1 - res_comp2->x0) *
+ (OPJ_SIZE_T)(res_comp2->y1 - res_comp2->y0) != l_samples) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Tiles don't all have the same dimension. Skip the MCT step.\n");
+ return OPJ_FALSE;
+ }
+ }
+ } else {
+ opj_tcd_resolution_t* res_comp0 = l_tile->comps[0].resolutions +
+ p_tcd->image->comps[0].resno_decoded;
+
+ l_samples = (res_comp0->win_x1 - res_comp0->win_x0) *
+ (res_comp0->win_y1 - res_comp0->win_y0);
+ if (l_tile->numcomps >= 3) {
+ opj_tcd_resolution_t* res_comp1 = l_tile->comps[1].resolutions +
+ p_tcd->image->comps[1].resno_decoded;
+ opj_tcd_resolution_t* res_comp2 = l_tile->comps[2].resolutions +
+ p_tcd->image->comps[2].resno_decoded;
+ /* testcase 1336.pdf.asan.47.376 */
+ if (p_tcd->image->comps[0].resno_decoded !=
+ p_tcd->image->comps[1].resno_decoded ||
+ p_tcd->image->comps[0].resno_decoded !=
+ p_tcd->image->comps[2].resno_decoded ||
+ (OPJ_SIZE_T)(res_comp1->win_x1 - res_comp1->win_x0) *
+ (OPJ_SIZE_T)(res_comp1->win_y1 - res_comp1->win_y0) != l_samples ||
+ (OPJ_SIZE_T)(res_comp2->win_x1 - res_comp2->win_x0) *
+ (OPJ_SIZE_T)(res_comp2->win_y1 - res_comp2->win_y0) != l_samples) {
+ opj_event_msg(p_manager, EVT_ERROR,
+ "Tiles don't all have the same dimension. Skip the MCT step.\n");
+ return OPJ_FALSE;
+ }
+ }
+ }
if (l_tile->numcomps >= 3) {
- /* testcase 1336.pdf.asan.47.376 */
- if ((l_tile->comps[0].x1 - l_tile->comps[0].x0) * (l_tile->comps[0].y1 -
- l_tile->comps[0].y0) < (OPJ_INT32)l_samples ||
- (l_tile->comps[1].x1 - l_tile->comps[1].x0) * (l_tile->comps[1].y1 -
- l_tile->comps[1].y0) < (OPJ_INT32)l_samples ||
- (l_tile->comps[2].x1 - l_tile->comps[2].x0) * (l_tile->comps[2].y1 -
- l_tile->comps[2].y0) < (OPJ_INT32)l_samples) {
- opj_event_msg(p_manager, EVT_ERROR,
- "Tiles don't all have the same dimension. Skip the MCT step.\n");
- return OPJ_FALSE;
- } else if (l_tcp->mct == 2) {
+ if (l_tcp->mct == 2) {
OPJ_BYTE ** l_data;
if (! l_tcp->m_mct_decoding_matrix) {
@@ -1823,7 +2107,11 @@ static OPJ_BOOL opj_tcd_mct_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
}
for (i = 0; i < l_tile->numcomps; ++i) {
- l_data[i] = (OPJ_BYTE*) l_tile_comp->data;
+ if (p_tcd->whole_tile_decoding) {
+ l_data[i] = (OPJ_BYTE*) l_tile_comp->data;
+ } else {
+ l_data[i] = (OPJ_BYTE*) l_tile_comp->data_win;
+ }
++l_tile_comp;
}
@@ -1844,15 +2132,29 @@ static OPJ_BOOL opj_tcd_mct_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
opj_free(l_data);
} else {
if (l_tcp->tccps->qmfbid == 1) {
- opj_mct_decode(l_tile->comps[0].data,
- l_tile->comps[1].data,
- l_tile->comps[2].data,
- l_samples);
+ if (p_tcd->whole_tile_decoding) {
+ opj_mct_decode(l_tile->comps[0].data,
+ l_tile->comps[1].data,
+ l_tile->comps[2].data,
+ l_samples);
+ } else {
+ opj_mct_decode(l_tile->comps[0].data_win,
+ l_tile->comps[1].data_win,
+ l_tile->comps[2].data_win,
+ l_samples);
+ }
} else {
- opj_mct_decode_real((OPJ_FLOAT32*)l_tile->comps[0].data,
- (OPJ_FLOAT32*)l_tile->comps[1].data,
- (OPJ_FLOAT32*)l_tile->comps[2].data,
- l_samples);
+ if (p_tcd->whole_tile_decoding) {
+ opj_mct_decode_real((OPJ_FLOAT32*)l_tile->comps[0].data,
+ (OPJ_FLOAT32*)l_tile->comps[1].data,
+ (OPJ_FLOAT32*)l_tile->comps[2].data,
+ l_samples);
+ } else {
+ opj_mct_decode_real((OPJ_FLOAT32*)l_tile->comps[0].data_win,
+ (OPJ_FLOAT32*)l_tile->comps[1].data_win,
+ (OPJ_FLOAT32*)l_tile->comps[2].data_win,
+ l_samples);
+ }
}
}
} else {
@@ -1883,14 +2185,32 @@ static OPJ_BOOL opj_tcd_dc_level_shift_decode(opj_tcd_t *p_tcd)
l_tccp = p_tcd->tcp->tccps;
l_img_comp = p_tcd->image->comps;
- for (compno = 0; compno < l_tile->numcomps; compno++) {
+ for (compno = 0; compno < l_tile->numcomps;
+ compno++, ++l_img_comp, ++l_tccp, ++l_tile_comp) {
+
+ if (p_tcd->used_component != NULL && !p_tcd->used_component[compno]) {
+ continue;
+ }
+
l_res = l_tile_comp->resolutions + l_img_comp->resno_decoded;
- l_width = (OPJ_UINT32)(l_res->x1 - l_res->x0);
- l_height = (OPJ_UINT32)(l_res->y1 - l_res->y0);
- l_stride = (OPJ_UINT32)(l_tile_comp->x1 - l_tile_comp->x0) - l_width;
- assert(l_height == 0 ||
- l_width + l_stride <= l_tile_comp->data_size / l_height); /*MUPDF*/
+ if (!p_tcd->whole_tile_decoding) {
+ l_width = l_res->win_x1 - l_res->win_x0;
+ l_height = l_res->win_y1 - l_res->win_y0;
+ l_stride = 0;
+ l_current_ptr = l_tile_comp->data_win;
+ } else {
+ l_width = (OPJ_UINT32)(l_res->x1 - l_res->x0);
+ l_height = (OPJ_UINT32)(l_res->y1 - l_res->y0);
+ l_stride = (OPJ_UINT32)(
+ l_tile_comp->resolutions[l_tile_comp->minimum_num_resolutions - 1].x1 -
+ l_tile_comp->resolutions[l_tile_comp->minimum_num_resolutions - 1].x0)
+ - l_width;
+ l_current_ptr = l_tile_comp->data;
+
+ assert(l_height == 0 ||
+ l_width + l_stride <= l_tile_comp->data_size / l_height); /*MUPDF*/
+ }
if (l_img_comp->sgnd) {
l_min = -(1 << (l_img_comp->prec - 1));
@@ -1900,11 +2220,11 @@ static OPJ_BOOL opj_tcd_dc_level_shift_decode(opj_tcd_t *p_tcd)
l_max = (OPJ_INT32)((1U << l_img_comp->prec) - 1);
}
- l_current_ptr = l_tile_comp->data;
if (l_tccp->qmfbid == 1) {
for (j = 0; j < l_height; ++j) {
for (i = 0; i < l_width; ++i) {
+ /* TODO: do addition on int64 ? */
*l_current_ptr = opj_int_clamp(*l_current_ptr + l_tccp->m_dc_level_shift, l_min,
l_max);
++l_current_ptr;
@@ -1915,13 +2235,14 @@ static OPJ_BOOL opj_tcd_dc_level_shift_decode(opj_tcd_t *p_tcd)
for (j = 0; j < l_height; ++j) {
for (i = 0; i < l_width; ++i) {
OPJ_FLOAT32 l_value = *((OPJ_FLOAT32 *) l_current_ptr);
- OPJ_INT32 l_value_int = (OPJ_INT32)opj_lrintf(l_value);
- if (l_value > INT_MAX ||
- (l_value_int > 0 && l_tccp->m_dc_level_shift > 0 &&
- l_value_int > INT_MAX - l_tccp->m_dc_level_shift)) {
+ if (l_value > INT_MAX) {
*l_current_ptr = l_max;
+ } else if (l_value < INT_MIN) {
+ *l_current_ptr = l_min;
} else {
- *l_current_ptr = opj_int_clamp(
+ /* Do addition on int64 to avoid overflows */
+ OPJ_INT64 l_value_int = (OPJ_INT64)opj_lrintf(l_value);
+ *l_current_ptr = (OPJ_INT32)opj_int64_clamp(
l_value_int + l_tccp->m_dc_level_shift, l_min, l_max);
}
++l_current_ptr;
@@ -1929,10 +2250,6 @@ static OPJ_BOOL opj_tcd_dc_level_shift_decode(opj_tcd_t *p_tcd)
l_current_ptr += l_stride;
}
}
-
- ++l_img_comp;
- ++l_tccp;
- ++l_tile_comp;
}
return OPJ_TRUE;
@@ -1955,7 +2272,8 @@ static void opj_tcd_code_block_dec_deallocate(opj_tcd_precinct_t * p_precinct)
l_code_block->numbps, l_code_block->numlenbits, l_code_block->len, l_code_block->numnewpasses, l_code_block->real_num_segs, l_code_block->m_current_max_segs );*/
- l_nb_code_blocks = p_precinct->block_size / sizeof(opj_tcd_cblk_dec_t);
+ l_nb_code_blocks = p_precinct->block_size / (OPJ_UINT32)sizeof(
+ opj_tcd_cblk_dec_t);
/*fprintf(stderr,"nb_code_blocks =%d\t}\n", l_nb_code_blocks);*/
for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) {
@@ -1970,6 +2288,9 @@ static void opj_tcd_code_block_dec_deallocate(opj_tcd_precinct_t * p_precinct)
l_code_block->chunks = 00;
}
+ opj_aligned_free(l_code_block->decoded_data);
+ l_code_block->decoded_data = NULL;
+
++l_code_block;
}
@@ -1987,7 +2308,8 @@ static void opj_tcd_code_block_enc_deallocate(opj_tcd_precinct_t * p_precinct)
opj_tcd_cblk_enc_t * l_code_block = p_precinct->cblks.enc;
if (l_code_block) {
- l_nb_code_blocks = p_precinct->block_size / sizeof(opj_tcd_cblk_enc_t);
+ l_nb_code_blocks = p_precinct->block_size / (OPJ_UINT32)sizeof(
+ opj_tcd_cblk_enc_t);
for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) {
if (l_code_block->data) {
@@ -2015,9 +2337,10 @@ static void opj_tcd_code_block_enc_deallocate(opj_tcd_precinct_t * p_precinct)
}
}
-OPJ_UINT32 opj_tcd_get_encoded_tile_size(opj_tcd_t *p_tcd)
+OPJ_SIZE_T opj_tcd_get_encoded_tile_size(opj_tcd_t *p_tcd)
{
- OPJ_UINT32 i, l_data_size = 0;
+ OPJ_UINT32 i;
+ OPJ_SIZE_T l_data_size = 0;
opj_image_comp_t * l_img_comp = 00;
opj_tcd_tilecomp_t * l_tilec = 00;
OPJ_UINT32 l_size_comp, l_remaining;
@@ -2036,8 +2359,8 @@ OPJ_UINT32 opj_tcd_get_encoded_tile_size(opj_tcd_t *p_tcd)
l_size_comp = 4;
}
- l_data_size += l_size_comp * (OPJ_UINT32)((l_tilec->x1 - l_tilec->x0) *
- (l_tilec->y1 - l_tilec->y0));
+ l_data_size += l_size_comp * ((OPJ_SIZE_T)(l_tilec->x1 - l_tilec->x0) *
+ (OPJ_SIZE_T)(l_tilec->y1 - l_tilec->y0));
++l_img_comp;
++l_tilec;
}
@@ -2052,7 +2375,7 @@ static OPJ_BOOL opj_tcd_dc_level_shift_encode(opj_tcd_t *p_tcd)
opj_tccp_t * l_tccp = 00;
opj_image_comp_t * l_img_comp = 00;
opj_tcd_tile_t * l_tile;
- OPJ_UINT32 l_nb_elem, i;
+ OPJ_SIZE_T l_nb_elem, i;
OPJ_INT32 * l_current_ptr;
l_tile = p_tcd->tcd_image->tiles;
@@ -2062,8 +2385,8 @@ static OPJ_BOOL opj_tcd_dc_level_shift_encode(opj_tcd_t *p_tcd)
for (compno = 0; compno < l_tile->numcomps; compno++) {
l_current_ptr = l_tile_comp->data;
- l_nb_elem = (OPJ_UINT32)((l_tile_comp->x1 - l_tile_comp->x0) *
- (l_tile_comp->y1 - l_tile_comp->y0));
+ l_nb_elem = (OPJ_SIZE_T)(l_tile_comp->x1 - l_tile_comp->x0) *
+ (OPJ_SIZE_T)(l_tile_comp->y1 - l_tile_comp->y0);
if (l_tccp->qmfbid == 1) {
for (i = 0; i < l_nb_elem; ++i) {
@@ -2089,8 +2412,8 @@ static OPJ_BOOL opj_tcd_mct_encode(opj_tcd_t *p_tcd)
{
opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
opj_tcd_tilecomp_t * l_tile_comp = p_tcd->tcd_image->tiles->comps;
- OPJ_UINT32 samples = (OPJ_UINT32)((l_tile_comp->x1 - l_tile_comp->x0) *
- (l_tile_comp->y1 - l_tile_comp->y0));
+ OPJ_SIZE_T samples = (OPJ_SIZE_T)(l_tile_comp->x1 - l_tile_comp->x0) *
+ (OPJ_SIZE_T)(l_tile_comp->y1 - l_tile_comp->y0);
OPJ_UINT32 i;
OPJ_BYTE ** l_data = 00;
opj_tcp_t * l_tcp = p_tcd->tcp;
@@ -2205,7 +2528,8 @@ static OPJ_BOOL opj_tcd_t2_encode(opj_tcd_t *p_tcd,
OPJ_BYTE * p_dest_data,
OPJ_UINT32 * p_data_written,
OPJ_UINT32 p_max_dest_size,
- opj_codestream_info_t *p_cstr_info)
+ opj_codestream_info_t *p_cstr_info,
+ opj_event_mgr_t *p_manager)
{
opj_t2_t * l_t2;
@@ -2226,7 +2550,8 @@ static OPJ_BOOL opj_tcd_t2_encode(opj_tcd_t *p_tcd,
p_tcd->tp_num,
p_tcd->tp_pos,
p_tcd->cur_pino,
- FINAL_PASS)) {
+ FINAL_PASS,
+ p_manager)) {
opj_t2_destroy(l_t2);
return OPJ_FALSE;
}
@@ -2241,7 +2566,8 @@ static OPJ_BOOL opj_tcd_t2_encode(opj_tcd_t *p_tcd,
static OPJ_BOOL opj_tcd_rate_allocate_encode(opj_tcd_t *p_tcd,
OPJ_BYTE * p_dest_data,
OPJ_UINT32 p_max_dest_size,
- opj_codestream_info_t *p_cstr_info)
+ opj_codestream_info_t *p_cstr_info,
+ opj_event_mgr_t *p_manager)
{
opj_cp_t * l_cp = p_tcd->cp;
OPJ_UINT32 l_nb_written = 0;
@@ -2255,7 +2581,7 @@ static OPJ_BOOL opj_tcd_rate_allocate_encode(opj_tcd_t *p_tcd,
/* fixed_quality */
/* Normal Rate/distortion allocation */
if (! opj_tcd_rateallocate(p_tcd, p_dest_data, &l_nb_written, p_max_dest_size,
- p_cstr_info)) {
+ p_cstr_info, p_manager)) {
return OPJ_FALSE;
}
} else {
@@ -2269,13 +2595,15 @@ static OPJ_BOOL opj_tcd_rate_allocate_encode(opj_tcd_t *p_tcd,
OPJ_BOOL opj_tcd_copy_tile_data(opj_tcd_t *p_tcd,
OPJ_BYTE * p_src,
- OPJ_UINT32 p_src_length)
+ OPJ_SIZE_T p_src_length)
{
- OPJ_UINT32 i, j, l_data_size = 0;
+ OPJ_UINT32 i;
+ OPJ_SIZE_T j;
+ OPJ_SIZE_T l_data_size = 0;
opj_image_comp_t * l_img_comp = 00;
opj_tcd_tilecomp_t * l_tilec = 00;
OPJ_UINT32 l_size_comp, l_remaining;
- OPJ_UINT32 l_nb_elem;
+ OPJ_SIZE_T l_nb_elem;
l_data_size = opj_tcd_get_encoded_tile_size(p_tcd);
if (l_data_size != p_src_length) {
@@ -2287,8 +2615,8 @@ OPJ_BOOL opj_tcd_copy_tile_data(opj_tcd_t *p_tcd,
for (i = 0; i < p_tcd->image->numcomps; ++i) {
l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
l_remaining = l_img_comp->prec & 7; /* (%8) */
- l_nb_elem = (OPJ_UINT32)((l_tilec->x1 - l_tilec->x0) * (l_tilec->y1 -
- l_tilec->y0));
+ l_nb_elem = (OPJ_SIZE_T)(l_tilec->x1 - l_tilec->x0) *
+ (OPJ_SIZE_T)(l_tilec->y1 - l_tilec->y0);
if (l_remaining) {
++l_size_comp;
@@ -2357,3 +2685,125 @@ OPJ_BOOL opj_tcd_is_band_empty(opj_tcd_band_t* band)
{
return (band->x1 - band->x0 == 0) || (band->y1 - band->y0 == 0);
}
+
+OPJ_BOOL opj_tcd_is_subband_area_of_interest(opj_tcd_t *tcd,
+ OPJ_UINT32 compno,
+ OPJ_UINT32 resno,
+ OPJ_UINT32 bandno,
+ OPJ_UINT32 band_x0,
+ OPJ_UINT32 band_y0,
+ OPJ_UINT32 band_x1,
+ OPJ_UINT32 band_y1)
+{
+ /* Note: those values for filter_margin are in part the result of */
+ /* experimentation. The value 2 for QMFBID=1 (5x3 filter) can be linked */
+ /* to the maximum left/right extension given in tables F.2 and F.3 of the */
+ /* standard. The value 3 for QMFBID=0 (9x7 filter) is more suspicious, */
+ /* since F.2 and F.3 would lead to 4 instead, so the current 3 might be */
+ /* needed to be bumped to 4, in case inconsistencies are found while */
+ /* decoding parts of irreversible coded images. */
+ /* See opj_dwt_decode_partial_53 and opj_dwt_decode_partial_97 as well */
+ OPJ_UINT32 filter_margin = (tcd->tcp->tccps[compno].qmfbid == 1) ? 2 : 3;
+ opj_tcd_tilecomp_t *tilec = &(tcd->tcd_image->tiles->comps[compno]);
+ opj_image_comp_t* image_comp = &(tcd->image->comps[compno]);
+ /* Compute the intersection of the area of interest, expressed in tile coordinates */
+ /* with the tile coordinates */
+ OPJ_UINT32 tcx0 = opj_uint_max(
+ (OPJ_UINT32)tilec->x0,
+ opj_uint_ceildiv(tcd->win_x0, image_comp->dx));
+ OPJ_UINT32 tcy0 = opj_uint_max(
+ (OPJ_UINT32)tilec->y0,
+ opj_uint_ceildiv(tcd->win_y0, image_comp->dy));
+ OPJ_UINT32 tcx1 = opj_uint_min(
+ (OPJ_UINT32)tilec->x1,
+ opj_uint_ceildiv(tcd->win_x1, image_comp->dx));
+ OPJ_UINT32 tcy1 = opj_uint_min(
+ (OPJ_UINT32)tilec->y1,
+ opj_uint_ceildiv(tcd->win_y1, image_comp->dy));
+ /* Compute number of decomposition for this band. See table F-1 */
+ OPJ_UINT32 nb = (resno == 0) ?
+ tilec->numresolutions - 1 :
+ tilec->numresolutions - resno;
+ /* Map above tile-based coordinates to sub-band-based coordinates per */
+ /* equation B-15 of the standard */
+ OPJ_UINT32 x0b = bandno & 1;
+ OPJ_UINT32 y0b = bandno >> 1;
+ OPJ_UINT32 tbx0 = (nb == 0) ? tcx0 :
+ (tcx0 <= (1U << (nb - 1)) * x0b) ? 0 :
+ opj_uint_ceildivpow2(tcx0 - (1U << (nb - 1)) * x0b, nb);
+ OPJ_UINT32 tby0 = (nb == 0) ? tcy0 :
+ (tcy0 <= (1U << (nb - 1)) * y0b) ? 0 :
+ opj_uint_ceildivpow2(tcy0 - (1U << (nb - 1)) * y0b, nb);
+ OPJ_UINT32 tbx1 = (nb == 0) ? tcx1 :
+ (tcx1 <= (1U << (nb - 1)) * x0b) ? 0 :
+ opj_uint_ceildivpow2(tcx1 - (1U << (nb - 1)) * x0b, nb);
+ OPJ_UINT32 tby1 = (nb == 0) ? tcy1 :
+ (tcy1 <= (1U << (nb - 1)) * y0b) ? 0 :
+ opj_uint_ceildivpow2(tcy1 - (1U << (nb - 1)) * y0b, nb);
+ OPJ_BOOL intersects;
+
+ if (tbx0 < filter_margin) {
+ tbx0 = 0;
+ } else {
+ tbx0 -= filter_margin;
+ }
+ if (tby0 < filter_margin) {
+ tby0 = 0;
+ } else {
+ tby0 -= filter_margin;
+ }
+ tbx1 = opj_uint_adds(tbx1, filter_margin);
+ tby1 = opj_uint_adds(tby1, filter_margin);
+
+ intersects = band_x0 < tbx1 && band_y0 < tby1 && band_x1 > tbx0 &&
+ band_y1 > tby0;
+
+#ifdef DEBUG_VERBOSE
+ printf("compno=%u resno=%u nb=%u bandno=%u x0b=%u y0b=%u band=%u,%u,%u,%u tb=%u,%u,%u,%u -> %u\n",
+ compno, resno, nb, bandno, x0b, y0b,
+ band_x0, band_y0, band_x1, band_y1,
+ tbx0, tby0, tbx1, tby1, intersects);
+#endif
+ return intersects;
+}
+
+/** Returns whether a tile componenent is fully decoded, taking into account
+ * p_tcd->win_* members.
+ *
+ * @param p_tcd TCD handle.
+ * @param compno Component number
+ * @return OPJ_TRUE whether the tile componenent is fully decoded
+ */
+static OPJ_BOOL opj_tcd_is_whole_tilecomp_decoding(opj_tcd_t *p_tcd,
+ OPJ_UINT32 compno)
+{
+ opj_tcd_tilecomp_t* tilec = &(p_tcd->tcd_image->tiles->comps[compno]);
+ opj_image_comp_t* image_comp = &(p_tcd->image->comps[compno]);
+ /* Compute the intersection of the area of interest, expressed in tile coordinates */
+ /* with the tile coordinates */
+ OPJ_UINT32 tcx0 = opj_uint_max(
+ (OPJ_UINT32)tilec->x0,
+ opj_uint_ceildiv(p_tcd->win_x0, image_comp->dx));
+ OPJ_UINT32 tcy0 = opj_uint_max(
+ (OPJ_UINT32)tilec->y0,
+ opj_uint_ceildiv(p_tcd->win_y0, image_comp->dy));
+ OPJ_UINT32 tcx1 = opj_uint_min(
+ (OPJ_UINT32)tilec->x1,
+ opj_uint_ceildiv(p_tcd->win_x1, image_comp->dx));
+ OPJ_UINT32 tcy1 = opj_uint_min(
+ (OPJ_UINT32)tilec->y1,
+ opj_uint_ceildiv(p_tcd->win_y1, image_comp->dy));
+
+ OPJ_UINT32 shift = tilec->numresolutions - tilec->minimum_num_resolutions;
+ /* Tolerate small margin within the reduced resolution factor to consider if */
+ /* the whole tile path must be taken */
+ return (tcx0 >= (OPJ_UINT32)tilec->x0 &&
+ tcy0 >= (OPJ_UINT32)tilec->y0 &&
+ tcx1 <= (OPJ_UINT32)tilec->x1 &&
+ tcy1 <= (OPJ_UINT32)tilec->y1 &&
+ (shift >= 32 ||
+ (((tcx0 - (OPJ_UINT32)tilec->x0) >> shift) == 0 &&
+ ((tcy0 - (OPJ_UINT32)tilec->y0) >> shift) == 0 &&
+ (((OPJ_UINT32)tilec->x1 - tcx1) >> shift) == 0 &&
+ (((OPJ_UINT32)tilec->y1 - tcy1) >> shift) == 0)));
+}
diff --git a/third_party/libopenjpeg20/tcd.h b/third_party/libopenjpeg20/tcd.h
index 3f40b3595b..e3214c1d98 100644
--- a/third_party/libopenjpeg20/tcd.h
+++ b/third_party/libopenjpeg20/tcd.h
@@ -13,6 +13,7 @@
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR
* Copyright (c) 2012, CS Systemes d'Information, France
+ * Copyright (c) 2017, IntoPIX SA <support@intopix.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -133,6 +134,8 @@ typedef struct opj_tcd_cblk_dec {
OPJ_UINT32 m_current_max_segs; /* allocated number of segs[] items */
OPJ_UINT32 numchunks; /* Number of valid chunks items */
OPJ_UINT32 numchunksalloc; /* Number of chunks item allocated */
+ /* Decoded code-block. Only used for subtile decoding. Otherwise tilec->data is directly updated */
+ OPJ_INT32* decoded_data;
} opj_tcd_cblk_dec_t;
/** Precinct structure */
@@ -174,12 +177,20 @@ typedef struct opj_tcd_resolution {
OPJ_UINT32 numbands;
/* subband information */
opj_tcd_band_t bands[3];
+
+ /* dimension of the resolution limited to window of interest. Only valid if tcd->whole_tile_decoding is set */
+ OPJ_UINT32 win_x0;
+ OPJ_UINT32 win_y0;
+ OPJ_UINT32 win_x1;
+ OPJ_UINT32 win_y1;
} opj_tcd_resolution_t;
/** Tile-component structure */
typedef struct opj_tcd_tilecomp {
/* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */
OPJ_INT32 x0, y0, x1, y1;
+ /* component number */
+ OPJ_UINT32 compno;
/* number of resolutions level */
OPJ_UINT32 numresolutions;
/* number of resolutions level to decode (at max)*/
@@ -188,14 +199,24 @@ typedef struct opj_tcd_tilecomp {
opj_tcd_resolution_t *resolutions;
/* size of data for resolutions (in bytes) */
OPJ_UINT32 resolutions_size;
- /* data of the component */
+
+ /* data of the component. For decoding, only valid if tcd->whole_tile_decoding is set (so exclusive of data_win member) */
OPJ_INT32 *data;
/* if true, then need to free after usage, otherwise do not free */
OPJ_BOOL ownsData;
/* we may either need to allocate this amount of data, or re-use image data and ignore this value */
- OPJ_UINT32 data_size_needed;
+ size_t data_size_needed;
/* size of the data of the component */
- OPJ_UINT32 data_size;
+ size_t data_size;
+
+ /** data of the component limited to window of interest. Only valid for decoding and if tcd->whole_tile_decoding is NOT set (so exclusive of data member) */
+ OPJ_INT32 *data_win;
+ /* dimension of the component limited to window of interest. Only valid for decoding and if tcd->whole_tile_decoding is NOT set */
+ OPJ_UINT32 win_x0;
+ OPJ_UINT32 win_y0;
+ OPJ_UINT32 win_x1;
+ OPJ_UINT32 win_y1;
+
/* add fixed_quality */
OPJ_INT32 numpix;
} opj_tcd_tilecomp_t;
@@ -252,6 +273,15 @@ typedef struct opj_tcd {
OPJ_BITFIELD m_is_decoder : 1;
/** Thread pool */
opj_thread_pool_t* thread_pool;
+ /** Coordinates of the window of interest, in grid reference space */
+ OPJ_UINT32 win_x0;
+ OPJ_UINT32 win_y0;
+ OPJ_UINT32 win_x1;
+ OPJ_UINT32 win_y1;
+ /** Only valid for decoding. Whether the whole tile is decoded, or just the region in win_x0/win_y0/win_x1/win_y1 */
+ OPJ_BOOL whole_tile_decoding;
+ /* Array of size image->numcomps indicating if a component must be decoded. NULL if all components must be decoded */
+ OPJ_BOOL* used_component;
} opj_tcd_t;
/** @name Exported functions */
@@ -317,12 +347,14 @@ OPJ_BOOL opj_tcd_rateallocate(opj_tcd_t *tcd,
OPJ_BYTE *dest,
OPJ_UINT32 * p_data_written,
OPJ_UINT32 len,
- opj_codestream_info_t *cstr_info);
+ opj_codestream_info_t *cstr_info,
+ opj_event_mgr_t *p_manager);
/**
* Gets the maximum tile size that will be taken by the tile once decoded.
*/
-OPJ_UINT32 opj_tcd_get_decoded_tile_size(opj_tcd_t *p_tcd);
+OPJ_UINT32 opj_tcd_get_decoded_tile_size(opj_tcd_t *p_tcd,
+ OPJ_BOOL take_into_account_partial_decoding);
/**
* Encodes a tile from the raw image into the given buffer.
@@ -332,6 +364,7 @@ OPJ_UINT32 opj_tcd_get_decoded_tile_size(opj_tcd_t *p_tcd);
* @param p_data_written pointer to an int that is incremented by the number of bytes really written on p_dest
* @param p_len Maximum length of the destination buffer
* @param p_cstr_info Codestream information structure
+ * @param p_manager the user event manager
* @return true if the coding is successful.
*/
OPJ_BOOL opj_tcd_encode_tile(opj_tcd_t *p_tcd,
@@ -339,12 +372,21 @@ OPJ_BOOL opj_tcd_encode_tile(opj_tcd_t *p_tcd,
OPJ_BYTE *p_dest,
OPJ_UINT32 * p_data_written,
OPJ_UINT32 p_len,
- struct opj_codestream_info *p_cstr_info);
+ struct opj_codestream_info *p_cstr_info,
+ opj_event_mgr_t *p_manager);
/**
Decode a tile from a buffer into a raw image
@param tcd TCD handle
+@param win_x0 Upper left x of region to decode (in grid coordinates)
+@param win_y0 Upper left y of region to decode (in grid coordinates)
+@param win_x1 Lower right x of region to decode (in grid coordinates)
+@param win_y1 Lower right y of region to decode (in grid coordinates)
+@param numcomps_to_decode Size of the comps_indices array, or 0 if decoding all components.
+@param comps_indices Array of numcomps values representing the indices
+ of the components to decode (relative to the
+ codestream, starting at 0). Or NULL if decoding all components.
@param src Source buffer
@param len Length of source buffer
@param tileno Number that identifies one of the tiles to be decoded
@@ -352,6 +394,12 @@ Decode a tile from a buffer into a raw image
@param manager the event manager.
*/
OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *tcd,
+ OPJ_UINT32 win_x0,
+ OPJ_UINT32 win_y0,
+ OPJ_UINT32 win_x1,
+ OPJ_UINT32 win_y1,
+ OPJ_UINT32 numcomps_to_decode,
+ const OPJ_UINT32 *comps_indices,
OPJ_BYTE *src,
OPJ_UINT32 len,
OPJ_UINT32 tileno,
@@ -369,7 +417,7 @@ OPJ_BOOL opj_tcd_update_tile_data(opj_tcd_t *p_tcd,
/**
*
*/
-OPJ_UINT32 opj_tcd_get_encoded_tile_size(opj_tcd_t *p_tcd);
+OPJ_SIZE_T opj_tcd_get_encoded_tile_size(opj_tcd_t *p_tcd);
/**
* Initialize the tile coder and may reuse some meory.
@@ -388,7 +436,7 @@ OPJ_BOOL opj_tcd_init_encode_tile(opj_tcd_t *p_tcd,
*/
OPJ_BOOL opj_tcd_copy_tile_data(opj_tcd_t *p_tcd,
OPJ_BYTE * p_src,
- OPJ_UINT32 p_src_length);
+ OPJ_SIZE_T p_src_length);
/**
* Allocates tile component data
@@ -406,6 +454,30 @@ OPJ_BOOL opj_tcd_is_band_empty(opj_tcd_band_t* band);
/** Reinitialize a segment */
void opj_tcd_reinit_segment(opj_tcd_seg_t* seg);
+
+/** Returns whether a sub-band region contributes to the area of interest
+ * tcd->win_x0,tcd->win_y0,tcd->win_x1,tcd->win_y1.
+ *
+ * @param tcd TCD handle.
+ * @param compno Component number
+ * @param resno Resolution number
+ * @param bandno Band number (*not* band index, ie 0, 1, 2 or 3)
+ * @param x0 Upper left x in subband coordinates
+ * @param y0 Upper left y in subband coordinates
+ * @param x1 Lower right x in subband coordinates
+ * @param y1 Lower right y in subband coordinates
+ * @return OPJ_TRUE whether the sub-band region contributs to the area of
+ * interest.
+ */
+OPJ_BOOL opj_tcd_is_subband_area_of_interest(opj_tcd_t *tcd,
+ OPJ_UINT32 compno,
+ OPJ_UINT32 resno,
+ OPJ_UINT32 bandno,
+ OPJ_UINT32 x0,
+ OPJ_UINT32 y0,
+ OPJ_UINT32 x1,
+ OPJ_UINT32 y1);
+
/* ----------------------------------------------------------------------- */
/*@}*/
diff --git a/third_party/libopenjpeg20/thread.c b/third_party/libopenjpeg20/thread.c
index 8b56aa4d5c..af33c2c806 100644
--- a/third_party/libopenjpeg20/thread.c
+++ b/third_party/libopenjpeg20/thread.c
@@ -29,9 +29,6 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
-#include "opj_includes.h"
-
-#include "thread.h"
#include <assert.h>
#ifdef MUTEX_win32
@@ -46,6 +43,8 @@
#include <windows.h>
#include <process.h>
+#include "opj_includes.h"
+
OPJ_BOOL OPJ_CALLCONV opj_has_thread_support(void)
{
return OPJ_TRUE;
@@ -289,6 +288,10 @@ void opj_thread_join(opj_thread_t* thread)
#include <stdlib.h>
#include <unistd.h>
+/* Moved after all system includes, and in particular pthread.h, so as to */
+/* avoid poisoning issuing with malloc() use in pthread.h with ulibc (#1013) */
+#include "opj_includes.h"
+
OPJ_BOOL OPJ_CALLCONV opj_has_thread_support(void)
{
return OPJ_TRUE;
@@ -425,6 +428,8 @@ void opj_thread_join(opj_thread_t* thread)
#else
/* Stub implementation */
+#include "opj_includes.h"
+
OPJ_BOOL OPJ_CALLCONV opj_has_thread_support(void)
{
return OPJ_FALSE;