Show correct image format in the file list

Don't treat JPEG and PNG as video stream in FFmpeg frame grabber
zenden2k · Jun 12, 2023 · 05b2666 · 05b2666
1 parent 0dd09f1
commit 05b2666
Show file tree

Hide file tree

Showing 18 changed files with 174 additions and 89 deletions.
diff --git a/Dist/iu_setup_script.iss b/Dist/iu_setup_script.iss
@@ -155,8 +155,12 @@ begin
 end;
 
 procedure ShellExtBeforeInstall();
+var 
+  dest: String;
 begin
-  RenameFile(ExpandConstant(CurrentFileName), ExpandConstant(CurrentFileName) + '.' + IntToStr(Random(100000)) + '.old');
+  dest := ExpandConstant(CurrentFileName) + '.' + IntToStr(Random(100000)) + '.old';
+  RenameFile(ExpandConstant(CurrentFileName), dest);
+  DeleteFile(dest)
 end;
 
 function GetIconFileName(Param: String): String;

diff --git a/Source/Core/Images/AbstractImage.cpp b/Source/Core/Images/AbstractImage.cpp
@@ -34,4 +34,12 @@ bool AbstractImage::loadFromFile(const std::string& fileName)
 
 const std::string& AbstractImage::factoryName() {
     return factoryName_;
-}
+}
+
+void AbstractImage::setSrcFormat(const std::string& str) {
+    srcFormat_ = str;
+}
+
+std::string AbstractImage::getSrcFormat() const {
+    return srcFormat_;
+}
diff --git a/Source/Core/Images/AbstractImage.h b/Source/Core/Images/AbstractImage.h
@@ -25,7 +25,7 @@ class AbstractImage
     virtual int getHeight() const;
     virtual bool isNull() const = 0;
     virtual bool loadFromRawData(DataFormat dt, int width, int height, uint8_t* data, size_t dataSize, void* parameter) = 0;
-
+    std::string getSrcFormat() const;
     template<class T> static void registerFactory(const char* name) {
         factory_ = [] () -> AbstractImage* {
             return new T();
@@ -42,11 +42,13 @@ class AbstractImage
     }
     static const std::string& factoryName();
     static AbstractImage* createImage();
+    void setSrcFormat(const std::string& str);
 protected:
     static std::function<AbstractImage*()> factory_;
     static std::string factoryName_;
     int width_;
     int height_;
+    std::string srcFormat_;
     DISALLOW_COPY_AND_ASSIGN(AbstractImage);
 };
 

diff --git a/Source/Core/Images/GdiPlusImage.cpp b/Source/Core/Images/GdiPlusImage.cpp
@@ -27,7 +27,7 @@ void GdiPlusImage::init()
     width_ = 0;
     height_ = 0;
     takeOwnership_ = true;
-    isSrcAnimated_ = false;
+    isSrcMultiFrame_ = false;
 }
 
 GdiPlusImage::~GdiPlusImage() {
@@ -170,10 +170,10 @@ Gdiplus::Bitmap* GdiPlusImage::releaseBitmap() {
     return bm_;
 }
 
-void GdiPlusImage::setSrcAnimated(bool animated) {
-    isSrcAnimated_ = animated;
+void GdiPlusImage::setSrcMultiFrame(bool animated) {
+    isSrcMultiFrame_ = animated;
 }
 
-bool GdiPlusImage::isSrcAnimated() const {
-    return isSrcAnimated_;
-}
+bool GdiPlusImage::isSrcMultiFrame() const {
+    return isSrcMultiFrame_;
+}
diff --git a/Source/Core/Images/GdiPlusImage.h b/Source/Core/Images/GdiPlusImage.h
@@ -22,13 +22,13 @@ class GdiPlusImage: public AbstractImage
 
     int getWidth() const override;
     int getHeight() const override;
-    void setSrcAnimated(bool animated);
-    bool isSrcAnimated() const;
+    void setSrcMultiFrame(bool animated);
+    bool isSrcMultiFrame() const;
 protected:
     Gdiplus::Bitmap* bm_;
     uint8_t* data_;
     bool takeOwnership_;
-    bool isSrcAnimated_;
+    bool isSrcMultiFrame_;
     void init();
     DISALLOW_COPY_AND_ASSIGN(GdiPlusImage);
 };

diff --git a/Source/Core/Images/GdiplusImageReader.cpp b/Source/Core/Images/GdiplusImageReader.cpp
@@ -2,6 +2,7 @@
 
 #include "Utils.h"
 #include "Func/WinUtils.h"
+#include "Core/Utils/CoreUtils.h"
 
 typedef IStream * (STDAPICALLTYPE *SHCreateMemStreamFuncType)(const BYTE *pInit, UINT cbInit);
 
@@ -71,5 +72,10 @@ bool GdiplusImageReader::checkLastStatus(Gdiplus::Bitmap* bm) {
 void GdiplusImageReader::postLoad(GdiPlusImage* bm) {
     short orient = ImageUtils::GetImageOrientation(bm->getBitmap());
     ImageUtils::RotateAccordingToOrientation(orient, bm->getBitmap(), true);
-    bm->setSrcAnimated(ImageUtils::IsImageAnimated(bm->getBitmap()));
+    bm->setSrcMultiFrame(ImageUtils::IsImageMultiFrame(bm->getBitmap()));
+    GUID format;
+    if (bm->getBitmap()->GetRawFormat(&format) == Gdiplus::Ok) { 
+        bm->setSrcFormat(W2U(ImageUtils::ImageFormatGUIDToString(format)));
+    }
+
 }
diff --git a/Source/Core/Images/ImageConverterPrivate_gdiplus.cpp b/Source/Core/Images/ImageConverterPrivate_gdiplus.cpp
@@ -1,4 +1,4 @@
-#include "ImageConverterPrivate_gdiplus.h"
+#include "ImageConverterPrivate_gdiplus.h"
 
 #include <cassert>
 #include <memory>
@@ -58,7 +58,7 @@ bool ImageConverterPrivate::convert(const std::string& sourceFile)
         processingEnabled_ = false;
     }
 
-    if (m_imageConvertingParams.SkipAnimated && srcImg->isSrcAnimated()) {
+    if (m_imageConvertingParams.SkipAnimated && srcImg->isSrcMultiFrame()) {
         processingEnabled_ = false;
     }
 
@@ -603,4 +603,4 @@ void ImageConverterPrivate::calcCropSize(int srcWidth, int srcHeight, CRect targ
 
     destRect = rectDrawing;
     srcRect = CRect(0,0, srcWidth, srcHeight);
-}
+}
diff --git a/Source/Core/Images/Tests/UtilsTest.cpp b/Source/Core/Images/Tests/UtilsTest.cpp
@@ -476,12 +476,12 @@ TEST_F(UtilsTest, IsImageAnimated) {
     {
         Gdiplus::Image img(U2W(TestHelpers::resolvePath("Images/animation.gif")));
         ASSERT_EQ(Gdiplus::Ok, img.GetLastStatus());
-        EXPECT_TRUE(IsImageAnimated(&img));
+        EXPECT_TRUE(IsImageMultiFrame(&img));
     }
     {
 
         Gdiplus::Image img(U2W(TestHelpers::resolvePath("file_with_const_size.png")));
         ASSERT_EQ(Gdiplus::Ok, img.GetLastStatus());
-        EXPECT_FALSE(IsImageAnimated(&img));
+        EXPECT_FALSE(IsImageMultiFrame(&img));
     }
-}
+}
diff --git a/Source/Core/Images/Utils.cpp b/Source/Core/Images/Utils.cpp
@@ -397,7 +397,7 @@ void ApplyPixelateEffect(Gdiplus::Bitmap* bm, int xPos, int yPos, int w, int h,
 
 }
 
-std::unique_ptr<Gdiplus::Bitmap> LoadImageFromFileWithoutLocking(const WCHAR* fileName, bool* isAnimated) {
+std::unique_ptr<Gdiplus::Bitmap> LoadImageFromFileWithoutLocking(const WCHAR* fileName, bool* isMultiFrame) {
     using namespace Gdiplus;
     auto img = LoadImageFromFileExtended(fileName);
     if (!img) {
@@ -407,8 +407,8 @@ std::unique_ptr<Gdiplus::Bitmap> LoadImageFromFileWithoutLocking(const WCHAR* fi
     if ( !src || src->GetLastStatus() != Ok ) {
         return nullptr;
     }
-    if (isAnimated) {
-        *isAnimated = img->isSrcAnimated();
+    if (isMultiFrame) {
+        *isMultiFrame = img->isSrcMultiFrame();
     }
     std::unique_ptr<Gdiplus::Bitmap> dst = std::make_unique<Bitmap>(src->GetWidth(), src->GetHeight(), PixelFormat32bppARGB);
 
@@ -1032,7 +1032,7 @@ std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(Gdiplus::Image* bm, int width, int
     return res;
 }
 
-std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(const CString& filename, int width, int height, Gdiplus::Size* realSize) {
+std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(const CString& filename, int width, int height, Gdiplus::Size* realSize, CString* imageFormat) {
     using namespace Gdiplus;
     std::unique_ptr<GdiPlusImage> img = LoadImageFromFileExtended(filename);
     if (!img) {
@@ -1044,7 +1044,11 @@ std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(const CString& filename, int width
     if (!bm || bm->GetLastStatus() != Ok) {
         return {};
     }
-    return GetThumbnail(bm.get(), width, height, realSize);
+    std::unique_ptr<Gdiplus::Bitmap> res = GetThumbnail(bm.get(), width, height, realSize);
+    if (res && imageFormat) {
+        *imageFormat = U2W(img->getSrcFormat());
+    }
+    return res;
 }
 
 Gdiplus::Size AdaptProportionalSize(const Gdiplus::Size& szMax, const Gdiplus::Size& szReal)
@@ -1421,16 +1425,22 @@ bool ExUtilReadFile(const wchar_t* const file_name, uint8_t** data, size_t* data
     return true;
 }
 
-bool IsImageAnimated(Gdiplus::Image* img) {
+bool IsImageMultiFrame(Gdiplus::Image* img) {
+    /*GUID format;
+    if (img->GetRawFormat(&format) == Gdiplus::Ok) {
+        if (format == ImageFormatTIFF) {
+            return false;
+        }
+    }*/
+
     UINT count = img->GetFrameDimensionsCount();
-    GUID* pDimensionIDs = new GUID[count];
+    auto pDimensionIDs = std::make_unique<GUID[]>(count);
 
     // Get the list of frame dimensions from the Image object.
-    img->GetFrameDimensionsList(pDimensionIDs, count);
+    img->GetFrameDimensionsList(pDimensionIDs.get(), count);
 
     // Get the number of frames in the first dimension.
     int frameCount = img->GetFrameCount(&pDimensionIDs[0]);
-    delete[] pDimensionIDs;
     return frameCount > 1;
 }
 
@@ -1532,4 +1542,41 @@ std::unique_ptr<Gdiplus::Font> StringToGdiplusFont(LPCTSTR szBuffer) {
     return std::make_unique<Font>(&fontFamily, static_cast<REAL>(nFontSize), style, Gdiplus::UnitPixel);
 }
 
+CString ImageFormatGUIDToString(GUID guid) {
+    if (guid == ImageFormatBMP) {
+        return "bmp";
+    }
+    if (guid == ImageFormatEMF) {
+        return "emf";
+    }
+    if (guid == ImageFormatEXIF) {
+        return "exif";
+    }
+    if (guid == ImageFormatGIF) {
+        return "gif";
+    }
+    if (guid == ImageFormatIcon) {
+        return "ico";
+    }
+    if (guid == ImageFormatJPEG) {
+        return "jpeg";
+    }
+    if (guid == ImageFormatMemoryBMP) {
+        return "bmp";
+    }
+    if (guid == ImageFormatPNG) {
+        return "png";
+    }
+    if (guid == ImageFormatTIFF) {
+        return "tiff";
+    }
+    if (guid == ImageFormatWEBP) {
+        return "webp";
+    }
+    if (guid == ImageFormatWMF) {
+        return "wmf";
+    }
+    return "unknown";
+}
+
 }
diff --git a/Source/Core/Images/Utils.h b/Source/Core/Images/Utils.h
@@ -55,7 +55,7 @@ void ChangeAlphaChannel(Gdiplus::Bitmap& source, Gdiplus::Bitmap& dest, int sour
 Gdiplus::Rect MeasureDisplayString(Gdiplus::Graphics& graphics, CString text, Gdiplus::RectF boundingRect, Gdiplus::Font& font);
 CRect CenterRect(CRect r1, const CRect& intoR2);
 std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(Gdiplus::Image* bm, int width, int height, Gdiplus::Size* realSize = 0);
-std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(const CString& filename, int width, int height, Gdiplus::Size* realSize = 0);
+std::unique_ptr<Gdiplus::Bitmap> GetThumbnail(const CString& filename, int width, int height, Gdiplus::Size* realSize = 0, CString* imageFormat = nullptr);
 Gdiplus::Size AdaptProportionalSize(const Gdiplus::Size& szMax, const Gdiplus::Size& szReal);
 std::unique_ptr<Gdiplus::Bitmap> BitmapFromMemory(BYTE* data, size_t size);
 
@@ -74,14 +74,15 @@ bool RotateAccordingToOrientation(short orient, Gdiplus::Image* img, bool remove
 ImageInfo GetImageInfo(const wchar_t* fileName);
 
 CString GdiplusStatusToString(Gdiplus::Status statusID);
-bool IsImageAnimated(Gdiplus::Image* img);
+bool IsImageMultiFrame(Gdiplus::Image* img);
 
 /**
  * @throws IOException
  */
 bool SaveBitmapAsWebp(Gdiplus::Bitmap* img, CString fileName, IStream* stream, bool lossless, int quality);
 
 std::unique_ptr<Gdiplus::Font> StringToGdiplusFont(LPCTSTR szBuffer);
+CString ImageFormatGUIDToString(GUID guid);
 }
 
 #endif
diff --git a/Source/Core/Images/WebpImageReader.cpp b/Source/Core/Images/WebpImageReader.cpp
@@ -24,7 +24,7 @@ std::unique_ptr<GdiPlusImage> WebpImageReader::readFromFile(const wchar_t* fileN
     size_t dataSize = 0;
     try {
         if (!ImageUtils::ExUtilReadFile(fileName, &dataRaw, &dataSize)) {
-            return nullptr;
+            return {};
         }
     } catch (const std::exception&) {
         return {};
@@ -58,7 +58,8 @@ std::unique_ptr<GdiPlusImage> WebpImageReader::readFromMemory(uint8_t* data, siz
     else {
         WebPFree(pic.rgba);
     }
-    img->setSrcAnimated(pic.animated);
+    img->setSrcMultiFrame(pic.animated);
+    img->setSrcFormat("webp");
     return img;
 }