在midp1.0上实现完美翻转

深入理解png终极篇  在midp1.0上实现完美翻转

在midp1.0上实现翻转图片是一个老生长谈的话题了一直以来都没有完美的解决方案

以前的解决方法一直是* setClip and drawImage 方式模拟绘制像素来实现速度极慢

改进的方法又会有白底

总之约等于鸡肋 使一些动作游戏很难做到1.0上 现在我来实现在midp1.0上的完美翻转

怎么实现呢

大家都知道png的IDAT数据段存储了重要的像素信息如果能修改IDAT数据段实现翻转就易如反掌

IDAT数据段的数据是使用lz77压缩算法压缩过的如果在手机端解压在修改数据则会耗费很长的时间

2秒左右了其实lz77压缩算法还提供了一种无压缩的压缩方式如果我们可以创建无压缩的IDAT数据那

在手机端翻转图片就很快了但现在几乎没有软件能生成这样的png 于是我做了一个 png2png来解决这个

问题 http://www.j2medev.com/bbs/dispbbs.asp?boardID=17&ID=20692&page=1

如png2png.jar放于c:/png2png.jar  需要压缩 c:/test.png 输出文件为c:/test.png 压缩率为 不压缩

 则运行命令为 java -jar c:/png2png.jar c:/test.png c:/test.png 0

这样输出的c:/test.png 就是不压缩IDAT的png了

虽然比压缩的png大很多但打包到jar里就和普通的png差不多大了甚至还小一些

在j2me端我用200行代码实现了水平垂直的4方向翻转

其中有一个public static Image createImage(String file, int flip);方法实现了翻转

其中flip

0 代表Sprite.TRANS_NONE, //0无翻转
1 代表Sprite.TRANS_MIRROR, //1x翻转
2 代表Sprite.TRANS_MIRROR_ROT180, //2Y翻转
3 代表Sprite.TRANS_ROT180, //3xy翻转

这样做了一些简单修改使我的动画引擎完美呈现于midp1.0上

这实际上是一种以空间换时间的方法

此文献给广大被midp1.0折磨的人

    public static byte[] getBytes(String file) throws IOException {
//        byte[] data = new byte[20480];
        ByteArrayOutputStream ba = new ByteArrayOutputStream();
        int off = 0;
        int val;
        InputStream is = file.getClass().getResourceAsStream(file);
        while ((val = is.read()) != -1) {
//            data[off] = (byte) val;
            ba.write(val);
            off++;
        }
        System.out.println("len = " + off);
        byte[] a = ba.toByteArray();
//        byte[] a = new byte[off];
//        System.arraycopy(data, 0, a, 0, off);
        is = null;
        ba = null;
//        data = null;
        System.gc();
        return a;
    }

    public static Image createImage(String file, int flip) {
        int _IDAT = 0;
        int _IHDR = 0;
        int _tRNS = 0;
        int _PLTE = 0;
        int width, height;
        byte[] data;
        byte[] Pixels;
        try {
            int i = 0;
            int off = 0;
            int chunklen = 1;
            int chunktype = 0;
            data = getBytes(file);

    public static void writeInt(byte[] dst, int pos, int val) {
        dst[pos] = (byte) ((val & 0xFF000000) >> 24);
        dst[pos + 1] = (byte) ((val & 0xFF0000) >> 16);
        dst[pos + 2] = (byte) ((val & 0xFF00) >> 8);
        dst[pos + 3] = (byte) (val & 0xFF);
    }

    public static int readInt(byte[] dst, int pos) { //读一个int
        return ((dst[pos] & 0xFF) << 24)
                | ((dst[pos + 1] & 0xFF) << 16)
                | ((dst[pos + 2] & 0xFF) << 8)
                | (dst[pos + 3] & 0xFF);
    }

    public static void writeCRC(byte[] data, int chunkpos) {
        int chunklen = readInt(data, chunkpos);
//        System.out.println(chunklen);
        int sum = CRCChecksum(data, chunkpos + 4, 4 + chunklen) ^ 0xffffffff;
//        System.out.println(sum);
        writeInt(data, chunkpos + 8 + chunklen, sum);
    }

    public static int[] crc_table; //CRC 表
    public static int CRCChecksum(byte[] buf, int off, int len) {
        int c = 0xffffffff;
        int n;
        if (crc_table == null) {
            int mkc;
            int mkn, mkk;
            crc_table = new int[256];
            for (mkn = 0; mkn < 256; mkn++) {
                mkc = mkn;
                for (mkk = 0; mkk < 8; mkk++) {
                    if ((mkc & 1) == 1) {

    public static long adler32(long adler, byte[] buf, int index, int len) {
        int BASE = 65521;
        int NMAX = 5552;
        //TODO remove this function at all
        if (buf == null) {
            return 1L;
        }

        long s1 = adler & 0xffff;
        long s2 = (adler >> 16) & 0xffff;
        int k;

        while (len > 0) {
            k = len < NMAX ? len : NMAX;
            len -= k;
            while (k >= 16) {
                s1 += buf[index++] & 0xff;
                s2 += s1;
                s1 += buf[index++] & 0xff;
                s2 += s1;
                s1 += buf[index++] & 0xff;
                s2 += s1;