ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #11456 from MayImilae/remove-boot-from-dvd 

Remove Boot from DVD Backup
This commit is contained in:
Pierre Bourdon 2023-01-17 23:27:59 +01:00 committed by GitHub
parent c527aea40d dcc10cff11
commit 686ac363ba
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 0 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Core/DiscIO/Blob.cpp
View File

@ -18,7 +18,6 @@
#include "DiscIO/CISOBlob.h"
#include "DiscIO/CompressedBlob.h"
#include "DiscIO/DirectoryBlob.h"
#include "DiscIO/DriveBlob.h"
#include "DiscIO/FileBlob.h"
#include "DiscIO/NFSBlob.h"
#include "DiscIO/TGCBlob.h"
@ -215,9 +214,6 @@ u32 SectorReader::ReadChunk(u8* buffer, u64 chunk_num)
std::unique_ptr<BlobReader> CreateBlobReader(const std::string& filename)
{
if (Common::IsCDROMDevice(filename))
return DriveReader::Create(filename);
File::IOFile file(filename, "rb");
u32 magic;
if (!file.ReadArray(&magic, 1))

2
Source/Core/DiscIO/CMakeLists.txt
View File

@ -13,8 +13,6 @@ add_library(discio
DiscScrubber.h
DiscUtils.cpp
DiscUtils.h
DriveBlob.cpp
DriveBlob.h
Enums.cpp
Enums.h
FileBlob.cpp

161
Source/Core/DiscIO/DriveBlob.cpp
View File

@ -1,161 +0,0 @@
// Copyright 2008 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "DiscIO/DriveBlob.h"
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <memory>
#include <string>
#include <vector>
#include "Common/CommonTypes.h"
#include "Common/IOFile.h"
#include "Common/Logging/Log.h"
#include "DiscIO/Blob.h"
#ifdef _WIN32
#include "Common/StringUtil.h"
#else
#include <stdio.h> // fileno
#include <sys/ioctl.h>
#if defined __linux__
#include <linux/fs.h> // BLKGETSIZE64
#elif defined __FreeBSD__
#include <sys/disk.h> // DIOCGMEDIASIZE
#elif defined __APPLE__
#include <sys/disk.h> // DKIOCGETBLOCKCOUNT / DKIOCGETBLOCKSIZE
#endif
#endif
namespace DiscIO
{
DriveReader::DriveReader(const std::string& drive)
{
// 32 sectors is roughly the optimal amount a CD Drive can read in
// a single IO cycle. Larger values yield no performance improvement
// and just cause IO stalls from the read delay. Smaller values allow
// the OS IO and seeking overhead to ourstrip the time actually spent
// transferring bytes from the media.
SetChunkSize(32); // 32*2048 = 64KiB
SetSectorSize(2048);
#ifdef _WIN32
auto const path = UTF8ToTStr(std::string("\\\\.\\") + drive);
m_disc_handle = CreateFile(path.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
nullptr, OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, nullptr);
if (IsOK())
{
// Do a test read to make sure everything is OK, since it seems you can get
// handles to empty drives.
DWORD not_used;
std::vector<u8> buffer(GetSectorSize());
if (!ReadFile(m_disc_handle, buffer.data(), GetSectorSize(), &not_used, nullptr))
{
// OK, something is wrong.
CloseHandle(m_disc_handle);
m_disc_handle = INVALID_HANDLE_VALUE;
}
}
if (IsOK())
{
// Initialize m_size by querying the volume capacity.
STORAGE_READ_CAPACITY storage_size;
storage_size.Version = sizeof(storage_size);
DWORD bytes = 0;
DeviceIoControl(m_disc_handle, IOCTL_STORAGE_READ_CAPACITY, nullptr, 0, &storage_size,
sizeof(storage_size), &bytes, nullptr);
m_size = bytes ? storage_size.DiskLength.QuadPart : 0;
#ifdef _LOCKDRIVE // Do we want to lock the drive?
// Lock the compact disc in the CD-ROM drive to prevent accidental
// removal while reading from it.
m_lock_cdrom.PreventMediaRemoval = TRUE;
DeviceIoControl(m_disc_handle, IOCTL_CDROM_MEDIA_REMOVAL, &m_lock_cdrom, sizeof(m_lock_cdrom),
nullptr, 0, &dwNotUsed, nullptr);
#endif
#else
m_file.Open(drive, "rb");
if (m_file)
{
int fd = fileno(m_file.GetHandle());
#if defined __linux__
// NOTE: Doesn't matter if it fails, m_size was initialized to zero
ioctl(fd, BLKGETSIZE64, &m_size); // u64*
#elif defined __FreeBSD__
off_t size = 0;
ioctl(fd, DIOCGMEDIASIZE, &size); // off_t*
m_size = size;
#elif defined __APPLE__
u64 count = 0;
u32 block_size = 0;
ioctl(fd, DKIOCGETBLOCKCOUNT, &count); // u64*
ioctl(fd, DKIOCGETBLOCKSIZE, &block_size); // u32*
m_size = count * block_size;
#endif
#endif
}
else
{
NOTICE_LOG_FMT(DISCIO, "Load from DVD backup failed or no disc in drive {}", drive);
}
}
DriveReader::~DriveReader()
{
#ifdef _WIN32
#ifdef _LOCKDRIVE // Do we want to lock the drive?
// Unlock the disc in the CD-ROM drive.
m_lock_cdrom.PreventMediaRemoval = FALSE;
DeviceIoControl(m_disc_handle, IOCTL_CDROM_MEDIA_REMOVAL, &m_lock_cdrom, sizeof(m_lock_cdrom),
nullptr, 0, &dwNotUsed, nullptr);
#endif
if (m_disc_handle != INVALID_HANDLE_VALUE)
{
CloseHandle(m_disc_handle);
m_disc_handle = INVALID_HANDLE_VALUE;
}
#else
m_file.Close();
#endif
}
std::unique_ptr<DriveReader> DriveReader::Create(const std::string& drive)
{
auto reader = std::unique_ptr<DriveReader>(new DriveReader(drive));
if (!reader->IsOK())
reader.reset();
return reader;
}
bool DriveReader::GetBlock(u64 block_num, u8* out_ptr)
{
return DriveReader::ReadMultipleAlignedBlocks(block_num, 1, out_ptr);
}
bool DriveReader::ReadMultipleAlignedBlocks(u64 block_num, u64 num_blocks, u8* out_ptr)
{
#ifdef _WIN32
LARGE_INTEGER offset;
offset.QuadPart = GetSectorSize() * block_num;
DWORD bytes_read;
if (!SetFilePointerEx(m_disc_handle, offset, nullptr, FILE_BEGIN) ||
!ReadFile(m_disc_handle, out_ptr, static_cast<DWORD>(GetSectorSize() * num_blocks),
&bytes_read, nullptr))
{
ERROR_LOG_FMT(DISCIO, "Disc Read Error");
return false;
}
return bytes_read == GetSectorSize() * num_blocks;
#else
m_file.Seek(GetSectorSize() * block_num, File::SeekOrigin::Begin);
if (m_file.ReadBytes(out_ptr, num_blocks * GetSectorSize()))
return true;
m_file.ClearError();
return false;
#endif
}
} // namespace DiscIO

54
Source/Core/DiscIO/DriveBlob.h
View File

@ -1,54 +0,0 @@
// Copyright 2008 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <memory>
#include <string>
#include "Common/CommonTypes.h"
#include "Common/IOFile.h"
#include "DiscIO/Blob.h"
#ifdef _WIN32
#include <windows.h>
#include <winioctl.h>
#endif
namespace DiscIO
{
class DriveReader : public SectorReader
{
public:
static std::unique_ptr<DriveReader> Create(const std::string& drive);
~DriveReader();
BlobType GetBlobType() const override { return BlobType::DRIVE; }
u64 GetRawSize() const override { return m_size; }
u64 GetDataSize() const override { return m_size; }
DataSizeType GetDataSizeType() const override { return DataSizeType::Accurate; }
u64 GetBlockSize() const override { return ECC_BLOCK_SIZE; }
bool HasFastRandomAccessInBlock() const override { return false; }
std::string GetCompressionMethod() const override { return {}; }
std::optional<int> GetCompressionLevel() const override { return std::nullopt; }
private:
DriveReader(const std::string& drive);
bool GetBlock(u64 block_num, u8* out_ptr) override;
bool ReadMultipleAlignedBlocks(u64 block_num, u64 num_blocks, u8* out_ptr) override;
#ifdef _WIN32
HANDLE m_disc_handle = INVALID_HANDLE_VALUE;
PREVENT_MEDIA_REMOVAL m_lock_cdrom;
bool IsOK() const { return m_disc_handle != INVALID_HANDLE_VALUE; }
#else
File::IOFile m_file;
bool IsOK() const { return m_file.IsOpen() && m_file.IsGood(); }
#endif
static constexpr u64 ECC_BLOCK_SIZE = 0x8000;
u64 m_size = 0;
};
} // namespace DiscIO

2
Source/Core/DolphinLib.props
View File

@ -438,7 +438,6 @@
<ClInclude Include="DiscIO\DiscExtractor.h" />
<ClInclude Include="DiscIO\DiscScrubber.h" />
<ClInclude Include="DiscIO\DiscUtils.h" />
<ClInclude Include="DiscIO\DriveBlob.h" />
<ClInclude Include="DiscIO\Enums.h" />
<ClInclude Include="DiscIO\FileBlob.h" />
<ClInclude Include="DiscIO\Filesystem.h" />
@ -1051,7 +1050,6 @@
<ClCompile Include="DiscIO\DiscExtractor.cpp" />
<ClCompile Include="DiscIO\DiscScrubber.cpp" />
<ClCompile Include="DiscIO\DiscUtils.cpp" />
<ClCompile Include="DiscIO\DriveBlob.cpp" />
<ClCompile Include="DiscIO\Enums.cpp" />
<ClCompile Include="DiscIO\FileBlob.cpp" />
<ClCompile Include="DiscIO\Filesystem.cpp" />

2
Source/Core/DolphinQt/MainWindow.cpp
View File

@ -479,8 +479,6 @@ void MainWindow::ConnectMenuBar()
connect(m_menu_bar, &MenuBar::Exit, this, &MainWindow::close);
connect(m_menu_bar, &MenuBar::EjectDisc, this, &MainWindow::EjectDisc);
connect(m_menu_bar, &MenuBar::ChangeDisc, this, &MainWindow::ChangeDisc);
connect(m_menu_bar, &MenuBar::BootDVDBackup, this,
[this](const QString& drive) { StartGame(drive, ScanForSecondDisc::No); });
connect(m_menu_bar, &MenuBar::OpenUserFolder, this, &MainWindow::OpenUserFolder);
// Emulation

15
Source/Core/DolphinQt/MenuBar.cpp
View File

@ -189,19 +189,6 @@ void MenuBar::OnDebugModeToggled(bool enabled)
}
}
void MenuBar::AddDVDBackupMenu(QMenu* file_menu)
{
m_backup_menu = file_menu->addMenu(tr("&Boot from DVD Backup"));
const std::vector<std::string> drives = Common::GetCDDevices();
// Windows Limitation of 24 character drives
for (size_t i = 0; i < drives.size() && i < 24; i++)
{
auto drive = QString::fromStdString(drives[i]);
m_backup_menu->addAction(drive, this, [this, drive] { emit BootDVDBackup(drive); });
}
}
void MenuBar::AddFileMenu()
{
QMenu* file_menu = addMenu(tr("&File"));
@ -212,8 +199,6 @@ void MenuBar::AddFileMenu()
m_change_disc = file_menu->addAction(tr("Change &Disc..."), this, &MenuBar::ChangeDisc);
m_eject_disc = file_menu->addAction(tr("&Eject Disc"), this, &MenuBar::EjectDisc);
AddDVDBackupMenu(file_menu);
file_menu->addSeparator();
m_open_user_folder =

2
Source/Core/DolphinQt/MenuBar.h
View File

@ -54,7 +54,6 @@ signals:
void Open();
void Exit();
void ChangeDisc();
void BootDVDBackup(const QString& backup);
void EjectDisc();
void OpenUserFolder();
@ -127,7 +126,6 @@ private:
void OnEmulationStateChanged(Core::State state);
void AddFileMenu();
void AddDVDBackupMenu(QMenu* file_menu);
void AddEmulationMenu();
void AddStateLoadMenu(QMenu* emu_menu);