jpegdecoder.java

一款J2ME浏览器

package com.lightspeedleader.browser;

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import java.io.InputStream;

public class JpegDecoder {

    int _fld0116;
    int _fld0117;
    int _fld0118;
    int _fld0119;
    int _fld011A;
    int qt[][];
    CellComponent _fld011B[];
    HuffmanTable _fld011C[];
    HuffmanTable _fld011D[];
    int _fld011E;
    int _fld011F;
    int _fld0120;
    int _fld0121;
    byte _fld0122[][];
    int ri;
    int _fld0123[] = {
            0, 1, 8, 16, 9, 2, 3, 10, 17, 24,
            32, 25, 18, 11, 4, 5, 12, 19, 26, 33,
            40, 48, 41, 34, 27, 20, 13, 6, 7, 14,
            21, 28, 35, 42, 49, 56, 57, 50, 43, 36,
            29, 22, 15, 23, 30, 37, 44, 51, 58, 59,
            52, 45, 38, 31, 39, 46, 53, 60, 61, 54,
            47, 55, 62, 63
    };
    Image _fld0124;
    boolean _fld0125;
    int _fld0126;
    public int poolsize;
    int FA;
    byte C2[];
    int _fld0127[];

    public JpegDecoder(byte abyte0[]) {
        qt = new int[4][64];
        _fld011B = new CellComponent[6];
        _fld011C = new HuffmanTable[4];
        _fld011D = new HuffmanTable[4];
        _fld0122 = new byte[5][];
        _fld0125 = false;
        _fld0126 = 0;
        _fld0127 = new int[64];
        C2 = abyte0;
        poolsize = C2.length;
        FA = 0;
    }

    public JpegDecoder(InputStream inputstream) {
        qt = new int[4][64];
        _fld011B = new CellComponent[6];
        _fld011C = new HuffmanTable[4];
        _fld011D = new HuffmanTable[4];
        _fld0122 = new byte[5][];
        _fld0125 = false;
        _fld0126 = 0;
        _fld0127 = new int[64];
        byte abyte0[][] = new byte[64][1];
        int i = 0;
        int j = 0;
        do {
            abyte0[i] = new byte[1024];
            try {
                j = inputstream.read(abyte0[i]);
            }
            catch (Exception exception) {
                j = 0;
            }
            poolsize += j;
            if (j != 1024) {
                break;
            }
            i++;
        } while (true);
        C2 = new byte[poolsize];
        FA = 0;
        int k = 0;
        boolean flag = false;
        for (int i1 = 0; i1 <= i; i1++) {
            int l;
            if (i1 == i) {
                l = j;
            } else {
                l = 1024;
            }
            System.arraycopy(abyte0[i1], 0, C2, k, l);
            k += l;
        }

    }

    public void setColorImage() {
        _fld0125 = false;
    }

    public void setGrayScaleImage() {
        _fld0125 = true;
    }

    public Image decodeImage() {
        _fld0124 = null;
        _mth0116();
        return _fld0124;
    }

    void _mth0116() {
        for (int i = 0; i < 6; i++) {
            _fld011B[i] = new CellComponent();
        }

        for (int j = 0; j < 4; j++) {
            _fld011C[j] = new HuffmanTable();
            _fld011D[j] = new HuffmanTable();
        }

        if (_mth0123() != 65496) {
            return;
        }
        do {
            int k = _mth0122();
            int l = _mth0122();
            if (k != 255) {
                return;
            }
            for (; l == 255; l = _mth0122()) {
            }
            switch (l) {
                case 193:
                case 194:
                case 195:
                case 197:
                case 198:
                case 199:
                case 200:
                case 201:
                case 202:
                case 203:
                case 204:
                case 205:
                case 206:
                case 207:
                    return;

                case 219:
                    if (!_mth0117()) {
                        return;
                    }
                    break;

                case 192:
                    if (!_mth0118()) {
                        return;
                    }
                    break;

                case 221:
                    if (!_mth0119()) {
                        return;
                    }
                    break;

                case 196:
                    if (!_mth011A()) {
                        return;
                    }
                    break;

                case 218:
                    if (!_mth011B()) {
                        return;
                    }
                    break;

                case 217:
                    _mth0120();
                    return;

                default:
                    int i1 = _mth0123() - 2;
                    _mth0121(i1);
                    break;

                case 1: // '\001'
                case 208:
                case 209:
                case 210:
                case 211:
                case 212:
                case 213:
                case 214:
                case 215:
                    break;
            }
        } while (true);
    }

    boolean _mth0117() {
        int l;
        for (l = _mth0123() - 2; l > 0; l -= 64) {
            int i = _mth0122();
            l--;
            int k = i & 0xf;
            int j = i >> 4;
            if (j != 0 || k >= 4) {
                return false;
            }
            for (int i1 = 0; i1 < 64; i1++) {
                qt[k][i1] = _mth0122();
            }

        }

        return l == 0;
    }

    boolean _mth0118() {
        int l = _mth0123() - 2;
        if (_mth0122() != 8) {
            return false;
        }
        _fld0117 = _mth0123();
        _fld0116 = _mth0123();
        if (_fld0117 == 0 || _fld0116 == 0) {
            return false;
        }
        _fld011A = _mth0122();
        for (int i1 = 0; i1 < _fld011A; i1++) {
            int i = _mth0122();
            if (i > 5) {
                return false;
            }
            int j = _mth0122();
            int k = _mth0122();
            _fld011B[i].h = j >> 4;
            _fld011B[i].v = j & 0xf;
            _fld011B[i].DB = k;
            if (_fld011B[i].h == 0 || _fld011B[i].v == 0) {
                return false;
            }
            if (_fld011E < _fld011B[i].h) {
                _fld011E = _fld011B[i].h;
            }
            if (_fld011F < _fld011B[i].v) {
                _fld011F = _fld011B[i].v;
            }
        }

        _fld0120 = ((_fld0116 + _fld011E * 8) - 1) / (_fld011E * 8);
        _fld0121 = ((_fld0117 + _fld011F * 8) - 1) / (_fld011F * 8);
        _fld0118 = _fld0120 * _fld011E * 8;
        _fld0119 = _fld0121 * _fld011F * 8;
        for (int j1 = 0; j1 < _fld011A; j1++) {
            try {
                _fld0122[j1] = new byte[_fld0118 * _fld0119];
            }
            catch (Exception exception) {
                return false;
            }
        }

        return true;
    }

    boolean _mth0119() {
        if (_mth0123() != 4) {
            return false;
        } else {
            ri = _mth0123();
            return true;
        }
    }

    boolean _mth011A() {
        int ai[] = new int[16];
        for (int i1 = _mth0123() - 2; i1 > 0;) {
            int i = _mth0122();
            i1--;
            int k = i & 0xf;
            int l = i >> 4 & 1;
            if (k >= 2) {
                return false;
            }
            HuffmanTable huffmantable;
            if (l == 0) {
                huffmantable = _fld011C[k];
            } else {
                huffmantable = _fld011D[k];
            }
            for (int j1 = 0; j1 < 16; j1++) {
                ai[j1] = _mth0122();
            }

            i1 -= 16;
            int k1 = 0;
            while (k1 < 16) {
                for (int l1 = 0; l1 < ai[k1]; l1++) {
                    int j = _mth0122();
                    i1--;
                    huffmantable.addNode(k1 + 1, j);
                }

                k1++;
            }
        }

        return true;
    }

    boolean _mth011B() {
        int ai[] = new int[4];
        int ai1[] = new int[4];
        int ai2[] = new int[4];
        int ai3[] = new int[4];
        int j = _mth0123() - 2;
        int k = _mth0122();
        if (k < 1 || k > 4) {
            return false;
        }
        int i = k;