walkero
/
openjpeg
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
openjpeg/src/lib/openjp2/sparse_array.c

347 lines
15 KiB
C
Raw Normal View History

Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
/*
* 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;
}
Fix warnings and errors when compiling with a c++ compiler (#1021)
2017-09-19 12:46:20 +02:00
sa = (opj_sparse_array_int32_t*) opj_calloc(1,
sizeof(opj_sparse_array_int32_t));
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
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;
}
Fix warnings and errors when compiling with a c++ compiler (#1021)
2017-09-19 12:46:20 +02:00
sa->data_blocks = (OPJ_INT32**) opj_calloc(sizeof(OPJ_INT32*),
sa->block_count_hor * sa->block_count_ver);
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
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);
}
}
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
OPJ_BOOL opj_sparse_array_is_region_valid(const opj_sparse_array_int32_t* sa,
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
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(
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
const opj_sparse_array_int32_t* sa,
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
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;
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
const OPJ_UINT32 block_width = sa->block_width;
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
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);
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
block_x = x0 / block_width;
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
for (x = x0; x < x1; block_x ++, x += x_incr) {
OPJ_UINT32 j;
OPJ_UINT32 block_x_offset;
OPJ_INT32* src_block;
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
x_incr = (x == x0) ? block_width - (x0 % block_width) : block_width;
block_x_offset = block_width - x_incr;
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
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) {
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
if (buf_col_stride == 1) {
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
OPJ_INT32* dest_ptr = buf + (y - y0) * (OPJ_SIZE_T)buf_line_stride +
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
(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 {
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
OPJ_INT32* dest_ptr = buf + (y - y0) * (OPJ_SIZE_T)buf_line_stride +
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
(x - x0) * buf_col_stride;
for (j = 0; j < y_incr; j++) {
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
OPJ_UINT32 k;
for (k = 0; k < x_incr; k++) {
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
dest_ptr[k * buf_col_stride] = 0;
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
}
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
dest_ptr += buf_line_stride;
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
}
}
} else {
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
const OPJ_INT32* OPJ_RESTRICT src_ptr = src_block + block_y_offset *
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
(OPJ_SIZE_T)block_width + block_x_offset;
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
if (buf_col_stride == 1) {
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
OPJ_INT32* OPJ_RESTRICT dest_ptr = buf + (y - y0) * (OPJ_SIZE_T)buf_line_stride
+
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
(x - x0) * buf_col_stride;
Sub-tile decoding: speed up vertical pass in IDWT5x3 by processing 4 cols at a time
2017-09-01 16:31:00 +02:00
if (x_incr == 4) {
Replace C++ style comments by C ones
2017-09-19 18:22:07 +02:00
/* Same code as general branch, but the compiler */
/* can have an efficient memcpy() */
Workaroudn cppcheck (correct) warning about same code in then and else branches
2017-09-19 18:35:31 +02:00
(void)(x_incr); /* trick to silent cppcheck duplicateBranch warning */
Sub-tile decoding: speed up vertical pass in IDWT5x3 by processing 4 cols at a time
2017-09-01 16:31:00 +02:00
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;
}
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
}
} else {
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
OPJ_INT32* OPJ_RESTRICT dest_ptr = buf + (y - y0) * (OPJ_SIZE_T)buf_line_stride
+
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
(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;
}
Sub-tile decoding: speed up vertical pass in IDWT5x3 by processing 4 cols at a time
2017-09-01 16:31:00 +02:00
} 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];
}
sparse_array: optimizations for lossy case
2017-09-01 16:31:10 +02:00
} 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;
}
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
} else {
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
/* 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;
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
}
}
}
}
} else {
if (src_block == NULL) {
Fix warnings and errors when compiling with a c++ compiler (#1021)
2017-09-19 12:46:20 +02:00
src_block = (OPJ_INT32*) opj_calloc(1,
sa->block_width * sa->block_height * sizeof(OPJ_INT32));
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
if (src_block == NULL) {
return OPJ_FALSE;
}
sa->data_blocks[block_y * sa->block_count_hor + block_x] = src_block;
}
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
if (buf_col_stride == 1) {
OPJ_INT32* OPJ_RESTRICT dest_ptr = src_block + block_y_offset *
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
(OPJ_SIZE_T)block_width + block_x_offset;
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
const OPJ_INT32* OPJ_RESTRICT src_ptr = buf + (y - y0) *
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
(OPJ_SIZE_T)buf_line_stride + (x - x0) * buf_col_stride;
Sub-tile decoding: speed up vertical pass in IDWT5x3 by processing 4 cols at a time
2017-09-01 16:31:00 +02:00
if (x_incr == 4) {
Replace C++ style comments by C ones
2017-09-19 18:25:55 +02:00
/* Same code as general branch, but the compiler */
/* can have an efficient memcpy() */
Workaroudn cppcheck (correct) warning about same code in then and else branches
2017-09-19 18:35:31 +02:00
(void)(x_incr); /* trick to silent cppcheck duplicateBranch warning */
Sub-tile decoding: speed up vertical pass in IDWT5x3 by processing 4 cols at a time
2017-09-01 16:31:00 +02:00
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;
}
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
}
} else {
OPJ_INT32* OPJ_RESTRICT dest_ptr = src_block + block_y_offset *
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
(OPJ_SIZE_T)block_width + block_x_offset;
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
const OPJ_INT32* OPJ_RESTRICT src_ptr = buf + (y - y0) *
Replace uses of size_t by OPJ_SIZE_T
2017-09-04 17:35:52 +02:00
(OPJ_SIZE_T)buf_line_stride + (x - x0) * buf_col_stride;
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
if (x_incr == 1) {
for (j = 0; j < y_incr; j++) {
*dest_ptr = *src_ptr;
src_ptr += buf_line_stride;
dest_ptr += block_width;
}
sparse_array: optimizations for lossy case
2017-09-01 16:31:10 +02:00
} 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;
}
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
} else {
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
/* 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;
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
}
}
}
}
}
}
return OPJ_TRUE;
}
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
OPJ_BOOL opj_sparse_array_int32_read(const opj_sparse_array_int32_t* sa,
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
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)
{
Optimize reading/write into sparse array
2017-09-01 16:30:50 +02:00
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);
Sub-tile decoding: only allocate tile component buffer of the needed dimension Instead of being the full tile size. * Use a sparse array mechanism to store code-blocks and intermediate stages of IDWT. * IDWT, DC level shift and MCT stages are done just on that smaller array. * Improve copy of tile component array to final image, by saving an intermediate buffer. * For full-tile decoding at reduced resolution, only allocate the tile buffer to the reduced size, instead of the full-resolution size.
2017-09-01 16:30:29 +02:00
}
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);
}