private int ippFilter()

in modules/awt/src/main/java/common/java/awt/image/BandCombineOp.java [299:476]
149 lines of code
45 McCabe index (conditional complexity)

    private int ippFilter(Raster src, WritableRaster dst) {
        boolean invertChannels;
        boolean inPlace = (src == dst);
        int type;
        int srcStride, dstStride;
        int offsets[] = null;

        int srcBands = src.getNumBands();
        int dstBands = dst.getNumBands();

        if (
                dstBands != 3 ||
                (srcBands != 3 &&
                !(srcBands == 4 &&
                  matrix[0][3] == 0 &&
                  matrix[1][3] == 0 &&
                  matrix[2][3] == 0)
                )
        ) {
            return slowFilter(src, dst);
        }

        SampleModel srcSM = src.getSampleModel();
        SampleModel dstSM = dst.getSampleModel();

        if (
                srcSM instanceof SinglePixelPackedSampleModel &&
                dstSM instanceof SinglePixelPackedSampleModel
        ) {
            // Check SinglePixelPackedSampleModel
            SinglePixelPackedSampleModel sppsm1 = (SinglePixelPackedSampleModel) srcSM;
            SinglePixelPackedSampleModel sppsm2 = (SinglePixelPackedSampleModel) dstSM;

            if (
                    sppsm1.getDataType() != DataBuffer.TYPE_INT ||
                    sppsm2.getDataType() != DataBuffer.TYPE_INT
            ) {
                return slowFilter(src, dst);
            }

            // Check sample models
            if (
                    !Arrays.equals(sppsm2.getBitOffsets(), offsets3c) ||
                    !Arrays.equals(sppsm2.getBitMasks(), masks3c)
            ) {
                return slowFilter(src, dst);
            }

            if (srcBands == 3) {
                if (
                        !Arrays.equals(sppsm1.getBitOffsets(), offsets3c) ||
                        !Arrays.equals(sppsm1.getBitMasks(), masks3c)
                ) {
                    return slowFilter(src, dst);
                }
            } else if (srcBands == 4) {
                if (
                        !Arrays.equals(sppsm1.getBitOffsets(), offsets4ac) ||
                        !Arrays.equals(sppsm1.getBitMasks(), masks4ac)
                ) {
                    return slowFilter(src, dst);
                }
            }

            type = TYPE_BYTE4AC;
            invertChannels = true;

            srcStride = sppsm1.getScanlineStride() * 4;
            dstStride = sppsm2.getScanlineStride() * 4;
        } else if (
            srcSM instanceof PixelInterleavedSampleModel &&
            dstSM instanceof PixelInterleavedSampleModel
        ) {
            if (srcBands != 3) {
                return slowFilter(src, dst);
            }

            int srcDataType = srcSM.getDataType();

            switch (srcDataType) {
                case DataBuffer.TYPE_BYTE:
                    type = TYPE_BYTE3C;
                    break;
                case DataBuffer.TYPE_USHORT:
                    type = TYPE_USHORT3C;
                    break;
                case DataBuffer.TYPE_SHORT:
                    type = TYPE_SHORT3C;
                    break;
                default:
                    return slowFilter(src, dst);
            }

            // Check PixelInterleavedSampleModel
            PixelInterleavedSampleModel pism1 = (PixelInterleavedSampleModel) srcSM;
            PixelInterleavedSampleModel pism2 = (PixelInterleavedSampleModel) dstSM;

            if (
                    srcDataType != pism2.getDataType() ||
                    pism1.getPixelStride() != 3 ||
                    pism2.getPixelStride() != 3 ||
                    !Arrays.equals(pism1.getBandOffsets(), pism2.getBandOffsets())
            ) {
                return slowFilter(src, dst);
            }

            if (Arrays.equals(pism1.getBandOffsets(), piInvOffsets)) {
                invertChannels = true;
            } else if (Arrays.equals(pism1.getBandOffsets(), piOffsets)) {
                invertChannels = false;
            } else {
                return slowFilter(src, dst);
            }

            int dataTypeSize = DataBuffer.getDataTypeSize(srcDataType) / 8;

            srcStride = pism1.getScanlineStride() * dataTypeSize;
            dstStride = pism2.getScanlineStride() * dataTypeSize;
        } else { // XXX - todo - IPP allows support for planar data also
            return slowFilter(src, dst);
        }

        // Fill offsets if there's a child raster
        if (src.getParent() != null || dst.getParent() != null) {
            if (src.getSampleModelTranslateX() != 0 || src.getSampleModelTranslateY() != 0 ||
               dst.getSampleModelTranslateX() != 0 || dst.getSampleModelTranslateY() != 0) {
                offsets = new int[4];
                offsets[0] = -src.getSampleModelTranslateX() + src.getMinX();
                offsets[1] = -src.getSampleModelTranslateY() + src.getMinY();
                offsets[2] = -dst.getSampleModelTranslateX() + dst.getMinX();
                offsets[3] = -dst.getSampleModelTranslateY() + dst.getMinY();
            }
        }

        Object srcData, dstData;
        AwtImageBackdoorAccessor dbAccess = AwtImageBackdoorAccessor.getInstance();
        try {
            srcData = dbAccess.getData(src.getDataBuffer());
            dstData = dbAccess.getData(dst.getDataBuffer());
        } catch (IllegalArgumentException e) {
            return -1; // Unknown data buffer type
        }

        float ippMatrix[] = new float[12];

        if (invertChannels) {
            // IPP treats big endian integers like BGR, so we have to
            // swap columns 1 and 3 and rows 1 and 3
            for (int i = 0; i < mxHeight; i++) {
                ippMatrix[i*4] = matrix[2-i][2];
                ippMatrix[i*4+1] = matrix[2-i][1];
                ippMatrix[i*4+2] = matrix[2-i][0];

                if (mxWidth == 4) {
                    ippMatrix[i*4+3] = matrix[2-i][3];
                } else if (mxWidth == 5) {
                    ippMatrix[i*4+3] = matrix[2-i][4];
                }
            }
        } else {
            for (int i = 0; i < mxHeight; i++) {
                ippMatrix[i*4] = matrix[i][0];
                ippMatrix[i*4+1] = matrix[i][1];
                ippMatrix[i*4+2] = matrix[i][2];

                if (mxWidth == 4) {
                    ippMatrix[i*4+3] = matrix[i][3];
                } else if (mxWidth == 5) {
                    ippMatrix[i*4+3] = matrix[i][4];
                }
            }
        }

        return ippColorTwist(
                srcData, src.getWidth(), src.getHeight(), srcStride,
                dstData, dst.getWidth(), dst.getHeight(), dstStride,
                ippMatrix, type, offsets, inPlace);
    }