walkero
/
openjpeg
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
openjpeg/libopenjpeg/t1.c

1192 lines
29 KiB
C
Raw Normal View History

Initial revision
2003-11-27 11:10:17 +01:00
/*
Copyright update
2007-01-15 10:55:40 +01:00
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2007, Professor Benoit Macq
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
* Copyright (c) 2001-2003, David Janssens
Initial revision
2003-11-27 11:10:17 +01:00
* Copyright (c) 2002-2003, Yannick Verschueren
Copyright update
2007-01-15 10:55:40 +01:00
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
* Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
Initial revision
2003-11-27 11:10:17 +01:00
* 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.
*/
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
#include "opj_includes.h"
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
#include "t1_luts.h"
Initial revision
2003-11-27 11:10:17 +01:00
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/** @defgroup T1 T1 - Implementation of the tier-1 coding */
/*@{*/
/** @name Local static functions */
/*@{*/
Moved the orient flipping into the ctxno_zc table. Thanks to Callum Lerwick who provided all these great patches !
2007-08-21 14:51:57 +02:00
static INLINE char t1_getctxno_zc(int f, int orient);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
static char t1_getctxno_sc(int f);
Replaced the large ctxno_mag lookup table with a small bit of inline-able branchless code
2007-08-21 14:42:55 +02:00
static INLINE int t1_getctxno_mag(int f);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
static char t1_getspb(int f);
static short t1_getnmsedec_sig(int x, int bitpos);
static short t1_getnmsedec_ref(int x, int bitpos);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
static void t1_updateflags(flag_t *flagsp, int s, int stride);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Encode significant pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_sigpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int orient,
int bpno,
int one,
int *nmsedec,
char type,
int vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Decode significant pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_sigpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int orient,
int oneplushalf,
char type,
int vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Encode significant pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_sigpass(
opj_t1_t *t1,
int bpno,
int orient,
int *nmsedec,
char type,
int cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Decode significant pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_sigpass(
opj_t1_t *t1,
int bpno,
int orient,
char type,
int cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Encode refinement pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_refpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int bpno,
int one,
int *nmsedec,
char type,
int vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Decode refinement pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_refpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int poshalf,
int neghalf,
char type,
int vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Encode refinement pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_refpass(
opj_t1_t *t1,
int bpno,
int *nmsedec,
char type,
int cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Decode refinement pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_refpass(
opj_t1_t *t1,
int bpno,
char type,
int cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Encode clean-up pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_clnpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int orient,
int bpno,
int one,
int *nmsedec,
int partial,
int vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Decode clean-up pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_clnpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int orient,
int oneplushalf,
int partial,
int vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Encode clean-up pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_clnpass(
opj_t1_t *t1,
int bpno,
int orient,
int *nmsedec,
int cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Decode clean-up pass
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_clnpass(
opj_t1_t *t1,
int bpno,
int orient,
int cblksty);
static double t1_getwmsedec(
int nmsedec,
int compno,
int level,
int orient,
int bpno,
int qmfbid,
double stepsize,
int numcomps);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Encode 1 code-block
@param t1 T1 handle
@param cblk Code-block coding parameters
@param orient
@param compno Component number
@param level
@param qmfbid
@param stepsize
@param cblksty Code-block style
@param numcomps
@param tile
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_encode_cblk(
opj_t1_t *t1,
opj_tcd_cblk_t * cblk,
int orient,
int compno,
int level,
int qmfbid,
double stepsize,
int cblksty,
int numcomps,
opj_tcd_tile_t * tile);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/**
Decode 1 code-block
@param t1 T1 handle
@param cblk Code-block coding parameters
@param orient
@param roishift Region of interest shifting value
@param cblksty Code-block style
*/
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_decode_cblk(
opj_t1_t *t1,
opj_tcd_cblk_t * cblk,
int orient,
int roishift,
int cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/*@}*/
/*@}*/
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
/* ----------------------------------------------------------------------- */
Initial revision
2003-11-27 11:10:17 +01:00
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
static char t1_getctxno_zc(int f, int orient) {
return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
static char t1_getctxno_sc(int f) {
return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
Initial revision
2003-11-27 11:10:17 +01:00
}
Replaced the large ctxno_mag lookup table with a small bit of inline-able branchless code
2007-08-21 14:42:55 +02:00
static int t1_getctxno_mag(int f) {
int tmp1 = (f & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
int tmp2 = (f & T1_REFINE) ? T1_CTXNO_MAG + 2 : tmp1;
return (tmp2);
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
static char t1_getspb(int f) {
return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
static short t1_getnmsedec_sig(int x, int bitpos) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (bitpos > T1_NMSEDEC_FRACBITS) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
static short t1_getnmsedec_ref(int x, int bitpos) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (bitpos > T1_NMSEDEC_FRACBITS) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
static void t1_updateflags(flag_t *flagsp, int s, int stride) {
flag_t *np = flagsp - stride;
flag_t *sp = flagsp + stride;
static const flag_t mod[] = {
Reworks of t1_updateflags to get rid of the shift operation. mqc_setcurctx moved to the header to allow it to be inlined into the t1.
2007-08-21 14:30:08 +02:00
T1_SIG_S, T1_SIG_S|T1_SGN_S,
T1_SIG_E, T1_SIG_E|T1_SGN_E,
T1_SIG_W, T1_SIG_W|T1_SGN_W,
T1_SIG_N, T1_SIG_N|T1_SGN_N
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
};
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
np[-1] |= T1_SIG_SE;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
np[0] |= mod[s];
np[1] |= T1_SIG_SW;
flagsp[-1] |= mod[s+2];
Reworks of t1_updateflags to get rid of the shift operation. mqc_setcurctx moved to the header to allow it to be inlined into the t1.
2007-08-21 14:30:08 +02:00
flagsp[0] |= T1_SIG;
flagsp[1] |= mod[s+4];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
sp[-1] |= T1_SIG_NE;
Reworks of t1_updateflags to get rid of the shift operation. mqc_setcurctx moved to the header to allow it to be inlined into the t1.
2007-08-21 14:30:08 +02:00
sp[0] |= mod[s+6];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
sp[1] |= T1_SIG_NW;
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_sigpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int orient,
int bpno,
int one,
int *nmsedec,
char type,
int vsc)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int v, flag;
opj_mqc_t *mqc = t1->mqc; /* MQC component */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
v = int_abs(*datap) & one ? 1 : 0;
Consolidated some calls to mqc_setcurctx. Cleaned up t1_generate_luts to output the proper types.
2007-08-21 14:36:05 +02:00
mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient)); /* ESSAI */
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */
mqc_bypass_enc(mqc, v);
} else {
mqc_encode(mqc, v);
}
if (v) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
v = *datap < 0 ? 1 : 0;
*nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
Consolidated some calls to mqc_setcurctx. Cleaned up t1_generate_luts to output the proper types.
2007-08-21 14:36:05 +02:00
mqc_setcurctx(mqc, t1_getctxno_sc(flag)); /* ESSAI */
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */
mqc_bypass_enc(mqc, v);
} else {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
mqc_encode(mqc, v ^ t1_getspb(flag));
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1_updateflags(flagsp, v, t1->flags_stride);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
*flagsp |= T1_VISIT;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_sigpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int orient,
int oneplushalf,
char type,
int vsc)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int v, flag;
opj_raw_t *raw = t1->raw; /* RAW component */
opj_mqc_t *mqc = t1->mqc; /* MQC component */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
if (type == T1_TYPE_RAW) {
if (raw_decode(raw)) {
v = raw_decode(raw); /* ESSAI */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
*datap = v ? -oneplushalf : oneplushalf;
t1_updateflags(flagsp, v, t1->flags_stride);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
} else {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (mqc_decode(mqc)) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
mqc_setcurctx(mqc, t1_getctxno_sc(flag));
v = mqc_decode(mqc) ^ t1_getspb(flag);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
*datap = v ? -oneplushalf : oneplushalf;
t1_updateflags(flagsp, v, t1->flags_stride);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
*flagsp |= T1_VISIT;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
} /* VSC and BYPASS by Antonin */
Initial revision
2003-11-27 11:10:17 +01:00
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_sigpass(
opj_t1_t *t1,
int bpno,
int orient,
int *nmsedec,
char type,
int cblksty)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int i, j, k, one, vsc;
*nmsedec = 0;
one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (k = 0; k < t1->h; k += 4) {
for (i = 0; i < t1->w; ++i) {
for (j = k; j < k + 4 && j < t1->h; ++j) {
vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
t1_enc_sigpass_step(
t1,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
&t1->flags[((j+1) * t1->flags_stride) + i + 1],
&t1->data[(j * t1->w) + i],
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
orient,
bpno,
one,
nmsedec,
type,
vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_sigpass(
opj_t1_t *t1,
int bpno,
int orient,
char type,
int cblksty)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int i, j, k, one, half, oneplushalf, vsc;
one = 1 << bpno;
half = one >> 1;
oneplushalf = one | half;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (k = 0; k < t1->h; k += 4) {
for (i = 0; i < t1->w; ++i) {
for (j = k; j < k + 4 && j < t1->h; ++j) {
vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
t1_dec_sigpass_step(
t1,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
&t1->flags[((j+1) * t1->flags_stride) + i + 1],
&t1->data[(j * t1->w) + i],
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
orient,
oneplushalf,
type,
vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
} /* VSC and BYPASS by Antonin */
Initial revision
2003-11-27 11:10:17 +01:00
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_refpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int bpno,
int one,
int *nmsedec,
char type,
int vsc)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int v, flag;
opj_mqc_t *mqc = t1->mqc; /* MQC component */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
*nmsedec += t1_getnmsedec_ref(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
v = int_abs(*datap) & one ? 1 : 0;
Consolidated some calls to mqc_setcurctx. Cleaned up t1_generate_luts to output the proper types.
2007-08-21 14:36:05 +02:00
mqc_setcurctx(mqc, t1_getctxno_mag(flag)); /* ESSAI */
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */
mqc_bypass_enc(mqc, v);
} else {
mqc_encode(mqc, v);
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
*flagsp |= T1_REFINE;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_refpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int poshalf,
int neghalf,
char type,
int vsc)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int v, t, flag;
opj_mqc_t *mqc = t1->mqc; /* MQC component */
opj_raw_t *raw = t1->raw; /* RAW component */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
Consolidated some calls to mqc_setcurctx. Cleaned up t1_generate_luts to output the proper types.
2007-08-21 14:36:05 +02:00
mqc_setcurctx(mqc, t1_getctxno_mag(flag)); /* ESSAI */
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (type == T1_TYPE_RAW) {
v = raw_decode(raw);
} else {
v = mqc_decode(mqc);
}
t = v ? poshalf : neghalf;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
*datap += *datap < 0 ? -t : t;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
*flagsp |= T1_REFINE;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
} /* VSC and BYPASS by Antonin */
Initial revision
2003-11-27 11:10:17 +01:00
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_refpass(
opj_t1_t *t1,
int bpno,
int *nmsedec,
char type,
int cblksty)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int i, j, k, one, vsc;
*nmsedec = 0;
one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (k = 0; k < t1->h; k += 4) {
for (i = 0; i < t1->w; ++i) {
for (j = k; j < k + 4 && j < t1->h; ++j) {
vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
t1_enc_refpass_step(
t1,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
&t1->flags[((j+1) * t1->flags_stride) + i + 1],
&t1->data[(j * t1->w) + i],
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
bpno,
one,
nmsedec,
type,
vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_refpass(
opj_t1_t *t1,
int bpno,
char type,
int cblksty)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int i, j, k, one, poshalf, neghalf;
int vsc;
one = 1 << bpno;
poshalf = one >> 1;
neghalf = bpno > 0 ? -poshalf : -1;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (k = 0; k < t1->h; k += 4) {
for (i = 0; i < t1->w; ++i) {
for (j = k; j < k + 4 && j < t1->h; ++j) {
vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
t1_dec_refpass_step(
t1,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
&t1->flags[((j+1) * t1->flags_stride) + i + 1],
&t1->data[(j * t1->w) + i],
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
poshalf,
neghalf,
type,
vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
} /* VSC and BYPASS by Antonin */
Initial revision
2003-11-27 11:10:17 +01:00
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_clnpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int orient,
int bpno,
int one,
int *nmsedec,
int partial,
int vsc)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int v, flag;
opj_mqc_t *mqc = t1->mqc; /* MQC component */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (partial) {
goto LABEL_PARTIAL;
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
if (!(*flagsp & (T1_SIG | T1_VISIT))) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
v = int_abs(*datap) & one ? 1 : 0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
mqc_encode(mqc, v);
if (v) {
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
LABEL_PARTIAL:
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
*nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
mqc_setcurctx(mqc, t1_getctxno_sc(flag));
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
v = *datap < 0 ? 1 : 0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
mqc_encode(mqc, v ^ t1_getspb(flag));
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1_updateflags(flagsp, v, t1->flags_stride);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
*flagsp &= ~T1_VISIT;
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_clnpass_step(
opj_t1_t *t1,
flag_t *flagsp,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int *datap,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
int orient,
int oneplushalf,
int partial,
int vsc)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int v, flag;
opj_mqc_t *mqc = t1->mqc; /* MQC component */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (partial) {
goto LABEL_PARTIAL;
}
if (!(flag & (T1_SIG | T1_VISIT))) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (mqc_decode(mqc)) {
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
LABEL_PARTIAL:
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
2007-05-21 11:44:10 +02:00
mqc_setcurctx(mqc, t1_getctxno_sc(flag));
v = mqc_decode(mqc) ^ t1_getspb(flag);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
*datap = v ? -oneplushalf : oneplushalf;
t1_updateflags(flagsp, v, t1->flags_stride);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
2007-05-21 14:50:03 +02:00
*flagsp &= ~T1_VISIT;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
} /* VSC and BYPASS by Antonin */
Initial revision
2003-11-27 11:10:17 +01:00
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_enc_clnpass(
opj_t1_t *t1,
int bpno,
int orient,
int *nmsedec,
int cblksty)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int i, j, k, one, agg, runlen, vsc;
opj_mqc_t *mqc = t1->mqc; /* MQC component */
*nmsedec = 0;
one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (k = 0; k < t1->h; k += 4) {
for (i = 0; i < t1->w; ++i) {
if (k + 3 < t1->h) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (cblksty & J2K_CCP_CBLKSTY_VSC) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| (MACRO_t1_flags(1 + k + 3,1 + i)
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
& (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
} else {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
} else {
agg = 0;
}
if (agg) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (runlen = 0; runlen < 4; ++runlen) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
if (int_abs(t1->data[((k + runlen)*t1->w) + i]) & one)
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
break;
}
mqc_setcurctx(mqc, T1_CTXNO_AGG);
mqc_encode(mqc, runlen != 4);
if (runlen == 4) {
continue;
}
mqc_setcurctx(mqc, T1_CTXNO_UNI);
mqc_encode(mqc, runlen >> 1);
mqc_encode(mqc, runlen & 1);
} else {
runlen = 0;
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
t1_enc_clnpass_step(
t1,
&t1->flags[((j+1) * t1->flags_stride) + i + 1],
&t1->data[(j * t1->w) + i],
orient,
bpno,
one,
nmsedec,
agg && (j == k + runlen),
vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_dec_clnpass(
opj_t1_t *t1,
int bpno,
int orient,
int cblksty)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int i, j, k, one, half, oneplushalf, agg, runlen, vsc;
int segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;
opj_mqc_t *mqc = t1->mqc; /* MQC component */
one = 1 << bpno;
half = one >> 1;
oneplushalf = one | half;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (k = 0; k < t1->h; k += 4) {
for (i = 0; i < t1->w; ++i) {
if (k + 3 < t1->h) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (cblksty & J2K_CCP_CBLKSTY_VSC) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| (MACRO_t1_flags(1 + k + 3,1 + i)
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
& (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
} else {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
|| MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
} else {
agg = 0;
}
if (agg) {
mqc_setcurctx(mqc, T1_CTXNO_AGG);
if (!mqc_decode(mqc)) {
continue;
}
mqc_setcurctx(mqc, T1_CTXNO_UNI);
runlen = mqc_decode(mqc);
runlen = (runlen << 1) | mqc_decode(mqc);
} else {
runlen = 0;
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
t1_dec_clnpass_step(
t1,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
&t1->flags[((j+1) * t1->flags_stride) + i + 1],
&t1->data[(j * t1->w) + i],
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
orient,
oneplushalf,
agg && (j == k + runlen),
vsc);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
if (segsym) {
int v = 0;
mqc_setcurctx(mqc, T1_CTXNO_UNI);
v = mqc_decode(mqc);
v = (v << 1) | mqc_decode(mqc);
v = (v << 1) | mqc_decode(mqc);
v = (v << 1) | mqc_decode(mqc);
/*
if (v!=0xa) {
opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
}
*/
}
} /* VSC and BYPASS by Antonin */
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
Initial revision
2003-11-27 11:10:17 +01:00
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
/** mod fixed_quality */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static double t1_getwmsedec(
int nmsedec,
int compno,
int level,
int orient,
int bpno,
int qmfbid,
double stepsize,
int numcomps)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
double w1, w2, wmsedec;
if (qmfbid == 1) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
w1 = (numcomps > 1) ? mct_getnorm(compno) : 1.0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
w2 = dwt_getnorm(level, orient);
} else { /* if (qmfbid == 0) */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
w1 = (numcomps > 1) ? mct_getnorm_real(compno) : 1.0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
w2 = dwt_getnorm_real(level, orient);
}
fixed a bug in t1_getwmsedec (stepsize was divided by 8192)
2005-12-08 12:01:59 +01:00
wmsedec = w1 * w2 * stepsize * (1 << bpno);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
wmsedec *= wmsedec * nmsedec / 8192.0;
return wmsedec;
Initial revision
2003-11-27 11:10:17 +01:00
}
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
static bool allocate_buffers(
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
opj_t1_t *t1,
int w,
int h)
{
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
int datasize=w * h;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int flagssize;
if(datasize > t1->datasize){
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
opj_aligned_free(t1->data);
Patch from Callum Lewick. Memset patch. See ChangeLog for more details. Thanks Callum !
2007-10-18 14:26:11 +02:00
t1->data = (int*) opj_aligned_malloc(datasize * sizeof(int));
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
if(!t1->data){
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
return false;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
}
t1->datasize=datasize;
}
memset(t1->data,0,datasize * sizeof(int));
t1->flags_stride=w+2;
Reworks of t1_updateflags to get rid of the shift operation. mqc_setcurctx moved to the header to allow it to be inlined into the t1.
2007-08-21 14:30:08 +02:00
flagssize=t1->flags_stride * (h+2);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
if(flagssize > t1->flagssize){
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
opj_aligned_free(t1->flags);
Patch from Callum Lewick. Memset patch. See ChangeLog for more details. Thanks Callum !
2007-10-18 14:26:11 +02:00
t1->flags = (flag_t*) opj_aligned_malloc(flagssize * sizeof(flag_t));
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
if(!t1->flags){
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
return false;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
}
t1->flagssize=flagssize;
}
memset(t1->flags,0,flagssize * sizeof(flag_t));
t1->w=w;
t1->h=h;
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
return true;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
}
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
/** mod fixed_quality */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_encode_cblk(
opj_t1_t *t1,
opj_tcd_cblk_t * cblk,
int orient,
int compno,
int level,
int qmfbid,
double stepsize,
int cblksty,
int numcomps,
opj_tcd_tile_t * tile)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int i, j;
int passno;
int bpno, passtype;
int max;
fixed two initialization problems in t1.c and tcd.c
2006-01-27 17:29:41 +01:00
int nmsedec = 0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
double cumwmsedec = 0.0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
char type = T1_TYPE_MQ;
opj_mqc_t *mqc = t1->mqc; /* MQC component */
max = 0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (j = 0; j < t1->h; ++j) {
for (i = 0; i < t1->w; ++i) {
max = int_max(max, int_abs(t1->data[(j * t1->w) + i]));
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;
bpno = cblk->numbps - 1;
passtype = 2;
mqc_resetstates(mqc);
mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
mqc_init_enc(mqc, cblk->data);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (passno = 0; bpno >= 0; ++passno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_pass_t *pass = &cblk->passes[passno];
int correction = 3;
type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
switch (passtype) {
case 0:
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
break;
case 1:
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
break;
case 2:
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
/* code switch SEGMARK (i.e. SEGSYM) */
if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)
mqc_segmark_enc(mqc);
break;
}
/* fixed_quality */
cumwmsedec += t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps);
tile->distotile += t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps);
/* Code switch "RESTART" (i.e. TERMALL) */
if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {
if (type == T1_TYPE_RAW) {
mqc_flush(mqc);
correction = 1;
/* correction = mqc_bypass_flush_enc(); */
} else { /* correction = mqc_restart_enc(); */
mqc_flush(mqc);
correction = 1;
}
pass->term = 1;
} else {
if (((bpno < (cblk->numbps - 4) && (passtype > 0))
|| ((bpno == (cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
if (type == T1_TYPE_RAW) {
mqc_flush(mqc);
correction = 1;
/* correction = mqc_bypass_flush_enc(); */
} else { /* correction = mqc_restart_enc(); */
mqc_flush(mqc);
correction = 1;
}
pass->term = 1;
} else {
pass->term = 0;
}
}
if (++passtype == 3) {
passtype = 0;
bpno--;
}
if (pass->term && bpno > 0) {
type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
if (type == T1_TYPE_RAW)
mqc_bypass_init_enc(mqc);
else
mqc_restart_init_enc(mqc);
}
pass->distortiondec = cumwmsedec;
pass->rate = mqc_numbytes(mqc) + correction; /* FIXME */
/* Code-switch "RESET" */
if (cblksty & J2K_CCP_CBLKSTY_RESET)
mqc_reset_enc(mqc);
}
/* Code switch "ERTERM" (i.e. PTERM) */
if (cblksty & J2K_CCP_CBLKSTY_PTERM)
mqc_erterm_enc(mqc);
else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))
mqc_flush(mqc);
cblk->totalpasses = passno;
Fixed an historical bug in t1.c that leaded to the inclusion of useless 0xFF in the codestream. Thanks to Sylvain, Pascal and Parvatha !
2007-03-28 10:44:21 +02:00
for (passno = 0; passno<cblk->totalpasses; passno++) {
opj_tcd_pass_t *pass = &cblk->passes[passno];
if (pass->rate > mqc_numbytes(mqc))
pass->rate = mqc_numbytes(mqc);
/*Preventing generation of FF as last data byte of a pass*/
if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){
pass->rate--;
}
pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
}
Initial revision
2003-11-27 11:10:17 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
static void t1_decode_cblk(
opj_t1_t *t1,
opj_tcd_cblk_t * cblk,
int orient,
int roishift,
int cblksty)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int bpno, passtype;
int segno, passno;
char type = T1_TYPE_MQ; /* BYPASS mode */
opj_raw_t *raw = t1->raw; /* RAW component */
opj_mqc_t *mqc = t1->mqc; /* MQC component */
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
if(!allocate_buffers(
t1,
cblk->x1 - cblk->x0,
cblk->y1 - cblk->y0))
{
return;
}
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
bpno = roishift + cblk->numbps - 1;
passtype = 2;
mqc_resetstates(mqc);
mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (segno = 0; segno < cblk->numsegs; ++segno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_seg_t *seg = &cblk->segs[segno];
/* BYPASS mode */
type = ((bpno <= (cblk->numbps - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
if (type == T1_TYPE_RAW) {
raw_init_dec(raw, seg->data, seg->len);
} else {
mqc_init_dec(mqc, seg->data, seg->len);
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (passno = 0; passno < seg->numpasses; ++passno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
switch (passtype) {
case 0:
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1_dec_sigpass(t1, bpno+1, orient, type, cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
break;
case 1:
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1_dec_refpass(t1, bpno+1, type, cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
break;
case 2:
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1_dec_clnpass(t1, bpno+1, orient, cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
break;
}
if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
mqc_resetstates(mqc);
mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
}
if (++passtype == 3) {
passtype = 0;
bpno--;
}
}
}
Initial revision
2003-11-27 11:10:17 +01:00
}
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
/* ----------------------------------------------------------------------- */
opj_t1_t* t1_create(opj_common_ptr cinfo) {
Indexes can now be generated when decoding J2K codestreams.
2007-09-07 17:01:55 +02:00
opj_t1_t *t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
if(!t1)
return NULL;
Patch from Callum Lewick. Memset patch. See ChangeLog for more details. Thanks Callum !
2007-10-18 14:26:11 +02:00
t1->cinfo = cinfo;
/* create MQC and RAW handles */
t1->mqc = mqc_create();
t1->raw = raw_create();
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1->data=NULL;
t1->flags=NULL;
Patch from Callum Lewick. Memset patch. See ChangeLog for more details. Thanks Callum !
2007-10-18 14:26:11 +02:00
t1->datasize=0;
t1->flagssize=0;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
return t1;
Initial revision
2003-11-27 11:10:17 +01:00
}
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
void t1_destroy(opj_t1_t *t1) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if(t1) {
/* destroy MQC and RAW handles */
mqc_destroy(t1->mqc);
raw_destroy(t1->raw);
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
opj_aligned_free(t1->data);
opj_aligned_free(t1->flags);
Patch from Callum Lewick. Memset patch. See ChangeLog for more details. Thanks Callum !
2007-10-18 14:26:11 +02:00
opj_free(t1);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
void t1_encode_cblks(
opj_t1_t *t1,
opj_tcd_tile_t *tile,
opj_tcp_t *tcp)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int compno, resno, bandno, precno, cblkno;
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
tile->distotile = 0; /* fixed_quality */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (compno = 0; compno < tile->numcomps; ++compno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (resno = 0; resno < tilec->numresolutions; ++resno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_resolution_t *res = &tilec->resolutions[resno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (bandno = 0; bandno < res->numbands; ++bandno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_band_t *band = &res->bands[bandno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (precno = 0; precno < res->pw * res->ph; ++precno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_precinct_t *prc = &band->precincts[precno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
Moved the orient flipping into the ctxno_zc table. Thanks to Callum Lerwick who provided all these great patches !
2007-08-21 14:51:57 +02:00
int x, y, w, i, j;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
x = cblk->x0 - band->x0;
y = cblk->y0 - band->y0;
if (band->bandno & 1) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
x += pres->x1 - pres->x0;
}
if (band->bandno & 2) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
y += pres->y1 - pres->y0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
Aligned malloc using Intel's _mm_malloc(), cleanup on the t1 memory allocation, getting rid of some leftover debug code
2007-08-21 14:13:54 +02:00
if(!allocate_buffers(
t1,
cblk->x1 - cblk->x0,
cblk->y1 - cblk->y0))
{
return;
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
w = tilec->x1 - tilec->x0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (tcp->tccps[compno].qmfbid == 1) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (j = 0; j < t1->h; ++j) {
for (i = 0; i < t1->w; ++i) {
t1->data[(j * t1->w) + i] =
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
tilec->data[(x + i) + (y + j) * w] << T1_NMSEDEC_FRACBITS;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
} else { /* if (tcp->tccps[compno].qmfbid == 0) */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
for (j = 0; j < t1->h; ++j) {
for (i = 0; i < t1->w; ++i) {
t1->data[(j * t1->w) + i] =
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
fix_mul(
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
tilec->data[x + i + (y + j) * w],
Bugs corrected in decoding of command line (getopt.c), in the handling of 16 bit files (t1.c and tcd.c) and the calculation of elapsed time for multiple tiles parts (tcd.c and tdc.h).
2007-06-04 15:23:26 +02:00
8192 * 8192 / ((int) floor(band->stepsize * 8192))) >> (11 - T1_NMSEDEC_FRACBITS);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
t1_encode_cblk(
t1,
cblk,
Moved the orient flipping into the ctxno_zc table. Thanks to Callum Lerwick who provided all these great patches !
2007-08-21 14:51:57 +02:00
band->bandno,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
compno,
tilec->numresolutions - 1 - resno,
tcp->tccps[compno].qmfbid,
band->stepsize,
tcp->tccps[compno].cblksty,
tile->numcomps,
tile);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
} /* cblkno */
} /* precno */
} /* bandno */
} /* resno */
} /* compno */
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
void t1_decode_cblks(
opj_t1_t *t1,
opj_tcd_tile_t *tile,
opj_tcp_t *tcp)
{
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
int compno, resno, bandno, precno, cblkno;
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (compno = 0; compno < tile->numcomps; ++compno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (resno = 0; resno < tilec->numresolutions; ++resno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_resolution_t *res = &tilec->resolutions[resno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (bandno = 0; bandno < res->numbands; ++bandno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_band_t *band = &res->bands[bandno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (precno = 0; precno < res->pw * res->ph; ++precno) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_precinct_t *prc = &band->precincts[precno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
Use <xmmintrin.h> for WIN32, else use <mm_malloc.h>
2007-08-21 14:57:39 +02:00
int x, y, w, i, j, cblk_w, cblk_h;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
t1_decode_cblk(
t1,
cblk,
Moved the orient flipping into the ctxno_zc table. Thanks to Callum Lerwick who provided all these great patches !
2007-08-21 14:51:57 +02:00
band->bandno,
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
tcp->tccps[compno].roishift,
tcp->tccps[compno].cblksty);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
x = cblk->x0 - band->x0;
y = cblk->y0 - band->y0;
if (band->bandno & 1) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
x += pres->x1 - pres->x0;
}
if (band->bandno & 2) {
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
y += pres->y1 - pres->y0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
cblk_w = cblk->x1 - cblk->x0;
cblk_h = cblk->y1 - cblk->y0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (tcp->tccps[compno].roishift) {
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
int thresh = 1 << tcp->tccps[compno].roishift;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (j = 0; j < cblk_h; ++j) {
for (i = 0; i < cblk_w; ++i) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
int val = t1->data[(j * t1->w) + i];
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
int mag = int_abs(val);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (mag >= thresh) {
mag >>= tcp->tccps[compno].roishift;
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
t1->data[(j * t1->w) + i] = val < 0 ? -mag : mag;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
}
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
w = tilec->x1 - tilec->x0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
if (tcp->tccps[compno].qmfbid == 1) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (j = 0; j < cblk_h; ++j) {
for (i = 0; i < cblk_w; ++i) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
tilec->data[x + i + (y + j) * w] = t1->data[(j * t1->w) + i]/2;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
} else { /* if (tcp->tccps[compno].qmfbid == 0) */
Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups, so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
2007-05-21 15:08:10 +02:00
for (j = 0; j < cblk_h; ++j) {
for (i = 0; i < cblk_w; ++i) {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
if (t1->data[(j * t1->w) + i] >> 1 == 0) {
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
tilec->data[x + i + (y + j) * w] = 0;
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
} else {
Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
2007-05-22 15:14:13 +02:00
double tmp = (double)(t1->data[(j * t1->w) + i] * band->stepsize * 4096.0);
int tmp2 = ((int) (floor(fabs(tmp)))) + ((int) floor(fabs(tmp*2))%2);
Algorithmic optimizations in t1.c, thanks to Guido J. !
2007-02-21 08:57:27 +01:00
tilec->data[x + i + (y + j) * w] = ((tmp<0)?-tmp2:tmp2);
OpenJPEG version 1.1
2005-12-08 10:38:47 +01:00
}
}
}
}
} /* cblkno */
} /* precno */
} /* bandno */
} /* resno */
} /* compno */
openjpeg version 1.0 (previous version still available with tag opj0-97)
2005-12-02 14:34:15 +01:00
}