print sizes human friendly (comma-delimited)

sizes: allow consumation of leading spaces

If the result is too big (like 300 MB in case of 10k*10k RGB) do not
(needlesly) insist on 10 characters.

Author: MartinPulec

src/gpujpeg_common.c

@@ -2170,4 +2170,44 @@ coder_process_stats_overall(struct gpujpeg_coder* coder) {
     printf("\n");
 }
 
+char*
+format_number_with_delim(size_t num, char* buf, size_t buflen)
+{
+    assert(buflen >= 1);
+    buf[buflen - 1] = '\0';
+    char* ptr = buf + buflen - 1;
+    while ( 1 ) {
+        int tmp = num % 1000;
+        num /= 1000;
+        if ( num == 0 ) {
+            ptr -= 1;
+            if ( tmp >= 10 ) {
+                ptr -= 1;
+                if ( tmp >= 100 ) {
+                    ptr -= 1;
+                }
+            }
+            if ( ptr < buf ) {
+                snprintf(buf, buflen, "%s", "ERR");
+                return buf;
+            }
+            char numbuf[4];
+            snprintf(numbuf, sizeof numbuf, "%i", tmp);
+            // NOLINTNEXTLINE(bugprone-not-null-terminated-result): preending, no '\0' (already terminated)
+            memcpy(ptr, numbuf, strlen(numbuf));
+            return ptr;
+        }
+        ptr -= 4;
+        if ( ptr < buf ) {
+            snprintf(buf, buflen, "%s", "ERR");
+            return buf;
+        }
+        char numbuf[5];
+        snprintf(numbuf, sizeof numbuf, ",%03d", tmp);
+        // NOLINTNEXTLINE(bugprone-not-null-terminated-result): preending, no '\0' (already terminated)
+        memcpy(ptr, numbuf, 4);
+    }
+    return ptr;
+}
+
 /* vi: set expandtab sw=4 : */

src/gpujpeg_decoder.c

@@ -447,7 +447,9 @@ gpujpeg_decoder_decode(struct gpujpeg_decoder* decoder, uint8_t* image, size_t i
 
     coder_process_stats(coder);
     if ( coder->param.verbose >= GPUJPEG_LL_STATUS ) {
-        printf("Decompressed Size:   %10.zu bytes %dx%d %s %s\n", output->data_size, output->param_image.width,
+        char buf[21];
+        char* comp_size_delim = format_number_with_delim(output->data_size, buf, sizeof buf);
+        printf("Decompressed Size:   %10s bytes %dx%d %s %s\n",comp_size_delim, output->param_image.width,
                output->param_image.height, gpujpeg_pixel_format_get_name(output->param_image.pixel_format),
                gpujpeg_color_space_get_name(output->param_image.color_space));
     }

src/gpujpeg_encoder.c

@@ -628,7 +628,9 @@ gpujpeg_encoder_encode(struct gpujpeg_encoder* encoder, const struct gpujpeg_par
     if (coder->param.verbose >= GPUJPEG_LL_STATUS ) {
         const char* interleaved =
             coder->param.comp_count == 1 ? "" : (coder->param.interleaved ? " interleaved" : " non-interleaved");
-        printf("Compressed Size:     %10.zu bytes %dx%d %s %s%s\n", *image_compressed_size, coder->param_image.width,
+        char buf[21];
+        char* comp_size_delim = format_number_with_delim(*image_compressed_size, buf, sizeof buf);
+        printf("Compressed Size:     %10s bytes %dx%d %s %s%s\n", comp_size_delim, coder->param_image.width,
                coder->param_image.height, gpujpeg_color_space_get_name(coder->param.color_space_internal),
                gpujpeg_subsampling_get_name(coder->param.comp_count, coder->param.sampling_factor), interleaved);
     }

src/gpujpeg_util.h

@@ -81,6 +81,18 @@ struct { int x; int y; int z; } gridDim;
     fprintf(stderr, "[GPUJPEG] [Error] Can't use OpenGL. The codec was compiled without OpenGL!\n"); \
     action; \
 
+#define ARR_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+/**
+ * formats num with thousand delimitered by a comma (,)
+ * @param buf    output buffer, must not be NULL of zero bytes long
+ * @param buflen buffer len, should be long enough to hold the result
+ * @returns pointer to buf (not necessarily the beginning) containng the represented number of "ERR"
+ *          if not enough space
+ */
+char*
+format_number_with_delim(size_t num, char* buf, size_t buflen);
+
 #ifdef __cplusplus
 }
 #endif

test/unit/run_tests.c

@@ -3,6 +3,7 @@
 #include <libgpujpeg/gpujpeg_common.h>
 #include <libgpujpeg/gpujpeg_encoder.h>
 #include "../../src/gpujpeg_common_internal.h"
+#include "../../src/gpujpeg_util.h"
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -79,10 +80,49 @@ static void encode_gpu_mem_as_cpu() {
 void
 test_gh_95();
 
+static char*
+test_format_number_with_delim() {
+        struct {
+                size_t val;
+                char exp_res[1024];
+        } test_cases[] = {
+            {0,                          "0"             },
+            {1,                          "1"             },
+            {10,                         "10"            },
+            {11,                         "11"            },
+            {100,                        "100"           },
+            {101,                        "101"           },
+            {1000,                       "1,000"         },
+            {1001,                       "1,001"         },
+            {1100,                       "1,100"         },
+            {101100,                     "101,100"       },
+            {10LLU * 1000 * 1000 * 1000, "10,000,000,000"},
+        };
+        char buf[1024];
+        for ( unsigned i = 0; i < ARR_SIZE(test_cases); i++ ) {
+            char* res = format_number_with_delim(test_cases[i].val, buf, sizeof buf);
+            ASSERT_STR_EQ(test_cases[i].exp_res, res);
+            // "tight" buffer
+            res = format_number_with_delim(test_cases[i].val, buf, strlen(test_cases[i].exp_res) + 1);
+            ASSERT_STR_EQ(test_cases[i].exp_res, res);
+        }
+
+        // test not enough space
+        char* res = format_number_with_delim(1000000, buf, 4);
+        ASSERT_STR_EQ(res, "ERR");
+        res = format_number_with_delim(1000000, buf, 2);
+        ASSERT_STR_EQ(res, "E");
+        res = format_number_with_delim(1000000, buf, 1);
+        ASSERT_STR_EQ(res, "");
+
+        printf("Ok\n");
+}
+
 int main() {
         subsampling_name_test();
         encode_gpu_mem_as_cpu();
         test_gh_95();
+        test_format_number_with_delim();
         printf("PASSED\n");
 }