Merge pull request #10403 from AdmiralCurtiss/iofile-seek

Minor IOFile cleanup.

Source/Core/AudioCommon/WaveFile.cpp

@@ -95,11 +95,10 @@ bool WaveFileWriter::Start(const std::string& filename, unsigned int HLESampleRa
 
 void WaveFileWriter::Stop()
 {
-  // u32 file_size = (u32)ftello(file);
-  file.Seek(4, SEEK_SET);
+  file.Seek(4, File::SeekOrigin::Begin);
   Write(audio_size + 36);
 
-  file.Seek(40, SEEK_SET);
+  file.Seek(40, File::SeekOrigin::Begin);
   Write(audio_size);
 
   file.Close();

Source/Core/Common/IOFile.cpp

@@ -94,7 +94,7 @@ bool IOFile::Close()
 void IOFile::SetHandle(std::FILE* file)
 {
   Close();
-  Clear();
+  ClearError();
   m_file = file;
 }
 
@@ -106,9 +106,25 @@ u64 IOFile::GetSize() const
     return 0;
 }
 
-bool IOFile::Seek(s64 off, int origin)
-{
-  if (!IsOpen() || 0 != fseeko(m_file, off, origin))
+bool IOFile::Seek(s64 offset, SeekOrigin origin)
+{
+  int fseek_origin;
+  switch (origin)
+  {
+  case SeekOrigin::Begin:
+    fseek_origin = SEEK_SET;
+    break;
+  case SeekOrigin::Current:
+    fseek_origin = SEEK_CUR;
+    break;
+  case SeekOrigin::End:
+    fseek_origin = SEEK_END;
+    break;
+  default:
+    return false;
+  }
+
+  if (!IsOpen() || 0 != fseeko(m_file, offset, fseek_origin))
     m_good = false;
 
   return m_good;

Source/Core/Common/IOFile.h

@@ -13,6 +13,13 @@
 
 namespace File
 {
+enum class SeekOrigin
+{
+  Begin,
+  Current,
+  End,
+};
+
 // simple wrapper for cstdlib file functions to
 // hopefully will make error checking easier
 // and make forgetting an fclose() harder
@@ -89,14 +96,14 @@ class IOFile
   std::FILE* GetHandle() { return m_file; }
   void SetHandle(std::FILE* file);
 
-  bool Seek(s64 off, int origin);
+  bool Seek(s64 offset, SeekOrigin origin);
   u64 Tell() const;
   u64 GetSize() const;
   bool Resize(u64 size);
   bool Flush();
 
   // clear error state
-  void Clear()
+  void ClearError()
   {
     m_good = true;
     std::clearerr(m_file);

Source/Core/Common/LinearDiskCache.h

@@ -100,8 +100,8 @@ class LinearDiskCache
 
         m_num_entries++;
       }
-      m_file.Clear();
-      m_file.Seek(last_valid_value_start, SEEK_SET);
+      m_file.ClearError();
+      m_file.Seek(last_valid_value_start, File::SeekOrigin::Begin);
 
       return m_num_entries;
     }

Source/Core/Core/Boot/Boot.cpp

@@ -650,7 +650,7 @@ BootExecutableReader::BootExecutableReader(const std::string& file_name)
 
 BootExecutableReader::BootExecutableReader(File::IOFile file)
 {
-  file.Seek(0, SEEK_SET);
+  file.Seek(0, File::SeekOrigin::Begin);
   m_bytes.resize(file.GetSize());
   file.ReadBytes(m_bytes.data(), m_bytes.size());
 }

Source/Core/Core/FifoPlayer/FifoDataFile.cpp

@@ -167,7 +167,7 @@ bool FifoDataFile::Save(const std::string& filename)
   header.mem1_size = Memory::GetRamSizeReal();
   header.mem2_size = Memory::GetExRamSizeReal();
 
-  file.Seek(0, SEEK_SET);
+  file.Seek(0, File::SeekOrigin::Begin);
   file.WriteBytes(&header, sizeof(FileHeader));
 
   // Write frames list
@@ -176,7 +176,7 @@ bool FifoDataFile::Save(const std::string& filename)
     const FifoFrameInfo& srcFrame = m_Frames[i];
 
     // Write FIFO data
-    file.Seek(0, SEEK_END);
+    file.Seek(0, File::SeekOrigin::End);
     u64 dataOffset = file.Tell();
     file.WriteBytes(srcFrame.fifoData.data(), srcFrame.fifoData.size());
 
@@ -192,7 +192,7 @@ bool FifoDataFile::Save(const std::string& filename)
 
     // Write frame info
     u64 frameOffset = frameListOffset + (i * sizeof(FileFrameInfo));
-    file.Seek(frameOffset, SEEK_SET);
+    file.Seek(frameOffset, File::SeekOrigin::Begin);
     file.WriteBytes(&dstFrame, sizeof(FileFrameInfo));
   }
 
@@ -284,27 +284,27 @@ std::unique_ptr<FifoDataFile> FifoDataFile::Load(const std::string& filename, bo
   }
 
   u32 size = std::min<u32>(BP_MEM_SIZE, header.bpMemSize);
-  file.Seek(header.bpMemOffset, SEEK_SET);
+  file.Seek(header.bpMemOffset, File::SeekOrigin::Begin);
   file.ReadArray(&dataFile->m_BPMem);
 
   size = std::min<u32>(CP_MEM_SIZE, header.cpMemSize);
-  file.Seek(header.cpMemOffset, SEEK_SET);
+  file.Seek(header.cpMemOffset, File::SeekOrigin::Begin);
   file.ReadArray(&dataFile->m_CPMem);
 
   size = std::min<u32>(XF_MEM_SIZE, header.xfMemSize);
-  file.Seek(header.xfMemOffset, SEEK_SET);
+  file.Seek(header.xfMemOffset, File::SeekOrigin::Begin);
   file.ReadArray(&dataFile->m_XFMem);
 
   size = std::min<u32>(XF_REGS_SIZE, header.xfRegsSize);
-  file.Seek(header.xfRegsOffset, SEEK_SET);
+  file.Seek(header.xfRegsOffset, File::SeekOrigin::Begin);
   file.ReadArray(&dataFile->m_XFRegs);
 
   // Texture memory saving was added in version 4.
   dataFile->m_TexMem.fill(0);
   if (dataFile->m_Version >= 4)
   {
     size = std::min<u32>(TEX_MEM_SIZE, header.texMemSize);
-    file.Seek(header.texMemOffset, SEEK_SET);
+    file.Seek(header.texMemOffset, File::SeekOrigin::Begin);
     file.ReadArray(&dataFile->m_TexMem);
   }
 
@@ -319,7 +319,7 @@ std::unique_ptr<FifoDataFile> FifoDataFile::Load(const std::string& filename, bo
   for (u32 i = 0; i < header.frameCount; ++i)
   {
     u64 frameOffset = header.frameListOffset + (i * sizeof(FileFrameInfo));
-    file.Seek(frameOffset, SEEK_SET);
+    file.Seek(frameOffset, File::SeekOrigin::Begin);
     FileFrameInfo srcFrame;
     if (!file.ReadBytes(&srcFrame, sizeof(FileFrameInfo)))
       return panic_failed_to_read();
@@ -329,7 +329,7 @@ std::unique_ptr<FifoDataFile> FifoDataFile::Load(const std::string& filename, bo
     dstFrame.fifoStart = srcFrame.fifoStart;
     dstFrame.fifoEnd = srcFrame.fifoEnd;
 
-    file.Seek(srcFrame.fifoDataOffset, SEEK_SET);
+    file.Seek(srcFrame.fifoDataOffset, File::SeekOrigin::Begin);
     file.ReadBytes(dstFrame.fifoData.data(), srcFrame.fifoDataSize);
 
     ReadMemoryUpdates(srcFrame.memoryUpdatesOffset, srcFrame.numMemoryUpdates,
@@ -375,7 +375,7 @@ u64 FifoDataFile::WriteMemoryUpdates(const std::vector<MemoryUpdate>& memUpdates
     const MemoryUpdate& srcUpdate = memUpdates[i];
 
     // Write memory
-    file.Seek(0, SEEK_END);
+    file.Seek(0, File::SeekOrigin::End);
     u64 dataOffset = file.Tell();
     file.WriteBytes(srcUpdate.data.data(), srcUpdate.data.size());
 
@@ -387,7 +387,7 @@ u64 FifoDataFile::WriteMemoryUpdates(const std::vector<MemoryUpdate>& memUpdates
     dstUpdate.type = srcUpdate.type;
 
     u64 updateOffset = updateListOffset + (i * sizeof(FileMemoryUpdate));
-    file.Seek(updateOffset, SEEK_SET);
+    file.Seek(updateOffset, File::SeekOrigin::Begin);
     file.WriteBytes(&dstUpdate, sizeof(FileMemoryUpdate));
   }
 
@@ -402,7 +402,7 @@ void FifoDataFile::ReadMemoryUpdates(u64 fileOffset, u32 numUpdates,
   for (u32 i = 0; i < numUpdates; ++i)
   {
     u64 updateOffset = fileOffset + (i * sizeof(FileMemoryUpdate));
-    file.Seek(updateOffset, SEEK_SET);
+    file.Seek(updateOffset, File::SeekOrigin::Begin);
     FileMemoryUpdate srcUpdate;
     file.ReadBytes(&srcUpdate, sizeof(FileMemoryUpdate));
 
@@ -412,7 +412,7 @@ void FifoDataFile::ReadMemoryUpdates(u64 fileOffset, u32 numUpdates,
     dstUpdate.data.resize(srcUpdate.dataSize);
     dstUpdate.type = static_cast<MemoryUpdate::Type>(srcUpdate.type);
 
-    file.Seek(srcUpdate.dataOffset, SEEK_SET);
+    file.Seek(srcUpdate.dataOffset, File::SeekOrigin::Begin);
     file.ReadBytes(dstUpdate.data.data(), srcUpdate.dataSize);
   }
 }

Source/Core/Core/HW/EXI/EXI_DeviceIPL.cpp

@@ -236,7 +236,7 @@ void CEXIIPL::LoadFontFile(const std::string& filename, u32 offset)
   INFO_LOG_FMT(BOOT, "Found IPL dump, loading {} font from {}",
                (offset == 0x1aff00) ? "Shift JIS" : "Windows-1252", ipl_rom_path);
 
-  stream.Seek(offset, 0);
+  stream.Seek(offset, File::SeekOrigin::Begin);
   stream.ReadBytes(&m_rom[offset], fontsize);
 
   m_fonts_loaded = true;

Source/Core/Core/HW/GCMemcard/GCIFile.cpp

@@ -55,7 +55,7 @@ bool GCIFile::LoadSaveBlocks()
     }
 
     m_save_data.resize(num_blocks);
-    save_file.Seek(DENTRY_SIZE, SEEK_SET);
+    save_file.Seek(DENTRY_SIZE, File::SeekOrigin::Begin);
     if (!save_file.ReadBytes(m_save_data.data(), size))
     {
       ERROR_LOG_FMT(EXPANSIONINTERFACE, "Failed to read data from GCI file {}", m_filename);

Source/Core/Core/HW/GCMemcard/GCMemcard.cpp

@@ -112,7 +112,7 @@ std::pair<GCMemcardErrorCode, std::optional<GCMemcard>> GCMemcard::Open(std::str
 
   // read the entire card into memory
   GCMemcard card;
-  file.Seek(0, SEEK_SET);
+  file.Seek(0, File::SeekOrigin::Begin);
   if (!file.ReadBytes(&card.m_header_block, BLOCK_SIZE) ||
       !file.ReadBytes(&card.m_directory_blocks[0], BLOCK_SIZE) ||
       !file.ReadBytes(&card.m_directory_blocks[1], BLOCK_SIZE) ||
@@ -310,7 +310,7 @@ bool GCMemcard::IsShiftJIS() const
 bool GCMemcard::Save()
 {
   File::IOFile mcdFile(m_filename, "wb");
-  mcdFile.Seek(0, SEEK_SET);
+  mcdFile.Seek(0, File::SeekOrigin::Begin);
 
   mcdFile.WriteBytes(&m_header_block, BLOCK_SIZE);
   mcdFile.WriteBytes(&m_directory_blocks[0], BLOCK_SIZE);

Source/Core/Core/HW/WiiSave.cpp

@@ -278,7 +278,7 @@ class DataBinStorage final : public Storage
   std::optional<Header> ReadHeader() override
   {
     Header header;
-    if (!m_file.Seek(0, SEEK_SET) || !m_file.ReadArray(&header, 1))
+    if (!m_file.Seek(0, File::SeekOrigin::Begin) || !m_file.ReadArray(&header, 1))
       return {};
 
     std::array<u8, 0x10> iv = s_sd_initial_iv;
@@ -310,7 +310,7 @@ class DataBinStorage final : public Storage
   std::optional<BkHeader> ReadBkHeader() override
   {
     BkHeader bk_header;
-    m_file.Seek(sizeof(Header), SEEK_SET);
+    m_file.Seek(sizeof(Header), File::SeekOrigin::Begin);
     if (!m_file.ReadArray(&bk_header, 1))
       return {};
     if (bk_header.size != BK_LISTED_SZ || bk_header.magic != BK_HDR_MAGIC)
@@ -323,7 +323,7 @@ class DataBinStorage final : public Storage
   std::optional<std::vector<SaveFile>> ReadFiles() override
   {
     const std::optional<BkHeader> bk_header = ReadBkHeader();
-    if (!bk_header || !m_file.Seek(sizeof(Header) + sizeof(BkHeader), SEEK_SET))
+    if (!bk_header || !m_file.Seek(sizeof(Header) + sizeof(BkHeader), File::SeekOrigin::Begin))
       return {};
 
     std::vector<SaveFile> files;
@@ -352,15 +352,18 @@ class DataBinStorage final : public Storage
         save_file.data = [this, size, rounded_size, iv,
                           pos]() mutable -> std::optional<std::vector<u8>> {
           std::vector<u8> file_data(rounded_size);
-          if (!m_file.Seek(pos, SEEK_SET) || !m_file.ReadBytes(file_data.data(), rounded_size))
+          if (!m_file.Seek(pos, File::SeekOrigin::Begin) ||
+              !m_file.ReadBytes(file_data.data(), rounded_size))
+          {
             return {};
+          }
 
           m_iosc.Decrypt(IOS::HLE::IOSC::HANDLE_SD_KEY, iv.data(), file_data.data(), rounded_size,
                          file_data.data(), IOS::PID_ES);
           file_data.resize(size);
           return file_data;
         };
-        m_file.Seek(pos + rounded_size, SEEK_SET);
+        m_file.Seek(pos + rounded_size, File::SeekOrigin::Begin);
       }
       files.emplace_back(std::move(save_file));
     }
@@ -373,17 +376,17 @@ class DataBinStorage final : public Storage
     std::array<u8, 0x10> iv = s_sd_initial_iv;
     m_iosc.Encrypt(IOS::HLE::IOSC::HANDLE_SD_KEY, iv.data(), reinterpret_cast<const u8*>(&header),
                    sizeof(Header), reinterpret_cast<u8*>(&encrypted_header), IOS::PID_ES);
-    return m_file.Seek(0, SEEK_SET) && m_file.WriteArray(&encrypted_header, 1);
+    return m_file.Seek(0, File::SeekOrigin::Begin) && m_file.WriteArray(&encrypted_header, 1);
   }
 
   bool WriteBkHeader(const BkHeader& bk_header) override
   {
-    return m_file.Seek(sizeof(Header), SEEK_SET) && m_file.WriteArray(&bk_header, 1);
+    return m_file.Seek(sizeof(Header), File::SeekOrigin::Begin) && m_file.WriteArray(&bk_header, 1);
   }
 
   bool WriteFiles(const std::vector<SaveFile>& files) override
   {
-    if (!m_file.Seek(sizeof(Header) + sizeof(BkHeader), SEEK_SET))
+    if (!m_file.Seek(sizeof(Header) + sizeof(BkHeader), File::SeekOrigin::Begin))
       return false;
 
     for (const SaveFile& save_file : files)
@@ -440,7 +443,7 @@ class DataBinStorage final : public Storage
     {
       const u32 data_size = bk_header->size_of_files + sizeof(BkHeader);
       auto data = std::make_unique<u8[]>(data_size);
-      m_file.Seek(sizeof(Header), SEEK_SET);
+      m_file.Seek(sizeof(Header), File::SeekOrigin::Begin);
       if (!m_file.ReadBytes(data.get(), data_size))
         return false;
       mbedtls_sha1_ret(data.get(), data_size, data_sha1.data());
@@ -453,7 +456,7 @@ class DataBinStorage final : public Storage
                 data_sha1.data(), static_cast<u32>(data_sha1.size()));
 
     // Write signatures.
-    if (!m_file.Seek(0, SEEK_END))
+    if (!m_file.Seek(0, File::SeekOrigin::End))
       return false;
     const u32 SIGNATURE_END_MAGIC = Common::swap32(0x2f536969);
     const IOS::CertECC device_certificate = m_iosc.GetDeviceCertificate();

Source/Core/Core/IOS/FS/HostBackend/File.cpp

@@ -127,7 +127,7 @@ Result<u32> HostFileSystem::ReadBytesFromFile(Fd fd, u8* ptr, u32 count)
     count = file_size - handle->file_offset;
 
   // File might be opened twice, need to seek before we read
-  handle->host_file->Seek(handle->file_offset, SEEK_SET);
+  handle->host_file->Seek(handle->file_offset, File::SeekOrigin::Begin);
   const u32 actually_read = static_cast<u32>(fread(ptr, 1, count, handle->host_file->GetHandle()));
 
   if (actually_read != count && ferror(handle->host_file->GetHandle()))
@@ -149,7 +149,7 @@ Result<u32> HostFileSystem::WriteBytesToFile(Fd fd, const u8* ptr, u32 count)
     return ResultCode::AccessDenied;
 
   // File might be opened twice, need to seek before we read
-  handle->host_file->Seek(handle->file_offset, SEEK_SET);
+  handle->host_file->Seek(handle->file_offset, File::SeekOrigin::Begin);
   if (!handle->host_file->WriteBytes(ptr, count))
     return ResultCode::AccessDenied;
 

Source/Core/Core/IOS/SDIO/SDIOSlot0.cpp

@@ -251,8 +251,8 @@ s32 SDIOSlot0Device::ExecuteCommand(const Request& request, u32 buffer_in, u32 b
       const u32 size = req.bsize * req.blocks;
       const u64 address = GetAddressFromRequest(req.arg);
 
-      if (!m_card.Seek(address, SEEK_SET))
-        ERROR_LOG_FMT(IOS_SD, "Seek failed WTF");
+      if (!m_card.Seek(address, File::SeekOrigin::Begin))
+        ERROR_LOG_FMT(IOS_SD, "Seek failed");
 
       if (m_card.ReadBytes(Memory::GetPointer(req.addr), size))
       {
@@ -281,8 +281,8 @@ s32 SDIOSlot0Device::ExecuteCommand(const Request& request, u32 buffer_in, u32 b
       const u32 size = req.bsize * req.blocks;
       const u64 address = GetAddressFromRequest(req.arg);
 
-      if (!m_card.Seek(address, SEEK_SET))
-        ERROR_LOG_FMT(IOS_SD, "fseeko failed WTF");
+      if (!m_card.Seek(address, File::SeekOrigin::Begin))
+        ERROR_LOG_FMT(IOS_SD, "Seek failed");
 
       if (!m_card.WriteBytes(Memory::GetPointer(req.addr), size))
       {