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

cdvdgigaherz: Remove unused mode parameter/member variables

This commit is contained in:
Jonathan Li 2018-06-02 10:01:56 +01:00
parent 2b9c368fa8
commit 83ffbc2d3d
3 changed files with 34 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
plugins/cdvdGigaherz/src/CDVD.cpp
View File

@ -110,7 +110,7 @@ bool weAreInNewDiskCB = false;
std::unique_ptr<IOCtlSrc> src; std::unique_ptr<IOCtlSrc> src;
extern CacheRequest g_last_sector_block; extern u32 g_last_sector_block_lsn;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// keepAliveThread throws a read event regularly to prevent drive spin down // // keepAliveThread throws a read event regularly to prevent drive spin down //
@ -127,9 +127,9 @@ void keepAliveThread()
//printf(" * keepAliveThread: polling drive.\n"); //printf(" * keepAliveThread: polling drive.\n");
if (src->GetMediaType() >= 0) if (src->GetMediaType() >= 0)
src->ReadSectors2048(g_last_sector_block.lsn, 1, throwaway); src->ReadSectors2048(g_last_sector_block_lsn, 1, throwaway);
else else
src->ReadSectors2352(g_last_sector_block.lsn, 1, throwaway); src->ReadSectors2352(g_last_sector_block_lsn, 1, throwaway);
} }
printf(" * CDVD: KeepAlive thread finished.\n"); printf(" * CDVD: KeepAlive thread finished.\n");

6
plugins/cdvdGigaherz/src/CDVD.h
View File

@ -47,12 +47,6 @@ extern track tracks[100];
extern int curDiskType; extern int curDiskType;
extern int curTrayStatus; extern int curTrayStatus;
struct CacheRequest
{
u32 lsn;
s32 mode;
};
struct toc_entry struct toc_entry
{ {
u32 lba; u32 lba;

66
plugins/cdvdGigaherz/src/ReadThread.cpp
View File

@ -28,19 +28,18 @@ static_assert(sectors_per_read > 1 && !(sectors_per_read & (sectors_per_read - 1
struct SectorInfo struct SectorInfo
{ {
u32 lsn; u32 lsn;
s32 mode;
// Sectors are read in blocks, not individually // Sectors are read in blocks, not individually
u8 data[2352 * sectors_per_read]; u8 data[2352 * sectors_per_read];
}; };
CacheRequest g_last_sector_block; u32 g_last_sector_block_lsn;
static std::thread s_thread; static std::thread s_thread;
static std::mutex s_notify_lock; static std::mutex s_notify_lock;
static std::condition_variable s_notify_cv; static std::condition_variable s_notify_cv;
static std::mutex s_request_lock; static std::mutex s_request_lock;
static std::queue<CacheRequest> s_request_queue; static std::queue<u32> s_request_queue;
static std::mutex s_cache_lock; static std::mutex s_cache_lock;
static std::atomic<bool> cdvd_is_open; static std::atomic<bool> cdvd_is_open;
@ -51,7 +50,7 @@ static std::atomic<bool> cdvd_is_open;
const u32 CacheSize = 1U << CACHE_SIZE; const u32 CacheSize = 1U << CACHE_SIZE;
SectorInfo Cache[CacheSize]; SectorInfo Cache[CacheSize];
u32 cdvdSectorHash(u32 lsn, s32 mode) u32 cdvdSectorHash(u32 lsn)
{ {
u32 t = 0; u32 t = 0;
@ -64,34 +63,32 @@ u32 cdvdSectorHash(u32 lsn, s32 mode)
i -= CACHE_SIZE; i -= CACHE_SIZE;
} }
return (t ^ mode) & m; return t & m;
} }
void cdvdCacheUpdate(u32 lsn, s32 mode, u8 *data) void cdvdCacheUpdate(u32 lsn, u8 *data)
{ {
std::lock_guard<std::mutex> guard(s_cache_lock); std::lock_guard<std::mutex> guard(s_cache_lock);
u32 entry = cdvdSectorHash(lsn, mode); u32 entry = cdvdSectorHash(lsn);
memcpy(Cache[entry].data, data, 2352 * sectors_per_read); memcpy(Cache[entry].data, data, 2352 * sectors_per_read);
Cache[entry].lsn = lsn; Cache[entry].lsn = lsn;
Cache[entry].mode = mode;
} }
bool cdvdCacheCheck(u32 lsn, s32 mode) bool cdvdCacheCheck(u32 lsn)
{ {
std::lock_guard<std::mutex> guard(s_cache_lock); std::lock_guard<std::mutex> guard(s_cache_lock);
u32 entry = cdvdSectorHash(lsn, mode); u32 entry = cdvdSectorHash(lsn);
return Cache[entry].lsn == lsn && Cache[entry].mode == mode; return Cache[entry].lsn == lsn;
} }
bool cdvdCacheFetch(u32 lsn, s32 mode, u8 *data) bool cdvdCacheFetch(u32 lsn, u8 *data)
{ {
std::lock_guard<std::mutex> guard(s_cache_lock); std::lock_guard<std::mutex> guard(s_cache_lock);
u32 entry = cdvdSectorHash(lsn, mode); u32 entry = cdvdSectorHash(lsn);
if ((Cache[entry].lsn == lsn) && if (Cache[entry].lsn == lsn) {
(Cache[entry].mode == mode)) {
memcpy(data, Cache[entry].data, 2352 * sectors_per_read); memcpy(data, Cache[entry].data, 2352 * sectors_per_read);
return true; return true;
} }
@ -104,11 +101,10 @@ void cdvdCacheReset()
std::lock_guard<std::mutex> guard(s_cache_lock); std::lock_guard<std::mutex> guard(s_cache_lock);
for (u32 i = 0; i < CacheSize; i++) { for (u32 i = 0; i < CacheSize; i++) {
Cache[i].lsn = std::numeric_limits<u32>::max(); Cache[i].lsn = std::numeric_limits<u32>::max();
Cache[i].mode = -1;
} }
} }
bool cdvdReadBlockOfSectors(u32 sector, s32 mode, u8 *data) bool cdvdReadBlockOfSectors(u32 sector, u8 *data)
{ {
u32 count = std::min(sectors_per_read, src->GetSectorCount() - sector); u32 count = std::min(sectors_per_read, src->GetSectorCount() - sector);
const s32 media = src->GetMediaType(); const s32 media = src->GetMediaType();
@ -155,7 +151,7 @@ bool cdvdUpdateDiscStatus()
{ {
std::lock_guard<std::mutex> request_guard(s_request_lock); std::lock_guard<std::mutex> request_guard(s_request_lock);
s_request_queue = std::queue<CacheRequest>(); s_request_queue = decltype(s_request_queue)();
} }
cdvdCallNewDiscCB(); cdvdCallNewDiscCB();
@ -189,12 +185,12 @@ void cdvdThread()
// Read request // Read request
bool handling_request = false; bool handling_request = false;
CacheRequest request; u32 request_lsn;
{ {
std::lock_guard<std::mutex> request_guard(s_request_lock); std::lock_guard<std::mutex> request_guard(s_request_lock);
if (!s_request_queue.empty()) { if (!s_request_queue.empty()) {
request = s_request_queue.front(); request_lsn = s_request_queue.front();
s_request_queue.pop(); s_request_queue.pop();
handling_request = true; handling_request = true;
} }
@ -206,14 +202,14 @@ void cdvdThread()
--prefetches_left; --prefetches_left;
u32 next_prefetch_lsn = g_last_sector_block.lsn + sectors_per_read; u32 next_prefetch_lsn = g_last_sector_block_lsn + sectors_per_read;
request = {next_prefetch_lsn, g_last_sector_block.mode}; request_lsn = next_prefetch_lsn;
} }
// Handle request // Handle request
if (!cdvdCacheCheck(request.lsn, request.mode)) { if (!cdvdCacheCheck(request_lsn)) {
if (cdvdReadBlockOfSectors(request.lsn, request.mode, buffer)) { if (cdvdReadBlockOfSectors(request_lsn, buffer)) {
cdvdCacheUpdate(request.lsn, request.mode, buffer); cdvdCacheUpdate(request_lsn, buffer);
} else { } else {
// If the read fails, further reads are likely to fail too. // If the read fails, further reads are likely to fail too.
prefetches_left = 0; prefetches_left = 0;
@ -221,13 +217,13 @@ void cdvdThread()
} }
} }
g_last_sector_block = request; g_last_sector_block_lsn = request_lsn;
if (!handling_request) if (!handling_request)
continue; continue;
// Prefetch // Prefetch
u32 next_prefetch_lsn = g_last_sector_block.lsn + sectors_per_read; u32 next_prefetch_lsn = g_last_sector_block_lsn + sectors_per_read;
if (next_prefetch_lsn >= src->GetSectorCount()) { if (next_prefetch_lsn >= src->GetSectorCount()) {
prefetches_left = 0; prefetches_left = 0;
} else { } else {
@ -269,12 +265,12 @@ s32 cdvdRequestSector(u32 sector, s32 mode)
// Align to cache block // Align to cache block
sector &= ~(sectors_per_read - 1); sector &= ~(sectors_per_read - 1);
if (cdvdCacheCheck(sector, mode)) if (cdvdCacheCheck(sector))
return 0; return 0;
{ {
std::lock_guard<std::mutex> guard(s_request_lock); std::lock_guard<std::mutex> guard(s_request_lock);
s_request_queue.push({sector, mode}); s_request_queue.push(sector);
} }
s_notify_cv.notify_one(); s_notify_cv.notify_one();
@ -289,9 +285,9 @@ u8 *cdvdGetSector(u32 sector, s32 mode)
// Align to cache block // Align to cache block
u32 sector_block = sector & ~(sectors_per_read - 1); u32 sector_block = sector & ~(sectors_per_read - 1);
if (!cdvdCacheFetch(sector_block, mode, buffer)) if (!cdvdCacheFetch(sector_block, buffer))
if (cdvdReadBlockOfSectors(sector_block, mode, buffer)) if (cdvdReadBlockOfSectors(sector_block, buffer))
cdvdCacheUpdate(sector_block, mode, buffer); cdvdCacheUpdate(sector_block, buffer);
if (src->GetMediaType() >= 0) { if (src->GetMediaType() >= 0) {
u32 offset = 2048 * (sector - sector_block); u32 offset = 2048 * (sector - sector_block);
@ -323,9 +319,9 @@ s32 cdvdDirectReadSector(u32 sector, s32 mode, u8 *buffer)
// Align to cache block // Align to cache block
u32 sector_block = sector & ~(sectors_per_read - 1); u32 sector_block = sector & ~(sectors_per_read - 1);
if (!cdvdCacheFetch(sector_block, mode, data)) { if (!cdvdCacheFetch(sector_block, data)) {
if (cdvdReadBlockOfSectors(sector_block, mode, data)) if (cdvdReadBlockOfSectors(sector_block, data))
cdvdCacheUpdate(sector_block, mode, data); cdvdCacheUpdate(sector_block, data);
} }
if (src->GetMediaType() >= 0) { if (src->GetMediaType() >= 0) {