//: Removes the directory or file specified by path
OsStatus OsFileSystem::remove(const OsPath& path, UtlBoolean bRecursive, UtlBoolean bForce)
{
OsStatus retval = OS_INVALID;
OsFileInfo info;
OsPath testpath = path;
getFileInfo(testpath,info);
if (info.isDir())
{
if (bRecursive)
{
retval = removeTree(path,bForce);
}
else
{
if (rmdir((char *)path.data()) != -1)
retval = OS_SUCCESS;
}
}
else
{
if (bForce)
setReadOnly(path,FALSE);
if (::remove(path.data()) != -1)
retval = OS_SUCCESS;
}
return retval;
}
bool LocalFileLoader::IsDirectory() {
FileInfo info;
if (getFileInfo(filename_.c_str(), &info)) {
return info.isDirectory;
}
return false;
}
UtlBoolean OsFileLinux::isReadonly() const
{
OsFileInfoLinux info;
getFileInfo(info);
return info.mbIsReadOnly;
}
int main(int argc, char *argv[]){
int n;
struct Filethings f[BUF_LENGTH];
calling(argv[1]);
n=getFileInfo(f);
//compareFile(f,n,argv[1]);
}
void __UmdReplace(std::string filepath) {
// Only get system from disc0 seems have been enough.
IFileSystem* currentUMD = pspFileSystem.GetSystem("disc0:");
if (!currentUMD)
return;
IFileSystem* umd2;
FileInfo info;
if (!getFileInfo(filepath.c_str(), &info)) // This shouldn't happen, but for safety.
return;
if (info.isDirectory) {
umd2 = new VirtualDiscFileSystem(&pspFileSystem, filepath);
} else {
auto bd = constructBlockDevice(filepath.c_str());
if (!bd)
return;
umd2 = new ISOFileSystem(&pspFileSystem, bd);
pspFileSystem.Remount(currentUMD, umd2);
}
delete currentUMD;
// TODO Is this always correct if UMD was not activated?
u32 notifyArg = PSP_UMD_PRESENT | PSP_UMD_READABLE | PSP_UMD_CHANGED;
if (driveCBId != -1)
__KernelNotifyCallback(driveCBId, notifyArg);
}
static std::string SymbolMapFilename(const char *currentFilename, char* ext)
{
FileInfo info;
std::string result = currentFilename;
// can't fail, definitely exists if it gets this far
getFileInfo(currentFilename, &info);
if (info.isDirectory)
{
#ifdef _WIN32
char* slash = "\\";
#else
char* slash = "/";
#endif
if (!endsWith(result,slash))
result += slash;
return result + ".ppsspp-symbols" + ext;
} else {
size_t dot = result.rfind('.');
if (dot == result.npos)
return result + ext;
result.replace(dot, result.npos, ext);
return result;
}
}
void ReplayWindow::openReplay(String path)
{
if (FileInfo* info = (replay ? replay->getFileInfo() : NULL))
{
if (info->path.icompare(path) == 0)
{
FileInfo cur;
getFileInfo(path, cur);
if (cur.ftime == info->ftime)
return;
}
}
delete replay;
viewItem = NULL;
uint32 error;
replay = W3GReplay::load(path, false, &error);
if (replay == NULL)
{
switch (error)
{
case W3GReplay::eNoFile:
failureInfo->setText("File not found");
break;
case W3GReplay::eBadFile:
failureInfo->setText("Failed to parse file");
break;
case W3GReplay::eNoMap:
failureInfo->setText("No map data");
break;
}
failureInfo->resetSize();
}
update();
}
u64 GameInfo::GetInstallDataSizeInBytes() {
if (fileType == FILETYPE_PSP_SAVEDATA_DIRECTORY || fileType == FILETYPE_PPSSPP_SAVESTATE) {
return 0;
}
std::vector<std::string> saveDataDir = GetSaveDataDirectories();
u64 totalSize = 0;
u64 filesSizeInDir = 0;
for (size_t j = 0; j < saveDataDir.size(); j++) {
std::vector<FileInfo> fileInfo;
getFilesInDir(saveDataDir[j].c_str(), &fileInfo);
// Note: getFileInDir does not fill in fileSize properly.
for (size_t i = 0; i < fileInfo.size(); i++) {
FileInfo finfo;
getFileInfo(fileInfo[i].fullName.c_str(), &finfo);
if (!finfo.isDirectory)
filesSizeInDir += finfo.size;
}
if (filesSizeInDir >= 0xA00000) {
// HACK: Generally the savedata size in a dir shouldn't be more than 10MB.
// This is probably GameInstall data.
totalSize += filesSizeInDir;
}
filesSizeInDir = 0;
}
return totalSize;
}
bool CVolume3D::_loadRAWFile(const char *fname)
{
int bpv; //bytes per voxel
if (!getFileInfo(fname, m_nx, m_ny, m_nz, bpv, m_vBrickBuffer, m_nBrick)){
printf("Cannot find the info file associated with %s.\n", fname);
return false;
}
m_nxy = m_nx*m_ny;
FILE *fp = fopen(fname, _RB_);
if (fp==NULL) return false;
const int nsize = m_nx*m_ny*m_nz;
m_pDensityVolume = (float*)(new unsigned char [nsize*bpv]);
fread(m_pDensityVolume, bpv*m_nx, m_ny*m_nz, fp);
fclose(fp);
switch(bpv){
case 1:
{
float *p=convertByteToFloat((unsigned char*)m_pDensityVolume, m_nx, m_ny, m_nz);
delete [] m_pDensityVolume;
m_pDensityVolume =p;
break;
}
case 4:
break;
}
m_nDensityVolumeType = GL_FLOAT;
return true;
}
bool LoadFile(std::string &filename, std::string *error_string) {
INFO_LOG(LOADER,"Identifying file...");
// Note that this can modify filename!
switch (Identify_File(filename)) {
case FILETYPE_PSP_PBP_DIRECTORY:
{
std::string ebootFilename = filename + "/EBOOT.PBP";
FileInfo fileInfo;
getFileInfo((filename + "/EBOOT.PBP").c_str(), &fileInfo);
if (fileInfo.exists) {
INFO_LOG(LOADER, "File is a PBP in a directory!");
std::string path = filename;
size_t pos = path.find("/PSP/GAME/");
if (pos != std::string::npos)
pspFileSystem.SetStartingDirectory("ms0:" + path.substr(pos));
return Load_PSP_ELF_PBP(ebootFilename.c_str(), error_string);
} else {
*error_string = "No EBOOT.PBP, misidentified game";
return false;
}
}
case FILETYPE_PSP_PBP:
case FILETYPE_PSP_ELF:
{
INFO_LOG(LOADER,"File is an ELF or loose PBP!");
return Load_PSP_ELF_PBP(filename.c_str(), error_string);
}
case FILETYPE_PSP_ISO:
case FILETYPE_PSP_ISO_NP:
case FILETYPE_PSP_DISC_DIRECTORY: // behaves the same as the mounting is already done by now
pspFileSystem.SetStartingDirectory("disc0:/PSP_GAME/USRDIR");
return Load_PSP_ISO(filename.c_str(), error_string);
case FILETYPE_ERROR:
ERROR_LOG(LOADER, "Could not read file");
*error_string = "Error reading file";
break;
case FILETYPE_ARCHIVE_RAR:
*error_string = "File is compressed (RAR).\nPlease decompress first (try WinRAR)";
break;
case FILETYPE_ARCHIVE_ZIP:
*error_string = "File is compressed (ZIP).\nPlease decompress first (try WinRAR)";
break;
case FILETYPE_UNKNOWN_BIN:
case FILETYPE_UNKNOWN_ELF:
case FILETYPE_UNKNOWN:
default:
ERROR_LOG(LOADER, "Failed to identify file");
*error_string = "Failed to identify file";
break;
}
return false;
}
bool LocalFileLoader::Exists() {
// If we couldn't open it for reading, we say it does not exist.
if (f_ || IsDirectory()) {
FileInfo info;
return getFileInfo(filename_.c_str(), &info);
}
return false;
}
void auditPrepare()
{
getAllRomsetInfo();
clearAllRomsetState();
freeArchiveList();
getFileInfo(false);
}
// We gather the game info before actually loading/booting the ISO
// to determine if the emulator should enable extra memory and
// double-sized texture coordinates.
void InitMemoryForGameISO(std::string fileToStart) {
IFileSystem* umd2;
// check if it's a disc directory
FileInfo info;
if (!getFileInfo(fileToStart.c_str(), &info)) return;
if (info.isDirectory)
{
umd2 = new VirtualDiscFileSystem(&pspFileSystem, fileToStart);
}
else
{
auto bd = constructBlockDevice(fileToStart.c_str());
// Can't init anything without a block device...
if (!bd)
return;
umd2 = new ISOFileSystem(&pspFileSystem, bd);
}
// Parse PARAM.SFO
//pspFileSystem.Mount("host0:",umd2);
pspFileSystem.Mount("umd0:", umd2);
pspFileSystem.Mount("umd1:", umd2);
pspFileSystem.Mount("disc0:", umd2);
pspFileSystem.Mount("umd:", umd2);
std::string gameID;
std::string sfoPath("disc0:/PSP_GAME/PARAM.SFO");
PSPFileInfo fileInfo = pspFileSystem.GetFileInfo(sfoPath.c_str());
if (fileInfo.exists)
{
u8 *paramsfo = new u8[(size_t)fileInfo.size];
u32 fd = pspFileSystem.OpenFile(sfoPath, FILEACCESS_READ);
pspFileSystem.ReadFile(fd, paramsfo, fileInfo.size);
pspFileSystem.CloseFile(fd);
if (g_paramSFO.ReadSFO(paramsfo, (size_t)fileInfo.size))
{
gameID = g_paramSFO.GetValueString("DISC_ID");
for (size_t i = 0; i < ARRAY_SIZE(g_HDRemasters); i++) {
if(g_HDRemasters[i].gameID == gameID) {
g_RemasterMode = true;
Memory::g_MemorySize = g_HDRemasters[i].MemorySize;
if(g_HDRemasters[i].DoubleTextureCoordinates)
g_DoubleTextureCoordinates = true;
break;
}
}
DEBUG_LOG(LOADER, "HDRemaster mode is %s", g_RemasterMode? "true": "false");
}
delete [] paramsfo;
}
}
bool getFileModificationTime(const String& path, time_t& time)
{
BY_HANDLE_FILE_INFORMATION fileInformation;
if (!getFileInfo(path, fileInformation))
return false;
getFileModificationTimeFromFileInfo(fileInformation, time);
return true;
}
bool getFileSize(const String& path, long long& size)
{
BY_HANDLE_FILE_INFORMATION fileInformation;
if (!getFileInfo(path, fileInformation))
return false;
getFileSizeFromFileInfo(fileInformation, size);
return true;
}
UtlBoolean OsFileWnt::isReadonly() const
{
UtlBoolean retval = FALSE;
OsFileInfoWnt info;
getFileInfo(info);
return info.mbIsReadOnly;
}
bool File::isDirectory() const
{
WIN32_FIND_DATA fileInfo;
if (getFileInfo(&fileInfo)) {
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
return true;
}
}
return false;
}
bool LocalFileLoader::Exists() {
// If we couldn't open it for reading, we say it does not exist.
#ifndef _WIN32
if (fd_ != -1 || IsDirectory()) {
#else
if (handle_ != INVALID_HANDLE_VALUE || IsDirectory()) {
#endif
FileInfo info;
return getFileInfo(filename_.c_str(), &info);
}
return false;
}
bool LocalFileLoader::IsDirectory() {
FileInfo info;
if (getFileInfo(filename_.c_str(), &info)) {
return info.isDirectory;
}
return false;
}
UtlBoolean OsDirLinux::exists()
{
UtlBoolean stat = FALSE;
OsFileInfoLinux info;
OsStatus retval = getFileInfo(info);
if (retval == OS_SUCCESS)
stat = TRUE;
return stat;
}
UINT64 File::lastModified() const
{
WIN32_FIND_DATA fileInfo;
if (!getFileInfo(&fileInfo)) {
return 0;
}
DateTime dt(fileInfo.ftLastWriteTime);
return dt.getTime();
}
UINT64 File::length() const
{
WIN32_FIND_DATA fileInfo;
if (!getFileInfo(&fileInfo)) {
return 0;
}
INT64 maxDWORDPlusOne = 1 + (INT64)MAXDWORD;
return fileInfo.nFileSizeHigh * maxDWORDPlusOne + fileInfo.nFileSizeLow;
}
bool DirectoryAssetReader::GetFileInfo(const char *path, FileInfo *info)
{
char new_path[256] = {0};
// Check if it already contains the path
if (strlen(path) > strlen(path_) && 0 == memcmp(path, path_, strlen(path_))) {
}
else {
strcpy(new_path, path_);
}
strcat(new_path, path);
return getFileInfo(new_path, info);
}
//prints out all of the images for the given directory
//spawns new threads for each new directory encountered
void *showimagesV1(void *arg1)
{
//get argument
char *dir = (char*)arg1;
DIR *dp = opendir(dir);
if(dp == NULL)
{
printf("Cannot open directory: %s\n", dir);
return NULL;
}
//scan through everything in current directory
struct dirent *entry;
while((entry = readdir(dp)) != NULL)
{
//ignore . and .. directories
if(strcmp(".",entry->d_name) == 0 ||strcmp("..",entry->d_name) == 0)
{continue;}
pthread_mutex_lock(&dirCountMutex);
dirCount++;
pthread_mutex_unlock(&dirCountMutex);
//get full file name (with path) of current file
char curName[strlen(dir) + strlen(entry->d_name) + 3];
strcpy(curName, dir);
strcat(curName, "/");
strcat(curName, entry->d_name);
//see if the entry is a directory by attempting to open it
DIR *dp2 = opendir(curName);
if(dp2 != NULL)
{
//entry is a directory
closedir(dp2); //close directory
char* curDir = (char*)malloc(strlen(curName) + 1); //malloc to avoid string deletion
strcpy(curDir, curName);
thread_creator(curDir); //spawn new thread for the directory
}
else if(getFileExtension(entry->d_name) != NULL) //file is not a directory, check extension
{
//get information about file
pthread_mutex_lock(&FilePrinting);
getFileInfo(curName);
pthread_mutex_unlock(&FilePrinting);
//printf("%s\n",curName);
pthread_mutex_lock(&CountMutex);
count++;
pthread_mutex_unlock(&CountMutex);
}
}
closedir(dp); //close directory
return NULL;
}
int main(int argc, char* argv[])
{
FILE* f;
struct file input;
int k;
int lows[argc];
int highs[argc];
int high, low, numRanges = 0;
input = getFileInfo("(standard input)", stdin);
fclose(f);
for(k = 1; k < argc; k++)
{
if(strncmp(argv[k], "-h", 2) == 0)
{
fprintf(stderr, "This program reads a sound file from the standard input stream and writes it to the standard output stream. It removes all samples specified as arguments. The arguments are written as low..high \n");
}
else
{
/*Looks for range*/
if(sscanf(argv[k], "%d..%d", &low, &high) > 0)
{
if( low >= 0 && high <= input.samples)
{
lows[numRanges] = low;
highs[numRanges] = high;
numRanges++;
}
else {
fprintf(stderr, "\nYou specified ranges outside of the file sample ranges\n");
}
}
}
}
if(input.error == 0)
{
input = removeRange(lows, highs, numRanges, input);
if(input.error == 5)
{
fprintf(stderr, "Error: Boundaries written incorrectly");
printf("\n");
return 0;
}
}
if(input.type == 1) {
convert(input, stdout, 2);
}
else if(input.type == 2) {
convert(input, stdout, 1);
}
}
bool getFileModificationTime(const String& path, time_t& result)
{
BY_HANDLE_FILE_INFORMATION fileInformation;
if (!getFileInfo(path, fileInformation))
return false;
ULARGE_INTEGER t;
memcpy(&t, &fileInformation.ftLastWriteTime, sizeof(t));
result = t.QuadPart * 0.0000001 - 11644473600.0;
return true;
}
bool getFileSize(const String& path, long long& result)
{
BY_HANDLE_FILE_INFORMATION fileInformation;
if (!getFileInfo(path, fileInformation))
return false;
ULARGE_INTEGER fileSize;
fileSize.LowPart = fileInformation.nFileSizeLow;
fileSize.HighPart = fileInformation.nFileSizeHigh;
result = fileSize.QuadPart;
return true;
}
void TakeScreenshot() {
g_TakeScreenshot = false;
mkDir(g_Config.memCardDirectory + "/PSP/SCREENSHOT");
// First, find a free filename.
int i = 0;
char temp[256];
while (i < 10000){
if(g_Config.bScreenshotsAsPNG)
sprintf(temp, "%s/PSP/SCREENSHOT/screen%05d.png", g_Config.memCardDirectory.c_str(), i);
else
sprintf(temp, "%s/PSP/SCREENSHOT/screen%05d.jpg", g_Config.memCardDirectory.c_str(), i);
FileInfo info;
if (!getFileInfo(temp, &info))
break;
i++;
}
// Okay, allocate a buffer.
u8 *buffer = new u8[3 * pixel_xres * pixel_yres];
// Silly openGL reads upside down, we flip to another buffer for simplicity.
u8 *flipbuffer = new u8[3 * pixel_xres * pixel_yres];
glReadPixels(0, 0, pixel_xres, pixel_yres, GL_RGB, GL_UNSIGNED_BYTE, buffer);
for (int y = 0; y < pixel_yres; y++) {
memcpy(flipbuffer + y * pixel_xres * 3, buffer + (pixel_yres - y - 1) * pixel_xres * 3, pixel_xres * 3);
}
if (g_Config.bScreenshotsAsPNG) {
png_image png;
memset(&png, 0, sizeof(png));
png.version = PNG_IMAGE_VERSION;
png.format = PNG_FORMAT_RGB;
png.width = pixel_xres;
png.height = pixel_yres;
png_image_write_to_file(&png, temp, 0, flipbuffer, pixel_xres * 3, NULL);
png_image_free(&png);
} else {
jpge::params params;
params.m_quality = 90;
compress_image_to_jpeg_file(temp, pixel_xres, pixel_yres, 3, flipbuffer, params);
}
delete [] buffer;
delete [] flipbuffer;
osm.Show(temp);
}
void FileSystemAssetBrowserModel::populateFolderContents(const IItem* item)
{
impl_->folderContents_.clear();
if (item)
{
auto folderItem = dynamic_cast<const BaseAssetObjectItem*>(item);
if (folderItem)
{
std::vector<std::string> paths;
auto fileInfo = folderItem->getFileInfo();
paths.push_back(fileInfo->fullPath());
addFolderItems(paths);
}
}
}
static int64_t GetDirectoryRecursiveSize(std::string path) {
std::vector<FileInfo> fileInfo;
getFilesInDir(path.c_str(), &fileInfo);
int64_t sizeSum = 0;
// Note: getFileInDir does not fill in fileSize properly.
for (size_t i = 0; i < fileInfo.size(); i++) {
FileInfo finfo;
getFileInfo(fileInfo[i].fullName.c_str(), &finfo);
if (!finfo.isDirectory)
sizeSum += finfo.size;
else
sizeSum += GetDirectoryRecursiveSize(finfo.fullName);
}
return sizeSum;
}
//------------------------------
BitmapTex* MaterialCreator::createTexture( const COLLADAFW::EffectCommon& effectCommon, const COLLADAFW::Texture& texture )
{
BitmapTex* bitmapTexture = NewDefaultBitmapTex();
COLLADAFW::SamplerID samplerId = texture.getSamplerId();
const COLLADAFW::Sampler* sampler = effectCommon.getSamplerPointerArray()[ samplerId ];
const COLLADAFW::UniqueId& imageUniqueId = sampler->getSourceImage();
const COLLADAFW::Image* image = getFWImageByUniqueId( imageUniqueId );
if ( !image )
return 0;
COLLADABU::URI imageUri( getFileInfo().absoluteFileUri, image->getImageURI().getURIString() );
COLLADABU::NativeString imageFileName( imageUri.toNativePath().c_str(), COLLADABU::NativeString::ENCODING_UTF8 );
bitmapTexture->SetMapName(const_cast<char*>(imageFileName.c_str()));
bitmapTexture->LoadMapFiles(0);
UVGen* uvGen = bitmapTexture->GetTheUVGen();
StdUVGen* stdUVGen = (StdUVGen*)uvGen;
// reset all flags
//stdUVGen->SetFlag(U_WRAP|V_WRAP, 1);
//stdUVGen->SetFlag(U_MIRROR|V_MIRROR, 0);
int tiling = 0;
if ( sampler->getWrapS() == COLLADAFW::Sampler::WRAP_MODE_WRAP )
{
tiling += 1<<0;
}
else if ( sampler->getWrapS() == COLLADAFW::Sampler::WRAP_MODE_MIRROR )
{
tiling += 1<<2;
}
if ( sampler->getWrapT() == COLLADAFW::Sampler::WRAP_MODE_WRAP )
{
tiling += 1<<1;
}
else if ( sampler->getWrapT() == COLLADAFW::Sampler::WRAP_MODE_MIRROR )
{
tiling += 1<<3;
}
stdUVGen->SetTextureTiling(tiling);
return bitmapTexture;
}
