Show file format details in game properties

Source/Core/DiscIO/Blob.cpp

@@ -12,6 +12,7 @@
 #include "Common/CDUtils.h"
 #include "Common/CommonTypes.h"
 #include "Common/File.h"
+#include "Common/MsgHandler.h"
 
 #include "DiscIO/Blob.h"
 #include "DiscIO/CISOBlob.h"
@@ -25,6 +26,35 @@
 
 namespace DiscIO
 {
+std::string GetName(BlobType blob_type, bool translate)
+{
+  const auto translate_str = [translate](const std::string& str) {
+    return translate ? Common::GetStringT(str.c_str()) : str;
+  };
+
+  switch (blob_type)
+  {
+  case BlobType::PLAIN:
+    return "ISO";
+  case BlobType::DIRECTORY:
+    return translate_str("Directory");
+  case BlobType::GCZ:
+    return "GCZ";
+  case BlobType::CISO:
+    return "CISO";
+  case BlobType::WBFS:
+    return "WBFS";
+  case BlobType::TGC:
+    return "TGC";
+  case BlobType::WIA:
+    return "WIA";
+  case BlobType::RVZ:
+    return "RVZ";
+  default:
+    return "";
+  }
+}
+
 void SectorReader::SetSectorSize(int blocksize)
 {
   m_block_size = std::max(blocksize, 0);

Source/Core/DiscIO/Blob.h

@@ -41,6 +41,8 @@ enum class BlobType
   RVZ,
 };
 
+std::string GetName(BlobType blob_type, bool translate);
+
 class BlobReader
 {
 public:
@@ -55,6 +57,7 @@ public:
   // Returns 0 if the format does not use blocks
   virtual u64 GetBlockSize() const = 0;
   virtual bool HasFastRandomAccessInBlock() const = 0;
+  virtual std::string GetCompressionMethod() const = 0;
 
   // NOT thread-safe - can't call this from multiple threads.
   virtual bool Read(u64 offset, u64 size, u8* out_ptr) = 0;

Source/Core/DiscIO/CISOBlob.h

@@ -46,6 +46,7 @@ public:
 
   u64 GetBlockSize() const override { return m_block_size; }
   bool HasFastRandomAccessInBlock() const override { return true; }
+  std::string GetCompressionMethod() const override { return {}; }
 
   bool Read(u64 offset, u64 nbytes, u8* out_ptr) override;
 

Source/Core/DiscIO/CompressedBlob.h

@@ -58,6 +58,7 @@ public:
 
   u64 GetBlockSize() const override { return m_header.block_size; }
   bool HasFastRandomAccessInBlock() const override { return false; }
+  std::string GetCompressionMethod() const override { return "Deflate"; }
 
   u64 GetBlockCompressedSize(u64 block_num) const;
   bool GetBlock(u64 block_num, u8* out_ptr) override;

Source/Core/DiscIO/DirectoryBlob.h

@@ -168,6 +168,7 @@ public:
 
   u64 GetBlockSize() const override { return 0; }
   bool HasFastRandomAccessInBlock() const override { return true; }
+  std::string GetCompressionMethod() const override { return {}; }
 
 private:
   struct PartitionWithType

Source/Core/DiscIO/DriveBlob.h

@@ -32,6 +32,7 @@ public:
 
   u64 GetBlockSize() const override { return ECC_BLOCK_SIZE; }
   bool HasFastRandomAccessInBlock() const override { return false; }
+  std::string GetCompressionMethod() const override { return {}; }
 
 private:
   DriveReader(const std::string& drive);

Source/Core/DiscIO/FileBlob.h

@@ -27,6 +27,7 @@ public:
 
   u64 GetBlockSize() const override { return 0; }
   bool HasFastRandomAccessInBlock() const override { return true; }
+  std::string GetCompressionMethod() const override { return {}; }
 
   bool Read(u64 offset, u64 nbytes, u8* out_ptr) override;
 

Source/Core/DiscIO/ScrubbedBlob.h

@@ -30,6 +30,10 @@ public:
   {
     return m_blob_reader->HasFastRandomAccessInBlock();
   }
+  std::string GetCompressionMethod() const override
+  {
+    return m_blob_reader->GetCompressionMethod();
+  }
 
   bool Read(u64 offset, u64 size, u8* out_ptr) override;
 

Source/Core/DiscIO/TGCBlob.h

@@ -50,6 +50,7 @@ public:
 
   u64 GetBlockSize() const override { return 0; }
   bool HasFastRandomAccessInBlock() const override { return true; }
+  std::string GetCompressionMethod() const override { return {}; }
 
   bool Read(u64 offset, u64 nbytes, u8* out_ptr) override;
 

Source/Core/DiscIO/VolumeFileBlobReader.cpp

@@ -54,6 +54,11 @@ bool VolumeFileBlobReader::HasFastRandomAccessInBlock() const
   return m_volume.GetBlobReader().HasFastRandomAccessInBlock();
 }
 
+std::string VolumeFileBlobReader::GetCompressionMethod() const
+{
+  return m_volume.GetBlobReader().GetCompressionMethod();
+}
+
 bool VolumeFileBlobReader::Read(u64 offset, u64 length, u8* out_ptr)
 {
   if (offset + length > m_file_info->GetSize())

Source/Core/DiscIO/VolumeFileBlobReader.h

@@ -30,6 +30,7 @@ public:
 
   u64 GetBlockSize() const override;
   bool HasFastRandomAccessInBlock() const override;
+  std::string GetCompressionMethod() const override;
 
   bool Read(u64 offset, u64 length, u8* out_ptr) override;
 

Source/Core/DiscIO/WIABlob.cpp

@@ -290,6 +290,26 @@ BlobType WIARVZFileReader<RVZ>::GetBlobType() const
   return RVZ ? BlobType::RVZ : BlobType::WIA;
 }
 
+template <bool RVZ>
+std::string WIARVZFileReader<RVZ>::GetCompressionMethod() const
+{
+  switch (m_compression_type)
+  {
+  case WIARVZCompressionType::Purge:
+    return "Purge";
+  case WIARVZCompressionType::Bzip2:
+    return "bzip2";
+  case WIARVZCompressionType::LZMA:
+    return "LZMA";
+  case WIARVZCompressionType::LZMA2:
+    return "LZMA2";
+  case WIARVZCompressionType::Zstd:
+    return "Zstandard";
+  default:
+    return {};
+  }
+}
+
 template <bool RVZ>
 bool WIARVZFileReader<RVZ>::Read(u64 offset, u64 size, u8* out_ptr)
 {

Source/Core/DiscIO/WIABlob.h

@@ -56,6 +56,7 @@ public:
 
   u64 GetBlockSize() const override { return Common::swap32(m_header_2.chunk_size); }
   bool HasFastRandomAccessInBlock() const override { return false; }
+  std::string GetCompressionMethod() const override;
 
   bool Read(u64 offset, u64 size, u8* out_ptr) override;
   bool SupportsReadWiiDecrypted() const override;

Source/Core/DiscIO/WbfsBlob.h

@@ -34,6 +34,7 @@ public:
 
   u64 GetBlockSize() const override { return m_wbfs_sector_size; }
   bool HasFastRandomAccessInBlock() const override { return true; }
+  std::string GetCompressionMethod() const override { return {}; }
 
   bool Read(u64 offset, u64 nbytes, u8* out_ptr) override;
 

Source/Core/DolphinQt/Config/InfoWidget.cpp

@@ -27,7 +27,8 @@ InfoWidget::InfoWidget(const UICommon::GameFile& game) : m_game(game)
 {
   QVBoxLayout* layout = new QVBoxLayout();
 
-  layout->addWidget(CreateISODetails());
+  layout->addWidget(CreateFileDetails());
+  layout->addWidget(CreateGameDetails());
 
   if (!game.GetLanguages().empty())
     layout->addWidget(CreateBannerDetails());
@@ -35,19 +36,54 @@ InfoWidget::InfoWidget(const UICommon::GameFile& game) : m_game(game)
   setLayout(layout);
 }
 
-QGroupBox* InfoWidget::CreateISODetails()
+QGroupBox* InfoWidget::CreateFileDetails()
 {
-  const QString UNKNOWN_NAME = tr("Unknown");
-
-  QGroupBox* group = new QGroupBox(tr("ISO Details"));
+  QGroupBox* group = new QGroupBox(tr("File Details"));
   QFormLayout* layout = new QFormLayout;
 
   layout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
 
-  QLineEdit* file_path = CreateValueDisplay(
-      QStringLiteral("%1 (%2)")
-          .arg(QDir::toNativeSeparators(QString::fromStdString(m_game.GetFilePath())))
-          .arg(QString::fromStdString(UICommon::FormatSize(m_game.GetFileSize()))));
+  QString path = QDir::toNativeSeparators(QString::fromStdString(m_game.GetFilePath()));
+  layout->addRow(tr("Path:"), CreateValueDisplay(path));
+
+  const std::string file_size = UICommon::FormatSize(m_game.GetFileSize());
+
+  if (!m_game.ShouldShowFileFormatDetails())
+  {
+    layout->addRow(tr("File Size:"), CreateValueDisplay(file_size));
+  }
+  else
+  {
+    const QString file_format =
+        QStringLiteral("%1 (%2)")
+            .arg(QString::fromStdString(DiscIO::GetName(m_game.GetBlobType(), true)))
+            .arg(QString::fromStdString(file_size));
+    layout->addRow(tr("File Format:"), CreateValueDisplay(file_format));
+
+    QString compression = QString::fromStdString(m_game.GetCompressionMethod());
+    if (compression.isEmpty())
+      compression = tr("No Compression");
+    layout->addRow(tr("Compression:"), CreateValueDisplay(compression));
+
+    if (m_game.GetBlockSize() > 0)
+    {
+      const std::string block_size = UICommon::FormatSize(m_game.GetBlockSize(), 0);
+      layout->addRow(tr("Block Size:"), CreateValueDisplay(block_size));
+    }
+  }
+
+  group->setLayout(layout);
+  return group;
+}
+
+QGroupBox* InfoWidget::CreateGameDetails()
+{
+  const QString UNKNOWN_NAME = tr("Unknown");
+
+  QGroupBox* group = new QGroupBox(tr("Game Details"));
+  QFormLayout* layout = new QFormLayout;
+
+  layout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
 
   const QString game_name = QString::fromStdString(m_game.GetInternalName());
 
@@ -79,7 +115,6 @@ QGroupBox* InfoWidget::CreateISODetails()
                          m_game.GetMakerID() + ")");
 
   layout->addRow(tr("Name:"), internal_name);
-  layout->addRow(tr("File:"), file_path);
   layout->addRow(tr("Game ID:"), game_id);
   layout->addRow(tr("Country:"), country);
   layout->addRow(tr("Maker:"), maker);

Source/Core/DolphinQt/Config/InfoWidget.h

@@ -26,8 +26,9 @@ private:
   void ChangeLanguage();
   void SaveBanner();
 
+  QGroupBox* CreateFileDetails();
+  QGroupBox* CreateGameDetails();
   QGroupBox* CreateBannerDetails();
-  QGroupBox* CreateISODetails();
   QLineEdit* CreateValueDisplay(const QString& value);
   QLineEdit* CreateValueDisplay(const std::string& value = "");
   void CreateLanguageSelector();

Source/Core/UICommon/GameFile.cpp

@@ -115,6 +115,8 @@ GameFile::GameFile(std::string path) : m_file_path(std::move(path))
       m_region = volume->GetRegion();
       m_country = volume->GetCountry();
       m_blob_type = volume->GetBlobType();
+      m_block_size = volume->GetBlobReader().GetBlockSize();
+      m_compression_method = volume->GetBlobReader().GetCompressionMethod();
       m_file_size = volume->GetRawSize();
       m_volume_size = volume->GetSize();
       m_volume_size_is_accurate = volume->IsSizeAccurate();
@@ -320,6 +322,8 @@ void GameFile::DoState(PointerWrap& p)
   p.Do(m_country);
   p.Do(m_platform);
   p.Do(m_blob_type);
+  p.Do(m_block_size);
+  p.Do(m_compression_method);
   p.Do(m_revision);
   p.Do(m_disc_number);
   p.Do(m_apploader_date);
@@ -566,6 +570,29 @@ std::string GameFile::GetWiiFSPath() const
   return Common::GetTitleDataPath(m_title_id, Common::FROM_CONFIGURED_ROOT);
 }
 
+bool GameFile::ShouldShowFileFormatDetails() const
+{
+  switch (m_blob_type)
+  {
+  case DiscIO::BlobType::PLAIN:
+    break;
+  case DiscIO::BlobType::DRIVE:
+    return false;
+  default:
+    return true;
+  }
+
+  switch (m_platform)
+  {
+  case DiscIO::Platform::WiiWAD:
+    return false;
+  case DiscIO::Platform::ELFOrDOL:
+    return false;
+  default:
+    return true;
+  }
+}
+
 const GameBanner& GameFile::GetBannerImage() const
 {
   return m_custom_banner.empty() ? m_volume_banner : m_custom_banner;

Source/Core/UICommon/GameFile.h

@@ -86,6 +86,9 @@ public:
   DiscIO::Country GetCountry() const { return m_country; }
   DiscIO::Platform GetPlatform() const { return m_platform; }
   DiscIO::BlobType GetBlobType() const { return m_blob_type; }
+  u64 GetBlockSize() const { return m_block_size; }
+  const std::string& GetCompressionMethod() const { return m_compression_method; }
+  bool ShouldShowFileFormatDetails() const;
   const std::string& GetApploaderDate() const { return m_apploader_date; }
   u64 GetFileSize() const { return m_file_size; }
   u64 GetVolumeSize() const { return m_volume_size; }
@@ -144,6 +147,8 @@ private:
   DiscIO::Country m_country{DiscIO::Country::Unknown};
   DiscIO::Platform m_platform{};
   DiscIO::BlobType m_blob_type{};
+  u64 m_block_size{};
+  std::string m_compression_method{};
   u16 m_revision{};
   u8 m_disc_number{};
   std::string m_apploader_date;

Source/Core/UICommon/GameFileCache.cpp

@@ -27,7 +27,7 @@
 
 namespace UICommon
 {
-static constexpr u32 CACHE_REVISION = 17;  // Last changed in PR 8738
+static constexpr u32 CACHE_REVISION = 18;  // Last changed in PR 8891
 
 std::vector<std::string> FindAllGamePaths(const std::vector<std::string>& directories_to_scan,
                                           bool recursive_scan)