static int Overture_MRG_extract_resource(struct package *pkg,
struct package_resource *pkg_res)
{
if (!pkg || !pkg_res)
return -CUI_EPARA;
pkg_res->raw_data = malloc(pkg_res->raw_data_length_lo);
if (!pkg_res->raw_data)
return -CUI_EMEM;
if (pkg->ior.io->readvec(&pkg->ior, pkg_res->raw_data, pkg_res->raw_data_length_lo,
pkg_res->offset_lo, IO_SEEK_SET)) {
free(pkg_res->raw_data);
pkg_res->raw_data = NULL;
return -CUI_EREADVEC;
}
#if 0 // 体验版
char *ext = PathFindExtensionA(pkg_res->name);
if (!ext || (ext[0] != '.') || (ext[1] == '\x0')) {
if (!memcmp(pkg_res->raw_data, "OggS", 4)) {
pkg_res->replace_extension = _T(".ogg");
pkg_res->flags = PKG_RES_FLAG_REEXT;
} else if (!memcmp(pkg_res->raw_data, "RIFF", 4)) {
pkg_res->replace_extension = _T(".wav");
pkg_res->flags = PKG_RES_FLAG_REEXT;
}
}
#endif
return 0;
}
/*************************************************************************
* PathFindExtension [SHELL32.31]
*/
LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath)
{
if (SHELL_OsIsUnicode())
return PathFindExtensionW(lpszPath);
return PathFindExtensionA(lpszPath);
}
/*************************************************************************
* PathGetExtensionA [internal]
*
* NOTES
* exported by ordinal
* return value points to the first char after the dot
*/
static LPSTR PathGetExtensionA(LPCSTR lpszPath)
{
TRACE("(%s)\n",lpszPath);
lpszPath = PathFindExtensionA(lpszPath);
return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
}
//
// ----------------------------------------------------------------------------
//
bool CMemoryIniFile::isPathExisting(void)
{
std::string strIniFile = m_strIniFile;
strIniFile.reserve ( 2*MAX_PATH );
LPSTR szPath = (LPSTR) strIniFile.c_str();
if (!std::string( PathFindExtensionA( szPath )).empty())
{
PathRemoveFileSpecA( szPath );
}
str::ResizeByZeroTermination( strIniFile );
BOOL bRC = PathIsDirectoryA( (char*) strIniFile.c_str() );
return (bRC != FALSE);
}
std::vector<FileListItem> Enviroment::getFilesInDirectory(const std::string& directory)
{
HANDLE dir;
WIN32_FIND_DATAA file_data;
std::vector<FileListItem> out;
if ((dir = FindFirstFileA((directory + "/*").c_str(), &file_data)) == INVALID_HANDLE_VALUE)
{
return std::vector<FileListItem>();
}
do
{
const std::string file_name = file_data.cFileName;
const std::string full_file_name = file_name;
const bool is_directory = (file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
if (file_name[0] == '.')
{
continue;
}
FileListItem item;
size_t lastindex = full_file_name.find_last_of(".");
if (lastindex != std::string::npos)
{
item.Filename = full_file_name.substr(0, lastindex);
}
else
{
item.Filename = full_file_name;
}
if (is_directory)
{
item.Filename = "[" + item.Filename + "]";
}
item.Extension = is_directory ? "" : PathFindExtensionA(file_data.cFileName);
item.Size = is_directory ? 0 : (file_data.nFileSizeHigh * (MAXDWORD + 1) + file_data.nFileSizeLow) / 1024 ; //To kilobytes
item.CreationDate = file_data.ftCreationTime;
out.push_back(item);
} while (FindNextFileA(dir, &file_data));
FindClose(dir);
return out;
}
void md_util_fn_split(CHAR *f_name, CHAR *f_ext, const CHAR *asciiz_fn) {
CHAR* ext = "\0";
size_t ext_len = 0;
memset(f_name, ' ', 8);
memset(f_ext, ' ', 3);
if(strcmp(asciiz_fn, ".") && strcmp(asciiz_fn, "..")) {
ext = PathFindExtensionA(asciiz_fn);
ext_len = strlen(ext);
}
memcpy(f_name, asciiz_fn, strlen(asciiz_fn) - ext_len);
if(ext[0] != '\0') {
memcpy(f_ext, ext + 1, strlen(ext) - 1);
}
}
MPxFileTranslator::MFileKind
XFileTranslator::identifyFile(
const MFileObject& fileName,
const char* buffer,
short size) const
{
LPSTR extension = PathFindExtensionA(fileName.name().asChar());
if(0==lstrcmpA(extension, ".x"))
{
return kIsMyFileType;
}
else
{
return kNotMyFileType;
}
}
_MY_C_HEAD_
#include "LZMA/7zVersion.h"
#include "LZMA/Alloc.h"
#include "LZMA/Lzma86.h"
_MY_C_TAIL_
void __cdecl main2(int argc, wchar_t **argv)
{
if (argc < 3)
{
printf("Too few parameters\n");
return;
}
Byte *outBuffer, FileType, bLZMA;
SizeT inSize, outSize, outMaxSize;
WCHAR szFileName[MAX_PATH];
WCHAR *szFileType[] = { L"UCA", L"UCI", L"AAC", L"M4A", L"Unknown" };
PBYTE pbFile;
DWORD dwFileNumber, dwErrorCount, dwMaxNumber, dwFileSize, dwRead;
DWORD dwBufferSize, dwMaxFileNumber, dwMethod[] = {'ACU', 'ICU', 'CAA', 'A4M', 'KNU'};
HANDLE hFind, hHeap, hFile, hDestFile;
WIN32_FIND_DATAW wfd;
TSpiArchiveInfo *pSpiArcInfo;
LARGE_INTEGER liFrequency, liStart, liStop;
setlocale(LC_CTYPE, "");
hDestFile = CreateFileW(argv[2],
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hDestFile == INVALID_HANDLE_VALUE)
{
wprintf(L"Can't create %s\n", argv[2]);
return;
}
swprintf(szFileName, L"%s\\*.*", argv[1]);
hFind = FindFirstFileW(szFileName, &wfd);
if (hFind == INVALID_HANDLE_VALUE)
{
wprintf(L"Can't find %s\n", szFileName);
return;
}
outMaxSize = 0;
dwBufferSize = 0;
dwErrorCount = 0;
dwFileNumber = 0;
dwMaxNumber = 1000;
hHeap = GetProcessHeap();
pbFile = (PBYTE)HeapAlloc(hHeap, 0, 0);
outBuffer = (Byte *)HeapAlloc(hHeap, 0, 0);
pSpiArcInfo = (TSpiArchiveInfo *)HeapAlloc(hHeap,
HEAP_ZERO_MEMORY, dwMaxNumber * sizeof(*pSpiArcInfo));
WriteFile(hDestFile, pSpiArcInfo, 0x10, &dwRead, NULL);
bLZMA = argc >= 4 ? (Byte)wcstoul(argv[3], NULL, 10) : 1;
dwMaxFileNumber = argc == 5 ? wcstoul(argv[4], NULL, 10) : -1;
QueryPerformanceFrequency(&liFrequency);
QueryPerformanceCounter(&liStart);
do
{
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
swprintf(szFileName, L"%s\\%s", argv[1], wfd.cFileName);
hFile = CreateFileW(szFileName,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
wprintf(L"Open %s failed.\n", szFileName);
++dwErrorCount;
continue;
}
if (dwFileNumber >= dwMaxNumber)
{
dwMaxNumber = dwMaxNumber + (dwMaxNumber >> 1);
pSpiArcInfo = (TSpiArchiveInfo *)HeapReAlloc(hHeap, HEAP_ZERO_MEMORY,
pSpiArcInfo, dwMaxNumber * sizeof(*pSpiArcInfo));
}
dwFileSize = GetFileSize(hFile, NULL);
if (dwFileSize > dwBufferSize)
{
dwBufferSize = dwFileSize;
pbFile = (PBYTE)HeapReAlloc(hHeap, 0, pbFile, dwBufferSize);
}
ReadFile(hFile, pbFile, dwFileSize, &dwRead, NULL);
CloseHandle(hFile);
FileType = CheckFileType(pbFile);
wprintf(L"Packing %s ... %s ", szFileName, szFileType[FileType]);
pSpiArcInfo[dwFileNumber].position = SetFilePointer(hDestFile, 0, 0, FILE_CURRENT);
if (dwFileSize > 300 && bLZMA && FileType != UCI && FileType != M4A && FileType != AAC)
{
outSize = dwFileSize / 20 * 21 + (1 << 16) + 4;
if (outSize > outMaxSize)
{
outMaxSize = outSize;
outBuffer = (Byte *)HeapReAlloc(hHeap, 0, outBuffer, outSize);
}
Lzma86_Encode(outBuffer, &outSize, (Byte *)pbFile, dwFileSize, 9, 1 << 27, 0);
pSpiArcInfo[dwFileNumber].compsize = outSize;
WriteFile(hDestFile, outBuffer, outSize, &dwRead, NULL);
wprintf(L"@ compressed ... ");
}
else
{
if (FileType != UCI && FileType != UCA)
{
WriteFile(hDestFile, &dwFileSize, 4, &dwRead, NULL);
}
WriteFile(hDestFile, pbFile, dwFileSize, &dwRead, NULL);
pSpiArcInfo[dwFileNumber].compsize = dwFileSize;
}
if (FileType != UNKNOWN)
{
*(LPDWORD)&pSpiArcInfo[dwFileNumber].method = dwMethod[FileType];
}
int w, h, b;
CHAR *p;
HSTREAM hStream;
static BOOL bBassInit = FALSE;
WideCharToMultiByte(936,
0,
wfd.cFileName,
-1,
pSpiArcInfo[dwFileNumber].filename,
sizeof(pSpiArcInfo[dwFileNumber].filename),
NULL, NULL);
if (FileType == UNKNOWN)
{
CHAR *pExt = PathFindExtensionA(pSpiArcInfo[dwFileNumber].filename);
if (pExt++)
{
lstrcpynA((LPSTR)pSpiArcInfo[dwFileNumber].method, pExt, sizeof(pSpiArcInfo->method));
}
else
{
*(LPDWORD)&pSpiArcInfo[dwFileNumber].method = 'KNU';
}
}
p = PathFindExtensionA(pSpiArcInfo[dwFileNumber].filename);
switch (FileType)
{
case UCA:
UCADecode(pbFile, dwFileSize, NULL,(int *)&pSpiArcInfo[dwFileNumber].filesize);
if (p)
{
lstrcpyA(p + 1, "wav");
}
printf("OK!");
break;
case UCI:
UCIDecode(pbFile, dwFileSize, NULL, NULL, &w, &h, &b);
pSpiArcInfo[dwFileNumber].filesize =
(w * b / 8 + (b == 0x18 ? (w & 3) : 0)) * h + sizeof(TBitMapHeader);
if (p)
{
lstrcpyA(p + 1, "bmp");
}
printf("OK!");
break;
case AAC:
case M4A:
if (bBassInit == FALSE)
{
bBassInit = TRUE;
if (BASS_Init(0, 44100, 0, NULL, NULL) == FALSE)
{
++dwErrorCount;
printf("failed!");
break;
}
}
hStream = FileType == AAC ?
BASS_AAC_StreamCreateFile(TRUE, pbFile, 0, dwFileSize, BASS_STREAM_DECODE) :
BASS_MP4_StreamCreateFile(TRUE, pbFile, 0, dwFileSize, BASS_STREAM_DECODE);
if (hStream)
{
pSpiArcInfo[dwFileNumber].filesize =
(DWORD)BASS_ChannelGetLength(hStream, BASS_POS_BYTE) + + sizeof(TWaveHeader);
BASS_StreamFree(hStream);
if (p)
{
lstrcpyA(p + 1, "wav");
}
printf("OK!");
}
else
{
++dwErrorCount;
printf("failed!");
}
break;
default:
pSpiArcInfo[dwFileNumber].filesize = dwFileSize;
printf("OK!");
}
wprintf(L"\n");
++dwFileNumber;
} while (dwFileNumber < dwMaxFileNumber && FindNextFileW(hFind, &wfd));
