Add various fixes and improve code

3 files changed, 36 insertions, 45 deletions

diff --git a/lisiblepng/src/lisiblepng.c b/lisiblepng/src/lisiblepng.c
index 5fecb52..92edc3d 100644
--- a/lisiblepng/src/lisiblepng.c
+++ b/lisiblepng/src/lisiblepng.c
@@ -89,7 +89,7 @@ uint8_t ColourType_sample_count(const ColourType colour_type) {
 }
 
 struct Png {
-  char *data;
+  uint8_t *data;
   size_t width;
   size_t height;
   ColourType colour_type;
@@ -358,8 +358,8 @@ static const ReconstructionFn reconstruction_functions[] = {
     paeth_reconstruction_function};
 
 void apply_reconstruction_functions_to_scanline(
-    char *output_scanline, const char *input_scanline,
-    const char *previous_output_scanline, size_t filter_type,
+    uint8_t *output_scanline, const uint8_t *input_scanline,
+    const uint8_t *previous_output_scanline, size_t filter_type,
     size_t scanline_size, size_t bytes_per_pixel) {
   ASSERT(output_scanline != NULL);
   ASSERT(input_scanline != NULL);
@@ -367,31 +367,31 @@ void apply_reconstruction_functions_to_scanline(
          sizeof(reconstruction_functions) / sizeof(ReconstructionFn));
 
   for (size_t i = 0; i < scanline_size / bytes_per_pixel; i++) {
-    for (size_t p = 0; p < bytes_per_pixel; p++) {
+    for (size_t byte = 0; byte < bytes_per_pixel; byte++) {
+      size_t pixel_base = i * bytes_per_pixel;
       uint8_t a = 0;
       if (i > 0) {
-        a = output_scanline[i * bytes_per_pixel - bytes_per_pixel + p];
+        a = output_scanline[pixel_base - bytes_per_pixel + byte];
       }
 
       uint8_t b = 0;
       uint8_t c = 0;
       if (previous_output_scanline != NULL) {
-        b = previous_output_scanline[i * bytes_per_pixel + p];
+        b = previous_output_scanline[pixel_base + byte];
         if (i > 0) {
-          c = previous_output_scanline[i * bytes_per_pixel - bytes_per_pixel +
-                                       p];
+          c = previous_output_scanline[pixel_base - bytes_per_pixel + byte];
         }
       }
 
-      uint8_t x = input_scanline[i * bytes_per_pixel + p];
-      output_scanline[i * bytes_per_pixel + p] =
+      uint8_t x = input_scanline[pixel_base + byte];
+      output_scanline[pixel_base + byte] =
           reconstruction_functions[filter_type](a, b, c, x);
     }
   }
 }
 
 void apply_reconstruction_functions(Png *image,
-                                    const char *decompressed_data_buffer) {
+                                    const uint8_t *decompressed_data_buffer) {
   ASSERT(image != NULL);
   ASSERT(decompressed_data_buffer != NULL);
   size_t sample_count = ColourType_sample_count(image->colour_type);
@@ -406,7 +406,7 @@ void apply_reconstruction_functions(Png *image,
     size_t output_scanline_start = scanline_size * scanline;
     size_t input_scanline_start = (scanline_size + 1) * scanline;
     uint8_t filter_type = decompressed_data_buffer[input_scanline_start];
-    const char *previous_output_scanline = NULL;
+    const uint8_t *previous_output_scanline = NULL;
     if (scanline > 0) {
       size_t previous_output_scanline_start = scanline_size * (scanline - 1);
       previous_output_scanline = &image->data[previous_output_scanline_start];
@@ -494,7 +494,7 @@ Png *lis_Png_decode(FILE *stream) {
   png->colour_type = header.colour_type;
   png->bits_per_sample = header.bit_depth;
   size_t output_length;
-  char *output_buffer =
+  uint8_t *output_buffer =
       zlib_decompress(image_data.data, image_data.length, &output_length);
   png->data = output_buffer;
 
@@ -528,42 +528,33 @@ void lis_Png_dump_ppm(const Png *png) {
   }
   for (size_t pixel_index = 0; pixel_index < png->height * png->width;
        pixel_index++) {
-
+    size_t pixel_base = pixel_index * bytes_per_pixel;
     if (png->colour_type == ColourType_Greyscale) {
       if (bits_per_pixel == 16) {
-        uint8_t hi = png->data[pixel_index * bytes_per_pixel];
-        uint8_t lo = png->data[pixel_index * bytes_per_pixel + 1];
-        uint16_t grey = ((hi & 0xFFu) << 8) | (lo & 0xFFu);
+        uint16_t grey =
+            (png->data[pixel_base] << 8) | png->data[pixel_base + 1];
         printf("%u %u %u\n", grey, grey, grey);
       } else {
         size_t absolute_bit_offset = pixel_index * bits_per_pixel;
         size_t byte_offset = absolute_bit_offset / 8;
         size_t relative_bit_offset = absolute_bit_offset % 8;
-        unsigned char grey =
-            (png->data[byte_offset] >>
-             (7 - relative_bit_offset - (bits_per_pixel - 1))) &
-            ((1 << bits_per_pixel) - 1);
+        uint8_t grey = (png->data[byte_offset] >>
+                        (7 - relative_bit_offset - (bits_per_pixel - 1))) &
+                       ((1 << bits_per_pixel) - 1);
         printf("%u %u %u\n", grey, grey, grey);
       }
     } else if (png->colour_type == ColourType_Truecolour) {
       if (png->bits_per_sample == 16) {
-        uint8_t hi_r = png->data[pixel_index * bytes_per_pixel];
-        uint8_t lo_r = png->data[pixel_index * bytes_per_pixel + 1];
-        uint16_t r = ((hi_r & 0xFFu) << 8) | (lo_r & 0xFFu);
-
-        uint8_t hi_g = png->data[pixel_index * bytes_per_pixel + 2];
-        uint8_t lo_g = png->data[pixel_index * bytes_per_pixel + 3];
-        uint16_t g = ((hi_g & 0xFFu) << 8) | (lo_g & 0xFFu);
-
-        uint8_t hi_b = png->data[pixel_index * bytes_per_pixel + 4];
-        uint8_t lo_b = png->data[pixel_index * bytes_per_pixel + 5];
-        uint16_t b = ((hi_b & 0xFFu) << 8) | (lo_b & 0xFFu);
-
+        uint16_t r = (png->data[pixel_base] << 8) | png->data[pixel_base + 1];
+        uint16_t g =
+            (png->data[pixel_base + 2] << 8) | png->data[pixel_base + 3];
+        uint16_t b =
+            (png->data[pixel_base + 4] << 8) | png->data[pixel_base + 5];
         printf("%u %u %u\n", r, g, b);
       } else {
-        uint8_t r = png->data[pixel_index * bytes_per_pixel];
-        uint8_t g = png->data[pixel_index * bytes_per_pixel + 1];
-        uint8_t b = png->data[pixel_index * bytes_per_pixel + 2];
+        uint8_t r = png->data[pixel_base];
+        uint8_t g = png->data[pixel_base + 1];
+        uint8_t b = png->data[pixel_base + 2];
         printf("%u %u %u\n", r, g, b);
       }
     } else {
diff --git a/lisiblepng/src/lisiblepng/deflate.c b/lisiblepng/src/lisiblepng/deflate.c
index 50f90e3..5b33b1d 100644
--- a/lisiblepng/src/lisiblepng/deflate.c
+++ b/lisiblepng/src/lisiblepng/deflate.c
@@ -43,7 +43,7 @@ typedef struct {
 #define DEFLATE_OUTPUT_BUFFER_INITIAL_CAPACITY (1024 * 256)
 
 typedef struct {
-  char *buffer;
+  uint8_t *buffer;
   size_t len;
   size_t cap;
 } OutputBuffer;
@@ -236,7 +236,7 @@ bool deflate_decompress(Bitstream *bitstream, OutputBuffer *output) {
       abort();
     } else {
       if (b_type == DeflateBlockType_FixedHuffman) {
-        LPNG_LOG_ERR0("Static huffman table");
+        LPNG_LOG_DBG0("Static huffman table");
         static bool are_tables_blank = true;
         static LengthLiteralTable length_literal_table = {0};
         static DistanceTable distance_table = {0};
@@ -244,7 +244,7 @@ bool deflate_decompress(Bitstream *bitstream, OutputBuffer *output) {
         uint16_t lenlit_codelengths[FIXED_LENGTH_LITERAL_CODE_COUNT];
 
         if (are_tables_blank) {
-          LPNG_LOG_ERR0("Computing static huffman table");
+          LPNG_LOG_DBG0("Computing static huffman table");
           for (int symbol = 0; symbol < 144; symbol++) {
             lenlit_codelengths[symbol] = 8;
           }
@@ -339,9 +339,9 @@ bool deflate_decompress(Bitstream *bitstream, OutputBuffer *output) {
   return true;
 }
 
-char *zlib_decompress(const uint8_t *compressed_data_buffer,
-                      const size_t compressed_data_length,
-                      size_t *output_length) {
+uint8_t *zlib_decompress(const uint8_t *compressed_data_buffer,
+                         const size_t compressed_data_length,
+                         size_t *output_length) {
   ASSERT(compressed_data_buffer != NULL);
 
   Bitstream bitstream;
diff --git a/lisiblepng/src/lisiblepng/deflate.h b/lisiblepng/src/lisiblepng/deflate.h
index 88a3711..3b707ab 100644
--- a/lisiblepng/src/lisiblepng/deflate.h
+++ b/lisiblepng/src/lisiblepng/deflate.h
@@ -12,8 +12,8 @@
 /// @param output_length The pointer to write the output length to
 /// @return A pointer to the decompressed data, the caller is responsible to
 /// deallocate it using free(). In case of error, NULL is returned.
-char *zlib_decompress(const uint8_t *compressed_data_buffer,
-                      const size_t compressed_data_length,
-                      size_t *output_length);
+uint8_t *zlib_decompress(const uint8_t *compressed_data_buffer,
+                         const size_t compressed_data_length,
+                         size_t *output_length);
 
 #endif // LISIBLE_PNG_DEFLATE_H