Function stbi__pic_load_core

lite/example/cpp_example/mge/cv/stb_image.h:7010–7126

}

static stbi_uc* stbi__pic_load_core(
        stbi__context* s, int width, int height, int* comp, stbi_uc* result) {
    int act_comp = 0, num_packets = 0, y, chained;
    stbi__pic_packet packets[10];

    // this will (should...) cater for even some bizarre stuff like having data
    // for the same channel in multiple packets.
    do {
        stbi__pic_packet* packet;

        if (num_packets == sizeof(packets) / sizeof(packets[0]))
            return stbi__errpuc("bad format", "too many packets");

        packet = &packets[num_packets++];

        chained = stbi__get8(s);
        packet->size = stbi__get8(s);
        packet->type = stbi__get8(s);
        packet->channel = stbi__get8(s);

        act_comp |= packet->channel;

        if (stbi__at_eof(s))
            return stbi__errpuc("bad file", "file too short (reading packets)");
        if (packet->size != 8)
            return stbi__errpuc("bad format", "packet isn't 8bpp");
    } while (chained);

    *comp = (act_comp & 0x10 ? 4 : 3);  // has alpha channel?

    for (y = 0; y < height; ++y) {
        int packet_idx;

        for (packet_idx = 0; packet_idx < num_packets; ++packet_idx) {
            stbi__pic_packet* packet = &packets[packet_idx];
            stbi_uc* dest = result + y * width * 4;

            switch (packet->type) {
                default:
                    return stbi__errpuc(
                            "bad format", "packet has bad compression type");

                case 0: {  // uncompressed
                    int x;

                    for (x = 0; x < width; ++x, dest += 4)
                        if (!stbi__readval(s, packet->channel, dest))
                            return 0;
                    break;
                }

                case 1:  // Pure RLE
                {
                    int left = width, i;

                    while (left > 0) {
                        stbi_uc count, value[4];