✨ TGA

.vscode/launch.json

···
     {
       "type": "lldb",
       "request": "launch",
-      "name": "Inspect PBM",
+      "name": "Inspect TGA",
       "program": "${workspaceFolder}/img-inspect",
-      "args": ["TestImages/j.pbm"],
+      "args": ["TestImages/kitty.tga"],
       "cwd": "${workspaceFolder}"
     },
     {
       "type": "lldb",
       "request": "launch",
-      "name": "BMP2PPM",
+      "name": "TGA2PPM",
       "program": "${workspaceFolder}/img2ppm",
-      "args": ["TestImages/monochrome.bmp", "TestImages/monochrome.bmp.ppm"],
+      "args": ["TestImages/rgby.tga", "TestImages/rgby.tga.ppm"],
       "cwd": "${workspaceFolder}"
     }
   ]

img-inspect.c

···
 #include "img.h"
 #include <stdio.h>
+#include <string.h>
 
 struct Ctx {
   FILE *file;
···
   if(argc < 2) {
     printf("Usage: %s <file>\n", argv[0]);
     return 1;
+  }
+
+  int dumpColorMap = 0;
+  for(int i = 2; i < argc; ++i) {
+    /* BMP Color Table, TGA Color Map */
+    if(strcmp(argv[i], "-colorMap") == 0
+    || strcmp(argv[1], "-colorTable") == 0) {
+      dumpColorMap = 1;
+    }
   }
 
   FILE *file = fopen(argv[1], "rb");
···
       img.bmp.xPPM,
       img.bmp.yPPM,
       img.bmp.colorTableSize);
+    if(dumpColorMap && img.bmp.colorTableSize) {
+      printf("  Color table:\n");
+      for(int i = 0; i < img.bmp.colorTableSize; ++i) {
+        const struct ImgBmpRGBQuad *color = &img.bmp.colorTable[i];
+        printf("    %u,%u,%u,%u\n",
+          color->red, color->green, color->blue, color->reserved);
+      }
+    }
+    break;
+  case ImgFormatTga:
+    printf(
+      "ID: %s\n"
+      "Color map type: %u\n"
+      "Image type: %u\n"
+      "Color map first index: %u\n"
+      "Color map length: %u\n"
+      "Color map entry size: %u\n"
+      "Origin X: %u\n"
+      "Origin Y: %u\n"
+      "Pixel Depth: %u\n"
+      "Image Origin: %u\n"
+      "Alpha Bits: %u\n",
+      img.tga.id,
+      img.tga.colorMapType,
+      img.tga.imageType,
+      img.tga.colorMapFirstIndex,
+      img.tga.colorMapLength,
+      img.tga.colorMapEntrySize,
+      img.tga.originX,
+      img.tga.originY,
+      img.tga.pixelDepth,
+      img.tga.imageOrigin,
+      img.tga.alphaBits);
+    if(dumpColorMap && img.tga.colorMapType) {
+      printf("  Color map:\n");
+      for(int i = 0; i < img.tga.colorMapLength; ++i) {
+        const struct ImgTgaColor *color = &img.tga.colorMap[i];
+        printf("    %u,%u,%u,%u\n",
+          color->red, color->green, color->blue, color->alpha);
+      }
+    }
     break;
   default:
     break;

img.c

···
 static ImgStatus readPbm(Img *img, ImgAny buf, ImgSz bufSz);
 static ImgStatus openBmp(Img *img);
 static ImgStatus readBmp(Img *img, ImgAny buf, ImgSz bufSz);
+static ImgStatus openTga(Img *img);
+static ImgStatus readTga(Img *img, ImgAny buf, ImgSz bufSz);
 
 ImgStatus imgOpen(Img *img, const ImgFuncs *funcs)
 {
···
     return openPbm(img);
   case ImgFormatBmp:
     return openBmp(img);
+  case ImgFormatTga:
+    return openTga(img);
   }
 }
 
···
     return readPbm(img, buf, bufSz);
   case ImgFormatBmp:
     return readBmp(img, buf, bufSz);
+  case ImgFormatTga:
+    return readTga(img, buf, bufSz);
   }
 }
 
···
     return "PBM";
   case ImgFormatBmp:
     return "BMP";
+  case ImgFormatTga:
+    return "TGA";
   }
 }
 
···
     return "BMP: Unsupported compression mode";
   case ImgErrBmpUnsupportedBitDepth:
     return "BMP: Unsupported bit depth";
+  case ImgErrTgaMissingColorMap:
+    return "TGA: Missing color map";
+  case ImgErrTgaColorMapTooLong:
+    return "TGA: Color map too long (>256 colors)";
+  case ImgErrTgaNoImageData:
+    return "TGA: Attempt to decode an image not containing image data";
+  case ImgErrTgaUnsupportedPixelDepth:
+    return "TGA: Unsupported pixel depth";
   }
 }
 
···
   return ImgOK;
 }
 
+static ImgStatus readU24LE(Img *img, ImgU32 *out)
+{
+  ImgU8 bytes[3];
+  ImgStatus status = img->funcs.read(img->funcs.user, bytes, 3);
+  if(status != ImgOK) { return status; }
+  #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+  *out = ((ImgU32)bytes[2] << 16) | ((ImgU32)bytes[1] << 8) | (ImgU32)bytes[0];
+  #else
+  *out = ((ImgU32)bytes[0] << 16) | ((ImgU32)bytes[1] << 8) | (ImgU32)bytes[2];
+  #endif
+  return ImgOK;
+}
+
 static ImgStatus readU32LE(Img *img, ImgU32 *out)
 {
   ImgStatus status = img->funcs.read(img->funcs.user, out, 4);
···
   return img->funcs.seek(img->funcs.user, off);
 }
 
+static ImgStatus determineTga(Img *img);
+
 static ImgStatus determineFormat(Img *img)
 {
   ImgStatus status;
···
     img->format = ImgFormatQoi;
     return ImgOK;
   }
-  return ImgErrUnknownFormat;
+  status = determineTga(img);
+  if(status != ImgOK) { return status; }
+  if(img->format == ImgFormatUnknown) {
+    return ImgErrUnknownFormat;
+  }
+  return ImgOK;
 }
 
 struct RGBA {
···
 
   return ImgOK;
 }
+
+#define TGA_NO_IMAGE_DATA 0
+#define TGA_COLOR_MAPPED 1
+#define TGA_TRUE_COLOR 2
+#define TGA_BLACK_AND_WHITE 3
+#define TGA_RLE_COLOR_MAPPED 9
+#define TGA_RLE_TRUE_COLOR 10
+#define TGA_RLE_BLACK_AND_WHITE 11
+
+ImgStatus determineTga(Img *img)
+{
+  ImgOff returnOff = 0;
+  ImgStatus status;
+
+  status = read(img, &img->tga.idLength, 1);
+  ++returnOff;
+  if(status != ImgOK) { return status; }
+
+  status = read(img, &img->tga.colorMapType, 1);
+  ++returnOff;
+  if(status != ImgOK) { return status; }
+
+  /* invalid color map type, likely not TGA */
+  if(img->tga.colorMapType != 0 && img->tga.colorMapType != 1) {
+    return seek(img, -returnOff);
+  }
+
+  status = read(img, &img->tga.imageType, 1);
+  ++returnOff;
+  if(status != ImgOK) { return status; }
+
+  switch(img->tga.imageType) {
+  case TGA_NO_IMAGE_DATA:
+  case TGA_COLOR_MAPPED:
+  case TGA_TRUE_COLOR:
+  case TGA_BLACK_AND_WHITE:
+  case TGA_RLE_COLOR_MAPPED:
+  case TGA_RLE_TRUE_COLOR:
+  case TGA_RLE_BLACK_AND_WHITE:
+    break;
+  /* invalid image type, likely not TGA */
+  default:
+    return seek(img, -returnOff);
+  }
+
+  status = readU16LE(img, &img->tga.colorMapFirstIndex);
+  returnOff += 2;
+  if(status != ImgOK) { return status; }
+
+  if(!img->tga.colorMapType && img->tga.colorMapFirstIndex != 0) {
+    return seek(img, -returnOff);
+  }
+
+  status = readU16LE(img, &img->tga.colorMapLength);
+  returnOff += 2;
+  if(status != ImgOK) { return status; }
+
+  if(!img->tga.colorMapType && img->tga.colorMapLength != 0) {
+    return seek(img, -returnOff);
+  }
+  if(img->tga.colorMapType && img->tga.colorMapLength == 0) {
+    return seek(img, -returnOff);
+  }
+
+  status = read(img, &img->tga.colorMapEntrySize, 1);
+  ++returnOff;
+  if(status != ImgOK) { return status; }
+
+  if(!img->tga.colorMapType && img->tga.colorMapEntrySize != 0) {
+    return seek(img, -returnOff);
+  }
+
+  status = readU16LE(img, &img->tga.originX);
+  returnOff += 2;
+  if(status != ImgOK) { return status; }
+
+  status = readU16LE(img, &img->tga.originY);
+  returnOff += 2;
+  if(status != ImgOK) { return status; }
+
+  status = readU16LE(img, &img->tga.width);
+  returnOff += 2;
+  if(status != ImgOK) { return status; }
+
+  status = readU16LE(img, &img->tga.height);
+  returnOff += 2;
+  if(status != ImgOK) { return status; }
+
+  status = read(img, &img->tga.pixelDepth, 1);
+  returnOff += 1;
+  if(status != ImgOK) { return status; }
+
+  ImgU8 imageDescriptor;
+  status = read(img, &imageDescriptor, 1);
+  ++returnOff;
+  if(status != ImgOK) { return status; }
+
+  /* unused bits must be 0 */
+  if((imageDescriptor >> 6) != 0) {
+    return seek(img, -returnOff);
+  }
+
+  img->tga.alphaBits = imageDescriptor & 15;
+  img->tga.imageOrigin = (imageDescriptor >> 4) & 3;
+
+  img->format = ImgFormatTga;
+  return ImgOK;
+}
+
+/* Number of bytes needed to store the given amount of bits */
+#define BITS_TO_BYTES(bits) (((bits) + 7) >> 3)
+
+ImgStatus openTga(Img *img)
+{
+  ImgStatus status;
+
+  if(img->tga.colorMapType) {
+    if(img->tga.colorMapLength > IMG_TGA_MAX_COLOR_MAP_SIZE) {
+      return ImgErrTgaColorMapTooLong;
+    }
+  } else if(img->tga.imageType == TGA_COLOR_MAPPED || img->tga.imageType == TGA_RLE_COLOR_MAPPED) {
+    return ImgErrTgaMissingColorMap;
+  }
+
+  /* the header was already read in by determineTga() */
+  if(img->tga.idLength) {
+    status = read(img, img->tga.id, img->tga.idLength);
+    if(status != ImgOK) { return status; }
+  }
+  /* NUL-terminate for convenience */
+  img->tga.id[img->tga.idLength] = '\0';
+
+  /* set this here in case there is no color map */
+  if(img->tga.alphaBits) {
+    img->channelCount = 4;
+  } else {
+    img->channelCount = 3;
+  }
+  img->width = img->tga.width;
+  img->height = img->tga.height;
+
+  /* image data follows color map and we'll read that in readTga() */
+  /* so if we don't have a color map, we just return early here */
+  if(!img->tga.colorMapType) {
+    return ImgOK;
+  }
+
+  /* bits in a color field */
+  ImgU32 fieldBits = img->tga.colorMapEntrySize / 3;
+  /* spec requires fields be at most 8 bits each */
+  if(fieldBits > 8) {
+    fieldBits = 8;
+  }
+  /* mask of a field's bits */
+  ImgU32 fieldMask = (1 << fieldBits) - 1;
+  /* bits in a full color entry (3 fields) */
+  ImgU32 entryBits = fieldBits * 3;
+  /* total bits needed to store the entry (round up to 8) */
+  ImgU32 totalBits = BITS_TO_BYTES(img->tga.colorMapEntrySize) << 3;
+  /* bits not used by entry */
+  ImgU32 alphaBits = totalBits - entryBits;
+  /* alpha bit mask */
+  ImgU32 alphaMask = (1 << alphaBits) - 1;
+  if(alphaBits != 0) {
+    img->channelCount = 4;
+  } else {
+    img->channelCount = 3;
+  }
+
+  ImgU8 entry8;
+  ImgU16 entry16;
+  ImgU32 entry32;
+  for(ImgU16 i = img->tga.colorMapFirstIndex; i < img->tga.colorMapLength; ++i) {
+    struct ImgTgaColor *color = &img->tga.colorMap[i];
+
+    switch(totalBits) {
+    case 8:
+      status = read(img, &entry8, 1);
+      if(status != ImgOK) { return status; }
+      entry32 = entry8;
+      break;
+    case 16:
+      status = readU16LE(img, &entry16);
+      if(status != ImgOK) { return status; }
+      entry32 = entry16;
+      break;
+    case 32:
+      status = readU32LE(img, &entry32);
+      if(status != ImgOK) { return status; }
+      break;
+    }
+
+    color->red = (entry32 >> (fieldBits * 2)) & fieldMask;
+    color->green = (entry32 >> fieldBits) & fieldMask;
+    color->blue = entry32 & fieldMask;
+    if(alphaBits > 0) {
+      color->alpha = (entry32 >> (fieldBits * 3)) & alphaMask;
+    }
+  }
+
+  return ImgOK;
+}
+
+static ImgStatus readTgaColorMapped(Img *img, ImgAny buf, ImgSz bufSz);
+static ImgStatus readTgaTrueColor(Img *img, ImgAny buf, ImgSz bufSz);
+static ImgStatus readTgaBlackAndWhite(Img *img, ImgAny buf, ImgSz bufSz);
+static ImgStatus readTgaRleColorMapped(Img *img, ImgAny buf, ImgSz bufSz);
+static ImgStatus readTgaRleTrueColor(Img *img, ImgAny buf, ImgSz bufSz);
+static ImgStatus readTgaRleBlackAndWhite(Img *img, ImgAny buf, ImgSz bufSz);
+
+/* TODO: Implement RLE */
+ImgStatus readTga(Img *img, ImgAny buf, ImgSz bufSz)
+{
+  ImgSz expectedSize = (ImgSz)img->width * img->height * img->channelCount;
+  if(bufSz < expectedSize) {
+    return ImgErrBufferTooSmall;
+  }
+
+  switch(img->tga.imageType) {
+  case TGA_NO_IMAGE_DATA:
+    return ImgErrTgaNoImageData;
+  case TGA_COLOR_MAPPED:
+    return readTgaColorMapped(img, buf, bufSz);
+  case TGA_TRUE_COLOR:
+    return readTgaTrueColor(img, buf, bufSz);
+  case TGA_BLACK_AND_WHITE:
+    return readTgaBlackAndWhite(img, buf, bufSz);
+  case TGA_RLE_COLOR_MAPPED:
+    return readTgaRleColorMapped(img, buf, bufSz);
+  case TGA_RLE_TRUE_COLOR:
+    return readTgaRleTrueColor(img, buf, bufSz);
+  case TGA_RLE_BLACK_AND_WHITE:
+    return readTgaRleBlackAndWhite(img, buf, bufSz);
+  }
+  return ImgErrUnimplemented;
+}
+
+ImgStatus readTgaColorMapped(Img *img, ImgAny buf, ImgSz bufSz)
+{
+  ImgStatus status;
+  ImgSz expectedSize = (ImgSz)img->width * img->height * img->channelCount;
+  ImgU8 *cur = buf;
+  ImgU8 *end = cur + expectedSize;
+
+  /* above 8 not supported, also enforced by IMG_TGA_MAX_COLOR_MAP_LENGTH */
+  if(img->tga.pixelDepth > 8) {
+    return ImgErrTgaUnsupportedPixelDepth;
+  }
+
+  ImgU8 pixel;
+  while(cur < end) {
+    status = read(img, &pixel, 1);
+    if(status != ImgOK) { return status; }
+
+    const struct ImgTgaColor *color = &img->tga.colorMap[pixel];
+    *cur++ = color->red;
+    *cur++ = color->green;
+    *cur++ = color->blue;
+    if(img->channelCount == 4) {
+      *cur++ = color->alpha;
+    }
+  }
+
+  return ImgOK;
+}
+
+ImgStatus readTgaTrueColor(Img *img, ImgAny buf, ImgSz bufSz)
+{
+  ImgStatus status;
+  ImgSz expectedSize = (ImgSz)img->width * img->height * img->channelCount;
+  ImgU8 *curr = buf;
+  ImgU8 *end = curr + expectedSize;
+
+  ImgU32 pixelSize = BITS_TO_BYTES(img->tga.pixelDepth);
+  ImgU32 alphaMask = (1 << img->tga.alphaBits) - 1;
+  ImgU32 fieldBits = (img->tga.pixelDepth - img->tga.alphaBits) / 3;
+  ImgU32 fieldMask = (1 << fieldBits) - 1;
+
+  ImgU8 pixel8;
+  ImgU16 pixel16;
+  ImgU32 pixel32;
+  while(curr < end) {
+    switch(pixelSize) {
+    case 1:
+      status = read(img, &pixel8, 1);
+      if(status != ImgOK) { return status; }
+      pixel32 = pixel8;
+      break;
+    case 2:
+      status = readU16LE(img, &pixel16);
+      if(status != ImgOK) { return status; }
+      pixel32 = pixel16;
+      break;
+    case 3:
+      status = readU24LE(img, &pixel32);
+      if(status != ImgOK) { return status; };
+      break;
+    case 4:
+      status = readU32LE(img, &pixel32);
+      if(status != ImgOK) { return status; }
+      break;
+    default:
+      return ImgErrTgaUnsupportedPixelDepth;
+    }
+
+    *curr++ = (pixel32 >> (2 * fieldBits)) & fieldMask;
+    *curr++ = (pixel32 >> fieldBits) & fieldMask;
+    *curr++ = pixel32 & fieldMask;
+    if(img->channelCount > 3) {
+      *curr++ = (pixel32 >> (3 * fieldBits)) & alphaMask;
+    }
+  }
+
+  return ImgOK;
+}
+
+ImgStatus readTgaBlackAndWhite(Img *img, ImgAny buf, ImgSz bufSz)
+{
+  ImgStatus status;
+  ImgSz expectedSize = (ImgSz)img->width * img->height * img->channelCount;
+  ImgU8 *curr = buf;
+  ImgU8 *end = curr + expectedSize;
+
+  ImgU32 pixelSize = BITS_TO_BYTES(img->tga.pixelDepth);
+  ImgU8 pixel8;
+  ImgU16 pixel16;
+  ImgU32 pixel32;
+  while(curr < end) {
+    switch(pixelSize) {
+    case 1:
+      status = read(img, &pixel8, 1);
+      if(status != ImgOK) { return status; }
+      break;
+    case 2:
+      status = readU16LE(img, &pixel16);
+      if(status != ImgOK) { return status; }
+      pixel8 = pixel16 >> 8;
+      break;
+      case 3:
+      status = readU24LE(img, &pixel32);
+      if(status != ImgOK) { return status; }
+      pixel8 = pixel32 >> 16;
+      break;
+      case 4:
+      status = readU32LE(img, &pixel32);
+      if(status != ImgOK) { return status; }
+      pixel8 = pixel32 >> 24;
+      break;
+    default:
+      return ImgErrTgaUnsupportedPixelDepth;
+    }
+
+    *curr++ = pixel8;
+    *curr++ = pixel8;
+    *curr++ = pixel8;
+    if(img->channelCount > 3) {
+      *curr++ = 255;
+    }
+  }
+
+  return ImgOK;
+}
+
+ImgStatus readTgaRleColorMapped(Img *img, ImgAny buf, ImgSz bufSz)
+{
+  return ImgErrUnimplemented;
+}
+
+ImgStatus readTgaRleTrueColor(Img *img, ImgAny buf, ImgSz bufSz)
+{
+  return ImgErrUnimplemented;
+}
+
+ImgStatus readTgaRleBlackAndWhite(Img *img, ImgAny buf, ImgSz bufSz)
+{
+  return ImgErrUnimplemented;
+}

img.h

···
   ImgErrBmpUnsupportedVariant,
   ImgErrBmpPlaneCount,
   ImgErrBmpUnsupportedCompression,
-  ImgErrBmpUnsupportedBitDepth
+  ImgErrBmpUnsupportedBitDepth,
+  ImgErrTgaMissingColorMap,
+  ImgErrTgaColorMapTooLong,
+  ImgErrTgaNoImageData,
+  ImgErrTgaUnsupportedPixelDepth,
 };
 
 typedef enum ImgStatusE ImgStatus;
···
   ImgFormatUnknown,
   ImgFormatQoi,
   ImgFormatPbm,
-  ImgFormatBmp
+  ImgFormatBmp,
+  ImgFormatTga
 };
 
 typedef enum ImgFormatE ImgFormat;
 
-struct ImgQoiInfoS {
+struct ImgQoi {
   ImgU8 colorSpace;
 };
 
-struct ImgPbmInfoS {
+struct ImgPbm {
   char variant;
   ImgU16 max;
 };
···
   ImgU8 reserved;
 };
 
-struct ImgBmpInfoS {
+struct ImgBmp {
   ImgU32 bitmapOffset;
   ImgS32 width;
   ImgS32 height;
···
   struct ImgBmpRGBQuad colorTable[256];
 };
 
+/* for color map, converted to RGBA32 for convenience */
+struct ImgTgaColor {
+  ImgU8 red;
+  ImgU8 green;
+  ImgU8 blue;
+  ImgU8 alpha;
+};
+
+/* just use true-color at that point */
+#define IMG_TGA_MAX_COLOR_MAP_SIZE 256
+
+struct ImgTga {
+  ImgU8 idLength;
+  /* 1 extra for null byte */
+  char id[256];
+  /* 1 if has color map, 0 otherwise */
+  ImgU8 colorMapType;
+  ImgU8 imageType;
+  ImgU16 colorMapFirstIndex;
+  ImgU16 colorMapLength;
+  ImgU8 colorMapEntrySize;
+  ImgU16 originX;
+  ImgU16 originY;
+  ImgU16 width;
+  ImgU16 height;
+  ImgU8 imageOrigin;
+  ImgU8 pixelDepth;
+  ImgU8 alphaBits;
+  struct ImgTgaColor colorMap[IMG_TGA_MAX_COLOR_MAP_SIZE];
+};
+
 struct ImgS {
   ImgFormat format;
   ImgU32 width;
···
   ImgU8 channelCount;
   ImgFuncs funcs;
   union {
-    struct ImgQoiInfoS qoi;
-    struct ImgPbmInfoS pbm;
-    struct ImgBmpInfoS bmp;
+    struct ImgQoi qoi;
+    struct ImgPbm pbm;
+    struct ImgBmp bmp;
+    struct ImgTga tga;
   };
 };