~ubuntu-branches/ubuntu/precise/jasper/precise-updates
» Revision
10
: .pc/01-misc-fixes.patch/src/libjasper/jpc/jpc_qmfb.c
« back to all changes in this revision
Viewing changes to .pc/01-misc-fixes.patch/src/libjasper/jpc/jpc_qmfb.c
- browse files at revision 10
- compare with another revision
- download diff
- download tarball
- view history from revision 10
- Committer: Bazaar Package Importer
- Author(s): Colin Watson
- Date: 2011-10-24 12:33:36 UTC
- mfrom: (7.1.3 sid)
- Revision ID: james.westby@ubuntu.com-20111024123336-fyqahayo6mm0q7ke
Tags: 1.900.1-10ubuntu1
* Resynchronise with Debian. Remaining changes (revised for dh(1)):
- Enable multiarch build.
- Enable multiarch build.
- files added:
- .pc
- .pc/01-misc-fixes.patch
- .pc/01-misc-fixes.patch/acaux
- .pc/01-misc-fixes.patch/src
- .pc/01-misc-fixes.patch/src/libjasper
- .pc/01-misc-fixes.patch/src/libjasper/base
- .pc/01-misc-fixes.patch/src/libjasper/bmp
- .pc/01-misc-fixes.patch/src/libjasper/include
- .pc/01-misc-fixes.patch/src/libjasper/include/jasper
- .pc/01-misc-fixes.patch/src/libjasper/jp2
- .pc/01-misc-fixes.patch/src/libjasper/jpc
- .pc/01-misc-fixes.patch/src/libjasper/mif
- debian/patches
- debian/source
- files removed:
- config.guess
- files modified:
- debian/changelog
added
removed
.pc/01-misc-fixes.patch/src/libjasper/jpc/jpc_qmfb.c
1
/*
2
* Copyright (c) 1999-2000 Image Power, Inc. and the University of
3
* British Columbia.
4
* Copyright (c) 2001-2003 Michael David Adams.
5
* All rights reserved.
6
*/
7
8
/* __START_OF_JASPER_LICENSE__
9
*
10
* JasPer License Version 2.0
11
*
12
* Copyright (c) 2001-2006 Michael David Adams
13
* Copyright (c) 1999-2000 Image Power, Inc.
14
* Copyright (c) 1999-2000 The University of British Columbia
15
*
16
* All rights reserved.
17
*
18
* Permission is hereby granted, free of charge, to any person (the
19
* "User") obtaining a copy of this software and associated documentation
20
* files (the "Software"), to deal in the Software without restriction,
21
* including without limitation the rights to use, copy, modify, merge,
22
* publish, distribute, and/or sell copies of the Software, and to permit
23
* persons to whom the Software is furnished to do so, subject to the
24
* following conditions:
25
*
26
* 1. The above copyright notices and this permission notice (which
27
* includes the disclaimer below) shall be included in all copies or
28
* substantial portions of the Software.
29
*
30
* 2. The name of a copyright holder shall not be used to endorse or
31
* promote products derived from the Software without specific prior
32
* written permission.
33
*
34
* THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
35
* LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
36
* THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
37
* "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
38
* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
39
* PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
40
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
41
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
42
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
43
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
44
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
45
* PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
46
* THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
47
* EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
48
* BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
49
* PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
50
* GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
51
* ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
52
* IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
53
* SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
54
* AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
55
* SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
56
* THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
57
* PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
58
* RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
59
* EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
60
*
61
* __END_OF_JASPER_LICENSE__
62
*/
63
64
/*
65
* Quadrature Mirror-Image Filter Bank (QMFB) Library
66
*
67
* $Id$
68
*/
69
70
/******************************************************************************\
71
*
72
\******************************************************************************/
73
74
#undef WT_LENONE /* This is not needed due to normalization. */
75
#define WT_DOSCALE
76
77
/******************************************************************************\
78
* Includes.
79
\******************************************************************************/
80
81
#include <assert.h>
82
#include "jasper/jas_fix.h"
83
#include "jasper/jas_malloc.h"
84
#include "jasper/jas_math.h"
85
86
#include "jpc_qmfb.h"
87
#include "jpc_tsfb.h"
88
#include "jpc_math.h"
89
90
/******************************************************************************\
91
*
92
\******************************************************************************/
93
94
#define QMFB_SPLITBUFSIZE 4096
95
#define QMFB_JOINBUFSIZE 4096
96
97
int jpc_ft_analyze(jpc_fix_t *a, int xstart, int ystart, int width, int height,
98
int stride);
99
int jpc_ft_synthesize(int *a, int xstart, int ystart, int width, int height,
100
int stride);
101
102
int jpc_ns_analyze(jpc_fix_t *a, int xstart, int ystart, int width, int height,
103
int stride);
104
int jpc_ns_synthesize(jpc_fix_t *a, int xstart, int ystart, int width,
105
int height, int stride);
106
107
void jpc_ft_fwdlift_row(jpc_fix_t *a, int numcols, int parity);
108
void jpc_ft_fwdlift_col(jpc_fix_t *a, int numrows, int stride,
109
int parity);
110
void jpc_ft_fwdlift_colgrp(jpc_fix_t *a, int numrows, int stride,
111
int parity);
112
void jpc_ft_fwdlift_colres(jpc_fix_t *a, int numrows, int numcols,
113
int stride, int parity);
114
115
void jpc_ft_invlift_row(jpc_fix_t *a, int numcols, int parity);
116
void jpc_ft_invlift_col(jpc_fix_t *a, int numrows, int stride,
117
int parity);
118
void jpc_ft_invlift_colgrp(jpc_fix_t *a, int numrows, int stride,
119
int parity);
120
void jpc_ft_invlift_colres(jpc_fix_t *a, int numrows, int numcols,
121
int stride, int parity);
122
123
void jpc_ns_fwdlift_row(jpc_fix_t *a, int numcols, int parity);
124
void jpc_ns_fwdlift_colgrp(jpc_fix_t *a, int numrows, int stride, int parity);
125
void jpc_ns_fwdlift_colres(jpc_fix_t *a, int numrows, int numcols, int stride,
126
int parity);
127
void jpc_ns_invlift_row(jpc_fix_t *a, int numcols, int parity);
128
void jpc_ns_invlift_colgrp(jpc_fix_t *a, int numrows, int stride, int parity);
129
void jpc_ns_invlift_colres(jpc_fix_t *a, int numrows, int numcols, int stride,
130
int parity);
131
132
void jpc_qmfb_split_row(jpc_fix_t *a, int numcols, int parity);
133
void jpc_qmfb_split_col(jpc_fix_t *a, int numrows, int stride, int parity);
134
void jpc_qmfb_split_colgrp(jpc_fix_t *a, int numrows, int stride, int parity);
135
void jpc_qmfb_split_colres(jpc_fix_t *a, int numrows, int numcols, int stride,
136
int parity);
137
138
void jpc_qmfb_join_row(jpc_fix_t *a, int numcols, int parity);
139
void jpc_qmfb_join_col(jpc_fix_t *a, int numrows, int stride, int parity);
140
void jpc_qmfb_join_colgrp(jpc_fix_t *a, int numrows, int stride, int parity);
141
void jpc_qmfb_join_colres(jpc_fix_t *a, int numrows, int numcols, int stride,
142
int parity);
143
144
double jpc_ft_lpenergywts[32] = {
145
1.2247448713915889,
146
1.6583123951776999,
147
2.3184046238739260,
148
3.2691742076555053,
149
4.6199296531440819,
150
6.5323713152269596,
151
9.2377452606141937,
152
13.0639951297449581,
153
18.4752262333915667,
154
26.1278968190610392,
155
36.9504194305524791,
156
52.2557819580462777,
157
73.9008347315741645,
158
104.5115624560829133,
159
147.8016689469569656,
160
209.0231247296646018,
161
295.6033378293900000,
162
418.0462494347059419,
163
591.2066756503630813,
164
836.0924988714708661,
165
/* approximations */
166
836.0924988714708661,
167
836.0924988714708661,
168
836.0924988714708661,
169
836.0924988714708661,
170
836.0924988714708661,
171
836.0924988714708661,
172
836.0924988714708661,
173
836.0924988714708661,
174
836.0924988714708661,
175
836.0924988714708661,
176
836.0924988714708661,
177
836.0924988714708661
178
};
179
180
double jpc_ft_hpenergywts[32] = {
181
0.8477912478906585,
182
0.9601432184835760,
183
1.2593401049756179,
184
1.7444107171191079,
185
2.4538713036750726,
186
3.4656517695088755,
187
4.8995276398597856,
188
6.9283970402160842,
189
9.7980274940131444,
190
13.8564306871112652,
191
19.5959265076535587,
192
27.7128159494245487,
193
39.1918369552045860,
194
55.4256262207444053,
195
78.3836719028959124,
196
110.8512517317256822,
197
156.7673435548526868,
198
221.7025033739244293,
199
313.5346870787551552,
200
443.4050067351659550,
201
/* approximations */
202
443.4050067351659550,
203
443.4050067351659550,
204
443.4050067351659550,
205
443.4050067351659550,
206
443.4050067351659550,
207
443.4050067351659550,
208
443.4050067351659550,
209
443.4050067351659550,
210
443.4050067351659550,
211
443.4050067351659550,
212
443.4050067351659550,
213
443.4050067351659550
214
};
215
216
double jpc_ns_lpenergywts[32] = {
217
1.4021081679297411,
218
2.0303718560817923,
219
2.9011625562785555,
220
4.1152851751758002,
221
5.8245108637728071,
222
8.2387599345725171,
223
11.6519546479210838,
224
16.4785606470644375,
225
23.3042776444606794,
226
32.9572515613740435,
227
46.6086013487782793,
228
65.9145194076860861,
229
93.2172084551803977,
230
131.8290408510004283,
231
186.4344176300625691,
232
263.6580819564562148,
233
372.8688353500955373,
234
527.3161639447193920,
235
745.7376707114038936,
236
1054.6323278917823245,
237
/* approximations follow */
238
1054.6323278917823245,
239
1054.6323278917823245,
240
1054.6323278917823245,
241
1054.6323278917823245,
242
1054.6323278917823245,
243
1054.6323278917823245,
244
1054.6323278917823245,
245
1054.6323278917823245,
246
1054.6323278917823245,
247
1054.6323278917823245,
248
1054.6323278917823245,
249
1054.6323278917823245
250
};
251
252
double jpc_ns_hpenergywts[32] = {
253
1.4425227650161456,
254
1.9669426082455688,
255
2.8839248082788891,
256
4.1475208393432981,
257
5.8946497530677817,
258
8.3471789178590949,
259
11.8086046551047463,
260
16.7012780415647804,
261
23.6196657032246620,
262
33.4034255108592362,
263
47.2396388881632632,
264
66.8069597416714061,
265
94.4793162154500692,
266
133.6139330736999113,
267
188.9586372358249378,
268
267.2278678461869390,
269
377.9172750722391356,
270
534.4557359047058753,
271
755.8345502191498326,
272
1068.9114718353569060,
273
/* approximations follow */
274
1068.9114718353569060,
275
1068.9114718353569060,
276
1068.9114718353569060,
277
1068.9114718353569060,
278
1068.9114718353569060,
279
1068.9114718353569060,
280
1068.9114718353569060,
281
1068.9114718353569060,
282
1068.9114718353569060,
283
1068.9114718353569060,
284
1068.9114718353569060
285
};
286
287
jpc_qmfb2d_t jpc_ft_qmfb2d = {
288
jpc_ft_analyze,
289
jpc_ft_synthesize,
290
jpc_ft_lpenergywts,
291
jpc_ft_hpenergywts
292
};
293
294
jpc_qmfb2d_t jpc_ns_qmfb2d = {
295
jpc_ns_analyze,
296
jpc_ns_synthesize,
297
jpc_ns_lpenergywts,
298
jpc_ns_hpenergywts
299
};
300
301
/******************************************************************************\
302
* generic
303
\******************************************************************************/
304
305
void jpc_qmfb_split_row(jpc_fix_t *a, int numcols, int parity)
306
{
307
308
int bufsize = JPC_CEILDIVPOW2(numcols, 1);
309
#if !defined(HAVE_VLA)
310
jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE];
311
#else
312
jpc_fix_t splitbuf[bufsize];
313
#endif
314
jpc_fix_t *buf = splitbuf;
315
register jpc_fix_t *srcptr;
316
register jpc_fix_t *dstptr;
317
register int n;
318
register int m;
319
int hstartcol;
320
321
#if !defined(HAVE_VLA)
322
/* Get a buffer. */
323
if (bufsize > QMFB_SPLITBUFSIZE) {
324
if (!(buf = jas_malloc(bufsize * sizeof(jpc_fix_t)))) {
325
/* We have no choice but to commit suicide in this case. */
326
abort();
327
}
328
}
329
#endif
330
331
if (numcols >= 2) {
332
hstartcol = (numcols + 1 - parity) >> 1;
333
m = (parity) ? hstartcol : (numcols - hstartcol);
334
/* Save the samples destined for the highpass channel. */
335
n = m;
336
dstptr = buf;
337
srcptr = &a[1 - parity];
338
while (n-- > 0) {
339
*dstptr = *srcptr;
340
++dstptr;
341
srcptr += 2;
342
}
343
/* Copy the appropriate samples into the lowpass channel. */
344
dstptr = &a[1 - parity];
345
srcptr = &a[2 - parity];
346
n = numcols - m - (!parity);
347
while (n-- > 0) {
348
*dstptr = *srcptr;
349
++dstptr;
350
srcptr += 2;
351
}
352
/* Copy the saved samples into the highpass channel. */
353
dstptr = &a[hstartcol];
354
srcptr = buf;
355
n = m;
356
while (n-- > 0) {
357
*dstptr = *srcptr;
358
++dstptr;
359
++srcptr;
360
}
361
}
362
363
#if !defined(HAVE_VLA)
364
/* If the split buffer was allocated on the heap, free this memory. */
365
if (buf != splitbuf) {
366
jas_free(buf);
367
}
368
#endif
369
370
}
371
372
void jpc_qmfb_split_col(jpc_fix_t *a, int numrows, int stride,
373
int parity)
374
{
375
376
int bufsize = JPC_CEILDIVPOW2(numrows, 1);
377
#if !defined(HAVE_VLA)
378
jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE];
379
#else
380
jpc_fix_t splitbuf[bufsize];
381
#endif
382
jpc_fix_t *buf = splitbuf;
383
register jpc_fix_t *srcptr;
384
register jpc_fix_t *dstptr;
385
register int n;
386
register int m;
387
int hstartcol;
388
389
#if !defined(HAVE_VLA)
390
/* Get a buffer. */
391
if (bufsize > QMFB_SPLITBUFSIZE) {
392
if (!(buf = jas_malloc(bufsize * sizeof(jpc_fix_t)))) {
393
/* We have no choice but to commit suicide in this case. */
394
abort();
395
}
396
}
397
#endif
398
399
if (numrows >= 2) {
400
hstartcol = (numrows + 1 - parity) >> 1;
401
m = (parity) ? hstartcol : (numrows - hstartcol);
402
/* Save the samples destined for the highpass channel. */
403
n = m;
404
dstptr = buf;
405
srcptr = &a[(1 - parity) * stride];
406
while (n-- > 0) {
407
*dstptr = *srcptr;
408
++dstptr;
409
srcptr += stride << 1;
410
}
411
/* Copy the appropriate samples into the lowpass channel. */
412
dstptr = &a[(1 - parity) * stride];
413
srcptr = &a[(2 - parity) * stride];
414
n = numrows - m - (!parity);
415
while (n-- > 0) {
416
*dstptr = *srcptr;
417
dstptr += stride;
418
srcptr += stride << 1;
419
}
420
/* Copy the saved samples into the highpass channel. */
421
dstptr = &a[hstartcol * stride];
422
srcptr = buf;
423
n = m;
424
while (n-- > 0) {
425
*dstptr = *srcptr;
426
dstptr += stride;
427
++srcptr;
428
}
429
}
430
431
#if !defined(HAVE_VLA)
432
/* If the split buffer was allocated on the heap, free this memory. */
433
if (buf != splitbuf) {
434
jas_free(buf);
435
}
436
#endif
437
438
}
439
440
void jpc_qmfb_split_colgrp(jpc_fix_t *a, int numrows, int stride,
441
int parity)
442
{
443
444
int bufsize = JPC_CEILDIVPOW2(numrows, 1);
445
#if !defined(HAVE_VLA)
446
jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE * JPC_QMFB_COLGRPSIZE];
447
#else
448
jpc_fix_t splitbuf[bufsize * JPC_QMFB_COLGRPSIZE];
449
#endif
450
jpc_fix_t *buf = splitbuf;
451
jpc_fix_t *srcptr;
452
jpc_fix_t *dstptr;
453
register jpc_fix_t *srcptr2;
454
register jpc_fix_t *dstptr2;
455
register int n;
456
register int i;
457
int m;
458
int hstartcol;
459
460
#if !defined(HAVE_VLA)
461
/* Get a buffer. */
462
if (bufsize > QMFB_SPLITBUFSIZE) {
463
if (!(buf = jas_malloc(bufsize * sizeof(jpc_fix_t)))) {
464
/* We have no choice but to commit suicide in this case. */
465
abort();
466
}
467
}
468
#endif
469
470
if (numrows >= 2) {
471
hstartcol = (numrows + 1 - parity) >> 1;
472
m = (parity) ? hstartcol : (numrows - hstartcol);
473
/* Save the samples destined for the highpass channel. */
474
n = m;
475
dstptr = buf;
476
srcptr = &a[(1 - parity) * stride];
477
while (n-- > 0) {
478
dstptr2 = dstptr;
479
srcptr2 = srcptr;
480
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
481
*dstptr2 = *srcptr2;
482
++dstptr2;
483
++srcptr2;
484
}
485
dstptr += JPC_QMFB_COLGRPSIZE;
486
srcptr += stride << 1;
487
}
488
/* Copy the appropriate samples into the lowpass channel. */
489
dstptr = &a[(1 - parity) * stride];
490
srcptr = &a[(2 - parity) * stride];
491
n = numrows - m - (!parity);
492
while (n-- > 0) {
493
dstptr2 = dstptr;
494
srcptr2 = srcptr;
495
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
496
*dstptr2 = *srcptr2;
497
++dstptr2;
498
++srcptr2;
499
}
500
dstptr += stride;
501
srcptr += stride << 1;
502
}
503
/* Copy the saved samples into the highpass channel. */
504
dstptr = &a[hstartcol * stride];
505
srcptr = buf;
506
n = m;
507
while (n-- > 0) {
508
dstptr2 = dstptr;
509
srcptr2 = srcptr;
510
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
511
*dstptr2 = *srcptr2;
512
++dstptr2;
513
++srcptr2;
514
}
515
dstptr += stride;
516
srcptr += JPC_QMFB_COLGRPSIZE;
517
}
518
}
519
520
#if !defined(HAVE_VLA)
521
/* If the split buffer was allocated on the heap, free this memory. */
522
if (buf != splitbuf) {
523
jas_free(buf);
524
}
525
#endif
526
527
}
528
529
void jpc_qmfb_split_colres(jpc_fix_t *a, int numrows, int numcols,
530
int stride, int parity)
531
{
532
533
int bufsize = JPC_CEILDIVPOW2(numrows, 1);
534
#if !defined(HAVE_VLA)
535
jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE * JPC_QMFB_COLGRPSIZE];
536
#else
537
jpc_fix_t splitbuf[bufsize * numcols];
538
#endif
539
jpc_fix_t *buf = splitbuf;
540
jpc_fix_t *srcptr;
541
jpc_fix_t *dstptr;
542
register jpc_fix_t *srcptr2;
543
register jpc_fix_t *dstptr2;
544
register int n;
545
register int i;
546
int m;
547
int hstartcol;
548
549
#if !defined(HAVE_VLA)
550
/* Get a buffer. */
551
if (bufsize > QMFB_SPLITBUFSIZE) {
552
if (!(buf = jas_malloc(bufsize * sizeof(jpc_fix_t)))) {
553
/* We have no choice but to commit suicide in this case. */
554
abort();
555
}
556
}
557
#endif
558
559
if (numrows >= 2) {
560
hstartcol = (numrows + 1 - parity) >> 1;
561
m = (parity) ? hstartcol : (numrows - hstartcol);
562
/* Save the samples destined for the highpass channel. */
563
n = m;
564
dstptr = buf;
565
srcptr = &a[(1 - parity) * stride];
566
while (n-- > 0) {
567
dstptr2 = dstptr;
568
srcptr2 = srcptr;
569
for (i = 0; i < numcols; ++i) {
570
*dstptr2 = *srcptr2;
571
++dstptr2;
572
++srcptr2;
573
}
574
dstptr += numcols;
575
srcptr += stride << 1;
576
}
577
/* Copy the appropriate samples into the lowpass channel. */
578
dstptr = &a[(1 - parity) * stride];
579
srcptr = &a[(2 - parity) * stride];
580
n = numrows - m - (!parity);
581
while (n-- > 0) {
582
dstptr2 = dstptr;
583
srcptr2 = srcptr;
584
for (i = 0; i < numcols; ++i) {
585
*dstptr2 = *srcptr2;
586
++dstptr2;
587
++srcptr2;
588
}
589
dstptr += stride;
590
srcptr += stride << 1;
591
}
592
/* Copy the saved samples into the highpass channel. */
593
dstptr = &a[hstartcol * stride];
594
srcptr = buf;
595
n = m;
596
while (n-- > 0) {
597
dstptr2 = dstptr;
598
srcptr2 = srcptr;
599
for (i = 0; i < numcols; ++i) {
600
*dstptr2 = *srcptr2;
601
++dstptr2;
602
++srcptr2;
603
}
604
dstptr += stride;
605
srcptr += numcols;
606
}
607
}
608
609
#if !defined(HAVE_VLA)
610
/* If the split buffer was allocated on the heap, free this memory. */
611
if (buf != splitbuf) {
612
jas_free(buf);
613
}
614
#endif
615
616
}
617
618
void jpc_qmfb_join_row(jpc_fix_t *a, int numcols, int parity)
619
{
620
621
int bufsize = JPC_CEILDIVPOW2(numcols, 1);
622
#if !defined(HAVE_VLA)
623
jpc_fix_t joinbuf[QMFB_JOINBUFSIZE];
624
#else
625
jpc_fix_t joinbuf[bufsize];
626
#endif
627
jpc_fix_t *buf = joinbuf;
628
register jpc_fix_t *srcptr;
629
register jpc_fix_t *dstptr;
630
register int n;
631
int hstartcol;
632
633
#if !defined(HAVE_VLA)
634
/* Allocate memory for the join buffer from the heap. */
635
if (bufsize > QMFB_JOINBUFSIZE) {
636
if (!(buf = jas_malloc(bufsize * sizeof(jpc_fix_t)))) {
637
/* We have no choice but to commit suicide. */
638
abort();
639
}
640
}
641
#endif
642
643
hstartcol = (numcols + 1 - parity) >> 1;
644
645
/* Save the samples from the lowpass channel. */
646
n = hstartcol;
647
srcptr = &a[0];
648
dstptr = buf;
649
while (n-- > 0) {
650
*dstptr = *srcptr;
651
++srcptr;
652
++dstptr;
653
}
654
/* Copy the samples from the highpass channel into place. */
655
srcptr = &a[hstartcol];
656
dstptr = &a[1 - parity];
657
n = numcols - hstartcol;
658
while (n-- > 0) {
659
*dstptr = *srcptr;
660
dstptr += 2;
661
++srcptr;
662
}
663
/* Copy the samples from the lowpass channel into place. */
664
srcptr = buf;
665
dstptr = &a[parity];
666
n = hstartcol;
667
while (n-- > 0) {
668
*dstptr = *srcptr;
669
dstptr += 2;
670
++srcptr;
671
}
672
673
#if !defined(HAVE_VLA)
674
/* If the join buffer was allocated on the heap, free this memory. */
675
if (buf != joinbuf) {
676
jas_free(buf);
677
}
678
#endif
679
680
}
681
682
void jpc_qmfb_join_col(jpc_fix_t *a, int numrows, int stride,
683
int parity)
684
{
685
686
int bufsize = JPC_CEILDIVPOW2(numrows, 1);
687
#if !defined(HAVE_VLA)
688
jpc_fix_t joinbuf[QMFB_JOINBUFSIZE];
689
#else
690
jpc_fix_t joinbuf[bufsize];
691
#endif
692
jpc_fix_t *buf = joinbuf;
693
register jpc_fix_t *srcptr;
694
register jpc_fix_t *dstptr;
695
register int n;
696
int hstartcol;
697
698
#if !defined(HAVE_VLA)
699
/* Allocate memory for the join buffer from the heap. */
700
if (bufsize > QMFB_JOINBUFSIZE) {
701
if (!(buf = jas_malloc(bufsize * sizeof(jpc_fix_t)))) {
702
/* We have no choice but to commit suicide. */
703
abort();
704
}
705
}
706
#endif
707
708
hstartcol = (numrows + 1 - parity) >> 1;
709
710
/* Save the samples from the lowpass channel. */
711
n = hstartcol;
712
srcptr = &a[0];
713
dstptr = buf;
714
while (n-- > 0) {
715
*dstptr = *srcptr;
716
srcptr += stride;
717
++dstptr;
718
}
719
/* Copy the samples from the highpass channel into place. */
720
srcptr = &a[hstartcol * stride];
721
dstptr = &a[(1 - parity) * stride];
722
n = numrows - hstartcol;
723
while (n-- > 0) {
724
*dstptr = *srcptr;
725
dstptr += 2 * stride;
726
srcptr += stride;
727
}
728
/* Copy the samples from the lowpass channel into place. */
729
srcptr = buf;
730
dstptr = &a[parity * stride];
731
n = hstartcol;
732
while (n-- > 0) {
733
*dstptr = *srcptr;
734
dstptr += 2 * stride;
735
++srcptr;
736
}
737
738
#if !defined(HAVE_VLA)
739
/* If the join buffer was allocated on the heap, free this memory. */
740
if (buf != joinbuf) {
741
jas_free(buf);
742
}
743
#endif
744
745
}
746
747
void jpc_qmfb_join_colgrp(jpc_fix_t *a, int numrows, int stride,
748
int parity)
749
{
750
751
int bufsize = JPC_CEILDIVPOW2(numrows, 1);
752
#if !defined(HAVE_VLA)
753
jpc_fix_t joinbuf[QMFB_JOINBUFSIZE * JPC_QMFB_COLGRPSIZE];
754
#else
755
jpc_fix_t joinbuf[bufsize * JPC_QMFB_COLGRPSIZE];
756
#endif
757
jpc_fix_t *buf = joinbuf;
758
jpc_fix_t *srcptr;
759
jpc_fix_t *dstptr;
760
register jpc_fix_t *srcptr2;
761
register jpc_fix_t *dstptr2;
762
register int n;
763
register int i;
764
int hstartcol;
765
766
#if !defined(HAVE_VLA)
767
/* Allocate memory for the join buffer from the heap. */
768
if (bufsize > QMFB_JOINBUFSIZE) {
769
if (!(buf = jas_malloc(bufsize * JPC_QMFB_COLGRPSIZE * sizeof(jpc_fix_t)))) {
770
/* We have no choice but to commit suicide. */
771
abort();
772
}
773
}
774
#endif
775
776
hstartcol = (numrows + 1 - parity) >> 1;
777
778
/* Save the samples from the lowpass channel. */
779
n = hstartcol;
780
srcptr = &a[0];
781
dstptr = buf;
782
while (n-- > 0) {
783
dstptr2 = dstptr;
784
srcptr2 = srcptr;
785
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
786
*dstptr2 = *srcptr2;
787
++dstptr2;
788
++srcptr2;
789
}
790
srcptr += stride;
791
dstptr += JPC_QMFB_COLGRPSIZE;
792
}
793
/* Copy the samples from the highpass channel into place. */
794
srcptr = &a[hstartcol * stride];
795
dstptr = &a[(1 - parity) * stride];
796
n = numrows - hstartcol;
797
while (n-- > 0) {
798
dstptr2 = dstptr;
799
srcptr2 = srcptr;
800
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
801
*dstptr2 = *srcptr2;
802
++dstptr2;
803
++srcptr2;
804
}
805
dstptr += 2 * stride;
806
srcptr += stride;
807
}
808
/* Copy the samples from the lowpass channel into place. */
809
srcptr = buf;
810
dstptr = &a[parity * stride];
811
n = hstartcol;
812
while (n-- > 0) {
813
dstptr2 = dstptr;
814
srcptr2 = srcptr;
815
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
816
*dstptr2 = *srcptr2;
817
++dstptr2;
818
++srcptr2;
819
}
820
dstptr += 2 * stride;
821
srcptr += JPC_QMFB_COLGRPSIZE;
822
}
823
824
#if !defined(HAVE_VLA)
825
/* If the join buffer was allocated on the heap, free this memory. */
826
if (buf != joinbuf) {
827
jas_free(buf);
828
}
829
#endif
830
831
}
832
833
void jpc_qmfb_join_colres(jpc_fix_t *a, int numrows, int numcols,
834
int stride, int parity)
835
{
836
837
int bufsize = JPC_CEILDIVPOW2(numrows, 1);
838
#if !defined(HAVE_VLA)
839
jpc_fix_t joinbuf[QMFB_JOINBUFSIZE * JPC_QMFB_COLGRPSIZE];
840
#else
841
jpc_fix_t joinbuf[bufsize * numcols];
842
#endif
843
jpc_fix_t *buf = joinbuf;
844
jpc_fix_t *srcptr;
845
jpc_fix_t *dstptr;
846
register jpc_fix_t *srcptr2;
847
register jpc_fix_t *dstptr2;
848
register int n;
849
register int i;
850
int hstartcol;
851
852
#if !defined(HAVE_VLA)
853
/* Allocate memory for the join buffer from the heap. */
854
if (bufsize > QMFB_JOINBUFSIZE) {
855
if (!(buf = jas_malloc(bufsize * numcols * sizeof(jpc_fix_t)))) {
856
/* We have no choice but to commit suicide. */
857
abort();
858
}
859
}
860
#endif
861
862
hstartcol = (numrows + 1 - parity) >> 1;
863
864
/* Save the samples from the lowpass channel. */
865
n = hstartcol;
866
srcptr = &a[0];
867
dstptr = buf;
868
while (n-- > 0) {
869
dstptr2 = dstptr;
870
srcptr2 = srcptr;
871
for (i = 0; i < numcols; ++i) {
872
*dstptr2 = *srcptr2;
873
++dstptr2;
874
++srcptr2;
875
}
876
srcptr += stride;
877
dstptr += numcols;
878
}
879
/* Copy the samples from the highpass channel into place. */
880
srcptr = &a[hstartcol * stride];
881
dstptr = &a[(1 - parity) * stride];
882
n = numrows - hstartcol;
883
while (n-- > 0) {
884
dstptr2 = dstptr;
885
srcptr2 = srcptr;
886
for (i = 0; i < numcols; ++i) {
887
*dstptr2 = *srcptr2;
888
++dstptr2;
889
++srcptr2;
890
}
891
dstptr += 2 * stride;
892
srcptr += stride;
893
}
894
/* Copy the samples from the lowpass channel into place. */
895
srcptr = buf;
896
dstptr = &a[parity * stride];
897
n = hstartcol;
898
while (n-- > 0) {
899
dstptr2 = dstptr;
900
srcptr2 = srcptr;
901
for (i = 0; i < numcols; ++i) {
902
*dstptr2 = *srcptr2;
903
++dstptr2;
904
++srcptr2;
905
}
906
dstptr += 2 * stride;
907
srcptr += numcols;
908
}
909
910
#if !defined(HAVE_VLA)
911
/* If the join buffer was allocated on the heap, free this memory. */
912
if (buf != joinbuf) {
913
jas_free(buf);
914
}
915
#endif
916
917
}
918
919
/******************************************************************************\
920
* 5/3 transform
921
\******************************************************************************/
922
923
void jpc_ft_fwdlift_row(jpc_fix_t *a, int numcols, int parity)
924
{
925
926
register jpc_fix_t *lptr;
927
register jpc_fix_t *hptr;
928
register int n;
929
int llen;
930
931
llen = (numcols + 1 - parity) >> 1;
932
933
if (numcols > 1) {
934
935
/* Apply the first lifting step. */
936
lptr = &a[0];
937
hptr = &a[llen];
938
if (parity) {
939
hptr[0] -= lptr[0];
940
++hptr;
941
}
942
n = numcols - llen - parity - (parity == (numcols & 1));
943
while (n-- > 0) {
944
hptr[0] -= (lptr[0] + lptr[1]) >> 1;
945
++hptr;
946
++lptr;
947
}
948
if (parity == (numcols & 1)) {
949
hptr[0] -= lptr[0];
950
}
951
952
/* Apply the second lifting step. */
953
lptr = &a[0];
954
hptr = &a[llen];
955
if (!parity) {
956
lptr[0] += (hptr[0] + 1) >> 1;
957
++lptr;
958
}
959
n = llen - (!parity) - (parity != (numcols & 1));
960
while (n-- > 0) {
961
lptr[0] += (hptr[0] + hptr[1] + 2) >> 2;
962
++lptr;
963
++hptr;
964
}
965
if (parity != (numcols & 1)) {
966
lptr[0] += (hptr[0] + 1) >> 1;
967
}
968
969
} else {
970
971
if (parity) {
972
lptr = &a[0];
973
lptr[0] <<= 1;
974
}
975
976
}
977
978
}
979
980
void jpc_ft_fwdlift_col(jpc_fix_t *a, int numrows, int stride, int parity)
981
{
982
983
jpc_fix_t *lptr;
984
jpc_fix_t *hptr;
985
#if 0
986
register jpc_fix_t *lptr2;
987
register jpc_fix_t *hptr2;
988
register int i;
989
#endif
990
register int n;
991
int llen;
992
993
llen = (numrows + 1 - parity) >> 1;
994
995
if (numrows > 1) {
996
997
/* Apply the first lifting step. */
998
lptr = &a[0];
999
hptr = &a[llen * stride];
1000
if (parity) {
1001
hptr[0] -= lptr[0];
1002
hptr += stride;
1003
}
1004
n = numrows - llen - parity - (parity == (numrows & 1));
1005
while (n-- > 0) {
1006
hptr[0] -= (lptr[0] + lptr[stride]) >> 1;
1007
hptr += stride;
1008
lptr += stride;
1009
}
1010
if (parity == (numrows & 1)) {
1011
hptr[0] -= lptr[0];
1012
}
1013
1014
/* Apply the second lifting step. */
1015
lptr = &a[0];
1016
hptr = &a[llen * stride];
1017
if (!parity) {
1018
lptr[0] += (hptr[0] + 1) >> 1;
1019
lptr += stride;
1020
}
1021
n = llen - (!parity) - (parity != (numrows & 1));
1022
while (n-- > 0) {
1023
lptr[0] += (hptr[0] + hptr[stride] + 2) >> 2;
1024
lptr += stride;
1025
hptr += stride;
1026
}
1027
if (parity != (numrows & 1)) {
1028
lptr[0] += (hptr[0] + 1) >> 1;
1029
}
1030
1031
} else {
1032
1033
if (parity) {
1034
lptr = &a[0];
1035
lptr[0] <<= 1;
1036
}
1037
1038
}
1039
1040
}
1041
1042
void jpc_ft_fwdlift_colgrp(jpc_fix_t *a, int numrows, int stride, int parity)
1043
{
1044
1045
jpc_fix_t *lptr;
1046
jpc_fix_t *hptr;
1047
register jpc_fix_t *lptr2;
1048
register jpc_fix_t *hptr2;
1049
register int n;
1050
register int i;
1051
int llen;
1052
1053
llen = (numrows + 1 - parity) >> 1;
1054
1055
if (numrows > 1) {
1056
1057
/* Apply the first lifting step. */
1058
lptr = &a[0];
1059
hptr = &a[llen * stride];
1060
if (parity) {
1061
lptr2 = lptr;
1062
hptr2 = hptr;
1063
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1064
hptr2[0] -= lptr2[0];
1065
++hptr2;
1066
++lptr2;
1067
}
1068
hptr += stride;
1069
}
1070
n = numrows - llen - parity - (parity == (numrows & 1));
1071
while (n-- > 0) {
1072
lptr2 = lptr;
1073
hptr2 = hptr;
1074
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1075
hptr2[0] -= (lptr2[0] + lptr2[stride]) >> 1;
1076
++lptr2;
1077
++hptr2;
1078
}
1079
hptr += stride;
1080
lptr += stride;
1081
}
1082
if (parity == (numrows & 1)) {
1083
lptr2 = lptr;
1084
hptr2 = hptr;
1085
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1086
hptr2[0] -= lptr2[0];
1087
++lptr2;
1088
++hptr2;
1089
}
1090
}
1091
1092
/* Apply the second lifting step. */
1093
lptr = &a[0];
1094
hptr = &a[llen * stride];
1095
if (!parity) {
1096
lptr2 = lptr;
1097
hptr2 = hptr;
1098
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1099
lptr2[0] += (hptr2[0] + 1) >> 1;
1100
++lptr2;
1101
++hptr2;
1102
}
1103
lptr += stride;
1104
}
1105
n = llen - (!parity) - (parity != (numrows & 1));
1106
while (n-- > 0) {
1107
lptr2 = lptr;
1108
hptr2 = hptr;
1109
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1110
lptr2[0] += (hptr2[0] + hptr2[stride] + 2) >> 2;
1111
++lptr2;
1112
++hptr2;
1113
}
1114
lptr += stride;
1115
hptr += stride;
1116
}
1117
if (parity != (numrows & 1)) {
1118
lptr2 = lptr;
1119
hptr2 = hptr;
1120
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1121
lptr2[0] += (hptr2[0] + 1) >> 1;
1122
++lptr2;
1123
++hptr2;
1124
}
1125
}
1126
1127
} else {
1128
1129
if (parity) {
1130
lptr2 = &a[0];
1131
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1132
lptr2[0] <<= 1;
1133
++lptr2;
1134
}
1135
}
1136
1137
}
1138
1139
}
1140
1141
void jpc_ft_fwdlift_colres(jpc_fix_t *a, int numrows, int numcols, int stride,
1142
int parity)
1143
{
1144
1145
jpc_fix_t *lptr;
1146
jpc_fix_t *hptr;
1147
register jpc_fix_t *lptr2;
1148
register jpc_fix_t *hptr2;
1149
register int n;
1150
register int i;
1151
int llen;
1152
1153
llen = (numrows + 1 - parity) >> 1;
1154
1155
if (numrows > 1) {
1156
1157
/* Apply the first lifting step. */
1158
lptr = &a[0];
1159
hptr = &a[llen * stride];
1160
if (parity) {
1161
lptr2 = lptr;
1162
hptr2 = hptr;
1163
for (i = 0; i < numcols; ++i) {
1164
hptr2[0] -= lptr2[0];
1165
++hptr2;
1166
++lptr2;
1167
}
1168
hptr += stride;
1169
}
1170
n = numrows - llen - parity - (parity == (numrows & 1));
1171
while (n-- > 0) {
1172
lptr2 = lptr;
1173
hptr2 = hptr;
1174
for (i = 0; i < numcols; ++i) {
1175
hptr2[0] -= (lptr2[0] + lptr2[stride]) >> 1;
1176
++lptr2;
1177
++hptr2;
1178
}
1179
hptr += stride;
1180
lptr += stride;
1181
}
1182
if (parity == (numrows & 1)) {
1183
lptr2 = lptr;
1184
hptr2 = hptr;
1185
for (i = 0; i < numcols; ++i) {
1186
hptr2[0] -= lptr2[0];
1187
++lptr2;
1188
++hptr2;
1189
}
1190
}
1191
1192
/* Apply the second lifting step. */
1193
lptr = &a[0];
1194
hptr = &a[llen * stride];
1195
if (!parity) {
1196
lptr2 = lptr;
1197
hptr2 = hptr;
1198
for (i = 0; i < numcols; ++i) {
1199
lptr2[0] += (hptr2[0] + 1) >> 1;
1200
++lptr2;
1201
++hptr2;
1202
}
1203
lptr += stride;
1204
}
1205
n = llen - (!parity) - (parity != (numrows & 1));
1206
while (n-- > 0) {
1207
lptr2 = lptr;
1208
hptr2 = hptr;
1209
for (i = 0; i < numcols; ++i) {
1210
lptr2[0] += (hptr2[0] + hptr2[stride] + 2) >> 2;
1211
++lptr2;
1212
++hptr2;
1213
}
1214
lptr += stride;
1215
hptr += stride;
1216
}
1217
if (parity != (numrows & 1)) {
1218
lptr2 = lptr;
1219
hptr2 = hptr;
1220
for (i = 0; i < numcols; ++i) {
1221
lptr2[0] += (hptr2[0] + 1) >> 1;
1222
++lptr2;
1223
++hptr2;
1224
}
1225
}
1226
1227
} else {
1228
1229
if (parity) {
1230
lptr2 = &a[0];
1231
for (i = 0; i < numcols; ++i) {
1232
lptr2[0] <<= 1;
1233
++lptr2;
1234
}
1235
}
1236
1237
}
1238
1239
}
1240
1241
void jpc_ft_invlift_row(jpc_fix_t *a, int numcols, int parity)
1242
{
1243
1244
register jpc_fix_t *lptr;
1245
register jpc_fix_t *hptr;
1246
register int n;
1247
int llen;
1248
1249
llen = (numcols + 1 - parity) >> 1;
1250
1251
if (numcols > 1) {
1252
1253
/* Apply the first lifting step. */
1254
lptr = &a[0];
1255
hptr = &a[llen];
1256
if (!parity) {
1257
lptr[0] -= (hptr[0] + 1) >> 1;
1258
++lptr;
1259
}
1260
n = llen - (!parity) - (parity != (numcols & 1));
1261
while (n-- > 0) {
1262
lptr[0] -= (hptr[0] + hptr[1] + 2) >> 2;
1263
++lptr;
1264
++hptr;
1265
}
1266
if (parity != (numcols & 1)) {
1267
lptr[0] -= (hptr[0] + 1) >> 1;
1268
}
1269
1270
/* Apply the second lifting step. */
1271
lptr = &a[0];
1272
hptr = &a[llen];
1273
if (parity) {
1274
hptr[0] += lptr[0];
1275
++hptr;
1276
}
1277
n = numcols - llen - parity - (parity == (numcols & 1));
1278
while (n-- > 0) {
1279
hptr[0] += (lptr[0] + lptr[1]) >> 1;
1280
++hptr;
1281
++lptr;
1282
}
1283
if (parity == (numcols & 1)) {
1284
hptr[0] += lptr[0];
1285
}
1286
1287
} else {
1288
1289
if (parity) {
1290
lptr = &a[0];
1291
lptr[0] >>= 1;
1292
}
1293
1294
}
1295
1296
}
1297
1298
void jpc_ft_invlift_col(jpc_fix_t *a, int numrows, int stride, int parity)
1299
{
1300
1301
jpc_fix_t *lptr;
1302
jpc_fix_t *hptr;
1303
#if 0
1304
register jpc_fix_t *lptr2;
1305
register jpc_fix_t *hptr2;
1306
register int i;
1307
#endif
1308
register int n;
1309
int llen;
1310
1311
llen = (numrows + 1 - parity) >> 1;
1312
1313
if (numrows > 1) {
1314
1315
/* Apply the first lifting step. */
1316
lptr = &a[0];
1317
hptr = &a[llen * stride];
1318
if (!parity) {
1319
lptr[0] -= (hptr[0] + 1) >> 1;
1320
lptr += stride;
1321
}
1322
n = llen - (!parity) - (parity != (numrows & 1));
1323
while (n-- > 0) {
1324
lptr[0] -= (hptr[0] + hptr[stride] + 2) >> 2;
1325
lptr += stride;
1326
hptr += stride;
1327
}
1328
if (parity != (numrows & 1)) {
1329
lptr[0] -= (hptr[0] + 1) >> 1;
1330
}
1331
1332
/* Apply the second lifting step. */
1333
lptr = &a[0];
1334
hptr = &a[llen * stride];
1335
if (parity) {
1336
hptr[0] += lptr[0];
1337
hptr += stride;
1338
}
1339
n = numrows - llen - parity - (parity == (numrows & 1));
1340
while (n-- > 0) {
1341
hptr[0] += (lptr[0] + lptr[stride]) >> 1;
1342
hptr += stride;
1343
lptr += stride;
1344
}
1345
if (parity == (numrows & 1)) {
1346
hptr[0] += lptr[0];
1347
}
1348
1349
} else {
1350
1351
if (parity) {
1352
lptr = &a[0];
1353
lptr[0] >>= 1;
1354
}
1355
1356
}
1357
1358
}
1359
1360
void jpc_ft_invlift_colgrp(jpc_fix_t *a, int numrows, int stride, int parity)
1361
{
1362
1363
jpc_fix_t *lptr;
1364
jpc_fix_t *hptr;
1365
register jpc_fix_t *lptr2;
1366
register jpc_fix_t *hptr2;
1367
register int n;
1368
register int i;
1369
int llen;
1370
1371
llen = (numrows + 1 - parity) >> 1;
1372
1373
if (numrows > 1) {
1374
1375
/* Apply the first lifting step. */
1376
lptr = &a[0];
1377
hptr = &a[llen * stride];
1378
if (!parity) {
1379
lptr2 = lptr;
1380
hptr2 = hptr;
1381
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1382
lptr2[0] -= (hptr2[0] + 1) >> 1;
1383
++lptr2;
1384
++hptr2;
1385
}
1386
lptr += stride;
1387
}
1388
n = llen - (!parity) - (parity != (numrows & 1));
1389
while (n-- > 0) {
1390
lptr2 = lptr;
1391
hptr2 = hptr;
1392
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1393
lptr2[0] -= (hptr2[0] + hptr2[stride] + 2) >> 2;
1394
++lptr2;
1395
++hptr2;
1396
}
1397
lptr += stride;
1398
hptr += stride;
1399
}
1400
if (parity != (numrows & 1)) {
1401
lptr2 = lptr;
1402
hptr2 = hptr;
1403
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1404
lptr2[0] -= (hptr2[0] + 1) >> 1;
1405
++lptr2;
1406
++hptr2;
1407
}
1408
}
1409
1410
/* Apply the second lifting step. */
1411
lptr = &a[0];
1412
hptr = &a[llen * stride];
1413
if (parity) {
1414
lptr2 = lptr;
1415
hptr2 = hptr;
1416
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1417
hptr2[0] += lptr2[0];
1418
++hptr2;
1419
++lptr2;
1420
}
1421
hptr += stride;
1422
}
1423
n = numrows - llen - parity - (parity == (numrows & 1));
1424
while (n-- > 0) {
1425
lptr2 = lptr;
1426
hptr2 = hptr;
1427
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1428
hptr2[0] += (lptr2[0] + lptr2[stride]) >> 1;
1429
++lptr2;
1430
++hptr2;
1431
}
1432
hptr += stride;
1433
lptr += stride;
1434
}
1435
if (parity == (numrows & 1)) {
1436
lptr2 = lptr;
1437
hptr2 = hptr;
1438
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1439
hptr2[0] += lptr2[0];
1440
++lptr2;
1441
++hptr2;
1442
}
1443
}
1444
1445
} else {
1446
1447
if (parity) {
1448
lptr2 = &a[0];
1449
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1450
lptr2[0] >>= 1;
1451
++lptr2;
1452
}
1453
}
1454
1455
}
1456
1457
}
1458
1459
void jpc_ft_invlift_colres(jpc_fix_t *a, int numrows, int numcols, int stride,
1460
int parity)
1461
{
1462
1463
jpc_fix_t *lptr;
1464
jpc_fix_t *hptr;
1465
register jpc_fix_t *lptr2;
1466
register jpc_fix_t *hptr2;
1467
register int n;
1468
register int i;
1469
int llen;
1470
1471
llen = (numrows + 1 - parity) >> 1;
1472
1473
if (numrows > 1) {
1474
1475
/* Apply the first lifting step. */
1476
lptr = &a[0];
1477
hptr = &a[llen * stride];
1478
if (!parity) {
1479
lptr2 = lptr;
1480
hptr2 = hptr;
1481
for (i = 0; i < numcols; ++i) {
1482
lptr2[0] -= (hptr2[0] + 1) >> 1;
1483
++lptr2;
1484
++hptr2;
1485
}
1486
lptr += stride;
1487
}
1488
n = llen - (!parity) - (parity != (numrows & 1));
1489
while (n-- > 0) {
1490
lptr2 = lptr;
1491
hptr2 = hptr;
1492
for (i = 0; i < numcols; ++i) {
1493
lptr2[0] -= (hptr2[0] + hptr2[stride] + 2) >> 2;
1494
++lptr2;
1495
++hptr2;
1496
}
1497
lptr += stride;
1498
hptr += stride;
1499
}
1500
if (parity != (numrows & 1)) {
1501
lptr2 = lptr;
1502
hptr2 = hptr;
1503
for (i = 0; i < numcols; ++i) {
1504
lptr2[0] -= (hptr2[0] + 1) >> 1;
1505
++lptr2;
1506
++hptr2;
1507
}
1508
}
1509
1510
/* Apply the second lifting step. */
1511
lptr = &a[0];
1512
hptr = &a[llen * stride];
1513
if (parity) {
1514
lptr2 = lptr;
1515
hptr2 = hptr;
1516
for (i = 0; i < numcols; ++i) {
1517
hptr2[0] += lptr2[0];
1518
++hptr2;
1519
++lptr2;
1520
}
1521
hptr += stride;
1522
}
1523
n = numrows - llen - parity - (parity == (numrows & 1));
1524
while (n-- > 0) {
1525
lptr2 = lptr;
1526
hptr2 = hptr;
1527
for (i = 0; i < numcols; ++i) {
1528
hptr2[0] += (lptr2[0] + lptr2[stride]) >> 1;
1529
++lptr2;
1530
++hptr2;
1531
}
1532
hptr += stride;
1533
lptr += stride;
1534
}
1535
if (parity == (numrows & 1)) {
1536
lptr2 = lptr;
1537
hptr2 = hptr;
1538
for (i = 0; i < numcols; ++i) {
1539
hptr2[0] += lptr2[0];
1540
++lptr2;
1541
++hptr2;
1542
}
1543
}
1544
1545
} else {
1546
1547
if (parity) {
1548
lptr2 = &a[0];
1549
for (i = 0; i < numcols; ++i) {
1550
lptr2[0] >>= 1;
1551
++lptr2;
1552
}
1553
}
1554
1555
}
1556
1557
}
1558
1559
int jpc_ft_analyze(jpc_fix_t *a, int xstart, int ystart, int width, int height,
1560
int stride)
1561
{
1562
int numrows = height;
1563
int numcols = width;
1564
int rowparity = ystart & 1;
1565
int colparity = xstart & 1;
1566
int i;
1567
jpc_fix_t *startptr;
1568
int maxcols;
1569
1570
maxcols = (numcols / JPC_QMFB_COLGRPSIZE) * JPC_QMFB_COLGRPSIZE;
1571
startptr = &a[0];
1572
for (i = 0; i < maxcols; i += JPC_QMFB_COLGRPSIZE) {
1573
jpc_qmfb_split_colgrp(startptr, numrows, stride, rowparity);
1574
jpc_ft_fwdlift_colgrp(startptr, numrows, stride, rowparity);
1575
startptr += JPC_QMFB_COLGRPSIZE;
1576
}
1577
if (maxcols < numcols) {
1578
jpc_qmfb_split_colres(startptr, numrows, numcols - maxcols, stride,
1579
rowparity);
1580
jpc_ft_fwdlift_colres(startptr, numrows, numcols - maxcols, stride,
1581
rowparity);
1582
}
1583
1584
startptr = &a[0];
1585
for (i = 0; i < numrows; ++i) {
1586
jpc_qmfb_split_row(startptr, numcols, colparity);
1587
jpc_ft_fwdlift_row(startptr, numcols, colparity);
1588
startptr += stride;
1589
}
1590
1591
return 0;
1592
1593
}
1594
1595
int jpc_ft_synthesize(int *a, int xstart, int ystart, int width, int height,
1596
int stride)
1597
{
1598
int numrows = height;
1599
int numcols = width;
1600
int rowparity = ystart & 1;
1601
int colparity = xstart & 1;
1602
1603
int maxcols;
1604
jpc_fix_t *startptr;
1605
int i;
1606
1607
startptr = &a[0];
1608
for (i = 0; i < numrows; ++i) {
1609
jpc_ft_invlift_row(startptr, numcols, colparity);
1610
jpc_qmfb_join_row(startptr, numcols, colparity);
1611
startptr += stride;
1612
}
1613
1614
maxcols = (numcols / JPC_QMFB_COLGRPSIZE) * JPC_QMFB_COLGRPSIZE;
1615
startptr = &a[0];
1616
for (i = 0; i < maxcols; i += JPC_QMFB_COLGRPSIZE) {
1617
jpc_ft_invlift_colgrp(startptr, numrows, stride, rowparity);
1618
jpc_qmfb_join_colgrp(startptr, numrows, stride, rowparity);
1619
startptr += JPC_QMFB_COLGRPSIZE;
1620
}
1621
if (maxcols < numcols) {
1622
jpc_ft_invlift_colres(startptr, numrows, numcols - maxcols, stride,
1623
rowparity);
1624
jpc_qmfb_join_colres(startptr, numrows, numcols - maxcols, stride,
1625
rowparity);
1626
}
1627
1628
return 0;
1629
1630
}
1631
1632
/******************************************************************************\
1633
* 9/7 transform
1634
\******************************************************************************/
1635
1636
#define ALPHA (-1.586134342059924)
1637
#define BETA (-0.052980118572961)
1638
#define GAMMA (0.882911075530934)
1639
#define DELTA (0.443506852043971)
1640
#define LGAIN (1.0 / 1.23017410558578)
1641
#define HGAIN (1.0 / 1.62578613134411)
1642
1643
void jpc_ns_fwdlift_row(jpc_fix_t *a, int numcols, int parity)
1644
{
1645
1646
register jpc_fix_t *lptr;
1647
register jpc_fix_t *hptr;
1648
register int n;
1649
int llen;
1650
1651
llen = (numcols + 1 - parity) >> 1;
1652
1653
if (numcols > 1) {
1654
1655
/* Apply the first lifting step. */
1656
lptr = &a[0];
1657
hptr = &a[llen];
1658
if (parity) {
1659
jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
1660
lptr[0]));
1661
++hptr;
1662
}
1663
n = numcols - llen - parity - (parity == (numcols & 1));
1664
while (n-- > 0) {
1665
jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
1666
jpc_fix_add(lptr[0], lptr[1])));
1667
++hptr;
1668
++lptr;
1669
}
1670
if (parity == (numcols & 1)) {
1671
jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
1672
lptr[0]));
1673
}
1674
1675
/* Apply the second lifting step. */
1676
lptr = &a[0];
1677
hptr = &a[llen];
1678
if (!parity) {
1679
jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
1680
hptr[0]));
1681
++lptr;
1682
}
1683
n = llen - (!parity) - (parity != (numcols & 1));
1684
while (n-- > 0) {
1685
jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(BETA),
1686
jpc_fix_add(hptr[0], hptr[1])));
1687
++lptr;
1688
++hptr;
1689
}
1690
if (parity != (numcols & 1)) {
1691
jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
1692
hptr[0]));
1693
}
1694
1695
/* Apply the third lifting step. */
1696
lptr = &a[0];
1697
hptr = &a[llen];
1698
if (parity) {
1699
jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
1700
lptr[0]));
1701
++hptr;
1702
}
1703
n = numcols - llen - parity - (parity == (numcols & 1));
1704
while (n-- > 0) {
1705
jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
1706
jpc_fix_add(lptr[0], lptr[1])));
1707
++hptr;
1708
++lptr;
1709
}
1710
if (parity == (numcols & 1)) {
1711
jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
1712
lptr[0]));
1713
}
1714
1715
/* Apply the fourth lifting step. */
1716
lptr = &a[0];
1717
hptr = &a[llen];
1718
if (!parity) {
1719
jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
1720
hptr[0]));
1721
++lptr;
1722
}
1723
n = llen - (!parity) - (parity != (numcols & 1));
1724
while (n-- > 0) {
1725
jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(DELTA),
1726
jpc_fix_add(hptr[0], hptr[1])));
1727
++lptr;
1728
++hptr;
1729
}
1730
if (parity != (numcols & 1)) {
1731
jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
1732
hptr[0]));
1733
}
1734
1735
/* Apply the scaling step. */
1736
#if defined(WT_DOSCALE)
1737
lptr = &a[0];
1738
n = llen;
1739
while (n-- > 0) {
1740
lptr[0] = jpc_fix_mul(lptr[0], jpc_dbltofix(LGAIN));
1741
++lptr;
1742
}
1743
hptr = &a[llen];
1744
n = numcols - llen;
1745
while (n-- > 0) {
1746
hptr[0] = jpc_fix_mul(hptr[0], jpc_dbltofix(HGAIN));
1747
++hptr;
1748
}
1749
#endif
1750
1751
} else {
1752
1753
#if defined(WT_LENONE)
1754
if (parity) {
1755
lptr = &a[0];
1756
lptr[0] <<= 1;
1757
}
1758
#endif
1759
1760
}
1761
1762
}
1763
1764
void jpc_ns_fwdlift_colgrp(jpc_fix_t *a, int numrows, int stride,
1765
int parity)
1766
{
1767
1768
jpc_fix_t *lptr;
1769
jpc_fix_t *hptr;
1770
register jpc_fix_t *lptr2;
1771
register jpc_fix_t *hptr2;
1772
register int n;
1773
register int i;
1774
int llen;
1775
1776
llen = (numrows + 1 - parity) >> 1;
1777
1778
if (numrows > 1) {
1779
1780
/* Apply the first lifting step. */
1781
lptr = &a[0];
1782
hptr = &a[llen * stride];
1783
if (parity) {
1784
lptr2 = lptr;
1785
hptr2 = hptr;
1786
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1787
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
1788
lptr2[0]));
1789
++hptr2;
1790
++lptr2;
1791
}
1792
hptr += stride;
1793
}
1794
n = numrows - llen - parity - (parity == (numrows & 1));
1795
while (n-- > 0) {
1796
lptr2 = lptr;
1797
hptr2 = hptr;
1798
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1799
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
1800
jpc_fix_add(lptr2[0], lptr2[stride])));
1801
++lptr2;
1802
++hptr2;
1803
}
1804
hptr += stride;
1805
lptr += stride;
1806
}
1807
if (parity == (numrows & 1)) {
1808
lptr2 = lptr;
1809
hptr2 = hptr;
1810
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1811
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
1812
lptr2[0]));
1813
++lptr2;
1814
++hptr2;
1815
}
1816
}
1817
1818
/* Apply the second lifting step. */
1819
lptr = &a[0];
1820
hptr = &a[llen * stride];
1821
if (!parity) {
1822
lptr2 = lptr;
1823
hptr2 = hptr;
1824
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1825
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
1826
hptr2[0]));
1827
++lptr2;
1828
++hptr2;
1829
}
1830
lptr += stride;
1831
}
1832
n = llen - (!parity) - (parity != (numrows & 1));
1833
while (n-- > 0) {
1834
lptr2 = lptr;
1835
hptr2 = hptr;
1836
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1837
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(BETA),
1838
jpc_fix_add(hptr2[0], hptr2[stride])));
1839
++lptr2;
1840
++hptr2;
1841
}
1842
lptr += stride;
1843
hptr += stride;
1844
}
1845
if (parity != (numrows & 1)) {
1846
lptr2 = lptr;
1847
hptr2 = hptr;
1848
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1849
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
1850
hptr2[0]));
1851
++lptr2;
1852
++hptr2;
1853
}
1854
}
1855
1856
/* Apply the third lifting step. */
1857
lptr = &a[0];
1858
hptr = &a[llen * stride];
1859
if (parity) {
1860
lptr2 = lptr;
1861
hptr2 = hptr;
1862
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1863
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
1864
lptr2[0]));
1865
++hptr2;
1866
++lptr2;
1867
}
1868
hptr += stride;
1869
}
1870
n = numrows - llen - parity - (parity == (numrows & 1));
1871
while (n-- > 0) {
1872
lptr2 = lptr;
1873
hptr2 = hptr;
1874
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1875
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
1876
jpc_fix_add(lptr2[0], lptr2[stride])));
1877
++lptr2;
1878
++hptr2;
1879
}
1880
hptr += stride;
1881
lptr += stride;
1882
}
1883
if (parity == (numrows & 1)) {
1884
lptr2 = lptr;
1885
hptr2 = hptr;
1886
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1887
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
1888
lptr2[0]));
1889
++lptr2;
1890
++hptr2;
1891
}
1892
}
1893
1894
/* Apply the fourth lifting step. */
1895
lptr = &a[0];
1896
hptr = &a[llen * stride];
1897
if (!parity) {
1898
lptr2 = lptr;
1899
hptr2 = hptr;
1900
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1901
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
1902
hptr2[0]));
1903
++lptr2;
1904
++hptr2;
1905
}
1906
lptr += stride;
1907
}
1908
n = llen - (!parity) - (parity != (numrows & 1));
1909
while (n-- > 0) {
1910
lptr2 = lptr;
1911
hptr2 = hptr;
1912
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1913
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(DELTA),
1914
jpc_fix_add(hptr2[0], hptr2[stride])));
1915
++lptr2;
1916
++hptr2;
1917
}
1918
lptr += stride;
1919
hptr += stride;
1920
}
1921
if (parity != (numrows & 1)) {
1922
lptr2 = lptr;
1923
hptr2 = hptr;
1924
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1925
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
1926
hptr2[0]));
1927
++lptr2;
1928
++hptr2;
1929
}
1930
}
1931
1932
/* Apply the scaling step. */
1933
#if defined(WT_DOSCALE)
1934
lptr = &a[0];
1935
n = llen;
1936
while (n-- > 0) {
1937
lptr2 = lptr;
1938
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1939
lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(LGAIN));
1940
++lptr2;
1941
}
1942
lptr += stride;
1943
}
1944
hptr = &a[llen * stride];
1945
n = numrows - llen;
1946
while (n-- > 0) {
1947
hptr2 = hptr;
1948
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1949
hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(HGAIN));
1950
++hptr2;
1951
}
1952
hptr += stride;
1953
}
1954
#endif
1955
1956
} else {
1957
1958
#if defined(WT_LENONE)
1959
if (parity) {
1960
lptr2 = &a[0];
1961
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
1962
lptr2[0] <<= 1;
1963
++lptr2;
1964
}
1965
}
1966
#endif
1967
1968
}
1969
1970
}
1971
1972
void jpc_ns_fwdlift_colres(jpc_fix_t *a, int numrows, int numcols,
1973
int stride, int parity)
1974
{
1975
1976
jpc_fix_t *lptr;
1977
jpc_fix_t *hptr;
1978
register jpc_fix_t *lptr2;
1979
register jpc_fix_t *hptr2;
1980
register int n;
1981
register int i;
1982
int llen;
1983
1984
llen = (numrows + 1 - parity) >> 1;
1985
1986
if (numrows > 1) {
1987
1988
/* Apply the first lifting step. */
1989
lptr = &a[0];
1990
hptr = &a[llen * stride];
1991
if (parity) {
1992
lptr2 = lptr;
1993
hptr2 = hptr;
1994
for (i = 0; i < numcols; ++i) {
1995
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
1996
lptr2[0]));
1997
++hptr2;
1998
++lptr2;
1999
}
2000
hptr += stride;
2001
}
2002
n = numrows - llen - parity - (parity == (numrows & 1));
2003
while (n-- > 0) {
2004
lptr2 = lptr;
2005
hptr2 = hptr;
2006
for (i = 0; i < numcols; ++i) {
2007
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
2008
jpc_fix_add(lptr2[0], lptr2[stride])));
2009
++lptr2;
2010
++hptr2;
2011
}
2012
hptr += stride;
2013
lptr += stride;
2014
}
2015
if (parity == (numrows & 1)) {
2016
lptr2 = lptr;
2017
hptr2 = hptr;
2018
for (i = 0; i < numcols; ++i) {
2019
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
2020
lptr2[0]));
2021
++lptr2;
2022
++hptr2;
2023
}
2024
}
2025
2026
/* Apply the second lifting step. */
2027
lptr = &a[0];
2028
hptr = &a[llen * stride];
2029
if (!parity) {
2030
lptr2 = lptr;
2031
hptr2 = hptr;
2032
for (i = 0; i < numcols; ++i) {
2033
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2034
hptr2[0]));
2035
++lptr2;
2036
++hptr2;
2037
}
2038
lptr += stride;
2039
}
2040
n = llen - (!parity) - (parity != (numrows & 1));
2041
while (n-- > 0) {
2042
lptr2 = lptr;
2043
hptr2 = hptr;
2044
for (i = 0; i < numcols; ++i) {
2045
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(BETA),
2046
jpc_fix_add(hptr2[0], hptr2[stride])));
2047
++lptr2;
2048
++hptr2;
2049
}
2050
lptr += stride;
2051
hptr += stride;
2052
}
2053
if (parity != (numrows & 1)) {
2054
lptr2 = lptr;
2055
hptr2 = hptr;
2056
for (i = 0; i < numcols; ++i) {
2057
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2058
hptr2[0]));
2059
++lptr2;
2060
++hptr2;
2061
}
2062
}
2063
2064
/* Apply the third lifting step. */
2065
lptr = &a[0];
2066
hptr = &a[llen * stride];
2067
if (parity) {
2068
lptr2 = lptr;
2069
hptr2 = hptr;
2070
for (i = 0; i < numcols; ++i) {
2071
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
2072
lptr2[0]));
2073
++hptr2;
2074
++lptr2;
2075
}
2076
hptr += stride;
2077
}
2078
n = numrows - llen - parity - (parity == (numrows & 1));
2079
while (n-- > 0) {
2080
lptr2 = lptr;
2081
hptr2 = hptr;
2082
for (i = 0; i < numcols; ++i) {
2083
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
2084
jpc_fix_add(lptr2[0], lptr2[stride])));
2085
++lptr2;
2086
++hptr2;
2087
}
2088
hptr += stride;
2089
lptr += stride;
2090
}
2091
if (parity == (numrows & 1)) {
2092
lptr2 = lptr;
2093
hptr2 = hptr;
2094
for (i = 0; i < numcols; ++i) {
2095
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
2096
lptr2[0]));
2097
++lptr2;
2098
++hptr2;
2099
}
2100
}
2101
2102
/* Apply the fourth lifting step. */
2103
lptr = &a[0];
2104
hptr = &a[llen * stride];
2105
if (!parity) {
2106
lptr2 = lptr;
2107
hptr2 = hptr;
2108
for (i = 0; i < numcols; ++i) {
2109
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
2110
hptr2[0]));
2111
++lptr2;
2112
++hptr2;
2113
}
2114
lptr += stride;
2115
}
2116
n = llen - (!parity) - (parity != (numrows & 1));
2117
while (n-- > 0) {
2118
lptr2 = lptr;
2119
hptr2 = hptr;
2120
for (i = 0; i < numcols; ++i) {
2121
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(DELTA),
2122
jpc_fix_add(hptr2[0], hptr2[stride])));
2123
++lptr2;
2124
++hptr2;
2125
}
2126
lptr += stride;
2127
hptr += stride;
2128
}
2129
if (parity != (numrows & 1)) {
2130
lptr2 = lptr;
2131
hptr2 = hptr;
2132
for (i = 0; i < numcols; ++i) {
2133
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
2134
hptr2[0]));
2135
++lptr2;
2136
++hptr2;
2137
}
2138
}
2139
2140
/* Apply the scaling step. */
2141
#if defined(WT_DOSCALE)
2142
lptr = &a[0];
2143
n = llen;
2144
while (n-- > 0) {
2145
lptr2 = lptr;
2146
for (i = 0; i < numcols; ++i) {
2147
lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(LGAIN));
2148
++lptr2;
2149
}
2150
lptr += stride;
2151
}
2152
hptr = &a[llen * stride];
2153
n = numrows - llen;
2154
while (n-- > 0) {
2155
hptr2 = hptr;
2156
for (i = 0; i < numcols; ++i) {
2157
hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(HGAIN));
2158
++hptr2;
2159
}
2160
hptr += stride;
2161
}
2162
#endif
2163
2164
} else {
2165
2166
#if defined(WT_LENONE)
2167
if (parity) {
2168
lptr2 = &a[0];
2169
for (i = 0; i < numcols; ++i) {
2170
lptr2[0] <<= 1;
2171
++lptr2;
2172
}
2173
}
2174
#endif
2175
2176
}
2177
2178
}
2179
2180
void jpc_ns_fwdlift_col(jpc_fix_t *a, int numrows, int stride,
2181
int parity)
2182
{
2183
2184
jpc_fix_t *lptr;
2185
jpc_fix_t *hptr;
2186
register jpc_fix_t *lptr2;
2187
register jpc_fix_t *hptr2;
2188
register int n;
2189
int llen;
2190
2191
llen = (numrows + 1 - parity) >> 1;
2192
2193
if (numrows > 1) {
2194
2195
/* Apply the first lifting step. */
2196
lptr = &a[0];
2197
hptr = &a[llen * stride];
2198
if (parity) {
2199
lptr2 = lptr;
2200
hptr2 = hptr;
2201
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
2202
lptr2[0]));
2203
++hptr2;
2204
++lptr2;
2205
hptr += stride;
2206
}
2207
n = numrows - llen - parity - (parity == (numrows & 1));
2208
while (n-- > 0) {
2209
lptr2 = lptr;
2210
hptr2 = hptr;
2211
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
2212
jpc_fix_add(lptr2[0], lptr2[stride])));
2213
++lptr2;
2214
++hptr2;
2215
hptr += stride;
2216
lptr += stride;
2217
}
2218
if (parity == (numrows & 1)) {
2219
lptr2 = lptr;
2220
hptr2 = hptr;
2221
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
2222
lptr2[0]));
2223
++lptr2;
2224
++hptr2;
2225
}
2226
2227
/* Apply the second lifting step. */
2228
lptr = &a[0];
2229
hptr = &a[llen * stride];
2230
if (!parity) {
2231
lptr2 = lptr;
2232
hptr2 = hptr;
2233
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2234
hptr2[0]));
2235
++lptr2;
2236
++hptr2;
2237
lptr += stride;
2238
}
2239
n = llen - (!parity) - (parity != (numrows & 1));
2240
while (n-- > 0) {
2241
lptr2 = lptr;
2242
hptr2 = hptr;
2243
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(BETA),
2244
jpc_fix_add(hptr2[0], hptr2[stride])));
2245
++lptr2;
2246
++hptr2;
2247
lptr += stride;
2248
hptr += stride;
2249
}
2250
if (parity != (numrows & 1)) {
2251
lptr2 = lptr;
2252
hptr2 = hptr;
2253
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2254
hptr2[0]));
2255
++lptr2;
2256
++hptr2;
2257
}
2258
2259
/* Apply the third lifting step. */
2260
lptr = &a[0];
2261
hptr = &a[llen * stride];
2262
if (parity) {
2263
lptr2 = lptr;
2264
hptr2 = hptr;
2265
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
2266
lptr2[0]));
2267
++hptr2;
2268
++lptr2;
2269
hptr += stride;
2270
}
2271
n = numrows - llen - parity - (parity == (numrows & 1));
2272
while (n-- > 0) {
2273
lptr2 = lptr;
2274
hptr2 = hptr;
2275
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
2276
jpc_fix_add(lptr2[0], lptr2[stride])));
2277
++lptr2;
2278
++hptr2;
2279
hptr += stride;
2280
lptr += stride;
2281
}
2282
if (parity == (numrows & 1)) {
2283
lptr2 = lptr;
2284
hptr2 = hptr;
2285
jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
2286
lptr2[0]));
2287
++lptr2;
2288
++hptr2;
2289
}
2290
2291
/* Apply the fourth lifting step. */
2292
lptr = &a[0];
2293
hptr = &a[llen * stride];
2294
if (!parity) {
2295
lptr2 = lptr;
2296
hptr2 = hptr;
2297
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
2298
hptr2[0]));
2299
++lptr2;
2300
++hptr2;
2301
lptr += stride;
2302
}
2303
n = llen - (!parity) - (parity != (numrows & 1));
2304
while (n-- > 0) {
2305
lptr2 = lptr;
2306
hptr2 = hptr;
2307
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(DELTA),
2308
jpc_fix_add(hptr2[0], hptr2[stride])));
2309
++lptr2;
2310
++hptr2;
2311
lptr += stride;
2312
hptr += stride;
2313
}
2314
if (parity != (numrows & 1)) {
2315
lptr2 = lptr;
2316
hptr2 = hptr;
2317
jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
2318
hptr2[0]));
2319
++lptr2;
2320
++hptr2;
2321
}
2322
2323
/* Apply the scaling step. */
2324
#if defined(WT_DOSCALE)
2325
lptr = &a[0];
2326
n = llen;
2327
while (n-- > 0) {
2328
lptr2 = lptr;
2329
lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(LGAIN));
2330
++lptr2;
2331
lptr += stride;
2332
}
2333
hptr = &a[llen * stride];
2334
n = numrows - llen;
2335
while (n-- > 0) {
2336
hptr2 = hptr;
2337
hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(HGAIN));
2338
++hptr2;
2339
hptr += stride;
2340
}
2341
#endif
2342
2343
} else {
2344
2345
#if defined(WT_LENONE)
2346
if (parity) {
2347
lptr2 = &a[0];
2348
lptr2[0] <<= 1;
2349
++lptr2;
2350
}
2351
#endif
2352
2353
}
2354
2355
}
2356
2357
void jpc_ns_invlift_row(jpc_fix_t *a, int numcols, int parity)
2358
{
2359
2360
register jpc_fix_t *lptr;
2361
register jpc_fix_t *hptr;
2362
register int n;
2363
int llen;
2364
2365
llen = (numcols + 1 - parity) >> 1;
2366
2367
if (numcols > 1) {
2368
2369
/* Apply the scaling step. */
2370
#if defined(WT_DOSCALE)
2371
lptr = &a[0];
2372
n = llen;
2373
while (n-- > 0) {
2374
lptr[0] = jpc_fix_mul(lptr[0], jpc_dbltofix(1.0 / LGAIN));
2375
++lptr;
2376
}
2377
hptr = &a[llen];
2378
n = numcols - llen;
2379
while (n-- > 0) {
2380
hptr[0] = jpc_fix_mul(hptr[0], jpc_dbltofix(1.0 / HGAIN));
2381
++hptr;
2382
}
2383
#endif
2384
2385
/* Apply the first lifting step. */
2386
lptr = &a[0];
2387
hptr = &a[llen];
2388
if (!parity) {
2389
jpc_fix_minuseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
2390
hptr[0]));
2391
++lptr;
2392
}
2393
n = llen - (!parity) - (parity != (numcols & 1));
2394
while (n-- > 0) {
2395
jpc_fix_minuseq(lptr[0], jpc_fix_mul(jpc_dbltofix(DELTA),
2396
jpc_fix_add(hptr[0], hptr[1])));
2397
++lptr;
2398
++hptr;
2399
}
2400
if (parity != (numcols & 1)) {
2401
jpc_fix_minuseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
2402
hptr[0]));
2403
}
2404
2405
/* Apply the second lifting step. */
2406
lptr = &a[0];
2407
hptr = &a[llen];
2408
if (parity) {
2409
jpc_fix_minuseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
2410
lptr[0]));
2411
++hptr;
2412
}
2413
n = numcols - llen - parity - (parity == (numcols & 1));
2414
while (n-- > 0) {
2415
jpc_fix_minuseq(hptr[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
2416
jpc_fix_add(lptr[0], lptr[1])));
2417
++hptr;
2418
++lptr;
2419
}
2420
if (parity == (numcols & 1)) {
2421
jpc_fix_minuseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
2422
lptr[0]));
2423
}
2424
2425
/* Apply the third lifting step. */
2426
lptr = &a[0];
2427
hptr = &a[llen];
2428
if (!parity) {
2429
jpc_fix_minuseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2430
hptr[0]));
2431
++lptr;
2432
}
2433
n = llen - (!parity) - (parity != (numcols & 1));
2434
while (n-- > 0) {
2435
jpc_fix_minuseq(lptr[0], jpc_fix_mul(jpc_dbltofix(BETA),
2436
jpc_fix_add(hptr[0], hptr[1])));
2437
++lptr;
2438
++hptr;
2439
}
2440
if (parity != (numcols & 1)) {
2441
jpc_fix_minuseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2442
hptr[0]));
2443
}
2444
2445
/* Apply the fourth lifting step. */
2446
lptr = &a[0];
2447
hptr = &a[llen];
2448
if (parity) {
2449
jpc_fix_minuseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
2450
lptr[0]));
2451
++hptr;
2452
}
2453
n = numcols - llen - parity - (parity == (numcols & 1));
2454
while (n-- > 0) {
2455
jpc_fix_minuseq(hptr[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
2456
jpc_fix_add(lptr[0], lptr[1])));
2457
++hptr;
2458
++lptr;
2459
}
2460
if (parity == (numcols & 1)) {
2461
jpc_fix_minuseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
2462
lptr[0]));
2463
}
2464
2465
} else {
2466
2467
#if defined(WT_LENONE)
2468
if (parity) {
2469
lptr = &a[0];
2470
lptr[0] >>= 1;
2471
}
2472
#endif
2473
2474
}
2475
2476
}
2477
2478
void jpc_ns_invlift_colgrp(jpc_fix_t *a, int numrows, int stride,
2479
int parity)
2480
{
2481
2482
jpc_fix_t *lptr;
2483
jpc_fix_t *hptr;
2484
register jpc_fix_t *lptr2;
2485
register jpc_fix_t *hptr2;
2486
register int n;
2487
register int i;
2488
int llen;
2489
2490
llen = (numrows + 1 - parity) >> 1;
2491
2492
if (numrows > 1) {
2493
2494
/* Apply the scaling step. */
2495
#if defined(WT_DOSCALE)
2496
lptr = &a[0];
2497
n = llen;
2498
while (n-- > 0) {
2499
lptr2 = lptr;
2500
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2501
lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(1.0 / LGAIN));
2502
++lptr2;
2503
}
2504
lptr += stride;
2505
}
2506
hptr = &a[llen * stride];
2507
n = numrows - llen;
2508
while (n-- > 0) {
2509
hptr2 = hptr;
2510
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2511
hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(1.0 / HGAIN));
2512
++hptr2;
2513
}
2514
hptr += stride;
2515
}
2516
#endif
2517
2518
/* Apply the first lifting step. */
2519
lptr = &a[0];
2520
hptr = &a[llen * stride];
2521
if (!parity) {
2522
lptr2 = lptr;
2523
hptr2 = hptr;
2524
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2525
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2526
DELTA), hptr2[0]));
2527
++lptr2;
2528
++hptr2;
2529
}
2530
lptr += stride;
2531
}
2532
n = llen - (!parity) - (parity != (numrows & 1));
2533
while (n-- > 0) {
2534
lptr2 = lptr;
2535
hptr2 = hptr;
2536
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2537
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(DELTA),
2538
jpc_fix_add(hptr2[0], hptr2[stride])));
2539
++lptr2;
2540
++hptr2;
2541
}
2542
lptr += stride;
2543
hptr += stride;
2544
}
2545
if (parity != (numrows & 1)) {
2546
lptr2 = lptr;
2547
hptr2 = hptr;
2548
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2549
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2550
DELTA), hptr2[0]));
2551
++lptr2;
2552
++hptr2;
2553
}
2554
}
2555
2556
/* Apply the second lifting step. */
2557
lptr = &a[0];
2558
hptr = &a[llen * stride];
2559
if (parity) {
2560
lptr2 = lptr;
2561
hptr2 = hptr;
2562
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2563
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2564
GAMMA), lptr2[0]));
2565
++hptr2;
2566
++lptr2;
2567
}
2568
hptr += stride;
2569
}
2570
n = numrows - llen - parity - (parity == (numrows & 1));
2571
while (n-- > 0) {
2572
lptr2 = lptr;
2573
hptr2 = hptr;
2574
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2575
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
2576
jpc_fix_add(lptr2[0], lptr2[stride])));
2577
++lptr2;
2578
++hptr2;
2579
}
2580
hptr += stride;
2581
lptr += stride;
2582
}
2583
if (parity == (numrows & 1)) {
2584
lptr2 = lptr;
2585
hptr2 = hptr;
2586
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2587
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2588
GAMMA), lptr2[0]));
2589
++lptr2;
2590
++hptr2;
2591
}
2592
}
2593
2594
/* Apply the third lifting step. */
2595
lptr = &a[0];
2596
hptr = &a[llen * stride];
2597
if (!parity) {
2598
lptr2 = lptr;
2599
hptr2 = hptr;
2600
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2601
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2602
hptr2[0]));
2603
++lptr2;
2604
++hptr2;
2605
}
2606
lptr += stride;
2607
}
2608
n = llen - (!parity) - (parity != (numrows & 1));
2609
while (n-- > 0) {
2610
lptr2 = lptr;
2611
hptr2 = hptr;
2612
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2613
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(BETA),
2614
jpc_fix_add(hptr2[0], hptr2[stride])));
2615
++lptr2;
2616
++hptr2;
2617
}
2618
lptr += stride;
2619
hptr += stride;
2620
}
2621
if (parity != (numrows & 1)) {
2622
lptr2 = lptr;
2623
hptr2 = hptr;
2624
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2625
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2626
hptr2[0]));
2627
++lptr2;
2628
++hptr2;
2629
}
2630
}
2631
2632
/* Apply the fourth lifting step. */
2633
lptr = &a[0];
2634
hptr = &a[llen * stride];
2635
if (parity) {
2636
lptr2 = lptr;
2637
hptr2 = hptr;
2638
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2639
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2640
ALPHA), lptr2[0]));
2641
++hptr2;
2642
++lptr2;
2643
}
2644
hptr += stride;
2645
}
2646
n = numrows - llen - parity - (parity == (numrows & 1));
2647
while (n-- > 0) {
2648
lptr2 = lptr;
2649
hptr2 = hptr;
2650
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2651
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
2652
jpc_fix_add(lptr2[0], lptr2[stride])));
2653
++lptr2;
2654
++hptr2;
2655
}
2656
hptr += stride;
2657
lptr += stride;
2658
}
2659
if (parity == (numrows & 1)) {
2660
lptr2 = lptr;
2661
hptr2 = hptr;
2662
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2663
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2664
ALPHA), lptr2[0]));
2665
++lptr2;
2666
++hptr2;
2667
}
2668
}
2669
2670
} else {
2671
2672
#if defined(WT_LENONE)
2673
if (parity) {
2674
lptr2 = &a[0];
2675
for (i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {
2676
lptr2[0] >>= 1;
2677
++lptr2;
2678
}
2679
}
2680
#endif
2681
2682
}
2683
2684
}
2685
2686
void jpc_ns_invlift_colres(jpc_fix_t *a, int numrows, int numcols,
2687
int stride, int parity)
2688
{
2689
2690
jpc_fix_t *lptr;
2691
jpc_fix_t *hptr;
2692
register jpc_fix_t *lptr2;
2693
register jpc_fix_t *hptr2;
2694
register int n;
2695
register int i;
2696
int llen;
2697
2698
llen = (numrows + 1 - parity) >> 1;
2699
2700
if (numrows > 1) {
2701
2702
/* Apply the scaling step. */
2703
#if defined(WT_DOSCALE)
2704
lptr = &a[0];
2705
n = llen;
2706
while (n-- > 0) {
2707
lptr2 = lptr;
2708
for (i = 0; i < numcols; ++i) {
2709
lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(1.0 / LGAIN));
2710
++lptr2;
2711
}
2712
lptr += stride;
2713
}
2714
hptr = &a[llen * stride];
2715
n = numrows - llen;
2716
while (n-- > 0) {
2717
hptr2 = hptr;
2718
for (i = 0; i < numcols; ++i) {
2719
hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(1.0 / HGAIN));
2720
++hptr2;
2721
}
2722
hptr += stride;
2723
}
2724
#endif
2725
2726
/* Apply the first lifting step. */
2727
lptr = &a[0];
2728
hptr = &a[llen * stride];
2729
if (!parity) {
2730
lptr2 = lptr;
2731
hptr2 = hptr;
2732
for (i = 0; i < numcols; ++i) {
2733
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2734
DELTA), hptr2[0]));
2735
++lptr2;
2736
++hptr2;
2737
}
2738
lptr += stride;
2739
}
2740
n = llen - (!parity) - (parity != (numrows & 1));
2741
while (n-- > 0) {
2742
lptr2 = lptr;
2743
hptr2 = hptr;
2744
for (i = 0; i < numcols; ++i) {
2745
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(DELTA),
2746
jpc_fix_add(hptr2[0], hptr2[stride])));
2747
++lptr2;
2748
++hptr2;
2749
}
2750
lptr += stride;
2751
hptr += stride;
2752
}
2753
if (parity != (numrows & 1)) {
2754
lptr2 = lptr;
2755
hptr2 = hptr;
2756
for (i = 0; i < numcols; ++i) {
2757
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2758
DELTA), hptr2[0]));
2759
++lptr2;
2760
++hptr2;
2761
}
2762
}
2763
2764
/* Apply the second lifting step. */
2765
lptr = &a[0];
2766
hptr = &a[llen * stride];
2767
if (parity) {
2768
lptr2 = lptr;
2769
hptr2 = hptr;
2770
for (i = 0; i < numcols; ++i) {
2771
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2772
GAMMA), lptr2[0]));
2773
++hptr2;
2774
++lptr2;
2775
}
2776
hptr += stride;
2777
}
2778
n = numrows - llen - parity - (parity == (numrows & 1));
2779
while (n-- > 0) {
2780
lptr2 = lptr;
2781
hptr2 = hptr;
2782
for (i = 0; i < numcols; ++i) {
2783
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
2784
jpc_fix_add(lptr2[0], lptr2[stride])));
2785
++lptr2;
2786
++hptr2;
2787
}
2788
hptr += stride;
2789
lptr += stride;
2790
}
2791
if (parity == (numrows & 1)) {
2792
lptr2 = lptr;
2793
hptr2 = hptr;
2794
for (i = 0; i < numcols; ++i) {
2795
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2796
GAMMA), lptr2[0]));
2797
++lptr2;
2798
++hptr2;
2799
}
2800
}
2801
2802
/* Apply the third lifting step. */
2803
lptr = &a[0];
2804
hptr = &a[llen * stride];
2805
if (!parity) {
2806
lptr2 = lptr;
2807
hptr2 = hptr;
2808
for (i = 0; i < numcols; ++i) {
2809
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2810
hptr2[0]));
2811
++lptr2;
2812
++hptr2;
2813
}
2814
lptr += stride;
2815
}
2816
n = llen - (!parity) - (parity != (numrows & 1));
2817
while (n-- > 0) {
2818
lptr2 = lptr;
2819
hptr2 = hptr;
2820
for (i = 0; i < numcols; ++i) {
2821
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(BETA),
2822
jpc_fix_add(hptr2[0], hptr2[stride])));
2823
++lptr2;
2824
++hptr2;
2825
}
2826
lptr += stride;
2827
hptr += stride;
2828
}
2829
if (parity != (numrows & 1)) {
2830
lptr2 = lptr;
2831
hptr2 = hptr;
2832
for (i = 0; i < numcols; ++i) {
2833
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
2834
hptr2[0]));
2835
++lptr2;
2836
++hptr2;
2837
}
2838
}
2839
2840
/* Apply the fourth lifting step. */
2841
lptr = &a[0];
2842
hptr = &a[llen * stride];
2843
if (parity) {
2844
lptr2 = lptr;
2845
hptr2 = hptr;
2846
for (i = 0; i < numcols; ++i) {
2847
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2848
ALPHA), lptr2[0]));
2849
++hptr2;
2850
++lptr2;
2851
}
2852
hptr += stride;
2853
}
2854
n = numrows - llen - parity - (parity == (numrows & 1));
2855
while (n-- > 0) {
2856
lptr2 = lptr;
2857
hptr2 = hptr;
2858
for (i = 0; i < numcols; ++i) {
2859
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
2860
jpc_fix_add(lptr2[0], lptr2[stride])));
2861
++lptr2;
2862
++hptr2;
2863
}
2864
hptr += stride;
2865
lptr += stride;
2866
}
2867
if (parity == (numrows & 1)) {
2868
lptr2 = lptr;
2869
hptr2 = hptr;
2870
for (i = 0; i < numcols; ++i) {
2871
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2872
ALPHA), lptr2[0]));
2873
++lptr2;
2874
++hptr2;
2875
}
2876
}
2877
2878
} else {
2879
2880
#if defined(WT_LENONE)
2881
if (parity) {
2882
lptr2 = &a[0];
2883
for (i = 0; i < numcols; ++i) {
2884
lptr2[0] >>= 1;
2885
++lptr2;
2886
}
2887
}
2888
#endif
2889
2890
}
2891
2892
}
2893
2894
void jpc_ns_invlift_col(jpc_fix_t *a, int numrows, int stride,
2895
int parity)
2896
{
2897
2898
jpc_fix_t *lptr;
2899
jpc_fix_t *hptr;
2900
register jpc_fix_t *lptr2;
2901
register jpc_fix_t *hptr2;
2902
register int n;
2903
int llen;
2904
2905
llen = (numrows + 1 - parity) >> 1;
2906
2907
if (numrows > 1) {
2908
2909
/* Apply the scaling step. */
2910
#if defined(WT_DOSCALE)
2911
lptr = &a[0];
2912
n = llen;
2913
while (n-- > 0) {
2914
lptr2 = lptr;
2915
lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(1.0 / LGAIN));
2916
++lptr2;
2917
lptr += stride;
2918
}
2919
hptr = &a[llen * stride];
2920
n = numrows - llen;
2921
while (n-- > 0) {
2922
hptr2 = hptr;
2923
hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(1.0 / HGAIN));
2924
++hptr2;
2925
hptr += stride;
2926
}
2927
#endif
2928
2929
/* Apply the first lifting step. */
2930
lptr = &a[0];
2931
hptr = &a[llen * stride];
2932
if (!parity) {
2933
lptr2 = lptr;
2934
hptr2 = hptr;
2935
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2936
DELTA), hptr2[0]));
2937
++lptr2;
2938
++hptr2;
2939
lptr += stride;
2940
}
2941
n = llen - (!parity) - (parity != (numrows & 1));
2942
while (n-- > 0) {
2943
lptr2 = lptr;
2944
hptr2 = hptr;
2945
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(DELTA),
2946
jpc_fix_add(hptr2[0], hptr2[stride])));
2947
++lptr2;
2948
++hptr2;
2949
lptr += stride;
2950
hptr += stride;
2951
}
2952
if (parity != (numrows & 1)) {
2953
lptr2 = lptr;
2954
hptr2 = hptr;
2955
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2956
DELTA), hptr2[0]));
2957
++lptr2;
2958
++hptr2;
2959
}
2960
2961
/* Apply the second lifting step. */
2962
lptr = &a[0];
2963
hptr = &a[llen * stride];
2964
if (parity) {
2965
lptr2 = lptr;
2966
hptr2 = hptr;
2967
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2968
GAMMA), lptr2[0]));
2969
++hptr2;
2970
++lptr2;
2971
hptr += stride;
2972
}
2973
n = numrows - llen - parity - (parity == (numrows & 1));
2974
while (n-- > 0) {
2975
lptr2 = lptr;
2976
hptr2 = hptr;
2977
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
2978
jpc_fix_add(lptr2[0], lptr2[stride])));
2979
++lptr2;
2980
++hptr2;
2981
hptr += stride;
2982
lptr += stride;
2983
}
2984
if (parity == (numrows & 1)) {
2985
lptr2 = lptr;
2986
hptr2 = hptr;
2987
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
2988
GAMMA), lptr2[0]));
2989
++lptr2;
2990
++hptr2;
2991
}
2992
2993
/* Apply the third lifting step. */
2994
lptr = &a[0];
2995
hptr = &a[llen * stride];
2996
if (!parity) {
2997
lptr2 = lptr;
2998
hptr2 = hptr;
2999
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
3000
hptr2[0]));
3001
++lptr2;
3002
++hptr2;
3003
lptr += stride;
3004
}
3005
n = llen - (!parity) - (parity != (numrows & 1));
3006
while (n-- > 0) {
3007
lptr2 = lptr;
3008
hptr2 = hptr;
3009
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(BETA),
3010
jpc_fix_add(hptr2[0], hptr2[stride])));
3011
++lptr2;
3012
++hptr2;
3013
lptr += stride;
3014
hptr += stride;
3015
}
3016
if (parity != (numrows & 1)) {
3017
lptr2 = lptr;
3018
hptr2 = hptr;
3019
jpc_fix_minuseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
3020
hptr2[0]));
3021
++lptr2;
3022
++hptr2;
3023
}
3024
3025
/* Apply the fourth lifting step. */
3026
lptr = &a[0];
3027
hptr = &a[llen * stride];
3028
if (parity) {
3029
lptr2 = lptr;
3030
hptr2 = hptr;
3031
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
3032
ALPHA), lptr2[0]));
3033
++hptr2;
3034
++lptr2;
3035
hptr += stride;
3036
}
3037
n = numrows - llen - parity - (parity == (numrows & 1));
3038
while (n-- > 0) {
3039
lptr2 = lptr;
3040
hptr2 = hptr;
3041
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
3042
jpc_fix_add(lptr2[0], lptr2[stride])));
3043
++lptr2;
3044
++hptr2;
3045
hptr += stride;
3046
lptr += stride;
3047
}
3048
if (parity == (numrows & 1)) {
3049
lptr2 = lptr;
3050
hptr2 = hptr;
3051
jpc_fix_minuseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 *
3052
ALPHA), lptr2[0]));
3053
++lptr2;
3054
++hptr2;
3055
}
3056
3057
} else {
3058
3059
#if defined(WT_LENONE)
3060
if (parity) {
3061
lptr2 = &a[0];
3062
lptr2[0] >>= 1;
3063
++lptr2;
3064
}
3065
#endif
3066
3067
}
3068
3069
}
3070
3071
int jpc_ns_analyze(jpc_fix_t *a, int xstart, int ystart, int width, int height,
3072
int stride)
3073
{
3074
3075
int numrows = height;
3076
int numcols = width;
3077
int rowparity = ystart & 1;
3078
int colparity = xstart & 1;
3079
int i;
3080
jpc_fix_t *startptr;
3081
int maxcols;
3082
3083
maxcols = (numcols / JPC_QMFB_COLGRPSIZE) * JPC_QMFB_COLGRPSIZE;
3084
startptr = &a[0];
3085
for (i = 0; i < maxcols; i += JPC_QMFB_COLGRPSIZE) {
3086
jpc_qmfb_split_colgrp(startptr, numrows, stride, rowparity);
3087
jpc_ns_fwdlift_colgrp(startptr, numrows, stride, rowparity);
3088
startptr += JPC_QMFB_COLGRPSIZE;
3089
}
3090
if (maxcols < numcols) {
3091
jpc_qmfb_split_colres(startptr, numrows, numcols - maxcols, stride,
3092
rowparity);
3093
jpc_ns_fwdlift_colres(startptr, numrows, numcols - maxcols, stride,
3094
rowparity);
3095
}
3096
3097
startptr = &a[0];
3098
for (i = 0; i < numrows; ++i) {
3099
jpc_qmfb_split_row(startptr, numcols, colparity);
3100
jpc_ns_fwdlift_row(startptr, numcols, colparity);
3101
startptr += stride;
3102
}
3103
3104
return 0;
3105
3106
}
3107
3108
int jpc_ns_synthesize(jpc_fix_t *a, int xstart, int ystart, int width,
3109
int height, int stride)
3110
{
3111
3112
int numrows = height;
3113
int numcols = width;
3114
int rowparity = ystart & 1;
3115
int colparity = xstart & 1;
3116
int maxcols;
3117
jpc_fix_t *startptr;
3118
int i;
3119
3120
startptr = &a[0];
3121
for (i = 0; i < numrows; ++i) {
3122
jpc_ns_invlift_row(startptr, numcols, colparity);
3123
jpc_qmfb_join_row(startptr, numcols, colparity);
3124
startptr += stride;
3125
}
3126
3127
maxcols = (numcols / JPC_QMFB_COLGRPSIZE) * JPC_QMFB_COLGRPSIZE;
3128
startptr = &a[0];
3129
for (i = 0; i < maxcols; i += JPC_QMFB_COLGRPSIZE) {
3130
jpc_ns_invlift_colgrp(startptr, numrows, stride, rowparity);
3131
jpc_qmfb_join_colgrp(startptr, numrows, stride, rowparity);
3132
startptr += JPC_QMFB_COLGRPSIZE;
3133
}
3134
if (maxcols < numcols) {
3135
jpc_ns_invlift_colres(startptr, numrows, numcols - maxcols, stride,
3136
rowparity);
3137
jpc_qmfb_join_colres(startptr, numrows, numcols - maxcols, stride,
3138
rowparity);
3139
}
3140
3141
return 0;
3142
3143
}
3144
Loggerhead is a web-based interface for Breezy
Version: 2.0.1