wipcancel

15 files changed, 332 insertions, 182 deletions

diff --git a/src/lib/openjp2/dwt.c b/src/lib/openjp2/dwt.c
index 6b18c5dd..d0e24afe 100644
--- a/src/lib/openjp2/dwt.c
+++ b/src/lib/openjp2/dwt.c
@@ -139,8 +139,8 @@ 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);
+static OPJ_RESULT opj_dwt_decode_tile(opj_thread_pool_t* tp,
+                                      opj_tcd_tilecomp_t* tilec, OPJ_UINT32 i, opj_cancel_t* cancel);
 
 static OPJ_BOOL opj_dwt_decode_partial_tile(
     opj_tcd_tilecomp_t* tilec,
@@ -1910,11 +1910,11 @@ OPJ_BOOL opj_dwt_encode(opj_tcd_t *p_tcd,
 /* <summary>                            */
 /* Inverse 5-3 wavelet transform in 2-D. */
 /* </summary>                           */
-OPJ_BOOL opj_dwt_decode(opj_tcd_t *p_tcd, opj_tcd_tilecomp_t* tilec,
-                        OPJ_UINT32 numres)
+OPJ_RESULT opj_dwt_decode(opj_tcd_t *p_tcd, opj_tcd_tilecomp_t* tilec,
+                          OPJ_UINT32 numres, opj_cancel_t* cancel)
 {
     if (p_tcd->whole_tile_decoding) {
-        return opj_dwt_decode_tile(p_tcd->thread_pool, tilec, numres);
+        return opj_dwt_decode_tile(p_tcd->thread_pool, tilec, numres, cancel);
     } else {
         return opj_dwt_decode_partial_tile(tilec, numres);
     }
@@ -2064,8 +2064,8 @@ static void opj_dwt_decode_v_func(void* user_data, opj_tls_t* tls)
 /* <summary>                            */
 /* Inverse wavelet transform in 2-D.    */
 /* </summary>                           */
-static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
-                                    opj_tcd_tilecomp_t* tilec, OPJ_UINT32 numres)
+static OPJ_RESULT opj_dwt_decode_tile(opj_thread_pool_t* tp,
+                                      opj_tcd_tilecomp_t* tilec, OPJ_UINT32 numres, opj_cancel_t* cancel)
 {
     opj_dwt_t h;
     opj_dwt_t v;
@@ -2086,14 +2086,14 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
     /* Not entirely sure for the return code of w == 0 which is triggered per */
     /* https://github.com/uclouvain/openjpeg/issues/1505 */
     if (numres == 1U || w == 0) {
-        return OPJ_TRUE;
+        return OPJ_SUCCESS;
     }
     num_threads = opj_thread_pool_get_thread_count(tp);
     h_mem_size = opj_dwt_max_resolution(tr, numres);
     /* overflow check */
     if (h_mem_size > (SIZE_MAX / PARALLEL_COLS_53 / sizeof(OPJ_INT32))) {
         /* FIXME event manager error callback */
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
     /* We need PARALLEL_COLS_53 times the height of the array, */
     /* since for the vertical pass */
@@ -2102,7 +2102,7 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
     h.mem = (OPJ_INT32*)opj_aligned_32_malloc(h_mem_size);
     if (! h.mem) {
         /* FIXME event manager error callback */
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
 
     v.mem = h.mem;
@@ -2111,6 +2111,10 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
         OPJ_INT32 * OPJ_RESTRICT tiledp = tilec->data;
         OPJ_UINT32 j;
 
+        if (opj_should_cancel(cancel)) {
+            return OPJ_CANCEL;
+        }
+
         ++tr;
         h.sn = (OPJ_INT32)rw;
         v.sn = (OPJ_INT32)rh;
@@ -2145,7 +2149,7 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
                     /* FIXME event manager error callback */
                     opj_thread_pool_wait_completion(tp, 0);
                     opj_aligned_free(h.mem);
-                    return OPJ_FALSE;
+                    return OPJ_FAILURE;
                 }
                 job->h = h;
                 job->rw = rw;
@@ -2162,7 +2166,7 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
                     opj_thread_pool_wait_completion(tp, 0);
                     opj_free(job);
                     opj_aligned_free(h.mem);
-                    return OPJ_FALSE;
+                    return OPJ_FAILURE;
                 }
                 opj_thread_pool_submit_job(tp, opj_dwt_decode_h_func, job);
             }
@@ -2200,7 +2204,7 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
                     /* FIXME event manager error callback */
                     opj_thread_pool_wait_completion(tp, 0);
                     opj_aligned_free(v.mem);
-                    return OPJ_FALSE;
+                    return OPJ_FAILURE;
                 }
                 job->v = v;
                 job->rh = rh;
@@ -2217,7 +2221,7 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
                     opj_thread_pool_wait_completion(tp, 0);
                     opj_free(job);
                     opj_aligned_free(v.mem);
-                    return OPJ_FALSE;
+                    return OPJ_FAILURE;
                 }
                 opj_thread_pool_submit_job(tp, opj_dwt_decode_v_func, job);
             }
@@ -2225,7 +2229,7 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_thread_pool_t* tp,
         }
     }
     opj_aligned_free(h.mem);
-    return OPJ_TRUE;
+    return OPJ_SUCCESS;
 }
 
 static void opj_dwt_interleave_partial_h(OPJ_INT32 *dest,
@@ -3300,9 +3304,9 @@ static void opj_dwt97_decode_v_func(void* user_data, opj_tls_t* tls)
 /* Inverse 9-7 wavelet transform in 2-D. */
 /* </summary>                            */
 static
-OPJ_BOOL opj_dwt_decode_tile_97(opj_thread_pool_t* tp,
-                                opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
-                                OPJ_UINT32 numres)
+OPJ_RESULT opj_dwt_decode_tile_97(opj_thread_pool_t* tp,
+                                  opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
+                                  OPJ_UINT32 numres, opj_cancel_t* p_cancel)
 {
     opj_v8dwt_t h;
     opj_v8dwt_t v;
@@ -3322,19 +3326,19 @@ OPJ_BOOL opj_dwt_decode_tile_97(opj_thread_pool_t* tp,
     const int num_threads = opj_thread_pool_get_thread_count(tp);
 
     if (numres == 1) {
-        return OPJ_TRUE;
+        return OPJ_SUCCESS;
     }
 
     l_data_size = opj_dwt_max_resolution(res, numres);
     /* overflow check */
     if (l_data_size > (SIZE_MAX / sizeof(opj_v8_t))) {
         /* FIXME event manager error callback */
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
     h.wavelet = (opj_v8_t*) opj_aligned_malloc(l_data_size * sizeof(opj_v8_t));
     if (!h.wavelet) {
         /* FIXME event manager error callback */
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
     v.wavelet = h.wavelet;
 
@@ -3342,6 +3346,10 @@ OPJ_BOOL opj_dwt_decode_tile_97(opj_thread_pool_t* tp,
         OPJ_FLOAT32 * OPJ_RESTRICT aj = (OPJ_FLOAT32*) tilec->data;
         OPJ_UINT32 j;
 
+        if (opj_should_cancel(p_cancel)) {
+            return OPJ_FAILURE;
+        }
+
         h.sn = (OPJ_INT32)rw;
         v.sn = (OPJ_INT32)rh;
 
@@ -3397,14 +3405,14 @@ OPJ_BOOL opj_dwt_decode_tile_97(opj_thread_pool_t* tp,
                 if (!job) {
                     opj_thread_pool_wait_completion(tp, 0);
                     opj_aligned_free(h.wavelet);
-                    return OPJ_FALSE;
+                    return OPJ_FAILURE;
                 }
                 job->h.wavelet = (opj_v8_t*)opj_aligned_malloc(l_data_size * sizeof(opj_v8_t));
                 if (!job->h.wavelet) {
                     opj_thread_pool_wait_completion(tp, 0);
                     opj_free(job);
                     opj_aligned_free(h.wavelet);
-                    return OPJ_FALSE;
+                    return OPJ_FAILURE;
                 }
                 job->h.dn = h.dn;
                 job->h.sn = h.sn;
@@ -3757,12 +3765,12 @@ OPJ_BOOL opj_dwt_decode_partial_97(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)
+OPJ_RESULT opj_dwt_decode_real(opj_tcd_t *p_tcd,
+                               opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
+                               OPJ_UINT32 numres, opj_cancel_t* cancel)
 {
     if (p_tcd->whole_tile_decoding) {
-        return opj_dwt_decode_tile_97(p_tcd->thread_pool, tilec, numres);
+        return opj_dwt_decode_tile_97(p_tcd->thread_pool, tilec, numres, cancel);
     } else {
         return opj_dwt_decode_partial_97(tilec, numres);
     }
diff --git a/src/lib/openjp2/dwt.h b/src/lib/openjp2/dwt.h
index 215061e6..bc3f68ae 100644
--- a/src/lib/openjp2/dwt.h
+++ b/src/lib/openjp2/dwt.h
@@ -69,9 +69,9 @@ Apply a reversible inverse DWT transform to a component of an image.
 @param tilec Tile component information (current tile)
 @param numres Number of resolution levels to decode
 */
-OPJ_BOOL opj_dwt_decode(opj_tcd_t *p_tcd,
-                        opj_tcd_tilecomp_t* tilec,
-                        OPJ_UINT32 numres);
+OPJ_RESULT opj_dwt_decode(opj_tcd_t *p_tcd,
+                          opj_tcd_tilecomp_t* tilec,
+                          OPJ_UINT32 numres, opj_cancel_t* p_cancel);
 
 /**
 Get the norm of a wavelet function of a subband at a specified level for the reversible 5-3 DWT.
@@ -95,9 +95,9 @@ Apply an irreversible inverse DWT transform to a component of an image.
 @param tilec Tile component information (current tile)
 @param numres Number of resolution levels to decode
 */
-OPJ_BOOL opj_dwt_decode_real(opj_tcd_t *p_tcd,
-                             opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
-                             OPJ_UINT32 numres);
+OPJ_RESULT opj_dwt_decode_real(opj_tcd_t *p_tcd,
+                               opj_tcd_tilecomp_t* OPJ_RESTRICT tilec,
+                               OPJ_UINT32 numres, opj_cancel_t* cancel);
 
 /**
 Get the norm of a wavelet function of a subband at a specified level for the irreversible 9-7 DWT
diff --git a/src/lib/openjp2/j2k.c b/src/lib/openjp2/j2k.c
index 2b825b81..e6b511db 100644
--- a/src/lib/openjp2/j2k.c
+++ b/src/lib/openjp2/j2k.c
@@ -360,9 +360,10 @@ static void opj_j2k_copy_tile_quantization_parameters(opj_j2k_t *p_j2k);
 /**
  * Reads the tiles.
  */
-static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
-                                     opj_stream_private_t *p_stream,
-                                     opj_event_mgr_t * p_manager);
+static OPJ_RESULT opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
+                                       opj_stream_private_t *p_stream,
+                                       opj_event_mgr_t * p_manager,
+                                       opj_cancel_t * p_cancel);
 
 static OPJ_BOOL opj_j2k_pre_write_tile(opj_j2k_t * p_j2k,
                                        OPJ_UINT32 p_tile_index,
@@ -9856,12 +9857,13 @@ OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k,
     return OPJ_TRUE;
 }
 
-OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
-                             OPJ_UINT32 p_tile_index,
-                             OPJ_BYTE * p_data,
-                             OPJ_UINT32 p_data_size,
-                             opj_stream_private_t *p_stream,
-                             opj_event_mgr_t * p_manager)
+OPJ_RESULT opj_j2k_decode_tile(opj_j2k_t * p_j2k,
+                               OPJ_UINT32 p_tile_index,
+                               OPJ_BYTE * p_data,
+                               OPJ_UINT32 p_data_size,
+                               opj_stream_private_t *p_stream,
+                               opj_event_mgr_t * p_manager,
+                               opj_cancel_t * p_cancel)
 {
     OPJ_UINT32 l_current_marker;
     OPJ_BYTE l_data [2];
@@ -9875,13 +9877,13 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
 
     if (!(p_j2k->m_specific_param.m_decoder.m_state & J2K_STATE_DATA)
             || (p_tile_index != p_j2k->m_current_tile_number)) {
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
 
     l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
     if (! l_tcp->m_data) {
         opj_j2k_tcp_destroy(l_tcp);
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
 
     /* When using the opj_read_tile_header / opj_decode_tile_data API */
@@ -9901,11 +9903,11 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
                               l_tcp->m_data,
                               l_tcp->m_data_size,
                               p_tile_index,
-                              p_j2k->cstr_index, p_manager)) {
+                              p_j2k->cstr_index, p_manager, p_cancel)) {
         opj_j2k_tcp_destroy(l_tcp);
         p_j2k->m_specific_param.m_decoder.m_state |= J2K_STATE_ERR;
         opj_event_msg(p_manager, EVT_ERROR, "Failed to decode.\n");
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
 
     /* p_data can be set to NULL when the call will take care of using */
@@ -9913,7 +9915,7 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
     /* tile decoding optimization. */
     if (p_data != NULL) {
         if (! opj_tcd_update_tile_data(p_j2k->m_tcd, p_data, p_data_size)) {
-            return OPJ_FALSE;
+            return OPJ_FAILURE;
         }
 
         /* To avoid to destroy the tcp which can be useful when we try to decode a tile decoded before (cf j2k_random_tile_access)
@@ -9928,7 +9930,7 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
 
     if (opj_stream_get_number_byte_left(p_stream) == 0
             && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) {
-        return OPJ_TRUE;
+        return OPJ_SUCCESS;
     }
 
     if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_EOC) {
@@ -9946,14 +9948,14 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
             if (opj_stream_get_number_byte_left(p_stream) == 0) {
                 p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC;
                 opj_event_msg(p_manager, EVT_WARNING, "Stream does not end with EOC\n");
-                return OPJ_TRUE;
+                return OPJ_SUCCESS;
             }
             opj_event_msg(p_manager, EVT_ERROR, "Stream too short, expected SOT\n");
-            return OPJ_FALSE;
+            return OPJ_FAILURE;
         }
     }
 
-    return OPJ_TRUE;
+    return OPJ_SUCCESS;
 }
 
 static OPJ_BOOL opj_j2k_update_image_data(opj_tcd_t * p_tcd,
@@ -11671,9 +11673,10 @@ static OPJ_BOOL opj_j2k_are_all_used_components_decoded(opj_j2k_t *p_j2k,
 }
 
 
-static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
-                                     opj_stream_private_t *p_stream,
-                                     opj_event_mgr_t * p_manager)
+static OPJ_RESULT opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
+                                       opj_stream_private_t *p_stream,
+                                       opj_event_mgr_t * p_manager,
+                                       opj_cancel_t * p_cancel)
 {
     OPJ_BOOL l_go_on = OPJ_TRUE;
     OPJ_UINT32 l_current_tile_no;
@@ -11690,6 +11693,7 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
             p_j2k->m_output_image->x1 == p_j2k->m_cp.tdx &&
             p_j2k->m_output_image->y1 == p_j2k->m_cp.tdy) {
         OPJ_UINT32 i;
+        OPJ_RESULT r;
         if (! opj_j2k_read_tile_header(p_j2k,
                                        &l_current_tile_no,
                                        NULL,
@@ -11702,10 +11706,12 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
             return OPJ_FALSE;
         }
 
-        if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
-                                  p_stream, p_manager)) {
-            opj_event_msg(p_manager, EVT_ERROR, "Failed to decode tile 1/1\n");
-            return OPJ_FALSE;
+        r = opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0, p_stream, p_manager, p_cancel);
+        if (r != OPJ_SUCCESS) {
+            if (r == OPJ_FAILURE) {
+                    opj_event_msg(p_manager, EVT_ERROR, "Failed to decode tile 1/1\n");
+            }
+            return r;
         }
 
         /* Transfer TCD data to output image data */
@@ -11722,6 +11728,8 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
     }
 
     for (;;) {
+        OPJ_RESULT r;
+
         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;
@@ -11745,11 +11753,13 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
             }
         }
 
-        if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
-                                  p_stream, p_manager)) {
-            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;
+        r = opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0, p_stream, p_manager, p_cancel);
+        if (r != OPJ_SUCCESS) {
+                if (r == OPJ_FAILURE) {
+                        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",
@@ -11811,9 +11821,10 @@ static OPJ_BOOL opj_j2k_setup_decoding(opj_j2k_t *p_j2k,
 /*
  * Read and decode one tile.
  */
-static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
-                                        opj_stream_private_t *p_stream,
-                                        opj_event_mgr_t * p_manager)
+static OPJ_RESULT opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
+                                          opj_stream_private_t *p_stream,
+                                          opj_event_mgr_t * p_manager,
+                                          opj_cancel_t * p_cancel)
 {
     OPJ_BOOL l_go_on = OPJ_TRUE;
     OPJ_UINT32 l_current_tile_no;
@@ -11866,6 +11877,8 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
     }
 
     for (;;) {
+        OPJ_RESULT r;
+
         if (! opj_j2k_read_tile_header(p_j2k,
                                        &l_current_tile_no,
                                        NULL,
@@ -11882,9 +11895,9 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
             break;
         }
 
-        if (! opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0,
-                                  p_stream, p_manager)) {
-            return OPJ_FALSE;
+        r = opj_j2k_decode_tile(p_j2k, l_current_tile_no, NULL, 0, p_stream, p_manager, p_cancel);
+        if (r != OPJ_SUCCESS) {
+            return r;
         }
         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);
diff --git a/src/lib/openjp2/j2k.h b/src/lib/openjp2/j2k.h
index e0b9688a..7ed2e541 100644
--- a/src/lib/openjp2/j2k.h
+++ b/src/lib/openjp2/j2k.h
@@ -708,12 +708,13 @@ void j2k_destroy_cstr_index(opj_codestream_index_t *p_cstr_ind);
  * @param   p_stream            the stream to write data to.
  * @param   p_manager   the user event manager.
  */
-OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
-                             OPJ_UINT32 p_tile_index,
-                             OPJ_BYTE * p_data,
-                             OPJ_UINT32 p_data_size,
-                             opj_stream_private_t *p_stream,
-                             opj_event_mgr_t * p_manager);
+OPJ_RESULT opj_j2k_decode_tile(opj_j2k_t * p_j2k,
+                               OPJ_UINT32 p_tile_index,
+                               OPJ_BYTE * p_data,
+                               OPJ_UINT32 p_data_size,
+                               opj_stream_private_t *p_stream,
+                               opj_event_mgr_t * p_manager,
+			       opj_cancel_t * p_cancel);
 
 /**
  * Reads a tile header.
diff --git a/src/lib/openjp2/jp2.c b/src/lib/openjp2/jp2.c
index 6015190e..97576b5d 100644
--- a/src/lib/openjp2/jp2.c
+++ b/src/lib/openjp2/jp2.c
@@ -3014,16 +3014,17 @@ OPJ_BOOL opj_jp2_write_tile(opj_jp2_t *p_jp2,
                               p_stream, p_manager);
 }
 
-OPJ_BOOL opj_jp2_decode_tile(opj_jp2_t * p_jp2,
-                             OPJ_UINT32 p_tile_index,
-                             OPJ_BYTE * p_data,
-                             OPJ_UINT32 p_data_size,
-                             opj_stream_private_t *p_stream,
-                             opj_event_mgr_t * p_manager
-                            )
+OPJ_RESULT opj_jp2_decode_tile(opj_jp2_t * p_jp2,
+                               OPJ_UINT32 p_tile_index,
+                               OPJ_BYTE * p_data,
+                               OPJ_UINT32 p_data_size,
+                               opj_stream_private_t *p_stream,
+                               opj_event_mgr_t * p_manager,
+                               opj_cancel_t * p_cancel
+                              )
 {
     return opj_j2k_decode_tile(p_jp2->j2k, p_tile_index, p_data, p_data_size,
-                               p_stream, p_manager);
+                               p_stream, p_manager, p_cancel);
 }
 
 void opj_jp2_destroy(opj_jp2_t *jp2)
diff --git a/src/lib/openjp2/jp2.h b/src/lib/openjp2/jp2.h
index 173f2511..b784ead1 100644
--- a/src/lib/openjp2/jp2.h
+++ b/src/lib/openjp2/jp2.h
@@ -411,12 +411,13 @@ OPJ_BOOL opj_jp2_write_tile(opj_jp2_t *p_jp2,
  *
  * @return FIXME DOC
  */
-OPJ_BOOL opj_jp2_decode_tile(opj_jp2_t * p_jp2,
-                             OPJ_UINT32 p_tile_index,
-                             OPJ_BYTE * p_data,
-                             OPJ_UINT32 p_data_size,
-                             opj_stream_private_t *p_stream,
-                             opj_event_mgr_t * p_manager);
+OPJ_RESULT opj_jp2_decode_tile(opj_jp2_t * p_jp2,
+                               OPJ_UINT32 p_tile_index,
+                               OPJ_BYTE * p_data,
+                               OPJ_UINT32 p_data_size,
+                               opj_stream_private_t *p_stream,
+                               opj_event_mgr_t * p_manager,
+			       opj_cancel_t * p_cancel);
 
 /**
  * Creates a jpeg2000 file decompressor.
diff --git a/src/lib/openjp2/openjpeg.c b/src/lib/openjp2/openjpeg.c
index 382d8f4f..339687a0 100644
--- a/src/lib/openjp2/openjpeg.c
+++ b/src/lib/openjp2/openjpeg.c
@@ -36,6 +36,7 @@
 #endif /* _WIN32 */
 
 #include "opj_includes.h"
+#include <stdatomic.h>
 
 
 /* ---------------------------------------------------------------------- */
@@ -86,6 +87,17 @@ OPJ_BOOL OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec,
     return OPJ_TRUE;
 }
 
+OPJ_BOOL OPJ_CALLCONV opj_set_cancel(opj_codec_t * p_codec, opj_cancel_t * p_cancel)
+{
+    opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
+    if (! l_codec) {
+        return OPJ_FALSE;
+    }
+
+    l_codec->p_cancel = p_cancel;
+    return OPJ_TRUE;
+}
+
 /* ---------------------------------------------------------------------- */
 
 static OPJ_SIZE_T opj_read_from_file(void * p_buffer, OPJ_SIZE_T p_nb_bytes,
@@ -245,7 +257,8 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
                          OPJ_BYTE*,
                          OPJ_UINT32,
                          struct opj_stream_private *,
-                         struct opj_event_mgr *)) opj_j2k_decode_tile;
+                         struct opj_event_mgr *,
+                         struct opj_cancel *)) opj_j2k_decode_tile;
 
         l_codec->m_codec_data.m_decompression.opj_set_decode_area =
             (OPJ_BOOL(*)(void *,
@@ -327,7 +340,8 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
             (OPJ_BOOL(*)(void *,
                          OPJ_UINT32, OPJ_BYTE*, OPJ_UINT32,
                          struct opj_stream_private *,
-                         struct opj_event_mgr *)) opj_jp2_decode_tile;
+                         struct opj_event_mgr *,
+                         struct opj_cancel *)) opj_jp2_decode_tile;
 
         l_codec->m_codec_data.m_decompression.opj_destroy = (void (*)(
                     void *))opj_jp2_destroy;
@@ -381,6 +395,7 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
     }
 
     opj_set_default_event_handler(&(l_codec->m_event_mgr));
+    l_codec->p_cancel = 00;
     return (opj_codec_t*) l_codec;
 }
 
@@ -607,7 +622,8 @@ OPJ_BOOL OPJ_CALLCONV opj_decode_tile_data(opj_codec_t *p_codec,
                    p_data,
                    p_data_size,
                    l_stream,
-                   &(l_codec->m_event_mgr));
+                   &(l_codec->m_event_mgr),
+                   l_codec->p_cancel);
     }
     return OPJ_FALSE;
 }
@@ -1142,3 +1158,42 @@ void OPJ_CALLCONV opj_image_data_free(void* ptr)
     /* printf("opj_image_data_free %p\n", ptr); */
     opj_aligned_free(ptr);
 }
+
+struct opj_cancel
+{
+    atomic_bool cancel;
+};
+
+typedef struct opj_cancel opj_cancel_t;
+
+opj_cancel_t* OPJ_CALLCONV opj_create_cancel(void)
+{
+    opj_cancel_t* cancel = opj_malloc(sizeof(opj_cancel_t));
+    if (! cancel) {
+        return NULL;
+    }
+
+    cancel->cancel = OPJ_FALSE;
+    return cancel;
+}
+
+void opj_destroy_cancel(opj_cancel_t* cancel)
+{
+    opj_free(cancel);
+}
+
+void opj_cancel(opj_cancel_t* cancel)
+{
+    cancel->cancel = OPJ_TRUE;
+}
+
+void opj_reset(opj_cancel_t* cancel)
+{
+    cancel->cancel = OPJ_FALSE;
+}
+
+OPJ_BOOL opj_should_cancel(opj_cancel_t* cancel)
+{
+    return cancel && cancel->cancel;
+}
+
diff --git a/src/lib/openjp2/openjpeg.h b/src/lib/openjp2/openjpeg.h
index 67d168bb..3ca2f5d3 100644
--- a/src/lib/openjp2/openjpeg.h
+++ b/src/lib/openjp2/openjpeg.h
@@ -117,6 +117,11 @@ typedef int OPJ_BOOL;
 #define OPJ_TRUE 1
 #define OPJ_FALSE 0
 
+typedef int OPJ_RESULT;
+#define OPJ_SUCCESS OPJ_TRUE
+#define OPJ_FAILURE OPJ_FALSE
+#define OPJ_CANCEL 2
+
 typedef char          OPJ_CHAR;
 typedef float         OPJ_FLOAT32;
 typedef double        OPJ_FLOAT64;
@@ -1160,6 +1165,16 @@ OPJ_API void* OPJ_CALLCONV opj_image_data_alloc(OPJ_SIZE_T size);
 */
 OPJ_API void OPJ_CALLCONV opj_image_data_free(void* ptr);
 
+struct opj_cancel;
+typedef struct opj_cancel opj_cancel_t;
+
+OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_cancel(opj_codec_t * p_codec, opj_cancel_t * p_cancel);
+OPJ_API opj_cancel_t* OPJ_CALLCONV opj_create_cancel(void);
+OPJ_API void OPJ_CALLCONV opj_destroy_cancel(opj_cancel_t * p_cancel);
+OPJ_API void OPJ_CALLCONV opj_cancel(opj_cancel_t * p_cancel);
+OPJ_API void OPJ_CALLCONV opj_reset(opj_cancel_t * p_cancel);
+OPJ_API OPJ_BOOL OPJ_CALLCONV opj_should_cancel(opj_cancel_t * p_cancel);
+
 /*
 ==========================================================
    stream functions definitions
diff --git a/src/lib/openjp2/opj_codec.h b/src/lib/openjp2/opj_codec.h
index 7cff6708..f41221b4 100644
--- a/src/lib/openjp2/opj_codec.h
+++ b/src/lib/openjp2/opj_codec.h
@@ -77,7 +77,8 @@ typedef struct opj_codec_private {
                                             OPJ_BYTE * p_data,
                                             OPJ_UINT32 p_data_size,
                                             struct opj_stream_private * p_cio,
-                                            struct opj_event_mgr * p_manager);
+                                            struct opj_event_mgr * p_manager,
+					    struct opj_cancel * p_cancel);
 
             /** Reading function used after codestream if necessary */
             OPJ_BOOL(* opj_end_decompress)(void *p_codec,
@@ -162,6 +163,7 @@ typedef struct opj_codec_private {
     void * m_codec;
     /** Event handler */
     opj_event_mgr_t m_event_mgr;
+    opj_cancel_t* p_cancel;
     /** Flag to indicate if the codec is used to decode or encode*/
     OPJ_BOOL is_decompressor;
     void (*opj_dump_codec)(void * p_codec, OPJ_INT32 info_flag,
diff --git a/src/lib/openjp2/t1.c b/src/lib/openjp2/t1.c
index 52e466eb..4964888a 100644
--- a/src/lib/openjp2/t1.c
+++ b/src/lib/openjp2/t1.c
@@ -1833,12 +1833,13 @@ static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
 
 
 void opj_t1_decode_cblks(opj_tcd_t* tcd,
-                         volatile OPJ_BOOL* pret,
+                         volatile OPJ_RESULT* pret,
                          opj_tcd_tilecomp_t* tilec,
                          opj_tccp_t* tccp,
                          opj_event_mgr_t *p_manager,
                          opj_mutex_t* p_manager_mutex,
-                         OPJ_BOOL check_pterm
+                         OPJ_BOOL check_pterm,
+                         opj_cancel_t *p_cancel
                         )
 {
     opj_thread_pool_t* tp = tcd->thread_pool;
@@ -1851,13 +1852,24 @@ void opj_t1_decode_cblks(opj_tcd_t* tcd,
 
     for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
         opj_tcd_resolution_t* res = &tilec->resolutions[resno];
+        if (opj_should_cancel(p_cancel)) {
+            *pret = OPJ_CANCEL;
+        }
 
         for (bandno = 0; bandno < res->numbands; ++bandno) {
             opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
 
+            if (opj_should_cancel(p_cancel)) {
+                *pret = OPJ_CANCEL;
+            }
+
             for (precno = 0; precno < res->pw * res->ph; ++precno) {
                 opj_tcd_precinct_t* precinct = &band->precincts[precno];
 
+                if (opj_should_cancel(p_cancel)) {
+                    *pret = OPJ_CANCEL;
+                }
+
                 if (!opj_tcd_is_subband_area_of_interest(tcd,
                         tilec->compno,
                         resno,
@@ -1866,7 +1878,7 @@ void opj_t1_decode_cblks(opj_tcd_t* tcd,
                         (OPJ_UINT32)precinct->y0,
                         (OPJ_UINT32)precinct->x1,
                         (OPJ_UINT32)precinct->y1)) {
-                    for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
+            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
@@ -1884,6 +1896,10 @@ void opj_t1_decode_cblks(opj_tcd_t* tcd,
                     opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
                     opj_t1_cblk_decode_processing_job_t* job;
 
+                    if (opj_should_cancel(p_cancel)) {
+                        *pret = OPJ_FALSE;
+                    }
+
                     if (!opj_tcd_is_subband_area_of_interest(tcd,
                             tilec->compno,
                             resno,
@@ -1925,7 +1941,7 @@ void opj_t1_decode_cblks(opj_tcd_t* tcd,
                     job = (opj_t1_cblk_decode_processing_job_t*) opj_calloc(1,
                             sizeof(opj_t1_cblk_decode_processing_job_t));
                     if (!job) {
-                        *pret = OPJ_FALSE;
+                        *pret = OPJ_FAILURE;
                         return;
                     }
                     job->whole_tile_decoding = tcd->whole_tile_decoding;
diff --git a/src/lib/openjp2/t1.h b/src/lib/openjp2/t1.h
index ce43658b..06d695a6 100644
--- a/src/lib/openjp2/t1.h
+++ b/src/lib/openjp2/t1.h
@@ -238,12 +238,13 @@ Decode the code-blocks of a tile
 @param check_pterm whether PTERM correct termination should be checked
 */
 void opj_t1_decode_cblks(opj_tcd_t* tcd,
-                         volatile OPJ_BOOL* pret,
+                         volatile OPJ_RESULT* pret,
                          opj_tcd_tilecomp_t* tilec,
                          opj_tccp_t* tccp,
                          opj_event_mgr_t *p_manager,
                          opj_mutex_t* p_manager_mutex,
-                         OPJ_BOOL check_pterm);
+                         OPJ_BOOL check_pterm,
+			 opj_cancel_t* p_cancel);
 
 
 
diff --git a/src/lib/openjp2/t2.c b/src/lib/openjp2/t2.c
index 781a6a59..6a2ee523 100644
--- a/src/lib/openjp2/t2.c
+++ b/src/lib/openjp2/t2.c
@@ -390,15 +390,16 @@ 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_tcd_t* tcd,
-                               opj_t2_t *p_t2,
-                               OPJ_UINT32 p_tile_no,
-                               opj_tcd_tile_t *p_tile,
-                               OPJ_BYTE *p_src,
-                               OPJ_UINT32 * p_data_read,
-                               OPJ_UINT32 p_max_len,
-                               opj_codestream_index_t *p_cstr_index,
-                               opj_event_mgr_t *p_manager)
+OPJ_RESULT 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,
+                                 OPJ_UINT32 * p_data_read,
+                                 OPJ_UINT32 p_max_len,
+                                 opj_codestream_index_t *p_cstr_index,
+                                 opj_event_mgr_t *p_manager,
+                                 opj_cancel_t *p_cancel)
 {
     OPJ_BYTE *l_current_data = p_src;
     opj_pi_iterator_t *l_pi = 00;
@@ -462,6 +463,10 @@ OPJ_BOOL opj_t2_decode_packets(opj_tcd_t* tcd,
                         l_current_pi->poc.prg1, l_current_pi->compno, l_current_pi->resno,
                         l_current_pi->precno, l_current_pi->layno);
 
+            if (opj_should_cancel(p_cancel)) {
+                return OPJ_CANCEL;
+            }
+
             /* 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) {
diff --git a/src/lib/openjp2/t2.h b/src/lib/openjp2/t2.h
index becfa91a..9a342705 100644
--- a/src/lib/openjp2/t2.h
+++ b/src/lib/openjp2/t2.h
@@ -109,15 +109,16 @@ Decode the packets of a tile from a source buffer
 
 @return FIXME DOC
  */
-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,
-                               OPJ_UINT32 * p_data_read,
-                               OPJ_UINT32 len,
-                               opj_codestream_index_t *cstr_info,
-                               opj_event_mgr_t *p_manager);
+OPJ_RESULT opj_t2_decode_packets(opj_tcd_t* tcd,
+                                 opj_t2_t *t2,
+                                 OPJ_UINT32 tileno,
+                                 opj_tcd_tile_t *tile,
+                                 OPJ_BYTE *src,
+                                 OPJ_UINT32 * p_data_read,
+                                 OPJ_UINT32 len,
+                                 opj_codestream_index_t *cstr_info,
+                                 opj_event_mgr_t *p_manager,
+				 opj_cancel_t *p_cancel);
 
 /**
  * Creates a Tier 2 handle
diff --git a/src/lib/openjp2/tcd.c b/src/lib/openjp2/tcd.c
index 687aa61b..ea37a71c 100644
--- a/src/lib/openjp2/tcd.c
+++ b/src/lib/openjp2/tcd.c
@@ -156,17 +156,19 @@ Free the memory allocated for encoding
 static void opj_tcd_free_tile(opj_tcd_t *tcd);
 
 
-static OPJ_BOOL opj_tcd_t2_decode(opj_tcd_t *p_tcd,
-                                  OPJ_BYTE * p_src_data,
-                                  OPJ_UINT32 * p_data_read,
-                                  OPJ_UINT32 p_max_src_size,
-                                  opj_codestream_index_t *p_cstr_index,
-                                  opj_event_mgr_t *p_manager);
+static OPJ_RESULT opj_tcd_t2_decode(opj_tcd_t *p_tcd,
+                                    OPJ_BYTE * p_src_data,
+                                    OPJ_UINT32 * p_data_read,
+                                    OPJ_UINT32 p_max_src_size,
+                                    opj_codestream_index_t *p_cstr_index,
+                                    opj_event_mgr_t *p_manager,
+                                    opj_cancel_t *p_cancel);
 
-static OPJ_BOOL opj_tcd_t1_decode(opj_tcd_t *p_tcd,
-                                  opj_event_mgr_t *p_manager);
+static OPJ_RESULT opj_tcd_t1_decode(opj_tcd_t *p_tcd,
+                                    opj_event_mgr_t *p_manager,
+                                    opj_cancel_t *p_cancel);
 
-static OPJ_BOOL opj_tcd_dwt_decode(opj_tcd_t *p_tcd);
+static OPJ_RESULT opj_tcd_dwt_decode(opj_tcd_t *p_tcd, opj_cancel_t *p_cancel);
 
 static OPJ_BOOL opj_tcd_mct_decode(opj_tcd_t *p_tcd,
                                    opj_event_mgr_t *p_manager);
@@ -1542,22 +1544,24 @@ OPJ_BOOL opj_tcd_encode_tile(opj_tcd_t *p_tcd,
     return OPJ_TRUE;
 }
 
-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,
-                             opj_codestream_index_t *p_cstr_index,
-                             opj_event_mgr_t *p_manager
-                            )
+OPJ_RESULT 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,
+                               opj_codestream_index_t *p_cstr_index,
+                               opj_event_mgr_t *p_manager,
+                               opj_cancel_t *p_cancel
+                               )
 {
     OPJ_UINT32 l_data_read;
     OPJ_UINT32 compno;
+    OPJ_RESULT r;
 
     p_tcd->tcd_tileno = p_tile_no;
     p_tcd->tcp = &(p_tcd->cp->tcps[p_tile_no]);
@@ -1574,7 +1578,7 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
         OPJ_BOOL* used_component = (OPJ_BOOL*) opj_calloc(sizeof(OPJ_BOOL),
                                    p_tcd->image->numcomps);
         if (used_component == NULL) {
-            return OPJ_FALSE;
+            return OPJ_FAILURE;
         }
         for (compno = 0; compno < numcomps_to_decode; compno++) {
             used_component[ comps_indices[compno] ] = OPJ_TRUE;
@@ -1613,14 +1617,14 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
             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;
+                return OPJ_FAILURE;
             }
             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;
+                return OPJ_FAILURE;
             }
             l_data_size *= sizeof(OPJ_UINT32);
 
@@ -1629,7 +1633,7 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
             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;
+                return OPJ_FAILURE;
             }
         }
     } else {
@@ -1666,7 +1670,7 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
                 /* 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;
+                return OPJ_FAILURE;
             }
 
             for (resno = 0; resno < tilec->numresolutions; ++resno) {
@@ -1707,20 +1711,29 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
     /* << INDEX */
 #endif
 
+    if (opj_should_cancel(p_cancel)) {
+        return OPJ_CANCEL;
+    }
+
     /*--------------TIER2------------------*/
     /* FIXME _ProfStart(PGROUP_T2); */
     l_data_read = 0;
-    if (! opj_tcd_t2_decode(p_tcd, p_src, &l_data_read, p_max_length, p_cstr_index,
-                            p_manager)) {
-        return OPJ_FALSE;
+    r = opj_tcd_t2_decode(p_tcd, p_src, &l_data_read, p_max_length, p_cstr_index, p_manager, p_cancel);
+    if (r != OPJ_SUCCESS) {
+        return r;
     }
     /* FIXME _ProfStop(PGROUP_T2); */
 
+    if (opj_should_cancel(p_cancel)) {
+        return OPJ_CANCEL;
+    }
+
     /*------------------TIER1-----------------*/
 
     /* FIXME _ProfStart(PGROUP_T1); */
-    if (! opj_tcd_t1_decode(p_tcd, p_manager)) {
-        return OPJ_FALSE;
+    r = opj_tcd_t1_decode(p_tcd, p_manager, p_cancel);
+    if (r != OPJ_SUCCESS) {
+        return r;
     }
     /* FIXME _ProfStop(PGROUP_T1); */
 
@@ -1747,13 +1760,13 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
                 if (w > SIZE_MAX / h) {
                     opj_event_msg(p_manager, EVT_ERROR,
                                   "Size of tile data exceeds system limits\n");
-                    return OPJ_FALSE;
+                    return OPJ_FAILURE;
                 }
                 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;
+                    return OPJ_FAILURE;
                 }
                 l_data_size *= sizeof(OPJ_INT32);
 
@@ -1761,39 +1774,51 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *p_tcd,
                 if (tilec->data_win == NULL) {
                     opj_event_msg(p_manager, EVT_ERROR,
                                   "Size of tile data exceeds system limits\n");
-                    return OPJ_FALSE;
+                    return OPJ_FAILURE;
                 }
             }
         }
     }
 
+    if (opj_should_cancel(p_cancel)) {
+        return OPJ_CANCEL;
+    }
+
     /*----------------DWT---------------------*/
 
     /* FIXME _ProfStart(PGROUP_DWT); */
-    if
-    (! opj_tcd_dwt_decode(p_tcd)) {
-        return OPJ_FALSE;
+    r = opj_tcd_dwt_decode(p_tcd, p_cancel);
+    if (r != OPJ_SUCCESS) {
+        return r;
     }
     /* FIXME _ProfStop(PGROUP_DWT); */
 
+    if (opj_should_cancel(p_cancel)) {
+        return OPJ_CANCEL;
+    }
+
     /*----------------MCT-------------------*/
     /* FIXME _ProfStart(PGROUP_MCT); */
     if
     (! opj_tcd_mct_decode(p_tcd, p_manager)) {
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
     /* FIXME _ProfStop(PGROUP_MCT); */
 
+    if (opj_should_cancel(p_cancel)) {
+        return OPJ_CANCEL;
+    }
+
     /* FIXME _ProfStart(PGROUP_DC_SHIFT); */
     if
     (! opj_tcd_dc_level_shift_decode(p_tcd)) {
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
     /* FIXME _ProfStop(PGROUP_DC_SHIFT); */
 
 
     /*---------------TILE-------------------*/
-    return OPJ_TRUE;
+    return OPJ_SUCCESS;
 }
 
 OPJ_BOOL opj_tcd_update_tile_data(opj_tcd_t *p_tcd,
@@ -2006,22 +2031,24 @@ static void opj_tcd_free_tile(opj_tcd_t *p_tcd)
 }
 
 
-static OPJ_BOOL opj_tcd_t2_decode(opj_tcd_t *p_tcd,
-                                  OPJ_BYTE * p_src_data,
-                                  OPJ_UINT32 * p_data_read,
-                                  OPJ_UINT32 p_max_src_size,
-                                  opj_codestream_index_t *p_cstr_index,
-                                  opj_event_mgr_t *p_manager
-                                 )
+static OPJ_RESULT opj_tcd_t2_decode(opj_tcd_t *p_tcd,
+                                    OPJ_BYTE * p_src_data,
+                                    OPJ_UINT32 * p_data_read,
+                                    OPJ_UINT32 p_max_src_size,
+                                    opj_codestream_index_t *p_cstr_index,
+                                    opj_event_mgr_t *p_manager,
+                                    opj_cancel_t *p_cancel
+                                   )
 {
     opj_t2_t * l_t2;
+    OPJ_RESULT r;
 
     l_t2 = opj_t2_create(p_tcd->image, p_tcd->cp);
     if (l_t2 == 00) {
-        return OPJ_FALSE;
+        return OPJ_FAILURE;
     }
 
-    if (! opj_t2_decode_packets(
+    r = opj_t2_decode_packets(
                 p_tcd,
                 l_t2,
                 p_tcd->tcd_tileno,
@@ -2030,18 +2057,21 @@ static OPJ_BOOL opj_tcd_t2_decode(opj_tcd_t *p_tcd,
                 p_data_read,
                 p_max_src_size,
                 p_cstr_index,
-                p_manager)) {
+                p_manager,
+                p_cancel);
+
+    if (r != OPJ_SUCCESS) {
         opj_t2_destroy(l_t2);
-        return OPJ_FALSE;
+        return r;
     }
 
     opj_t2_destroy(l_t2);
 
     /*---------------CLEAN-------------------*/
-    return OPJ_TRUE;
+    return OPJ_SUCCESS;
 }
 
-static OPJ_BOOL opj_tcd_t1_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
+static OPJ_RESULT opj_tcd_t1_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager, opj_cancel_t *p_cancel)
 {
     OPJ_UINT32 compno;
     opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
@@ -2066,8 +2096,8 @@ static OPJ_BOOL opj_tcd_t1_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
         }
 
         opj_t1_decode_cblks(p_tcd, &ret, l_tile_comp, l_tccp,
-                            p_manager, p_manager_mutex, check_pterm);
-        if (!ret) {
+                            p_manager, p_manager_mutex, check_pterm, p_cancel);
+        if (ret != OPJ_SUCCESS) {
             break;
         }
     }
@@ -2080,7 +2110,7 @@ static OPJ_BOOL opj_tcd_t1_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
 }
 
 
-static OPJ_BOOL opj_tcd_dwt_decode(opj_tcd_t *p_tcd)
+static OPJ_RESULT opj_tcd_dwt_decode(opj_tcd_t *p_tcd, opj_cancel_t *p_cancel)
 {
     OPJ_UINT32 compno;
     opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
@@ -2095,20 +2125,20 @@ static OPJ_BOOL opj_tcd_dwt_decode(opj_tcd_t *p_tcd)
         }
 
         if (l_tccp->qmfbid == 1) {
-            if (! opj_dwt_decode(p_tcd, l_tile_comp,
-                                 l_img_comp->resno_decoded + 1)) {
-                return OPJ_FALSE;
+            OPJ_RESULT r = opj_dwt_decode(p_tcd, l_tile_comp, l_img_comp->resno_decoded + 1, p_cancel);
+            if (r != OPJ_SUCCESS) {
+                return r;
             }
         } else {
-            if (! opj_dwt_decode_real(p_tcd, l_tile_comp,
-                                      l_img_comp->resno_decoded + 1)) {
-                return OPJ_FALSE;
+            OPJ_RESULT r = opj_dwt_decode_real(p_tcd, l_tile_comp, l_img_comp->resno_decoded + 1, p_cancel);
+            if (r != OPJ_SUCCESS) {
+                return r;
             }
         }
 
     }
 
-    return OPJ_TRUE;
+    return OPJ_SUCCESS;
 }
 
 static OPJ_BOOL opj_tcd_mct_decode(opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager)
diff --git a/src/lib/openjp2/tcd.h b/src/lib/openjp2/tcd.h
index f659869a..66809757 100644
--- a/src/lib/openjp2/tcd.h
+++ b/src/lib/openjp2/tcd.h
@@ -425,7 +425,8 @@ OPJ_BOOL opj_tcd_decode_tile(opj_tcd_t *tcd,
                              OPJ_UINT32 len,
                              OPJ_UINT32 tileno,
                              opj_codestream_index_t *cstr_info,
-                             opj_event_mgr_t *manager);
+                             opj_event_mgr_t *manager,
+			     opj_cancel_t *cancel);
 
 
 /**