✨ GIF but without decoding

.vscode/launch.json

···
     {
       "type": "lldb",
       "request": "launch",
-      "name": "TGA2PPM",
+      "name": "GIF2PPM",
       "program": "${workspaceFolder}/img2ppm",
-      "args": ["TestImages/rgby.tga", "TestImages/rgby.tga.ppm"],
+      "args": ["TestImages/gifdecod.gif", "TestImages/gifdecod.gif.ppm"],
       "cwd": "${workspaceFolder}"
     }
   ]

img-inspect.c

···
   for(int i = 2; i < argc; ++i) {
     /* BMP Color Table, TGA Color Map */
     if(strcmp(argv[i], "-colorMap") == 0
-    || strcmp(argv[1], "-colorTable") == 0) {
+    || strcmp(argv[i], "-colorTable") == 0) {
       dumpColorMap = 1;
     }
   }
···
         const struct ImgTgaColor *color = &img.tga.colorMap[i];
         printf("    %u,%u,%u,%u\n",
           color->red, color->green, color->blue, color->alpha);
+      }
+    }
+    break;
+  case ImgFormatGif:
+    printf(
+      "Global Color Table Flag: %u\n"
+      "Color Resolution: %u\n"
+      "Sort Flag: %u\n"
+      "Global Color Table Size: %u\n"
+      "Background Color Index: %u\n"
+      "Pixel Aspect Ratio: %u\n",
+      img.gif.globalColorTableFlag,
+      img.gif.colorResolution,
+      img.gif.sortFlag,
+      img.gif.globalColorTableSize,
+      img.gif.backgroundColorIndex,
+      img.gif.pixelAspectRatio);
+    if(dumpColorMap && img.gif.globalColorTableFlag) {
+      printf("  Global Color Table:\n");
+      for(int i = 0; i < img.gif.globalColorTableSize; ++i) {
+        const struct ImgGifColor *color = &img.gif.globalColorTable[i];
+        printf("    %u,%u,%u\n",
+          color->red, color->green, color->blue);
       }
     }
     break;

img.c

···
 static ImgStatus readBmp(Img *img, ImgAny buf, ImgSz bufSz);
 static ImgStatus openTga(Img *img);
 static ImgStatus readTga(Img *img, ImgAny buf, ImgSz bufSz);
+static ImgStatus openGif(Img *img);
+static ImgStatus readGif(Img *img, ImgAny buf, ImgSz bufSz);
 
 ImgStatus imgOpen(Img *img, const ImgFuncs *funcs)
 {
···
     return openBmp(img);
   case ImgFormatTga:
     return openTga(img);
+  case ImgFormatGif:
+    return openGif(img);
   }
 }
 
···
     return readBmp(img, buf, bufSz);
   case ImgFormatTga:
     return readTga(img, buf, bufSz);
+  case ImgFormatGif:
+    return readGif(img, buf, bufSz);
   }
 }
 
···
     return "BMP";
   case ImgFormatTga:
     return "TGA";
+  case ImgFormatGif:
+    return "GIF";
   }
 }
 
···
     return "TGA: Attempt to decode an image not containing image data";
   case ImgErrTgaUnsupportedPixelDepth:
     return "TGA: Unsupported pixel depth";
+  case ImgErrGifExpectedImageDescriptor:
+    return "GIF: Expected Image Descriptor";
+  case ImgErrGifExpectedTrailer:
+    return "GIF: Expected trailer";
   }
 }
 
···
 static ImgStatus determineFormat(Img *img)
 {
   ImgStatus status;
-  char magic[4];
+  char magic[8];
+
   status = read(img, magic, 2);
   if(status != ImgOK) { return status; }
   status = seek(img, -2);
   if(status != ImgOK) { return status; }
+
   if(magic[0] == 'P' && magic[1] >= '1' && magic[1] <= '6') {
     img->format = ImgFormatPbm;
     return ImgOK;
···
     img->format = ImgFormatBmp;
     return ImgOK;
   }
+
   status = read(img, magic, 4);
   if(status != ImgOK) { return status; }
   status = seek(img, -4);
   if(status != ImgOK) { return status; }
+
   if(magic[0] == 'q' && magic[1] == 'o' && magic[2] == 'i' && magic[3] == 'f') {
     img->format = ImgFormatQoi;
     return ImgOK;
   }
+
+  status = read(img, magic, 6);
+  if(status != ImgOK) { return status; }
+  status = seek(img, -6);
+  if(status != ImgOK) { return status; }
+
+  if(magic[0] == 'G' && magic[1] == 'I' && magic[2] == 'F'
+  && magic[3] == '8' && (magic[4] == '7' || magic[4] == '9') && magic[5] == 'a') {
+    img->format = ImgFormatGif;
+    return ImgOK;
+  }
+
   status = determineTga(img);
   if(status != ImgOK) { return status; }
+
   if(img->format == ImgFormatUnknown) {
     return ImgErrUnknownFormat;
   }
···
 {
   return ImgErrUnimplemented;
 }
+
+ImgStatus openGif(Img *img)
+{
+  ImgStatus status;
+
+  /* skip over header */
+  status = seek(img, 6);
+  if(status != ImgOK) { return status; }
+
+  ImgU16 width;
+  ImgU16 height;
+
+  status = readU16LE(img, &width);
+  if(status != ImgOK) { return status; }
+  status = readU16LE(img, &height);
+  if(status != ImgOK) { return status; }
+
+  img->width = width;
+  img->height = height;
+  img->channelCount = 4;
+
+  ImgU8 flags;
+  status = read(img, &flags, 1);
+  if(status != ImgOK) { return status; }
+
+  img->gif.globalColorTableFlag = flags >> 7;
+  img->gif.colorResolution = (flags >> 4) & 7;
+  img->gif.sortFlag = (flags >> 3) & 1;
+  ImgU16 gctSize = flags & 7;
+  img->gif.globalColorTableSize = 1 << (gctSize + 1);
+
+  if(img->gif.globalColorTableFlag) {
+    status = read(img, img->gif.globalColorTable, 3 * img->gif.globalColorTableSize);
+    if(status != ImgOK) { return status; }
+  }
+
+  status = read(img, &img->gif.backgroundColorIndex, 1);
+  if(status != ImgOK) { return status; }
+  status = read(img, &img->gif.pixelAspectRatio, 1);
+  if(status != ImgOK) { return status; }
+
+  return ImgOK;
+}
+
+struct GifBlock {
+  ImgU8 size;
+  ImgU8 data[255];
+};
+
+struct GifImage {
+  ImgU16 left;
+  ImgU16 right;
+  ImgU16 width;
+  ImgU16 height;
+  ImgU8 localColorTableFlag;
+  ImgU8 interlaceFlag;
+  ImgU8 sortFlag;
+  ImgU16 localColorTableSize;
+  struct ImgGifColor localColorTable[256];
+  ImgU8 lzwCodeSize;
+  struct GifBlock block;
+};
+
+#define GIF_TABLE_SIZE 5021
+#define GIF_STACK_SIZE 1024
+
+struct GifDecompressor {
+  struct GifImage gifImage;
+  /* byte offset into current block */
+  ImgU16 byteOff;
+  /* bit offset into current block byte */
+  ImgU8 bitOff;
+  ImgU16 code;
+  ImgU8 *curr;
+
+  ImgU8 stack[GIF_STACK_SIZE];
+  ImgU16 stackOff;
+
+  ImgU8 shade[GIF_TABLE_SIZE];
+  ImgU16 child[GIF_TABLE_SIZE];
+};
+
+/* read the Image Descriptor + code size */
+static ImgStatus gifReadImage(Img *img, struct GifImage *desc);
+static ImgStatus gifReadBlock(Img *img, struct GifBlock *block);
+static ImgStatus gifDecompress(Img *img, struct GifDecompressor *decompressor);
+
+ImgStatus readGif(Img *img, ImgAny buf, ImgSz bufSz)
+{
+  ImgStatus status;
+  ImgSz expectedSize = (ImgSz)img->width * img->height * img->channelCount;
+  ImgU8 *curr = buf;
+  ImgU8 *end = curr + expectedSize;
+
+  struct GifDecompressor decompressor;
+  ImgU8 trailer;
+
+  status = gifReadImage(img, &decompressor.gifImage);
+  if(status != ImgOK) { return status; }
+
+  status = gifReadBlock(img, &decompressor.gifImage.block);
+  if(status != ImgOK) { return status; }
+
+  decompressor.byteOff = 0;
+  decompressor.bitOff = 0;
+  decompressor.curr = curr;
+  decompressor.stackOff = 0;
+  status = gifDecompress(img, &decompressor);
+  if(status != ImgOK) { return status; };
+
+  status = read(img, &trailer, 1);
+  if(status != ImgOK) { return status; }
+
+  if(trailer != 0x3B) {
+    return ImgErrGifExpectedTrailer;
+  }
+
+  return ImgOK;
+}
+
+ImgStatus gifReadImage(Img *img, struct GifImage *gifImage)
+{
+  ImgStatus status;
+  ImgU8 identifier;
+
+  status = read(img, &identifier, 1);
+  if(status != ImgOK) { return status; }
+  if(identifier != 0x2C) {
+    return ImgErrGifExpectedImageDescriptor;
+  }
+
+  status = readU16LE(img, &gifImage->left);
+  if(status != ImgOK) { return status; }
+  status = readU16LE(img, &gifImage->right);
+  if(status != ImgOK) { return status; }
+  status = readU16LE(img, &gifImage->width);
+  if(status != ImgOK) { return status; }
+  status = readU16LE(img, &gifImage->height);
+  if(status != ImgOK) { return status; }
+
+  ImgU8 flags;
+  status = read(img, &flags, 1);
+  if(status != ImgOK) { return status; }
+
+  gifImage->localColorTableFlag = flags >> 7;
+  gifImage->interlaceFlag = (flags >> 6) & 1;
+  gifImage->sortFlag = (flags >> 5) & 1;
+  ImgU16 lctSize = flags & 7;
+  gifImage->localColorTableSize = 1 << (lctSize + 1);
+
+  if(gifImage->localColorTableFlag) {
+    status = read(img, gifImage->localColorTable, 3 * gifImage->localColorTableSize);
+    if(status != ImgOK) { return status; }
+  }
+
+  status = read(img, &gifImage->lzwCodeSize, 1);
+  if(status != ImgOK) { return status; }
+
+  return ImgOK;
+}
+
+ImgStatus gifReadBlock(Img *img, struct GifBlock *block)
+{
+  ImgStatus status;
+
+  status = read(img, &block->size, 1);
+  if(status != ImgOK) { return status; }
+
+  if(block->size) {
+    status = read(img, block->data, block->size);
+    if(status != ImgOK) { return status; }
+  }
+
+  return ImgOK;
+}
+
+ImgStatus gifDecompress(Img *img, struct GifDecompressor *dec)
+{
+  return ImgErrUnimplemented;
+}

img.h

···
   ImgErrTgaColorMapTooLong,
   ImgErrTgaNoImageData,
   ImgErrTgaUnsupportedPixelDepth,
+  ImgErrGifExpectedImageDescriptor,
+  ImgErrGifExpectedTrailer,
 };
 
 typedef enum ImgStatusE ImgStatus;
···
   ImgFormatQoi,
   ImgFormatPbm,
   ImgFormatBmp,
-  ImgFormatTga
+  ImgFormatTga,
+  ImgFormatGif,
 };
 
 typedef enum ImgFormatE ImgFormat;
···
   struct ImgTgaColor colorMap[IMG_TGA_MAX_COLOR_MAP_SIZE];
 };
 
+/* for color table, converted to RGB24 for convenience */
+struct ImgGifColor {
+  ImgU8 red;
+  ImgU8 green;
+  ImgU8 blue;
+};
+
+struct ImgGif {
+  ImgU8 globalColorTableFlag;
+  ImgU8 colorResolution;
+  ImgU8 sortFlag;
+  ImgU16 globalColorTableSize;
+  ImgU8 backgroundColorIndex;
+  ImgU8 pixelAspectRatio;
+  struct ImgGifColor globalColorTable[256];
+};
+
 struct ImgS {
   ImgFormat format;
   ImgU32 width;
···
     struct ImgPbm pbm;
     struct ImgBmp bmp;
     struct ImgTga tga;
+    struct ImgGif gif;
   };
 };