gif

/* Copyright 2021 (c) phoebos
 *
 * This program reads a gif from stdin or a supplied filename
 * and prints the {global,local} color table then the bitmap
 * where each pixel is a number corresponding to the index of the color.
 */

#include <fcntl.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define BUF_SIZE 100
#define FAIL_GIF 1
#define FAIL_SYS 2

typedef unsigned char rgb[3];
struct Color_table {
    int len; /* 2- 256 */
    rgb table[256];
};
struct Gif {
    char version[3]; /* 87a or 89a */
    uint16_t width;
    uint16_t height;
    unsigned char flags;        /* ABBBCDDD
                                   A: global colour table [GCT] flag
                                   B+1: colour resolution (bits per primary colour)
                                   C: GCT sort flag (89a+ only)
                                   D+1: bits used per pixel in GCT
                                */
    unsigned char background;   /* color index in GCT of screen background */
    unsigned char aspect_ratio; /* 89a+ only */
    struct Color_table *gct;
    unsigned char *pixels; /* array of indices to colors */
};
struct Image {
    struct Color_table *lct;
    uint16_t left, top, width, height;
    unsigned char flags; /* AB000CCC
                            A: 0 -> use GCT, ignore C
                               1 -> LCT follows, use C
                            B: 0 -> image is in Sequential order
                               1 -> image is in Interlaced order
                            C+1: bits per pixel for this image
                         */
    unsigned char *pixels;
};

void
scan_colortable(struct Color_table *ct, unsigned char *buf) {
    /* TODO: gif87a.txt L 336? */
    int i;
    for (i = 0; i < ct->len; i += 1) {
        rgb c = {*buf++, *buf++, *buf++};
        memcpy(ct->table[i], c, sizeof(rgb));
    }
}

void
print_colortable(struct Color_table *c) {
    for (int i = 0; i < c->len; i++) {
        printf("%d: \033[48;2;%d;%d;%dm(%02x;%02x;%02x)\033[0m\n", i,
               c->table[i][0], c->table[i][1], c->table[i][2], c->table[i][0],
               c->table[i][1], c->table[i][2]);
    }
}

/* gif_decode_image should be called with buf pointing to the separator
 * character, ','. gct should be a pointer to the global color table.
 */
int
gif_decode_image(struct Image *img, struct Color_table *gct,
                     unsigned char *buf) {
    if (*buf++ != ',') {
        fprintf(stderr, "not an image block\n");
        return FAIL_GIF;
    }
    struct Color_table *ct = gct;

    /* Get the top, left, width, and height from the beginning of buf.
     * They are all 2 byte numbers with the LSB first. */
    uint16_t *tmp;
    tmp = (uint16_t *)buf;
    img->left = *tmp;
    buf += 2;
    tmp = (uint16_t *)buf;
    img->top = *tmp;
    buf += 2;
    tmp = (uint16_t *)buf;
    img->width = *tmp;
    buf += 2;
    tmp = (uint16_t *)buf;
    img->height = *tmp;
    buf += 2;

    fprintf(stderr, "image block starts at %d,%d with dimensions %d,%d\n",
            img->left, img->top, img->width, img->height);

    img->flags = *buf++;

    if (img->flags && 0x80) {
        /* local color table follows */
        fprintf(stderr, "using LCT(%d)\n", img->flags && 7);
        scan_colortable(img->lct, buf);
        buf += 3 * img->lct->len;
        print_colortable(img->lct);

        ct = img->lct;
    } else {
        /* use GCT */
        fprintf(stderr, "using GCT, ");
    }

    if (img->flags && 0x40) {
        /* image is interlaced */
        fprintf(stderr, "interlaced\n");
        /* TODO */
        return -1;
    } else {
        /* image is sequential */
        fprintf(stderr, "sequential\n");
    }

    return 0;
}

int
gif_decode(unsigned char *buf, size_t len) {
    struct Gif g = {0};
    g.gct = malloc(sizeof(struct Color_table));
    if (g.gct == NULL) {
        perror("malloc");
        exit(FAIL_SYS);
    }
    struct Image *img;
    int cur_block;
    enum { HEAD = 1, SPEC = 2, IMGE = 4 };
    cur_block = HEAD;
    (void)cur_block;

    if (strncmp((char *)buf, "GIF", 3))
        return FAIL_GIF;
    buf += 3;
    len -= 3;
    strncpy(g.version, (char *)buf, 3);
    fprintf(stderr, "GIF version %s, ", g.version);
    buf += 3;
    len -= 3;

    uint16_t *tmp;

    tmp = (uint16_t *)buf;
    g.width = *tmp;
    buf += 2;

    tmp = (uint16_t *)buf;
    g.height = *tmp;
    buf += 2;

    fprintf(stderr, "%d x %d\n", g.width, g.height);

    g.flags = *buf++;
    g.background = *buf++;
    g.aspect_ratio = *buf++;

    g.gct->len = (int)pow(2.0, (double)(g.flags & 7U) + 1);
    fprintf(stderr, "%d colors in GCT\n", g.gct->len);

    /* if GCT... */
    if (g.flags & 0x80) {
        scan_colortable(g.gct, buf);
        buf += 3 * g.gct->len;
    }

    print_colortable(g.gct);

    /* END OF HEADER */

    while (--len) {
        ++buf;
        switch (*buf) {
        case '!':
            if (cur_block != SPEC) {
                cur_block = SPEC;
            }
            break;
        case ',':
            if (cur_block != IMGE) {
                cur_block = IMGE;
                img = malloc(sizeof(struct Image));
                if (img == NULL) {
                    perror("malloc");
                    exit(FAIL_SYS);
                }
                img->lct = malloc(sizeof(struct Color_table));
                if (img->lct == NULL) {
                    perror("malloc");
                    exit(FAIL_SYS);
                }
                img->lct->len = g.gct->len;
                int ret;
                ret = gif_decode_image(img, g.gct, buf);
                if (ret != 0)
                    return ret;
            }
            break;
        case ';':
            /* last char of image section */
            return 0;
        }
    }
    free(img);

    return 0;
}

int
main(int argc, char **argv) {
    int fd;

    /* only work on one file */
    if (argc > 2) {
        fprintf(stderr, "too many args\n");
        return FAIL_SYS;
    }

    ++argv;
    /* stdin */
    if (argc == 1 || **argv == '-')
        fd = 0;
    else {
        /* open named file */
        fd = open(*argv, O_RDONLY);
        if (fd == -1) {
            perror(*argv);
            return FAIL_SYS;
        }
    }

    unsigned char *buf;
    buf = malloc(BUF_SIZE);
    if (buf == NULL) {
        perror("malloc");
        exit(FAIL_SYS);
    }

    /* read the whole file from fd into buf. */
    ssize_t bytes;
    size_t size, used;
    unsigned char *tmp;
    used = 0;
    size = BUF_SIZE; /* initial size from malloc(BUF_SIZE) above */

    while (1) {
        if (used + BUF_SIZE + 1 > size) {
            size = used + BUF_SIZE + 1;
            tmp = realloc(buf, size);
            if (tmp == NULL) {
                /* out of memory */
                perror("realloc");
                free(buf);
                return FAIL_SYS;
            }
            buf = tmp;
        }
        bytes = read(fd, buf + used, BUF_SIZE);
        if (bytes == 0)
            break; /* EOF */
        if (bytes < 0) {
            perror("read");
            return FAIL_SYS;
        }
        used += bytes;
    }

    if (close(fd) != 0) {
        perror("close");
        return FAIL_SYS;
    }

    int ret = gif_decode(buf, used);
    switch (ret) {
    case FAIL_GIF:
        fprintf(stderr, "error: invalid GIF format\n");
        return FAIL_GIF;
    case 0:
        break;
    default:
        return ret;
    }

    free(buf);
    return 0;
}