handle RGBA in windows

Author: TGS963

src/main.cpp

@@ -359,6 +359,48 @@ void *load(void *args)
                     // not webp, try jpg png etc.
 #if _WIN32
                     pixeldata = wic_decode_image(imagepath.c_str(), &w, &h, &c);
+                    if (pixeldata)
+                    {
+                        // WIC channel conversion logic similar to stb_image
+                        if (c == 1)
+                        {
+                            // grayscale -> rgb
+                            unsigned char *rgbdata = (unsigned char *)malloc(w * h * 3);
+                            if (rgbdata)
+                            {
+                                for (int i = 0; i < w * h; i++)
+                                {
+                                    unsigned char gray = pixeldata[i];
+                                    rgbdata[i * 3 + 0] = gray; // B
+                                    rgbdata[i * 3 + 1] = gray; // G
+                                    rgbdata[i * 3 + 2] = gray; // R
+                                }
+                                free(pixeldata);
+                                pixeldata = rgbdata;
+                                c = 3;
+                            }
+                        }
+                        else if (c == 2)
+                        {
+                            // grayscale + alpha -> rgba
+                            unsigned char *rgbadata = (unsigned char *)malloc(w * h * 4);
+                            if (rgbadata)
+                            {
+                                for (int i = 0; i < w * h; i++)
+                                {
+                                    unsigned char gray = pixeldata[i * 2];
+                                    unsigned char alpha = pixeldata[i * 2 + 1];
+                                    rgbadata[i * 4 + 0] = gray;  // B
+                                    rgbadata[i * 4 + 1] = gray;  // G
+                                    rgbadata[i * 4 + 2] = gray;  // R
+                                    rgbadata[i * 4 + 3] = alpha; // A
+                                }
+                                free(pixeldata);
+                                pixeldata = rgbadata;
+                                c = 4;
+                            }
+                        }
+                    }
 #else  // _WIN32
                     pixeldata = stbi_load_from_memory(filedata, length, &w, &h, &c, 0);
                     if (pixeldata)
@@ -401,9 +443,9 @@ void *load(void *args)
                 path_t output_filename2 = get_file_name_without_extension(ltp->output_files[i]) + PATHSTR('.') + ext;
                 v.outpath = output_filename2;
 #if _WIN32
-                fwprintf(stderr, L"ℹ️ Info: Image %s has alpha channel!\n", imagepath.c_str());
+                fwprintf(stderr, L"ℹ️ Info: Image %s has alpha channel! Converting to RGB for JPEG output.\n", imagepath.c_str());
 #else  // _WIN32
-                fprintf(stderr, "ℹ️ Info: Image %s has alpha channel!\n", imagepath.c_str());
+                fprintf(stderr, "ℹ️ Info: Image %s has alpha channel! Converting to RGB for JPEG output.\n", imagepath.c_str());
 #endif // _WIN32
             }
 
@@ -412,9 +454,9 @@ void *load(void *args)
         else
         {
 #if _WIN32
-            fwprintf(stderr, L"🚨 Error: Couldn't read the image '%s'!\n", imagepath.c_str());
+            fwprintf(stderr, L"🚨 Error: Couldn't read the image '%s'! (channels: %d)\n", imagepath.c_str(), c);
 #else  // _WIN32
-            fprintf(stderr, "🚨 Error: Couldn't read the image '%s'!\n", imagepath.c_str());
+            fprintf(stderr, "🚨 Error: Couldn't read the image '%s'! (channels: %d)\n", imagepath.c_str(), c);
 #endif // _WIN32
         }
     }
@@ -637,6 +679,10 @@ void *save(void *args)
         else if (ext == PATHSTR("jpg") || ext == PATHSTR("JPG") || ext == PATHSTR("jpeg") || ext == PATHSTR("JPEG"))
         {
 #if _WIN32
+            if (verbose)
+            {
+                fwprintf(stderr, L"🔧 Debug: Saving JPEG with %d channels, size %dx%d\n", v.outimage.elempack, v.outimage.w, v.outimage.h);
+            }
             success = wic_encode_jpeg_image(v.outpath.c_str(), v.outimage.w, v.outimage.h, v.outimage.elempack, v.outimage.data);
 #else
             success = stbi_write_jpg(v.outpath.c_str(), v.outimage.w, v.outimage.h, v.outimage.elempack, v.outimage.data, 100 - (int)stp->compression);

src/wic_image.h

@@ -55,13 +55,35 @@ unsigned char *wic_decode_image(const wchar_t *filepath, int *w, int *h, int *c)
     if (frame->GetPixelFormat(&pixel_format))
         goto RETURN;
 
-    if (!IsEqualGUID(pixel_format, GUID_WICPixelFormat32bppBGRA))
-        pixel_format = GUID_WICPixelFormat24bppBGR;
-
+    // Enhanced alpha channel detection and handling
+    BOOL has_alpha = FALSE;
     if (global_palette_has_alpha || frame_palette_has_alpha)
-        pixel_format = GUID_WICPixelFormat32bppBGRA;
+    {
+        has_alpha = TRUE;
+    }
+    else
+    {
+        // Check if the pixel format itself has alpha
+        if (IsEqualGUID(pixel_format, GUID_WICPixelFormat32bppBGRA) ||
+            IsEqualGUID(pixel_format, GUID_WICPixelFormat32bppRGBA) ||
+            IsEqualGUID(pixel_format, GUID_WICPixelFormat32bppPBGRA) ||
+            IsEqualGUID(pixel_format, GUID_WICPixelFormat32bppPRGBA))
+        {
+            has_alpha = TRUE;
+        }
+    }
 
-    channels = IsEqualGUID(pixel_format, GUID_WICPixelFormat32bppBGRA) ? 4 : 3;
+    // Choose appropriate output format based on alpha detection
+    if (has_alpha)
+    {
+        pixel_format = GUID_WICPixelFormat32bppBGRA;
+        channels = 4;
+    }
+    else
+    {
+        pixel_format = GUID_WICPixelFormat24bppBGR;
+        channels = 3;
+    }
 
     if (converter->Initialize(frame, pixel_format, WICBitmapDitherTypeNone, 0, 0.0, WICBitmapPaletteTypeCustom))
         goto RETURN;
@@ -197,7 +219,38 @@ int wic_encode_image(const wchar_t *filepath, int w, int h, int c, void *bgrdata
 
 int wic_encode_jpeg_image(const wchar_t *filepath, int w, int h, int c, void *bgrdata)
 {
-    // assert c == 3
+    // Convert 4-channel RGBA to 3-channel RGB for JPEG
+    unsigned char *rgbdata = 0;
+    int ret = 0;
+
+    if (c == 4)
+    {
+        // Convert RGBA to RGB by removing alpha channel
+        rgbdata = (unsigned char *)malloc(w * h * 3);
+        if (!rgbdata)
+            return 0;
+
+        const unsigned char *src = (const unsigned char *)bgrdata;
+        unsigned char *dst = rgbdata;
+
+        for (int i = 0; i < w * h; i++)
+        {
+            // Copy BGR channels, skip alpha
+            dst[0] = src[0]; // B
+            dst[1] = src[1]; // G
+            dst[2] = src[2]; // R
+            src += 4;        // Skip alpha
+            dst += 3;
+        }
+
+        bgrdata = rgbdata;
+        c = 3;
+    }
+    else if (c != 3)
+    {
+        // Invalid channel count for JPEG
+        return 0;
+    }
 
     IWICImagingFactory *factory = 0;
     IWICStream *stream = 0;
@@ -207,7 +260,6 @@ int wic_encode_jpeg_image(const wchar_t *filepath, int w, int h, int c, void *bg
     WICPixelFormatGUID format = GUID_WICPixelFormat24bppBGR;
     int stride = (w * c * 8 + 7) / 8;
     unsigned char *data = 0;
-    int ret = 0;
 
     PROPBAG2 option = {0};
     option.pstrName = L"ImageQuality";
@@ -274,6 +326,8 @@ int wic_encode_jpeg_image(const wchar_t *filepath, int w, int h, int c, void *bg
 RETURN:
     if (data)
         free(data);
+    if (rgbdata)
+        free(rgbdata);
     if (encoder)
         encoder->Release();
     if (frame)