/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwt.internal.image.WinBMPFileFormat;

import dwt.internal.image.FileFormat;
import dwt.graphics.PaletteData;
import dwt.graphics.Point;
import dwt.graphics.RGB;
import dwt.dwthelper.ByteArrayOutputStream;
import dwt.DWT;
import dwt.dwthelper.utils;

import tango.core.Exception;

final class WinBMPFileFormat : FileFormat {

    static final int BMPFileHeaderSize = 14;
    static final int BMPHeaderFixedSize = 40;
    int importantColors;
    Point pelsPerMeter;

public this(){
    pelsPerMeter = new Point(0, 0);
}

/**
 * Compress numBytes bytes of image data from src, storing in dest
 * (starting at 0), using the technique specified by comp.
 * If last is true, this indicates the last line of the image.
 * Answer the size of the compressed data.
 */
int compress(int comp, byte[] src, int srcOffset, int numBytes, byte[] dest, bool last) {
    if (comp is 1) { // BMP_RLE8_COMPRESSION
        return compressRLE8Data(src, srcOffset, numBytes, dest, last);
    }
    if (comp is 2) { // BMP_RLE4_COMPRESSION
        return compressRLE4Data(src, srcOffset, numBytes, dest, last);
    }
    DWT.error(DWT.ERROR_INVALID_IMAGE);
    return 0;
}
int compressRLE4Data(byte[] src, int srcOffset, int numBytes, byte[] dest, bool last) {
    int sp = srcOffset, end = srcOffset + numBytes, dp = 0;
    int size = 0, left, i, n;
    byte theByte;
    while (sp < end) {
        /* find two consecutive bytes that are the same in the next 128 */
        left = end - sp - 1;
        if (left > 127)
            left = 127;
        for (n = 0; n < left; n++) {
            if (src[sp + n] is src[sp + n + 1])
                break;
        }
        /* if there is only one more byte in the scan line, include it */
        if (n < 127 && n is left)
            n++;
        /* store the intervening data */
        switch (n) {
            case 0:
                break;
            case 1: /* handled separately because 0,2 is a command */
                dest[dp] = 2; dp++; /* 1 byte is 2 pixels */
                dest[dp] = src[sp];
                dp++; sp++;
                size += 2;
                break;
            default:
                dest[dp] = 0; dp++;
                dest[dp] = cast(byte)(n + n); dp++; /* n bytes = n*2 pixels */
                for (i = n; i > 0; i--) {
                    dest[dp] = src[sp];
                    dp++; sp++;
                }
                size += 2 + n;
                if ((n & 1) !is 0) { /* pad to word */
                    dest[dp] = 0;
                    dp++;
                    size++;
                }
                break;
        }
        /* find the length of the next run (up to 127) and store it */
        left = end - sp;
        if (left > 0) {
            if (left > 127)
                left = 127;
            theByte = src[sp];
            for (n = 1; n < left; n++) {
                if (src[sp + n] !is theByte)
                    break;
            }
            dest[dp] = cast(byte)(n + n); dp++; /* n bytes = n*2 pixels */
            dest[dp] = theByte; dp++;
            sp += n;
            size += 2;
        }
    }

    /* store the end of line or end of bitmap codes */
    dest[dp] = 0; dp++;
    if (last) {
        dest[dp] = 1; dp++;
    } else {
        dest[dp] = 0; dp++;
    }
    size += 2;

    return size;
}
int compressRLE8Data(byte[] src, int srcOffset, int numBytes, byte[] dest, bool last) {
    int sp = srcOffset, end = srcOffset + numBytes, dp = 0;
    int size = 0, left, i, n;
    byte theByte;
    while (sp < end) {
        /* find two consecutive bytes that are the same in the next 256 */
        left = end - sp - 1;
        if (left > 254)
            left = 254;
        for (n = 0; n < left; n++) {
            if (src[sp + n] is src[sp + n + 1])
                break;
        }
        /* if there is only one more byte in the scan line, include it */
        if (n is left)
            n++;
        /* store the intervening data */
        switch (n) {
            case 0:
                break;
            case 2: /* handled separately because 0,2 is a command */
                dest[dp] = 1; dp++;
                dest[dp] = src[sp];
                dp++; sp++;
                size += 2;
                /* don't break, fall through */
            case 1: /* handled separately because 0,1 is a command */
                dest[dp] = 1; dp++;
                dest[dp] = src[sp];
                dp++; sp++;
                size += 2;
                break;
            default:
                dest[dp] = 0; dp++;
                dest[dp] = cast(byte)n; dp++;
                for (i = n; i > 0; i--) {
                    dest[dp] = src[sp];
                    dp++; sp++;
                }
                size += 2 + n;
                if ((n & 1) !is 0) { /* pad to word */
                    dest[dp] = 0;
                    dp++;
                    size++;
                }
                break;
        }
        /* find the length of the next run (up to 255) and store it */
        left = end - sp;
        if (left > 0) {
            if (left > 255)
                left = 255;
            theByte = src[sp];
            for (n = 1; n < left; n++) {
                if (src[sp + n] !is theByte)
                    break;
            }
            dest[dp] = cast(byte)n; dp++;
            dest[dp] = theByte; dp++;
            sp += n;
            size += 2;
        }
    }

    /* store the end of line or end of bitmap codes */
    dest[dp] = 0; dp++;
    if (last) {
        dest[dp] = 1; dp++;
    } else {
        dest[dp] = 0; dp++;
    }
    size += 2;

    return size;
}
void decompressData(byte[] src, byte[] dest, int stride, int cmp) {
    if (cmp is 1) { // BMP_RLE8_COMPRESSION
        if (decompressRLE8Data(src, src.length, stride, dest, dest.length) <= 0)
            DWT.error(DWT.ERROR_INVALID_IMAGE);
        return;
    }
    if (cmp is 2) { // BMP_RLE4_COMPRESSION
        if (decompressRLE4Data(src, src.length, stride, dest, dest.length) <= 0)
            DWT.error(DWT.ERROR_INVALID_IMAGE);
        return;
    }
    DWT.error(DWT.ERROR_INVALID_IMAGE);
}
int decompressRLE4Data(byte[] src, int numBytes, int stride, byte[] dest, int destSize) {
    int sp = 0;
    int se = numBytes;
    int dp = 0;
    int de = destSize;
    int x = 0, y = 0;
    while (sp < se) {
        int len = src[sp] & 0xFF;
        sp++;
        if (len is 0) {
            len = src[sp] & 0xFF;
            sp++;
            switch (len) {
                case 0: /* end of line */
                    y++;
                    x = 0;
                    dp = y * stride;
                    if (dp > de)
                        return -1;
                    break;
                case 1: /* end of bitmap */
                    return 1;
                case 2: /* delta */
                    x += src[sp] & 0xFF;
                    sp++;
                    y += src[sp] & 0xFF;
                    sp++;
                    dp = y * stride + x / 2;
                    if (dp > de)
                        return -1;
                    break;
                default: /* absolute mode run */
                    if ((len & 1) !is 0) /* odd run lengths not currently supported */
                        return -1;
                    x += len;
                    len = len / 2;
                    if (len > (se - sp))
                        return -1;
                    if (len > (de - dp))
                        return -1;
                    for (int i = 0; i < len; i++) {
                        dest[dp] = src[sp];
                        dp++;
                        sp++;
                    }
                    if ((sp & 1) !is 0)
                        sp++; /* word align sp? */
                    break;
            }
        } else {
            if ((len & 1) !is 0)
                return -1;
            x += len;
            len = len / 2;
            byte theByte = src[sp];
            sp++;
            if (len > (de - dp))
                return -1;
            for (int i = 0; i < len; i++) {
                dest[dp] = theByte;
                dp++;
            }
        }
    }
    return 1;
}
int decompressRLE8Data(byte[] src, int numBytes, int stride, byte[] dest, int destSize) {
    int sp = 0;
    int se = numBytes;
    int dp = 0;
    int de = destSize;
    int x = 0, y = 0;
    while (sp < se) {
        int len = src[sp] & 0xFF;
        sp++;
        if (len is 0) {
            len = src[sp] & 0xFF;
            sp++;
            switch (len) {
                case 0: /* end of line */
                    y++;
                    x = 0;
                    dp = y * stride;
                    if (dp > de)
                        return -1;
                    break;
                case 1: /* end of bitmap */
                    return 1;
                case 2: /* delta */
                    x += src[sp] & 0xFF;
                    sp++;
                    y += src[sp] & 0xFF;
                    sp++;
                    dp = y * stride + x;
                    if (dp > de)
                        return -1;
                    break;
                default: /* absolute mode run */
                    if (len > (se - sp))
                        return -1;
                    if (len > (de - dp))
                        return -1;
                    for (int i = 0; i < len; i++) {
                        dest[dp] = src[sp];
                        dp++;
                        sp++;
                    }
                    if ((sp & 1) !is 0)
                        sp++; /* word align sp? */
                    x += len;
                    break;
            }
        } else {
            byte theByte = src[sp];
            sp++;
            if (len > (de - dp))
                return -1;
            for (int i = 0; i < len; i++) {
                dest[dp] = theByte;
                dp++;
            }
            x += len;
        }
    }
    return 1;
}
override bool isFileFormat(LEDataInputStream stream) {
    try {
        byte[] header = new byte[18];
        stream.read(header);
        stream.unread(header);
        int infoHeaderSize = (header[14] & 0xFF) | ((header[15] & 0xFF) << 8) | ((header[16] & 0xFF) << 16) | ((header[17] & 0xFF) << 24);
        return header[0] is 0x42 && header[1] is 0x4D && infoHeaderSize >= BMPHeaderFixedSize;
    } catch (Exception e) {
        return false;
    }
}
byte[] loadData(byte[] infoHeader) {
    int width = (infoHeader[4] & 0xFF) | ((infoHeader[5] & 0xFF) << 8) | ((infoHeader[6] & 0xFF) << 16) | ((infoHeader[7] & 0xFF) << 24);
    int height = (infoHeader[8] & 0xFF) | ((infoHeader[9] & 0xFF) << 8) | ((infoHeader[10] & 0xFF) << 16) | ((infoHeader[11] & 0xFF) << 24);
    int bitCount = (infoHeader[14] & 0xFF) | ((infoHeader[15] & 0xFF) << 8);
    int stride = (width * bitCount + 7) / 8;
    stride = (stride + 3) / 4 * 4; // Round up to 4 byte multiple
    byte[] data = loadData(infoHeader, stride);
    flipScanLines(data, stride, height);
    return data;
}
byte[] loadData(byte[] infoHeader, int stride) {
    int height = (infoHeader[8] & 0xFF) | ((infoHeader[9] & 0xFF) << 8) | ((infoHeader[10] & 0xFF) << 16) | ((infoHeader[11] & 0xFF) << 24);
    if (height < 0) height = -height;
    int dataSize = height * stride;
    byte[] data = new byte[dataSize];
    int cmp = (infoHeader[16] & 0xFF) | ((infoHeader[17] & 0xFF) << 8) | ((infoHeader[18] & 0xFF) << 16) | ((infoHeader[19] & 0xFF) << 24);
    if (cmp is 0 || cmp is 3) { // BMP_NO_COMPRESSION
        try {
            if (inputStream.read(data) !is dataSize)
                DWT.error(DWT.ERROR_INVALID_IMAGE);
        } catch (IOException e) {
            DWT.error(DWT.ERROR_IO, e);
        }
    } else {
        int compressedSize = (infoHeader[20] & 0xFF) | ((infoHeader[21] & 0xFF) << 8) | ((infoHeader[22] & 0xFF) << 16) | ((infoHeader[23] & 0xFF) << 24);
        byte[] compressed = new byte[compressedSize];
        try {
            if (inputStream.read(compressed) !is compressedSize)
                DWT.error(DWT.ERROR_INVALID_IMAGE);
        } catch (IOException e) {
            DWT.error(DWT.ERROR_IO, e);
        }
        decompressData(compressed, data, stride, cmp);
    }
    return data;
}
int[] loadFileHeader() {
    int[] header = new int[5];
    try {
        header[0] = inputStream.readShort();
        header[1] = inputStream.readInt();
        header[2] = inputStream.readShort();
        header[3] = inputStream.readShort();
        header[4] = inputStream.readInt();
    } catch (IOException e) {
        DWT.error(DWT.ERROR_IO, e);
    }
    if (header[0] !is 0x4D42)
        DWT.error(DWT.ERROR_INVALID_IMAGE);
    return header;
}
override ImageData[] loadFromByteStream() {
    int[] fileHeader = loadFileHeader();
    byte[] infoHeader = new byte[BMPHeaderFixedSize];
    try {
        inputStream.read(infoHeader);
    } catch (Exception e) {
        DWT.error(DWT.ERROR_IO, e);
    }
    int width = (infoHeader[4] & 0xFF) | ((infoHeader[5] & 0xFF) << 8) | ((infoHeader[6] & 0xFF) << 16) | ((infoHeader[7] & 0xFF) << 24);
    int height = (infoHeader[8] & 0xFF) | ((infoHeader[9] & 0xFF) << 8) | ((infoHeader[10] & 0xFF) << 16) | ((infoHeader[11] & 0xFF) << 24);
    if (height < 0) height = -height;
    int bitCount = (infoHeader[14] & 0xFF) | ((infoHeader[15] & 0xFF) << 8);
    this.compression = (infoHeader[16] & 0xFF) | ((infoHeader[17] & 0xFF) << 8) | ((infoHeader[18] & 0xFF) << 16) | ((infoHeader[19] & 0xFF) << 24);
    PaletteData palette = loadPalette(infoHeader);
    if (inputStream.getPosition() < fileHeader[4]) {
        // Seek to the specified offset
        try {
            inputStream.skip(fileHeader[4] - inputStream.getPosition());
        } catch (IOException e) {
            DWT.error(DWT.ERROR_IO, e);
        }
    }
    byte[] data = loadData(infoHeader);
    this.importantColors = (infoHeader[36] & 0xFF) | ((infoHeader[37] & 0xFF) << 8) | ((infoHeader[38] & 0xFF) << 16) | ((infoHeader[39] & 0xFF) << 24);
    int xPelsPerMeter = (infoHeader[24] & 0xFF) | ((infoHeader[25] & 0xFF) << 8) | ((infoHeader[26] & 0xFF) << 16) | ((infoHeader[27] & 0xFF) << 24);
    int yPelsPerMeter = (infoHeader[28] & 0xFF) | ((infoHeader[29] & 0xFF) << 8) | ((infoHeader[30] & 0xFF) << 16) | ((infoHeader[31] & 0xFF) << 24);
    this.pelsPerMeter = new Point(xPelsPerMeter, yPelsPerMeter);
    int type = (this.compression is 1 /*BMP_RLE8_COMPRESSION*/) || (this.compression is 2 /*BMP_RLE4_COMPRESSION*/) ? DWT.IMAGE_BMP_RLE : DWT.IMAGE_BMP;
    return [
        ImageData.internal_new(
            width,
            height,
            bitCount,
            palette,
            4,
            data,
            0,
            null,
            null,
            -1,
            -1,
            type,
            0,
            0,
            0,
            0)
    ];
}
PaletteData loadPalette(byte[] infoHeader) {
    int depth = (infoHeader[14] & 0xFF) | ((infoHeader[15] & 0xFF) << 8);
    if (depth <= 8) {
        int numColors = (infoHeader[32] & 0xFF) | ((infoHeader[33] & 0xFF) << 8) | ((infoHeader[34] & 0xFF) << 16) | ((infoHeader[35] & 0xFF) << 24);
        if (numColors is 0) {
            numColors = 1 << depth;
        } else {
            if (numColors > 256)
                numColors = 256;
        }
        byte[] buf = new byte[numColors * 4];
        try {
            if (inputStream.read(buf) !is buf.length)
                DWT.error(DWT.ERROR_INVALID_IMAGE);
        } catch (IOException e) {
            DWT.error(DWT.ERROR_IO, e);
        }
        return paletteFromBytes(buf, numColors);
    }
    if (depth is 16) {
        if (this.compression is 3) {
            try {
                return new PaletteData(inputStream.readInt(), inputStream.readInt(), inputStream.readInt());
            } catch (IOException e) {
                DWT.error(DWT.ERROR_IO, e);
            }
        }
        return new PaletteData(0x7C00, 0x3E0, 0x1F);
    }
    if (depth is 24) return new PaletteData(0xFF, 0xFF00, 0xFF0000);
    if (this.compression is 3) {
        try {
            return new PaletteData(inputStream.readInt(), inputStream.readInt(), inputStream.readInt());
        } catch (IOException e) {
            DWT.error(DWT.ERROR_IO, e);
        }
    }
    return new PaletteData(0xFF00, 0xFF0000, 0xFF000000);
}
PaletteData paletteFromBytes(byte[] bytes, int numColors) {
    int bytesOffset = 0;
    RGB[] colors = new RGB[numColors];
    for (int i = 0; i < numColors; i++) {
        colors[i] = new RGB(bytes[bytesOffset + 2] & 0xFF,
            bytes[bytesOffset + 1] & 0xFF,
            bytes[bytesOffset] & 0xFF);
        bytesOffset += 4;
    }
    return new PaletteData(colors);
}
/**
 * Answer a byte array containing the BMP representation of
 * the given device independent palette.
 */
static byte[] paletteToBytes(PaletteData pal) {
    int n = pal.colors is null ? 0 : (pal.colors.length < 256 ? pal.colors.length : 256);
    byte[] bytes = new byte[n * 4];
    int offset = 0;
    for (int i = 0; i < n; i++) {
        RGB col = pal.colors[i];
        bytes[offset] = cast(byte)col.blue;
        bytes[offset + 1] = cast(byte)col.green;
        bytes[offset + 2] = cast(byte)col.red;
        offset += 4;
    }
    return bytes;
}
/**
 * Unload the given image's data into the given byte stream
 * using the given compression strategy.
 * Answer the number of bytes written.
 */
int unloadData(ImageData image, OutputStream ostr, int comp) {
    int totalSize = 0;
    try {
        if (comp is 0)
            return unloadDataNoCompression(image, ostr);
        int bpl = (image.width * image.depth + 7) / 8;
        int bmpBpl = (bpl + 3) / 4 * 4; // BMP pads scanlines to multiples of 4 bytes
        int imageBpl = image.bytesPerLine;
        // Compression can actually take twice as much space, in worst case
        byte[] buf = new byte[bmpBpl * 2];
        int srcOffset = imageBpl * (image.height - 1); // Start at last line
        byte[] data = image.data;
        totalSize = 0;
        byte[] buf2 = new byte[32768];
        int buf2Offset = 0;
        for (int y = image.height - 1; y >= 0; y--) {
            int lineSize = compress(comp, data, srcOffset, bpl, buf, y is 0);
            if (buf2Offset + lineSize > buf2.length) {
                ostr.write(buf2, 0, buf2Offset);
                buf2Offset = 0;
            }
            System.arraycopy(buf, 0, buf2, buf2Offset, lineSize);
            buf2Offset += lineSize;
            totalSize += lineSize;
            srcOffset -= imageBpl;
        }
        if (buf2Offset > 0)
            ostr.write(buf2, 0, buf2Offset);
    } catch (IOException e) {
        DWT.error(DWT.ERROR_IO, e);
    }
    return totalSize;
}
/**
 * Prepare the given image's data for unloading into a byte stream
 * using no compression strategy.
 * Answer the number of bytes written.
 */
int unloadDataNoCompression(ImageData image, OutputStream ostr) {
    int bmpBpl = 0;
    try {
        int bpl = (image.width * image.depth + 7) / 8;
        bmpBpl = (bpl + 3) / 4 * 4; // BMP pads scanlines to multiples of 4 bytes
        int linesPerBuf = 32678 / bmpBpl;
        byte[] buf = new byte[linesPerBuf * bmpBpl];
        byte[] data = image.data;
        int imageBpl = image.bytesPerLine;
        int dataIndex = imageBpl * (image.height - 1); // Start at last line
        if (image.depth is 16) {
            for (int y = 0; y < image.height; y += linesPerBuf) {
                int count = image.height - y;
                if (linesPerBuf < count) count = linesPerBuf;
                int bufOffset = 0;
                for (int i = 0; i < count; i++) {
                    for (int wIndex = 0; wIndex < bpl; wIndex += 2) {
                        buf[bufOffset + wIndex + 1] = data[dataIndex + wIndex + 1];
                        buf[bufOffset + wIndex] = data[dataIndex + wIndex];
                    }
                    bufOffset += bmpBpl;
                    dataIndex -= imageBpl;
                }
                ostr.write(buf, 0, bufOffset);
            }
        } else {
            for (int y = 0; y < image.height; y += linesPerBuf) {
                int tmp = image.height - y;
                int count = tmp < linesPerBuf ? tmp : linesPerBuf;
                int bufOffset = 0;
                for (int i = 0; i < count; i++) {
                    System.arraycopy(data, dataIndex, buf, bufOffset, bpl);
                    bufOffset += bmpBpl;
                    dataIndex -= imageBpl;
                }
                ostr.write(buf, 0, bufOffset);
            }
        }
    } catch (IOException e) {
        DWT.error(DWT.ERROR_IO, e);
    }
    return bmpBpl * image.height;
}
/**
 * Unload a DeviceIndependentImage using Windows .BMP format into the given
 * byte stream.
 */
override void unloadIntoByteStream(ImageLoader loader) {
    ImageData image = loader.data[0];
    byte[] rgbs;
    int numCols;
    if (!((image.depth is 1) || (image.depth is 4) || (image.depth is 8) ||
          (image.depth is 16) || (image.depth is 24) || (image.depth is 32)))
            DWT.error(DWT.ERROR_UNSUPPORTED_DEPTH);
    int comp = this.compression;
    if (!((comp is 0) || ((comp is 1) && (image.depth is 8)) ||
          ((comp is 2) && (image.depth is 4))))
            DWT.error(DWT.ERROR_INVALID_IMAGE);
    PaletteData pal = image.palette;
    if ((image.depth is 16) || (image.depth is 24) || (image.depth is 32)) {
        if (!pal.isDirect)
            DWT.error(DWT.ERROR_INVALID_IMAGE);
        numCols = 0;
        rgbs = null;
    } else {
        if (pal.isDirect)
            DWT.error(DWT.ERROR_INVALID_IMAGE);
        numCols = pal.colors.length;
        rgbs = paletteToBytes(pal);
    }
    // Fill in file header, except for bfsize, which is done later.
    int headersSize = BMPFileHeaderSize + BMPHeaderFixedSize;
    int[] fileHeader = new int[5];
    fileHeader[0] = 0x4D42; // Signature
    fileHeader[1] = 0; // File size - filled in later
    fileHeader[2] = 0; // Reserved 1
    fileHeader[3] = 0; // Reserved 2
    fileHeader[4] = headersSize; // Offset to data
    if (rgbs !is null) {
        fileHeader[4] += rgbs.length;
    }

    // Prepare data. This is done first so we don't have to try to rewind
    // the stream and fill in the details later.
    ByteArrayOutputStream ostr = new ByteArrayOutputStream();
    unloadData(image, ostr, comp);
    byte[] data = ostr.toByteArray();

    // Calculate file size
    fileHeader[1] = fileHeader[4] + data.length;

    // Write the headers
    try {
        outputStream.writeShort(fileHeader[0]);
        outputStream.writeInt(fileHeader[1]);
        outputStream.writeShort(fileHeader[2]);
        outputStream.writeShort(fileHeader[3]);
        outputStream.writeInt(fileHeader[4]);
    } catch (IOException e) {
        DWT.error(DWT.ERROR_IO, e);
    }
    try {
        outputStream.writeInt(BMPHeaderFixedSize);
        outputStream.writeInt(image.width);
        outputStream.writeInt(image.height);
        outputStream.writeShort(1);
        outputStream.writeShort(cast(short)image.depth);
        outputStream.writeInt(comp);
        outputStream.writeInt(data.length);
        outputStream.writeInt(pelsPerMeter.x);
        outputStream.writeInt(pelsPerMeter.y);
        outputStream.writeInt(numCols);
        outputStream.writeInt(importantColors);
    } catch (IOException e) {
        DWT.error(DWT.ERROR_IO, e);
    }

    // Unload palette
    if (numCols > 0) {
        try {
            outputStream.write(rgbs);
        } catch (IOException e) {
            DWT.error(DWT.ERROR_IO, e);
        }
    }

    // Unload the data
    try {
        outputStream.write(data);
    } catch (IOException e) {
        DWT.error(DWT.ERROR_IO, e);
    }
}
void flipScanLines(byte[] data, int stride, int height) {
    int i1 = 0;
    int i2 = (height - 1) * stride;
    for (int i = 0; i < height / 2; i++) {
        for (int index = 0; index < stride; index++) {
            byte b = data[index + i1];
            data[index + i1] = data[index + i2];
            data[index + i2] = b;
        }
        i1 += stride;
        i2 -= stride;
    }
}

}