Fix compiler warnings

cary-ilm · cary-ilm · commit 6b2f2e8f2f64 · 2025-08-30T07:23:16.000-07:00
* static_cast for signed/unsigned integer comparisons
* remove unused variables
* fix order of member initialization
* use override instead of virtual
* printf %d -&gt; %ld
* clang pragmas

Signed-off-by: Cary Phillips &lt;cary@ilm.com&gt;
diff --git a/src/bin/exrmetrics/exrmetrics.cpp b/src/bin/exrmetrics/exrmetrics.cpp
@@ -1001,7 +1001,7 @@ exrmetrics (
 
     bool compressionSet = false;
 
-    for (int p = 0; p < outHeaders.size(); ++p)
+    for (size_t p = 0; p < outHeaders.size(); ++p)
     {
         if (compression < NUM_COMPRESSION_METHODS)
         {
diff --git a/src/lib/OpenEXR/ImfBytesAttribute.cpp b/src/lib/OpenEXR/ImfBytesAttribute.cpp
@@ -28,7 +28,7 @@ BytesAttribute::BytesAttribute (
     size_t      size,
     const void* data,
     const std::string& typeHint)
-    : _data (size), typeHint (typeHint)
+    : typeHint (typeHint), _data (size) 
 {
     if (size > 0 && ! data)
     {
@@ -41,7 +41,7 @@ BytesAttribute::BytesAttribute (
 }
 
 BytesAttribute::BytesAttribute (const BytesAttribute& other)
-    : _data (other._data.size ()), typeHint (other.typeHint)
+    : typeHint (other.typeHint), _data (other._data.size ())
 {
     memcpy (
         (unsigned char*) _data,
@@ -115,7 +115,7 @@ BytesAttribute::readValueFrom (
     unsigned int hintLength = 0;
     Xdr::read<StreamIO> (is, hintLength);
 
-    if (size < sizeof(hintLength) + hintLength)
+    if (size < static_cast<int>(sizeof(hintLength) + hintLength))
         THROW (IEX_NAMESPACE::InputExc,
                "Invalid bytes attribute type string length: " << hintLength);
 
diff --git a/src/lib/OpenEXR/ImfBytesAttribute.h b/src/lib/OpenEXR/ImfBytesAttribute.h
@@ -60,19 +60,19 @@ class IMF_EXPORT_TYPE BytesAttribute : public Attribute
     // Make a copy of this attribute
     //------------------------------
 
-    IMF_EXPORT virtual Attribute* copy () const;
+    IMF_EXPORT Attribute* copy () const override;
 
     //----------------
     // I/O and copying
     //----------------
 
-    IMF_EXPORT virtual void writeValueTo (
-        OPENEXR_IMF_INTERNAL_NAMESPACE::OStream& os, int version) const;
+    IMF_EXPORT void writeValueTo (
+        OPENEXR_IMF_INTERNAL_NAMESPACE::OStream& os, int version) const override;
 
-    IMF_EXPORT virtual void readValueFrom (
-        OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is, int size, int version);
+    IMF_EXPORT void readValueFrom (
+        OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is, int size, int version) override;
 
-    IMF_EXPORT virtual void copyValueFrom (const Attribute& other);
+    IMF_EXPORT void copyValueFrom (const Attribute& other) override;
 
     size_t size () const { return _data.size (); }
     const Array<unsigned char>& data () const { return _data; }
diff --git a/src/lib/OpenEXRCore/internal_ht.cpp b/src/lib/OpenEXRCore/internal_ht.cpp
@@ -174,7 +174,7 @@ ht_undo_impl (
     size_t header_sz;
     header_sz = read_header (
         (uint8_t*) compressed_data, comp_buf_size, cs_to_file_ch);
-    if (decode->channel_count != cs_to_file_ch.size ())
+    if (static_cast<std::size_t>(decode->channel_count) != cs_to_file_ch.size ())
         throw std::runtime_error ("Unexpected number of channels");
 
     for (int cs_i = 0; cs_i < decode->channel_count; cs_i++)
@@ -199,16 +199,13 @@ ht_undo_impl (
     cs.read_headers (&infile);
 
     ojph::param_siz siz = cs.access_siz ();
-    ojph::param_nlt nlt = cs.access_nlt ();
 
-    ojph::ui32 image_width =
-        siz.get_image_extent ().x - siz.get_image_offset ().x;
     ojph::ui32 image_height =
         siz.get_image_extent ().y - siz.get_image_offset ().y;
 
     int  bpl       = 0;
     bool is_planar = false;
-    for (ojph::ui32 c = 0; c < decode->channel_count; c++)
+    for (ojph::ui32 c = 0; c < static_cast<ojph::ui32>(decode->channel_count); c++)
     {
         bpl +=
             decode->channels[c].bytes_per_element * decode->channels[c].width;
@@ -218,7 +215,7 @@ ht_undo_impl (
     }
     cs.set_planar (is_planar);
 
-    assert (decode->chunk.width == image_width);
+    assert (decode->chunk.width == siz.get_image_extent ().x - siz.get_image_offset ().x);
     assert (decode->chunk.height == image_height);
     assert (decode->channel_count == siz.get_num_components ());
 
@@ -230,7 +227,7 @@ ht_undo_impl (
     ojph::line_buf* cur_line;
     if (cs.is_planar ())
     {
-        for (uint32_t c = 0; c < decode->channel_count; c++)
+        for (uint32_t c = 0; c < static_cast<uint32_t>(decode->channel_count); c++)
         {
             int file_c = cs_to_file_ch[c].file_index;
             assert (
@@ -245,12 +242,12 @@ ht_undo_impl (
                  y < image_height + decode->chunk.start_y;
                  y++)
             {
-                for (ojph::ui32 line_c = 0; line_c < decode->channel_count;
+                for (ojph::ui32 line_c = 0; line_c < static_cast<ojph::ui32>(decode->channel_count);
                      line_c++)
                 {
                     if (y % decode->channels[line_c].y_samples != 0) continue;
 
-                    if (line_c == file_c)
+                    if (line_c == static_cast<ojph::ui32>(file_c))
                     {
                         cur_line = cs.pull (next_comp);
                         assert (next_comp == c);
@@ -260,7 +257,7 @@ ht_undo_impl (
                         {
                             int16_t* channel_pixels = (int16_t*) line_pixels;
                             for (uint32_t p = 0;
-                                 p < decode->channels[file_c].width;
+                                 p < static_cast<uint32_t>(decode->channels[file_c].width);
                                  p++)
                             {
                                 *channel_pixels++ = cur_line->i32[p];
@@ -270,7 +267,7 @@ ht_undo_impl (
                         {
                             int32_t* channel_pixels = (int32_t*) line_pixels;
                             for (uint32_t p = 0;
-                                 p < decode->channels[file_c].width;
+                                 p < static_cast<uint32_t>(decode->channels[file_c].width);
                                  p++)
                             {
                                 *channel_pixels++ = cur_line->i32[p];
@@ -292,7 +289,7 @@ ht_undo_impl (
 
         for (uint32_t y = 0; y < image_height; ++y)
         {
-            for (uint32_t c = 0; c < decode->channel_count; c++)
+            for (uint32_t c = 0; c < static_cast<uint32_t>(decode->channel_count); c++)
             {
                 int file_c = cs_to_file_ch[c].file_index;
                 cur_line   = cs.pull (next_comp);
@@ -301,7 +298,7 @@ ht_undo_impl (
                 {
                     int16_t* channel_pixels =
                         (int16_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);
-                    for (uint32_t p = 0; p < decode->channels[file_c].width;
+                    for (uint32_t p = 0; p < static_cast<uint32_t>(decode->channels[file_c].width);
                          p++)
                     {
                         *channel_pixels++ = cur_line->i32[p];
@@ -311,7 +308,7 @@ ht_undo_impl (
                 {
                     int32_t* channel_pixels =
                         (int32_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);
-                    for (uint32_t p = 0; p < decode->channels[file_c].width;
+                    for (uint32_t p = 0; p < static_cast<uint32_t>(decode->channels[file_c].width);
                          p++)
                     {
                         *channel_pixels++ = cur_line->i32[p];
@@ -371,7 +368,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
     bool isPlanar = false;
     siz.set_num_components (encode->channel_count);
     int bpl = 0;
-    for (ojph::ui32 c = 0; c < encode->channel_count; c++)
+    for (ojph::ui32 c = 0; c < static_cast<ojph::ui32>(encode->channel_count); c++)
     {
         int file_c = cs_to_file_ch[c].file_index;
         if (encode->channels[file_c].data_type != EXR_PIXEL_UINT)
@@ -425,7 +422,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
 
         if (cs.is_planar ())
         {
-            for (ojph::ui32 c = 0; c < encode->channel_count; c++)
+            for (ojph::ui32 c = 0; c < static_cast<ojph::ui32>(encode->channel_count); c++)
             {
                 if (encode->channels[c].height == 0) continue;
 
@@ -437,20 +434,20 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
                     y < image_height + encode->chunk.start_y;
                     y++)
                 {
-                    for (ojph::ui32 line_c = 0; line_c < encode->channel_count;
+                    for (ojph::ui32 line_c = 0; line_c < static_cast<ojph::ui32>(encode->channel_count);
                         line_c++)
                     {
 
                         if (y % encode->channels[line_c].y_samples != 0) continue;
 
-                        if (line_c == file_c)
+                        if (line_c == static_cast<ojph::ui32>(file_c))
                         {
                             if (encode->channels[file_c].data_type ==
                                 EXR_PIXEL_HALF)
                             {
                                 int16_t* channel_pixels = (int16_t*) (line_pixels);
                                 for (uint32_t p = 0;
-                                    p < encode->channels[file_c].width;
+                                     p < static_cast<ojph::ui32>(encode->channels[file_c].width);
                                     p++)
                                 {
                                     cur_line->i32[p] = *channel_pixels++;
@@ -460,7 +457,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
                             {
                                 int32_t* channel_pixels = (int32_t*) (line_pixels);
                                 for (uint32_t p = 0;
-                                    p < encode->channels[file_c].width;
+                                     p < static_cast<ojph::ui32>(encode->channels[file_c].width);
                                     p++)
                                 {
                                     cur_line->i32[p] = *channel_pixels++;
@@ -486,15 +483,15 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
 
             for (int y = 0; y < image_height; y++)
             {
-                for (ojph::ui32 c = 0; c < encode->channel_count; c++)
+                for (ojph::ui32 c = 0; c < static_cast<ojph::ui32>(encode->channel_count); c++)
                 {
                     int file_c = cs_to_file_ch[c].file_index;
 
                     if (encode->channels[file_c].data_type == EXR_PIXEL_HALF)
                     {
                         int16_t* channel_pixels =
                             (int16_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);
-                        for (uint32_t p = 0; p < encode->channels[file_c].width;
+                        for (uint32_t p = 0; p < static_cast<uint32_t>(encode->channels[file_c].width);
                             p++)
                         {
                             cur_line->i32[p] = *channel_pixels++;
@@ -504,7 +501,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)
                     {
                         int32_t* channel_pixels =
                             (int32_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);
-                        for (uint32_t p = 0; p < encode->channels[file_c].width;
+                        for (uint32_t p = 0; p < static_cast<uint32_t>(encode->channels[file_c].width);
                             p++)
                         {
                             cur_line->i32[p] = *channel_pixels++;
diff --git a/src/lib/OpenEXRCore/internal_ht_common.cpp b/src/lib/OpenEXRCore/internal_ht_common.cpp
@@ -12,10 +12,6 @@
 #include <cctype>
 #include <stdexcept>
 
-const std::string RED_CH_FULLNAME = "red";
-const std::string GREEN_CH_FULLNAME = "green";
-const std::string BLUE_CH_FULLNAME = "blue";
-
 struct RGBChannelParams
 {
     const char* r_suffix;
@@ -63,7 +59,7 @@ make_channel_map (
 
     cs_to_file_ch.resize (channel_count);
 
-    for (size_t i = 0; i < channel_count; i++)
+    for (size_t i = 0; i < static_cast<size_t>(channel_count); i++)
     {
         const char* channel_name = channels[i].channel_name;
         const char* suffix       = strrchr (channel_name, '.');
@@ -147,14 +143,14 @@ make_channel_map (
 
         int avail_cs_i = 3;
         int offset = 0;
-        for (size_t file_i = 0; file_i < channel_count; file_i++)
+        for (size_t file_i = 0; file_i < static_cast<size_t>(channel_count); file_i++)
         {
             int cs_i;
-            if (file_i == r_index) {
+            if (static_cast<int>(file_i) == r_index) {
                 cs_i = 0;
-            } else if (file_i == g_index) {
+            } else if (static_cast<int>(file_i) == g_index) {
                 cs_i = 1;
-            } else if (file_i == b_index) {
+            } else if (static_cast<int>(file_i) == b_index) {
                 cs_i = 2;
             } else {
                 cs_i = avail_cs_i++;
@@ -168,7 +164,7 @@ make_channel_map (
     else
     {
         int offset = 0;
-        for (size_t file_i = 0; file_i < channel_count; file_i++)
+        for (size_t file_i = 0; file_i < static_cast<size_t>(channel_count); file_i++)
         {
             cs_to_file_ch[file_i].file_index = file_i;
             cs_to_file_ch[file_i].raster_line_offset = offset;
diff --git a/src/lib/OpenEXRCore/internal_huf.c b/src/lib/OpenEXRCore/internal_huf.c
@@ -1722,7 +1722,7 @@ fasthuf_decode (
         // 8 bits of data in the buffer
         //
 
-        if (symbol == rleSym)
+        if (symbol == (int) rleSym)
         {
             uint32_t rleCount;
 
diff --git a/src/lib/OpenEXRCore/parse_header.c b/src/lib/OpenEXRCore/parse_header.c
@@ -773,7 +773,7 @@ extract_attr_bytes(
         return ctxt->print_error (
             ctxt,
             EXR_ERR_ATTR_SIZE_MISMATCH,
-            "Attribute '%s': Invalid size %d (exp '%s' size >= %d)",
+            "Attribute '%s': Invalid size %d (exp '%s' size >= %ld)",
             aname,
             attrsz,
             tname,
diff --git a/src/lib/OpenEXRCore/string.c b/src/lib/OpenEXRCore/string.c
@@ -125,6 +125,8 @@ exr_attr_string_create_with_length (
 #ifdef _MSC_VER
 #    pragma warning(push)
 #    pragma warning(disable : 4996)
+#elif defined(__clang__)
+// clang: do nothing
 #elif defined(__GNUC__)
 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wstringop-truncation"
@@ -135,6 +137,8 @@ exr_attr_string_create_with_length (
                 memset (outs, 0, (size_t) len);
 #ifdef _MSC_VER
 #    pragma warning(pop)
+#elif defined(__clang__)
+// clang: do nothing
 #elif defined(__GNUC__)
 #    pragma GCC diagnostic pop
 #endif
@@ -199,6 +203,8 @@ exr_attr_string_set_with_length (
 #ifdef _MSC_VER
 #    pragma warning(push)
 #    pragma warning(disable : 4996)
+#elif defined(__clang__)
+// clang: do nothing
 #elif defined(__GNUC__)
 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wstringop-truncation"
@@ -209,6 +215,8 @@ exr_attr_string_set_with_length (
                 memset (sstr, 0, (size_t) len);
 #ifdef _MSC_VER
 #    pragma warning(pop)
+#elif defined(__clang__)
+// clang: do nothing
 #elif defined(__GNUC__)
 #    pragma GCC diagnostic pop
 #endif
diff --git a/src/test/OpenEXRCoreTest/compression.cpp b/src/test/OpenEXRCoreTest/compression.cpp
@@ -1722,7 +1722,7 @@ testHTChannelMap (const std::string& tempdir)
     };
     int test_count = sizeof(tests) / sizeof(ht_channel_map_tests);
 
-    for (size_t i = 0; i < test_count; i++)
+    for (size_t i = 0; i < static_cast<size_t>(test_count); i++)
     {
         EXRCORE_TEST (
             make_channel_map (

Original file line number	Diff line number	Diff line change
`@@ -1001,7 +1001,7 @@ exrmetrics (`
`1001`	`1001`
`1002`	`1002`	`bool compressionSet = false;`
`1003`	`1003`
`1004`		`- for (int p = 0; p < outHeaders.size(); ++p)`
	`1004`	`+ for (size_t p = 0; p < outHeaders.size(); ++p)`
`1005`	`1005`	`{`
`1006`	`1006`	`if (compression < NUM_COMPRESSION_METHODS)`
`1007`	`1007`	`{`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ BytesAttribute::BytesAttribute (`
`28`	`28`	`size_t size,`
`29`	`29`	`const void* data,`
`30`	`30`	`const std::string& typeHint)`
`31`		`- : _data (size), typeHint (typeHint)`
	`31`	`+ : typeHint (typeHint), _data (size)`
`32`	`32`	`{`
`33`	`33`	`if (size > 0 && ! data)`
`34`	`34`	`{`
`@@ -41,7 +41,7 @@ BytesAttribute::BytesAttribute (`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`BytesAttribute::BytesAttribute (const BytesAttribute& other)`
`44`		`- : _data (other._data.size ()), typeHint (other.typeHint)`
	`44`	`+ : typeHint (other.typeHint), _data (other._data.size ())`
`45`	`45`	`{`
`46`	`46`	`memcpy (`
`47`	`47`	`(unsigned char*) _data,`
`@@ -115,7 +115,7 @@ BytesAttribute::readValueFrom (`
`115`	`115`	`unsigned int hintLength = 0;`
`116`	`116`	`Xdr::read<StreamIO> (is, hintLength);`
`117`	`117`
`118`		`- if (size < sizeof(hintLength) + hintLength)`
	`118`	`+ if (size < static_cast<int>(sizeof(hintLength) + hintLength))`
`119`	`119`	`THROW (IEX_NAMESPACE::InputExc,`
`120`	`120`	`"Invalid bytes attribute type string length: " << hintLength);`
`121`	`121`
Original file line number	Diff line number	Diff line change
`@@ -174,7 +174,7 @@ ht_undo_impl (`
`174`	`174`	`size_t header_sz;`
`175`	`175`	`header_sz = read_header (`
`176`	`176`	`(uint8_t*) compressed_data, comp_buf_size, cs_to_file_ch);`
`177`		`- if (decode->channel_count != cs_to_file_ch.size ())`
	`177`	`+ if (static_cast<std::size_t>(decode->channel_count) != cs_to_file_ch.size ())`
`178`	`178`	`throw std::runtime_error ("Unexpected number of channels");`
`179`	`179`
`180`	`180`	`for (int cs_i = 0; cs_i < decode->channel_count; cs_i++)`
`@@ -199,16 +199,13 @@ ht_undo_impl (`
`199`	`199`	`cs.read_headers (&infile);`
`200`	`200`
`201`	`201`	`ojph::param_siz siz = cs.access_siz ();`
`202`		`- ojph::param_nlt nlt = cs.access_nlt ();`
`203`	`202`
`204`		`- ojph::ui32 image_width =`
`205`		`- siz.get_image_extent ().x - siz.get_image_offset ().x;`
`206`	`203`	`ojph::ui32 image_height =`
`207`	`204`	`siz.get_image_extent ().y - siz.get_image_offset ().y;`
`208`	`205`
`209`	`206`	`int bpl = 0;`
`210`	`207`	`bool is_planar = false;`
`211`		`- for (ojph::ui32 c = 0; c < decode->channel_count; c++)`
	`208`	`+ for (ojph::ui32 c = 0; c < static_cast<ojph::ui32>(decode->channel_count); c++)`
`212`	`209`	`{`
`213`	`210`	`bpl +=`
`214`	`211`	`decode->channels[c].bytes_per_element * decode->channels[c].width;`
`@@ -218,7 +215,7 @@ ht_undo_impl (`
`218`	`215`	`}`
`219`	`216`	`cs.set_planar (is_planar);`
`220`	`217`
`221`		`- assert (decode->chunk.width == image_width);`
	`218`	`+ assert (decode->chunk.width == siz.get_image_extent ().x - siz.get_image_offset ().x);`
`222`	`219`	`assert (decode->chunk.height == image_height);`
`223`	`220`	`assert (decode->channel_count == siz.get_num_components ());`
`224`	`221`
`@@ -230,7 +227,7 @@ ht_undo_impl (`
`230`	`227`	`ojph::line_buf* cur_line;`
`231`	`228`	`if (cs.is_planar ())`
`232`	`229`	`{`
`233`		`- for (uint32_t c = 0; c < decode->channel_count; c++)`
	`230`	`+ for (uint32_t c = 0; c < static_cast<uint32_t>(decode->channel_count); c++)`
`234`	`231`	`{`
`235`	`232`	`int file_c = cs_to_file_ch[c].file_index;`
`236`	`233`	`assert (`
`@@ -245,12 +242,12 @@ ht_undo_impl (`
`245`	`242`	`y < image_height + decode->chunk.start_y;`
`246`	`243`	`y++)`
`247`	`244`	`{`
`248`		`- for (ojph::ui32 line_c = 0; line_c < decode->channel_count;`
	`245`	`+ for (ojph::ui32 line_c = 0; line_c < static_cast<ojph::ui32>(decode->channel_count);`
`249`	`246`	`line_c++)`
`250`	`247`	`{`
`251`	`248`	`if (y % decode->channels[line_c].y_samples != 0) continue;`
`252`	`249`
`253`		`- if (line_c == file_c)`
	`250`	`+ if (line_c == static_cast<ojph::ui32>(file_c))`
`254`	`251`	`{`
`255`	`252`	`cur_line = cs.pull (next_comp);`
`256`	`253`	`assert (next_comp == c);`
`@@ -260,7 +257,7 @@ ht_undo_impl (`
`260`	`257`	`{`
`261`	`258`	`int16_t* channel_pixels = (int16_t*) line_pixels;`
`262`	`259`	`for (uint32_t p = 0;`
`263`		`- p < decode->channels[file_c].width;`
	`260`	`+ p < static_cast<uint32_t>(decode->channels[file_c].width);`
`264`	`261`	`p++)`
`265`	`262`	`{`
`266`	`263`	`*channel_pixels++ = cur_line->i32[p];`
`@@ -270,7 +267,7 @@ ht_undo_impl (`
`270`	`267`	`{`
`271`	`268`	`int32_t* channel_pixels = (int32_t*) line_pixels;`
`272`	`269`	`for (uint32_t p = 0;`
`273`		`- p < decode->channels[file_c].width;`
	`270`	`+ p < static_cast<uint32_t>(decode->channels[file_c].width);`
`274`	`271`	`p++)`
`275`	`272`	`{`
`276`	`273`	`*channel_pixels++ = cur_line->i32[p];`
`@@ -292,7 +289,7 @@ ht_undo_impl (`
`292`	`289`
`293`	`290`	`for (uint32_t y = 0; y < image_height; ++y)`
`294`	`291`	`{`
`295`		`- for (uint32_t c = 0; c < decode->channel_count; c++)`
	`292`	`+ for (uint32_t c = 0; c < static_cast<uint32_t>(decode->channel_count); c++)`
`296`	`293`	`{`
`297`	`294`	`int file_c = cs_to_file_ch[c].file_index;`
`298`	`295`	`cur_line = cs.pull (next_comp);`
`@@ -301,7 +298,7 @@ ht_undo_impl (`
`301`	`298`	`{`
`302`	`299`	`int16_t* channel_pixels =`
`303`	`300`	`(int16_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);`
`304`		`- for (uint32_t p = 0; p < decode->channels[file_c].width;`
	`301`	`+ for (uint32_t p = 0; p < static_cast<uint32_t>(decode->channels[file_c].width);`
`305`	`302`	`p++)`
`306`	`303`	`{`
`307`	`304`	`*channel_pixels++ = cur_line->i32[p];`
`@@ -311,7 +308,7 @@ ht_undo_impl (`
`311`	`308`	`{`
`312`	`309`	`int32_t* channel_pixels =`
`313`	`310`	`(int32_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);`
`314`		`- for (uint32_t p = 0; p < decode->channels[file_c].width;`
	`311`	`+ for (uint32_t p = 0; p < static_cast<uint32_t>(decode->channels[file_c].width);`
`315`	`312`	`p++)`
`316`	`313`	`{`
`317`	`314`	`*channel_pixels++ = cur_line->i32[p];`
`@@ -371,7 +368,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)`
`371`	`368`	`bool isPlanar = false;`
`372`	`369`	`siz.set_num_components (encode->channel_count);`
`373`	`370`	`int bpl = 0;`
`374`		`- for (ojph::ui32 c = 0; c < encode->channel_count; c++)`
	`371`	`+ for (ojph::ui32 c = 0; c < static_cast<ojph::ui32>(encode->channel_count); c++)`
`375`	`372`	`{`
`376`	`373`	`int file_c = cs_to_file_ch[c].file_index;`
`377`	`374`	`if (encode->channels[file_c].data_type != EXR_PIXEL_UINT)`
`@@ -425,7 +422,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)`
`425`	`422`
`426`	`423`	`if (cs.is_planar ())`
`427`	`424`	`{`
`428`		`- for (ojph::ui32 c = 0; c < encode->channel_count; c++)`
	`425`	`+ for (ojph::ui32 c = 0; c < static_cast<ojph::ui32>(encode->channel_count); c++)`
`429`	`426`	`{`
`430`	`427`	`if (encode->channels[c].height == 0) continue;`
`431`	`428`
`@@ -437,20 +434,20 @@ ht_apply_impl (exr_encode_pipeline_t* encode)`
`437`	`434`	`y < image_height + encode->chunk.start_y;`
`438`	`435`	`y++)`
`439`	`436`	`{`
`440`		`- for (ojph::ui32 line_c = 0; line_c < encode->channel_count;`
	`437`	`+ for (ojph::ui32 line_c = 0; line_c < static_cast<ojph::ui32>(encode->channel_count);`
`441`	`438`	`line_c++)`
`442`	`439`	`{`
`443`	`440`
`444`	`441`	`if (y % encode->channels[line_c].y_samples != 0) continue;`
`445`	`442`
`446`		`- if (line_c == file_c)`
	`443`	`+ if (line_c == static_cast<ojph::ui32>(file_c))`
`447`	`444`	`{`
`448`	`445`	`if (encode->channels[file_c].data_type ==`
`449`	`446`	`EXR_PIXEL_HALF)`
`450`	`447`	`{`
`451`	`448`	`int16_t* channel_pixels = (int16_t*) (line_pixels);`
`452`	`449`	`for (uint32_t p = 0;`
`453`		`- p < encode->channels[file_c].width;`
	`450`	`+ p < static_cast<ojph::ui32>(encode->channels[file_c].width);`
`454`	`451`	`p++)`
`455`	`452`	`{`
`456`	`453`	`cur_line->i32[p] = *channel_pixels++;`
`@@ -460,7 +457,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)`
`460`	`457`	`{`
`461`	`458`	`int32_t* channel_pixels = (int32_t*) (line_pixels);`
`462`	`459`	`for (uint32_t p = 0;`
`463`		`- p < encode->channels[file_c].width;`
	`460`	`+ p < static_cast<ojph::ui32>(encode->channels[file_c].width);`
`464`	`461`	`p++)`
`465`	`462`	`{`
`466`	`463`	`cur_line->i32[p] = *channel_pixels++;`
`@@ -486,15 +483,15 @@ ht_apply_impl (exr_encode_pipeline_t* encode)`
`486`	`483`
`487`	`484`	`for (int y = 0; y < image_height; y++)`
`488`	`485`	`{`
`489`		`- for (ojph::ui32 c = 0; c < encode->channel_count; c++)`
	`486`	`+ for (ojph::ui32 c = 0; c < static_cast<ojph::ui32>(encode->channel_count); c++)`
`490`	`487`	`{`
`491`	`488`	`int file_c = cs_to_file_ch[c].file_index;`
`492`	`489`
`493`	`490`	`if (encode->channels[file_c].data_type == EXR_PIXEL_HALF)`
`494`	`491`	`{`
`495`	`492`	`int16_t* channel_pixels =`
`496`	`493`	`(int16_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);`
`497`		`- for (uint32_t p = 0; p < encode->channels[file_c].width;`
	`494`	`+ for (uint32_t p = 0; p < static_cast<uint32_t>(encode->channels[file_c].width);`
`498`	`495`	`p++)`
`499`	`496`	`{`
`500`	`497`	`cur_line->i32[p] = *channel_pixels++;`
`@@ -504,7 +501,7 @@ ht_apply_impl (exr_encode_pipeline_t* encode)`
`504`	`501`	`{`
`505`	`502`	`int32_t* channel_pixels =`
`506`	`503`	`(int32_t*) (line_pixels + cs_to_file_ch[c].raster_line_offset);`
`507`		`- for (uint32_t p = 0; p < encode->channels[file_c].width;`
	`504`	`+ for (uint32_t p = 0; p < static_cast<uint32_t>(encode->channels[file_c].width);`
`508`	`505`	`p++)`
`509`	`506`	`{`
`510`	`507`	`cur_line->i32[p] = *channel_pixels++;`
Original file line number	Diff line number	Diff line change
`@@ -1722,7 +1722,7 @@ fasthuf_decode (`
`1722`	`1722`	`// 8 bits of data in the buffer`
`1723`	`1723`	`//`
`1724`	`1724`
`1725`		`- if (symbol == rleSym)`
	`1725`	`+ if (symbol == (int) rleSym)`
`1726`	`1726`	`{`
`1727`	`1727`	`uint32_t rleCount;`
`1728`	`1728`
Original file line number	Diff line number	Diff line change
`@@ -1722,7 +1722,7 @@ testHTChannelMap (const std::string& tempdir)`
`1722`	`1722`	`};`
`1723`	`1723`	`int test_count = sizeof(tests) / sizeof(ht_channel_map_tests);`
`1724`	`1724`
`1725`		`- for (size_t i = 0; i < test_count; i++)`
	`1725`	`+ for (size_t i = 0; i < static_cast<size_t>(test_count); i++)`
`1726`	`1726`	`{`
`1727`	`1727`	`EXRCORE_TEST (`
`1728`	`1728`	`make_channel_map (`