HEFFECT D3DCore_Impl::Effect_Load(const WCHAR *filename, DWORD size)
{
if(m_bSilent) return 0;
DWORD _size;
FilePtr pf;
SampleSource* SSource = NULL;
void *data;
if(m_pADevice)
{
if(size) { data=(void *)filename; _size=size; }
else
{
data=File_Load(filename, &_size);
if(!data) return NULL;
}
pf = CreateMemoryFile(data, _size);
if(pf.get() != NULL) {
SSource = OpenSampleSource( pf.get() );
if(!SSource) {
System_Log(L"[AUDIERE - ERROR] %s - Can't create sound effect", filename);
}
SSource->ref();
}
if(!size) File_Free(data);
return (HEFFECT)SSource;
}
else return 0;
}
long File::FileSize(const FilePtr& file)
{
std::fseek(file.get(), 0, SEEK_END);
const long size = std::ftell(file.get());
std::rewind(file.get());
return size;
}
void File::FileRead(const FilePtr& file, std::vector<byte>& bytes)
{
const long filesize = File::FileSize(file);
bytes.resize(filesize, 0);
std::fread(bytes.data(), 1, filesize, file.get());
}
void WriteAppx(
const FilePtr &zip,
const std::unordered_map<std::string, std::string> &fileNames,
const std::string *certPath, int compressionLevel, bool isBundle)
{
FileSink zipRawSink(zip.get());
OffsetSink zipOffsetSink;
auto zipSink = MakeMultiSink(zipRawSink, zipOffsetSink);
std::vector<ZIPFileEntry> zipFileEntries;
std::pair<std::string, std::string> appxBundleManifest;
APPXDigests digests;
// Write and hash the ZIP content.
{
SHA256Sink axpcSink;
auto sink = MakeMultiSink(zipSink, axpcSink);
for (const auto &fileNamePair : fileNames) {
const std::string &archiveName = fileNamePair.first;
const std::string &fileName = fileNamePair.second;
const std::string suffix = "AppxBundleManifest.xml";
if (isBundle &&
suffix.size() < archiveName.size() &&
std::equal(suffix.rbegin(), suffix.rend(), archiveName.rbegin())) {
appxBundleManifest = fileNamePair;
continue;
}
zipFileEntries.emplace_back(
WriteZIPFileEntry(sink, zipOffsetSink.Offset(), fileName,
archiveName, compressionLevel));
}
if (isBundle) {
ZIPFileEntry appxBundleManifestEntry = WriteAppxBundleManifestZIPFileEntry(
sink,
zipOffsetSink.Offset(),
appxBundleManifest.second,
appxBundleManifest.first, compressionLevel,
zipFileEntries);
zipFileEntries.emplace_back(std::move(appxBundleManifestEntry));
}
// this creates AppxBlockMap.xml file
ZIPFileEntry blockMap = WriteAppxBlockMapZIPFileEntry(
sink, zipOffsetSink.Offset(), zipFileEntries, isBundle);
digests.axbm = blockMap.sha256;
zipFileEntries.emplace_back(std::move(blockMap));
// this creates [Content_Types].xml
ZIPFileEntry contentTypes = WriteContentTypesZIPFileEntry(
sink, zipOffsetSink.Offset(), isBundle, zipFileEntries);
digests.axct = contentTypes.sha256;
zipFileEntries.emplace_back(std::move(contentTypes));
digests.axpc = axpcSink.SHA256();
}
// Hash (but do not write) the directory, pre-signature.
{
SHA256Sink axcdSink;
OffsetSink tmpOffsetSink = zipOffsetSink;
auto sink = MakeMultiSink(axcdSink, tmpOffsetSink);
for (const ZIPFileEntry &entry : zipFileEntries) {
entry.WriteDirectoryEntry(sink);
}
WriteZIPEndOfCentralDirectoryRecord(sink, tmpOffsetSink.Offset(),
zipFileEntries);
digests.axcd = axcdSink.SHA256();
}
// Sign and write the signature.
if (certPath) {
zipFileEntries.emplace_back(WriteSignature(
zipSink, *certPath, digests, zipOffsetSink.Offset()));
}
// Write the directory.
for (const ZIPFileEntry &entry : zipFileEntries) {
entry.WriteDirectoryEntry(zipSink);
}
WriteZIPEndOfCentralDirectoryRecord(zipSink, zipOffsetSink.Offset(),
zipFileEntries);
}
bool Material::load(const FilePtr& file)
{
return load(file.get());
}
MaterialPtr Material::fromFile(const FilePtr& file)
{
return fromFile(file.get());
}
TiXmlDocument XmlUtils::parseFile(const FilePtr& file)
{
return parseFile(file.get());
}
std::vector<std::string> FileUtils::loadFileLines(const FilePtr& file, bool includeEolMarker)
{
return loadFileLines(file.get(), includeEolMarker);
}
std::vector<std::string> FileUtils::loadFileLines(const std::string& fileName, bool includeEolMarker)
{
FilePtr file = Services::fileSystem()->openFile(fileName);
return loadFileLines(file.get(), includeEolMarker);
}
std::vector<char> FileUtils::loadFile(const FilePtr& file)
{
return loadFile(file.get());
}
std::vector<char> FileUtils::loadFile(const std::string& fileName)
{
FilePtr file = Services::fileSystem()->openFile(fileName);
return loadFile(file.get());
}
