Compiler Explorer

Source code

alias stbi__uint32 = uint;
alias stbi__uint16 = ushort;
alias stbi_uc = ubyte;

import core.stdc.string;

struct stbi__context
{
     int img_n;   
}

struct stbi__png
{
    stbi__context* s;
    stbi_uc* out_;
}

ubyte STBI__BYTECAST(int x)
{
    return cast(ubyte)x;
}

int stbi__paeth(int a, int b, int c)
{
    return a + b + c;
}

int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
{
    int bytes = (depth == 16? 2 : 1);
    stbi__context *s = a.s;
    stbi__uint32 i,j,stride = x*out_n*bytes;
    stbi__uint32 img_len, img_width_bytes;
    int k;
    int img_n = s.img_n; // copy it into a local for later

int output_bytes = out_n*bytes;
    int filter_bytes = img_n*bytes;
    int width = x;

assert(out_n == s.img_n || out_n == s.img_n+1);
    a.out_ = null;
    if (!a.out_) return 0; //stbi__err("outofmem", "Out of memory");

img_width_bytes = (((img_n * x * depth) + 7) >> 3);
    img_len = (img_width_bytes + 1) * y;

// we make a separate pass to expand bits to pixels; for performance,
    // this could run two scanlines behind the above code, so it won't
    // intefere with filtering but will still be in the cache.
    if (depth < 8) {
        for (j=0; j < y; ++j) {
            stbi_uc *cur = a.out_ + stride*j;
            stbi_uc *in_  = a.out_ + stride*j + x*out_n - img_width_bytes;
            // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
            // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
            stbi_uc scale = (color == 0) ? 0 : 1; // scale grayscale values to 0..255 range

// note that the final byte might overshoot and write more data than desired.
            // we can allocate enough data that this never writes out of memory, but it
            // could also overwrite the next scanline. can it overwrite non-empty data
            // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
            // so we need to explicitly clamp the final ones

if (depth == 4) {
                for (k=x*img_n; k >= 2; k-=2, ++in_) {
                    *cur++ = cast(ubyte)(scale * ((*in_ >> 4))       );
                    *cur++ = cast(ubyte)(scale * ((*in_     ) & 0x0f));
                }
                if (k > 0) *cur++ = cast(ubyte)(scale * ((*in_ >> 4)       ));
            } else if (depth == 2) {
                for (k=x*img_n; k >= 4; k-=4, ++in_) {
                    *cur++ = cast(ubyte)(scale * ((*in_ >> 6)       ));
                    *cur++ = cast(ubyte)(scale * ((*in_ >> 4) & 0x03));
                    *cur++ = cast(ubyte)(scale * ((*in_ >> 2) & 0x03));
                    *cur++ = cast(ubyte)(scale * ((*in_     ) & 0x03));
                }
                if (k > 0) *cur++ = cast(ubyte)(scale * ((*in_ >> 6)       ));
                if (k > 1) *cur++ = cast(ubyte)(scale * ((*in_ >> 4) & 0x03));
                if (k > 2) *cur++ = cast(ubyte)(scale * ((*in_ >> 2) & 0x03));
            } else { 
                for (k=x*img_n; k >= 8; k-=8, ++in_) {
                    *cur++ = (scale * ((*in_ >> 7)       ));
                    *cur++ = (scale * ((*in_ >> 6) & 0x01));
                    *cur++ = (scale * ((*in_ >> 5) & 0x01));
                    *cur++ = (scale * ((*in_ >> 4) & 0x01));
                    *cur++ = (scale * ((*in_ >> 3) & 0x01));
                    *cur++ = (scale * ((*in_ >> 2) & 0x01));
                    *cur++ = (scale * ((*in_ >> 1) & 0x01));
                    *cur++ = (scale * ((*in_     ) & 0x01));
                }
                if (k > 0) *cur++ = (scale * ((*in_ >> 7)       ));
                if (k > 1) *cur++ = (scale * ((*in_ >> 6) & 0x01));
                if (k > 2) *cur++ = (scale * ((*in_ >> 5) & 0x01));
                if (k > 3) *cur++ = (scale * ((*in_ >> 4) & 0x01));
                if (k > 4) *cur++ = (scale * ((*in_ >> 3) & 0x01));
                if (k > 5) *cur++ = (scale * ((*in_ >> 2) & 0x01));
                if (k > 6) *cur++ = (scale * ((*in_ >> 1) & 0x01));
            }
            if (img_n != out_n) {
                int q;
                // insert alpha = 255
                cur = a.out_ + stride*j;
                if (img_n == 1) {
                    for (q=x-1; q >= 0; --q) {
                        cur[q*2+1] = 255;
                        cur[q*2+0] = cur[q];
                    }
                } else {
                    assert(img_n == 3);
                    for (q=x-1; q >= 0; --q) {
                        cur[q*4+3] = 255;
                        cur[q*4+2] = cur[q*3+2];
                        cur[q*4+1] = cur[q*3+1];
                        cur[q*4+0] = cur[q*3+0];
                    }
                }
            }
        }
    }
    return 1;
}

void main()
{

}