Function stbi__process_marker

lite/example/cpp_example/mge/cv/stb_image.h:3338–3444

}

static int stbi__process_marker(stbi__jpeg* z, int m) {
    int L;
    switch (m) {
        case STBI__MARKER_none:  // no marker found
            return stbi__err("expected marker", "Corrupt JPEG");

        case 0xDD:  // DRI - specify restart interval
            if (stbi__get16be(z->s) != 4)
                return stbi__err("bad DRI len", "Corrupt JPEG");
            z->restart_interval = stbi__get16be(z->s);
            return 1;

        case 0xDB:  // DQT - define quantization table
            L = stbi__get16be(z->s) - 2;
            while (L > 0) {
                int q = stbi__get8(z->s);
                int p = q >> 4, sixteen = (p != 0);
                int t = q & 15, i;
                if (p != 0 && p != 1)
                    return stbi__err("bad DQT type", "Corrupt JPEG");
                if (t > 3)
                    return stbi__err("bad DQT table", "Corrupt JPEG");

                for (i = 0; i < 64; ++i)
                    z->dequant[t][stbi__jpeg_dezigzag[i]] =
                            (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
                L -= (sixteen ? 129 : 65);
            }
            return L == 0;

        case 0xC4:  // DHT - define huffman table
            L = stbi__get16be(z->s) - 2;
            while (L > 0) {
                stbi_uc* v;
                int sizes[16], i, n = 0;
                int q = stbi__get8(z->s);
                int tc = q >> 4;
                int th = q & 15;
                if (tc > 1 || th > 3)
                    return stbi__err("bad DHT header", "Corrupt JPEG");
                for (i = 0; i < 16; ++i) {
                    sizes[i] = stbi__get8(z->s);
                    n += sizes[i];
                }
                L -= 17;
                if (tc == 0) {
                    if (!stbi__build_huffman(z->huff_dc + th, sizes))
                        return 0;
                    v = z->huff_dc[th].values;
                } else {
                    if (!stbi__build_huffman(z->huff_ac + th, sizes))
                        return 0;
                    v = z->huff_ac[th].values;
                }
                for (i = 0; i < n; ++i)
                    v[i] = stbi__get8(z->s);
                if (tc != 0)
                    stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);