Emulation/pureikyubu
1
0
Fork 0
mirror of https://github.com/emu-russia/pureikyubu.git synced 2025-04-02 10:42:15 -04:00
Code Issues Projects Releases Packages Wiki Activity
pureikyubu/src/dvd.cpp
ogamespec 1bd24bbd5c warnings
2024-04-19 10:03:36 +03:00

1963 lines
41 KiB
C++
Raw Permalink Blame History

// DVD API for emulator
#include "pch.h"
DVDControl dvd;
using namespace Debug;
namespace DVD
{
// Mount current dvd
bool MountFile(const wchar_t* file)
{
// try to open file
if (!Util::FileExists(file))
{
return false;
}
Unmount();
// select current DVD
bool res = GCMMountFile(file);
if (!res)
return res;
// init filesystem
res = dvd_fs_init();
if (!res)
{
GCMMountFile(nullptr);
return res;
}
Seek(0);
return true;
}
bool MountFile(const std::string& file)
{
wchar_t path[0x1000] = { 0, };
wchar_t* tcharPtr = path;
char* ansiPtr = (char *)file.c_str();
while (*ansiPtr)
{
*tcharPtr++ = *ansiPtr++;
}
*tcharPtr++ = 0;
return MountFile(path);
}
bool MountFile(const std::wstring& file)
{
wchar_t path[0x1000] = { 0, };
wchar_t* tcharPtr = path;
wchar_t* widePtr = (wchar_t*)file.c_str();
while (*widePtr)
{
*tcharPtr++ = *widePtr++;
}
*tcharPtr++ = 0;
return MountFile(path);
}
bool MountSdk(const wchar_t* path)
{
Unmount();
dvd.mountedSdk = new MountDolphinSdk(path);
if (!dvd.mountedSdk->Mounted())
{
delete dvd.mountedSdk;
dvd.mountedSdk = nullptr;
return false;
}
// init filesystem
if (!dvd_fs_init())
{
delete dvd.mountedSdk;
dvd.mountedSdk = nullptr;
return false;
}
dvd.mountedSdk->Seek(0);
return true;
}
bool MountSdk(std::string path)
{
wchar_t tcharStr[0x1000] = { 0, };
wchar_t* tcharPtr = tcharStr;
char* ansiPtr = (char*)path.c_str();
while (*ansiPtr)
{
*tcharPtr++ = *ansiPtr++;
}
*tcharPtr++ = 0;
return MountSdk(tcharStr);
}
// Unmount
void Unmount()
{
GCMMountFile(nullptr);
if (dvd.mountedSdk)
{
delete dvd.mountedSdk;
dvd.mountedSdk = nullptr;
}
dvd_fs_shutdown();
}
bool IsMounted()
{
return (dvd.mountedImage || dvd.mountedSdk != nullptr);
}
// dvd operations on current mounted dvd
void Seek(int position)
{
if (dvd.mountedImage)
{
GCMSeek(position);
}
else if (dvd.mountedSdk)
{
dvd.mountedSdk->Seek(position);
}
}
int GetSeek()
{
if (dvd.mountedImage)
{
return dvd.seekval;
}
else if (dvd.mountedSdk)
{
return dvd.mountedSdk->GetSeek();
}
else return 0;
}
bool Read(void *buffer, size_t length)
{
if (length == 0)
return true;
if (dvd.mountedImage)
{
return GCMRead((uint8_t*)buffer, length);
}
else if (dvd.mountedSdk)
{
return dvd.mountedSdk->Read((uint8_t*)buffer, length);
}
else
{
memset(buffer, 0, length); // fill by zeroes
}
return true;
}
long OpenFile(std::string& dvdfile)
{
if (dvd.mountedImage || dvd.mountedSdk)
{
// call DVD filesystem open
return dvd_open(dvdfile.data());
}
// Not mounted
return 0;
}
// Call somewhere
void InitSubsystem()
{
JDI::Hub.AddNode(DDU_JDI_JSON, DvdCommandsReflector);
DDU = new DduCore;
}
void ShutdownSubsystem()
{
Unmount();
JDI::Hub.RemoveNode(DDU_JDI_JSON);
delete DDU;
}
}
/*
Code for mounting the Dolphin SDK folder as a virtual disk.
All the necessary data (BI2, Appldr, some DOL executable, we take from the SDK). If they are not there, then the disk is simply not mounted.
*/
namespace DVD
{
MountDolphinSdk::MountDolphinSdk(const wchar_t* DolphinSDKPath)
{
wcscpy(directory, DolphinSDKPath);
// Load dvddata structure.
// TODO: Generate Json dynamically
auto dvdDataInfoText = Util::FileLoad(DvdDataJson);
if (dvdDataInfoText.empty())
{
Report(Channel::Norm, "Failed to load DolphinSDK dvddata json: %s\n", Util::WstringToString(DvdDataJson).c_str());
return;
}
try
{
DvdDataInfo.Deserialize(dvdDataInfoText.data(), dvdDataInfoText.size());
}
catch (...)
{
Report(Channel::Norm, "Failed to Deserialize DolphinSDK dvddata json: %s\n", Util::WstringToString(DvdDataJson).c_str());
return;
}
// Generate data blobs
if (!GenDiskId())
{
Report(Channel::Norm, "Failed to GenDiskId\n");
return;
}
if (!GenApploader())
{
Report(Channel::Norm, "Failed to GenApploader\n");
return;
}
if (!GenBi2())
{
Report(Channel::Norm, "Failed to GenBi2\n");
return;
}
if (!GenFst())
{
Report(Channel::Norm, "Failed to GenFst\n");
return;
}
if (!GenDol())
{
Report(Channel::Norm, "Failed to GenDol\n");
return;
}
if (!GenBb2())
{
Report(Channel::Norm, "Failed to GenBb2\n");
return;
}
// Generate mapping
if (!GenMap())
{
Report(Channel::Norm, "Failed to GenMap\n");
return;
}
if (!GenFileMap())
{
Report(Channel::Norm, "Failed to GenFileMap\n");
return;
}
Report(Channel::DVD, "DolphinSDK mounted!\n");
mounted = true;
}
MountDolphinSdk::~MountDolphinSdk()
{
}
void MountDolphinSdk::MapVector(std::vector<uint8_t>& v, uint32_t offset)
{
std::tuple<std::vector<uint8_t>&, uint32_t, size_t> entry(v, offset, v.size());
mapping.push_back(entry);
}
void MountDolphinSdk::MapFile(wchar_t* path, uint32_t offset)
{
size_t size = Util::FileSize(path);
std::tuple<wchar_t*, uint32_t, size_t> entry(path, offset, size);
fileMapping.push_back(entry);
}
// Check memory mapping
uint8_t* MountDolphinSdk::TranslateMemory(uint32_t offset, size_t requestedSize, size_t& maxSize)
{
for (auto it = mapping.begin(); it != mapping.end(); ++it)
{
uint8_t* ptr = std::get<0>(*it).data();
uint32_t startingOffset = std::get<1>(*it);
size_t size = std::get<2>(*it);
if (startingOffset <= offset && offset < (startingOffset + size))
{
maxSize = my_min(requestedSize, (startingOffset + size) - offset);
return ptr + (offset - startingOffset);
}
}
return nullptr;
}
// Check file mapping
FILE* MountDolphinSdk::TranslateFile(uint32_t offset, size_t requestedSize, size_t& maxSize)
{
for (auto it = fileMapping.begin(); it != fileMapping.end(); ++it)
{
wchar_t* file = std::get<0>(*it);
uint32_t startingOffset = std::get<1>(*it);
size_t size = std::get<2>(*it);
if (startingOffset <= offset && offset < (startingOffset + size))
{
maxSize = my_min(requestedSize, (startingOffset + size) - offset);
FILE* f;
f = fopen(Util::WstringToString(file).c_str(), "rb");
assert(f);
fseek(f, offset - startingOffset, SEEK_SET);
return f;
}
}
return nullptr;
}
void MountDolphinSdk::Seek(int position)
{
if (!mounted)
return;
assert(position >= 0 && position < DVD_SIZE);
currentSeek = (uint32_t)position;
}
bool MountDolphinSdk::Read(void* buffer, size_t length)
{
bool result = true;
assert(buffer);
if (!mounted)
{
memset(buffer, 0, length);
return true;
}
if (currentSeek >= DVD_SIZE)
{
memset(buffer, 0, length);
return false;
}
size_t maxLength = 0;
// First, try to enter the mapped binary blob, if it doesn't work, try the mapped file.
uint8_t* ptr = TranslateMemory(currentSeek, length, maxLength);
if (ptr != nullptr)
{
memcpy(buffer, ptr, maxLength);
if (maxLength < length)
{
memset((uint8_t*)buffer + maxLength, 0, length - maxLength);
}
}
else
{
FILE* f = TranslateFile(currentSeek, length, maxLength);
if (f != nullptr)
{
fread(buffer, 1, maxLength, f);
if (maxLength < length)
{
memset((uint8_t*)buffer + maxLength, 0, length - maxLength);
}
fclose(f);
}
else
{
// None of the options came up - return zeros.
memset(buffer, 0, length);
result = false;
}
}
currentSeek += (uint32_t)length;
return result;
}
#pragma region "Data Generators"
// In addition to the actual files, the DVD image also contains a number of important binary data: DiskID, Apploader image, main program (DOL), BootInfo2 and BootBlock2 structures and FST.
// Generating almost all blobs is straightforward, with the exception of the FST, which will have to tinker with.
bool MountDolphinSdk::GenDiskId()
{
DiskId.resize(sizeof(DiskID));
DiskID* id = (DiskID*)DiskId.data();
id->gameName[0] = 'S';
id->gameName[1] = 'D';
id->gameName[2] = 'K';
id->gameName[3] = 'E';
id->company[0] = '0';
id->company[1] = '1';
id->magicNumber = _BYTESWAP_UINT32(DVD_DISKID_MAGIC);
GameName.resize(0x400);
memset(GameName.data(), 0, GameName.size());
strcpy((char*)GameName.data(), "GameCube SDK");
return true;
}
bool MountDolphinSdk::GenApploader()
{
AppldrData = Util::FileLoad(std::wstring(directory) + std::wstring(AppldrPath));
return true;
}
/// <summary>
/// Unfortunately, all demos in the SDK are in ELF format. Therefore, we will use PONG.DOL as the main program, which is included in each release and is a full resident of the project :p
/// </summary>
/// <returns></returns>
bool MountDolphinSdk::GenDol()
{
Dol = Util::FileLoad(DolPath);
return true;
}
bool MountDolphinSdk::GenBi2()
{
Bi2Data = Util::FileLoad(std::wstring(directory) + std::wstring(Bi2Path));
return true;
}
/// <summary>
/// Add a string with the name of the entry (directory or file name) to the NameTable.
/// </summary>
/// <param name="str"></param>
void MountDolphinSdk::AddString(std::string str)
{
for (auto& c : str)
{
NameTableData.push_back(c);
}
NameTableData.push_back(0);
}
/// <summary>
/// Process original Json with dvddata directory structure. The Json structure is designed to accommodate the weird FST feature when a directory is in the middle of files.
/// For a more detailed description of this oddity, see `dolwin-docs\RE\DVD\FSTNotes.md`.
/// The method is recursive tree descent.
/// In the process, meta information is added to the original Json structure, which is used by the `WalkAndGenerateFst` method to create the final binary FST blob.
/// </summary>
/// <param name="entry"></param>
void MountDolphinSdk::ParseDvdDataEntryForFst(Json::Value* entry)
{
Json::Value* parent = nullptr;
if (entry->type != Json::ValueType::Object)
{
return;
}
if (entry->children.size() != 0)
{
// Directory
// Save directory name offset
size_t nameOffset = NameTableData.size();
if (entry->name)
{
// Root has no name
AddString(entry->name);
}
entry->AddInt("nameOffset", (int)nameOffset);
entry->AddBool("dir", true);
// Save current FST index for directory
entry->AddInt("entryId", entryCounter);
entryCounter++;
// Reset totalChildren counter
entry->AddInt("totalChildren", 0);
}
else
{
// File.
// Differs from a directory in that it has no descendants
assert(entry->name);
std::string path = entry->name;
size_t nameOffset = NameTableData.size();
AddString(path);
parent = entry->parent;
// Save file name offset
entry->AddInt("nameOffset", (int)nameOffset);
// Generate full path to file
do
{
if (parent->ByName("dir"))
{
path = (parent->name ? parent->name + std::string("/") : "/") + path;
}
parent = parent->parent;
} while (parent != nullptr);
assert(path.size() < DVD_MAXPATH);
wchar_t filePath[0x1000] = { 0, };
wcscat(filePath, directory);
wcscat(filePath, FilesRoot);
wchar_t* filePathPtr = filePath + wcslen(filePath);
for (size_t i = 0; i < path.size(); i++)
{
*filePathPtr++ = (wchar_t)path[i];
}
*filePathPtr++ = 0;
//Report(Channel::Norm, "Processing file: %s\n", path.c_str());
// Save file offset
entry->AddInt("fileOffset", userFilesStart + userFilesOffset);
// Save file size
size_t fileSize = Util::FileSize(filePath);
entry->AddInt("fileSize", (int)fileSize);
userFilesOffset += RoundUp32((uint32_t)fileSize);
// Save file path
entry->AddString("filePath", filePath);
// Adjust entry counter
entry->AddInt("entryId", entryCounter);
entryCounter++;
}
// Update parent sibling counters
parent = entry->parent;
while (parent)
{
Json::Value* totalChildren = parent->ByName("totalChildren");
if (totalChildren) totalChildren->value.AsInt++;
parent = parent->parent; // :p
}
// Recursively process descendants
if (entry->ByName("dir") != nullptr)
{
for (auto it = entry->children.begin(); it != entry->children.end(); ++it)
{
ParseDvdDataEntryForFst(*it);
}
}
}
/// <summary>
/// Based on the Json structure with the data of the dvddata directory tree, in which meta-information is added, the final FST binary blob is built.
/// </summary>
/// <param name="entry"></param>
void MountDolphinSdk::WalkAndGenerateFst(Json::Value* entry)
{
DVDFileEntry fstEntry = { 0 };
if (entry->type != Json::ValueType::Object)
{
return;
}
Json::Value* isDir = entry->ByName("dir");
if (isDir)
{
// Directory
fstEntry.isDir = 1;
Json::Value* nameOffset = entry->ByName("nameOffset");
assert(nameOffset);
if (nameOffset)
{
fstEntry.nameOffsetHi = (uint8_t)(nameOffset->value.AsInt >> 16);
fstEntry.nameOffsetLo = _BYTESWAP_UINT16((uint16_t)nameOffset->value.AsInt);
}
if (entry->parent)
{
Json::Value* parentId = entry->parent->ByName("entryId");
if (parentId)
{
fstEntry.parentOffset = _BYTESWAP_UINT32((uint32_t)parentId->value.AsInt);
}
}
Json::Value* entryId = entry->ByName("entryId");
Json::Value* totalChildren = entry->ByName("totalChildren");
if (entryId && totalChildren)
{
fstEntry.nextOffset = _BYTESWAP_UINT32((uint32_t)(entryId->value.AsInt + totalChildren->value.AsInt) + 1);
}
FstData.insert(FstData.end(), (uint8_t*)&fstEntry, (uint8_t*)&fstEntry + sizeof(fstEntry));
if (logMount)
{
Report(Channel::Norm, "%d: directory: %s. nextOffset: %d\n",
entryId->value.AsInt, entry->name, _BYTESWAP_UINT32(fstEntry.nextOffset));
}
for (auto it = entry->children.begin(); it != entry->children.end(); ++it)
{
WalkAndGenerateFst(*it);
}
}
else
{
// File
Json::Value* entryId = entry->ByName("entryId");
Json::Value* nameOffsetValue = entry->ByName("nameOffset");
Json::Value* fileOffsetValue = entry->ByName("fileOffset");
Json::Value* fileSizeValue = entry->ByName("fileSize");
assert(nameOffsetValue && fileOffsetValue && fileSizeValue);
fstEntry.isDir = 0;
uint32_t nameOffset = (uint32_t)(nameOffsetValue->value.AsInt);
uint32_t fileOffset = (uint32_t)(fileOffsetValue->value.AsInt);
uint32_t fileSize = (uint32_t)(fileSizeValue->value.AsInt);
fstEntry.nameOffsetHi = (uint8_t)(nameOffset >> 16);
fstEntry.nameOffsetLo = _BYTESWAP_UINT16((uint16_t)nameOffset);
fstEntry.fileOffset = _BYTESWAP_UINT32(fileOffset);
fstEntry.fileLength = _BYTESWAP_UINT32(fileSize);
FstData.insert(FstData.end(), (uint8_t*)&fstEntry, (uint8_t*)&fstEntry + sizeof(fstEntry));
if (logMount)
{
Report(Channel::Norm, "%d: file: %s\n", entryId->value.AsInt, entry->name);
}
}
}
// The basic idea behind generating FST is to walk by DvdDataJson.
// When traversing a structure a specific meta-information is attached to each node.
// After generation, this meta-information is collected in a final collection (FST).
bool MountDolphinSdk::GenFst()
{
try
{
ParseDvdDataEntryForFst(DvdDataInfo.root.children.back());
}
catch (...)
{
Report(Channel::Norm, "ParseDvdDataEntryForFst failed!\n");
return false;
}
if (logMount)
{
JDI::Hub.Dump(DvdDataInfo.root.children.back());
}
try
{
WalkAndGenerateFst(DvdDataInfo.root.children.back());
}
catch (...)
{
Report(Channel::Norm, "WalkAndGenerateFst failed!\n");
return false;
}
// Add Name Table to the end
FstData.insert(FstData.end(), NameTableData.begin(), NameTableData.end());
Util::FileSave(L"Data/DolphinSdkFST.bin", FstData);
return true;
}
bool MountDolphinSdk::GenBb2()
{
DVDBB2 bb2 = { 0 };
bb2.bootFilePosition = RoundUpSector(DVD_APPLDR_OFFSET + (uint32_t)AppldrData.size());
bb2.FSTLength = (uint32_t)FstData.size();
bb2.FSTMaxLength = bb2.FSTLength;
bb2.FSTPosition = RoundUpSector(bb2.bootFilePosition + (uint32_t)Dol.size() + DVD_SECTOR_SIZE);
bb2.userPosition = 0x80030000; // Ignored
bb2.userLength = RoundUpSector(bb2.FSTLength);
Bb2Data.resize(sizeof(DVDBB2));
memcpy(Bb2Data.data(), &bb2, sizeof(bb2));
return true;
}
bool MountDolphinSdk::GenMap()
{
MapVector(DiskId, DVD_ID_OFFSET);
MapVector(GameName, sizeof(DiskID));
MapVector(Bb2Data, DVD_BB2_OFFSET);
MapVector(Bi2Data, DVD_BI2_OFFSET);
MapVector(AppldrData, DVD_APPLDR_OFFSET);
DVDBB2* bb2 = (DVDBB2*)Bb2Data.data();
MapVector(Dol, bb2->bootFilePosition);
MapVector(FstData, bb2->FSTPosition);
SwapArea(bb2, sizeof(DVDBB2));
return true;
}
void MountDolphinSdk::WalkAndMapFiles(Json::Value* entry)
{
if (entry->type != Json::ValueType::Object)
{
return;
}
Json::Value* isDir = entry->ByName("dir");
if (!isDir)
{
Json::Value* filePath = entry->ByName("filePath");
Json::Value* fileOffset = entry->ByName("fileOffset");
assert(filePath && fileOffset);
MapFile(filePath->value.AsString, (uint32_t)(fileOffset->value.AsInt));
}
else
{
for (auto it = entry->children.begin(); it != entry->children.end(); ++it)
{
WalkAndMapFiles(*it);
}
}
}
bool MountDolphinSdk::GenFileMap()
{
userFilesOffset = 0;
try
{
WalkAndMapFiles(DvdDataInfo.root.children.back());
}
catch (...)
{
Report(Channel::Norm, "WalkAndMapFiles failed!\n");
return false;
}
return true;
}
void MountDolphinSdk::SwapArea(void* _addr, int sizeInBytes)
{
uint32_t* addr = (uint32_t*)_addr;
uint32_t* until = addr + sizeInBytes / sizeof(uint32_t);
while (addr != until)
{
*addr = _BYTESWAP_UINT32(*addr);
addr++;
}
}
#pragma endregion "Data Generators"
}
// Disk region detection
namespace DVD
{
// Get region by DiskID (not a very reliable method)
Region RegionById(const char* DiskId)
{
switch (DiskId[3])
{
case 'P':
case 'Y':
return Region::EUR;
case 'D':
return Region::NOE;
case 'F':
return Region::FRA;
case 'S':
return Region::ESP;
case 'I':
return Region::ITA;
case 'X':
case 'K':
return Region::FAH;
case 'H':
return Region::HOL;
case 'U':
return Region::AUS;
case 'J':
return Region::JPN;
case 'E':
return Region::USA;
case 'W':
return Region::KOR;
}
return Region::Unknown;
}
// Check that the region is NTSC-like
bool IsNtsc(Region region)
{
switch (region)
{
case Region::JPN:
case Region::USA:
case Region::KOR:
return true;
}
return false;
}
}
// DVD filesystem access.
// local data
static DVDBB2 bb2;
static DVDFileEntry* FstStart; // Loaded FST (byte-swapped as little-endian)
static uint32_t fstSize; // Size of loaded FST in bytes (not greater DVD_FST_MAX_SIZE)
static char* FstStringStart; // Strings(name) table
#define FSTOFS(lo, hi) (((uint32_t)hi << 16) | lo)
// Swap longs (no need in assembly, used by tools)
static void SwapArea(uint32_t* addr, int count)
{
uint32_t* until = addr + count / sizeof(uint32_t);
while (addr != until)
{
*addr = _BYTESWAP_UINT32(*addr);
addr++;
}
}
// swap bytes in FST (little-endian)
// return beginning of strings table (or NULL, if bad FST)
static char *fst_prepare(DVDFileEntry *root)
{
char* nameTablePtr = nullptr;
root->nameOffsetLo = _BYTESWAP_UINT16(root->nameOffsetLo);
root->fileOffset = _BYTESWAP_UINT32(root->fileOffset);
root->fileLength = _BYTESWAP_UINT32(root->fileLength);
// Check root: must have no parent, has zero nameOfset and non-zero nextOffset.
if (! ( root->isDir &&
root->parentOffset == 0 &&
FSTOFS(root->nameOffsetLo, root->nameOffsetHi) == 0 &&
root->nextOffset != 0 ) )
{
return nullptr;
}
nameTablePtr = (char*)&root[root->nextOffset];
// Starting from next after root
for (uint32_t i = 1; i < root->nextOffset; i++)
{
DVDFileEntry* entry = &root[i];
entry->nameOffsetLo = _BYTESWAP_UINT16(entry->nameOffsetLo);
entry->fileOffset = _BYTESWAP_UINT32(entry->fileOffset);
entry->fileLength = _BYTESWAP_UINT32(entry->fileLength);
}
return nameTablePtr;
}
// initialize filesystem
bool dvd_fs_init()
{
// Check DiskID
char diskId[5] = { 0 };
DVD::Seek(DVD_ID_OFFSET);
DVD::Read(diskId, 4);
for (int i = 0; i < 4; i++)
{
if (!isalnum(diskId[i]))
{
return false;
}
}
// Check Apploader
char apploaderBytes[5] = { 0 };
DVD::Seek(DVD_APPLDR_OFFSET);
DVD::Read(apploaderBytes, 4);
for (int i = 0; i < 4; i++)
{
if (!isdigit(apploaderBytes[i]))
{
return false;
}
}
// load tables
DVD::Seek(DVD_BB2_OFFSET);
DVD::Read(&bb2, sizeof(DVDBB2));
SwapArea((uint32_t *)&bb2, sizeof(DVDBB2));
// delete previous FST
if(FstStart)
{
free(FstStart);
FstStart = NULL;
fstSize = 0;
}
// create new FST
fstSize = bb2.FSTLength;
if(fstSize > DVD_FST_MAX_SIZE)
{
return false;
}
FstStart = (DVDFileEntry *)malloc(fstSize);
if(FstStart == NULL)
{
return false;
}
DVD::Seek(bb2.FSTPosition);
DVD::Read(FstStart, fstSize);
// swap bytes in FST and find offset of string table
FstStringStart = fst_prepare(FstStart);
if(!FstStringStart)
{
free(FstStart);
FstStart = NULL;
return false;
}
// FST loaded ok
return true;
}
void dvd_fs_shutdown()
{
if (FstStart)
{
free(FstStart);
FstStart = NULL;
fstSize = 0;
}
}
// Based on reversing of original method.
// <0: Bad path
static int DVDConvertPathToEntrynum(const char* _path)
{
char* path = (char *)_path;
// currentDirectory assigned by DVDChangeDir
int entry = 0; // running entry
// Loop1
while (true)
{
if (path[0] == 0)
return entry;
// Current/parent directory walk
if (path[0] == '/')
{
entry = 0; // root
path++;
continue; // Loop1
}
if (path[0] == '.')
{
if (path[1] == '.')
{
if (path[2] == '/')
{
entry = FstStart[entry].parentOffset;
path += 3;
continue; // Loop1
}
if (path[2] == 0)
{
return FstStart[entry].parentOffset;
}
}
else
{
if (path[1] == '/')
{
path += 2;
continue; // Loop1
}
if (path[1] == 0)
{
return entry;
}
}
}
// Get a pointer to the end of a file or directory name (the end is 0 or /)
char* endPathPtr;
if (true)
{
endPathPtr = path;
while (!(endPathPtr[0] == 0 || endPathPtr[0] == '/'))
{
endPathPtr++;
}
}
// if-else Block 2
bool afterNameCharNZ = endPathPtr[0] != 0; // after-name character != 0
int prevEntry = entry; // Save previous entry
size_t nameSize = endPathPtr - path; // path element nameSize
entry++; // Increment entry
// Loop2
while (true)
{
if ((int)FstStart[prevEntry].nextOffset <= entry) // Walk forward only
return -1; // Bad FST
// Loop2 - Group 1 -- Compare names
if (FstStart[entry].isDir || afterNameCharNZ == false /* after-name is 0 */)
{
char* r21 = path; // r21 -- current pathPtr to inner loop
int nameOffset = (FstStart[entry].nameOffsetHi << 16) | FstStart[entry].nameOffsetLo;
char* r20 = &FstStringStart[nameOffset & 0xFFFFFF]; // r20 -- ptr to current entry name
bool same;
while (true)
{
if (*r20 == 0)
{
same = (*r21 == '/' || *r21 == 0);
break;
}
if (_tolower(*r20++) != _tolower(*r21++))
{
same = false;
break;
}
}
if (same)
{
if (afterNameCharNZ == false)
return entry;
path += nameSize + 1;
break; // break Loop2
}
}
// Walk next directory/file at same level
entry = FstStart[entry].isDir ? FstStart[entry].nextOffset : (entry + 1);
} // Loop2
} // Loop1
}
// convert DVD file name into file position on the disk
// 0, if file not found
int dvd_open(const char *path)
{
int entry = DVDConvertPathToEntrynum(path);
if (entry < 0)
{
return 0;
}
return (int)FstStart[entry].fileOffset;
}
// simple GCM image reading.
bool GCMMountFile(const wchar_t*file)
{
FILE* gcm_file;
dvd.gcm_filename[0] = 0;
dvd.mountedImage = false;
if (file == nullptr)
{
return true;
}
// open GCM file
gcm_file = fopen(Util::WstringToString(file).c_str(), "rb");
if(!gcm_file) return false;
// get file size
fseek(gcm_file, 0, SEEK_END);
dvd.gcm_size = ftell(gcm_file);
fseek(gcm_file, 0, SEEK_SET);
fclose(gcm_file);
// protect from damaged GCMs
if(dvd.gcm_size < DVD_APPLDR_OFFSET)
{
return false;
}
// reset position
dvd.seekval = 0;
wcscpy(dvd.gcm_filename, file);
dvd.mountedImage = true;
return true;
}
void GCMSeek(int position)
{
dvd.seekval = position;
}
bool GCMRead(uint8_t*buf, size_t length)
{
FILE* gcm_file;
if (dvd.gcm_filename[0] == 0)
{
memset(buf, 0, length); // fill by zeroes
return true;
}
gcm_file = fopen ( Util::WstringToString(dvd.gcm_filename).c_str(), "rb");
if(gcm_file)
{
// out of DVD
if(dvd.seekval >= DVD_SIZE)
{
memset(buf, 0, length); // fill by zeroes
dvd.seekval += (int)length;
fclose(gcm_file);
return false;
}
// GCM files can be less than 1.4 GB,
// so just return zeroes, when seek is out of file
if(dvd.seekval >= dvd.gcm_size)
{
memset(buf, 0, length); // fill by zeroes
dvd.seekval += (int)length;
fclose(gcm_file);
return true;
}
// wrap, if seek is near to out of DVD
if( (dvd.seekval + length) >= DVD_SIZE)
{
length = DVD_SIZE - dvd.seekval;
}
// wrap, if seek is near to out of file
if( (dvd.seekval + length) >= dvd.gcm_size)
{
length = dvd.gcm_size - dvd.seekval;
}
// read data
if(length)
{
fseek(gcm_file, dvd.seekval, SEEK_SET);
// https://stackoverflow.com/questions/295994/what-is-the-rationale-for-fread-fwrite-taking-size-and-count-as-arguments
size_t bytesRead = fread(buf, 1, length, gcm_file);
fclose(gcm_file);
dvd.seekval += (int)length;
return (bytesRead == length);
}
}
else
{
memset(buf, 0, length); // fill by zeroes
return false;
}
return true;
}
int32_t YnLeft[2], YnRight[2];
typedef int Nibble;
void DvdAudioInitDecoder()
{
YnLeft[0] = YnLeft[1] = 0;
YnRight[0] = YnRight[1] = 0;
}
int32_t MulSomething(Nibble arg_0, int32_t yn1, int32_t yn2)
{
int16_t a1 = 0;
int16_t a2 = 0;
switch (arg_0)
{
case 0:
a1 = 0;
a2 = 0;
break;
case 1:
a1 = 60;
a2 = 0;
break;
case 2:
a1 = 115;
a2 = -52;
break;
case 3:
a1 = 98;
a2 = -55;
break;
}
int32_t ps1 = (int32_t)a1 * yn1;
int32_t ps2 = (int32_t)a2 * yn2;
int32_t var_C = (ps1 + ps2 + 32) >> 6;
return my_max(-0x200000, my_min(var_C, 0x1FFFFF) );
}
int16_t Shifts1(Nibble arg_0, Nibble arg_4)
{
int16_t var_4 = (int16_t)arg_0 << 12;
return var_4 >> arg_4;
}
int32_t Shifts2(int16_t arg_0, int32_t arg_4)
{
return ((int32_t)arg_0 << 6) + arg_4;
}
// Clamp
uint16_t Clamp(int32_t arg_0)
{
int32_t var_8 = arg_0 >> 6;
return (uint16_t)my_max(-0x8000, my_min(var_8, 0x7FFF));
}
uint16_t DecodeSample(Nibble arg_0, uint8_t arg_4, int Yn[2])
{
uint16_t res;
Nibble var_4 = arg_4 >> 4;
Nibble var_8 = arg_4 & 0xF;
int32_t var_18 = MulSomething(var_4, Yn[0], Yn[1]);
int16_t var_C = Shifts1(arg_0, var_8);
int32_t var_14 = Shifts2(var_C, var_18);
res = Clamp(var_14);
Yn[1] = Yn[0];
Yn[0] = var_14;
return res;
}
void DvdAudioDecode(uint8_t adpcmBuffer[32], uint16_t pcmBuffer[2 * 28])
{
uint8_t* adpcmData = &adpcmBuffer[4];
if (!(adpcmBuffer[0] == adpcmBuffer[2] && adpcmBuffer[1] == adpcmBuffer[3]))
{
memset(pcmBuffer, 0, 2 * 28 * sizeof(uint16_t));
return;
}
for (int i = 0; i < 28; i++)
{
pcmBuffer[2 * i] = DecodeSample(adpcmData[i] & 0xF, adpcmBuffer[0], YnLeft);
pcmBuffer[2 * i + 1] = DecodeSample(adpcmData[i] >> 4, adpcmBuffer[1], YnRight);
}
}
namespace DVD
{
DduCore * DDU;
DduCore::DduCore()
{
dduThread = EMUCreateThread(DduThreadProc, true, this, "DvdData");
dvdAudioThread = EMUCreateThread(DvdAudioThreadProc, true, this, "DvdAudio");
dataCache = new uint8_t[dataCacheSize];
memset(dataCache, 0, dataCacheSize);
streamingCache = new uint8_t[streamCacheSize];
memset(streamingCache, 0, streamCacheSize);
Reset();
if (adpcmStreamDump)
{
adpcmStreamFile = fopen("Data\\DvdAdpcm.bin", "wb");
}
if (decodedStreamDump)
{
decodedStreamFile = fopen("Data\\DvdDecodedPcm.bin", "wb");
}
}
DduCore::~DduCore()
{
if (adpcmStreamFile)
{
fclose(adpcmStreamFile);
}
if (decodedStreamFile)
{
fclose(decodedStreamFile);
}
TransferComplete();
EMUJoinThread(dduThread);
EMUJoinThread(dvdAudioThread);
delete[] dataCache;
delete[] streamingCache;
}
void DduCore::ExecuteCommand()
{
// Execute command
errorState = false;
errorCode = 0;
if (logCommands)
{
Report(Channel::DVD, "Command: %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X\n",
commandBuffer[0], commandBuffer[1], commandBuffer[2], commandBuffer[3],
commandBuffer[4], commandBuffer[5], commandBuffer[6], commandBuffer[7],
commandBuffer[8], commandBuffer[9], commandBuffer[10], commandBuffer[11]);
}
switch (commandBuffer[0])
{
// Inquiry (DVDLowInquiry), read manufacture info (DMA)
case 0x12:
state = DduThreadState::ReadBogusData;
if (log)
{
Report(Channel::DVD, "DVD Inquiry.\n");
}
break;
// read sector / disk id
case 0xA8:
state = DduThreadState::ReadDvdData;
{
uint32_t seekTemp = (commandBuffer[4] << 24) |
(commandBuffer[5] << 16) |
(commandBuffer[6] << 8) |
(commandBuffer[7]);
seekVal = seekTemp << 2;
// Use transaction size as hint for pre-caching
if (commandBuffer[3] == 0x40)
{
transactionSize = sizeof(DiskID);
}
else
{
transactionSize = (commandBuffer[8] << 24) |
(commandBuffer[9] << 16) |
(commandBuffer[10] << 8) |
(commandBuffer[11]);
}
}
// Invalidate reading cache
dataCachePtr = dataCacheSize;
if (log)
{
Report(Channel::DVD, "DVD Read: 0x%08X, %i bytes\n", seekVal, transactionSize);
}
break;
// seek (DVDLowSeek) (IMM)
case 0xAB:
state = DduThreadState::ReadBogusData;
{
uint32_t seekTemp = (commandBuffer[4] << 24) |
(commandBuffer[5] << 16) |
(commandBuffer[6] << 8) |
(commandBuffer[7]);
if (log)
{
Report(Channel::DVD, "Seek: 0x%08X (ignored)\n", seekTemp << 2);
}
}
break;
// Request Error (DVDLowRequestError) (IMM)
case 0xE0:
state = DduThreadState::ReadBogusData;
if (log)
{
Report(Channel::DVD, "Request Error\n");
}
break;
// set stream (DVDLowAudioStream) (IMM)
case 0xE1:
state = DduThreadState::ReadBogusData;
{
uint32_t seekTemp = (commandBuffer[4] << 24) |
(commandBuffer[5] << 16) |
(commandBuffer[6] << 8) |
(commandBuffer[7]);
// The SDK first sets the address of the stream, and then for some reason resets it to 0.
// We make the assumption that the value 0 should be ignored.
if (seekTemp != 0)
{
streamSeekVal = seekTemp << 2;
streamCount = (commandBuffer[8] << 24) |
(commandBuffer[9] << 16) |
(commandBuffer[10] << 8) |
(commandBuffer[11]);
SetDvdAudioSampleRate(sampleRate);
DvdAudioInitDecoder();
streamEnabledByDduCommand = true;
// Invalidate streaming cache
streamingCachePtr = streamCacheSize;
// Invalidate PCM buffer
pcmPlaybackCounter = sizeof(pcmPlaybackBuffer);
if (log)
{
Report(Channel::DVD, "DVD Streaming setup: stream start 0x%08X, counter: %i\n",
streamSeekVal, streamCount);
}
}
else
{
DvdAudioInitDecoder();
if (log)
{
Report(Channel::DVD, "DVD Bogus Streaming setup (ignored)\n");
}
}
}
break;
// get stream status (DVDLowRequestAudioStatus) (IMM)
case 0xE2:
switch (commandBuffer[1])
{
case 0: // Get stream enable
state = DduThreadState::GetStreamEnable;
immediateBuffer[0] = 0;
immediateBuffer[1] = 0;
immediateBuffer[2] = 0;
immediateBuffer[3] = streamEnabledByDduCommand ? 1 : 0;
immediateBufferPtr = 0;
break;
case 1: // Get stream address
state = DduThreadState::GetStreamOffset;
{
uint32_t seekTemp = streamSeekVal >> 2;
immediateBuffer[0] = (seekTemp >> 24) & 0xff;
immediateBuffer[1] = (seekTemp >> 16) & 0xff;
immediateBuffer[2] = (seekTemp >> 8) & 0xff;
immediateBuffer[3] = (seekTemp) & 0xff;
}
immediateBufferPtr = 0;
break;
default:
state = DduThreadState::GetStreamBogus;
Report(Channel::DVD, "Unknown GetStreamStatus: %i\n", commandBuffer[1]);
break;
}
break;
// stop motor (DVDLowStopMotor) (IMM)
case 0xE3:
state = DduThreadState::ReadBogusData;
if (log)
{
Report(Channel::DVD, "Stop motor.\n");
}
break;
// Set Audio Buffer (DVDLowAudioBufferConfig) (IMM)
// It looks like it's setting up a FIFO buffer that stores decoded PCM samples of the next 32 Bytes ADPCM chunk.
case 0xE4:
state = DduThreadState::ReadBogusData;
if (log)
{
Report(Channel::DVD, "SetAudioBuffer: Trig: %i, Enable: %i, Size: %i\n",
commandBuffer[0] & 3, commandBuffer[2] & 0x80 ? 1 : 0, commandBuffer[3] & 0xf);
}
break;
default:
state = DduThreadState::ReadBogusData;
Report(Channel::DVD, "Unknown DDU command: %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X\n",
commandBuffer[0], commandBuffer[1], commandBuffer[2], commandBuffer[3],
commandBuffer[4], commandBuffer[5], commandBuffer[6], commandBuffer[7],
commandBuffer[8], commandBuffer[9], commandBuffer[10], commandBuffer[11]);
break;
}
commandPtr = 0;
}
void DduCore::DduThreadProc(void* Parameter)
{
DduCore* core = (DduCore*)Parameter;
// Wait Gekko ticks
if (!core->transferRateNoLimit)
{
int64_t ticks = Core->GetTicks();
if (ticks >= core->savedGekkoTicks)
{
core->savedGekkoTicks = ticks + core->dduTicksPerByte;
}
else
{
return;
}
}
// Until break or transfer completed
while (core->ddBusBusy)
{
if (core->busDir == DduBusDirection::HostToDdu)
{
switch (core->state)
{
case DduThreadState::WriteCommand:
if (core->commandPtr < sizeof(core->commandBuffer))
{
core->commandBuffer[core->commandPtr] = core->hostToDduCallback();
core->stats.bytesWrite++;
core->commandPtr++;
}
if (core->commandPtr >= sizeof(core->commandBuffer))
{
core->ExecuteCommand();
}
break;
// Hidden debug commands are not supported yet
default:
core->DeviceError(0);
break;
}
}
else
{
switch (core->state)
{
case DduThreadState::ReadDvdData:
// Read-ahead new DVD data
if (core->dataCachePtr >= dataCacheSize)
{
Seek(core->seekVal);
size_t bytes = my_min(dataCacheSize, core->transactionSize);
bool readResult = Read(core->dataCache, bytes);
core->seekVal += (uint32_t)bytes;
core->transactionSize -= bytes;
if (core->seekVal >= DVD_SIZE || !readResult)
{
core->DeviceError(0);
}
core->dataCachePtr = 0;
}
core->dduToHostCallback(core->dataCache[core->dataCachePtr]);
core->stats.bytesRead++;
core->dataCachePtr++;
break;
case DduThreadState::ReadBogusData:
core->dduToHostCallback(0);
core->stats.bytesRead++;
break;
case DduThreadState::GetStreamEnable:
case DduThreadState::GetStreamOffset:
case DduThreadState::GetStreamBogus:
if (core->immediateBufferPtr < sizeof(core->immediateBuffer))
{
core->dduToHostCallback(core->immediateBuffer[core->immediateBufferPtr]);
core->stats.bytesRead++;
core->immediateBufferPtr++;
}
else
{
core->DeviceError(0);
}
break;
case DduThreadState::Idle:
break;
default:
core->DeviceError(0);
break;
}
}
}
// Sleep until next transfer
core->dduThread->Suspend();
}
// Enabling AISCLK forces the DDU to issue samples out even if there are none (zeros goes to output).
void DduCore::EnableAudioStreamClock(bool enable)
{
if (enable)
{
dvdAudioThread->Resume();
}
else
{
dvdAudioThread->Suspend();
}
}
void DduCore::DvdAudioThreadProc(void* Parameter)
{
uint16_t sample[2] = { 0, 0 };
DduCore* core = (DduCore*)Parameter;
while (true)
{
// If AISCLK is enabled but streaming is not enabled by the DDU command, DVD Audio will output only zeros.
// If its time to send sample
int64_t ticks = Core->GetTicks();
if (ticks < core->nextGekkoTicksToSample)
{
continue;
}
core->nextGekkoTicksToSample = ticks + core->TicksPerSample();
// Invalidate cache
if (core->streamEnabledByDduCommand)
{
if (core->streamingCachePtr >= streamCacheSize)
{
core->streamingCachePtr = 0;
Seek(core->streamSeekVal);
bool readResult = Read(core->streamingCache, streamCacheSize);
if (core->log)
{
//DBReport2(DbgChannel::DVD, "Streaming Seek: 0x%08X, Byte[0]: 0x%02X\n", core->streamSeekVal, core->streamingCache[0]);
}
//if (!readResult)
//{
// core->DeviceError(0);
//}
if (core->adpcmStreamDump && core->adpcmStreamFile)
{
fwrite(core->streamingCache, 1, streamCacheSize, core->adpcmStreamFile);
}
}
}
// From changing the playback frequency, the size of the ADPCM data does not change. The frequency of samples output to the outside changes.
if (core->streamEnabledByDduCommand)
{
if (core->pcmPlaybackCounter >= sizeof(core->pcmPlaybackBuffer))
{
// Decode next ADPCM chunk
DvdAudioDecode(&core->streamingCache[core->streamingCachePtr], core->pcmPlaybackBuffer);
if (core->decodedStreamDump && core->decodedStreamFile)
{
fwrite(core->pcmPlaybackBuffer, 1, sizeof(core->pcmPlaybackBuffer), core->decodedStreamFile);
}
core->streamingCachePtr += 32;
core->streamSeekVal += 32;
core->streamCount -= 32;
core->pcmPlaybackCounter = 0;
}
uint8_t* rawPtr = (uint8_t *)core->pcmPlaybackBuffer + core->pcmPlaybackCounter;
sample[0] = *(uint16_t *)rawPtr;
sample[1] = *(uint16_t *)(rawPtr + 2);
core->pcmPlaybackCounter += 4;
}
else
{
sample[0] = 0;
sample[1] = 0;
}
// Send sample
if (core->streamCallback)
{
core->streamCallback(sample[0], sample[1]);
}
core->stats.sampleCounter++;
if (core->streamEnabledByDduCommand)
{
if (core->streamCount <= 0)
{
core->streamEnabledByDduCommand = false;
if (core->log)
{
Report(Channel::DVD, "DVD streaming stopped by counter value reach zero\n");
}
}
}
}
}
// Calculates how many Gekko ticks takes 1 sample, at the selected sample rate.
int64_t DduCore::TicksPerSample()
{
if (sampleRate == DvdAudioSampleRate::Rate_32000)
{
// 32 kHz means 32,000 LR samples per second come from DVD Audio.
// To find out how many ticks a sample takes, you need to divide the number of Gekko ticks per second by 32000.
return gekkoOneSecond / 32000;
}
else
{
return gekkoOneSecond / 48000;
}
}
void DduCore::SetDvdAudioSampleRate(DvdAudioSampleRate rate)
{
sampleRate = rate;
nextGekkoTicksToSample = Core->GetTicks() + TicksPerSample();
}
// Reset internal state. If you forget something, then it will come out later..
void DduCore::Reset()
{
dduThread->Suspend();
dvdAudioThread->Suspend();
ddBusBusy = false;
errorState = false;
commandPtr = 0;
dataCachePtr = dataCacheSize;
streamingCachePtr = streamCacheSize;
state = DduThreadState::WriteCommand;
ResetStats();
gekkoOneSecond = Core->OneSecond();
dduTicksPerByte = gekkoOneSecond / transferRate;
SetDvdAudioSampleRate(DvdAudioSampleRate::Rate_48000);
streamEnabledByDduCommand = false;
}
void DduCore::Break()
{
// Abort data transfer
Report(Channel::DVD, "DDU Break\n");
ddBusBusy = false;
}
void DduCore::OpenCover()
{
if (coverStatus == CoverStatus::Open)
return;
coverStatus = CoverStatus::Open;
Report(Channel::DVD, "Cover opened\n");
// Notify host hardware
if (openCoverCallback)
{
openCoverCallback();
}
}
void DduCore::CloseCover()
{
if (coverStatus == CoverStatus::Close)
return;
coverStatus = CoverStatus::Close;
Report(Channel::DVD, "Cover closed\n");
// Notify host hardware
if (closeCoverCallback)
{
closeCoverCallback();
}
}
void DduCore::DeviceError(uint32_t reason)
{
Report(Channel::DVD, "DDU DeviceError: %08X\n", reason);
// Will deassert DIERR after the next command is received from the host
errorState = true;
errorCode = reason;
ddBusBusy = false;
if (errorCallback)
{
errorCallback();
}
}
void DduCore::StartTransfer(DduBusDirection direction)
{
if (logTransfers)
{
Report(Channel::DVD, "StartTransfer: %s\n", direction == DduBusDirection::DduToHost ? "Ddu->Host" : "Host->Ddu");
}
ddBusBusy = true;
busDir = direction;
savedGekkoTicks = Core->GetTicks() + dduTicksPerByte;
dduThread->Resume();
}
void DduCore::TransferComplete()
{
if (logTransfers)
{
Report(Channel::DVD, "TransferComplete\n");
}
ddBusBusy = false;
switch (state)
{
case DduThreadState::WriteCommand:
// Invalidate reading cache
dataCachePtr = dataCacheSize;
break;
case DduThreadState::Idle:
case DduThreadState::ReadDvdData:
case DduThreadState::ReadBogusData:
case DduThreadState::GetStreamEnable:
case DduThreadState::GetStreamOffset:
case DduThreadState::GetStreamBogus:
state = DduThreadState::WriteCommand;
break;
}
if (busDir == DduBusDirection::DduToHost)
{
stats.dduToHostTransferCount++;
}
else
{
stats.hostToDduTransferCount++;
}
}
}
Reference in a new issue View git blame Copy permalink