/*
* Copyright (c) 1999-2000 Image Power, Inc. and the University of
* British Columbia.
* Copyright (c) 2001-2002 Michael David Adams.
* All rights reserved.
*/
/* __START_OF_JASPER_LICENSE__
*
* JasPer Software License
*
* IMAGE POWER JPEG-2000 PUBLIC LICENSE
* ************************************
*
* GRANT:
*
* Permission is hereby granted, free of charge, to any person (the "User")
* obtaining a copy of this software and associated documentation, to deal
* in the JasPer Software without restriction, including without limitation
* the right to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the JasPer Software (in source and binary forms),
* and to permit persons to whom the JasPer Software is furnished to do so,
* provided further that the License Conditions below are met.
*
* License Conditions
* ******************
*
* A. Redistributions of source code must retain the above copyright notice,
* and this list of conditions, and the following disclaimer.
*
* B. Redistributions in binary form must reproduce the above copyright
* notice, and this list of conditions, and the following disclaimer in
* the documentation and/or other materials provided with the distribution.
*
* C. Neither the name of Image Power, Inc. nor any other contributor
* (including, but not limited to, the University of British Columbia and
* Michael David Adams) may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* D. User agrees that it shall not commence any action against Image Power,
* Inc., the University of British Columbia, Michael David Adams, or any
* other contributors (collectively "Licensors") for infringement of any
* intellectual property rights ("IPR") held by the User in respect of any
* technology that User owns or has a right to license or sublicense and
* which is an element required in order to claim compliance with ISO/IEC
* 15444-1 (i.e., JPEG-2000 Part 1). "IPR" means all intellectual property
* rights worldwide arising under statutory or common law, and whether
* or not perfected, including, without limitation, all (i) patents and
* patent applications owned or licensable by User; (ii) rights associated
* with works of authorship including copyrights, copyright applications,
* copyright registrations, mask work rights, mask work applications,
* mask work registrations; (iii) rights relating to the protection of
* trade secrets and confidential information; (iv) any right analogous
* to those set forth in subsections (i), (ii), or (iii) and any other
* proprietary rights relating to intangible property (other than trademark,
* trade dress, or service mark rights); and (v) divisions, continuations,
* renewals, reissues and extensions of the foregoing (as and to the extent
* applicable) now existing, hereafter filed, issued or acquired.
*
* E. If User commences an infringement action against any Licensor(s) then
* such Licensor(s) shall have the right to terminate User's license and
* all sublicenses that have been granted hereunder by User to other parties.
*
* F. This software is for use only in hardware or software products that
* are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license
* or right to this Software is granted for products that do not comply
* with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased
* from the ISO.
*
* THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE.
* NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
* THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND
* CONTRIBUTORS UNDER THIS LICENSE ON AN ``AS-IS'' BASIS, WITHOUT WARRANTY
* OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION,
* WARRANTIES THAT THE JASPER SOFTWARE IS FREE OF DEFECTS, IS MERCHANTABLE,
* IS FIT FOR A PARTICULAR PURPOSE OR IS NON-INFRINGING. THOSE INTENDING
* TO USE THE JASPER SOFTWARE OR MODIFICATIONS THEREOF FOR USE IN HARDWARE
* OR SOFTWARE PRODUCTS ARE ADVISED THAT THEIR USE MAY INFRINGE EXISTING
* PATENTS, COPYRIGHTS, TRADEMARKS, OR OTHER INTELLECTUAL PROPERTY RIGHTS.
* THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE JASPER SOFTWARE
* IS WITH THE USER. SHOULD ANY PART OF THE JASPER SOFTWARE PROVE DEFECTIVE
* IN ANY RESPECT, THE USER (AND NOT THE INITIAL DEVELOPERS, THE UNIVERSITY
* OF BRITISH COLUMBIA, IMAGE POWER, INC., MICHAEL DAVID ADAMS, OR ANY
* OTHER CONTRIBUTOR) SHALL ASSUME THE COST OF ANY NECESSARY SERVICING,
* REPAIR OR CORRECTION. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY,
* WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE
* INITIAL DEVELOPER, THE UNIVERSITY OF BRITISH COLUMBIA, IMAGE POWER, INC.,
* MICHAEL DAVID ADAMS, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF THE
* JASPER SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO
* THE USER OR ANY OTHER PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR
* CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION,
* DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR
* MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF
* SUCH PARTY HAD BEEN INFORMED, OR OUGHT TO HAVE KNOWN, OF THE POSSIBILITY
* OF SUCH DAMAGES. THE JASPER SOFTWARE AND UNDERLYING TECHNOLOGY ARE NOT
* FAULT-TOLERANT AND ARE NOT DESIGNED, MANUFACTURED OR INTENDED FOR USE OR
* RESALE AS ON-LINE CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING
* FAIL-SAFE PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES,
* AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT
* LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
* JASPER SOFTWARE OR UNDERLYING TECHNOLOGY OR PRODUCT COULD LEAD DIRECTLY
* TO DEATH, PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE
* ("HIGH RISK ACTIVITIES"). LICENSOR SPECIFICALLY DISCLAIMS ANY EXPRESS
* OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES. USER WILL NOT
* KNOWINGLY USE, DISTRIBUTE OR RESELL THE JASPER SOFTWARE OR UNDERLYING
* TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS
* CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE
* NOTICE SPECIFIED IN THIS SECTION.
*
* __END_OF_JASPER_LICENSE__
*/
/*
* Quadrature Mirror-Image Filter Bank (QMFB) Library
*
* $Id$
*/
/******************************************************************************\
* Includes.
\******************************************************************************/
#include <assert.h>
#include "jasper/jas_fix.h"
#include "jasper/jas_malloc.h"
#include "jasper/jas_math.h"
#include "jpc_qmfb.h"
#include "jpc_tsfb.h"
#include "jpc_math.h"
/******************************************************************************\
*
\******************************************************************************/
static jpc_qmfb1d_t *jpc_qmfb1d_create(void);
static int jpc_ft_getnumchans(jpc_qmfb1d_t *qmfb);
static int jpc_ft_getanalfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters);
static int jpc_ft_getsynfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters);
static void jpc_ft_analyze(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x);
static void jpc_ft_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x);
static int jpc_ns_getnumchans(jpc_qmfb1d_t *qmfb);
static int jpc_ns_getanalfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters);
static int jpc_ns_getsynfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters);
static void jpc_ns_analyze(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x);
static void jpc_ns_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x);
/******************************************************************************\
*
\******************************************************************************/
jpc_qmfb1dops_t jpc_ft_ops = {
jpc_ft_getnumchans,
jpc_ft_getanalfilters,
jpc_ft_getsynfilters,
jpc_ft_analyze,
jpc_ft_synthesize
};
jpc_qmfb1dops_t jpc_ns_ops = {
jpc_ns_getnumchans,
jpc_ns_getanalfilters,
jpc_ns_getsynfilters,
jpc_ns_analyze,
jpc_ns_synthesize
};
/******************************************************************************\
*
\******************************************************************************/
static void jpc_qmfb1d_setup(jpc_fix_t *startptr, int startind, int endind,
int intrastep, jpc_fix_t **lstartptr, int *lstartind, int *lendind,
jpc_fix_t **hstartptr, int *hstartind, int *hendind)
{
*lstartind = JPC_CEILDIVPOW2(startind, 1);
*lendind = JPC_CEILDIVPOW2(endind, 1);
*hstartind = JPC_FLOORDIVPOW2(startind, 1);
*hendind = JPC_FLOORDIVPOW2(endind, 1);
*lstartptr = startptr;
*hstartptr = &startptr[(*lendind - *lstartind) * intrastep];
}
static void jpc_qmfb1d_split(jpc_fix_t *startptr, int startind, int endind,
register int step, jpc_fix_t *lstartptr, int lstartind, int lendind,
jpc_fix_t *hstartptr, int hstartind, int hendind)
{
#define QMFB_SPLITBUFSIZE 4096
jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE];
jpc_fix_t *buf = splitbuf;
int llen;
int hlen;
int twostep;
jpc_fix_t *tmpptr;
register jpc_fix_t *ptr;
register jpc_fix_t *hptr;
register jpc_fix_t *lptr;
register int n;
int state;
twostep = step << 1;
llen = lendind - lstartind;
hlen = hendind - hstartind;
if (hstartind < lstartind) {
/* The first sample in the input signal is to appear
in the highpass subband signal. */
/* Copy the appropriate samples into the lowpass subband
signal, saving any samples destined for the highpass subband
signal as they are overwritten. */
tmpptr = buf;
ptr = &startptr[step];
lptr = lstartptr;
n = llen;
state = 1;
while (n-- > 0) {
if (state) {
*tmpptr = *lptr;
++tmpptr;
}
*lptr = *ptr;
ptr += twostep;
lptr += step;
state ^= 1;
}
/* Copy the appropriate samples into the highpass subband
signal. */
/* Handle the nonoverwritten samples. */
hptr = &hstartptr[(hlen - 1) * step];
ptr = &startptr[(((llen + hlen - 1) >> 1) << 1) * step];
n = hlen - (tmpptr - buf);
while (n-- > 0) {
*hptr = *ptr;
hptr -= step;
ptr -= twostep;
}
/* Handle the overwritten samples. */
n = tmpptr - buf;
while (n-- > 0) {
--tmpptr;
*hptr = *tmpptr;
hptr -= step;
}
} else {
/* The first sample in the input signal is to appear
in the lowpass subband signal. */
/* Copy the appropriate samples into the lowpass subband
signal, saving any samples for the highpass subband
signal as they are overwritten. */
state = 0;
ptr = startptr;
lptr = lstartptr;
tmpptr = buf;
n = llen;
while (n-- > 0) {
if (state) {
*tmpptr = *lptr;
++tmpptr;
}
*lptr = *ptr;
ptr += twostep;
lptr += step;
state ^= 1;
}
/* Copy the appropriate samples into the highpass subband
signal. */
/* Handle the nonoverwritten samples. */
ptr = &startptr[((((llen + hlen) >> 1) << 1) - 1) * step];
hptr = &hstartptr[(hlen - 1) * step];
n = hlen - (tmpptr - buf);
while (n-- > 0) {
*hptr = *ptr;
ptr -= twostep;
hptr -= step;
}
/* Handle the overwritten samples. */
n = tmpptr - buf;
while (n-- > 0) {
--tmpptr;
*hptr = *tmpptr;
hptr -= step;
}
}
}
static void jpc_qmfb1d_join(jpc_fix_t *startptr, int startind, int endind,
register int step, jpc_fix_t *lstartptr, int lstartind, int lendind,
jpc_fix_t *hstartptr, int hstartind, int hendind)
{
#define QMFB_JOINBUFSIZE 4096
jpc_fix_t joinbuf[QMFB_JOINBUFSIZE];
jpc_fix_t *buf = joinbuf;
int llen;
int hlen;
int twostep;
jpc_fix_t *tmpptr;
register jpc_fix_t *ptr;
register jpc_fix_t *hptr;
register jpc_fix_t *lptr;
register int n;
int state;
twostep = step << 1;
llen = lendind - lstartind;
hlen = hendind - hstartind;
if (hstartind < lstartind) {
/* The first sample in the highpass subband signal is to
appear first in the output signal. */
/* Copy the appropriate samples into the first phase of the
output signal. */
tmpptr = buf;
hptr = hstartptr;
ptr = startptr;
n = (llen + 1) >> 1;
while (n-- > 0) {
*tmpptr = *ptr;
*ptr = *hptr;
++tmpptr;
ptr += twostep;
hptr += step;
}
n = hlen - ((llen + 1) >> 1);
while (n-- > 0) {
*ptr = *hptr;
ptr += twostep;
hptr += step;
}
/* Copy the appropriate samples into the second phase of
the output signal. */
ptr -= (lendind > hendind) ? (step) : (step + twostep);
state = !((llen - 1) & 1);
lptr = &lstartptr[(llen - 1) * step];
n = llen;
while (n-- > 0) {
if (state) {
--tmpptr;
*ptr = *tmpptr;
} else {
*ptr = *lptr;
}
lptr -= step;
ptr -= twostep;
state ^= 1;
}
} else {
/* The first sample in the lowpass subband signal is to
appear first in the output signal. */
/* Copy the appropriate samples into the first phase of the
output signal (corresponding to even indexed samples). */
lptr = &lstartptr[(llen - 1) * step];
ptr = &startptr[((llen - 1) << 1) * step];
n = llen >> 1;
tmpptr = buf;
while (n-- > 0) {
*tmpptr = *ptr;
*ptr = *lptr;
++tmpptr;
ptr -= twostep;
lptr -= step;
}
n = llen - (llen >> 1);
while (n-- > 0) {
*ptr = *lptr;
ptr -= twostep;
lptr -= step;
}
/* Copy the appropriate samples into the second phase of
the output signal (corresponding to odd indexed
samples). */
ptr = &startptr[step];
hptr = hstartptr;
state = !(llen & 1);
n = hlen;
while (n-- > 0) {
if (state) {
--tmpptr;
*ptr = *tmpptr;
} else {
*ptr = *hptr;
}
hptr += step;
ptr += twostep;
state ^= 1;
}
}
}
/******************************************************************************\
* Code for 5/3 transform.
\******************************************************************************/
static int jpc_ft_getnumchans(jpc_qmfb1d_t *qmfb)
{
return 2;
}
static int jpc_ft_getanalfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters)
{
abort();
return -1;
}
static int jpc_ft_getsynfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters)
{
jas_seq_t *lf;
jas_seq_t *hf;
lf = 0;
hf = 0;
if (len > 1 || (!len)) {
if (!(lf = jas_seq_create(-1, 2))) {
goto error;
}
jas_seq_set(lf, -1, jpc_dbltofix(0.5));
jas_seq_set(lf, 0, jpc_dbltofix(1.0));
jas_seq_set(lf, 1, jpc_dbltofix(0.5));
if (!(hf = jas_seq_create(-1, 4))) {
goto error;
}
jas_seq_set(hf, -1, jpc_dbltofix(-0.125));
jas_seq_set(hf, 0, jpc_dbltofix(-0.25));
jas_seq_set(hf, 1, jpc_dbltofix(0.75));
jas_seq_set(hf, 2, jpc_dbltofix(-0.25));
jas_seq_set(hf, 3, jpc_dbltofix(-0.125));
} else if (len == 1) {
if (!(lf = jas_seq_create(0, 1))) {
goto error;
}
jas_seq_set(lf, 0, jpc_dbltofix(1.0));
if (!(hf = jas_seq_create(0, 1))) {
goto error;
}
jas_seq_set(hf, 0, jpc_dbltofix(2.0));
} else {
abort();
}
filters[0] = lf;
filters[1] = hf;
return 0;
error:
if (lf) {
jas_seq_destroy(lf);
}
if (hf) {
jas_seq_destroy(hf);
}
return -1;
}
#define NFT_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pluseq) \
{ \
register jpc_fix_t *lptr = (lstartptr); \
register jpc_fix_t *hptr = (hstartptr); \
register int n = (hendind) - (hstartind); \
if ((hstartind) < (lstartind)) { \
pluseq(*hptr, *lptr); \
hptr += (step); \
--n; \
} \
if ((hendind) >= (lendind)) { \
--n; \
} \
while (n-- > 0) { \
pluseq(*hptr, jpc_fix_asr(jpc_fix_add(*lptr, lptr[(step)]), 1)); \
hptr += (step); \
lptr += (step); \
} \
if ((hendind) >= (lendind)) { \
pluseq(*hptr, *lptr); \
} \
}
#define NFT_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pluseq) \
{ \
register jpc_fix_t *lptr = (lstartptr); \
register jpc_fix_t *hptr = (hstartptr); \
register int n = (lendind) - (lstartind); \
if ((hstartind) >= (lstartind)) { \
pluseq(*lptr, *hptr); \
lptr += (step); \
--n; \
} \
if ((lendind) > (hendind)) { \
--n; \
} \
while (n-- > 0) { \
pluseq(*lptr, jpc_fix_asr(jpc_fix_add(*hptr, hptr[(step)]), 2)); \
lptr += (step); \
hptr += (step); \
} \
if ((lendind) > (hendind)) { \
pluseq(*lptr, *hptr); \
} \
}
#define RFT_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pmeqop) \
{ \
register jpc_fix_t *lptr = (lstartptr); \
register jpc_fix_t *hptr = (hstartptr); \
register int n = (hendind) - (hstartind); \
if ((hstartind) < (lstartind)) { \
*hptr pmeqop *lptr; \
hptr += (step); \
--n; \
} \
if ((hendind) >= (lendind)) { \
--n; \
} \
while (n-- > 0) { \
*hptr pmeqop (*lptr + lptr[(step)]) >> 1; \
hptr += (step); \
lptr += (step); \
} \
if ((hendind) >= (lendind)) { \
*hptr pmeqop *lptr; \
} \
}
#define RFT_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pmeqop) \
{ \
register jpc_fix_t *lptr = (lstartptr); \
register jpc_fix_t *hptr = (hstartptr); \
register int n = (lendind) - (lstartind); \
if ((hstartind) >= (lstartind)) { \
*lptr pmeqop ((*hptr << 1) + 2) >> 2; \
lptr += (step); \
--n; \
} \
if ((lendind) > (hendind)) { \
--n; \
} \
while (n-- > 0) { \
*lptr pmeqop ((*hptr + hptr[(step)]) + 2) >> 2; \
lptr += (step); \
hptr += (step); \
} \
if ((lendind) > (hendind)) { \
*lptr pmeqop ((*hptr << 1) + 2) >> 2; \
} \
}
static void jpc_ft_analyze(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x)
{
jpc_fix_t *startptr;
int startind;
int endind;
jpc_fix_t * lstartptr;
int lstartind;
int lendind;
jpc_fix_t * hstartptr;
int hstartind;
int hendind;
int interstep;
int intrastep;
int numseq;
if (flags & JPC_QMFB1D_VERT) {
interstep = 1;
intrastep = jas_seq2d_rowstep(x);
numseq = jas_seq2d_width(x);
startind = jas_seq2d_ystart(x);
endind = jas_seq2d_yend(x);
} else {
interstep = jas_seq2d_rowstep(x);
intrastep = 1;
numseq = jas_seq2d_height(x);
startind = jas_seq2d_xstart(x);
endind = jas_seq2d_xend(x);
}
assert(startind < endind);
startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x));
if (flags & JPC_QMFB1D_RITIMODE) {
while (numseq-- > 0) {
jpc_qmfb1d_setup(startptr, startind, endind, intrastep,
&lstartptr, &lstartind, &lendind, &hstartptr,
&hstartind, &hendind);
if (endind - startind > 1) {
jpc_qmfb1d_split(startptr, startind, endind,
intrastep, lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind);
RFT_LIFT0(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep, -=);
RFT_LIFT1(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep, +=);
} else {
if (lstartind == lendind) {
*startptr <<= 1;
}
}
startptr += interstep;
}
} else {
while (numseq-- > 0) {
jpc_qmfb1d_setup(startptr, startind, endind, intrastep,
&lstartptr, &lstartind, &lendind, &hstartptr,
&hstartind, &hendind);
if (endind - startind > 1) {
jpc_qmfb1d_split(startptr, startind, endind,
intrastep, lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind);
NFT_LIFT0(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_fix_minuseq);
NFT_LIFT1(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_fix_pluseq);
} else {
if (lstartind == lendind) {
*startptr = jpc_fix_asl(*startptr, 1);
}
}
startptr += interstep;
}
}
}
static void jpc_ft_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x)
{
jpc_fix_t *startptr;
int startind;
int endind;
jpc_fix_t *lstartptr;
int lstartind;
int lendind;
jpc_fix_t *hstartptr;
int hstartind;
int hendind;
int interstep;
int intrastep;
int numseq;
if (flags & JPC_QMFB1D_VERT) {
interstep = 1;
intrastep = jas_seq2d_rowstep(x);
numseq = jas_seq2d_width(x);
startind = jas_seq2d_ystart(x);
endind = jas_seq2d_yend(x);
} else {
interstep = jas_seq2d_rowstep(x);
intrastep = 1;
numseq = jas_seq2d_height(x);
startind = jas_seq2d_xstart(x);
endind = jas_seq2d_xend(x);
}
assert(startind < endind);
startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x));
if (flags & JPC_QMFB1D_RITIMODE) {
while (numseq-- > 0) {
jpc_qmfb1d_setup(startptr, startind, endind, intrastep,
&lstartptr, &lstartind, &lendind, &hstartptr,
&hstartind, &hendind);
if (endind - startind > 1) {
RFT_LIFT1(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep, -=);
RFT_LIFT0(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep, +=);
jpc_qmfb1d_join(startptr, startind, endind,
intrastep, lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind);
} else {
if (lstartind == lendind) {
*startptr >>= 1;
}
}
startptr += interstep;
}
} else {
while (numseq-- > 0) {
jpc_qmfb1d_setup(startptr, startind, endind, intrastep,
&lstartptr, &lstartind, &lendind, &hstartptr,
&hstartind, &hendind);
if (endind - startind > 1) {
NFT_LIFT1(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_fix_minuseq);
NFT_LIFT0(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_fix_pluseq);
jpc_qmfb1d_join(startptr, startind, endind,
intrastep, lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind);
} else {
if (lstartind == lendind) {
*startptr = jpc_fix_asr(*startptr, 1);
}
}
startptr += interstep;
}
}
}
/******************************************************************************\
* Code for 9/7 transform.
\******************************************************************************/
static int jpc_ns_getnumchans(jpc_qmfb1d_t *qmfb)
{
return 2;
}
static int jpc_ns_getanalfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters)
{
abort();
return -1;
}
static int jpc_ns_getsynfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters)
{
jas_seq_t *lf;
jas_seq_t *hf;
lf = 0;
hf = 0;
if (len > 1 || (!len)) {
if (!(lf = jas_seq_create(-3, 4))) {
goto error;
}
jas_seq_set(lf, -3, jpc_dbltofix(-0.09127176311424948));
jas_seq_set(lf, -2, jpc_dbltofix(-0.05754352622849957));
jas_seq_set(lf, -1, jpc_dbltofix(0.5912717631142470));
jas_seq_set(lf, 0, jpc_dbltofix(1.115087052456994));
jas_seq_set(lf, 1, jpc_dbltofix(0.5912717631142470));
jas_seq_set(lf, 2, jpc_dbltofix(-0.05754352622849957));
jas_seq_set(lf, 3, jpc_dbltofix(-0.09127176311424948));
if (!(hf = jas_seq_create(-3, 6))) {
goto error;
}
jas_seq_set(hf, -3, jpc_dbltofix(-0.02674875741080976 * 2.0));
jas_seq_set(hf, -2, jpc_dbltofix(-0.01686411844287495 * 2.0));
jas_seq_set(hf, -1, jpc_dbltofix(0.07822326652898785 * 2.0));
jas_seq_set(hf, 0, jpc_dbltofix(0.2668641184428723 * 2.0));
jas_seq_set(hf, 1, jpc_dbltofix(-0.6029490182363579 * 2.0));
jas_seq_set(hf, 2, jpc_dbltofix(0.2668641184428723 * 2.0));
jas_seq_set(hf, 3, jpc_dbltofix(0.07822326652898785 * 2.0));
jas_seq_set(hf, 4, jpc_dbltofix(-0.01686411844287495 * 2.0));
jas_seq_set(hf, 5, jpc_dbltofix(-0.02674875741080976 * 2.0));
} else if (len == 1) {
if (!(lf = jas_seq_create(0, 1))) {
goto error;
}
jas_seq_set(lf, 0, jpc_dbltofix(1.0));
if (!(hf = jas_seq_create(0, 1))) {
goto error;
}
jas_seq_set(hf, 0, jpc_dbltofix(2.0));
} else {
abort();
}
filters[0] = lf;
filters[1] = hf;
return 0;
error:
if (lf) {
jas_seq_destroy(lf);
}
if (hf) {
jas_seq_destroy(hf);
}
return -1;
}
#define NNS_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, alpha) \
{ \
register jpc_fix_t *lptr = (lstartptr); \
register jpc_fix_t *hptr = (hstartptr); \
register int n = (hendind) - (hstartind); \
jpc_fix_t twoalpha = jpc_fix_mulbyint(alpha, 2); \
if ((hstartind) < (lstartind)) { \
jpc_fix_pluseq(*hptr, jpc_fix_mul(*lptr, (twoalpha))); \
hptr += (step); \
--n; \
} \
if ((hendind) >= (lendind)) { \
--n; \
} \
while (n-- > 0) { \
jpc_fix_pluseq(*hptr, jpc_fix_mul(jpc_fix_add(*lptr, lptr[(step)]), (alpha))); \
hptr += (step); \
lptr += (step); \
} \
if ((hendind) >= (lendind)) { \
jpc_fix_pluseq(*hptr, jpc_fix_mul(*lptr, (twoalpha))); \
} \
}
#define NNS_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, alpha) \
{ \
register jpc_fix_t *lptr = (lstartptr); \
register jpc_fix_t *hptr = (hstartptr); \
register int n = (lendind) - (lstartind); \
int twoalpha = jpc_fix_mulbyint(alpha, 2); \
if ((hstartind) >= (lstartind)) { \
jpc_fix_pluseq(*lptr, jpc_fix_mul(*hptr, (twoalpha))); \
lptr += (step); \
--n; \
} \
if ((lendind) > (hendind)) { \
--n; \
} \
while (n-- > 0) { \
jpc_fix_pluseq(*lptr, jpc_fix_mul(jpc_fix_add(*hptr, hptr[(step)]), (alpha))); \
lptr += (step); \
hptr += (step); \
} \
if ((lendind) > (hendind)) { \
jpc_fix_pluseq(*lptr, jpc_fix_mul(*hptr, (twoalpha))); \
} \
}
#define NNS_SCALE(startptr, startind, endind, step, alpha) \
{ \
register jpc_fix_t *ptr = (startptr); \
register int n = (endind) - (startind); \
while (n-- > 0) { \
jpc_fix_muleq(*ptr, alpha); \
ptr += (step); \
} \
}
static void jpc_ns_analyze(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x)
{
jpc_fix_t *startptr;
int startind;
int endind;
jpc_fix_t *lstartptr;
int lstartind;
int lendind;
jpc_fix_t *hstartptr;
int hstartind;
int hendind;
int interstep;
int intrastep;
int numseq;
if (flags & JPC_QMFB1D_VERT) {
interstep = 1;
intrastep = jas_seq2d_rowstep(x);
numseq = jas_seq2d_width(x);
startind = jas_seq2d_ystart(x);
endind = jas_seq2d_yend(x);
} else {
interstep = jas_seq2d_rowstep(x);
intrastep = 1;
numseq = jas_seq2d_height(x);
startind = jas_seq2d_xstart(x);
endind = jas_seq2d_xend(x);
}
assert(startind < endind);
startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x));
if (!(flags & JPC_QMFB1D_RITIMODE)) {
while (numseq-- > 0) {
jpc_qmfb1d_setup(startptr, startind, endind, intrastep,
&lstartptr, &lstartind, &lendind, &hstartptr,
&hstartind, &hendind);
if (endind - startind > 1) {
jpc_qmfb1d_split(startptr, startind, endind,
intrastep, lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind);
NNS_LIFT0(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_dbltofix(-1.586134342));
NNS_LIFT1(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_dbltofix(-0.052980118));
NNS_LIFT0(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_dbltofix(0.882911075));
NNS_LIFT1(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_dbltofix(0.443506852));
NNS_SCALE(lstartptr, lstartind, lendind,
intrastep, jpc_dbltofix(1.0/1.23017410558578));
NNS_SCALE(hstartptr, hstartind, hendind,
intrastep, jpc_dbltofix(1.0/1.62578613134411));
} else {
#if 0
if (lstartind == lendind) {
*startptr = jpc_fix_asl(*startptr, 1);
}
#endif
}
startptr += interstep;
}
} else {
/* The reversible integer-to-integer mode is not supported
for this transform. */
abort();
}
}
static void jpc_ns_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x)
{
jpc_fix_t *startptr;
int startind;
int endind;
jpc_fix_t *lstartptr;
int lstartind;
int lendind;
jpc_fix_t *hstartptr;
int hstartind;
int hendind;
int interstep;
int intrastep;
int numseq;
if (flags & JPC_QMFB1D_VERT) {
interstep = 1;
intrastep = jas_seq2d_rowstep(x);
numseq = jas_seq2d_width(x);
startind = jas_seq2d_ystart(x);
endind = jas_seq2d_yend(x);
} else {
interstep = jas_seq2d_rowstep(x);
intrastep = 1;
numseq = jas_seq2d_height(x);
startind = jas_seq2d_xstart(x);
endind = jas_seq2d_xend(x);
}
assert(startind < endind);
startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x));
if (!(flags & JPC_QMFB1D_RITIMODE)) {
while (numseq-- > 0) {
jpc_qmfb1d_setup(startptr, startind, endind, intrastep,
&lstartptr, &lstartind, &lendind, &hstartptr,
&hstartind, &hendind);
if (endind - startind > 1) {
NNS_SCALE(lstartptr, lstartind, lendind,
intrastep, jpc_dbltofix(1.23017410558578));
NNS_SCALE(hstartptr, hstartind, hendind,
intrastep, jpc_dbltofix(1.62578613134411));
NNS_LIFT1(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_dbltofix(-0.443506852));
NNS_LIFT0(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_dbltofix(-0.882911075));
NNS_LIFT1(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_dbltofix(0.052980118));
NNS_LIFT0(lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind, intrastep,
jpc_dbltofix(1.586134342));
jpc_qmfb1d_join(startptr, startind, endind,
intrastep, lstartptr, lstartind, lendind,
hstartptr, hstartind, hendind);
} else {
#if 0
if (lstartind == lendind) {
*startptr = jpc_fix_asr(*startptr, 1);
}
#endif
}
startptr += interstep;
}
} else {
/* The reversible integer-to-integer mode is not supported
for this transform. */
abort();
}
}
/******************************************************************************\
*
\******************************************************************************/
jpc_qmfb1d_t *jpc_qmfb1d_make(int qmfbid)
{
jpc_qmfb1d_t *qmfb;
if (!(qmfb = jpc_qmfb1d_create())) {
return 0;
}
switch (qmfbid) {
case JPC_QMFB1D_FT:
qmfb->ops = &jpc_ft_ops;
break;
case JPC_QMFB1D_NS:
qmfb->ops = &jpc_ns_ops;
break;
default:
jpc_qmfb1d_destroy(qmfb);
return 0;
break;
}
return qmfb;
}
static jpc_qmfb1d_t *jpc_qmfb1d_create()
{
jpc_qmfb1d_t *qmfb;
if (!(qmfb = jas_malloc(sizeof(jpc_qmfb1d_t)))) {
return 0;
}
qmfb->ops = 0;
return qmfb;
}
jpc_qmfb1d_t *jpc_qmfb1d_copy(jpc_qmfb1d_t *qmfb)
{
jpc_qmfb1d_t *newqmfb;
if (!(newqmfb = jpc_qmfb1d_create())) {
return 0;
}
newqmfb->ops = qmfb->ops;
return newqmfb;
}
void jpc_qmfb1d_destroy(jpc_qmfb1d_t *qmfb)
{
jas_free(qmfb);
}
/******************************************************************************\
*
\******************************************************************************/
void jpc_qmfb1d_getbands(jpc_qmfb1d_t *qmfb, int flags, uint_fast32_t xstart,
uint_fast32_t ystart, uint_fast32_t xend, uint_fast32_t yend, int maxbands,
int *numbandsptr, jpc_qmfb1dband_t *bands)
{
int start;
int end;
if (flags & JPC_QMFB1D_VERT) {
start = ystart;
end = yend;
} else {
start = xstart;
end = xend;
}
assert(jpc_qmfb1d_getnumchans(qmfb) == 2);
assert(start <= end);
bands[0].start = JPC_CEILDIVPOW2(start, 1);
bands[0].end = JPC_CEILDIVPOW2(end, 1);
bands[0].locstart = start;
bands[0].locend = start + bands[0].end - bands[0].start;
bands[1].start = JPC_FLOORDIVPOW2(start, 1);
bands[1].end = JPC_FLOORDIVPOW2(end, 1);
bands[1].locstart = bands[0].locend;
bands[1].locend = bands[1].locstart + bands[1].end - bands[1].start;
assert(bands[1].locend == end);
*numbandsptr = 2;
}
/******************************************************************************\
*
\******************************************************************************/
int jpc_qmfb1d_getnumchans(jpc_qmfb1d_t *qmfb)
{
return (*qmfb->ops->getnumchans)(qmfb);
}
int jpc_qmfb1d_getanalfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters)
{
return (*qmfb->ops->getanalfilters)(qmfb, len, filters);
}
int jpc_qmfb1d_getsynfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters)
{
return (*qmfb->ops->getsynfilters)(qmfb, len, filters);
}
void jpc_qmfb1d_analyze(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x)
{
(*qmfb->ops->analyze)(qmfb, flags, x);
}
void jpc_qmfb1d_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x)
{
(*qmfb->ops->synthesize)(qmfb, flags, x);
}