2015-05-23 22:55:12 -06:00
|
|
|
// Copyright 2008 Dolphin Emulator Project
|
2015-05-17 17:08:10 -06:00
|
|
|
// Licensed under GPLv2+
|
2013-04-17 21:09:55 -06:00
|
|
|
// Refer to the license.txt file included.
|
2008-12-07 22:30:24 -07:00
|
|
|
|
2014-02-20 17:47:53 -07:00
|
|
|
#include <cstddef>
|
2015-04-09 09:44:53 -06:00
|
|
|
#include <map>
|
2014-08-31 07:34:58 -06:00
|
|
|
#include <memory>
|
2014-02-20 17:47:53 -07:00
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
|
|
|
|
2015-04-10 14:10:49 -06:00
|
|
|
#include "Common/ColorUtil.h"
|
2014-09-07 19:06:58 -06:00
|
|
|
#include "Common/CommonTypes.h"
|
2014-02-17 03:18:15 -07:00
|
|
|
#include "Common/StringUtil.h"
|
2015-04-10 14:10:49 -06:00
|
|
|
#include "Common/Logging/Log.h"
|
2014-02-20 17:47:53 -07:00
|
|
|
#include "DiscIO/Blob.h"
|
2014-02-17 03:18:15 -07:00
|
|
|
#include "DiscIO/FileMonitor.h"
|
2015-04-10 14:10:49 -06:00
|
|
|
#include "DiscIO/Filesystem.h"
|
2014-02-20 17:47:53 -07:00
|
|
|
#include "DiscIO/Volume.h"
|
2014-02-17 03:18:15 -07:00
|
|
|
#include "DiscIO/VolumeGC.h"
|
2009-01-03 11:50:01 -07:00
|
|
|
|
2008-12-07 22:30:24 -07:00
|
|
|
namespace DiscIO
|
|
|
|
{
|
|
|
|
CVolumeGC::CVolumeGC(IBlobReader* _pReader)
|
|
|
|
: m_pReader(_pReader)
|
|
|
|
{}
|
|
|
|
|
|
|
|
CVolumeGC::~CVolumeGC()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-12-28 02:35:48 -07:00
|
|
|
bool CVolumeGC::Read(u64 _Offset, u64 _Length, u8* _pBuffer, bool decrypt) const
|
2008-12-07 22:30:24 -07:00
|
|
|
{
|
2014-12-28 02:35:48 -07:00
|
|
|
if (decrypt)
|
|
|
|
PanicAlertT("Tried to decrypt data from a non-Wii volume");
|
|
|
|
|
2014-03-09 14:14:26 -06:00
|
|
|
if (m_pReader == nullptr)
|
2008-12-07 22:30:24 -07:00
|
|
|
return false;
|
2009-07-02 21:26:23 -06:00
|
|
|
|
2009-09-03 14:00:09 -06:00
|
|
|
FileMon::FindFilename(_Offset);
|
|
|
|
|
2008-12-07 22:30:24 -07:00
|
|
|
return m_pReader->Read(_Offset, _Length, _pBuffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string CVolumeGC::GetUniqueID() const
|
|
|
|
{
|
|
|
|
static const std::string NO_UID("NO_UID");
|
2014-03-09 14:14:26 -06:00
|
|
|
if (m_pReader == nullptr)
|
2008-12-07 22:30:24 -07:00
|
|
|
return NO_UID;
|
|
|
|
|
2011-01-30 10:58:02 -07:00
|
|
|
char ID[7];
|
|
|
|
|
|
|
|
if (!Read(0, sizeof(ID), reinterpret_cast<u8*>(ID)))
|
2008-12-07 22:30:24 -07:00
|
|
|
{
|
2011-01-12 19:05:58 -07:00
|
|
|
PanicAlertT("Failed to read unique ID from disc image");
|
2008-12-07 22:30:24 -07:00
|
|
|
return NO_UID;
|
|
|
|
}
|
|
|
|
|
2011-01-30 10:58:02 -07:00
|
|
|
ID[6] = '\0';
|
|
|
|
|
|
|
|
return ID;
|
2008-12-07 22:30:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
IVolume::ECountry CVolumeGC::GetCountry() const
|
|
|
|
{
|
|
|
|
if (!m_pReader)
|
|
|
|
return COUNTRY_UNKNOWN;
|
|
|
|
|
2015-02-23 18:43:29 -07:00
|
|
|
u8 country_code;
|
|
|
|
m_pReader->Read(3, 1, &country_code);
|
2008-12-07 22:30:24 -07:00
|
|
|
|
2015-02-23 18:43:29 -07:00
|
|
|
return CountrySwitch(country_code);
|
2008-12-07 22:30:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string CVolumeGC::GetMakerID() const
|
|
|
|
{
|
2014-03-09 14:14:26 -06:00
|
|
|
if (m_pReader == nullptr)
|
2010-08-13 13:07:59 -06:00
|
|
|
return std::string();
|
2008-12-07 22:30:24 -07:00
|
|
|
|
|
|
|
char makerID[3];
|
|
|
|
if (!Read(0x4, 0x2, (u8*)&makerID))
|
2010-08-13 13:07:59 -06:00
|
|
|
return std::string();
|
|
|
|
makerID[2] = '\0';
|
2008-12-07 22:30:24 -07:00
|
|
|
|
|
|
|
return makerID;
|
|
|
|
}
|
|
|
|
|
2015-05-29 13:14:02 -06:00
|
|
|
u16 CVolumeGC::GetRevision() const
|
2013-04-16 21:29:01 -06:00
|
|
|
{
|
|
|
|
if (!m_pReader)
|
|
|
|
return 0;
|
|
|
|
|
2014-11-14 18:59:39 -07:00
|
|
|
u8 revision;
|
|
|
|
if (!Read(7, 1, &revision))
|
2013-04-16 21:29:01 -06:00
|
|
|
return 0;
|
|
|
|
|
2014-11-14 18:59:39 -07:00
|
|
|
return revision;
|
2013-04-16 21:29:01 -06:00
|
|
|
}
|
|
|
|
|
2015-05-11 03:19:30 -06:00
|
|
|
std::string CVolumeGC::GetInternalName() const
|
2015-04-10 14:10:49 -06:00
|
|
|
{
|
|
|
|
char name[0x60];
|
|
|
|
if (m_pReader != nullptr && Read(0x20, 0x60, (u8*)name))
|
|
|
|
return DecodeString(name);
|
|
|
|
else
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2015-04-09 09:44:53 -06:00
|
|
|
std::map<IVolume::ELanguage, std::string> CVolumeGC::GetNames() const
|
2008-12-07 22:30:24 -07:00
|
|
|
{
|
2015-04-09 09:44:53 -06:00
|
|
|
std::map<IVolume::ELanguage, std::string> names;
|
2013-10-28 23:23:17 -06:00
|
|
|
|
2015-04-10 14:10:49 -06:00
|
|
|
if (!LoadBannerFile())
|
|
|
|
return names;
|
2008-12-07 22:30:24 -07:00
|
|
|
|
2015-04-10 14:10:49 -06:00
|
|
|
u32 name_count = 0;
|
|
|
|
IVolume::ELanguage language;
|
|
|
|
bool is_japanese = GetCountry() == IVolume::ECountry::COUNTRY_JAPAN;
|
|
|
|
|
|
|
|
switch (m_banner_file_type)
|
|
|
|
{
|
|
|
|
case BANNER_BNR1:
|
|
|
|
name_count = 1;
|
|
|
|
language = is_japanese ? IVolume::ELanguage::LANGUAGE_JAPANESE : IVolume::ELanguage::LANGUAGE_ENGLISH;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BANNER_BNR2:
|
|
|
|
name_count = 6;
|
|
|
|
language = IVolume::ELanguage::LANGUAGE_ENGLISH;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BANNER_INVALID:
|
|
|
|
case BANNER_NOT_LOADED:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto const banner = reinterpret_cast<const GCBanner*>(m_banner_file.data());
|
|
|
|
|
|
|
|
for (u32 i = 0; i < name_count; ++i)
|
|
|
|
{
|
|
|
|
auto& comment = banner->comment[i];
|
|
|
|
std::string name = DecodeString(comment.longTitle);
|
|
|
|
|
|
|
|
if (name.empty())
|
|
|
|
name = DecodeString(comment.shortTitle);
|
|
|
|
|
|
|
|
if (!name.empty())
|
|
|
|
names[(IVolume::ELanguage)(language + i)] = name;
|
|
|
|
}
|
2008-12-07 22:30:24 -07:00
|
|
|
|
2013-03-02 18:46:55 -07:00
|
|
|
return names;
|
2008-12-07 22:30:24 -07:00
|
|
|
}
|
|
|
|
|
2015-04-10 14:10:49 -06:00
|
|
|
std::map<IVolume::ELanguage, std::string> CVolumeGC::GetDescriptions() const
|
|
|
|
{
|
|
|
|
std::map<IVolume::ELanguage, std::string> descriptions;
|
|
|
|
|
|
|
|
if (!LoadBannerFile())
|
|
|
|
return descriptions;
|
|
|
|
|
|
|
|
u32 desc_count = 0;
|
|
|
|
IVolume::ELanguage language;
|
|
|
|
bool is_japanese = GetCountry() == IVolume::ECountry::COUNTRY_JAPAN;
|
|
|
|
|
|
|
|
switch (m_banner_file_type)
|
|
|
|
{
|
|
|
|
case BANNER_BNR1:
|
|
|
|
desc_count = 1;
|
|
|
|
language = is_japanese ? IVolume::ELanguage::LANGUAGE_JAPANESE : IVolume::ELanguage::LANGUAGE_ENGLISH;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BANNER_BNR2:
|
|
|
|
language = IVolume::ELanguage::LANGUAGE_ENGLISH;
|
|
|
|
desc_count = 6;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BANNER_INVALID:
|
|
|
|
case BANNER_NOT_LOADED:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto banner = reinterpret_cast<const GCBanner*>(m_banner_file.data());
|
|
|
|
|
|
|
|
for (u32 i = 0; i < desc_count; ++i)
|
|
|
|
{
|
|
|
|
auto& data = banner->comment[i].comment;
|
|
|
|
std::string description = DecodeString(data);
|
|
|
|
|
|
|
|
if (!description.empty())
|
|
|
|
descriptions[(IVolume::ELanguage)(language + i)] = description;
|
|
|
|
}
|
|
|
|
|
|
|
|
return descriptions;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string CVolumeGC::GetCompany() const
|
|
|
|
{
|
|
|
|
if (!LoadBannerFile())
|
|
|
|
return "";
|
|
|
|
|
|
|
|
auto const pBanner = (GCBanner*)m_banner_file.data();
|
|
|
|
std::string company = DecodeString(pBanner->comment[0].longMaker);
|
|
|
|
|
|
|
|
if (company.empty())
|
|
|
|
company = DecodeString(pBanner->comment[0].shortMaker);
|
|
|
|
|
|
|
|
return company;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<u32> CVolumeGC::GetBanner(int* width, int* height) const
|
|
|
|
{
|
|
|
|
if (!LoadBannerFile())
|
|
|
|
{
|
|
|
|
*width = 0;
|
|
|
|
*height = 0;
|
|
|
|
return std::vector<u32>();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<u32> image_buffer(GC_BANNER_WIDTH * GC_BANNER_HEIGHT);
|
|
|
|
auto const pBanner = (GCBanner*)m_banner_file.data();
|
|
|
|
ColorUtil::decode5A3image(image_buffer.data(), pBanner->image, GC_BANNER_WIDTH, GC_BANNER_HEIGHT);
|
|
|
|
*width = GC_BANNER_WIDTH;
|
|
|
|
*height = GC_BANNER_HEIGHT;
|
|
|
|
return image_buffer;
|
|
|
|
}
|
|
|
|
|
2008-12-07 22:30:24 -07:00
|
|
|
u32 CVolumeGC::GetFSTSize() const
|
|
|
|
{
|
2014-03-09 14:14:26 -06:00
|
|
|
if (m_pReader == nullptr)
|
2010-08-13 13:07:59 -06:00
|
|
|
return 0;
|
2008-12-07 22:30:24 -07:00
|
|
|
|
|
|
|
u32 size;
|
|
|
|
if (!Read(0x428, 0x4, (u8*)&size))
|
2010-08-13 13:07:59 -06:00
|
|
|
return 0;
|
2008-12-07 22:30:24 -07:00
|
|
|
|
|
|
|
return Common::swap32(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string CVolumeGC::GetApploaderDate() const
|
|
|
|
{
|
2014-03-09 14:14:26 -06:00
|
|
|
if (m_pReader == nullptr)
|
2010-08-13 13:07:59 -06:00
|
|
|
return std::string();
|
2008-12-07 22:30:24 -07:00
|
|
|
|
|
|
|
char date[16];
|
|
|
|
if (!Read(0x2440, 0x10, (u8*)&date))
|
2010-08-13 13:07:59 -06:00
|
|
|
return std::string();
|
2008-12-07 22:30:24 -07:00
|
|
|
// Should be 0 already, but just in case
|
2010-08-13 13:07:59 -06:00
|
|
|
date[10] = '\0';
|
2008-12-07 22:30:24 -07:00
|
|
|
|
|
|
|
return date;
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 CVolumeGC::GetSize() const
|
|
|
|
{
|
|
|
|
if (m_pReader)
|
2010-12-03 05:42:01 -07:00
|
|
|
return m_pReader->GetDataSize();
|
2008-12-07 22:30:24 -07:00
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-09 11:58:56 -06:00
|
|
|
u64 CVolumeGC::GetRawSize() const
|
|
|
|
{
|
|
|
|
if (m_pReader)
|
|
|
|
return m_pReader->GetRawSize();
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-29 13:14:02 -06:00
|
|
|
u8 CVolumeGC::GetDiscNumber() const
|
2013-01-25 19:28:04 -07:00
|
|
|
{
|
2015-05-29 13:14:02 -06:00
|
|
|
u8 disc_number;
|
|
|
|
Read(6, 1, &disc_number);
|
|
|
|
return disc_number;
|
2013-01-25 19:28:04 -07:00
|
|
|
}
|
|
|
|
|
2015-06-04 08:26:36 -06:00
|
|
|
IVolume::EPlatform CVolumeGC::GetVolumeType() const
|
|
|
|
{
|
|
|
|
return GAMECUBE_DISC;
|
|
|
|
}
|
|
|
|
|
2015-04-10 14:10:49 -06:00
|
|
|
bool CVolumeGC::LoadBannerFile() const
|
2013-03-03 15:51:26 -07:00
|
|
|
{
|
2015-04-10 14:10:49 -06:00
|
|
|
// The methods GetNames, GetDescriptions, GetCompany and GetBanner
|
|
|
|
// all need to access the opening.bnr file. These four methods are
|
|
|
|
// typically called after each other, so we store the file in RAM
|
|
|
|
// to avoid reading it from the disc several times. However,
|
|
|
|
// if none of these methods are called, the file is never loaded.
|
|
|
|
|
|
|
|
if (m_banner_file_type != BANNER_NOT_LOADED)
|
|
|
|
return m_banner_file_type != BANNER_INVALID;
|
|
|
|
|
|
|
|
std::unique_ptr<IFileSystem> file_system(CreateFileSystem(this));
|
|
|
|
size_t file_size = (size_t)file_system->GetFileSize("opening.bnr");
|
|
|
|
if (file_size == BNR1_SIZE || file_size == BNR2_SIZE)
|
|
|
|
{
|
|
|
|
m_banner_file.resize(file_size);
|
|
|
|
file_system->ReadFile("opening.bnr", m_banner_file.data(), m_banner_file.size());
|
|
|
|
|
|
|
|
u32 bannerSignature = *(u32*)m_banner_file.data();
|
2015-06-03 03:35:05 -06:00
|
|
|
if (file_size == BNR1_SIZE && bannerSignature == 0x31524e42) // "BNR1"
|
2015-04-10 14:10:49 -06:00
|
|
|
{
|
|
|
|
m_banner_file_type = BANNER_BNR1;
|
2015-06-03 03:35:05 -06:00
|
|
|
}
|
|
|
|
else if (file_size == BNR2_SIZE && bannerSignature == 0x32524e42) // "BNR2"
|
|
|
|
{
|
2015-04-10 14:10:49 -06:00
|
|
|
m_banner_file_type = BANNER_BNR2;
|
2015-06-03 03:35:05 -06:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-04-10 14:10:49 -06:00
|
|
|
m_banner_file_type = BANNER_INVALID;
|
2015-06-03 03:35:05 -06:00
|
|
|
WARN_LOG(DISCIO, "Invalid opening.bnr. Type: %0x Size: %0lx", bannerSignature, (unsigned long)file_size);
|
2015-04-10 14:10:49 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_banner_file_type = BANNER_INVALID;
|
2015-06-03 03:35:05 -06:00
|
|
|
WARN_LOG(DISCIO, "Invalid opening.bnr. Size: %0lx", (unsigned long)file_size);
|
2015-04-10 14:10:49 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return m_banner_file_type != BANNER_INVALID;
|
2013-03-03 15:51:26 -07:00
|
|
|
}
|
|
|
|
|
2008-12-07 22:30:24 -07:00
|
|
|
} // namespace
|