From 9e114bcaa47194a9f6af8eadf6d7cb9bb1ec277f Mon Sep 17 00:00:00 2001 From: Francois-Olivier Devaux Date: Thu, 18 Oct 2007 12:26:11 +0000 Subject: [PATCH] Patch from Callum Lewick. Memset patch. See ChangeLog for more details. Thanks Callum ! --- ChangeLog | 12 ++++ LibOpenJPEG.vcproj | 6 +- Makefile | 2 +- libopenjpeg/image.c | 4 +- libopenjpeg/j2k.c | 68 +++++++++--------- libopenjpeg/j2k_lib.c | 17 ----- libopenjpeg/j2k_lib.h | 85 +--------------------- libopenjpeg/jp2.c | 2 +- libopenjpeg/opj_includes.h | 6 ++ libopenjpeg/opj_malloc.h | 140 +++++++++++++++++++++++++++++++++++++ libopenjpeg/pi.c | 34 +++------ libopenjpeg/t1.c | 18 ++--- libopenjpeg/tcd.c | 9 +-- libopenjpeg/tgt.c | 2 +- mj2/extract_j2k_from_mj2.c | 8 ++- mj2/frames_to_mj2.c | 22 ++++-- mj2/frames_to_mj2.vcproj | 3 +- mj2/mj2.c | 112 +++++++++++++---------------- mj2/mj2_to_frames.c | 9 ++- mj2/wrap_j2k_in_mj2.c | 13 +++- 20 files changed, 324 insertions(+), 248 deletions(-) create mode 100644 libopenjpeg/opj_malloc.h diff --git a/ChangeLog b/ChangeLog index 9df723ea..a5c2a87b 100644 --- a/ChangeLog +++ b/ChangeLog @@ -7,6 +7,18 @@ What's New for OpenJPEG October 18, 2007 * [FOD] Changed the ROI parameter in the image_to_j2k codec to make it correspond to the documentation (i.e. -ROI c=0,U=25) +* [FOD] Patch from Callum Lewick. Memset patch. + The main idea of the patch is that currently opj_malloc clears all allocations, which unnecessarily + dirties up the cache and eats bandwidth. This patch makes it no longer do so, and I've painstakingly determined which allocations actually need + to be cleared and changed them to use opj_calloc() instead. I previously tried to just get rid of the opj_*alloc wrappers but that + idea was nixed, so this time I'm trying it with macros. I also put in a gcc pragma that helps enforce their use. Which got messy. :) It caught a + few places they weren't used but it also revealed that the mj2 tools are not very cleanly separated from the library. It includes all the + internal headers, but it wasn't using the malloc wrappers. I figured the binaries should be "external" and have minimal knowledge of the + internals of the library. I patched them to not include opj_includes.h, and include only the internal headers they actually need. However, + they're using the opj_clock() function, which is in with the malloc wrappers. So I decided to move the malloc wrappers to their own header. + But mj2.c seems to want to be "internal", so I patched it to use the wrappers. Note that this patch changes the semantics of opj_malloc, it no longer + clears the memory it allocates. If you need it to be cleared, you must use opj_calloc instead, or memset it yourself. It is also somewhat + invasive, please test it extensively. I've been pounding on it all summer with my test suite, Second Life, and valgrind, and it checks out clean. October 12, 2007 * [FOD] Changed the way the image structure is allocated when the decoding parameters include some resolutions to discard. diff --git a/LibOpenJPEG.vcproj b/LibOpenJPEG.vcproj index 505f89b2..8d217d12 100644 --- a/LibOpenJPEG.vcproj +++ b/LibOpenJPEG.vcproj @@ -3,7 +3,7 @@ ProjectType="Visual C++" Version="8,00" Name="LibOpenJPEG" - ProjectGUID="{BDB8C37B-824E-4617-827C-B13E2F015EFE}" + ProjectGUID="{4F27AA53-4181-4A1A-8238-3931B0A41048}" > + + diff --git a/Makefile b/Makefile index eb97b940..f7564984 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ VER_MAJOR = 2 VER_MINOR = 1.2.0 SRCS = ./libopenjpeg/bio.c ./libopenjpeg/cio.c ./libopenjpeg/dwt.c ./libopenjpeg/event.c ./libopenjpeg/image.c ./libopenjpeg/j2k.c ./libopenjpeg/j2k_lib.c ./libopenjpeg/jp2.c ./libopenjpeg/jpt.c ./libopenjpeg/mct.c ./libopenjpeg/mqc.c ./libopenjpeg/openjpeg.c ./libopenjpeg/pi.c ./libopenjpeg/raw.c ./libopenjpeg/t1.c ./libopenjpeg/t2.c ./libopenjpeg/tcd.c ./libopenjpeg/tgt.c -INCLS = ./libopenjpeg/bio.h ./libopenjpeg/cio.h ./libopenjpeg/dwt.h ./libopenjpeg/event.h ./libopenjpeg/fix.h ./libopenjpeg/image.h ./libopenjpeg/int.h ./libopenjpeg/j2k.h ./libopenjpeg/j2k_lib.h ./libopenjpeg/jp2.h ./libopenjpeg/jpt.h ./libopenjpeg/mct.h ./libopenjpeg/mqc.h ./libopenjpeg/openjpeg.h ./libopenjpeg/pi.h ./libopenjpeg/raw.h ./libopenjpeg/t1.h ./libopenjpeg/t2.h ./libopenjpeg/tcd.h ./libopenjpeg/tgt.h ./libopenjpeg/opj_includes.h +INCLS = ./libopenjpeg/bio.h ./libopenjpeg/cio.h ./libopenjpeg/dwt.h ./libopenjpeg/event.h ./libopenjpeg/fix.h ./libopenjpeg/image.h ./libopenjpeg/int.h ./libopenjpeg/j2k.h ./libopenjpeg/j2k_lib.h ./libopenjpeg/jp2.h ./libopenjpeg/jpt.h ./libopenjpeg/mct.h ./libopenjpeg/mqc.h ./libopenjpeg/openjpeg.h ./libopenjpeg/pi.h ./libopenjpeg/raw.h ./libopenjpeg/t1.h ./libopenjpeg/t2.h ./libopenjpeg/tcd.h ./libopenjpeg/tgt.h ./libopenjpeg/opj_malloc.h ./libopenjpeg/opj_includes.h INCLUDE = -Ilibopenjpeg # General configuration variables: diff --git a/libopenjpeg/image.c b/libopenjpeg/image.c index 6698f459..ea8e59ea 100644 --- a/libopenjpeg/image.c +++ b/libopenjpeg/image.c @@ -35,7 +35,7 @@ opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *c int compno; opj_image_t *image = NULL; - image = (opj_image_t*)opj_malloc(sizeof(opj_image_t)); + image = (opj_image_t*) opj_calloc(1, sizeof(opj_image_t)); if(image) { image->color_space = clrspc; image->numcomps = numcmpts; @@ -58,7 +58,7 @@ opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *c comp->prec = cmptparms[compno].prec; comp->bpp = cmptparms[compno].bpp; comp->sgnd = cmptparms[compno].sgnd; - comp->data = (int*)opj_malloc(comp->w * comp->h * sizeof(int)); + comp->data = (int*) opj_calloc(comp->w * comp->h, sizeof(int)); if(!comp->data) { fprintf(stderr,"Unable to allocate memory for image.\n"); opj_image_destroy(image); diff --git a/libopenjpeg/j2k.c b/libopenjpeg/j2k.c index 042b8643..114ee9ec 100644 --- a/libopenjpeg/j2k.c +++ b/libopenjpeg/j2k.c @@ -259,13 +259,13 @@ char *j2k_convert_progression_order(OPJ_PROG_ORDER prg_order){ } static void j2k_check_poc_val(opj_cparameters_t *parameters, int numcomps, int numlayers){ + int* packet_array; int index, resno, compno, layno, i; - char loss = 0; int step_c = 1; int step_r = numcomps * step_c; int step_l = parameters->numresolution * step_r; - int array_size = step_l * numlayers * sizeof(int); - int *packet_array = (int *) opj_malloc(array_size); + bool loss = false; + packet_array = (int*) opj_calloc(step_l * numlayers, sizeof(int)); for (i = 0; i < parameters->numpocs ; i++) { int layno0 = 0; @@ -285,12 +285,12 @@ static void j2k_check_poc_val(opj_cparameters_t *parameters, int numcomps, int n for (layno = 0; layno < numlayers ; layno++) { index = step_r * resno + step_c * compno + step_l * layno; if(!( packet_array[index]== 1)){ - loss = 1; + loss = true; } } } } - if(loss == 1) + if(loss) fprintf(stdout,"Missing packets possible loss of data\n"); opj_free(packet_array); } @@ -536,7 +536,7 @@ static void j2k_read_siz(opj_j2k_t *j2k) { } #endif /* USE_JPWL */ - image->comps = (opj_image_comp_t *) opj_malloc(image->numcomps * sizeof(opj_image_comp_t)); + image->comps = (opj_image_comp_t*) opj_calloc(image->numcomps, sizeof(opj_image_comp_t)); for (i = 0; i < image->numcomps; i++) { int tmp, w, h; tmp = cio_read(cio, 1); /* Ssiz_i */ @@ -625,8 +625,8 @@ static void j2k_read_siz(opj_j2k_t *j2k) { } #endif /* USE_JPWL */ - cp->tcps = (opj_tcp_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tcp_t)); - cp->tileno = (int *) opj_malloc(cp->tw * cp->th * sizeof(int)); + cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t)); + cp->tileno = (int*) opj_malloc(cp->tw * cp->th * sizeof(int)); cp->tileno_size = 0; #ifdef USE_JPWL @@ -654,13 +654,13 @@ static void j2k_read_siz(opj_j2k_t *j2k) { cp->ppm_data_first = NULL; cp->ppm_previous = 0; cp->ppm_store = 0; - - j2k->default_tcp->tccps = (opj_tccp_t *) opj_malloc(sizeof(opj_tccp_t) * image->numcomps); + + j2k->default_tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t)); for (i = 0; i < cp->tw * cp->th; i++) { - cp->tcps[i].tccps = (opj_tccp_t *) opj_malloc(sizeof(opj_tccp_t) * image->numcomps); + cp->tcps[i].tccps = (opj_tccp_t*) opj_malloc(image->numcomps * sizeof(opj_tccp_t)); } - j2k->tile_data = (unsigned char **) opj_malloc(cp->tw * cp->th * sizeof(unsigned char *)); - j2k->tile_len = (int *) opj_malloc(cp->tw * cp->th * sizeof(int)); + j2k->tile_data = (unsigned char**) opj_calloc(cp->tw * cp->th, sizeof(unsigned char*)); + j2k->tile_len = (int*) opj_calloc(cp->tw * cp->th, sizeof(int)); j2k->state = J2K_STATE_MH; /* Index */ @@ -675,7 +675,7 @@ static void j2k_read_siz(opj_j2k_t *j2k) { cstr_info->tile_y = cp->tdy; cstr_info->tile_Ox = cp->tx0; cstr_info->tile_Oy = cp->ty0; - cstr_info->tile = (opj_tile_info_t*) opj_malloc(cp->tw * cp->th * sizeof(opj_tile_info_t)); + cstr_info->tile = (opj_tile_info_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tile_info_t)); } } @@ -824,7 +824,7 @@ static void j2k_read_cod(opj_j2k_t *j2k) { opj_codestream_info_t *cstr_info = j2k->cstr_info; cstr_info->prog = tcp->prg; cstr_info->numlayers = tcp->numlayers; - cstr_info->numdecompos = (int*) malloc (image->numcomps * sizeof(int)); + cstr_info->numdecompos = (int*) opj_malloc(image->numcomps * sizeof(int)); for (i = 0; i < image->numcomps; i++) { cstr_info->numdecompos[i] = tcp->tccps[i].numresolutions - 1; } @@ -1713,15 +1713,19 @@ static opj_dec_mstabent_t *j2k_dec_mstab_lookup(int id) { /* ----------------------------------------------------------------------- */ opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo) { - opj_j2k_t *j2k = (opj_j2k_t*)opj_malloc(sizeof(opj_j2k_t)); - if(j2k) { - j2k->cinfo = cinfo; - j2k->default_tcp = (opj_tcp_t*)opj_malloc(sizeof(opj_tcp_t)); - if(!j2k->default_tcp) { - opj_free(j2k); - return NULL; - } + opj_j2k_t *j2k = (opj_j2k_t*) opj_calloc(1, sizeof(opj_j2k_t)); + if(!j2k) + return NULL; + + j2k->default_tcp = (opj_tcp_t*) opj_calloc(1, sizeof(opj_tcp_t)); + if(!j2k->default_tcp) { + opj_free(j2k); + return NULL; } + + j2k->cinfo = cinfo; + j2k->tile_data = NULL; + return j2k; } @@ -1775,7 +1779,7 @@ void j2k_destroy_decompress(opj_j2k_t *j2k) { void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters) { if(j2k && parameters) { /* create and initialize the coding parameters structure */ - opj_cp_t *cp = (opj_cp_t*)opj_malloc(sizeof(opj_cp_t)); + opj_cp_t *cp = (opj_cp_t*) opj_calloc(1, sizeof(opj_cp_t)); cp->reduce = parameters->cp_reduce; cp->layer = parameters->cp_layer; cp->limit_decoding = parameters->cp_limit_decoding; @@ -1977,7 +1981,7 @@ opj_image_t* j2k_decode_jpt_stream(opj_j2k_t *j2k, opj_cio_t *cio, opj_codestre /* ----------------------------------------------------------------------- */ opj_j2k_t* j2k_create_compress(opj_common_ptr cinfo) { - opj_j2k_t *j2k = (opj_j2k_t*)opj_malloc(sizeof(opj_j2k_t)); + opj_j2k_t *j2k = (opj_j2k_t*) opj_calloc(1, sizeof(opj_j2k_t)); if(j2k) { j2k->cinfo = cinfo; } @@ -2016,7 +2020,7 @@ void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_ } /* create and initialize the coding parameters structure */ - cp = (opj_cp_t*)opj_malloc(sizeof(opj_cp_t)); + cp = (opj_cp_t*) opj_calloc(1, sizeof(opj_cp_t)); /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */ j2k->cp = cp; @@ -2140,7 +2144,7 @@ void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_ /* initialize the mutiple tiles */ /* ---------------------------- */ - cp->tcps = (opj_tcp_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tcp_t)); + cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t)); for (tileno = 0; tileno < cp->tw * cp->th; tileno++) { opj_tcp_t *tcp = &cp->tcps[tileno]; @@ -2187,8 +2191,8 @@ void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_ tcp->numpocs = 0; } - tcp->tccps = (opj_tccp_t *) opj_malloc(image->numcomps * sizeof(opj_tccp_t)); - + tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t)); + for (i = 0; i < image->numcomps; i++) { opj_tccp_t *tccp = &tcp->tccps[i]; tccp->csty = parameters->csty & 0x01; /* 0 => one precinct || 1 => custom precinct */ @@ -2299,11 +2303,11 @@ bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, opj_codestre cstr_info->tile_Oy = cp->ty0; /* new version parser */ cstr_info->numcomps = image->numcomps; cstr_info->numlayers = (&cp->tcps[0])->numlayers; - cstr_info->numdecompos = (int*) malloc (image->numcomps * sizeof(int)); + cstr_info->numdecompos = (int*) opj_malloc(image->numcomps * sizeof(int)); for (compno=0; compno < image->numcomps; compno++) { cstr_info->numdecompos[compno] = (&cp->tcps[0])->tccps->numresolutions - 1; } - cstr_info->D_max = 0; /* ADD Marcela */ + cstr_info->D_max = 0.0; /* ADD Marcela */ cstr_info->main_head_start = cio_tell(cio); /* position of SOC */ } /* << INDEX */ @@ -2450,7 +2454,7 @@ bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, opj_codestre tcd_free_encode(tcd); tcd_destroy(tcd); - free(j2k->cur_totnum_tp); + opj_free(j2k->cur_totnum_tp); j2k_write_eoc(j2k); diff --git a/libopenjpeg/j2k_lib.c b/libopenjpeg/j2k_lib.c index 62774320..91aee007 100644 --- a/libopenjpeg/j2k_lib.c +++ b/libopenjpeg/j2k_lib.c @@ -57,20 +57,3 @@ double opj_clock(void) { #endif } -void* opj_malloc( size_t size ) { - void *memblock = malloc(size); - if(memblock) { - memset(memblock, 0, size); - } - return memblock; -} - -void* opj_realloc( void *memblock, size_t size ) { - return realloc(memblock, size); -} - -void opj_free( void *memblock ) { - free(memblock); -} - - diff --git a/libopenjpeg/j2k_lib.h b/libopenjpeg/j2k_lib.h index 99f06196..7df4d367 100644 --- a/libopenjpeg/j2k_lib.h +++ b/libopenjpeg/j2k_lib.h @@ -29,13 +29,9 @@ @file j2k_lib.h @brief Internal functions -The functions in J2K_LIB.C are internal utilities mainly used for memory management. +The functions in J2K_LIB.C are internal utilities mainly used for timing. */ -#ifndef __GNUC__ -#define __attribute__(x) /* */ -#endif - /** @defgroup MISC MISC - Miscellaneous internal functions */ /*@{*/ @@ -49,85 +45,6 @@ Difference in successive opj_clock() calls tells you the elapsed time */ double opj_clock(void); -/** -Allocate a memory block with elements initialized to 0 -@param size Bytes to allocate -@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available -*/ -void* __attribute__ ((malloc)) opj_malloc( size_t size ); - -/** -Allocate memory aligned to a 16 byte boundry -@param size Bytes to allocate -@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available -*/ -/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */ -#ifdef WIN32 - /* Someone should tell the mingw people that their malloc.h ought to provide _mm_malloc() */ - #ifdef __GNUC__ - #include - #define HAVE_MM_MALLOC - #else /* MSVC, Intel C++ */ - #include - #ifdef _mm_malloc - #define HAVE_MM_MALLOC - #endif - #endif -#else /* Not WIN32 */ - #if defined(__sun) - #define HAVE_MEMALIGN - /* Linux x86_64 and OSX always align allocations to 16 bytes */ - #elif !defined(__amd64__) && !defined(__APPLE__) - /* FIXME: Yes, this is a big assumption */ - #define HAVE_POSIX_MEMALIGN - #endif -#endif - -#define opj_aligned_malloc(size) malloc(size) -#define opj_aligned_free(m) free(m) - -#ifdef HAVE_MM_MALLOC - #undef opj_aligned_malloc - #define opj_aligned_malloc(size) _mm_malloc(size, 16) - #undef opj_aligned_free - #define opj_aligned_free(m) _mm_free(m) -#endif - -#ifdef HAVE_MEMALIGN - extern void* memalign(size_t, size_t); - #undef opj_aligned_malloc - #define opj_aligned_malloc(size) memalign(16, (size)) - #undef opj_aligned_free - #define opj_aligned_free(m) free(m) -#endif - -#ifdef HAVE_POSIX_MEMALIGN - #undef opj_aligned_malloc - extern int posix_memalign(void**, size_t, size_t); - - static INLINE void* __attribute__ ((malloc)) opj_aligned_malloc(size_t size){ - void* mem = NULL; - posix_memalign(&mem, 16, size); - return mem; - } - #undef opj_aligned_free - #define opj_aligned_free(m) free(m) -#endif - -/** -Reallocate memory blocks. -@param memblock Pointer to previously allocated memory block -@param size New size in bytes -@return Returns a void pointer to the reallocated (and possibly moved) memory block -*/ -void* __attribute__ ((malloc)) opj_realloc( void *memblock, size_t size ); - -/** -Deallocates or frees a memory block. -@param memblock Previously allocated memory block to be freed -*/ -void opj_free( void *memblock ); - /* ----------------------------------------------------------------------- */ /*@}*/ diff --git a/libopenjpeg/jp2.c b/libopenjpeg/jp2.c index 92abf2e1..14f9493c 100644 --- a/libopenjpeg/jp2.c +++ b/libopenjpeg/jp2.c @@ -507,7 +507,7 @@ static bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio) { /* ----------------------------------------------------------------------- */ opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo) { - opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t)); + opj_jp2_t *jp2 = (opj_jp2_t*) opj_calloc(1, sizeof(opj_jp2_t)); if(jp2) { jp2->cinfo = cinfo; /* create the J2K codec */ diff --git a/libopenjpeg/opj_includes.h b/libopenjpeg/opj_includes.h index 72152a5e..7599a71f 100644 --- a/libopenjpeg/opj_includes.h +++ b/libopenjpeg/opj_includes.h @@ -54,6 +54,11 @@ ========================================================== */ +/* Ignore GCC attributes if this is not GCC */ +#ifndef __GNUC__ + #define __attribute__(x) /* __attribute__(x) */ +#endif + /* The inline keyword is supported by C99 but not by C90. Most compilers implement their own version of this keyword ... @@ -72,6 +77,7 @@ Most compilers implement their own version of this keyword ... #endif /* INLINE */ #include "j2k_lib.h" +#include "opj_malloc.h" #include "event.h" #include "cio.h" diff --git a/libopenjpeg/opj_malloc.h b/libopenjpeg/opj_malloc.h new file mode 100644 index 00000000..9b7c8956 --- /dev/null +++ b/libopenjpeg/opj_malloc.h @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2005, Hervé Drolon, FreeImage Team + * Copyright (c) 2007, Callum Lerwick + * 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. + */ +#ifndef __OPJ_MALLOC_H +#define __OPJ_MALLOC_H +/** +@file opj_malloc.h +@brief Internal functions + +The functions in opj_malloc.h are internal utilities used for memory management. +*/ + +/** @defgroup MISC MISC - Miscellaneous internal functions */ +/*@{*/ + +/** @name Exported functions */ +/*@{*/ +/* ----------------------------------------------------------------------- */ + +/** +Allocate an uninitialized memory block +@param size Bytes to allocate +@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available +*/ +#define opj_malloc(size) malloc(size) + +/** +Allocate a memory block with elements initialized to 0 +@param num Blocks to allocate +@param size Bytes per block to allocate +@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available +*/ +#define opj_calloc(num, size) calloc(num, size) + +/** +Allocate memory aligned to a 16 byte boundry +@param size Bytes to allocate +@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available +*/ +/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */ +#ifdef WIN32 + /* Someone should tell the mingw people that their malloc.h ought to provide _mm_malloc() */ + #ifdef __GNUC__ + #include + #define HAVE_MM_MALLOC + #else /* MSVC, Intel C++ */ + #include + #ifdef _mm_malloc + #define HAVE_MM_MALLOC + #endif + #endif +#else /* Not WIN32 */ + #if defined(__sun) + #define HAVE_MEMALIGN + /* Linux x86_64 and OSX always align allocations to 16 bytes */ + #elif !defined(__amd64__) && !defined(__APPLE__) + /* FIXME: Yes, this is a big assumption */ + #define HAVE_POSIX_MEMALIGN + #endif +#endif + +#define opj_aligned_malloc(size) malloc(size) +#define opj_aligned_free(m) free(m) + +#ifdef HAVE_MM_MALLOC + #undef opj_aligned_malloc + #define opj_aligned_malloc(size) _mm_malloc(size, 16) + #undef opj_aligned_free + #define opj_aligned_free(m) _mm_free(m) +#endif + +#ifdef HAVE_MEMALIGN + extern void* memalign(size_t, size_t); + #undef opj_aligned_malloc + #define opj_aligned_malloc(size) memalign(16, (size)) + #undef opj_aligned_free + #define opj_aligned_free(m) free(m) +#endif + +#ifdef HAVE_POSIX_MEMALIGN + #undef opj_aligned_malloc + extern int posix_memalign(void**, size_t, size_t); + + static INLINE void* __attribute__ ((malloc)) opj_aligned_malloc(size_t size){ + void* mem = NULL; + posix_memalign(&mem, 16, size); + return mem; + } + #undef opj_aligned_free + #define opj_aligned_free(m) free(m) +#endif + +/** +Reallocate memory blocks. +@param memblock Pointer to previously allocated memory block +@param size New size in bytes +@return Returns a void pointer to the reallocated (and possibly moved) memory block +*/ +#define opj_realloc(m, s) realloc(m, s) + +/** +Deallocates or frees a memory block. +@param memblock Previously allocated memory block to be freed +*/ +#define opj_free(m) free(m) + +#ifdef __GNUC__ +#pragma GCC poison malloc calloc realloc free +#endif + +/* ----------------------------------------------------------------------- */ +/*@}*/ + +/*@}*/ + +#endif /* __OPJ_MALLOC_H */ + diff --git a/libopenjpeg/pi.c b/libopenjpeg/pi.c index e43be817..b5e8656d 100644 --- a/libopenjpeg/pi.c +++ b/libopenjpeg/pi.c @@ -413,17 +413,15 @@ opj_pi_iterator_t *pi_create_decode(opj_image_t *image, opj_cp_t *cp, int tileno opj_pi_iterator_t *pi = NULL; opj_tcp_t *tcp = NULL; opj_tccp_t *tccp = NULL; - size_t array_size; - + tcp = &cp->tcps[tileno]; - array_size = (tcp->numpocs + 1) * sizeof(opj_pi_iterator_t); - pi = (opj_pi_iterator_t *) opj_malloc(array_size); + pi = (opj_pi_iterator_t*) opj_calloc((tcp->numpocs + 1), sizeof(opj_pi_iterator_t)); if(!pi) { /* TODO: throw an error */ return NULL; } - + for (pino = 0; pino < tcp->numpocs + 1; pino++) { /* change */ int maxres = 0; int maxprec = 0; @@ -436,14 +434,12 @@ opj_pi_iterator_t *pi_create_decode(opj_image_t *image, opj_cp_t *cp, int tileno pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1); pi[pino].numcomps = image->numcomps; - array_size = image->numcomps * sizeof(opj_pi_comp_t); - pi[pino].comps = (opj_pi_comp_t *) opj_malloc(array_size); + pi[pino].comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t)); if(!pi[pino].comps) { /* TODO: throw an error */ pi_destroy(pi, cp, tileno); return NULL; } - memset(pi[pino].comps, 0, array_size); for (compno = 0; compno < pi->numcomps; compno++) { int tcx0, tcy0, tcx1, tcy1; @@ -453,8 +449,7 @@ opj_pi_iterator_t *pi_create_decode(opj_image_t *image, opj_cp_t *cp, int tileno comp->dy = image->comps[compno].dy; comp->numresolutions = tccp->numresolutions; - array_size = comp->numresolutions * sizeof(opj_pi_resolution_t); - comp->resolutions = (opj_pi_resolution_t *) opj_malloc(array_size); + comp->resolutions = (opj_pi_resolution_t*) opj_calloc(comp->numresolutions, sizeof(opj_pi_resolution_t)); if(!comp->resolutions) { /* TODO: throw an error */ pi_destroy(pi, cp, tileno); @@ -507,8 +502,7 @@ opj_pi_iterator_t *pi_create_decode(opj_image_t *image, opj_cp_t *cp, int tileno pi[pino].step_l = maxres * pi[pino].step_r; if (pino == 0) { - array_size = image->numcomps * maxres * tcp->numlayers * maxprec * sizeof(short int); - pi[pino].include = (short int *) opj_malloc(array_size); + pi[pino].include = (short int*) opj_calloc(image->numcomps * maxres * tcp->numlayers * maxprec, sizeof(short int)); if(!pi[pino].include) { /* TODO: throw an error */ pi_destroy(pi, cp, tileno); @@ -554,15 +548,13 @@ opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int ti opj_pi_iterator_t *pi = NULL; opj_tcp_t *tcp = NULL; opj_tccp_t *tccp = NULL; - size_t array_size; tcp = &cp->tcps[tileno]; - array_size = (tcp->numpocs + 1) * sizeof(opj_pi_iterator_t); - pi = (opj_pi_iterator_t *) opj_malloc(array_size); + pi = (opj_pi_iterator_t*) opj_calloc((tcp->numpocs + 1), sizeof(opj_pi_iterator_t)); if(!pi) { return NULL;} pi->tp_on = cp->tp_on; - + for(pino = 0;pino < tcp->numpocs+1 ; pino ++){ p = tileno % cp->tw; q = tileno / cp->tw; @@ -573,13 +565,11 @@ opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int ti pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1); pi[pino].numcomps = image->numcomps; - array_size = image->numcomps * sizeof(opj_pi_comp_t); - pi[pino].comps = (opj_pi_comp_t *) opj_malloc(array_size); + pi[pino].comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t)); if(!pi[pino].comps) { pi_destroy(pi, cp, tileno); return NULL; } - memset(pi[pino].comps, 0, array_size); for (compno = 0; compno < pi[pino].numcomps; compno++) { int tcx0, tcy0, tcx1, tcy1; @@ -589,8 +579,7 @@ opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int ti comp->dy = image->comps[compno].dy; comp->numresolutions = tccp->numresolutions; - array_size = comp->numresolutions * sizeof(opj_pi_resolution_t); - comp->resolutions = (opj_pi_resolution_t *) opj_malloc(array_size); + comp->resolutions = (opj_pi_resolution_t*) opj_malloc(comp->numresolutions * sizeof(opj_pi_resolution_t)); if(!comp->resolutions) { pi_destroy(pi, cp, tileno); return NULL; @@ -653,8 +642,7 @@ opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int ti } if (pino == 0) { - array_size = tcp->numlayers * pi[pino].step_l * sizeof(short int); - pi[pino].include = (short int *) opj_malloc(array_size); + pi[pino].include = (short int*) opj_calloc(tcp->numlayers * pi[pino].step_l, sizeof(short int)); if(!pi[pino].include) { pi_destroy(pi, cp, tileno); return NULL; diff --git a/libopenjpeg/t1.c b/libopenjpeg/t1.c index c05d05c0..d359b093 100644 --- a/libopenjpeg/t1.c +++ b/libopenjpeg/t1.c @@ -762,7 +762,7 @@ static bool allocate_buffers( if(datasize > t1->datasize){ opj_aligned_free(t1->data); - t1->data=opj_aligned_malloc(datasize * sizeof(int)); + t1->data = (int*) opj_aligned_malloc(datasize * sizeof(int)); if(!t1->data){ return false; } @@ -775,7 +775,7 @@ static bool allocate_buffers( if(flagssize > t1->flagssize){ opj_aligned_free(t1->flags); - t1->flags=opj_aligned_malloc(flagssize * sizeof(flag_t)); + t1->flags = (flag_t*) opj_aligned_malloc(flagssize * sizeof(flag_t)); if(!t1->flags){ return false; } @@ -998,15 +998,15 @@ opj_t1_t* t1_create(opj_common_ptr cinfo) { if(!t1) return NULL; - t1->cinfo = cinfo; - /* create MQC and RAW handles */ - t1->mqc = mqc_create(); - t1->raw = raw_create(); + t1->cinfo = cinfo; + /* create MQC and RAW handles */ + t1->mqc = mqc_create(); + t1->raw = raw_create(); - t1->datasize=0; t1->data=NULL; - t1->flagssize=0; t1->flags=NULL; + t1->datasize=0; + t1->flagssize=0; return t1; } @@ -1018,7 +1018,7 @@ void t1_destroy(opj_t1_t *t1) { raw_destroy(t1->raw); opj_aligned_free(t1->data); opj_aligned_free(t1->flags); - free(t1); + opj_free(t1); } } diff --git a/libopenjpeg/tcd.c b/libopenjpeg/tcd.c index 8d91b851..2a8a6223 100644 --- a/libopenjpeg/tcd.c +++ b/libopenjpeg/tcd.c @@ -313,7 +313,7 @@ void tcd_malloc_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int c prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn; prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn; - prc->cblks = (opj_tcd_cblk_t *) opj_malloc((prc->cw * prc->ch) * sizeof(opj_tcd_cblk_t)); + prc->cblks = (opj_tcd_cblk_t*) opj_calloc((prc->cw * prc->ch), sizeof(opj_tcd_cblk_t)); prc->incltree = tgt_create(prc->cw, prc->ch); prc->imsbtree = tgt_create(prc->cw, prc->ch); @@ -548,7 +548,7 @@ void tcd_init_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int cur prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn; opj_free(prc->cblks); - prc->cblks = (opj_tcd_cblk_t *) opj_malloc(prc->cw * prc->ch * sizeof(opj_tcd_cblk_t)); + prc->cblks = (opj_tcd_cblk_t*) opj_calloc(prc->cw * prc->ch, sizeof(opj_tcd_cblk_t)); if (prc->incltree != NULL) { tgt_destroy(prc->incltree); @@ -603,7 +603,7 @@ void tcd_malloc_decode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp) { tileno = cp->tileno[j]; tile = &(tcd->tcd_image->tiles[cp->tileno[tileno]]); tile->numcomps = image->numcomps; - tile->comps = (opj_tcd_tilecomp_t *) opj_malloc(image->numcomps * sizeof(opj_tcd_tilecomp_t)); + tile->comps = (opj_tcd_tilecomp_t*) opj_calloc(image->numcomps, sizeof(opj_tcd_tilecomp_t)); } for (i = 0; i < image->numcomps; i++) { @@ -799,6 +799,7 @@ void tcd_malloc_decode_tile(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, cblk->y0 = int_max(cblkystart, prc->y0); cblk->x1 = int_min(cblkxend, prc->x1); cblk->y1 = int_min(cblkyend, prc->y1); + cblk->numsegs = 0; } } /* precno */ } /* bandno */ @@ -1178,7 +1179,7 @@ int tcd_encode_tile(opj_tcd_t *tcd, int tileno, unsigned char *dest, int len, op cstr_info->tile[tileno].pdx[i] = tccp->prcw[i]; cstr_info->tile[tileno].pdy[i] = tccp->prch[i]; } - cstr_info->tile[tileno].packet = (opj_packet_info_t *) opj_malloc(cstr_info->numcomps * cstr_info->numlayers * numpacks * sizeof(opj_packet_info_t)); + cstr_info->tile[tileno].packet = (opj_packet_info_t*) opj_calloc(cstr_info->numcomps * cstr_info->numlayers * numpacks, sizeof(opj_packet_info_t)); } /* << INDEX */ diff --git a/libopenjpeg/tgt.c b/libopenjpeg/tgt.c index 30b0aee4..a5dbcd3c 100644 --- a/libopenjpeg/tgt.c +++ b/libopenjpeg/tgt.c @@ -71,7 +71,7 @@ opj_tgt_tree_t *tgt_create(int numleafsh, int numleafsv) { return NULL; } - tree->nodes = (opj_tgt_node_t *) opj_malloc(tree->numnodes * sizeof(opj_tgt_node_t)); + tree->nodes = (opj_tgt_node_t*) opj_calloc(tree->numnodes, sizeof(opj_tgt_node_t)); if(!tree->nodes) { opj_free(tree); return NULL; diff --git a/mj2/extract_j2k_from_mj2.c b/mj2/extract_j2k_from_mj2.c index eff86063..6ecaf834 100644 --- a/mj2/extract_j2k_from_mj2.c +++ b/mj2/extract_j2k_from_mj2.c @@ -26,7 +26,13 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include "opj_includes.h" +#include +#include +#include + +#include "openjpeg.h" +#include "j2k.h" +#include "jp2.h" #include "mj2.h" /* -------------------------------------------------------------------------- */ diff --git a/mj2/frames_to_mj2.c b/mj2/frames_to_mj2.c index c780fd11..299b8e66 100644 --- a/mj2/frames_to_mj2.c +++ b/mj2/frames_to_mj2.c @@ -25,7 +25,15 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include "opj_includes.h" +#include +#include +#include + +#include "openjpeg.h" +#include "j2k_lib.h" +#include "j2k.h" +#include "jp2.h" +#include "cio.h" #include "mj2.h" #include "mj2_convert.h" #include "compat/getopt.h" @@ -697,8 +705,8 @@ int main(int argc, char **argv) fwrite(buf,cio_tell(cio),1,mj2file); offset = cio_tell(cio); opj_cio_close(cio); - opj_free(buf); - + free(buf); + for (i = 0; i < movie->num_stk + movie->num_htk + movie->num_vtk; i++) { if (movie->tk[i].track_type != 0) { fprintf(stderr, "Unable to write sound or hint tracks\n"); @@ -755,7 +763,7 @@ int main(int argc, char **argv) } /* free buffer data */ - opj_free(buf); + free(buf); /* free image data */ opj_image_destroy(img); } @@ -770,14 +778,14 @@ int main(int argc, char **argv) cio_write(cio, offset - mdat_initpos, 4); fwrite(buf, 4, 1, mj2file); fseek(mj2file,0,SEEK_END); - opj_free(buf); - + free(buf); + // Writing MOOV box buf = (char*) malloc ((TEMP_BUF+numframes*20) * sizeof(char)); cio = opj_cio_open(movie->cinfo, buf, (TEMP_BUF+numframes*20)); mj2_write_moov(movie, cio); fwrite(buf,cio_tell(cio),1,mj2file); - opj_free(buf); + free(buf); fprintf(stdout,"Total encoding time: %.2f s for %d frames (%.1f fps)\n", total_time, numframes, (float)numframes/total_time); diff --git a/mj2/frames_to_mj2.vcproj b/mj2/frames_to_mj2.vcproj index adf9bdf7..92e8eac7 100644 --- a/mj2/frames_to_mj2.vcproj +++ b/mj2/frames_to_mj2.vcproj @@ -75,6 +75,7 @@ OutputFile=".\Release/frames_to_mj2.exe" LinkIncremental="1" SuppressStartupBanner="true" + IgnoreDefaultLibraryNames="LIBC" ProgramDatabaseFile=".\Release/frames_to_mj2.pdb" SubSystem="1" TargetMachine="1" @@ -166,7 +167,7 @@ OutputFile=".\frames_to_mj2___Win32_Debug0/frames_to_mj2.exe" LinkIncremental="2" SuppressStartupBanner="true" - IgnoreDefaultLibraryNames="libcmt" + IgnoreDefaultLibraryNames="LIBC,LIBCMT" GenerateDebugInformation="true" ProgramDatabaseFile=".\frames_to_mj2___Win32_Debug0/frames_to_mj2.pdb" SubSystem="1" diff --git a/mj2/mj2.c b/mj2/mj2.c index 022aa232..1a15550d 100644 --- a/mj2/mj2.c +++ b/mj2/mj2.c @@ -96,9 +96,8 @@ int mj2_init_stdmovie(opj_mj2_t * movie) movie->brand = MJ2_MJ2; movie->minversion = 0; movie->num_cl = 2; - movie->cl = - (unsigned int *) malloc(movie->num_cl * sizeof(unsigned int)); - + movie->cl = (unsigned int*) opj_malloc(movie->num_cl * sizeof(unsigned int)); + movie->cl[0] = MJ2_MJ2; movie->cl[1] = MJ2_MJ2S; time(<ime); /* Time since 1/1/70 */ @@ -139,9 +138,7 @@ int mj2_init_stdmovie(opj_mj2_t * movie) tk->same_sample_size = 0; tk->num_samplestochunk = 1; /* One sample per chunk */ - tk->sampletochunk = - (mj2_sampletochunk_t *) malloc(tk->num_samplestochunk * - sizeof(mj2_sampletochunk_t)); + tk->sampletochunk = (mj2_sampletochunk_t*) opj_malloc(tk->num_samplestochunk * sizeof(mj2_sampletochunk_t)); tk->sampletochunk[0].first_chunk = 1; tk->sampletochunk[0].samples_per_chunk = 1; tk->sampletochunk[0].sample_descr_idx = 1; @@ -158,7 +155,7 @@ int mj2_init_stdmovie(opj_mj2_t * movie) } tk->num_tts = 1; - tk->tts = (mj2_tts_t *) malloc(tk->num_tts * sizeof(mj2_tts_t)); + tk->tts = (mj2_tts_t*) opj_malloc(tk->num_tts * sizeof(mj2_tts_t)); tk->tts[0].sample_count = tk->num_samples; tk->tts[0].sample_delta = tk->timescale / tk->sample_rate; @@ -196,7 +193,7 @@ int mj2_init_stdmovie(opj_mj2_t * movie) tk->or_fieldcount = 1; tk->or_fieldorder = 0; tk->num_br = 2; - tk->br = (unsigned int *) malloc(tk->num_br * sizeof(unsigned int)); + tk->br = (unsigned int*) opj_malloc(tk->num_br * sizeof(unsigned int)); tk->br[0] = MJ2_JP2; tk->br[1] = MJ2_J2P0; tk->num_jp2x = 0; @@ -226,10 +223,9 @@ void mj2_tts_decompact(mj2_tk_t * tk) for (i = 0; i < tk->num_tts; i++) { tk->num_samples += tk->tts[i].sample_count; } - - tk->sample = - (mj2_sample_t *) malloc(tk->num_samples * sizeof(mj2_sample_t)); - + + tk->sample = (mj2_sample_t*) opj_malloc(tk->num_samples * sizeof(mj2_sample_t)); + for (i = 0; i < tk->num_tts; i++) { for (j = 0; j < tk->tts[i].sample_count; j++) { tk->sample[j].sample_delta = tk->tts[i].sample_delta; @@ -251,15 +247,13 @@ void mj2_stsc_decompact(mj2_tk_t * tk) tk->num_chunks = (unsigned int) ceil((double) tk->num_samples / (double) tk->sampletochunk[0].samples_per_chunk); - tk->chunk = - (mj2_chunk_t *) malloc(tk->num_chunks * sizeof(mj2_chunk_t)); + tk->chunk = (mj2_chunk_t*) opj_malloc(tk->num_chunks * sizeof(mj2_chunk_t)); for (k = 0; k < tk->num_chunks; k++) { tk->chunk[k].num_samples = tk->sampletochunk[0].samples_per_chunk; } } else { - tk->chunk = - (mj2_chunk_t *) malloc(tk->num_samples * sizeof(mj2_chunk_t)); + tk->chunk = (mj2_chunk_t*) opj_malloc(tk->num_samples * sizeof(mj2_chunk_t)); tk->num_chunks = 0; for (i = 0; i < tk->num_samplestochunk -1 ; i++) { for (j = tk->sampletochunk[i].first_chunk - 1; @@ -275,7 +269,7 @@ void mj2_stsc_decompact(mj2_tk_t * tk) tk->chunk[k].num_samples = tk->sampletochunk[tk->num_samplestochunk - 1].samples_per_chunk; } - tk->chunk = realloc(tk->chunk, tk->num_chunks * sizeof(mj2_chunk_t)); + tk->chunk = opj_realloc(tk->chunk, tk->num_chunks * sizeof(mj2_chunk_t)); } } @@ -396,9 +390,8 @@ int mj2_read_ftyp(opj_mj2_t * movie, opj_cio_t *cio) movie->brand = cio_read(cio, 4); /* BR */ movie->minversion = cio_read(cio, 4); /* MinV */ movie->num_cl = (box.length - 16) / 4; - movie->cl = - (unsigned int *) malloc(movie->num_cl * sizeof(unsigned int)); - + movie->cl = (unsigned int*) opj_malloc(movie->num_cl * sizeof(unsigned int)); + for (i = movie->num_cl - 1; i > -1; i--) movie->cl[i] = cio_read(cio, 4); /* CLi */ @@ -643,12 +636,9 @@ int mj2_read_stsc(mj2_tk_t * tk, opj_cio_t *cio) } tk->num_samplestochunk = cio_read(cio, 4); - - tk->sampletochunk = - (mj2_sampletochunk_t *) malloc(tk->num_samplestochunk * - sizeof(mj2_sampletochunk_t)); - - + + tk->sampletochunk = (mj2_sampletochunk_t*) opj_malloc(tk->num_samplestochunk * sizeof(mj2_sampletochunk_t)); + for (i = 0; i < tk->num_samplestochunk; i++) { tk->sampletochunk[i].first_chunk = cio_read(cio, 4); tk->sampletochunk[i].samples_per_chunk = cio_read(cio, 4); @@ -725,9 +715,9 @@ int mj2_read_stts(mj2_tk_t * tk, opj_cio_t *cio) } tk->num_tts = cio_read(cio, 4); - - tk->tts = (mj2_tts_t *) malloc(tk->num_tts * sizeof(mj2_tts_t)); - + + tk->tts = (mj2_tts_t*) opj_malloc(tk->num_tts * sizeof(mj2_tts_t)); + for (i = 0; i < tk->num_tts; i++) { tk->tts[i].sample_count = cio_read(cio, 4); tk->tts[i].sample_delta = cio_read(cio, 4); @@ -905,8 +895,8 @@ int mj2_read_jp2p(mj2_tk_t * tk, opj_cio_t *cio) tk->num_br = (box.length - 12) / 4; - tk->br = (unsigned int *) malloc(tk->num_br * sizeof(unsigned int)); - + tk->br = (unsigned int*) opj_malloc(tk->num_br * sizeof(unsigned int)); + for (i = 0; i < tk->num_br; i++) { tk->br[i] = cio_read(cio, 4); } @@ -964,9 +954,8 @@ int mj2_read_jp2x(mj2_tk_t * tk, opj_cio_t *cio) tk->num_jp2x = (box.length - 8); - tk->jp2xdata = - (unsigned char *) malloc(tk->num_jp2x * sizeof(unsigned char)); - + tk->jp2xdata = (unsigned char*) opj_malloc(tk->num_jp2x * sizeof(unsigned char)); + for (i = 0; i < tk->num_jp2x; i++) { tk->jp2xdata[i] = cio_read(cio, 1); } @@ -1172,10 +1161,10 @@ int mj2_read_smj2(opj_image_t * img, mj2_tk_t * tk, opj_cio_t *cio) opj_event_msg(tk->cinfo, EVT_ERROR, "Error reading JP2H Box\n"); return 1; } - - tk->jp2_struct.comps = (opj_jp2_comps_t *) malloc(tk->jp2_struct.numcomps * sizeof(opj_jp2_comps_t)); - tk->jp2_struct.cl = (int *) malloc(sizeof(int)); - + + tk->jp2_struct.comps = (opj_jp2_comps_t*) opj_malloc(tk->jp2_struct.numcomps * sizeof(opj_jp2_comps_t)); + tk->jp2_struct.cl = (int*) opj_malloc(sizeof(int)); + tk->num_br = 0; tk->num_jp2x = 0; @@ -2046,8 +2035,8 @@ int mj2_read_hdlr(mj2_tk_t * tk, opj_cio_t *cio) cio_skip(cio,12); /* Reserved */ tk->name_size = box.length - 32; - - tk->name = (char *) malloc(tk->name_size * sizeof(char)); + + tk->name = (char*) opj_malloc(tk->name_size * sizeof(char)); for (i = 0; i < tk->name_size; i++) { tk->name[i] = cio_read(cio, 1); /* Name */ } @@ -2581,10 +2570,9 @@ int mj2_read_moov(opj_mj2_t * movie, opj_image_t * img, opj_cio_t *cio) if (mj2_read_mvhd(movie, cio)) return 1; - - movie->tk = - (mj2_tk_t *) malloc((movie->next_tk_id - 1) * sizeof(mj2_tk_t)); - + + movie->tk = (mj2_tk_t*) opj_malloc((movie->next_tk_id - 1) * sizeof(mj2_tk_t)); + for (i = 0; cio_tell(cio) - box.init_pos < box.length; i++) { mj2_tk_t *tk = &movie->tk[i]; tk->cinfo = movie->cinfo; @@ -2622,8 +2610,8 @@ int mj2_read_struct(FILE *file, opj_mj2_t *movie) { opj_cio_t *cio; /* open a byte stream for reading */ - src = (char*) malloc (300 * sizeof(char)); - + src = (char*) opj_malloc(300 * sizeof(char)); + /* Assuming that jp and ftyp markers size do not exceed 300 bytes */ fread(src,300,1, file); @@ -2706,7 +2694,7 @@ int mj2_read_struct(FILE *file, opj_mj2_t *movie) { } fseek(file,foffset,SEEK_SET); - src = realloc(src,box.length); + src = opj_realloc(src,box.length); fsresult = fread(src,box.length,1,file); if (fsresult != 1) { opj_event_msg(cio->cinfo, EVT_ERROR, "End of file reached while trying to read MOOV box\n"); @@ -2717,8 +2705,8 @@ int mj2_read_struct(FILE *file, opj_mj2_t *movie) { if (mj2_read_moov(movie, &img, cio)) return 1; - - free(src); + + opj_free(src); return 0; } @@ -2728,12 +2716,12 @@ int mj2_read_struct(FILE *file, opj_mj2_t *movie) { opj_dinfo_t* mj2_create_decompress() { opj_mj2_t* mj2; - opj_dinfo_t *dinfo = (opj_dinfo_t*)opj_malloc(sizeof(opj_dinfo_t)); + opj_dinfo_t *dinfo = (opj_dinfo_t*) opj_calloc(1, sizeof(opj_dinfo_t)); if(!dinfo) return NULL; dinfo->is_decompressor = true; - mj2 = (opj_mj2_t*)opj_malloc(sizeof(opj_mj2_t)); + mj2 = (opj_mj2_t*) opj_calloc(1, sizeof(opj_mj2_t)); dinfo->mj2_handle = mj2; if(mj2) { mj2->cinfo = (opj_common_ptr)dinfo; @@ -2806,10 +2794,10 @@ void mj2_destroy_decompress(opj_mj2_t *movie) { opj_cinfo_t* mj2_create_compress() { opj_mj2_t* mj2; - opj_cinfo_t *cinfo = (opj_cinfo_t*)opj_malloc(sizeof(opj_cinfo_t)); + opj_cinfo_t *cinfo = (opj_cinfo_t*) opj_calloc(1, sizeof(opj_cinfo_t)); if(!cinfo) return NULL; - mj2 = (opj_mj2_t*)opj_malloc(sizeof(opj_mj2_t)); + mj2 = (opj_mj2_t*) opj_calloc(1, sizeof(opj_mj2_t)); cinfo->mj2_handle = mj2; if(mj2) { mj2->cinfo = (opj_common_ptr)cinfo; @@ -2831,16 +2819,14 @@ void mj2_setup_encoder(opj_mj2_t *movie, mj2_cparameters_t *parameters) { movie->brand = MJ2_MJ2; // One brand: MJ2 movie->num_cl = 2; // Two compatible brands: MJ2 and MJ2S - movie->cl = (unsigned int *) malloc(movie->num_cl * sizeof(unsigned int)); + movie->cl = (unsigned int*) opj_malloc(movie->num_cl * sizeof(unsigned int)); movie->cl[0] = MJ2_MJ2; movie->cl[1] = MJ2_MJ2S; movie->minversion = 0; // Minimum version: 0 - movie->tk = (mj2_tk_t*) malloc (sizeof(mj2_tk_t)); //Memory allocation for the video track - movie->tk[0].sample = (mj2_sample_t*) malloc (sizeof(mj2_sample_t)); - movie->tk[0].chunk = (mj2_chunk_t *) malloc(sizeof(mj2_chunk_t)); - movie->tk[0].track_type = 0; // Video track + movie->tk = (mj2_tk_t*) opj_malloc(sizeof(mj2_tk_t)); //Memory allocation for the video track movie->tk[0].track_ID = 1; // Track ID = 1 + movie->tk[0].track_type = 0; // Video track movie->tk[0].Dim[0] = parameters->Dim[0]; movie->tk[0].Dim[1] = parameters->Dim[1]; movie->tk[0].w = parameters->w; @@ -2848,17 +2834,19 @@ void mj2_setup_encoder(opj_mj2_t *movie, mj2_cparameters_t *parameters) { movie->tk[0].CbCr_subsampling_dx = parameters->CbCr_subsampling_dx; movie->tk[0].CbCr_subsampling_dy = parameters->CbCr_subsampling_dy; movie->tk[0].sample_rate = parameters->frame_rate; - + movie->tk[0].name_size = 0; + movie->tk[0].chunk = (mj2_chunk_t*) opj_malloc(sizeof(mj2_chunk_t)); + movie->tk[0].sample = (mj2_sample_t*) opj_malloc(sizeof(mj2_sample_t)); + jp2_struct = &movie->tk[0].jp2_struct; jp2_struct->numcomps = 3; // NC - jp2_struct->comps = - (opj_jp2_comps_t *) malloc(jp2_struct->numcomps * sizeof(opj_jp2_comps_t)); + jp2_struct->comps = (opj_jp2_comps_t*) opj_malloc(jp2_struct->numcomps * sizeof(opj_jp2_comps_t)); jp2_struct->precedence = 0; /* PRECEDENCE*/ jp2_struct->approx = 0; /* APPROX*/ jp2_struct->brand = JP2_JP2; /* BR */ jp2_struct->minversion = 0; /* MinV */ jp2_struct->numcl = 1; - jp2_struct->cl = (unsigned int *) malloc(jp2_struct->numcl * sizeof(int)); + jp2_struct->cl = (unsigned int*) opj_malloc(jp2_struct->numcl * sizeof(int)); jp2_struct->cl[0] = JP2_JP2; /* CL0 : JP2 */ jp2_struct->C = 7; /* C : Always 7*/ jp2_struct->UnkC = 0; /* UnkC, colorspace specified in colr box*/ diff --git a/mj2/mj2_to_frames.c b/mj2/mj2_to_frames.c index bf4dfe6b..a94f6612 100644 --- a/mj2/mj2_to_frames.c +++ b/mj2/mj2_to_frames.c @@ -25,7 +25,14 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include "opj_includes.h" +#include +#include +#include + +#include "openjpeg.h" +#include "j2k_lib.h" +#include "j2k.h" +#include "jp2.h" #include "mj2.h" #include "mj2_convert.h" diff --git a/mj2/wrap_j2k_in_mj2.c b/mj2/wrap_j2k_in_mj2.c index 71dab0de..dd2af757 100644 --- a/mj2/wrap_j2k_in_mj2.c +++ b/mj2/wrap_j2k_in_mj2.c @@ -26,9 +26,20 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include "opj_includes.h" +#include +#include +#include + +#include "openjpeg.h" +#include "j2k.h" +#include "jp2.h" +#include "cio.h" #include "mj2.h" +static int int_ceildiv(int a, int b) { + return (a + b - 1) / b; +} + /** Size of memory first allocated for MOOV box */