/home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/medialib/awt

Bug Summary

File:	jdk/src/java.desktop/share/native/libawt/awt/medialib/awt_ImagingLib.c
Warning:	line 3752, column 39 The right operand of '<<' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name awt_ImagingLib.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -D __MEDIALIB_OLD_NAMES -D __USE_J2D_NAMES -D MLIB_NO_LIBSUNMATH -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/libawt -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/common/awt/debug -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/common/awt -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.desktop -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/image -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/image/cvutils -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/libawt/java2d -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/java2d -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/java2d/loops -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/java2d/pipe -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.base -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/medialib -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/common/awt/medialib -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libmlib_image -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/include -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/include -I /home/daniel/Projects/java/jdk/src/java.base/linux/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/include -I /home/daniel/Projects/java/jdk/src/java.base/share/native/include -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused -Wno-sign-compare -Wno-unused-result -Wno-maybe-uninitialized -Wno-format-nonliteral -Wno-parentheses -Wno-unused-value -Wno-unused-function -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility default -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/medialib/awt_ImagingLib.c
1/*
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.  Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include "sun_awt_image_ImagingLib.h"
30#include "java_awt_Transparency.h"
31#include "java_awt_image_AffineTransformOp.h"
32#include "java_awt_image_BufferedImage.h"
33#include "java_awt_color_ColorSpace.h"
34#include "java_awt_image_ConvolveOp.h"
35#include "sun_awt_image_IntegerComponentRaster.h"
36#include "awt_ImagingLib.h"
37#include "awt_parseImage.h"
38#include "imageInitIDs.h"
39#include <jni.h>
40#include <jni_util.h>
41#include <assert.h>
42#include "awt_Mlib.h"
43#include "gdefs.h"
44#include "safe_alloc.h"
45#include "safe_math.h"

47/***************************************************************************
*                               Definitions                               *
***************************************************************************/
50#define jio_fprintffprintf fprintf

52#ifndef TRUE(1)
53#define TRUE(1) 1
54#endif /* TRUE */

56#ifndef FALSE(0)
57#define FALSE(0) 0
58#endif /* FALSE */

60#define TYPE_CUSTOM0L         java_awt_image_BufferedImage_TYPE_CUSTOM0L
61#define TYPE_INT_RGB1L        java_awt_image_BufferedImage_TYPE_INT_RGB1L
62#define TYPE_INT_ARGB2L       java_awt_image_BufferedImage_TYPE_INT_ARGB2L
63#define TYPE_INT_ARGB_PRE3L   java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE3L
64#define TYPE_INT_BGR4L        java_awt_image_BufferedImage_TYPE_INT_BGR4L
65#define TYPE_4BYTE_ABGR6L     java_awt_image_BufferedImage_TYPE_4BYTE_ABGR6L
66#define TYPE_4BYTE_ABGR_PRE7L java_awt_image_BufferedImage_TYPE_4BYTE_ABGR_PRE7L

68/* (alpha*color)>>nbits + alpha>>(nbits-1) */
69#define BLEND(color, alpha, alphaNbits)((((alpha)*(color))>>(alphaNbits)) + ((alpha) >> (
(alphaNbits)-1))) \
  ((((alpha)*(color))>>(alphaNbits)) + ((alpha) >> ((alphaNbits)-1)))

  /* ((color - (alpha>>(nBits-1)))<<nBits)/alpha */
73#define UNBLEND(color, alpha, alphaNbits)((((color)-((alpha)>>((alphaNbits)-1)))<<(alphaNbits
))/(alpha)) \
  ((((color)-((alpha)>>((alphaNbits)-1)))<<(alphaNbits))/(alpha))

76/* Enumeration of all of the mlib functions used */
77typedef enum {
  MLIB_CONVMxN,
  MLIB_AFFINE,
  MLIB_LOOKUP,
  MLIB_CONVKERNCVT
82} mlibTypeE_t;

84typedef struct {
  int dataType;           /* One of BYTE_DATA_TYPE, SHORT_DATA_TYPE, */
  int needToCopy;
  int cvtSrcToDefault;    /* If TRUE, convert the src to def CM (pre?) */
  int allocDefaultDst;    /* If TRUE, alloc def CM dst buffer */
  int cvtToDst;           /* If TRUE, convert dst buffer to Dst CM */
  int addAlpha;
91} mlibHintS_t;

93/***************************************************************************
*                     Static Variables/Structures                         *
***************************************************************************/

97static mlibSysFnS_t sMlibSysFns = {
  NULL((void*)0), // placeholder for j2d_mlib_ImageCreate
  NULL((void*)0), // placeholder for j2d_mlib_ImageCreateStruct
  NULL((void*)0), // placeholder for j2d_mlib_ImageDelete
101};

103static mlibFnS_t sMlibFns[] = {
  {NULL((void*)0), "j2d_mlib_ImageConvMxN"},
  {NULL((void*)0), "j2d_mlib_ImageAffine"},
  {NULL((void*)0), "j2d_mlib_ImageLookUp"},
  {NULL((void*)0), "j2d_mlib_ImageConvKernelConvert"},
  {NULL((void*)0), NULL((void*)0)},
109};

111static int s_timeIt = 0;
112static int s_printIt = 0;
113static int s_startOff = 0;
114static int s_nomlib = 0;

116/***************************************************************************
*                          Static Function Prototypes                     *
***************************************************************************/

120static int
121allocateArray(JNIEnv *env, BufImageS_t *imageP,
            mlib_image **mlibImagePP, void **dataPP, int isSrc,
            int cvtToDefault, int addAlpha);
124static int
125allocateRasterArray(JNIEnv *env, RasterS_t *rasterP,
                  mlib_image **mlibImagePP, void **dataPP, int isSrc);

128static void
129freeArray(JNIEnv *env, BufImageS_t *srcimageP, mlib_image *srcmlibImP,
        void *srcdataP, BufImageS_t *dstimageP, mlib_image *dstmlibImP,
        void *dstdataP);
132static void
133freeDataArray(JNIEnv *env, jobject srcJdata, mlib_image *srcmlibImP,
        void *srcdataP, jobject dstJdata, mlib_image *dstmlibImP,
        void *dstdataP);

137static int
138storeImageArray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
              mlib_image *mlibImP);

141static int
142storeRasterArray(JNIEnv *env, RasterS_t *srcP, RasterS_t *dstP,
              mlib_image *mlibImP);

145static int
146storeICMarray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
            mlib_image *mlibImP);

149static int
150colorMatch(int r, int g, int b, int a, unsigned char *argb, int numColors);

152static int
153setImageHints(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
            int expandICM, int useAlpha,
            int premultiply, mlibHintS_t *hintP);


158static int expandICM(JNIEnv *env, BufImageS_t *imageP, unsigned int *mDataP);
159static int expandPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,
                         unsigned char *outDataP);
161static int expandPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,
                         unsigned char *outDataP);
163static int expandPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,
                         unsigned char *outDataP);
165static int expandPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,
                                int component, unsigned char *outDataP,
                                int forceAlpha);
168static int expandPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,
                                int component, unsigned char *outDataP,
                                int forceAlpha);
171static int expandPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,
                                int component, unsigned char *outDataP,
                                int forceAlpha);
174static int setPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,
                      unsigned char *outDataP);
176static int setPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,
                      unsigned char *outDataP);
178static int setPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,
                      unsigned char *outDataP);
180static int setPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,
                             int component, unsigned char *outDataP,
                             int supportsAlpha);
183static int setPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,
                             int component, unsigned char *outDataP,
                             int supportsAlpha);
186static int setPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,
                             int component, unsigned char *outDataP,
                             int supportsAlpha);

190mlib_start_timer start_timer = NULL((void*)0);
191mlib_stop_timer stop_timer = NULL((void*)0);

193/***************************************************************************
*                          Debugging Definitions                          *
***************************************************************************/
196#ifdef DEBUG1

198static void
199printMedialibError(int status) {
  switch(status) {
  case MLIB_FAILURE:
      jio_fprintf(stderr, "failure\n")__fprintf_chk (stderr, 2 - 1, "failure\n");
      break;
  case MLIB_NULLPOINTER:
      jio_fprintf(stderr, "null pointer\n")__fprintf_chk (stderr, 2 - 1, "null pointer\n");
      break;
  case MLIB_OUTOFRANGE:
      jio_fprintf (stderr, "out of range\n")__fprintf_chk (stderr, 2 - 1, "out of range\n");
      break;
  default:
      jio_fprintf (stderr, "medialib error\n")__fprintf_chk (stderr, 2 - 1, "medialib error\n");
      break;
  }
214}
215#else /* ! DEBUG */
216#  define printMedialibError(x)

218#endif /* ! DEBUG */

220static int
221getMlibEdgeHint(jint edgeHint) {
  switch (edgeHint) {
  case java_awt_image_ConvolveOp_EDGE_NO_OP1L:
      return MLIB_EDGE_DST_COPY_SRC;
  case java_awt_image_ConvolveOp_EDGE_ZERO_FILL0L:
  default:
      return MLIB_EDGE_DST_FILL_ZERO;
  }
229}

231/*
* We have to make sure that awt_setPixels can be safely applied to the given pair of
* raster and mlib image.
*
* In particular, make sure that
*  - dimension is the same
*  - number of channels in mlib image corresponds to the number of bands in the raster
*  - sample size in image and raster are the same.
*
* Returns:
*  -1 to indicate failure,
*   1 to indicate success
*/
244static int setPixelsFormMlibImage(JNIEnv *env, RasterS_t *rasterP, mlib_image* img) {
  if (rasterP->width != img->width || rasterP->height != img->height) {
      /* dimension does not match */
      return -1;
  }

  if (rasterP->numBands != img->channels) {
      /* number of bands does not match */
      return -1;
  }

  switch (rasterP->dataType) {
  case BYTE_DATA_TYPE1:
      if (img->type != MLIB_BYTE) {
          return -1;
      }
      break;
  case SHORT_DATA_TYPE2:
      if (img->type != MLIB_SHORT && img->type != MLIB_USHORT) {
          return -1;
      }
      break;
  default:
      /* awt_setPixels does not support such rasters */
      return -1;
  }

  return awt_setPixels(env, rasterP, mlib_ImageGetData(img));
272}

274/***************************************************************************
*                          External Functions                             *
***************************************************************************/
277JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
278Java_sun_awt_image_ImagingLib_convolveBI(JNIEnv *env, jobject this,
                                       jobject jsrc, jobject jdst,
                                       jobject jkernel, jint edgeHint)
281{
  void *sdata, *ddata;
  mlib_image *src;
  mlib_image *dst;
  int i, scale;
  mlib_d64 *dkern;
  mlib_s32 *kdata;
  int klen;
  float kmax;
  mlib_s32 cmask;
  mlib_status status;
  int retStatus = 1;
  float *kern;
  BufImageS_t *srcImageP, *dstImageP;
  jobject jdata;
  int kwidth;
  int kheight;
  int w, h;
  int x, y;
  mlibHintS_t hint;
  int nbands;

  /* This function requires a lot of local refs ??? Is 64 enough ??? */
  if ((*env)->EnsureLocalCapacity(env, 64) < 0)
1
Assuming the condition is false→
2
←
Taking false branch→
      return 0;

  if (s_nomlib) return 0;
3
←
Assuming 's_nomlib' is 0→
4
←
Taking false branch→
  if (s_timeIt)     (*start_timer)(3600);
5
←
Assuming 's_timeIt' is 0→
6
←
Taking false branch→

  kwidth  = (*env)->GetIntField(env, jkernel, g_KernelWidthID);
  kheight = (*env)->GetIntField(env, jkernel, g_KernelHeightID);
  jdata = (*env)->GetObjectField(env, jkernel, g_KernelDataID);
  klen  = (*env)->GetArrayLength(env, jdata);
  kern  = (float *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL((void*)0));
  if (kern == NULL((void*)0)) {
7
←
Assuming 'kern' is not equal to NULL→
8
←
Taking false branch→
      /* out of memory exception already thrown */
      return 0;
  }

  if ((kwidth&0x1) == 0) {
9
←
Assuming the condition is true→
10
←
Taking true branch→
      /* Kernel has even width */
      w = kwidth+1;
  }
  else {
      w = kwidth;
  }
  if ((kheight&0x1) == 0) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
      /* Kernel has even height */
      h = kheight+1;
  }
  else {
      h = kheight;
  }

  dkern = NULL((void*)0);
  if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_d64))(((w) > 0) && ((h) > 0) && ((sizeof(mlib_d64
)) > 0) && (((0x7fffffff / (w)) / (h)) > (sizeof
(mlib_d64))))) {
13
←
Assuming 'w' is > 0→
14
←
Assuming 'h' is > 0→
15
←
Assuming the condition is true→
16
←
Taking true branch→
      dkern = (mlib_d64 *)calloc(1, w * h * sizeof(mlib_d64));
  }
  if (dkern == NULL((void*)0)) {
17
←
Assuming 'dkern' is not equal to NULL→
18
←
Taking false branch→
      (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT2);
      return 0;
  }

  /* Need to flip and find max value of the kernel.
   * Also, save the kernel values as mlib_d64 values.
   * The flip is to operate correctly with medialib,
   * which doesn't do the mathemetically correct thing,
   * i.e. it doesn't rotate the kernel by 180 degrees.
   * REMIND: This should perhaps be done at the Java
   * level by ConvolveOp.
   * REMIND: Should the max test be looking at absolute
   * values?
   * REMIND: What if klen != kheight * kwidth?
   */
  kmax = kern[klen-1];
  i = klen-1;
  for (y=0; y18.1
'y' is < 'kheight'
 < kheight; y++) {
19
←
Loop condition is true.  Entering loop body→
22
←
Assuming 'y' is >= 'kheight'→
23
←
Loop condition is false. Execution continues on line 366→
      for (x=0; x < kwidth; x++, i--) {
20
←
Assuming 'x' is >= 'kwidth'→
21
←
Loop condition is false. Execution continues on line 357→
          dkern[y*w+x] = (mlib_d64) kern[i];
          if (kern[i] > kmax) {
              kmax = kern[i];
          }
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT2);

  if (kmax > 1<<16) {
24
←
Assuming the condition is false→
25
←
Taking false branch→
      /* We can only handle 16 bit max */
      free(dkern);
      return 0;
  }


  /* Parse the source image */
  if (awt_parseImage(env, jsrc, &srcImageP, FALSE(0)) <= 0) {
26
←
Assuming the condition is false→
27
←
Taking false branch→
      /* Can't handle any custom images */
      free(dkern);
      return 0;
  }

  /* Parse the destination image */
  if (awt_parseImage(env, jdst, &dstImageP, FALSE(0)) <= 0) {
28
←
Assuming the condition is false→
29
←
Taking false branch→
      /* Can't handle any custom images */
      awt_freeParsedImage(srcImageP, TRUE(1));
      free(dkern);
      return 0;
  }

  nbands = setImageHints(env, srcImageP, dstImageP, TRUE(1), TRUE(1),
                      FALSE(0), &hint);
  if (nbands < 1) {
30
←
Assuming 'nbands' is >= 1→
31
←
Taking false branch→
      /* Can't handle any custom images */
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      free(dkern);
      return 0;
  }
  /* Allocate the arrays */
  if (allocateArray(env, srcImageP, &src, &sdata, TRUE(1),
32
←
Assuming the condition is false→
33
←
Taking false branch→
                    hint.cvtSrcToDefault, hint.addAlpha) < 0) {
      /* Must be some problem */
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      free(dkern);
      return 0;
  }
  if (allocateArray(env, dstImageP, &dst, &ddata, FALSE(0),
34
←
Assuming the condition is false→
35
←
Taking false branch→
                    hint.cvtToDst, FALSE(0)) < 0) {
      /* Must be some problem */
      freeArray(env, srcImageP, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      free(dkern);
      return 0;
  }

  kdata = NULL((void*)0);
  if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_s32))(((w) > 0) && ((h) > 0) && ((sizeof(mlib_s32
)) > 0) && (((0x7fffffff / (w)) / (h)) > (sizeof
(mlib_s32))))) {
36
←
Taking true branch→
      kdata = (mlib_s32 *)malloc(w * h * sizeof(mlib_s32));
  }
  if (kdata == NULL((void*)0)) {
37
←
Assuming 'kdata' is not equal to NULL→
38
←
Taking false branch→
      freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      free(dkern);
      return 0;
  }

  if ((*sMlibFns[MLIB_CONVKERNCVT].fptr)(kdata, &scale, dkern, w, h,
39
←
Assuming the condition is false→
40
←
Taking false branch→
                                  mlib_ImageGetType(src)) != MLIB_SUCCESS) {
      freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      free(dkern);
      free(kdata);
      return 0;
  }

  if (s_printIt) {
41
←
Assuming 's_printIt' is 0→
42
←
Taking false branch→
      fprintf(stderr, "Orig Kernel(len=%d):\n",klen)__fprintf_chk (stderr, 2 - 1, "Orig Kernel(len=%d):\n",klen);
      for (y=kheight-1; y >= 0; y--) {
          for (x=kwidth-1; x >= 0; x--) {
              fprintf(stderr, "%g ", dkern[y*w+x])__fprintf_chk (stderr, 2 - 1, "%g ", dkern[y*w+x]);
          }
          fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
      }
      fprintf(stderr, "New Kernel(scale=%d):\n", scale)__fprintf_chk (stderr, 2 - 1, "New Kernel(scale=%d):\n", scale
);
      for (y=kheight-1; y >= 0; y--) {
          for (x=kwidth-1; x >= 0; x--) {
              fprintf(stderr, "%d ", kdata[y*w+x])__fprintf_chk (stderr, 2 - 1, "%d ", kdata[y*w+x]);
          }
          fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
      }
  }

  cmask = (1<<src->channels)-1;
  status = (*sMlibFns[MLIB_CONVMxN].fptr)(dst, src, kdata, w, h,
                             (w-1)/2, (h-1)/2, scale, cmask,
                             getMlibEdgeHint(edgeHint));

  if (status != MLIB_SUCCESS) {
43
←
Assuming 'status' is equal to MLIB_SUCCESS→
44
←
Taking false branch→
      printMedialibError(status);
      retStatus = 0;
  }

  if (s_printIt) {
45
←
Assuming 's_printIt' is 0→
46
←
Taking false branch→
      unsigned int *dP;
      if (s_startOff != 0) {
          printf("Starting at %d\n", s_startOff)__printf_chk (2 - 1, "Starting at %d\n", s_startOff);
      }
      if (sdata == NULL((void*)0)) {
          dP = (unsigned int *) mlib_ImageGetData(src);
      }
      else {
          dP = (unsigned int *) sdata;
      }
      printf("src is\n")__printf_chk (2 - 1, "src is\n");
      for (i=0; i < 20; i++) {
          printf("%x ",dP[s_startOff+i])__printf_chk (2 - 1, "%x ",dP[s_startOff+i]);
      }
      printf("\n")__printf_chk (2 - 1, "\n");
      if (ddata == NULL((void*)0)) {
          dP = (unsigned int *)mlib_ImageGetData(dst);
      }
      else {
          dP = (unsigned int *) ddata;
      }
      printf("dst is \n")__printf_chk (2 - 1, "dst is \n");
      for (i=0; i < 20; i++) {
          printf("%x ",dP[s_startOff+i])__printf_chk (2 - 1, "%x ",dP[s_startOff+i]);
      }
      printf("\n")__printf_chk (2 - 1, "\n");
  }

  /* Means that we couldn't write directly into the destination buffer */
  if (ddata == NULL((void*)0)) {
47
←
Assuming 'ddata' is equal to NULL→
48
←
Taking true branch→

      /* Need to store it back into the array */
      if (storeImageArray(env, srcImageP, dstImageP, dst) < 0) {
49
←
Calling 'storeImageArray'→
          /* Error */
          retStatus = 0;
      }
  }

  /* Release the pinned memory */
  freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
  awt_freeParsedImage(srcImageP, TRUE(1));
  awt_freeParsedImage(dstImageP, TRUE(1));
  free(dkern);
  free(kdata);

  if (s_timeIt) (*stop_timer)(3600, 1);

  return retStatus;
516}

518JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
519Java_sun_awt_image_ImagingLib_convolveRaster(JNIEnv *env, jobject this,
                                           jobject jsrc, jobject jdst,
                                           jobject jkernel, jint edgeHint)
522{
  mlib_image *src;
  mlib_image *dst;
  int i, scale;
  mlib_d64 *dkern;
  mlib_s32 *kdata;
  int klen;
  float kmax;
  int retStatus = 1;
  mlib_status status;
  mlib_s32 cmask;
  void *sdata;
  void *ddata;
  RasterS_t *srcRasterP;
  RasterS_t *dstRasterP;
  int kwidth;
  int kheight;
  int w, h;
  int x, y;
  jobject jdata;
  float *kern;

  /* This function requires a lot of local refs ??? Is 64 enough ??? */
  if ((*env)->EnsureLocalCapacity(env, 64) < 0)
      return 0;

  if (s_nomlib) return 0;
  if (s_timeIt)     (*start_timer)(3600);

  kwidth  = (*env)->GetIntField(env, jkernel, g_KernelWidthID);
  kheight = (*env)->GetIntField(env, jkernel, g_KernelHeightID);
  jdata = (*env)->GetObjectField(env, jkernel, g_KernelDataID);
  klen  = (*env)->GetArrayLength(env, jdata);
  kern  = (float *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL((void*)0));
  if (kern == NULL((void*)0)) {
      /* out of memory exception already thrown */
      return 0;
  }

  if ((kwidth&0x1) == 0) {
      /* Kernel has even width */
      w = kwidth+1;
  }
  else {
      w = kwidth;
  }
  if ((kheight&0x1) == 0) {
      /* Kernel has even height */
      h = kheight+1;
  }
  else {
      h = kheight;
  }

  dkern = NULL((void*)0);
  if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_d64))(((w) > 0) && ((h) > 0) && ((sizeof(mlib_d64
)) > 0) && (((0x7fffffff / (w)) / (h)) > (sizeof
(mlib_d64))))) {
      dkern = (mlib_d64 *)calloc(1, w * h * sizeof(mlib_d64));
  }
  if (dkern == NULL((void*)0)) {
      (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT2);
      return 0;
  }

  /* Need to flip and find max value of the kernel.
   * Also, save the kernel values as mlib_d64 values.
   * The flip is to operate correctly with medialib,
   * which doesn't do the mathemetically correct thing,
   * i.e. it doesn't rotate the kernel by 180 degrees.
   * REMIND: This should perhaps be done at the Java
   * level by ConvolveOp.
   * REMIND: Should the max test be looking at absolute
   * values?
   * REMIND: What if klen != kheight * kwidth?
   */
  kmax = kern[klen-1];
  i = klen-1;
  for (y=0; y < kheight; y++) {
      for (x=0; x < kwidth; x++, i--) {
          dkern[y*w+x] = (mlib_d64) kern[i];
          if (kern[i] > kmax) {
              kmax = kern[i];
          }
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT2);

  if (kmax > 1<<16) {
      /* We can only handle 16 bit max */
      free(dkern);
      return 0;
  }

  /* Parse the source image */
  if ((srcRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
      JNU_ThrowOutOfMemoryError(env, "Out of memory");
      free(dkern);
      return -1;
  }

  if ((dstRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
      JNU_ThrowOutOfMemoryError(env, "Out of memory");
      free(srcRasterP);
      free(dkern);
      return -1;
  }

  /* Parse the source raster */
  if (awt_parseRaster(env, jsrc, srcRasterP) <= 0) {
      /* Can't handle any custom rasters */
      free(srcRasterP);
      free(dstRasterP);
      free(dkern);
      return 0;
  }

  /* Parse the destination raster */
  if (awt_parseRaster(env, jdst, dstRasterP) <= 0) {
      /* Can't handle any custom images */
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      free(dstRasterP);
      free(dkern);
      return 0;
  }

  /* Allocate the arrays */
  if (allocateRasterArray(env, srcRasterP, &src, &sdata, TRUE(1)) < 0) {
      /* Must be some problem */
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      free(dkern);
      return 0;
  }
  if (allocateRasterArray(env, dstRasterP, &dst, &ddata, FALSE(0)) < 0) {
      /* Must be some problem */
      freeDataArray(env, srcRasterP->jdata, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      free(dkern);
      return 0;
  }

  kdata = NULL((void*)0);
  if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_s32))(((w) > 0) && ((h) > 0) && ((sizeof(mlib_s32
)) > 0) && (((0x7fffffff / (w)) / (h)) > (sizeof
(mlib_s32))))) {
      kdata = (mlib_s32 *)malloc(w * h * sizeof(mlib_s32));
  }
  if (kdata == NULL((void*)0)) {
      freeDataArray(env, srcRasterP->jdata, src, sdata,
                    dstRasterP->jdata, dst, ddata);
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      free(dkern);
      return 0;
  }

  if ((*sMlibFns[MLIB_CONVKERNCVT].fptr)(kdata, &scale, dkern, w, h,
                                  mlib_ImageGetType(src)) != MLIB_SUCCESS) {
      freeDataArray(env, srcRasterP->jdata, src, sdata,
                    dstRasterP->jdata, dst, ddata);
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      free(dkern);
      free(kdata);
      return 0;
  }

  if (s_printIt) {
      fprintf(stderr, "Orig Kernel(len=%d):\n",klen)__fprintf_chk (stderr, 2 - 1, "Orig Kernel(len=%d):\n",klen);
      for (y=kheight-1; y >= 0; y--) {
          for (x=kwidth-1; x >= 0; x--) {
              fprintf(stderr, "%g ", dkern[y*w+x])__fprintf_chk (stderr, 2 - 1, "%g ", dkern[y*w+x]);
          }
          fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
      }
      fprintf(stderr, "New Kernel(scale=%d):\n", scale)__fprintf_chk (stderr, 2 - 1, "New Kernel(scale=%d):\n", scale
);
      for (y=kheight-1; y >= 0; y--) {
          for (x=kwidth-1; x >= 0; x--) {
              fprintf(stderr, "%d ", kdata[y*w+x])__fprintf_chk (stderr, 2 - 1, "%d ", kdata[y*w+x]);
          }
          fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
      }
  }

  cmask = (1<<src->channels)-1;
  status = (*sMlibFns[MLIB_CONVMxN].fptr)(dst, src, kdata, w, h,
                             (w-1)/2, (h-1)/2, scale, cmask,
                             getMlibEdgeHint(edgeHint));

  if (status != MLIB_SUCCESS) {
      printMedialibError(status);
      retStatus = 0;
  }

  if (s_printIt) {
      unsigned int *dP;
      if (s_startOff != 0) {
          printf("Starting at %d\n", s_startOff)__printf_chk (2 - 1, "Starting at %d\n", s_startOff);
      }
      if (sdata == NULL((void*)0)) {
          dP = (unsigned int *) mlib_ImageGetData(src);
      }
      else {
          dP = (unsigned int *) sdata;
      }
      printf("src is\n")__printf_chk (2 - 1, "src is\n");
      for (i=0; i < 20; i++) {
          printf("%x ",dP[s_startOff+i])__printf_chk (2 - 1, "%x ",dP[s_startOff+i]);
      }
      printf("\n")__printf_chk (2 - 1, "\n");
      if (ddata == NULL((void*)0)) {
          dP = (unsigned int *)mlib_ImageGetData(dst);
      }
      else {
          dP = (unsigned int *) ddata;
      }
      printf("dst is\n")__printf_chk (2 - 1, "dst is\n");
      for (i=0; i < 20; i++) {
          printf("%x ",dP[s_startOff+i])__printf_chk (2 - 1, "%x ",dP[s_startOff+i]);
      }
      printf("\n")__printf_chk (2 - 1, "\n");
  }

  /* Means that we couldn't write directly into the destination buffer */
  if (ddata == NULL((void*)0)) {
      if (storeRasterArray(env, srcRasterP, dstRasterP, dst) < 0) {
          retStatus = setPixelsFormMlibImage(env, dstRasterP, dst);
      }
  }

  /* Release the pinned memory */
  freeDataArray(env, srcRasterP->jdata, src, sdata,
                dstRasterP->jdata, dst, ddata);
  awt_freeParsedRaster(srcRasterP, TRUE(1));
  awt_freeParsedRaster(dstRasterP, TRUE(1));
  free(dkern);
  free(kdata);

  if (s_timeIt) (*stop_timer)(3600,1);

  return retStatus;
762}


765JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
766Java_sun_awt_image_ImagingLib_transformBI(JNIEnv *env, jobject this,
                                        jobject jsrc,
                                        jobject jdst,
                                        jdoubleArray jmatrix,
                                        jint interpType)
771{
  mlib_image *src;
  mlib_image *dst;
  int i;
  int j = 0;
  int retStatus = 1;
  mlib_status status;
  double *matrix;
  mlib_d64 mtx[6];
  void *sdata;
  void *ddata;
  BufImageS_t *srcImageP;
  BufImageS_t *dstImageP;
  mlib_filter filter;
  mlibHintS_t hint;
  unsigned int *dP;
  int useIndexed;
  int nbands;

  /* This function requires a lot of local refs ??? Is 64 enough ??? */
  if ((*env)->EnsureLocalCapacity(env, 64) < 0)
      return 0;

  if (s_nomlib) return 0;
  if (s_timeIt) {
      (*start_timer)(3600);
  }

  switch(interpType) {
  case java_awt_image_AffineTransformOp_TYPE_BILINEAR2L:
      filter = MLIB_BILINEAR;
      break;
  case java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR1L:
      filter = MLIB_NEAREST;
      break;
  case java_awt_image_AffineTransformOp_TYPE_BICUBIC3L:
      filter = MLIB_BICUBIC;
      break;
  default:
      JNU_ThrowInternalError(env, "Unknown interpolation type");
      return -1;
  }

  if ((*env)->GetArrayLength(env, jmatrix) < 6) {
      /*
       * Very unlikely, however we should check for this:
       * if given matrix array is too short, we can't handle it
       */
      return 0;
  }

  matrix = (*env)->GetPrimitiveArrayCritical(env, jmatrix, NULL((void*)0));
  if (matrix == NULL((void*)0)) {
      /* out of memory error already thrown */
      return 0;
  }

  /* Check for invalid double value in transformation matrix */
  for (j = 0; j < 6; j++) {

      if (!(IS_FINITE(matrix[j])(((matrix[j]) >= -1.7976931348623157E+308) && ((matrix
[j]) <= 1.7976931348623157E+308)))) {
          (*env)->ReleasePrimitiveArrayCritical(env, jmatrix, matrix, JNI_ABORT2);
          return 0;
      }
  }

  if (s_printIt) {
      printf("matrix is %g %g %g %g %g %g\n", matrix[0], matrix[1],__printf_chk (2 - 1, "matrix is %g %g %g %g %g %g\n", matrix[
0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5])
             matrix[2], matrix[3], matrix[4], matrix[5])__printf_chk (2 - 1, "matrix is %g %g %g %g %g %g\n", matrix[
0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
  }

  mtx[0] = matrix[0];
  mtx[1] = matrix[2];
  mtx[2] = matrix[4];
  mtx[3] = matrix[1];
  mtx[4] = matrix[3];
  mtx[5] = matrix[5];

  (*env)->ReleasePrimitiveArrayCritical(env, jmatrix, matrix, JNI_ABORT2);

  /* Parse the source image */
  if (awt_parseImage(env, jsrc, &srcImageP, FALSE(0)) <= 0) {
      /* Can't handle any custom images */
      return 0;
  }

  /* Parse the destination image */
  if (awt_parseImage(env, jdst, &dstImageP, FALSE(0)) <= 0) {
      /* Can't handle any custom images */
      awt_freeParsedImage(srcImageP, TRUE(1));
      return 0;
  }

  /* REMIND!!  Can't assume that it is the same LUT!! */
  /* Fix 4213160, 4184283 */
  useIndexed = (srcImageP->cmodel.cmType == INDEX_CM_TYPE3 &&
                dstImageP->cmodel.cmType == INDEX_CM_TYPE3 &&
                srcImageP->raster.rasterType == dstImageP->raster.rasterType &&
                srcImageP->raster.rasterType == COMPONENT_RASTER_TYPE1);

  nbands = setImageHints(env, srcImageP, dstImageP, !useIndexed, TRUE(1),
                      FALSE(0), &hint);
  if (nbands < 1) {
      /* Can't handle any custom images */
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      return 0;
  }

  /* Allocate the arrays */
  if (allocateArray(env, srcImageP, &src, &sdata, TRUE(1),
                    hint.cvtSrcToDefault, hint.addAlpha) < 0) {
      /* Must be some problem */
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      return 0;
  }
  if (allocateArray(env, dstImageP, &dst, &ddata, FALSE(0),
                    hint.cvtToDst, FALSE(0)) < 0) {
      /* Must be some problem */
      freeArray(env, srcImageP, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      return 0;
  }
896#if 0
897fprintf(stderr,"Src----------------\n")__fprintf_chk (stderr, 2 - 1, "Src----------------\n");
898fprintf(stderr,"Type : %d\n",src->type)__fprintf_chk (stderr, 2 - 1, "Type : %d\n",src->type);
899fprintf(stderr,"Channels: %d\n",src->channels)__fprintf_chk (stderr, 2 - 1, "Channels: %d\n",src->channels
);
900fprintf(stderr,"Width   : %d\n",src->width)__fprintf_chk (stderr, 2 - 1, "Width   : %d\n",src->width);
901fprintf(stderr,"Height  : %d\n",src->height)__fprintf_chk (stderr, 2 - 1, "Height  : %d\n",src->height
);
902fprintf(stderr,"Stride  : %d\n",src->stride)__fprintf_chk (stderr, 2 - 1, "Stride  : %d\n",src->stride
);
903fprintf(stderr,"Flags   : %d\n",src->flags)__fprintf_chk (stderr, 2 - 1, "Flags   : %d\n",src->flags);

905fprintf(stderr,"Dst----------------\n")__fprintf_chk (stderr, 2 - 1, "Dst----------------\n");
906fprintf(stderr,"Type : %d\n",dst->type)__fprintf_chk (stderr, 2 - 1, "Type : %d\n",dst->type);
907fprintf(stderr,"Channels: %d\n",dst->channels)__fprintf_chk (stderr, 2 - 1, "Channels: %d\n",dst->channels
);
908fprintf(stderr,"Width   : %d\n",dst->width)__fprintf_chk (stderr, 2 - 1, "Width   : %d\n",dst->width);
909fprintf(stderr,"Height  : %d\n",dst->height)__fprintf_chk (stderr, 2 - 1, "Height  : %d\n",dst->height
);
910fprintf(stderr,"Stride  : %d\n",dst->stride)__fprintf_chk (stderr, 2 - 1, "Stride  : %d\n",dst->stride
);
911fprintf(stderr,"Flags   : %d\n",dst->flags)__fprintf_chk (stderr, 2 - 1, "Flags   : %d\n",dst->flags);
912#endif

  if (dstImageP->cmodel.cmType == INDEX_CM_TYPE3) {
      /* Need to clear the destination to the transparent pixel */
      unsigned char *cP = (unsigned char *)mlib_ImageGetData(dst);

      memset(cP, dstImageP->cmodel.transIdx,
             mlib_ImageGetWidth(dst)*mlib_ImageGetHeight(dst));
  }
  /* Perform the transformation */
  if ((status = (*sMlibFns[MLIB_AFFINE].fptr)(dst, src, mtx, filter,
                                MLIB_EDGE_SRC_EXTEND) != MLIB_SUCCESS))
  {
      printMedialibError(status);
      freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));

      return 0;
  }

  if (s_printIt) {
      if (sdata == NULL((void*)0)) {
          dP = (unsigned int *) mlib_ImageGetData(src);
      }
      else {
          dP = (unsigned int *) sdata;
      }
      printf("src is\n")__printf_chk (2 - 1, "src is\n");
      for (i=0; i < 20; i++) {
          printf("%x ",dP[i])__printf_chk (2 - 1, "%x ",dP[i]);
      }
      printf("\n")__printf_chk (2 - 1, "\n");
      if (ddata == NULL((void*)0)) {
          dP = (unsigned int *)mlib_ImageGetData(dst);
      }
      else {
          dP = (unsigned int *) ddata;
      }
      printf("dst is\n")__printf_chk (2 - 1, "dst is\n");
      for (i=0; i < 20; i++) {
          printf("%x ",dP[i])__printf_chk (2 - 1, "%x ",dP[i]);
      }
      printf("\n")__printf_chk (2 - 1, "\n");
  }

  /* Means that we couldn't write directly into the destination buffer */
  if (ddata == NULL((void*)0)) {
      freeDataArray(env, srcImageP->raster.jdata, src, sdata,
                    NULL((void*)0), NULL((void*)0), NULL((void*)0));
      /* Need to store it back into the array */
      if (storeImageArray(env, srcImageP, dstImageP, dst) < 0) {
          /* Error */
          retStatus = 0;
      }
      freeDataArray(env, NULL((void*)0), NULL((void*)0), NULL((void*)0), dstImageP->raster.jdata,
                    dst, ddata);
  }
  else {
      /* Release the pinned memory */
      freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
  }

  awt_freeParsedImage(srcImageP, TRUE(1));
  awt_freeParsedImage(dstImageP, TRUE(1));

  if (s_timeIt) (*stop_timer)(3600,1);

  return retStatus;
981}

983JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
984Java_sun_awt_image_ImagingLib_transformRaster(JNIEnv *env, jobject this,
                                            jobject jsrc,
                                            jobject jdst,
                                            jdoubleArray jmatrix,
                                            jint interpType)
989{
  mlib_image *src;
  mlib_image *dst;
  int i;
  int j = 0;
  int retStatus = 1;
  mlib_status status;
  double *matrix;
  mlib_d64 mtx[6];
  void *sdata;
  void *ddata;
  RasterS_t *srcRasterP;
  RasterS_t *dstRasterP;
  mlib_filter filter;
  unsigned int *dP;

  /* This function requires a lot of local refs ??? Is 64 enough ??? */
  if ((*env)->EnsureLocalCapacity(env, 64) < 0)
      return 0;

  if (s_nomlib) return 0;
  if (s_timeIt) {
      (*start_timer)(3600);
  }

  switch(interpType) {
  case java_awt_image_AffineTransformOp_TYPE_BILINEAR2L:
      filter = MLIB_BILINEAR;
      break;
  case java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR1L:
      filter = MLIB_NEAREST;
      break;
  case java_awt_image_AffineTransformOp_TYPE_BICUBIC3L:
      filter = MLIB_BICUBIC;
      break;
  default:
      JNU_ThrowInternalError(env, "Unknown interpolation type");
      return -1;
  }

  if ((srcRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
      JNU_ThrowOutOfMemoryError(env, "Out of memory");
      return -1;
  }

  if ((dstRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
      JNU_ThrowOutOfMemoryError(env, "Out of memory");
      free(srcRasterP);
      return -1;
  }

  if ((*env)->GetArrayLength(env, jmatrix) < 6) {
      /*
       * Very unlikely, however we should check for this:
       * if given matrix array is too short, we can't handle it.
       */
      free(srcRasterP);
      free(dstRasterP);
      return 0;
  }

  matrix = (*env)->GetPrimitiveArrayCritical(env, jmatrix, NULL((void*)0));
  if (matrix == NULL((void*)0)) {
      /* out of memory error already thrown */
      free(srcRasterP);
      free(dstRasterP);
      return 0;
  }

  /* Check for invalid double value in transformation matrix */
  for (j = 0; j < 6; j++) {

      if (!(IS_FINITE(matrix[j])(((matrix[j]) >= -1.7976931348623157E+308) && ((matrix
[j]) <= 1.7976931348623157E+308)))) {
          (*env)->ReleasePrimitiveArrayCritical(env, jmatrix, matrix, JNI_ABORT2);
          free(srcRasterP);
          free(dstRasterP);

          return 0;
      }
  }

  if (s_printIt) {
      printf("matrix is %g %g %g %g %g %g\n", matrix[0], matrix[1],__printf_chk (2 - 1, "matrix is %g %g %g %g %g %g\n", matrix[
0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5])
             matrix[2], matrix[3], matrix[4], matrix[5])__printf_chk (2 - 1, "matrix is %g %g %g %g %g %g\n", matrix[
0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
  }

  mtx[0] = matrix[0];
  mtx[1] = matrix[2];
  mtx[2] = matrix[4];
  mtx[3] = matrix[1];
  mtx[4] = matrix[3];
  mtx[5] = matrix[5];

  (*env)->ReleasePrimitiveArrayCritical(env, jmatrix, matrix, JNI_ABORT2);

  /* Parse the source raster */
  if (awt_parseRaster(env, jsrc, srcRasterP) <= 0) {
      /* Can't handle any custom rasters */
      free(srcRasterP);
      free(dstRasterP);
      return 0;
  }

  /* Parse the destination raster */
  if (awt_parseRaster(env, jdst, dstRasterP) <= 0) {
      /* Can't handle any custom images */
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      free(dstRasterP);
      return 0;
  }

  /* Allocate the arrays */
  if (allocateRasterArray(env, srcRasterP, &src, &sdata, TRUE(1)) < 0) {
      /* Must be some problem */
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      return 0;
  }
  if (allocateRasterArray(env, dstRasterP, &dst, &ddata, FALSE(0)) < 0) {
      /* Must be some problem */
      freeDataArray(env, srcRasterP->jdata, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      return 0;
  }

1115#if 0
1116fprintf(stderr,"Src----------------\n")__fprintf_chk (stderr, 2 - 1, "Src----------------\n");
1117fprintf(stderr,"Type : %d\n",src->type)__fprintf_chk (stderr, 2 - 1, "Type : %d\n",src->type);
1118fprintf(stderr,"Channels: %d\n",src->channels)__fprintf_chk (stderr, 2 - 1, "Channels: %d\n",src->channels
);
1119fprintf(stderr,"Width   : %d\n",src->width)__fprintf_chk (stderr, 2 - 1, "Width   : %d\n",src->width);
1120fprintf(stderr,"Height  : %d\n",src->height)__fprintf_chk (stderr, 2 - 1, "Height  : %d\n",src->height
);
1121fprintf(stderr,"Stride  : %d\n",src->stride)__fprintf_chk (stderr, 2 - 1, "Stride  : %d\n",src->stride
);
1122fprintf(stderr,"Flags   : %d\n",src->flags)__fprintf_chk (stderr, 2 - 1, "Flags   : %d\n",src->flags);

1124fprintf(stderr,"Dst----------------\n")__fprintf_chk (stderr, 2 - 1, "Dst----------------\n");
1125fprintf(stderr,"Type : %d\n",dst->type)__fprintf_chk (stderr, 2 - 1, "Type : %d\n",dst->type);
1126fprintf(stderr,"Channels: %d\n",dst->channels)__fprintf_chk (stderr, 2 - 1, "Channels: %d\n",dst->channels
);
1127fprintf(stderr,"Width   : %d\n",dst->width)__fprintf_chk (stderr, 2 - 1, "Width   : %d\n",dst->width);
1128fprintf(stderr,"Height  : %d\n",dst->height)__fprintf_chk (stderr, 2 - 1, "Height  : %d\n",dst->height
);
1129fprintf(stderr,"Stride  : %d\n",dst->stride)__fprintf_chk (stderr, 2 - 1, "Stride  : %d\n",dst->stride
);
1130fprintf(stderr,"Flags   : %d\n",dst->flags)__fprintf_chk (stderr, 2 - 1, "Flags   : %d\n",dst->flags);
1131#endif

  {
      unsigned char *cP = (unsigned char *)mlib_ImageGetData(dst);

      memset(cP, 0, mlib_ImageGetWidth(dst)*mlib_ImageGetHeight(dst));
  }

  /* Perform the transformation */
  if ((status = (*sMlibFns[MLIB_AFFINE].fptr)(dst, src, mtx, filter,
                                MLIB_EDGE_SRC_EXTEND) != MLIB_SUCCESS))
  {
      printMedialibError(status);
      /* REMIND: Free the regions */
      return 0;
  }

  if (s_printIt) {
      if (sdata == NULL((void*)0)) {
          dP = (unsigned int *) mlib_ImageGetData(src);
      }
      else {
          dP = (unsigned int *) sdata;
      }
      printf("src is\n")__printf_chk (2 - 1, "src is\n");
      for (i=0; i < 20; i++) {
          printf("%x ",dP[i])__printf_chk (2 - 1, "%x ",dP[i]);
      }
      printf("\n")__printf_chk (2 - 1, "\n");
      if (ddata == NULL((void*)0)) {
          dP = (unsigned int *)mlib_ImageGetData(dst);
      }
      else {
          dP = (unsigned int *) ddata;
      }
      printf("dst is\n")__printf_chk (2 - 1, "dst is\n");
      for (i=0; i < 20; i++) {
          printf("%x ",dP[i])__printf_chk (2 - 1, "%x ",dP[i]);
      }
      printf("\n")__printf_chk (2 - 1, "\n");
  }

  /* Means that we couldn't write directly into the destination buffer */
  if (ddata == NULL((void*)0)) {
      /* Need to store it back into the array */
      if (storeRasterArray(env, srcRasterP, dstRasterP, dst) < 0) {
          (*env)->ExceptionClear(env); // Could not store the array, try another way
          retStatus = setPixelsFormMlibImage(env, dstRasterP, dst);
      }
  }

  /* Release the pinned memory */
  freeDataArray(env, srcRasterP->jdata, src, sdata,
                dstRasterP->jdata, dst, ddata);

  awt_freeParsedRaster(srcRasterP, TRUE(1));
  awt_freeParsedRaster(dstRasterP, TRUE(1));

  if (s_timeIt) (*stop_timer)(3600,1);

  return retStatus;
1192}

1194typedef struct {
  jobject jArray;
  jsize length;
  unsigned char *table;
1198} LookupArrayInfo;

1200#define NLUT8 8

1202#ifdef _LITTLE_ENDIAN1
1203#define INDEXES{ 3, 2, 1, 0, 7, 6, 5, 4 }    { 3, 2, 1, 0, 7, 6, 5, 4 }
1204#else
1205#define INDEXES{ 3, 2, 1, 0, 7, 6, 5, 4 }    { 0, 1, 2, 3, 4, 5, 6, 7 }
1206#endif

1208static int lookupShortData(mlib_image* src, mlib_image* dst,
  LookupArrayInfo* lookup)
1210{
  int x, y;
  unsigned int mask = NLUT8-1;

  unsigned short* srcLine = (unsigned short*)src->data;
  unsigned char* dstLine = (unsigned char*)dst->data;

  static int indexes[NLUT8] = INDEXES{ 3, 2, 1, 0, 7, 6, 5, 4 };

  if (src->width != dst->width || src->height != dst->height) {
      return 0;
  }

  for (y=0; y < src->height; y++) {
      int nloop, nx;
      int npix = src->width;

      unsigned short* srcPixel = srcLine;
      unsigned char* dstPixel = dstLine;

1230#ifdef SIMPLE_LOOKUP_LOOP
      for (x=0; status && x < width; x++) {
          unsigned short s = *srcPixel++;
          if (s >= lookup->length) {
              /* we can not handle source image using
              * byte lookup table. Fall back to processing
              * images in java
              */
              return 0;
          }
          *dstPixel++ = lookup->table[s];
      }
1242#else
      /* Get to 32 bit-aligned point */
      while(((uintptr_t)dstPixel & 0x3) != 0 && npix>0) {
          unsigned short s = *srcPixel++;
          if (s >= lookup->length) {
              return 0;
          }
          *dstPixel++ = lookup->table[s];
          npix--;
      }

      /*
       * Do NLUT pixels per loop iteration.
       * Pack into ints and write out 2 at a time.
       */
      nloop = npix/NLUT8;
      nx = npix%NLUT8;

      for(x=nloop; x!=0; x--) {
          int i = 0;
          int* dstP = (int*)dstPixel;

          for (i = 0; i < NLUT8; i++) {
              if (srcPixel[i] >= lookup->length) {
                  return 0;
              }
          }

          dstP[0] = (int)
              ((lookup->table[srcPixel[indexes[0]]] << 24) |
               (lookup->table[srcPixel[indexes[1]]] << 16) |
               (lookup->table[srcPixel[indexes[2]]] << 8)  |
                lookup->table[srcPixel[indexes[3]]]);
          dstP[1] = (int)
              ((lookup->table[srcPixel[indexes[4]]] << 24) |
               (lookup->table[srcPixel[indexes[5]]] << 16) |
               (lookup->table[srcPixel[indexes[6]]] << 8)  |
                lookup->table[srcPixel[indexes[7]]]);


          dstPixel += NLUT8;
          srcPixel += NLUT8;
      }

      /*
       * Complete any remaining pixels
       */
      for(x=nx; x!=0; x--) {
          unsigned short s = *srcPixel++;
          if (s >= lookup->length) {
              return 0;
          }
          *dstPixel++ = lookup->table[s];
      }
1296#endif

      dstLine += dst->stride;     // array of bytes, scan stride in bytes
      srcLine += src->stride / 2; // array of shorts, scan stride in bytes
  }
  return 1;
1302}

1304JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
1305Java_sun_awt_image_ImagingLib_lookupByteBI(JNIEnv *env, jobject thisLib,
                                         jobject jsrc, jobject jdst,
                                         jobjectArray jtableArrays)
1308{
  mlib_image *src;
  mlib_image *dst;
  void *sdata, *ddata;
  unsigned char **tbl;
  unsigned char lut[256];
  int retStatus = 1;
  int i;
  mlib_status status;
  int lut_nbands;
  LookupArrayInfo *jtable;
  BufImageS_t *srcImageP, *dstImageP;
  int nbands;
  int ncomponents;
  mlibHintS_t hint;

  /* This function requires a lot of local refs ??? Is 64 enough ??? */
  if ((*env)->EnsureLocalCapacity(env, 64) < 0)
      return 0;

  if (s_nomlib) return 0;
  if (s_timeIt) (*start_timer)(3600);

  /* Parse the source image */
  if (awt_parseImage(env, jsrc, &srcImageP, FALSE(0)) <= 0) {
      /* Can't handle any custom images */
      return 0;
  }

  /* Parse the destination image */
  if (awt_parseImage(env, jdst, &dstImageP, FALSE(0)) <= 0) {
      /* Can't handle any custom images */
      awt_freeParsedImage(srcImageP, TRUE(1));
      return 0;
  }

  nbands = setImageHints(env, srcImageP, dstImageP, FALSE(0), TRUE(1),
                      FALSE(0), &hint);

  if (nbands < 1 || nbands > srcImageP->cmodel.numComponents) {
      /* Can't handle any custom images */
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      return 0;
  }

  ncomponents = srcImageP->cmodel.isDefaultCompatCM
      ? 4
      : srcImageP->cmodel.numComponents;

  /* Make sure that color order can be used for
   * re-ordering of lookup arrays.
   */
  for (i = 0; i < nbands; i++) {
      int idx = srcImageP->hints.colorOrder[i];

      if (idx < 0 || idx >= ncomponents) {
          awt_freeParsedImage(srcImageP, TRUE(1));
          awt_freeParsedImage(dstImageP, TRUE(1));
          return 0;
      }
  }

  lut_nbands = (*env)->GetArrayLength(env, jtableArrays);

  if (lut_nbands > ncomponents) {
      lut_nbands = ncomponents;
  }

  tbl = NULL((void*)0);
  if (SAFE_TO_ALLOC_2(ncomponents, sizeof(unsigned char *))(((ncomponents) > 0) && ((sizeof(unsigned char *))
 > 0) && ((0x7fffffff / (ncomponents)) > (sizeof
(unsigned char *))))) {
      tbl = (unsigned char **)
          calloc(1, ncomponents * sizeof(unsigned char *));
  }

  jtable = NULL((void*)0);
  if (SAFE_TO_ALLOC_2(lut_nbands, sizeof(LookupArrayInfo))(((lut_nbands) > 0) && ((sizeof(LookupArrayInfo)) >
 0) && ((0x7fffffff / (lut_nbands)) > (sizeof(LookupArrayInfo
))))) {
      jtable = (LookupArrayInfo *)malloc(lut_nbands * sizeof (LookupArrayInfo));
  }

  if (tbl == NULL((void*)0) || jtable == NULL((void*)0)) {
      if (tbl != NULL((void*)0)) free(tbl);
      if (jtable != NULL((void*)0)) free(jtable);
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      JNU_ThrowNullPointerException(env, "NULL LUT");
      return 0;
  }
  /* Need to grab these pointers before we lock down arrays */
  for (i=0; i < lut_nbands; i++) {
      jtable[i].jArray = (*env)->GetObjectArrayElement(env, jtableArrays, i);

      if (jtable[i].jArray != NULL((void*)0)) {
          jtable[i].length = (*env)->GetArrayLength(env, jtable[i].jArray);
          jtable[i].table = NULL((void*)0);

          if (jtable[i].length < 256) {
              /* we may read outside the table during lookup */
              jtable[i].jArray = NULL((void*)0);
              jtable[i].length = 0;
          }
      }
      if (jtable[i].jArray == NULL((void*)0)) {
          free(tbl);
          free(jtable);
          awt_freeParsedImage(srcImageP, TRUE(1));
          awt_freeParsedImage(dstImageP, TRUE(1));
          return 0;
      }
  }

  /* Allocate the arrays */
  if (allocateArray(env, srcImageP, &src, &sdata, TRUE(1), FALSE(0), FALSE(0)) < 0) {
      /* Must be some problem */
      free(tbl);
      free(jtable);
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      return 0;
  }
  if (allocateArray(env, dstImageP, &dst, &ddata, FALSE(0), FALSE(0), FALSE(0)) < 0) {
      /* Must be some problem */
      free(tbl);
      free(jtable);
      freeArray(env, srcImageP, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
      awt_freeParsedImage(srcImageP, TRUE(1));
      awt_freeParsedImage(dstImageP, TRUE(1));
      return 0;
  }

  /* Set up a straight lut so we don't mess around with alpha */
  /*
   * NB: medialib lookup routine expects lookup array for each
   * component of source image including alpha.
   * If lookup table we got form the java layer does not contain
   * sufficient number of lookup arrays we add references to identity
   * lookup array to make medialib happier.
   */
  if (lut_nbands < ncomponents) {
      int j;
      /* REMIND: This should be the size of the input lut!! */
      for (j=0; j < 256; j++) {
          lut[j] = j;
      }
      for (j=0; j < ncomponents; j++) {
          tbl[j] = lut;
      }
  }

  for (i=0; i < lut_nbands; i++) {
      jtable[i].table = (unsigned char *)
          (*env)->GetPrimitiveArrayCritical(env, jtable[i].jArray, NULL((void*)0));
      if (jtable[i].table == NULL((void*)0)) {
          /* Free what we've got so far. */
          int j;
          for (j = 0; j < i; j++) {
              (*env)->ReleasePrimitiveArrayCritical(env,
                                                    jtable[j].jArray,
                                                    (jbyte *) jtable[j].table,
                                                    JNI_ABORT2);
          }
          free(tbl);
          free(jtable);
          freeArray(env, srcImageP, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
          awt_freeParsedImage(srcImageP, TRUE(1));
          awt_freeParsedImage(dstImageP, TRUE(1));
          return 0;
      }
      tbl[srcImageP->hints.colorOrder[i]] = jtable[i].table;
  }

  if (lut_nbands == 1) {
      for (i=1; i < nbands -
               srcImageP->cmodel.supportsAlpha; i++) {
                   tbl[srcImageP->hints.colorOrder[i]] = jtable[0].table;
      }
  }

  /* Mlib needs 16bit lookuptable and must be signed! */
  if (src->type == MLIB_SHORT) {
      if (dst->type == MLIB_BYTE) {
          if (nbands > 1) {
              retStatus = 0;
          }
          else {
              retStatus = lookupShortData(src, dst, &jtable[0]);
          }
      }
      /* How about ddata == null? */
  }
  else if ((status = (*sMlibFns[MLIB_LOOKUP].fptr)(dst, src,
                                    (void **)tbl) != MLIB_SUCCESS)) {
      printMedialibError(status);
      retStatus = 0;
  }

 /* Release the LUT */
  for (i=0; i < lut_nbands; i++) {
      (*env)->ReleasePrimitiveArrayCritical(env, jtable[i].jArray,
          (jbyte *) jtable[i].table, JNI_ABORT2);
  }
  free ((void *) jtable);
  free ((void *) tbl);

  /*
   * Means that we couldn't write directly into
   * the destination buffer
   */
  if (ddata == NULL((void*)0)) {

      /* Need to store it back into the array */
      if (storeImageArray(env, srcImageP, dstImageP, dst) < 0) {
          /* Error */
          retStatus = 0;
      }
  }


  /* Release the pinned memory */
  freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);

  awt_freeParsedImage(srcImageP, TRUE(1));
  awt_freeParsedImage(dstImageP, TRUE(1));

  if (s_timeIt) (*stop_timer)(3600, 1);

  return retStatus;
1535}

1537JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
1538Java_sun_awt_image_ImagingLib_lookupByteRaster(JNIEnv *env,
                                             jobject this,
                                             jobject jsrc,
                                             jobject jdst,
                                             jobjectArray jtableArrays)
1543{
  RasterS_t*     srcRasterP;
  RasterS_t*     dstRasterP;
  mlib_image*    src;
  mlib_image*    dst;
  void*          sdata;
  void*          ddata;
  LookupArrayInfo jtable[4];
  unsigned char* mlib_lookupTable[4];
  int            i;
  int            retStatus = 1;
  mlib_status    status;
  int            jlen;
  int            lut_nbands;
  int            src_nbands;
  int            dst_nbands;
  unsigned char  ilut[256];

  /* This function requires a lot of local refs ??? Is 64 enough ??? */
  if ((*env)->EnsureLocalCapacity(env, 64) < 0)
      return 0;

  if (s_nomlib) return 0;
  if (s_timeIt) (*start_timer)(3600);

  if ((srcRasterP = (RasterS_t*) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
      JNU_ThrowOutOfMemoryError(env, "Out of memory");
      return -1;
  }

  if ((dstRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
      JNU_ThrowOutOfMemoryError(env, "Out of memory");
      free(srcRasterP);
      return -1;
  }

  /* Parse the source raster - reject custom images */
  if (awt_parseRaster(env, jsrc, srcRasterP) <= 0) {
      free(srcRasterP);
      free(dstRasterP);
      return 0;
  }

  /* Parse the destination image - reject custom images */
  if (awt_parseRaster(env, jdst, dstRasterP) <= 0) {
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      free(dstRasterP);
      return 0;
  }

  jlen = (*env)->GetArrayLength(env, jtableArrays);

  lut_nbands = jlen;
  src_nbands = srcRasterP->numBands;
  dst_nbands = dstRasterP->numBands;

  /* adjust number of lookup bands */
  if (lut_nbands > src_nbands) {
      lut_nbands = src_nbands;
  }

  /* MediaLib can't do more than 4 bands */
  if (src_nbands <= 0 || src_nbands > 4 ||
      dst_nbands <= 0 || dst_nbands > 4 ||
      lut_nbands <= 0 || lut_nbands > 4 ||
      src_nbands != dst_nbands ||
      ((lut_nbands != 1) && (lut_nbands != src_nbands)))
  {
      // we should free parsed rasters here
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      return 0;
  }

  /* Allocate the raster arrays */
  if (allocateRasterArray(env, srcRasterP, &src, &sdata, TRUE(1)) < 0) {
      /* Must be some problem */
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      return 0;
  }
  if (allocateRasterArray(env, dstRasterP, &dst, &ddata, FALSE(0)) < 0) {
      /* Must be some problem */
      freeDataArray(env, srcRasterP->jdata, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      return 0;
  }

  /*
   * Well, until now we have analyzed number of bands in
   * src and dst rasters.
   * However, it is not enough because medialib lookup routine uses
   * number of channels of medialib image. Note that in certain
   * case number of channels may differs form the number of bands.
   * Good example is raster that is used in TYPE_INT_RGB buffered
   * image: it has 3 bands, but their medialib representation has
   * 4 channels.
   *
   * In order to avoid the lookup routine failure, we need:
   *
   * 1. verify that src and dst have same number of channels.
   * 2. provide lookup array for every channel. If we have "extra"
   *    channel (like the raster described above) then we need to
   *    provide identical lookup array.
   */
  if (src->channels != dst->channels) {
      freeDataArray(env, srcRasterP->jdata, src, sdata,
                    dstRasterP->jdata, dst, ddata);

      awt_freeParsedRaster(srcRasterP, TRUE(1));
      awt_freeParsedRaster(dstRasterP, TRUE(1));
      return 0;
  }

  if (src_nbands < src->channels) {
      for (i = 0; i < 256; i++) {
          ilut[i] = i;
      }
  }


  /* Get references to the lookup table arrays */
  /* Need to grab these pointers before we lock down arrays */
  for (i=0; i < lut_nbands; i++) {
      jtable[i].jArray = (*env)->GetObjectArrayElement(env, jtableArrays, i);
      jtable[i].table = NULL((void*)0);
      if (jtable[i].jArray != NULL((void*)0)) {
          jtable[i].length = (*env)->GetArrayLength(env, jtable[i].jArray);
          if (jtable[i].length < 256) {
               /* we may read outside the table during lookup */
              jtable[i].jArray = NULL((void*)0);
          }
      }

      if (jtable[i].jArray == NULL((void*)0))
      {
          freeDataArray(env, srcRasterP->jdata, src, sdata,
                        dstRasterP->jdata, dst, ddata);

          awt_freeParsedRaster(srcRasterP, TRUE(1));
          awt_freeParsedRaster(dstRasterP, TRUE(1));
          return 0;
      }
  }

  for (i=0; i < lut_nbands; i++) {
      jtable[i].table = (unsigned char *)
          (*env)->GetPrimitiveArrayCritical(env, jtable[i].jArray, NULL((void*)0));
      if (jtable[i].table == NULL((void*)0)) {
          /* Free what we've got so far. */
          int j;
          for (j = 0; j < i; j++) {
              (*env)->ReleasePrimitiveArrayCritical(env,
                                                    jtable[j].jArray,
                                                    (jbyte *) jtable[j].table,
                                                    JNI_ABORT2);
          }
          freeDataArray(env, srcRasterP->jdata, src, sdata,
                        dstRasterP->jdata, dst, ddata);
          awt_freeParsedRaster(srcRasterP, TRUE(1));
          awt_freeParsedRaster(dstRasterP, TRUE(1));
          return 0;
      }
      mlib_lookupTable[i] = jtable[i].table;
  }

  /*
   * Medialib routine expects lookup array for each band of raster.
   * Setup the  rest of lookup arrays if supplied lookup table
   * contains single lookup array.
   */
  for (i = lut_nbands; i < src_nbands; i++) {
      mlib_lookupTable[i] = jtable[0].table;
  }

  /*
   * Setup lookup array for "extra" channels
   */
  for ( ; i < src->channels; i++) {
      mlib_lookupTable[i] = ilut;
  }

  /* Mlib needs 16bit lookuptable and must be signed! */
  if (src->type == MLIB_SHORT) {
      if (dst->type == MLIB_BYTE) {
          if (lut_nbands > 1) {
              retStatus = 0;
          } else {
              retStatus = lookupShortData(src, dst, &jtable[0]);
          }
      }
      /* How about ddata == null? */
  } else if ((status = (*sMlibFns[MLIB_LOOKUP].fptr)(dst, src,
                                    (void **)mlib_lookupTable) != MLIB_SUCCESS)) {
      printMedialibError(status);
      retStatus = 0;
  }

  /* Release the LUT */
  for (i=0; i < lut_nbands; i++) {
      (*env)->ReleasePrimitiveArrayCritical(env, jtable[i].jArray,
                                            (jbyte *) jtable[i].table, JNI_ABORT2);
  }

  /*
   * Means that we couldn't write directly into
   * the destination buffer
   */
  if (ddata == NULL((void*)0)) {
      if (storeRasterArray(env, srcRasterP, dstRasterP, dst) < 0) {
          retStatus = setPixelsFormMlibImage(env, dstRasterP, dst);
      }
  }

  /* Release the pinned memory */
  freeDataArray(env, srcRasterP->jdata, src, sdata,
                dstRasterP->jdata, dst, ddata);

  awt_freeParsedRaster(srcRasterP, TRUE(1));
  awt_freeParsedRaster(dstRasterP, TRUE(1));

  if (s_timeIt) (*stop_timer)(3600, 1);

  return retStatus;
1768}


1771JNIEXPORT__attribute__((visibility("default"))) jboolean JNICALL
1772Java_sun_awt_image_ImagingLib_init(JNIEnv *env, jclass thisClass) {
  char *start;
  if (getenv("IMLIB_DEBUG")) {
      start_timer = awt_setMlibStartTimer();
      stop_timer = awt_setMlibStopTimer();
      if (start_timer && stop_timer) {
          s_timeIt = 1;
      }
  }

  if (getenv("IMLIB_PRINT")) {
      s_printIt = 1;
  }
  if ((start = getenv("IMLIB_START")) != NULL((void*)0)) {
      sscanf(start, "%d", &s_startOff);
  }

  if (getenv ("IMLIB_NOMLIB")) {
      s_nomlib = 1;
      return JNI_FALSE0;
  }

  /* This function is platform-dependent and is in awt_mlib.c */
  if (awt_getImagingLib(env, (mlibFnS_t *)&sMlibFns, &sMlibSysFns) !=
      MLIB_SUCCESS)
  {
      s_nomlib = 1;
      return JNI_FALSE0;
  }
  return JNI_TRUE1;
1802}

1804/* REMIND: How to specify border? */
1805static void extendEdge(JNIEnv *env, BufImageS_t *imageP,
                     int *widthP, int *heightP) {
  RasterS_t *rasterP = &imageP->raster;
  int width;
  int height;
  /* Useful for convolution? */

  jobject jbaseraster = (*env)->GetObjectField(env, rasterP->jraster,
                                               g_RasterBaseRasterID);
  width = rasterP->width;
  height = rasterP->height;
1816#ifdef WORKING
  if (! JNU_IsNull(env, jbaseraster)((jbaseraster) == ((void*)0)) &&
      !(*env)->IsSameObject(env, rasterP->jraster, jbaseraster)) {
      int xOff;
      int yOff;
      int baseWidth;
      int baseHeight;
      int baseXoff;
      int baseYoff;
      /* Not the same object so get the width and height */
      xOff = (*env)->GetIntField(env, rasterP->jraster, g_RasterXOffsetID);
      yOff = (*env)->GetIntField(env, rasterP->jraster, g_RasterYOffsetID);
      baseWidth  = (*env)->GetIntField(env, jbaseraster, g_RasterWidthID);
      baseHeight = (*env)->GetIntField(env, jbaseraster, g_RasterHeightID);
      baseXoff   = (*env)->GetIntField(env, jbaseraster, g_RasterXOffsetID);
      baseYoff   = (*env)->GetIntField(env, jbaseraster, g_RasterYOffsetID);

      if (xOff + rasterP->width < baseXoff + baseWidth) {
          /* Can use edge */
          width++;
      }
      if (yOff + rasterP->height < baseYoff + baseHeight) {
          /* Can use edge */
          height++;
      }

  }
1843#endif

1845}

1847static int
1848setImageHints(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
            int expandICM, int useAlpha,
            int premultiply, mlibHintS_t *hintP)
1851{
  ColorModelS_t *srcCMP = &srcP->cmodel;
  ColorModelS_t *dstCMP = &dstP->cmodel;
  int nbands = 0;
  int ncomponents;

  hintP->dataType = srcP->raster.dataType;
  hintP->addAlpha = FALSE(0);

  /* Are the color spaces the same? */
  if (srcCMP->csType != dstCMP->csType) {
      /* If the src is GRAY and dst RGB, we can handle it */
      if (!(srcCMP->csType == java_awt_color_ColorSpace_TYPE_GRAY6L &&
            dstCMP->csType == java_awt_color_ColorSpace_TYPE_RGB5L)) {
          /* Nope, need to handle that in java for now */
          return -1;
      }
      else {
          hintP->cvtSrcToDefault = TRUE(1);
      }
  }
  else {
      if (srcP->hints.needToExpand) {
          hintP->cvtSrcToDefault = TRUE(1);
      }
      else {
          /* Need to initialize this */
          hintP->cvtSrcToDefault = FALSE(0);
      }
  }

  ncomponents = srcCMP->numComponents;
  if ((useAlpha == 0) && srcCMP->supportsAlpha) {
      ncomponents--;  /* ?? */
      /* Not really, more like shrink src to get rid of alpha */
      hintP->cvtSrcToDefault = TRUE(1);
  }

  hintP->dataType = srcP->raster.dataType;
  if (hintP->cvtSrcToDefault == FALSE(0)) {
      if (srcCMP->cmType == INDEX_CM_TYPE3) {
          if (expandICM) {
              nbands = srcCMP->numComponents;
              hintP->cvtSrcToDefault = TRUE(1);

              if (dstCMP->isDefaultCompatCM) {
                  hintP->allocDefaultDst = FALSE(0);
                  hintP->cvtToDst = FALSE(0);
              }
              else if (dstCMP->isDefaultCompatCM) {
                  hintP->allocDefaultDst = FALSE(0);
                  hintP->cvtToDst = FALSE(0);
              }
          }
          else {
              nbands = 1;
              hintP->cvtSrcToDefault = FALSE(0);
          }

      }
      else {
          if (srcP->hints.packing & INTERLEAVED0x10) {
              nbands = srcCMP->numComponents;
          }
          else {
              nbands = 1;
          }

          /* Look at the packing */
          if ((srcP->hints.packing&BYTE_INTERLEAVED(0x1 | 0x10))==BYTE_INTERLEAVED(0x1 | 0x10) ||
              (srcP->hints.packing&SHORT_INTERLEAVED(0x2 | 0x10))==SHORT_INTERLEAVED(0x2 | 0x10)||
              (srcP->hints.packing&BYTE_SINGLE_BAND(0x1 | 0x30)) == BYTE_SINGLE_BAND(0x1 | 0x30)||
              (srcP->hints.packing&SHORT_SINGLE_BAND(0x2 | 0x30))==SHORT_SINGLE_BAND(0x2 | 0x30)||
              (srcP->hints.packing&BYTE_BANDED(0x1 | 0x20))  == BYTE_BANDED(0x1 | 0x20)       ||
              (srcP->hints.packing&SHORT_BANDED(0x2 | 0x20)) == SHORT_BANDED(0x2 | 0x20)) {
              /* Can use src directly */
              hintP->cvtSrcToDefault = FALSE(0);
          }
          else {
              /* Must be packed or custom */
              hintP->cvtSrcToDefault = TRUE(1);
          }
      }
  }
  if (hintP->cvtSrcToDefault) {
      /* By definition */
      nbands = 4;  /* What about alpha? */
      hintP->dataType = BYTE_DATA_TYPE1;
      hintP->needToCopy = TRUE(1);

      if (srcP->imageType == dstP->imageType) {
          hintP->cvtToDst = TRUE(1);
      }
      else if (dstP->cmodel.isDefaultCM) {
          /* Not necessarily */
          hintP->cvtToDst = FALSE(0);
      }
      else {
          hintP->cvtToDst = TRUE(1);
      }
  }
  else {
      int srcImageType = srcP->imageType;
      int dstImageType = dstP->imageType;
      /* Special case where we need to fill in alpha values */
      if (srcCMP->isDefaultCompatCM && dstCMP->isDefaultCompatCM) {
          int i;
          if (!srcCMP->supportsAlpha &&dstCMP->supportsAlpha) {
              hintP->addAlpha = TRUE(1);
          }
          for (i=0; i < srcCMP->numComponents; i++) {
              if (srcP->hints.colorOrder[i] != dstP->hints.colorOrder[i]){
                  if (!srcCMP->isDefaultCM) {
                      hintP->cvtSrcToDefault = TRUE(1);
                      srcImageType = java_awt_image_BufferedImage_TYPE_INT_ARGB2L;
                  }
                  if (!dstCMP->isDefaultCM) {
                      hintP->cvtToDst = TRUE(1);
                      dstImageType = java_awt_image_BufferedImage_TYPE_INT_ARGB2L;
                  }

                  break;
              }
          }
      }
      else if (srcCMP->cmType != INDEX_CM_TYPE3 &&
               !srcCMP->supportsAlpha && dstCMP->supportsAlpha)
      {
          /* We've already handled the index case.  This is for the rest of the cases */
          srcImageType = java_awt_image_BufferedImage_TYPE_INT_ARGB2L;
          hintP->cvtSrcToDefault = TRUE(1);
      }

      hintP->allocDefaultDst = FALSE(0);
      if (srcImageType == dstImageType) {
          /* Same image type so use it */
          hintP->cvtToDst = FALSE(0);
      }
      else if (srcImageType == TYPE_INT_RGB1L &&
               (dstImageType == TYPE_INT_ARGB2L ||
                dstImageType == TYPE_INT_ARGB_PRE3L)) {
          hintP->cvtToDst = FALSE(0);
      }
      else if (srcImageType == TYPE_INT_BGR4L &&
               (dstImageType == TYPE_4BYTE_ABGR6L ||
                dstImageType == TYPE_4BYTE_ABGR_PRE7L)) {
          hintP->cvtToDst = FALSE(0);
      }
      else if (srcP->hints.packing == dstP->hints.packing) {
          /* Now what? */

          /* Check color order */

          /* Check if just need to scale the data */

          hintP->cvtToDst = TRUE(1);
      }
      else {
          /* Don't know what it is so convert it */
          hintP->allocDefaultDst = TRUE(1);
          hintP->cvtToDst = TRUE(1);
      }
      hintP->needToCopy = (ncomponents > nbands);
  }

  return nbands;
2017}


2020static int
2021expandPacked(JNIEnv *env, BufImageS_t *img, ColorModelS_t *cmP,
           RasterS_t *rasterP, int component, unsigned char *bdataP) {

  if (rasterP->rasterType == COMPONENT_RASTER_TYPE1) {
      switch (rasterP->dataType) {
      case BYTE_DATA_TYPE1:
          if (expandPackedBCR(env, rasterP, component, bdataP) < 0) {
              /* Must have been an error */
              return -1;
          }
          break;

      case SHORT_DATA_TYPE2:
          if (expandPackedICR(env, rasterP, component, bdataP) < 0) {
              /* Must have been an error */
              return -1;
          }
          break;

      case INT_DATA_TYPE3:
          if (expandPackedICR(env, rasterP, component, bdataP) < 0) {
              /* Must have been an error */
              return -1;
          }
          break;

      default:
          /* REMIND: Return some sort of error */
          return -1;
      }
  }
  else {
      /* REMIND: Return some sort of error */
      return -1;
  }

  return 0;
2058}

2060#define NUM_LINES10    10

2062static int
2063cvtCustomToDefault(JNIEnv *env, BufImageS_t *imageP, int component,
                 unsigned char *dataP) {
  const RasterS_t *rasterP = &imageP->raster;
  const int w = rasterP->width;
  const int h = rasterP->height;

  int y;
  jintArray jpixels = NULL((void*)0);
  jint *pixels;
  unsigned char *dP = dataP;
  int numLines = h > NUM_LINES10 ? NUM_LINES10 : h;

  /* it is safe to calculate the scan length, because width has been verified
   * on creation of the mlib image
   */
  const int scanLength = w * 4;

  int nbytes = 0;
  if (!SAFE_TO_MULT(numLines, scanLength)(((numLines) > 0) && ((scanLength) >= 0) &&
 ((0x7fffffff / (numLines)) > (scanLength)))) {
      return -1;
  }

  nbytes = numLines * scanLength;

  jpixels = (*env)->NewIntArray(env, nbytes);
  if (JNU_IsNull(env, jpixels)((jpixels) == ((void*)0))) {
      (*env)->ExceptionClear(env);
      JNU_ThrowOutOfMemoryError(env, "Out of Memory");
      return -1;
  }

  for (y = 0; y < h; y += numLines) {
      if (y + numLines > h) {
          numLines = h - y;
          nbytes = numLines * scanLength;
      }

      (*env)->CallObjectMethod(env, imageP->jimage,
                               g_BImgGetRGBMID, 0, y,
                               w, numLines,
                               jpixels, 0, w);
      if ((*env)->ExceptionOccurred(env)) {
          (*env)->DeleteLocalRef(env, jpixels);
          return -1;
      }

      pixels = (*env)->GetPrimitiveArrayCritical(env, jpixels, NULL((void*)0));
      if (pixels == NULL((void*)0)) {
          (*env)->DeleteLocalRef(env, jpixels);
          return -1;
      }

      memcpy(dP, pixels, nbytes);
      dP += nbytes;

      (*env)->ReleasePrimitiveArrayCritical(env, jpixels, pixels,
                                            JNI_ABORT2);
  }

  /* Need to release the array */
  (*env)->DeleteLocalRef(env, jpixels);

  return 0;
2126}

2128static int
2129cvtDefaultToCustom(JNIEnv *env, BufImageS_t *imageP, int component,
                 unsigned char *dataP) {
  const RasterS_t *rasterP = &imageP->raster;
  const int w = rasterP->width;
  const int h = rasterP->height;

  int y;
  jintArray jpixels = NULL((void*)0);
  jint *pixels;
  unsigned char *dP = dataP;
  int numLines = h > NUM_LINES10 ? NUM_LINES10 : h;

  /* it is safe to calculate the scan length, because width has been verified
   * on creation of the mlib image
   */
  const int scanLength = w * 4;

  int nbytes = 0;
  if (!SAFE_TO_MULT(numLines, scanLength)(((numLines) > 0) && ((scanLength) >= 0) &&
 ((0x7fffffff / (numLines)) > (scanLength)))) {
      return -1;
  }

  nbytes = numLines * scanLength;

  jpixels = (*env)->NewIntArray(env, nbytes);
  if (JNU_IsNull(env, jpixels)((jpixels) == ((void*)0))) {
      (*env)->ExceptionClear(env);
      JNU_ThrowOutOfMemoryError(env, "Out of Memory");
      return -1;
  }

  for (y = 0; y < h; y += numLines) {
      if (y + numLines > h) {
          numLines = h - y;
          nbytes = numLines * scanLength;
      }

      pixels = (*env)->GetPrimitiveArrayCritical(env, jpixels, NULL((void*)0));
      if (pixels == NULL((void*)0)) {
          (*env)->DeleteLocalRef(env, jpixels);
          return -1;
      }

      memcpy(pixels, dP, nbytes);
      dP += nbytes;

     (*env)->ReleasePrimitiveArrayCritical(env, jpixels, pixels, 0);

     (*env)->CallVoidMethod(env, imageP->jimage, g_BImgSetRGBMID, 0, y,
                              w, numLines, jpixels,
                              0, w);
     if ((*env)->ExceptionOccurred(env)) {
         (*env)->DeleteLocalRef(env, jpixels);
         return -1;
     }
  }

  /* Need to release the array */
  (*env)->DeleteLocalRef(env, jpixels);

  return 0;
2190}

2192static int
2193allocateArray(JNIEnv *env, BufImageS_t *imageP,
            mlib_image **mlibImagePP, void **dataPP, int isSrc,
            int cvtToDefault, int addAlpha) {
  void *dataP;
  unsigned char *cDataP;
  RasterS_t *rasterP = &imageP->raster;
  ColorModelS_t *cmP = &imageP->cmodel;
  int dataType = BYTE_DATA_TYPE1;
  int width;
  int height;
  HintS_t *hintP = &imageP->hints;
  *dataPP = NULL((void*)0);

  width = rasterP->width;
  height = rasterP->height;

  /* Useful for convolution? */
  /* This code is zero'ed out so that it cannot be called */

  /* To do this correctly, we need to expand src and dst in the     */
  /* same direction up/down/left/right only if both can be expanded */
  /* in that direction.  Expanding right and down is easy -         */
  /* increment width.  Expanding top and left requires bumping      */
  /* around pointers and incrementing the width/height              */

2218#if 0
  if (0 && useEdges) {
      baseWidth  = rasterP->baseRasterWidth;
      baseHeight = rasterP->baseRasterHeight;
      baseXoff = rasterP->baseOriginX;
      baseYoff = rasterP->baseOriginY;

      if (rasterP->minX + rasterP->width < baseXoff + baseWidth) {
          /* Can use edge */
          width++;
      }
      if (rasterP->minY + rasterP->height < baseYoff + baseHeight) {
          /* Can use edge */
          height++;
      }

      if (rasterP->minX > baseXoff ) {
          /* Can use edge */
          width++;
          /* NEED TO BUMP POINTER BACK A PIXELSTRIDE */
      }
      if (rasterP->minY  > baseYoff) {
          /* Can use edge */
          height++;
          /* NEED TO BUMP POINTER BACK A SCANLINE */
      }


  }
2247#endif
  if (cvtToDefault) {
      int status = 0;
      *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, 4, width, height);
      if (*mlibImagePP == NULL((void*)0)) {
          return -1;
      }
      cDataP  = (unsigned char *) mlib_ImageGetData(*mlibImagePP);
      /* Make sure the image is cleared.
       * NB: the image dimension is already verified, so we can
       * safely calculate the length of the buffer.
       */
      memset(cDataP, 0, width*height*4);

      if (!isSrc) {
          return 0;
      }

      switch(imageP->cmodel.cmType) {
      case INDEX_CM_TYPE3:
          /* REMIND: Need to rearrange according to dst cm */
          /* Fix 4213160, 4184283 */
          if (rasterP->rasterType == COMPONENT_RASTER_TYPE1) {
              return expandICM(env, imageP, (unsigned int *)cDataP);
          }
          else {
              return cvtCustomToDefault(env, imageP, -1, cDataP);
          }

      case DIRECT_CM_TYPE2:
          switch(imageP->raster.dataType) {
          case BYTE_DATA_TYPE1:
              return expandPackedBCRdefault(env, rasterP, -1, cDataP,
                                            !imageP->cmodel.supportsAlpha);
          case SHORT_DATA_TYPE2:
              return expandPackedSCRdefault(env, rasterP, -1, cDataP,
                                            !imageP->cmodel.supportsAlpha);
          case INT_DATA_TYPE3:
              return expandPackedICRdefault(env, rasterP, -1, cDataP,
                                            !imageP->cmodel.supportsAlpha);
          }
      } /* switch(imageP->cmodel.cmType) */

      return cvtCustomToDefault(env, imageP, -1, cDataP);
  }

  /* Interleaved with shared data */
  dataP = (void *) (*env)->GetPrimitiveArrayCritical(env, rasterP->jdata,
                                                     NULL((void*)0));
  if (dataP == NULL((void*)0)) {
      return -1;
  }

  /* Means we need to fill in alpha */
  if (!cvtToDefault && addAlpha) {
      *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, 4, width, height);
      if (*mlibImagePP != NULL((void*)0)) {
          unsigned int *dstP  = (unsigned int *)
              mlib_ImageGetData(*mlibImagePP);
          int dstride = (*mlibImagePP)->stride>>2;
          int sstride = hintP->sStride>>2;
          unsigned int *srcP = (unsigned int *)
              ((unsigned char *)dataP + hintP->dataOffset);
          unsigned int *dP, *sP;
          int x, y;
          for (y=0; y < height; y++, srcP += sstride, dstP += dstride){
              sP = srcP;
              dP = dstP;
              for (x=0; x < width; x++) {
                  dP[x] = sP[x] | 0xff000000;
              }
          }
      }
      (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
                                            JNI_ABORT2);
      return 0;
  }
  else if ((hintP->packing & BYTE_INTERLEAVED(0x1 | 0x10)) == BYTE_INTERLEAVED(0x1 | 0x10)) {
      int nChans = (cmP->isDefaultCompatCM ? 4 : hintP->numChans);
      /* Easy case.  It is or is similar to the default CM so use
   * the array.  Must be byte data.
       */
          /* Create the medialib image */
      *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_BYTE,
                                            nChans,
                                            width,
                                            height,
                                            hintP->sStride,
                                            (unsigned char *)dataP
                                            + hintP->dataOffset);
  }
  else if ((hintP->packing & SHORT_INTERLEAVED(0x2 | 0x10)) == SHORT_INTERLEAVED(0x2 | 0x10)) {
      *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_SHORT,
                                            hintP->numChans,
                                            width,
                                            height,
                                            imageP->raster.scanlineStride*2,
                                            (unsigned short *)dataP
                                            + hintP->channelOffset);
  }
  else {
      /* Release the data array */
      (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
                                            JNI_ABORT2);
      return -1;
  }

  *dataPP = dataP;
  return 0;
2356}

2358static int
2359allocateRasterArray(JNIEnv *env, RasterS_t *rasterP,
                  mlib_image **mlibImagePP, void **dataPP, int isSrc) {
  void *dataP;
  unsigned char *cDataP;
  int dataType = BYTE_DATA_TYPE1;
  int width;
  int height;
  int dataSize;
  int offset;

  *dataPP = NULL((void*)0);

  width = rasterP->width;
  height = rasterP->height;

  if (rasterP->numBands <= 0 || rasterP->numBands > 4) {
      /* REMIND: Fix this */
      return -1;
  }

  /* Useful for convolution? */
  /* This code is zero'ed out so that it cannot be called */

  /* To do this correctly, we need to expand src and dst in the     */
  /* same direction up/down/left/right only if both can be expanded */
  /* in that direction.  Expanding right and down is easy -         */
  /* increment width.  Expanding top and left requires bumping      */
  /* around pointers and incrementing the width/height              */

2388#if 0
  if (0 && useEdges) {
      baseWidth  = rasterP->baseRasterWidth;
      baseHeight = rasterP->baseRasterHeight;
      baseXoff = rasterP->baseOriginX;
      baseYoff = rasterP->baseOriginY;

      if (rasterP->minX + rasterP->width < baseXoff + baseWidth) {
          /* Can use edge */
          width++;
      }
      if (rasterP->minY + rasterP->height < baseYoff + baseHeight) {
          /* Can use edge */
          height++;
      }

      if (rasterP->minX > baseXoff ) {
          /* Can use edge */
          width++;
          /* NEED TO BUMP POINTER BACK A PIXELSTRIDE */
      }
      if (rasterP->minY  > baseYoff) {
          /* Can use edge */
          height++;
          /* NEED TO BUMP POINTER BACK A SCANLINE */
      }


  }
2417#endif
  switch (rasterP->type) {
  case sun_awt_image_IntegerComponentRaster_TYPE_INT_8BIT_SAMPLES10L:
      if (!((rasterP->chanOffsets[0] == 0 || SAFE_TO_ALLOC_2(rasterP->chanOffsets[0], 4)(((rasterP->chanOffsets[0]) > 0) && ((4) > 0
) && ((0x7fffffff / (rasterP->chanOffsets[0])) >
 (4)))) &&
            SAFE_TO_ALLOC_2(width, 4)(((width) > 0) && ((4) > 0) && ((0x7fffffff
 / (width)) > (4))) &&
            SAFE_TO_ALLOC_3(rasterP->scanlineStride, height, 4)(((rasterP->scanlineStride) > 0) && ((height) >
 0) && ((4) > 0) && (((0x7fffffff / (rasterP
->scanlineStride)) / (height)) > (4)))))
      {
          return -1;
      }
      offset = 4 * rasterP->chanOffsets[0];
      dataSize = 4 * (*env)->GetArrayLength(env, rasterP->jdata);

      if (offset < 0 || offset >= dataSize ||
          width > rasterP->scanlineStride ||
          ((width + (height - 1) * rasterP->scanlineStride) * 4) > dataSize - offset)
      {
          // raster data buffer is too short
          return -1;
      }
      dataP = (void *) (*env)->GetPrimitiveArrayCritical(env, rasterP->jdata,
                                                         NULL((void*)0));
      if (dataP == NULL((void*)0)) {
          return -1;
      }
      *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_BYTE, 4,
                                            width, height,
                                            rasterP->scanlineStride*4,
                                            (unsigned char *)dataP + offset);
      *dataPP = dataP;
      return 0;
  case sun_awt_image_IntegerComponentRaster_TYPE_BYTE_SAMPLES1L:
      if (!(SAFE_TO_ALLOC_2(width, rasterP->numBands)(((width) > 0) && ((rasterP->numBands) > 0) &&
 ((0x7fffffff / (width)) > (rasterP->numBands))) &&
            SAFE_TO_ALLOC_2(rasterP->scanlineStride, height)(((rasterP->scanlineStride) > 0) && ((height) >
 0) && ((0x7fffffff / (rasterP->scanlineStride)) >
 (height)))))
      {
          return -1;
      }
      offset = rasterP->chanOffsets[0];
      dataSize = (*env)->GetArrayLength(env, rasterP->jdata);

      if (offset < 0 || offset >= dataSize ||
          width * rasterP->numBands > rasterP->scanlineStride ||
          ((width * rasterP->numBands) +
           (height - 1) * rasterP->scanlineStride) > dataSize - offset)
      {
          // raster data buffer is too short
          return -1;
      }
      dataP = (void *) (*env)->GetPrimitiveArrayCritical(env, rasterP->jdata,
                                                         NULL((void*)0));
      if (dataP == NULL((void*)0)) {
          return -1;
      }
      *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_BYTE, rasterP->numBands,
                                            width, height,
                                            rasterP->scanlineStride,
                                            (unsigned char *)dataP + offset);
      *dataPP = dataP;
      return 0;
  case sun_awt_image_IntegerComponentRaster_TYPE_USHORT_SAMPLES2L:
      if (!((rasterP->chanOffsets[0] == 0 || SAFE_TO_ALLOC_2(rasterP->chanOffsets[0], 2)(((rasterP->chanOffsets[0]) > 0) && ((2) > 0
) && ((0x7fffffff / (rasterP->chanOffsets[0])) >
 (2)))) &&
            SAFE_TO_ALLOC_3(width, rasterP->numBands, 2)(((width) > 0) && ((rasterP->numBands) > 0) &&
 ((2) > 0) && (((0x7fffffff / (width)) / (rasterP->
numBands)) > (2))) &&
            SAFE_TO_ALLOC_3(rasterP->scanlineStride, height, 2)(((rasterP->scanlineStride) > 0) && ((height) >
 0) && ((2) > 0) && (((0x7fffffff / (rasterP
->scanlineStride)) / (height)) > (2)))))
      {
            return -1;
      }
      offset = rasterP->chanOffsets[0] * 2;
      dataSize = 2 * (*env)->GetArrayLength(env, rasterP->jdata);

      if (offset < 0 || offset >= dataSize ||
          width * rasterP->numBands > rasterP->scanlineStride ||
          (((width * rasterP->numBands) +
           (height - 1) * rasterP->scanlineStride)) * 2 > dataSize - offset)
      {
          // raster data buffer is too short
           return -1;
      }
      dataP = (void *) (*env)->GetPrimitiveArrayCritical(env, rasterP->jdata,
                                                         NULL((void*)0));
      if (dataP == NULL((void*)0)) {
          return -1;
      }
      *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_SHORT,
                                                   rasterP->numBands,
                                                   width, height,
                                                   rasterP->scanlineStride*2,
                                                   (unsigned char *)dataP + offset);
      *dataPP = dataP;
      return 0;

  case sun_awt_image_IntegerComponentRaster_TYPE_BYTE_PACKED_SAMPLES7L:
      *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, rasterP->numBands,
                                      width, height);
      if (*mlibImagePP == NULL((void*)0)) {
          return -1;
      }
      if (!isSrc) return 0;
      cDataP  = (unsigned char *) mlib_ImageGetData(*mlibImagePP);
      return expandPackedBCR(env, rasterP, -1, cDataP);

  case sun_awt_image_IntegerComponentRaster_TYPE_USHORT_PACKED_SAMPLES8L:
      if (rasterP->sppsm.maxBitSize <= 8) {
          *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, rasterP->numBands,
                                          width, height);
          if (*mlibImagePP == NULL((void*)0)) {
              return -1;
          }
          if (!isSrc) return 0;
          cDataP  = (unsigned char *) mlib_ImageGetData(*mlibImagePP);
          return expandPackedSCR(env, rasterP, -1, cDataP);
      }
      break;
  case sun_awt_image_IntegerComponentRaster_TYPE_INT_PACKED_SAMPLES9L:
      if (rasterP->sppsm.maxBitSize <= 8) {
          *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, rasterP->numBands,
                                          width, height);
          if (*mlibImagePP == NULL((void*)0)) {
              return -1;
          }
          if (!isSrc) return 0;
          cDataP  = (unsigned char *) mlib_ImageGetData(*mlibImagePP);
          return expandPackedICR(env, rasterP, -1, cDataP);
      }
      break;
  }

  /* Just expand it right now */
  switch (rasterP->dataType) {
  case BYTE_DATA_TYPE1:
      if ((*mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, rasterP->numBands,
                                           width, height)) == NULL((void*)0)) {
          return -1;
      }
      if (isSrc) {
          if (awt_getPixels(env, rasterP, mlib_ImageGetData(*mlibImagePP)) < 0) {
              (*sMlibSysFns.deleteImageFP)(*mlibImagePP);
              return -1;
          }
      }
      break;

  case SHORT_DATA_TYPE2:
      if ((*mlibImagePP = (*sMlibSysFns.createFP)(MLIB_SHORT,
                                                  rasterP->numBands,
                                                  width, height)) == NULL((void*)0)) {
          return -1;
      }
      if (isSrc) {
          if (awt_getPixels(env, rasterP, mlib_ImageGetData(*mlibImagePP)) < 0) {
              (*sMlibSysFns.deleteImageFP)(*mlibImagePP);
              return -1;
          }
      }
      break;

  default:
      return -1;
  }
  return 0;
2575}

2577static void
2578freeArray(JNIEnv *env, BufImageS_t *srcimageP, mlib_image *srcmlibImP,
        void *srcdataP, BufImageS_t *dstimageP, mlib_image *dstmlibImP,
        void *dstdataP) {
  jobject srcJdata = (srcimageP != NULL((void*)0) ? srcimageP->raster.jdata : NULL((void*)0));
  jobject dstJdata = (dstimageP != NULL((void*)0) ? dstimageP->raster.jdata : NULL((void*)0));
  freeDataArray(env, srcJdata, srcmlibImP, srcdataP,
                dstJdata, dstmlibImP, dstdataP);
2585}
2586static void
2587freeDataArray(JNIEnv *env, jobject srcJdata, mlib_image *srcmlibImP,
        void *srcdataP, jobject dstJdata, mlib_image *dstmlibImP,
        void *dstdataP)
2590{
  /* Free the medialib image */
  if (srcmlibImP) {
      (*sMlibSysFns.deleteImageFP)(srcmlibImP);
  }

  /* Release the array */
  if (srcdataP) {
      (*env)->ReleasePrimitiveArrayCritical(env, srcJdata,
                                            srcdataP, JNI_ABORT2);
  }

  /* Free the medialib image */
  if (dstmlibImP) {
      (*sMlibSysFns.deleteImageFP)(dstmlibImP);
  }

  /* Release the array */
  if (dstdataP) {
      (*env)->ReleasePrimitiveArrayCritical(env, dstJdata,
                                            dstdataP, 0);
  }
2612}

2614#define ERR_BAD_IMAGE_LAYOUT(-2) (-2)

2616#define CHECK_DST_ARRAY(start_offset, elements_per_scan, elements_per_pixel)do { int offset = (start_offset); int lastScanOffset; if (!((
((elements_per_scan)) > 0) && (((rasterP->height
 - 1)) >= 0) && ((0x7fffffff / ((elements_per_scan
))) > ((rasterP->height - 1))))) { return (-2); } lastScanOffset
 = (elements_per_scan) * (rasterP->height - 1); if (!(((offset
) >= 0) && ((lastScanOffset) >= 0) && (
(0x7fffffff - (offset)) > (lastScanOffset)))) { return (-2
); } lastScanOffset += offset; if (!((((elements_per_pixel)) >
 0) && ((rasterP->width) >= 0) && ((0x7fffffff
 / ((elements_per_pixel))) > (rasterP->width)))) { return
 (-2); } offset = (elements_per_pixel) * rasterP->width; if
 (!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0); \
  do {                                                                     \
      int offset = (start_offset);                                         \
      int lastScanOffset;                                                  \
                                                                           \
      if (!SAFE_TO_MULT((elements_per_scan),                               \((((elements_per_scan)) > 0) && (((rasterP->height
 - 1)) >= 0) && ((0x7fffffff / ((elements_per_scan
))) > ((rasterP->height - 1))))
                        (rasterP->height - 1))((((elements_per_scan)) > 0) && (((rasterP->height
 - 1)) >= 0) && ((0x7fffffff / ((elements_per_scan
))) > ((rasterP->height - 1)))))                            \
      {                                                                    \
          return ERR_BAD_IMAGE_LAYOUT(-2);                                     \
      }                                                                    \
      lastScanOffset = (elements_per_scan) * (rasterP->height - 1);        \
                                                                           \
      if (!SAFE_TO_ADD(offset, lastScanOffset)(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) {                          \
          return ERR_BAD_IMAGE_LAYOUT(-2);                                     \
      }                                                                    \
      lastScanOffset += offset;                                            \
                                                                           \
      if (!SAFE_TO_MULT((elements_per_pixel), rasterP->width)((((elements_per_pixel)) > 0) && ((rasterP->width
) >= 0) && ((0x7fffffff / ((elements_per_pixel))) >
 (rasterP->width)))) {           \
          return ERR_BAD_IMAGE_LAYOUT(-2);                                     \
      }                                                                    \
      offset = (elements_per_pixel) * rasterP->width;                      \
                                                                           \
      if (!SAFE_TO_ADD(offset, lastScanOffset)(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) {                          \
          return ERR_BAD_IMAGE_LAYOUT(-2);                                     \
      }                                                                    \
      lastScanOffset += offset;                                            \
                                                                           \
      if (dataArrayLength < lastScanOffset) {                              \
          return ERR_BAD_IMAGE_LAYOUT(-2);                                     \
      }                                                                    \
  } while(0);                                                              \

2648static int
2649storeImageArray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
              mlib_image *mlibImP) {
  int mStride;
  unsigned char *cmDataP, *dataP, *cDataP;
  HintS_t *hintP = &dstP->hints;
  RasterS_t *rasterP = &dstP->raster;
  jsize dataArrayLength = (*env)->GetArrayLength(env, rasterP->jdata);
  int y;

  /* REMIND: Store mlib data type? */

  /* Check if it is an IndexColorModel */
  if (dstP->cmodel.cmType == INDEX_CM_TYPE3) {
50
←
Assuming field 'cmType' is not equal to INDEX_CM_TYPE→
51
←
Taking false branch→
      if (dstP->raster.rasterType == COMPONENT_RASTER_TYPE1) {
          return storeICMarray(env, srcP, dstP, mlibImP);
      }
      else {
          /* Packed or some other custom raster */
          cmDataP = (unsigned char *) mlib_ImageGetData(mlibImP);
          return cvtDefaultToCustom(env, dstP, -1, cmDataP);
      }
  }

  if (hintP->packing == BYTE_INTERLEAVED(0x1 | 0x10)) {
52
←
Assuming the condition is false→
53
←
Taking false branch→
      /* Write it back to the destination */
      if (rasterP->dataType != BYTE_DATA_TYPE1) {
          /* We are working with a raster which was marked
             as a byte interleaved due to performance reasons.
             So, we have to convert the length of the data
             array to bytes as well.
          */
          if (!SAFE_TO_MULT(rasterP->dataSize, dataArrayLength)(((rasterP->dataSize) > 0) && ((dataArrayLength
) >= 0) && ((0x7fffffff / (rasterP->dataSize)) >
 (dataArrayLength)))) {
              return ERR_BAD_IMAGE_LAYOUT(-2);
          }
          dataArrayLength *= rasterP->dataSize;
      }

      CHECK_DST_ARRAY(hintP->dataOffset, hintP->sStride, hintP->numChans)do { int offset = (hintP->dataOffset); int lastScanOffset;
 if (!((((hintP->sStride)) > 0) && (((rasterP->
height - 1)) >= 0) && ((0x7fffffff / ((hintP->sStride
))) > ((rasterP->height - 1))))) { return (-2); } lastScanOffset
 = (hintP->sStride) * (rasterP->height - 1); if (!(((offset
) >= 0) && ((lastScanOffset) >= 0) && (
(0x7fffffff - (offset)) > (lastScanOffset)))) { return (-2
); } lastScanOffset += offset; if (!((((hintP->numChans)) >
 0) && ((rasterP->width) >= 0) && ((0x7fffffff
 / ((hintP->numChans))) > (rasterP->width)))) { return
 (-2); } offset = (hintP->numChans) * rasterP->width; if
 (!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
      cmDataP = (unsigned char *) mlib_ImageGetData(mlibImP);
      mStride = mlib_ImageGetStride(mlibImP);
      dataP = (unsigned char *)(*env)->GetPrimitiveArrayCritical(env,
                                                    rasterP->jdata, NULL((void*)0));
      if (dataP == NULL((void*)0)) return 0;
      cDataP = dataP + hintP->dataOffset;
      for (y=0; y < rasterP->height;
           y++, cmDataP += mStride, cDataP += hintP->sStride)
      {
          memcpy(cDataP, cmDataP, rasterP->width*hintP->numChans);
      }
      (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
                                            JNI_ABORT2);
  }
  else if (dstP->cmodel.cmType == DIRECT_CM_TYPE2) {
54
←
Assuming field 'cmType' is equal to DIRECT_CM_TYPE→
55
←
Taking true branch→
      /* Just need to move bits */
      if (mlibImP->type == MLIB_BYTE) {
56
←
Assuming field 'type' is equal to MLIB_BYTE→
57
←
Taking true branch→
          if (dstP->hints.packing == PACKED_BYTE_INTER(0x5 | 0x10)) {
58
←
Assuming the condition is true→
59
←
Taking true branch→
              return setPackedBCRdefault(env, rasterP, -1,
60
←
Calling 'setPackedBCRdefault'→
                                         (unsigned char *) mlibImP->data,
                                         dstP->cmodel.supportsAlpha);
          } else if (dstP->hints.packing == PACKED_SHORT_INTER(0x4 | 0x10)) {
              return setPackedSCRdefault(env, rasterP, -1,
                                         (unsigned char *) mlibImP->data,
                                         dstP->cmodel.supportsAlpha);
          } else if (dstP->hints.packing == PACKED_INT_INTER(0x3 | 0x10)) {
              return setPackedICRdefault(env, rasterP, -1,
                                         (unsigned char *) mlibImP->data,
                                         dstP->cmodel.supportsAlpha);
          }
      }
      else if (mlibImP->type == MLIB_SHORT) {
          return setPixelsFormMlibImage(env, rasterP, mlibImP);
      }
  }
  else {
      return cvtDefaultToCustom(env, dstP, -1,
                                (unsigned char *)mlibImP->data);
  }

  return 0;
2728}

2730static int
2731storeRasterArray(JNIEnv *env, RasterS_t *srcP, RasterS_t *dstP,
              mlib_image *mlibImP) {
  unsigned char *cDataP;

  switch(dstP->type) {
  case sun_awt_image_IntegerComponentRaster_TYPE_BYTE_PACKED_SAMPLES7L:
      cDataP  = (unsigned char *) mlib_ImageGetData(mlibImP);
      return setPackedBCR(env, dstP, -1, cDataP);

  case sun_awt_image_IntegerComponentRaster_TYPE_USHORT_PACKED_SAMPLES8L:
      if (dstP->sppsm.maxBitSize <= 8) {
          cDataP  = (unsigned char *) mlib_ImageGetData(mlibImP);
          return setPackedSCR(env, dstP, -1, cDataP);
      }
      break;
  case sun_awt_image_IntegerComponentRaster_TYPE_INT_PACKED_SAMPLES9L:
      if (dstP->sppsm.maxBitSize <= 8) {
          cDataP  = (unsigned char *) mlib_ImageGetData(mlibImP);
          return setPackedICR(env, dstP, -1, cDataP);
      }
  }

  return -1;
2754}


2757static int
2758storeICMarray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
            mlib_image *mlibImP)
2760{
  int *argb;
  int x, y;
  unsigned char *dataP, *cDataP, *cP;
  unsigned char *sP;
  int aIdx, rIdx, gIdx, bIdx;
  ColorModelS_t *cmodelP = &dstP->cmodel;
  RasterS_t *rasterP = &dstP->raster;

  /* REMIND: Only works for RGB */
  if (cmodelP->csType != java_awt_color_ColorSpace_TYPE_RGB5L) {
      JNU_ThrowInternalError(env, "Writing to non-RGB images not implemented yet");
      return -1;
  }

  if (srcP->imageType == java_awt_image_BufferedImage_TYPE_INT_ARGB2L ||
      srcP->imageType == java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE3L ||
      srcP->imageType == java_awt_image_BufferedImage_TYPE_INT_RGB1L)
  {
      aIdx = 0;
      rIdx = 1;
      gIdx = 2;
      bIdx = 3;
  }
  else if (srcP->imageType ==java_awt_image_BufferedImage_TYPE_4BYTE_ABGR6L||
      srcP->imageType == java_awt_image_BufferedImage_TYPE_4BYTE_ABGR_PRE7L)
  {
      aIdx = 0;
      rIdx = 3;
      gIdx = 2;
      bIdx = 1;
  }
  else if (srcP->imageType == java_awt_image_BufferedImage_TYPE_3BYTE_BGR5L){
      rIdx = 2;
      gIdx = 1;
      bIdx = 0;
      aIdx = 0;       /* Ignored */
  }
  else if (srcP->cmodel.cmType == INDEX_CM_TYPE3) {
      rIdx = 0;
      gIdx = 1;
      bIdx = 2;
      aIdx = 3;   /* Use supportsAlpha to see if it is really there */
  }
  else {
      return -1;
  }

  /* Lock down the destination raster */
  dataP = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env,
                                                rasterP->jdata, NULL((void*)0));
  if (dataP == NULL((void*)0)) {
      return -1;
  }
  argb = (*env)->GetPrimitiveArrayCritical(env, cmodelP->jrgb, NULL((void*)0));
  if (argb == NULL((void*)0)) {
      (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
                                            JNI_ABORT2);
      return -1;
  }

  cDataP = dataP + dstP->hints.dataOffset;
  sP = (unsigned char *) mlib_ImageGetData(mlibImP);

  for (y=0; y < rasterP->height; y++, cDataP += rasterP->scanlineStride) {
      cP = cDataP;
      for (x=0; x < rasterP->width; x++, cP += rasterP->pixelStride) {
          *cP = colorMatch(sP[rIdx], sP[gIdx], sP[bIdx], sP[aIdx],
                           (unsigned char *)argb, cmodelP->mapSize);
          sP += cmodelP->numComponents;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, cmodelP->jrgb, argb, JNI_ABORT2);
  (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
                                        JNI_ABORT2);
  return -1;
2837}

2839static int expandICM(JNIEnv *env, BufImageS_t *imageP, unsigned int *mDataP)
2840{
  ColorModelS_t *cmP = &imageP->cmodel;
  RasterS_t *rasterP = &imageP->raster;
  HintS_t *hintP     = &imageP->hints;
  int *rgb;
  int status = 0;
  unsigned char *dataP, *cP;
  unsigned int *mP;
  int width = rasterP->width;
  int height = rasterP->height;
  int x, y;

  /* Need to grab the lookup tables.  Right now only bytes */
  rgb = (int *) (*env)->GetPrimitiveArrayCritical(env, cmP->jrgb, NULL((void*)0));
  CHECK_NULL_RETURN(rgb, -1)do { if ((rgb) == ((void*)0)) { return (-1); } } while (0);

  /* Interleaved with shared data */
  dataP = (void *) (*env)->GetPrimitiveArrayCritical(env,
                                                     rasterP->jdata, NULL((void*)0));
  if (dataP == NULL((void*)0)) {
      /* Release the lookup tables */
      (*env)->ReleasePrimitiveArrayCritical(env, cmP->jrgb, rgb, JNI_ABORT2);
      return -1;
  }

  if (rasterP->dataType == BYTE_DATA_TYPE1) {
      unsigned char *cDataP = ((unsigned char *)dataP) + hintP->dataOffset;

      for (y=0; y < height; y++) {
          mP = mDataP;
          cP = cDataP;
          for (x=0; x < width; x++, cP += rasterP->pixelStride) {
              *mP++ = rgb[*cP];
          }
          mDataP += width;
          cDataP += rasterP->scanlineStride;
      }
  }
  else if (rasterP->dataType == SHORT_DATA_TYPE2) {
      unsigned short *sDataP, *sP;
      sDataP = ((unsigned short *)dataP) + hintP->channelOffset;

      for (y=0; y < height; y++) {
          mP = mDataP;
          sP = sDataP;
          for (x=0; x < width; x++, sP+=rasterP->pixelStride) {
              *mP++ = rgb[*sP];
          }
          mDataP += width;
          sDataP += rasterP->scanlineStride;
      }
  }
  else {
      /* Unknown type */
      status = -1;
  }
  /* Release the lookup table data */
  (*env)->ReleasePrimitiveArrayCritical(env, imageP->cmodel.jrgb,
                                        rgb, JNI_ABORT2);
  /* Release the data array */
  (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata,
                                        dataP, JNI_ABORT2);
  return status;
2903}
2904/* This routine is expecting a ByteComponentRaster with a PackedColorModel */
2905static int expandPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,
                         unsigned char *outDataP)
2907{
  int x, y, c;
  unsigned char *outP = outDataP;
  unsigned char *lineInP, *inP;
  jarray jInDataP;
  jint   *inDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_BCRdataID);
  inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
  if (inDataP == NULL((void*)0)) {
      return -1;
  }
  lineInP =  (unsigned char *)inDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (roff[c] < 0) {
              loff[c] = -roff[c];
              roff[c] = 0;
          }
          else loff[c] = 0;
      }
      /* Convert the all bands */
      if (rasterP->numBands < 4) {
          /* Need to put in alpha */
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  for (c=0; c < rasterP->numBands; c++) {
                      *outP++ = (unsigned char)
                          (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                           <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
      else {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  for (c=0; c < rasterP->numBands; c++) {
                      *outP++ = (unsigned char)
                          (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                           <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (roff[0] < 0) {
          loff[0] = -roff[0];
          roff[0] = 0;
      }
      else loff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          inP = lineInP;
          for (x=0; x < rasterP->width; x++) {
              *outP++ = (unsigned char)
                  ((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0];
              inP++;
          }
          lineInP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);

  return 0;
2989}

2991/* This routine is expecting a ByteComponentRaster with a PackedColorModel */
2992static int expandPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,
                                int component, unsigned char *outDataP,
                                int forceAlpha)
2995{
  int x, y, c;
  unsigned char *outP = outDataP;
  unsigned char *lineInP, *inP;
  jarray jInDataP;
  jint   *inDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
  int numBands = rasterP->numBands - (forceAlpha ? 0 : 1);
  int a = numBands;

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_BCRdataID);
  inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
  if (inDataP == NULL((void*)0)) {
      return -1;
  }
  lineInP =  (unsigned char *)inDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (roff[c] < 0) {
              loff[c] = -roff[c];
              roff[c] = 0;
          }
          else loff[c] = 0;
      }

      /* Need to put in alpha */
      if (forceAlpha) {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  *outP++ = 0xff;
                  for (c=0; c < numBands; c++) {
                      *outP++ = (unsigned char)
                          (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                           <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
      else {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  *outP++ = (unsigned char)
                      (((*inP&rasterP->sppsm.maskArray[a]) >> roff[a])
                       <<loff[a]);
                  for (c=0; c < numBands; c++) {
                      *outP++ = (unsigned char)
                          (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                           <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (roff[0] < 0) {
          loff[0] = -roff[0];
          roff[0] = 0;
      }
      else loff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          inP = lineInP;
          for (x=0; x < rasterP->width; x++) {
              *outP++ = (unsigned char)
                  ((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0];
              inP++;
          }
          lineInP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);

  return 0;
3083}

3085/* This routine is expecting a ShortComponentRaster with a PackedColorModel */
3086static int expandPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,
                         unsigned char *outDataP)
3088{
  int x, y, c;
  unsigned char *outP = outDataP;
  unsigned short *lineInP, *inP;
  jarray jInDataP;
  jint   *inDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_SCRdataID);
  inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
  if (inDataP == NULL((void*)0)) {
      return -1;
  }
  lineInP =  (unsigned short *)inDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (roff[c] < 0) {
              loff[c] = -roff[c];
              roff[c] = 0;
          }
          else loff[c] = 0;
      }
      /* Convert the all bands */
      if (rasterP->numBands < 4) {
          /* Need to put in alpha */
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  for (c=0; c < rasterP->numBands; c++) {
                      /*
                       *Not correct.  Might need to unpremult,
                       * shift, etc
                       */
                      *outP++ = (unsigned char)
                          (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                           <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      } else {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  for (c=0; c < rasterP->numBands; c++) {
                      /*
                       *Not correct.  Might need to unpremult,
                       * shift, etc
                       */
                      *outP++ = (unsigned char)
                          (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                           <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (roff[0] < 0) {
          loff[0] = -roff[0];
          roff[0] = 0;
      }
      else loff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          inP = lineInP;
          for (x=0; x < rasterP->width; x++) {
              *outP++ = (unsigned char)
                  ((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0];
              inP++;
          }
          lineInP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);

  return 0;
3177}

3179/* This routine is expecting a ShortComponentRaster with a PackedColorModel */
3180static int expandPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,
                                int component, unsigned char *outDataP,
                                int forceAlpha)
3183{
  int x, y, c;
  unsigned char *outP = outDataP;
  unsigned short *lineInP, *inP;
  jarray jInDataP;
  jint   *inDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
  int numBands = rasterP->numBands - (forceAlpha ? 0 : 1);
  int a = numBands;

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_SCRdataID);
  inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
  if (inDataP == NULL((void*)0)) {
      return -1;
  }
  lineInP =  (unsigned short *)inDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (roff[c] < 0) {
              loff[c] = -roff[c];
              roff[c] = 0;
          }
          else loff[c] = 0;
      }

      /* Need to put in alpha */
      if (forceAlpha) {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  *outP++ = 0xff;
                  for (c=0; c < numBands; c++) {
                      /*
                       * Not correct.  Might need to unpremult,
                       * shift, etc
                       */
                      *outP++ = (unsigned char)
                              (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                                 <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
      else {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  *outP++ = (unsigned char)
                      (((*inP&rasterP->sppsm.maskArray[a]) >> roff[a])
                                 <<loff[a]);
                  for (c=0; c < numBands; c++) {
                      /*
                       * Not correct.  Might need to
                       * unpremult, shift, etc
                       */
                      *outP++ = (unsigned char)
                              (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                                 <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (roff[0] < 0) {
          loff[0] = -roff[0];
          roff[0] = 0;
      }
      else loff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          inP = lineInP;
          for (x=0; x < rasterP->width; x++) {
              *outP++ = (unsigned char)
                      ((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0];
              inP++;
          }
          lineInP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);

  return 0;

3280}

3282/* This routine is expecting a IntegerComponentRaster with a PackedColorModel*/
3283static int expandPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,
                         unsigned char *outDataP)
3285{
  int x, y, c;
  unsigned char *outP = outDataP;
  unsigned int *lineInP, *inP;
  jarray jInDataP;
  jint   *inDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_ICRdataID);
  inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
  if (inDataP == NULL((void*)0)) {
      return -1;
  }
  lineInP =  (unsigned int *)inDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (roff[c] < 0) {
              loff[c] = -roff[c];
              roff[c] = 0;
          }
          else loff[c] = 0;
      }
      /* Convert the all bands */
      if (rasterP->numBands < 4) {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  for (c=0; c < rasterP->numBands; c++) {
                      /*
                       * Not correct.  Might need to unpremult,
                       * shift, etc
                       */
                      *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                                 <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
      else {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  for (c=0; c < rasterP->numBands; c++) {
                      /*
                       * Not correct.  Might need to
                       * unpremult, shift, etc
                       */
                      *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                                 <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (roff[0] < 0) {
          loff[0] = -roff[0];
          roff[0] = 0;
      }
      else loff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          inP = lineInP;
          for (x=0; x < rasterP->width; x++) {
              *outP++ = (unsigned char)(((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0]);
              inP++;
          }
          lineInP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);

  return 0;
3371}

3373/* This routine is expecting a IntegerComponentRaster with a PackedColorModel*/
3374static int expandPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,
                                int component, unsigned char *outDataP,
                                int forceAlpha)
3377{
  int x, y, c;
  unsigned char *outP = outDataP;
  unsigned int *lineInP, *inP;
  jarray jInDataP;
  jint   *inDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
  int numBands = rasterP->numBands - (forceAlpha ? 0 : 1);
  int a = numBands;

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_ICRdataID);
  inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
  if (inDataP == NULL((void*)0)) {
      return -1;
  }
  lineInP =  (unsigned int *)inDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (roff[c] < 0) {
              loff[c] = -roff[c];
              roff[c] = 0;
          }
          else loff[c] = 0;
      }

      /* Need to put in alpha */
      if (forceAlpha) {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  *outP++ = 0xff;
                  for (c=0; c < numBands; c++) {
                      /*
                       * Not correct.  Might need to unpremult,
                       * shift, etc
                       */
                      *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                                 <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
      else {
          for (y=0; y < rasterP->height; y++) {
              inP = lineInP;
              for (x=0; x < rasterP->width; x++) {
                  *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[a]) >> roff[a])
                                 <<loff[a]);
                  for (c=0; c < numBands; c++) {
                      /*
                       * Not correct.  Might need to
                       * unpremult, shift, etc
                       */
                      *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
                                 <<loff[c]);
                  }
                  inP++;
              }
              lineInP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (roff[0] < 0) {
          loff[0] = -roff[0];
          roff[0] = 0;
      }
      else loff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          inP = lineInP;
          for (x=0; x < rasterP->width; x++) {
              *outP++ = (unsigned char)(((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0]);
              inP++;
          }
          lineInP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);

  return 0;
3469}

3471/* This routine is expecting a ByteComponentRaster with a PackedColorModel */
3472static int setPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,
                      unsigned char *inDataP)
3474{
  int x, y, c;
  unsigned char *inP = inDataP;
  unsigned char *lineOutP, *outP;
  jarray jOutDataP;
  jsize dataArrayLength;
  unsigned char *outDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_BCRdataID);
  if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
      return -1;
  }

  dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
  CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
 ((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
 offset; if (!((((1)) > 0) && ((rasterP->width)
 >= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
 (!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;

  outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
  if (outDataP == NULL((void*)0)) {
      return -1;
  }
  lineOutP = outDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (loff[c] < 0) {
              roff[c] = -loff[c];
              loff[c] = 0;
          }
          else roff[c] = 0;
      }
      /* Convert the all bands */
      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          *outP = 0;
          for (x=0; x < rasterP->width; x++) {
              for (c=0; c < rasterP->numBands; c++, inP++) {
                  *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
              }
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }
  else {
      c = component;
      loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (loff[0] < 0) {
          roff[0] = -loff[0];
          loff[0] = 0;
      }
      else roff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          for (x=0; x < rasterP->width; x++, inP++) {
              *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);

  return 0;
3545}

3547/* This routine is expecting a ShortComponentRaster with a PackedColorModel */
3548static int setPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,
                         unsigned char *inDataP)
3550{
  int x, y, c;
  unsigned char *inP = inDataP;
  unsigned short *lineOutP, *outP;
  jarray jOutDataP;
  jsize dataArrayLength;
  unsigned short *outDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_SCRdataID);
  if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
      return -1;
  }

  dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
  CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
 ((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
 offset; if (!((((1)) > 0) && ((rasterP->width)
 >= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
 (!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;

  outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
  if (outDataP == NULL((void*)0)) {
      return -1;
  }
  lineOutP = outDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (loff[c] < 0) {
              roff[c] = -loff[c];
              loff[c] = 0;
          }
          else roff[c] = 0;
      }
      /* Convert the all bands */
      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          for (x=0; x < rasterP->width; x++) {
              for (c=0; c < rasterP->numBands; c++, inP++) {
                  /* Not correct.  Might need to unpremult, shift, etc */
                  *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
              }
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }
  else {
      c = component;
      loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (loff[0] < 0) {
          roff[0] = -loff[0];
          loff[0] = 0;
      }
      else roff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          for (x=0; x < rasterP->width; x++, inP++) {
              *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);

  return 0;
3621}

3623/* This routine is expecting a IntegerComponentRaster with a PackedColorModel*/
3624static int setPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,
                         unsigned char *inDataP)
3626{
  int x, y, c;
  unsigned char *inP = inDataP;
  unsigned int *lineOutP, *outP;
  jarray jOutDataP;
  jsize dataArrayLength;
  unsigned int *outDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_ICRdataID);
  if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
      return -1;
  }

  dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
  CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
 ((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
 offset; if (!((((1)) > 0) && ((rasterP->width)
 >= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
 (!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;

  outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
  if (outDataP == NULL((void*)0)) {
      return -1;
  }
  lineOutP = outDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (loff[c] < 0) {
              roff[c] = -loff[c];
              loff[c] = 0;
          }
          else roff[c] = 0;
      }
      /* Convert the all bands */
      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          for (x=0; x < rasterP->width; x++) {
              for (c=0; c < rasterP->numBands; c++, inP++) {
                  /* Not correct.  Might need to unpremult, shift, etc */
                  *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
              }
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }
  else {
      c = component;
      loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (loff[0] < 0) {
          roff[0] = -loff[0];
          loff[0] = 0;
      }
      else roff[c] = 0;

      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          for (x=0; x < rasterP->width; x++, inP++) {
              *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);

  return 0;
3698}

3700/* This routine is expecting a ByteComponentRaster with a PackedColorModel */
3701static int setPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,
                             int component, unsigned char *inDataP,
                             int supportsAlpha)
3704{
  int x, y, c;
  unsigned char *inP = inDataP;
  unsigned char *lineOutP, *outP;
  jarray jOutDataP;
  jsize  dataArrayLength;
  unsigned char *outDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
  int a = rasterP->numBands - 1;

  if (rasterP->numBands > MAX_NUMBANDS32) {
61
←
Assuming field 'numBands' is <= MAX_NUMBANDS→
62
←
Taking false branch→
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_BCRdataID);
  if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
63
←
Assuming 'jOutDataP' is not equal to null→
64
←
Taking false branch→
      return -1;
  }

  dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
  CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
 ((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
 offset; if (!((((1)) > 0) && ((rasterP->width)
 >= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
 (!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
65
←
Assuming field 'scanlineStride' is > 0→
66
←
Assuming the condition is true→
67
←
Assuming the condition is true→
68
←
Taking false branch→
69
←
Assuming 'offset' is >= 0→
70
←
Assuming 'lastScanOffset' is >= 0→
71
←
Assuming the condition is true→
72
←
Taking false branch→
73
←
Assuming field 'width' is >= 0→
74
←
Assuming the condition is true→
75
←
Taking false branch→
76
←
Assuming 'lastScanOffset' is >= 0→
77
←
Assuming the condition is true→
78
←
Taking false branch→
79
←
Assuming 'dataArrayLength' is >= 'lastScanOffset'→
80
←
Taking false branch→
81
←
Loop condition is false.  Exiting loop→

  outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
  if (outDataP == NULL((void*)0)) {
82
←
Assuming 'outDataP' is not equal to NULL→
83
←
Taking false branch→
      return -1;
  }
  lineOutP = outDataP + rasterP->chanOffsets[0];

  if (component83.1
'component' is < 0
 < 0) {
84
←
Taking true branch→
      for (c=0; c < rasterP->numBands; c++) {
85
←
Assuming 'c' is >= field 'numBands'→
86
←
Loop condition is false. Execution continues on line 3743→
          loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (loff[c] < 0) {
              roff[c] = -loff[c];
              loff[c] = 0;
          }
          else roff[c] = 0;
      }
      /* Convert the all bands */
      if (supportsAlpha) {
87
←
Assuming 'supportsAlpha' is not equal to 0→
88
←
Taking true branch→
          for (y=0; y < rasterP->height; y++) {
89
←
Assuming 'y' is < field 'height'→
90
←
Loop condition is true.  Entering loop body→
              outP = lineOutP;
              *outP = 0;
              for (x=0; x < rasterP->width; x++) {
91
←
Assuming 'x' is < field 'width'→
92
←
Loop condition is true.  Entering loop body→
                  *outP |= (*inP<<loff[a]>>roff[a])&
                      rasterP->sppsm.maskArray[a];
                  inP++;
                  for (c=0; c < rasterP->numBands-1; c++, inP++) {
93
←
The value 0 is assigned to 'c'→
94
←
Assuming the condition is true→
95
←
Loop condition is true.  Entering loop body→
                      *outP |= (*inP<<loff[c]>>roff[c])&
96
←
The right operand of '<<' is a garbage value
                          rasterP->sppsm.maskArray[c];
                  }
                  outP++;
              }
              lineOutP += rasterP->scanlineStride;
          }
      }
      else {
          for (y=0; y < rasterP->height; y++) {
              outP = lineOutP;
              *outP = 0;
              for (x=0; x < rasterP->width; x++) {
                  inP++;
                  for (c=0; c < rasterP->numBands; c++, inP++) {
                      *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
                  }
                  outP++;
              }
              lineOutP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (loff[0] < 0) {
          roff[0] = -loff[0];
          loff[0] = 0;
      }
      else roff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          for (x=0; x < rasterP->width; x++, inP++) {
              *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);

  return 0;
3796}

3798/* This routine is expecting a ShortComponentRaster with a PackedColorModel */
3799static int setPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,
                             int component, unsigned char *inDataP,
                             int supportsAlpha)
3802{
  int x, y, c;
  unsigned char *inP = inDataP;
  unsigned short *lineOutP, *outP;
  jarray jOutDataP;
  jsize dataArrayLength;
  unsigned short *outDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
  int a = rasterP->numBands - 1;

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_SCRdataID);
  if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
      return -1;
  }
  dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
  CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
 ((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
 offset; if (!((((1)) > 0) && ((rasterP->width)
 >= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
 (!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;

  outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
  if (outDataP == NULL((void*)0)) {
      return -1;
  }
  lineOutP = outDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (loff[c] < 0) {
              roff[c] = -loff[c];
              loff[c] = 0;
          }
          else roff[c] = 0;
      }
      /* Convert the all bands */
      if (supportsAlpha) {
          for (y=0; y < rasterP->height; y++) {
              outP = lineOutP;
              for (x=0; x < rasterP->width; x++) {
                  *outP |= (*inP<<loff[a]>>roff[a])&
                      rasterP->sppsm.maskArray[a];
                  inP++;
                  for (c=0; c < rasterP->numBands-1; c++, inP++) {
                      /* Not correct.  Might need to unpremult, shift, etc */
                      *outP |= (*inP<<loff[c]>>roff[c])&
                          rasterP->sppsm.maskArray[c];
                  }
                  outP++;
              }
              lineOutP += rasterP->scanlineStride;
          }
      }
      else {
          for (y=0; y < rasterP->height; y++) {
              outP = lineOutP;
              for (x=0; x < rasterP->width; x++) {
                  inP++;
                  for (c=0; c < rasterP->numBands; c++, inP++) {
                      /* Not correct.  Might need to unpremult, shift, etc */
                      *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
                  }
                  outP++;
              }
              lineOutP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (loff[0] < 0) {
          roff[0] = -loff[0];
          loff[0] = 0;
      }
      else roff[c] = 0;
      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          for (x=0; x < rasterP->width; x++, inP++) {
              *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);

  return 0;
3893}

3895/* This routine is expecting a IntegerComponentRaster with a PackedColorModel*/
3896static int setPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,
                             int component, unsigned char *inDataP,
                             int supportsAlpha)
3899{
  int x, y, c;
  unsigned char *inP = inDataP;
  unsigned int *lineOutP, *outP;
  jarray jOutDataP;
  jsize dataArrayLength;
  unsigned int *outDataP;
  int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
  int a = rasterP->numBands - 1;

  if (rasterP->numBands > MAX_NUMBANDS32) {
      return -1;
  }

  /* Grab data ptr, strides, offsets from raster */
  jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_ICRdataID);
  if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
      return -1;
  }

  dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
  CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
 ((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
 offset; if (!((((1)) > 0) && ((rasterP->width)
 >= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
 (!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
 ((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;

  outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
  if (outDataP == NULL((void*)0)) {
      return -1;
  }
  lineOutP = outDataP + rasterP->chanOffsets[0];

  if (component < 0) {
      for (c=0; c < rasterP->numBands; c++) {
          loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
          if (loff[c] < 0) {
              roff[c] = -loff[c];
              loff[c] = 0;
          }
          else roff[c] = 0;
      }
      /* Convert the all bands */
      if (supportsAlpha) {
          for (y=0; y < rasterP->height; y++) {
              outP = lineOutP;
              for (x=0; x < rasterP->width; x++) {
                  *outP |= (*inP<<loff[a]>>roff[a])&
                      rasterP->sppsm.maskArray[a];
                  inP++;
                  for (c=0; c < rasterP->numBands-1; c++, inP++) {
                      /* Not correct.  Might need to unpremult, shift, etc */
                      *outP |= (*inP<<loff[c]>>roff[c])&
                          rasterP->sppsm.maskArray[c];
                  }
                  outP++;
              }
              lineOutP += rasterP->scanlineStride;
          }
      }
      else {
          for (y=0; y < rasterP->height; y++) {
              outP = lineOutP;
              for (x=0; x < rasterP->width; x++) {
                  inP++;
                  for (c=0; c < rasterP->numBands; c++, inP++) {
                      /* Not correct.  Might need to unpremult, shift, etc */
                      *outP |= (*inP<<loff[c]>>roff[c])&
                          rasterP->sppsm.maskArray[c];
                  }
                  outP++;
              }
              lineOutP += rasterP->scanlineStride;
          }
      }
  }
  else {
      c = component;
      loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
      if (loff[0] < 0) {
          roff[0] = -loff[0];
          loff[0] = 0;
      }
      else roff[c] = 0;

      for (y=0; y < rasterP->height; y++) {
          outP = lineOutP;
          for (x=0; x < rasterP->width; x++, inP++) {
              *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
              outP++;
          }
          lineOutP += rasterP->scanlineStride;
      }
  }

  (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);

  return 0;
3993}

3995/* This is temporary code.  Should go away when there is better color
* conversion code available.
* REMIND:  Ignoring alpha
*/
3999/* returns the absolute value x */
4000#define ABS(x)((x) < 0 ? -(x) : (x)) ((x) < 0 ? -(x) : (x))
4001#define CLIP(val,min,max)((val < min) ? min : ((val > max) ? max : val))       ((val < min) ? min : ((val > max) ? max : val))

4003static int
4004colorMatch(int r, int g, int b, int a, unsigned char *argb, int numColors) {
  int besti = 0;
  int mindist, i, t, d;
  unsigned char red, green, blue;

  r = CLIP(r, 0, 255)((r < 0) ? 0 : ((r > 255) ? 255 : r));
  g = CLIP(g, 0, 255)((g < 0) ? 0 : ((g > 255) ? 255 : g));
  b = CLIP(b, 0, 255)((b < 0) ? 0 : ((b > 255) ? 255 : b));

  /* look for pure gray match */
  if ((r == g) && (g == b)) {
      mindist = 256;
      for (i = 0 ; i < numColors ; i++, argb+=4) {
          red = argb[1];
          green = argb[2];
          blue = argb[3];
          if (! ((red == green) && (green == blue)) ) {
              continue;
          }
          d = ABS(red - r)((red - r) < 0 ? -(red - r) : (red - r));
          if (d == 0)
              return i;
          if (d < mindist) {
              besti = i;
              mindist = d;
          }
      }
      return besti;
  }

  /* look for non-pure gray match */
  mindist = 256 * 256 * 256;
  for (i = 0 ; i < numColors ; i++, argb+=4) {
      red = argb[1];
      green = argb[2];
      blue = argb[3];
      t = red - r;
      d = t * t;
      if (d >= mindist) {
          continue;
      }
      t = green - g;
      d += t * t;
      if (d >= mindist) {
          continue;
      }
      t = blue - b;
      d += t * t;
      if (d >= mindist) {
          continue;
      }
      if (d == 0)
          return i;
      if (d < mindist) {
          besti = i;
          mindist = d;
      }
  }

  return besti;
4064}