override fun readFromPngRaw()

in plot-api/src/commonMain/kotlin/org/jetbrains/letsPlot/util/pngj/ImageLineInt.kt [91:163]
73 lines of code
16 McCabe index (conditional complexity)

    override fun readFromPngRaw(raw: ByteArray, len: Int, offset: Int, step: Int) {
        filterType = FilterType.getByVal(raw[0].toInt())
        val len1 = len - 1
        val step1: Int = (step - 1) * imgInfo.channels
        if (imgInfo.bitDepth == 8) {
            if (step == 1) { // 8bispp non-interlaced: most important case, should be optimized
                for (i in 0 until size) {
                    scanline[i] = raw[i + 1].toInt() and 0xff
                }
            } else { // 8bispp interlaced
                var s = 1
                var c = 0
                var i: Int = offset * imgInfo.channels
                while (s <= len1) {
                    scanline[i] = raw[s].toInt() and 0xff
                    c++
                    if (c == imgInfo.channels) {
                        c = 0
                        i += step1
                    }
                    s++
                    i++
                }
            }
        } else if (imgInfo.bitDepth == 16) {
            if (step == 1) { // 16bispp non-interlaced
                var i = 0
                var s = 1
                while (i < size) {
                    scanline[i] = raw[s++].toInt() and 0xFF shl 8 or (raw[s++].toInt() and 0xFF) // 16 bitspc
                    i++
                }
            } else {
                var s = 1
                var c = 0
                var i = if (offset != 0) offset * imgInfo.channels else 0
                while (s <= len1) {
                    scanline[i] = raw[s++].toInt() and 0xFF shl 8 or (raw[s].toInt() and 0xFF) // 16 bitspc
                    c++
                    if (c == imgInfo.channels) {
                        c = 0
                        i += step1
                    }
                    s++
                    i++
                }
            }
        } else { // packed formats
            val mask0: Int
            var mask: Int
            var shi: Int
            val bd: Int = imgInfo.bitDepth
            mask0 = getMaskForPackedFormats(bd)
            var i: Int = offset * imgInfo.channels
            var r = 1
            var c = 0
            while (r < len) {
                mask = mask0
                shi = 8 - bd
                do {
                    scanline[i++] = raw[r].toInt() and mask shr shi
                    mask = mask shr bd
                    shi -= bd
                    c++
                    if (c == imgInfo.channels) {
                        c = 0
                        i += step1
                    }
                } while (mask != 0 && i < size)
                r++
            }
        }
    }