cleanup

git-svn-id: http://svn.code.sf.net/p/netpbm/code/trunk@4340 9d0c8265-081b-0410-96cb-a4ca84ce46f8

4 files changed, 425 insertions, 519 deletions

diff --git a/converter/other/pamtoqoi.c b/converter/other/pamtoqoi.c
index 9f8e001b..ec0d91ba 100644
--- a/converter/other/pamtoqoi.c
+++ b/converter/other/pamtoqoi.c
@@ -93,7 +93,7 @@ static trqr_t get_trqr(const char *tuple_type) {
 int main(int argc, char **argv) {
     struct pam input;
     trqr_t trqr = NULL;
-    qoi_desc qd = {
+    qoi_Desc qd = {
         .colorspace = QOI_SRGB
     };
     tuplen *tr = NULL;
@@ -106,9 +106,9 @@ int main(int argc, char **argv) {
 
     qd.width = input.width;
     qd.height = input.height;
-    qd.channels = input.depth <= 3 ? 3 : 4;
+    qd.channelCt = input.depth <= 3 ? 3 : 4;
 
-    qb = malloc(qd.width * qd.height * qd.channels);
+    qb = malloc(qd.width * qd.height * qd.channelCt);
 
     trqr = get_trqr(input.tuple_type);
     if(!trqr) {
@@ -142,10 +142,10 @@ int main(int argc, char **argv) {
     /* Read and convert rows. */
     for(size_t i = 0; i < qd.height; i++) {
         pnm_readpamrown(&input, tr);
-        trqr(tr, input.width, qb + i * input.width * qd.channels);
+        trqr(tr, input.width, qb + i * input.width * qd.channelCt);
     }
     pnm_freepamrown(tr);
-    int ol = 0;
+    unsigned int ol = 0;
     unsigned char *buf = qoi_encode(qb, &qd, &ol);
     free(qb);
     fwrite(buf, ol, 1, stdout);
diff --git a/converter/other/qoi.c b/converter/other/qoi.c
index d5962fc4..79e56dd4 100644
--- a/converter/other/qoi.c
+++ b/converter/other/qoi.c
@@ -1,2 +1,296 @@
-#define QOI_IMPLEMENTATION
+#include <stdlib.h>
+#include <string.h>
+
 #include "qoi.h"
+
+#ifndef QOI_MALLOC
+    #define QOI_MALLOC(sz) malloc(sz)
+    #define QOI_FREE(p)    free(p)
+#endif
+#ifndef QOI_ZEROARR
+    #define QOI_ZEROARR(a) memset((a),0,sizeof(a))
+#endif
+
+#define QOI_OP_INDEX  0x00 /* 00xxxxxx */
+#define QOI_OP_DIFF   0x40 /* 01xxxxxx */
+#define QOI_OP_LUMA   0x80 /* 10xxxxxx */
+#define QOI_OP_RUN    0xc0 /* 11xxxxxx */
+#define QOI_OP_RGB    0xfe /* 11111110 */
+#define QOI_OP_RGBA   0xff /* 11111111 */
+
+#define QOI_MASK_2    0xc0 /* 11000000 */
+
+#define QOI_COLOR_HASH(C) (C.rgba.r*3 + C.rgba.g*5 + C.rgba.b*7 + C.rgba.a*11)
+#define QOI_MAGIC \
+    (((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
+     ((unsigned int)'i') <<  8 | ((unsigned int)'f'))
+#define QOI_HEADER_SIZE 14
+
+/* 2GB is the max file size that this implementation can safely handle. We
+   guard against anything larger than that, assuming the worst case with 5
+   bytes per pixel, rounded down to a nice clean value. 400 million pixels
+   ought to be enough for anybody.
+ */
+#define QOI_PIXELS_MAX ((unsigned int)400000000)
+
+typedef union {
+    struct { unsigned char r, g, b, a; } rgba;
+    unsigned int v;
+} Rgba;
+
+static unsigned char const padding[8] = {0,0,0,0,0,0,0,1};
+
+static void
+write32(unsigned char * const bytes,
+        int *           const p,
+        unsigned int    const v) {
+
+    bytes[(*p)++] = (0xff000000 & v) >> 24;
+    bytes[(*p)++] = (0x00ff0000 & v) >> 16;
+    bytes[(*p)++] = (0x0000ff00 & v) >> 8;
+    bytes[(*p)++] = (0x000000ff & v);
+}
+
+
+
+static unsigned int
+read32(const unsigned char *bytes, int *p) {
+
+    unsigned int a = bytes[(*p)++];
+    unsigned int b = bytes[(*p)++];
+    unsigned int c = bytes[(*p)++];
+    unsigned int d = bytes[(*p)++];
+    return a << 24 | b << 16 | c << 8 | d;
+}
+
+
+
+void *
+qoi_encode(const void *     const data,
+           const qoi_Desc * const descP,
+           unsigned int *   const outLenP) {
+
+    int p;
+    unsigned int i, maxSize, run;
+    unsigned int pxLen, pxEnd, pxPos, channelCt;
+    unsigned char * bytes;
+    const unsigned char * pixels;
+    Rgba index[64];
+    Rgba px, pxPrev;
+
+    if (data == NULL || outLenP == NULL || descP == NULL ||
+        descP->width == 0 || descP->height == 0 ||
+        descP->channelCt < 3 || descP->channelCt > 4 ||
+        descP->colorspace > 1 ||
+        descP->height >= QOI_PIXELS_MAX / descP->width) {
+
+        return NULL;
+    }
+
+    maxSize =
+        descP->width * descP->height * (descP->channelCt + 1) +
+        QOI_HEADER_SIZE + sizeof(padding);
+
+    p = 0;
+    bytes = (unsigned char *) QOI_MALLOC(maxSize);
+    if (!bytes)
+        return NULL;
+
+    write32(bytes, &p, QOI_MAGIC);
+    write32(bytes, &p, descP->width);
+    write32(bytes, &p, descP->height);
+    bytes[p++] = descP->channelCt;
+    bytes[p++] = descP->colorspace;
+
+    pixels = (const unsigned char *)data;
+
+    QOI_ZEROARR(index);
+
+    run = 0;
+    pxPrev.rgba.r = 0;
+    pxPrev.rgba.g = 0;
+    pxPrev.rgba.b = 0;
+    pxPrev.rgba.a = 255;
+    px = pxPrev;
+
+    pxLen = descP->width * descP->height * descP->channelCt;
+    pxEnd = pxLen - descP->channelCt;
+    channelCt = descP->channelCt;
+
+    for (pxPos = 0; pxPos < pxLen; pxPos += channelCt) {
+        px.rgba.r = pixels[pxPos + 0];
+        px.rgba.g = pixels[pxPos + 1];
+        px.rgba.b = pixels[pxPos + 2];
+
+        if (channelCt == 4) {
+            px.rgba.a = pixels[pxPos + 3];
+        }
+
+        if (px.v == pxPrev.v) {
+            ++run;
+            if (run == 62 || pxPos == pxEnd) {
+                bytes[p++] = QOI_OP_RUN | (run - 1);
+                run = 0;
+            }
+        } else {
+            unsigned int indexPos;
+
+            if (run > 0) {
+                bytes[p++] = QOI_OP_RUN | (run - 1);
+                run = 0;
+            }
+
+            indexPos = QOI_COLOR_HASH(px) % 64;
+
+            if (index[indexPos].v == px.v) {
+                bytes[p++] = QOI_OP_INDEX | indexPos;
+            } else {
+                index[indexPos] = px;
+
+                if (px.rgba.a == pxPrev.rgba.a) {
+                    signed char vr = px.rgba.r - pxPrev.rgba.r;
+                    signed char vg = px.rgba.g - pxPrev.rgba.g;
+                    signed char vb = px.rgba.b - pxPrev.rgba.b;
+
+                    signed char vgR = vr - vg;
+                    signed char vgB = vb - vg;
+
+                    if (
+                        vr > -3 && vr < 2 &&
+                        vg > -3 && vg < 2 &&
+                        vb > -3 && vb < 2
+                    ) {
+                        bytes[p++] = QOI_OP_DIFF |
+                            (vr + 2) << 4 | (vg + 2) << 2 | (vb + 2);
+                    } else if (
+                        vgR >  -9 && vgR <  8 &&
+                        vg  > -33 && vg  < 32 &&
+                        vgB >  -9 && vgB <  8
+                    ) {
+                        bytes[p++] = QOI_OP_LUMA     | (vg   + 32);
+                        bytes[p++] = (vgR + 8) << 4 | (vgB +  8);
+                    } else {
+                        bytes[p++] = QOI_OP_RGB;
+                        bytes[p++] = px.rgba.r;
+                        bytes[p++] = px.rgba.g;
+                        bytes[p++] = px.rgba.b;
+                    }
+                } else {
+                    bytes[p++] = QOI_OP_RGBA;
+                    bytes[p++] = px.rgba.r;
+                    bytes[p++] = px.rgba.g;
+                    bytes[p++] = px.rgba.b;
+                    bytes[p++] = px.rgba.a;
+                }
+            }
+        }
+        pxPrev = px;
+    }
+
+    for (i = 0; i < (int)sizeof(padding); ++i)
+        bytes[p++] = padding[i];
+
+    *outLenP = p;
+
+    return bytes;
+}
+
+
+
+void *
+qoi_decode(const void * const data,
+           unsigned int const size,
+           qoi_Desc *   const descP) {
+
+    const unsigned char * bytes;
+    unsigned int header_magic;
+    unsigned char * pixels;
+    Rgba index[64];
+    Rgba px;
+    unsigned int pxLen, chunksLen, pxPos;
+    int p;
+    unsigned int run;
+
+    if (data == NULL || descP == NULL ||
+        size < QOI_HEADER_SIZE + (int)sizeof(padding)) {
+        return NULL;
+    }
+
+    bytes = (const unsigned char *)data;
+
+    header_magic      = read32(bytes, &p);
+    descP->width      = read32(bytes, &p);
+    descP->height     = read32(bytes, &p);
+    descP->channelCt  = bytes[p++];
+    descP->colorspace = bytes[p++];
+
+    if (
+        descP->width == 0 || descP->height == 0 ||
+        descP->channelCt < 3 || descP->channelCt > 4 ||
+        descP->colorspace > 1 ||
+        header_magic != QOI_MAGIC ||
+        descP->height >= QOI_PIXELS_MAX / descP->width
+    ) {
+        return NULL;
+    }
+
+    pxLen = descP->width * descP->height * descP->channelCt;
+    pixels = (unsigned char *) QOI_MALLOC(pxLen);
+    if (!pixels) {
+        return NULL;
+    }
+
+    QOI_ZEROARR(index);
+    px.rgba.r = 0;
+    px.rgba.g = 0;
+    px.rgba.b = 0;
+    px.rgba.a = 255;
+
+    chunksLen = size - sizeof(padding);
+    for (pxPos = 0, run = 0; pxPos < pxLen; pxPos += descP->channelCt) {
+        if (run > 0) {
+            --run;
+        } else if (p < chunksLen) {
+            unsigned char const b1 = bytes[p++];
+
+            if (b1 == QOI_OP_RGB) {
+                px.rgba.r = bytes[p++];
+                px.rgba.g = bytes[p++];
+                px.rgba.b = bytes[p++];
+            } else if (b1 == QOI_OP_RGBA) {
+                px.rgba.r = bytes[p++];
+                px.rgba.g = bytes[p++];
+                px.rgba.b = bytes[p++];
+                px.rgba.a = bytes[p++];
+            } else if ((b1 & QOI_MASK_2) == QOI_OP_INDEX) {
+                px = index[b1];
+            } else if ((b1 & QOI_MASK_2) == QOI_OP_DIFF) {
+                px.rgba.r += ((b1 >> 4) & 0x03) - 2;
+                px.rgba.g += ((b1 >> 2) & 0x03) - 2;
+                px.rgba.b += ( b1       & 0x03) - 2;
+            } else if ((b1 & QOI_MASK_2) == QOI_OP_LUMA) {
+                unsigned char const b2 = bytes[p++];
+                unsigned char const vg = (b1 & 0x3f) - 32;
+                px.rgba.r += vg - 8 + ((b2 >> 4) & 0x0f);
+                px.rgba.g += vg;
+                px.rgba.b += vg - 8 +  (b2       & 0x0f);
+            } else if ((b1 & QOI_MASK_2) == QOI_OP_RUN) {
+                run = (b1 & 0x3f);
+            }
+
+            index[QOI_COLOR_HASH(px) % 64] = px;
+        }
+
+        pixels[pxPos + 0] = px.rgba.r;
+        pixels[pxPos + 1] = px.rgba.g;
+        pixels[pxPos + 2] = px.rgba.b;
+
+        if (descP->channelCt == 4)
+            pixels[pxPos + 3] = px.rgba.a;
+    }
+
+    return pixels;
+}
+
+
+
diff --git a/converter/other/qoi.h b/converter/other/qoi.h
index 2b782860..3eb3d3e8 100644
--- a/converter/other/qoi.h
+++ b/converter/other/qoi.h
@@ -1,3 +1,5 @@
+#ifndef QOI_H_INCLUDED
+#define QOI_H_INCLUDED
 /*
 
 QOI - The "Quite OK Image" format for fast, lossless image compression
@@ -35,12 +37,6 @@ stb_image_write QOI offers 20x-50x faster encoding, 3x-4x faster decoding and
 
 -- Synopsis
 
-// Define `QOI_IMPLEMENTATION` in *one* C/C++ file before including this
-// library to create the implementation.
-
-#define QOI_IMPLEMENTATION
-#include "qoi.h"
-
 // Encode and store an RGBA buffer to the file system. The qoi_desc describes
 // the input pixel data.
 qoi_write("image_new.qoi", rgba_pixels, &(qoi_desc){
@@ -68,9 +64,6 @@ This library provides the following functions;
 
 See the function declaration below for the signature and more information.
 
-If you don't want/need the qoi_read and qoi_write functions, you can define
-QOI_NO_STDIO before including this library.
-
 This library uses malloc() and free(). To supply your own malloc implementation
 you can define QOI_MALLOC and QOI_FREE before including this library.
 
@@ -228,442 +221,58 @@ The alpha value remains unchanged from the previous pixel.
 */
 
 
-/* -----------------------------------------------------------------------------
-Header - Public functions */
-
-#ifndef QOI_H
-#define QOI_H
+/* A pointer to a qoi_desc struct has to be supplied to all of qoi's
+   functions.  It describes either the input format (for qoi_write and
+   qoi_encode), or is filled with the description read from the file header
+   (for qoi_read and qoi_decode).
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* A pointer to a qoi_desc struct has to be supplied to all of qoi's functions.
-It describes either the input format (for qoi_write and qoi_encode), or is
-filled with the description read from the file header (for qoi_read and
-qoi_decode).
+   The colorspace in this qoi_desc is an enum where
+      0 = sRGB, i.e. gamma scaled RGB channels and a linear alpha channel
+      1 = all channels are linear
 
-The colorspace in this qoi_desc is an enum where
-    0 = sRGB, i.e. gamma scaled RGB channels and a linear alpha channel
-    1 = all channels are linear
-You may use the constants QOI_SRGB or QOI_LINEAR. The colorspace is purely
-informative. It will be saved to the file header, but does not affect
-how chunks are en-/decoded. */
+   You may use the constants QOI_SRGB or QOI_LINEAR. The colorspace is purely
+   informative. It will be saved to the file header, but does not affect how
+   chunks are en-/decoded.
+*/
 
-#define QOI_SRGB   0
-#define QOI_LINEAR 1
+typedef enum {
+    QOI_SRGB = 0,
+    QOI_LINEAR = 1
+} qoi_Colorspace;
 
 typedef struct {
-    unsigned int width;
-    unsigned int height;
-    unsigned char channels;
-    unsigned char colorspace;
-} qoi_desc;
-
-#ifndef QOI_NO_STDIO
-
-/* Encode raw RGB or RGBA pixels into a QOI image and write it to the file
-system. The qoi_desc struct must be filled with the image width, height,
-number of channels (3 = RGB, 4 = RGBA) and the colorspace.
-
-The function returns 0 on failure (invalid parameters, or fopen or malloc
-failed) or the number of bytes written on success. */
-
-int qoi_write(const char *filename, const void *data, const qoi_desc *desc);
-
-
-/* Read and decode a QOI image from the file system. If channels is 0, the
-number of channels from the file header is used. If channels is 3 or 4 the
-output format will be forced into this number of channels.
-
-The function either returns NULL on failure (invalid data, or malloc or fopen
-failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
-will be filled with the description from the file header.
-
-The returned pixel data should be free()d after use. */
-
-void *qoi_read(const char *filename, qoi_desc *desc, int channels);
-
-#endif /* QOI_NO_STDIO */
-
+    unsigned int   width;
+    unsigned int   height;
+    unsigned int   channelCt;
+    qoi_Colorspace colorspace;
+} qoi_Desc;
 
 /* Encode raw RGB or RGBA pixels into a QOI image in memory.
 
-The function either returns NULL on failure (invalid parameters or malloc
-failed) or a pointer to the encoded data on success. On success the out_len
-is set to the size in bytes of the encoded data.
-
-The returned qoi data should be free()d after use. */
+   The function either returns NULL on failure (invalid parameters or malloc
+   failed) or a pointer to the encoded data on success. On success the out_len
+   is set to the size in bytes of the encoded data.
 
-void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len);
+   The returned qoi data should be free()d after use.
+*/
 
+void *
+qoi_encode(const void *     const data,
+           const qoi_Desc * const descP,
+           unsigned int *   const outLenP);
 
 /* Decode a QOI image from memory.
 
-The function either returns NULL on failure (invalid parameters or malloc
-failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
-is filled with the description from the file header.
-
-The returned pixel data should be free()d after use. */
-
-void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels);
+   The function either returns NULL on failure (invalid parameters or malloc
+   failed) or a pointer to the decoded pixels. On success, the qoi_Desc struct
+   is filled with the description from the file header.
 
+   The returned pixel data should be free()d after use.
+*/
 
-#ifdef __cplusplus
-}
-#endif
-#endif /* QOI_H */
-
-
-/* -----------------------------------------------------------------------------
-Implementation */
-
-#ifdef QOI_IMPLEMENTATION
-#include <stdlib.h>
-#include <string.h>
+void *
+qoi_decode(const void * const data,
+           unsigned int const size,
+           qoi_Desc *   const descP);
 
-#ifndef QOI_MALLOC
-    #define QOI_MALLOC(sz) malloc(sz)
-    #define QOI_FREE(p)    free(p)
-#endif
-#ifndef QOI_ZEROARR
-    #define QOI_ZEROARR(a) memset((a),0,sizeof(a))
 #endif
-
-#define QOI_OP_INDEX  0x00 /* 00xxxxxx */
-#define QOI_OP_DIFF   0x40 /* 01xxxxxx */
-#define QOI_OP_LUMA   0x80 /* 10xxxxxx */
-#define QOI_OP_RUN    0xc0 /* 11xxxxxx */
-#define QOI_OP_RGB    0xfe /* 11111110 */
-#define QOI_OP_RGBA   0xff /* 11111111 */
-
-#define QOI_MASK_2    0xc0 /* 11000000 */
-
-#define QOI_COLOR_HASH(C) (C.rgba.r*3 + C.rgba.g*5 + C.rgba.b*7 + C.rgba.a*11)
-#define QOI_MAGIC \
-    (((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
-     ((unsigned int)'i') <<  8 | ((unsigned int)'f'))
-#define QOI_HEADER_SIZE 14
-
-/* 2GB is the max file size that this implementation can safely handle. We guard
-against anything larger than that, assuming the worst case with 5 bytes per
-pixel, rounded down to a nice clean value. 400 million pixels ought to be
-enough for anybody. */
-#define QOI_PIXELS_MAX ((unsigned int)400000000)
-
-typedef union {
-    struct { unsigned char r, g, b, a; } rgba;
-    unsigned int v;
-} qoi_rgba_t;
-
-static const unsigned char qoi_padding[8] = {0,0,0,0,0,0,0,1};
-
-static void qoi_write_32(unsigned char *bytes, int *p, unsigned int v) {
-    bytes[(*p)++] = (0xff000000 & v) >> 24;
-    bytes[(*p)++] = (0x00ff0000 & v) >> 16;
-    bytes[(*p)++] = (0x0000ff00 & v) >> 8;
-    bytes[(*p)++] = (0x000000ff & v);
-}
-
-static unsigned int qoi_read_32(const unsigned char *bytes, int *p) {
-    unsigned int a = bytes[(*p)++];
-    unsigned int b = bytes[(*p)++];
-    unsigned int c = bytes[(*p)++];
-    unsigned int d = bytes[(*p)++];
-    return a << 24 | b << 16 | c << 8 | d;
-}
-
-void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len) {
-    int i, max_size, p, run;
-    int px_len, px_end, px_pos, channels;
-    unsigned char *bytes;
-    const unsigned char *pixels;
-    qoi_rgba_t index[64];
-    qoi_rgba_t px, px_prev;
-
-    if (
-        data == NULL || out_len == NULL || desc == NULL ||
-        desc->width == 0 || desc->height == 0 ||
-        desc->channels < 3 || desc->channels > 4 ||
-        desc->colorspace > 1 ||
-        desc->height >= QOI_PIXELS_MAX / desc->width
-    ) {
-        return NULL;
-    }
-
-    max_size =
-        desc->width * desc->height * (desc->channels + 1) +
-        QOI_HEADER_SIZE + sizeof(qoi_padding);
-
-    p = 0;
-    bytes = (unsigned char *) QOI_MALLOC(max_size);
-    if (!bytes) {
-        return NULL;
-    }
-
-    qoi_write_32(bytes, &p, QOI_MAGIC);
-    qoi_write_32(bytes, &p, desc->width);
-    qoi_write_32(bytes, &p, desc->height);
-    bytes[p++] = desc->channels;
-    bytes[p++] = desc->colorspace;
-
-
-    pixels = (const unsigned char *)data;
-
-    QOI_ZEROARR(index);
-
-    run = 0;
-    px_prev.rgba.r = 0;
-    px_prev.rgba.g = 0;
-    px_prev.rgba.b = 0;
-    px_prev.rgba.a = 255;
-    px = px_prev;
-
-    px_len = desc->width * desc->height * desc->channels;
-    px_end = px_len - desc->channels;
-    channels = desc->channels;
-
-    for (px_pos = 0; px_pos < px_len; px_pos += channels) {
-        px.rgba.r = pixels[px_pos + 0];
-        px.rgba.g = pixels[px_pos + 1];
-        px.rgba.b = pixels[px_pos + 2];
-
-        if (channels == 4) {
-            px.rgba.a = pixels[px_pos + 3];
-        }
-
-        if (px.v == px_prev.v) {
-            run++;
-            if (run == 62 || px_pos == px_end) {
-                bytes[p++] = QOI_OP_RUN | (run - 1);
-                run = 0;
-            }
-        }
-        else {
-            int index_pos;
-
-            if (run > 0) {
-                bytes[p++] = QOI_OP_RUN | (run - 1);
-                run = 0;
-            }
-
-            index_pos = QOI_COLOR_HASH(px) % 64;
-
-            if (index[index_pos].v == px.v) {
-                bytes[p++] = QOI_OP_INDEX | index_pos;
-            }
-            else {
-                index[index_pos] = px;
-
-                if (px.rgba.a == px_prev.rgba.a) {
-                    signed char vr = px.rgba.r - px_prev.rgba.r;
-                    signed char vg = px.rgba.g - px_prev.rgba.g;
-                    signed char vb = px.rgba.b - px_prev.rgba.b;
-
-                    signed char vg_r = vr - vg;
-                    signed char vg_b = vb - vg;
-
-                    if (
-                        vr > -3 && vr < 2 &&
-                        vg > -3 && vg < 2 &&
-                        vb > -3 && vb < 2
-                    ) {
-                        bytes[p++] = QOI_OP_DIFF | (vr + 2) << 4 | (vg + 2) << 2 | (vb + 2);
-                    }
-                    else if (
-                        vg_r >  -9 && vg_r <  8 &&
-                        vg   > -33 && vg   < 32 &&
-                        vg_b >  -9 && vg_b <  8
-                    ) {
-                        bytes[p++] = QOI_OP_LUMA     | (vg   + 32);
-                        bytes[p++] = (vg_r + 8) << 4 | (vg_b +  8);
-                    }
-                    else {
-                        bytes[p++] = QOI_OP_RGB;
-                        bytes[p++] = px.rgba.r;
-                        bytes[p++] = px.rgba.g;
-                        bytes[p++] = px.rgba.b;
-                    }
-                }
-                else {
-                    bytes[p++] = QOI_OP_RGBA;
-                    bytes[p++] = px.rgba.r;
-                    bytes[p++] = px.rgba.g;
-                    bytes[p++] = px.rgba.b;
-                    bytes[p++] = px.rgba.a;
-                }
-            }
-        }
-        px_prev = px;
-    }
-
-    for (i = 0; i < (int)sizeof(qoi_padding); i++) {
-        bytes[p++] = qoi_padding[i];
-    }
-
-    *out_len = p;
-    return bytes;
-}
-
-void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels) {
-    const unsigned char *bytes;
-    unsigned int header_magic;
-    unsigned char *pixels;
-    qoi_rgba_t index[64];
-    qoi_rgba_t px;
-    int px_len, chunks_len, px_pos;
-    int p = 0, run = 0;
-
-    if (
-        data == NULL || desc == NULL ||
-        (channels != 0 && channels != 3 && channels != 4) ||
-        size < QOI_HEADER_SIZE + (int)sizeof(qoi_padding)
-    ) {
-        return NULL;
-    }
-
-    bytes = (const unsigned char *)data;
-
-    header_magic = qoi_read_32(bytes, &p);
-    desc->width = qoi_read_32(bytes, &p);
-    desc->height = qoi_read_32(bytes, &p);
-    desc->channels = bytes[p++];
-    desc->colorspace = bytes[p++];
-
-    if (
-        desc->width == 0 || desc->height == 0 ||
-        desc->channels < 3 || desc->channels > 4 ||
-        desc->colorspace > 1 ||
-        header_magic != QOI_MAGIC ||
-        desc->height >= QOI_PIXELS_MAX / desc->width
-    ) {
-        return NULL;
-    }
-
-    if (channels == 0) {
-        channels = desc->channels;
-    }
-
-    px_len = desc->width * desc->height * channels;
-    pixels = (unsigned char *) QOI_MALLOC(px_len);
-    if (!pixels) {
-        return NULL;
-    }
-
-    QOI_ZEROARR(index);
-    px.rgba.r = 0;
-    px.rgba.g = 0;
-    px.rgba.b = 0;
-    px.rgba.a = 255;
-
-    chunks_len = size - (int)sizeof(qoi_padding);
-    for (px_pos = 0; px_pos < px_len; px_pos += channels) {
-        if (run > 0) {
-            run--;
-        }
-        else if (p < chunks_len) {
-            int b1 = bytes[p++];
-
-            if (b1 == QOI_OP_RGB) {
-                px.rgba.r = bytes[p++];
-                px.rgba.g = bytes[p++];
-                px.rgba.b = bytes[p++];
-            }
-            else if (b1 == QOI_OP_RGBA) {
-                px.rgba.r = bytes[p++];
-                px.rgba.g = bytes[p++];
-                px.rgba.b = bytes[p++];
-                px.rgba.a = bytes[p++];
-            }
-            else if ((b1 & QOI_MASK_2) == QOI_OP_INDEX) {
-                px = index[b1];
-            }
-            else if ((b1 & QOI_MASK_2) == QOI_OP_DIFF) {
-                px.rgba.r += ((b1 >> 4) & 0x03) - 2;
-                px.rgba.g += ((b1 >> 2) & 0x03) - 2;
-                px.rgba.b += ( b1       & 0x03) - 2;
-            }
-            else if ((b1 & QOI_MASK_2) == QOI_OP_LUMA) {
-                int b2 = bytes[p++];
-                int vg = (b1 & 0x3f) - 32;
-                px.rgba.r += vg - 8 + ((b2 >> 4) & 0x0f);
-                px.rgba.g += vg;
-                px.rgba.b += vg - 8 +  (b2       & 0x0f);
-            }
-            else if ((b1 & QOI_MASK_2) == QOI_OP_RUN) {
-                run = (b1 & 0x3f);
-            }
-
-            index[QOI_COLOR_HASH(px) % 64] = px;
-        }
-
-        pixels[px_pos + 0] = px.rgba.r;
-        pixels[px_pos + 1] = px.rgba.g;
-        pixels[px_pos + 2] = px.rgba.b;
-
-        if (channels == 4) {
-            pixels[px_pos + 3] = px.rgba.a;
-        }
-    }
-
-    return pixels;
-}
-
-#ifndef QOI_NO_STDIO
-#include <stdio.h>
-
-int qoi_write(const char *filename, const void *data, const qoi_desc *desc) {
-    FILE *f = fopen(filename, "wb");
-    int size;
-    void *encoded;
-
-    if (!f) {
-        return 0;
-    }
-
-    encoded = qoi_encode(data, desc, &size);
-    if (!encoded) {
-        fclose(f);
-        return 0;
-    }
-
-    fwrite(encoded, 1, size, f);
-    fclose(f);
-
-    QOI_FREE(encoded);
-    return size;
-}
-
-void *qoi_read(const char *filename, qoi_desc *desc, int channels) {
-    FILE *f = fopen(filename, "rb");
-    int size, bytes_read;
-    void *pixels, *data;
-
-    if (!f) {
-        return NULL;
-    }
-
-    fseek(f, 0, SEEK_END);
-    size = ftell(f);
-    if (size <= 0) {
-        fclose(f);
-        return NULL;
-    }
-    fseek(f, 0, SEEK_SET);
-
-    data = QOI_MALLOC(size);
-    if (!data) {
-        fclose(f);
-        return NULL;
-    }
-
-    bytes_read = fread(data, 1, size, f);
-    fclose(f);
-
-    pixels = qoi_decode(data, bytes_read, desc, channels);
-    QOI_FREE(data);
-    return pixels;
-}
-
-#endif /* QOI_NO_STDIO */
-#endif /* QOI_IMPLEMENTATION */
diff --git a/converter/other/qoitopam.c b/converter/other/qoitopam.c
index f17f4609..578a88d3 100644
--- a/converter/other/qoitopam.c
+++ b/converter/other/qoitopam.c
@@ -14,18 +14,20 @@
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#include "pam.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include <string.h>
+
+#include "pam.h"
 #include "qoi.h"
 
 #define QOI_MAXVAL 0xFF
 
 /* Resizes buf of type T* so that at least needed+1 bytes
    are available, executing err if realloc fails.
-   Uses realloc -- is there a Netpbm equivalent? */
+   Uses realloc -- is there a Netpbm equivalent?
+*/
 #define RESIZE(buf, T, needed, allocated, err)  \
     do {                                        \
     size_t tmpn = (allocated);                  \
@@ -42,107 +44,108 @@
     } while(0)
 
 
-/* Unfortunately, qoi.h does not implement a streaming decoder,
-   we need to read the whole stream into memory -- expensive.
-   We might be able to cheat here with mmap sometimes,
-   but it's not worth the effort. */
-static void *read_into_mem(FILE *f, size_t *s) {
-    *s = 0;
-    unsigned char *buf = NULL;
-    size_t allocated = 0;
-    size_t x = 0;
-    size_t r = 0;
+static void
+readFile(FILE *                 const fileP,
+         const unsigned char ** const bytesP,
+         unsigned int *         const sizeP) {
+
+    unsigned char * buf;
+    size_t allocatedSz;
+    size_t sizeSoFar;
+    size_t bytesReadCt;
+
+    buf = NULL; /* initial value */
+    allocatedSz = 0;  /* initial value */
+    sizeSoFar = 0;  /* initial value */
+    *sizeP  = 0;
 
+    bytesReadCt = 0;  /* initial value */
     do {
-        x += r;
-        RESIZE(buf, unsigned char, x+4096, allocated, free(buf); return NULL;);
-        r = fread(buf + x, 1, 4096, f);
-    } while(r != 0);
+        sizeSoFar += bytesReadCt;
+        RESIZE(buf, unsigned char, sizeSoFar + 4096, allocatedSz, free(buf);
+               pm_error("Failed to get memory"););
+        bytesReadCt = fread(buf + sizeSoFar, 1, 4096, fileP);
+    } while (bytesReadCt != 0);
 
-    if(ferror(f)) {
+    if (ferror(fileP)) {
         free(buf);
-        return NULL;
-    }
-    else {
-        /* buf = realloc(buf, x); */
-        *s = x;
-        return buf;
+        pm_error("Failed to read input");
+    } else {
+        *bytesP = buf;
+        *sizeP  = sizeSoFar;
     }
 }
 
-int main(int argc, char **argv) {
-    struct pam output = {
-        .size = sizeof(struct pam),
-        .len = PAM_STRUCT_SIZE(tuple_type),
-        .maxval = QOI_MAXVAL,
-        .plainformat = 0
-    };
 
-    qoi_desc qd = {
-        .channels = 0
-    };
 
-    pm_proginit(&argc, (const char **)argv);
+int
+main(int argc, char **argv) {
+
+    struct pam outpam;
+
+    outpam.size        = sizeof(struct pam);
+    outpam.len         = PAM_STRUCT_SIZE(tuple_type);
+    outpam.maxval      = QOI_MAXVAL;
+    outpam.plainformat = 0;
+
+    qoi_Desc qoiDesc;
 
-    size_t il = 0;
-    char *img;
-    unsigned char *qoi_buf;
-    tuple *tr;
+    qoiDesc.channelCt = 0;
 
-    img = read_into_mem(stdin, &il);
+    pm_proginit(&argc, (const char **)argv);
+
+    unsigned int qoiSz;
+    const unsigned char * qoiImg;
+    unsigned char * qoiRaster;
+    tuple * tuplerow;
+    unsigned int qoiRasterCursor;
+    unsigned int row;
 
-    if(!img || il == 0)
-        pm_error("Failed to read qoi into memory.");
+    /* Unfortunately, qoi.h does not implement a streaming decoder,
+       we need to read the whole stream into memory -- expensive.
+       We might be able to cheat here with mmap sometimes,
+       but it's not worth the effort.
+    */
+    readFile(stdin, &qoiImg, &qoiSz);
 
-    qoi_buf = qoi_decode(img, il, &qd, 0);
-    free(img);
+    qoiRaster = qoi_decode(qoiImg, qoiSz, &qoiDesc);
 
-    if(!qoi_buf)
+    if (!qoiRaster)
         pm_error("Decoding qoi failed.");
 
-    output.depth = qd.channels == 3 ? 3 : 4;
-    output.width = qd.width;
-    output.height = qd.height;
-    output.file = stdout;
+    outpam.depth  = qoiDesc.channelCt == 3 ? 3 : 4;
+    outpam.width  = qoiDesc.width;
+    outpam.height = qoiDesc.height;
+    outpam.format = PAM_FORMAT;
+    outpam.file   = stdout;
 
-    /* Output PPM if the input is RGB only,
-       PAM with tuple type RGB_ALPHA otherwise. */
-    if(qd.channels == 3) {
-        output.format = PPM_FORMAT;
-        strcpy(output.tuple_type, PAM_PPM_TUPLETYPE);
-    }
-    else {
-        output.format = PAM_FORMAT;
-        strcpy(output.tuple_type, PAM_PPM_ALPHA_TUPLETYPE);
-    }
-    pnm_writepaminit(&output);
-    tr = pnm_allocpamrow(&output);
+    if (qoiDesc.channelCt == 3)
+        strcpy(outpam.tuple_type, PAM_PPM_TUPLETYPE);
+    else
+        strcpy(outpam.tuple_type, PAM_PPM_ALPHA_TUPLETYPE);
 
-    size_t k = 0;
+    pnm_writepaminit(&outpam);
 
-    if(output.depth == 3) {
-        for(int i = 0; i < output.height; i++) {
-            for(int j = 0; j < output.width; j++) {
-                tr[j][0] = qoi_buf[k++];
-                tr[j][1] = qoi_buf[k++];
-                tr[j][2] = qoi_buf[k++];
-            }
-            pnm_writepamrow(&output, tr);
-        }
-    }
-    else {
-        for(int i = 0; i < output.height; i++) {
-            for(int j = 0; j < output.width; j++) {
-                tr[j][0] = qoi_buf[k++];
-                tr[j][1] = qoi_buf[k++];
-                tr[j][2] = qoi_buf[k++];
-                tr[j][3] = qoi_buf[k++];
+    tuplerow = pnm_allocpamrow(&outpam);
+
+    qoiRasterCursor = 0;  /* initial value */
+
+    for (row = 0; row < outpam.height; ++row) {
+        unsigned int col;
+
+        for (col = 0; col < outpam.width; ++col) {
+            tuplerow[col][PAM_RED_PLANE] = qoiRaster[qoiRasterCursor++];
+            tuplerow[col][PAM_GRN_PLANE] = qoiRaster[qoiRasterCursor++];
+            tuplerow[col][PAM_BLU_PLANE] = qoiRaster[qoiRasterCursor++];
+            if (outpam.depth > 3)
+                tuplerow[col][PAM_TRN_PLANE] = qoiRaster[qoiRasterCursor++];
             }
-            pnm_writepamrow(&output, tr);
-        }
+        pnm_writepamrow(&outpam, tuplerow);
     }
 
-    free(qoi_buf);
-    pnm_freepamrow(tr);
+    free((void*)qoiImg);
+    free(qoiRaster);
+    pnm_freepamrow(tuplerow);
+
     return 0;
 }