// Reads and parses the file
// and returns the created Book
QSharedPointer<Book> ImportHTML::GetBook()
{
QString source = LoadSource();
LoadMetadata(source);
UpdateFiles(CreateHTMLResource(), source, LoadFolderStructure(source));
return m_Book;
}
bool GDALMDReaderBase::FillMetadata(GDALMultiDomainMetadata* poMDMD)
{
if(NULL == poMDMD)
return false;
LoadMetadata();
SETMETADATA(poMDMD, m_papszIMDMD, MD_DOMAIN_IMD );
SETMETADATA(poMDMD, m_papszRPCMD, MD_DOMAIN_RPC );
SETMETADATA(poMDMD, m_papszIMAGERYMD, MD_DOMAIN_IMAGERY );
SETMETADATA(poMDMD, m_papszDEFAULTMD, MD_DOMAIN_DEFAULT );
return true;
}
void MpvHandler::LoadFileInfo()
{
// get media-title
fileInfo.media_title = mpv_get_property_string(mpv, "media-title");
// get length
double len;
mpv_get_property(mpv, "length", MPV_FORMAT_DOUBLE, &len);
fileInfo.length = (int)len;
LoadTracks();
LoadChapters();
LoadVideoParams();
LoadAudioParams();
LoadMetadata();
emit fileInfoChanged(fileInfo);
}
// Reads and parses the file
// and returns the created Book
QSharedPointer<Book> ImportHTML::GetBook(bool extract_metadata)
{
QString source = LoadSource();
if (extract_metadata) {
LoadMetadata(source);
}
UpdateFiles(CreateHTMLResource(), source, LoadFolderStructure(source));
// Before returning the new book, if it is epub3, make sure it has a nav
if (m_EpubVersion.startsWith('3')) {
HTMLResource* nav_resource = m_Book->GetConstOPF()->GetNavResource();
if (!nav_resource) {
HTMLResource * nav_resource = m_Book->CreateEmptyNavFile(true);
m_Book->GetOPF()->SetNavResource(nav_resource);
m_Book->GetOPF()->SetItemRefLinear(nav_resource, false);
}
}
return m_Book;
}
Loader::ResultStatus CIAContainer::Load(const std::vector<u8>& file_data) {
Loader::ResultStatus result = LoadHeader(file_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load Title Metadata
result = LoadTitleMetadata(file_data, GetTitleMetadataOffset());
if (result != Loader::ResultStatus::Success)
return result;
// Load CIA Metadata
if (cia_header.meta_size) {
result = LoadMetadata(file_data, GetMetadataOffset());
if (result != Loader::ResultStatus::Success)
return result;
}
return Loader::ResultStatus::Success;
}
///////////////////////////////////////////////////////////////////////////////
//
// LoadFromFileAndRegister
//
///////////////////////////////////////////////////////////////////////////////
bool LoadFromFileAndRegister()
{
HRESULT hr = S_OK;
bool bResult = false;
PWSTR wszData = NULL;
CComPtr<IVssExpressWriter> spExpressWriter;
wprintf(L"INFO: LoadFromFileAndRegister called\n");
//
// Create Express Writer
//
wprintf(L"INFO: Creating Express Writer...\n");
CHECK_HR(
CreateVssExpressWriter(&spExpressWriter),
L"CreateVssExpressWriter failed");
//
// Load metadata
//
wprintf(L"INFO: Loading metadata...\n");
CHECK_CONDITION(
LoadMetadata(spExpressWriter, g_wszFileName, &wszData),
L"LoadMetadata failed");
//
// Save results
//
CHECK_HR(spExpressWriter->Register(), L"Register failed");
bResult = true;
_exit:
if (wszData)
{
free(wszData);
wszData = NULL;
}
return bResult;
}
void AssetLibrary::Reload(const char* filePathOrIdentifier)
{
char absolutePathOrIdentifier[DRFS_MAX_PATH];
if (!drfs_find_absolute_path(m_pVFS, filePathOrIdentifier, absolutePathOrIdentifier, sizeof(absolutePathOrIdentifier)))
{
char metadataPath[DRFS_MAX_PATH];
drpath_copy_and_append_extension(metadataPath, DRFS_MAX_PATH, filePathOrIdentifier, "gtdata");
if (!drfs_find_absolute_path(m_pVFS, metadataPath, absolutePathOrIdentifier, sizeof(absolutePathOrIdentifier)))
{
// The file nor it's metadata file could not be found, but the asset loader might be using it as a unique token, so we just assume use it as-is for the absolute path in this case.
strcpy_s(absolutePathOrIdentifier, filePathOrIdentifier);
}
}
dr_lock_mutex(m_mutex);
{
auto iAsset = m_loadedAssets.Find(absolutePathOrIdentifier);
if (iAsset != nullptr)
{
auto pAsset = iAsset->value;
assert(pAsset != nullptr);
{
// Load the metadata first. It does not matter if this fails so the return value doesn't need to be checked.
char metadataAbsolutePath[DRFS_MAX_PATH];
drpath_copy_and_append_extension(metadataAbsolutePath, DRFS_MAX_PATH, filePathOrIdentifier, "gtdata");
pAsset->LoadMetadata(metadataAbsolutePath, m_pVFS);
// Load the asset after the metadata.
if (pAsset->Load(absolutePathOrIdentifier, m_pVFS))
{
}
else
{
// Failed to reload asset.
}
}
}
}
dr_unlock_mutex(m_mutex);
}
void MpvHandler::LoadFileInfo()
{
// get media-title
fileInfo.media_title = mpv_get_property_string(mpv, "media-title");
// get length
double len;
mpv_get_property(mpv, "length", MPV_FORMAT_DOUBLE, &len);
fileInfo.length = (int)len;
fileInfo.video_params.codec = mpv_get_property_string(mpv, "video-codec");
fileInfo.audio_params.codec = mpv_get_property_string(mpv, "audio-codec");
fileInfo.audio_params.samplerate = mpv_get_property_string(mpv, "audio-samplerate");
fileInfo.audio_params.channels = mpv_get_property_string(mpv, "audio-channels");
LoadTracks();
LoadChapters();
LoadVideoParams();
LoadMetadata();
emit fileInfoChanged(fileInfo);
}
Loader::ResultStatus CIAContainer::Load(const std::string& filepath) {
FileUtil::IOFile file(filepath, "rb");
if (!file.IsOpen())
return Loader::ResultStatus::Error;
// Load CIA Header
std::vector<u8> header_data(sizeof(Header));
if (file.ReadBytes(header_data.data(), sizeof(Header)) != sizeof(Header))
return Loader::ResultStatus::Error;
Loader::ResultStatus result = LoadHeader(header_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load Title Metadata
std::vector<u8> tmd_data(cia_header.tmd_size);
file.Seek(GetTitleMetadataOffset(), SEEK_SET);
if (file.ReadBytes(tmd_data.data(), cia_header.tmd_size) != cia_header.tmd_size)
return Loader::ResultStatus::Error;
result = LoadTitleMetadata(tmd_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load CIA Metadata
if (cia_header.meta_size) {
std::vector<u8> meta_data(sizeof(Metadata));
file.Seek(GetMetadataOffset(), SEEK_SET);
if (file.ReadBytes(meta_data.data(), sizeof(Metadata)) != sizeof(Metadata))
return Loader::ResultStatus::Error;
result = LoadMetadata(meta_data);
if (result != Loader::ResultStatus::Success)
return result;
}
return Loader::ResultStatus::Success;
}
Loader::ResultStatus CIAContainer::Load(const FileBackend& backend) {
std::vector<u8> header_data(sizeof(Header));
// Load the CIA Header
ResultVal<size_t> read_result = backend.Read(0, sizeof(Header), header_data.data());
if (read_result.Failed() || *read_result != sizeof(Header))
return Loader::ResultStatus::Error;
Loader::ResultStatus result = LoadHeader(header_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load Title Metadata
std::vector<u8> tmd_data(cia_header.tmd_size);
read_result = backend.Read(GetTitleMetadataOffset(), cia_header.tmd_size, tmd_data.data());
if (read_result.Failed() || *read_result != cia_header.tmd_size)
return Loader::ResultStatus::Error;
result = LoadTitleMetadata(tmd_data);
if (result != Loader::ResultStatus::Success)
return result;
// Load CIA Metadata
if (cia_header.meta_size) {
std::vector<u8> meta_data(sizeof(Metadata));
read_result = backend.Read(GetMetadataOffset(), sizeof(Metadata), meta_data.data());
if (read_result.Failed() || *read_result != sizeof(Metadata))
return Loader::ResultStatus::Error;
result = LoadMetadata(meta_data);
if (result != Loader::ResultStatus::Success)
return result;
}
return Loader::ResultStatus::Success;
}
