Clean up code with more structured data

1 files changed, 96 insertions, 62 deletions

diff --git a/src/main.c b/src/main.c
index bcd72c9..65dc94d 100644
--- a/src/main.c
+++ b/src/main.c
@@ -20,14 +20,33 @@ rgb15(u32 red, u32 green, u32 blue ) {
 // TODO: Write more documentation about this.
 typedef u32 Tile[TILE_SIZE];
 
+typedef struct Tiles {
+    Tile *data;
+    size_t size;
+    size_t capacity;
+} Tiles;
+
+typedef struct Palette {
+    Color *data;
+    size_t size;
+    size_t capacity;
+} Palette;
+
+typedef struct Image {
+    unsigned char *data;
+    int width;
+    int height;
+    int n_channels;
+} Image;
+
 void
-export_c_file(Tile *tiles, Color *palette, size_t n_tiles, size_t palette_size) {
+export_c_file(Tiles *tiles, Palette *palette) {
     // Output tiles.
-    printf("u32 tiles[][%u] = {\n", TILE_SIZE);
-    for (size_t i = 0; i < n_tiles; ++i) {
+    printf("u32 tiles[%u][%u] = {\n", tiles->capacity, TILE_SIZE);
+    for (size_t i = 0; i < tiles->capacity; ++i) {
         printf("    {");
         for (size_t j = 0; j < TILE_SIZE; ++j) {
-            printf("0x%08x", tiles[i][j]);
+            printf("0x%08x", tiles->data[i][j]);
             if (j != (TILE_SIZE - 1)) {
                 printf(", ");
             }
@@ -38,15 +57,15 @@ export_c_file(Tile *tiles, Color *palette, size_t n_tiles, size_t palette_size)
     printf("\n");
 
     // Output palette.
-    printf("u16 palette[%u] = {\n", palette_size);
+    printf("u16 palette[%u] = {\n", palette->capacity);
     printf("    ");
     size_t counter = 0;
-    for (size_t i = 0; i < palette_size; ++i, ++counter) {
+    for (size_t i = 0; i < palette->capacity; ++i, ++counter) {
             if (counter == 4) {
                 counter = 0;
                 printf("\n    ");
             }
-            printf("0x%04x,", palette[i]);
+            printf("0x%04x,", palette->data[i]);
             if (counter < 3) {
                 printf(" ");
             }
@@ -64,6 +83,47 @@ print_usage(void) {
     // TODO: Print valid options as a suggestion.
 }
 
+void
+extract_tile(Tiles *tiles, Palette *palette, Image *img,
+        size_t offset_x, size_t offset_y) {
+    for (size_t j = 0; j < TILE_SIZE; ++j) {
+        u32 col_index = 0x00000000;
+        for (size_t i = 0; i < TILE_SIZE; ++i) {
+            size_t pal_index = palette->size;
+            // Find the memory index for this pixel.
+            int idx = (i + offset_x) + (j + offset_y) * img->width;
+            idx *= img->n_channels;
+
+            int red = img->data[idx];
+            int green = img->data[idx + 1];
+            int blue = img->data[idx + 2];
+
+            // Quantize to 5 bits per channel.
+            red = (red * 31 / 255);
+            green = (green * 31 / 255);
+            blue = (blue * 31 / 255);
+
+            Color clr = rgb15(red, green, blue);
+            bool found = false;
+            // TODO: If the palette is full, find the closest perceived
+            // color instead.
+            for (size_t p = 0; p < palette->capacity; ++p) {
+                if (clr == palette->data[p]) {
+                    pal_index = p;
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                palette->data[palette->size++] = clr;
+            }
+            col_index |= pal_index << i * 4; // TODO: FlipH?
+        }
+        tiles->data[tiles->size][j] = col_index;
+    }
+    tiles->size++;
+}
+
 int
 main(int argc, char *argv[]) {
     u16 background_color = DEFAULT_BG_COLOR;
@@ -122,85 +182,59 @@ main(int argc, char *argv[]) {
     char *file_name = argv[optind];
 
     // Fill the palette with the background color if one was given.
-    Color *palette = malloc(palette_size * sizeof(Color));
+    Palette palette = {
+        .data = malloc(palette_size * sizeof(Color)),
+        .size = 1,
+        .capacity = palette_size,
+    };
     for (size_t i = 0; i < palette_size; ++i) {
-        palette[i] = background_color;
+        palette.data[i] = background_color;
     }
 
-    int x;
-    int y;
-    int n;
-    unsigned char *data;
+    Image img = {0};
 
     // Open the given file.
-    data = stbi_load(file_name, &x, &y, &n, 0);
-    if (data == NULL) {
+    img.data = stbi_load(file_name, &img.width, &img.height, &img.n_channels, 0);
+    if (img.data == NULL) {
         fprintf(stderr, "Error: can't open the given file.\n");
         return EXIT_FAILURE;
     }
 
     // TODO: Implement support for different file inputs.
-    if (n != 3) {
+    if (img.n_channels != 3) {
         fprintf(stderr, "File format not supported. Only 3 channel files for now.\n");
         return EXIT_FAILURE;
     }
 
-    int n_tiles_x = x / TILE_SIZE;
-    int n_tiles_y = y / TILE_SIZE;
+    int n_tiles_x = img.width / TILE_SIZE;
+    int n_tiles_y = img.height / TILE_SIZE;
     int n_tiles = n_tiles_x * n_tiles_y;
 
-    // Allocate memory for the tiles in this file.
-    Tile *tiles = malloc(n_tiles * sizeof(Tile));
+    // Allocate memory for the tiles in this file, with zero-initialization.
+    Tiles tiles = {
+        .data = calloc(n_tiles, sizeof(Tile)),
+        .size = 0,
+        .capacity = n_tiles,
+    };
 
     // NOTE: We are going to brute-force this for now. Checking if the color is
     // in the palette and add it to the next slot if possible. In the future we
     // may want to use a hash-table instead.
     int pal_idx = 1;
-    int tile_offset_x = 0;
-    int tile_offset_y = 0;
+    int offset_x = 0;
+    int offset_y = 0;
     for (size_t k = 0; k < n_tiles; ++k) {
-        for (size_t j = 0; j < TILE_SIZE; ++j) {
-            u32 col_index = 0x00000000;
-            for (size_t i = 0; i < TILE_SIZE; ++i) {
-                // Find the memory index for this pixel.
-                int idx = (i + tile_offset_x) + (j + tile_offset_y) * x;
-                idx *= n;
-
-                int red = data[idx];
-                int green = data[idx + 1];
-                int blue = data[idx + 2];
-
-                // Quantize to 5 bits per channel.
-                red = (red * 31 / 255);
-                green = (green * 31 / 255);
-                blue = (blue * 31 / 255);
-
-                Color clr = rgb15(red, green, blue);
-                bool found = false;
-                // TODO: If the palette is full, find the closest perceived
-                // color instead.
-                for (size_t p = 0; p < palette_size; ++p) {
-                    if (clr == palette[p]) {
-                        col_index |= (p & 0xF) << ((i) * 4) ;
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    col_index |= pal_idx << (i) * 4; // TODO: FlipH?
-                    palette[pal_idx++] = clr;
-                }
-            }
-            tiles[k][j] = col_index;
-        }
-        tile_offset_x += TILE_SIZE;
-        if (tile_offset_x >= x) {
-            tile_offset_x = 0;
-            tile_offset_y += TILE_SIZE;
+        extract_tile(&tiles, &palette, &img, offset_x, offset_y);
+        offset_x += TILE_SIZE;
+        if (offset_x >= img.width) {
+            offset_x = 0;
+            offset_y += TILE_SIZE;
         }
     }
 
-    export_c_file(tiles, palette, n_tiles, palette_size);
-    stbi_image_free(data);
+    export_c_file(&tiles, &palette);
+
+    // TODO: Cleanup other resources.
+    stbi_image_free(img.data);
     return EXIT_SUCCESS;
 }