mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-07-30 01:29:42 -06:00
Cleaning up XK's mess, added a simple profiler, minor disasm fix. Too lazy to split it up into individual changes. Savestates not yet working.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@381 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
hrydgard
@ -20,208 +20,3 @@
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
// Not using file mapping, just bog standard fopen and friends. We trust them to be fast
|
||||
// enough to not be the bottleneck.
|
||||
|
||||
ChunkFile::ChunkFile(const char *filename, ChunkFileMode _mode)
|
||||
{
|
||||
mode = _mode;
|
||||
data = 0;
|
||||
|
||||
didFail = false;
|
||||
f = fopen(filename, mode == MODE_WRITE ? "wb" : "rb");
|
||||
if (!f) {
|
||||
didFail = true;
|
||||
return;
|
||||
}
|
||||
|
||||
fseek(f, 0, SEEK_END);
|
||||
fsize = ftell(f);
|
||||
eof = fsize;
|
||||
|
||||
fseek(f, 0, SEEK_SET);
|
||||
|
||||
stack_ptr = 0;
|
||||
}
|
||||
|
||||
ChunkFile::~ChunkFile()
|
||||
{
|
||||
if (f)
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
int ChunkFile::ReadInt()
|
||||
{
|
||||
int x;
|
||||
fread(&x, 4, 1, f);
|
||||
return x;
|
||||
}
|
||||
|
||||
void ChunkFile::WriteInt(int x)
|
||||
{
|
||||
fwrite(&x, 4, 1, f);
|
||||
}
|
||||
|
||||
bool ChunkFile::Do(void *ptr, int size)
|
||||
{
|
||||
int sz;
|
||||
switch (mode) {
|
||||
case MODE_READ:
|
||||
sz = ReadInt();
|
||||
if (sz != size)
|
||||
return false;
|
||||
fread(ptr, size, 1, f);
|
||||
//fseek(f, ((size + 3) & ~3) - size, SEEK_CUR);
|
||||
break;
|
||||
case MODE_WRITE:
|
||||
WriteInt(size);
|
||||
fwrite(ptr, size, 1, f);
|
||||
//fseek(f, ((size + 3) & ~3) - size, SEEK_CUR);
|
||||
break;
|
||||
case MODE_VERIFY:
|
||||
sz = ReadInt();
|
||||
if (sz != size)
|
||||
return false;
|
||||
//fseek(f, (size + 3) & ~3, SEEK_CUR);
|
||||
fseek(f, size, SEEK_CUR);
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Do variable size array (probably heap-allocated)
|
||||
bool ChunkFile::DoArray(void *ptr, int size, int arrSize) {
|
||||
int sz;
|
||||
|
||||
if(ptr == NULL)
|
||||
return false;
|
||||
|
||||
switch (mode) {
|
||||
case MODE_READ:
|
||||
sz = ReadInt();
|
||||
if (sz != size)
|
||||
return false;
|
||||
sz = ReadInt();
|
||||
if (sz != arrSize)
|
||||
return false;
|
||||
|
||||
fread(ptr, size, arrSize, f);
|
||||
//fseek(f, (((arrSize * size) + 3) & ~3) - (arrSize * size),
|
||||
// SEEK_CUR);
|
||||
|
||||
break;
|
||||
case MODE_WRITE:
|
||||
WriteInt(size);
|
||||
WriteInt(arrSize);
|
||||
|
||||
fwrite(ptr, size, arrSize, f);
|
||||
//fseek(f, (((arrSize * size) + 3) & ~3) - (arrSize * size),
|
||||
// SEEK_CUR);
|
||||
|
||||
break;
|
||||
case MODE_VERIFY:
|
||||
sz = ReadInt();
|
||||
if (sz != size)
|
||||
return false;
|
||||
sz = ReadInt();
|
||||
if (sz != arrSize)
|
||||
return false;
|
||||
|
||||
//for(int i = 0; i < arrSize; i++)
|
||||
//fseek(f, (size + 3) & ~3, SEEK_CUR);
|
||||
|
||||
fseek(f, arrSize * size, SEEK_CUR);
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
//let's get into the business
|
||||
bool ChunkFile::Descend(const char *cid)
|
||||
{
|
||||
return true;
|
||||
unsigned int id = *reinterpret_cast<const unsigned int*>(cid);
|
||||
if (mode == MODE_READ)
|
||||
{
|
||||
bool found = false;
|
||||
int startPos = ftell(f);
|
||||
ChunkInfo temp = stack[stack_ptr];
|
||||
|
||||
//save information to restore after the next Ascend
|
||||
stack[stack_ptr].parentStartLocation = startPos;
|
||||
stack[stack_ptr].parentEOF = eof;
|
||||
|
||||
unsigned int firstID = 0;
|
||||
//let's search through children..
|
||||
while (ftell(f) < eof)
|
||||
{
|
||||
stack[stack_ptr].ID = ReadInt();
|
||||
if (firstID == 0)
|
||||
firstID = stack[stack_ptr].ID|1;
|
||||
stack[stack_ptr].length = ReadInt();
|
||||
stack[stack_ptr].startLocation = ftell(f);
|
||||
if (stack[stack_ptr].ID == id)
|
||||
{
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
fseek(f, stack[stack_ptr].length, SEEK_CUR); //try next block
|
||||
}
|
||||
}
|
||||
|
||||
//if we found nothing, return false so the caller can skip this
|
||||
if (!found)
|
||||
{
|
||||
stack[stack_ptr] = temp;
|
||||
fseek(f, stack[stack_ptr].parentStartLocation, SEEK_SET);
|
||||
return false;
|
||||
}
|
||||
|
||||
//descend into it
|
||||
//pos was set inside the loop above
|
||||
eof = stack[stack_ptr].startLocation + stack[stack_ptr].length;
|
||||
stack_ptr++;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
//write a chunk id, and prepare for filling in length later
|
||||
WriteInt(id);
|
||||
WriteInt(0); //will be filled in by Ascend
|
||||
stack[stack_ptr].startLocation = ftell(f);
|
||||
stack_ptr++;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
//let's ascend out
|
||||
void ChunkFile::Ascend()
|
||||
{
|
||||
return;
|
||||
if (mode == MODE_READ)
|
||||
{
|
||||
//ascend, and restore information
|
||||
stack_ptr--;
|
||||
fseek(f, stack[stack_ptr].parentStartLocation, SEEK_SET);
|
||||
eof = stack[stack_ptr].parentEOF;
|
||||
}
|
||||
else
|
||||
{
|
||||
stack_ptr--;
|
||||
//now fill in the written length automatically
|
||||
int posNow = ftell(f);
|
||||
fseek(f, stack[stack_ptr].startLocation - 4, SEEK_SET);
|
||||
WriteInt(posNow - stack[stack_ptr].startLocation);
|
||||
fseek(f, posNow, SEEK_SET);
|
||||
}
|
||||
}
|
||||
|
||||
int ChunkFile::GetCurrentChunkSize()
|
||||
{
|
||||
if (stack_ptr)
|
||||
return stack[stack_ptr - 1].length;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -15,103 +15,67 @@
|
||||
// Official SVN repository and contact information can be found at
|
||||
// http://code.google.com/p/dolphin-emu/
|
||||
|
||||
#ifndef _CHUNKFILE_H
|
||||
#define _CHUNKFILE_H
|
||||
#ifndef _POINTERWRAP_H
|
||||
#define _POINTERWRAP_H
|
||||
|
||||
// Class to read/write/verify hierarchical binary file formats.
|
||||
// Grabbed from one of my older projects and modified heavily.
|
||||
// Works more like a RIFF file than a Google Protocol Buffer, for example.
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
//TO REMEMBER WHEN USING:
|
||||
#include "Common.h"
|
||||
|
||||
//EITHER a chunk contains ONLY data
|
||||
//OR it contains ONLY other chunks
|
||||
//otherwise the scheme breaks...
|
||||
|
||||
class ChunkFile
|
||||
class PointerWrap
|
||||
{
|
||||
public:
|
||||
enum ChunkFileMode
|
||||
enum Mode // also defined in pluginspecs.h. Didn't want to couple them.
|
||||
{
|
||||
MODE_READ,
|
||||
MODE_WRITE,
|
||||
MODE_VERIFY,
|
||||
};
|
||||
private:
|
||||
struct ChunkInfo
|
||||
{
|
||||
int startLocation;
|
||||
int parentStartLocation;
|
||||
int parentEOF;
|
||||
unsigned int ID;
|
||||
int length;
|
||||
MODE_READ = 1,
|
||||
MODE_WRITE = 2,
|
||||
MODE_MEASURE = 3,
|
||||
};
|
||||
|
||||
ChunkInfo stack[8];
|
||||
int stack_ptr;
|
||||
|
||||
char *data;
|
||||
int fsize;
|
||||
int eof;
|
||||
|
||||
ChunkFileMode mode;
|
||||
FILE *f;
|
||||
bool didFail;
|
||||
|
||||
// Used for internal bookkeeping only.
|
||||
int ReadInt();
|
||||
void WriteInt(int x);
|
||||
u8 **ptr;
|
||||
Mode mode;
|
||||
|
||||
public:
|
||||
PointerWrap(u8 **ptr_, Mode mode_) : ptr(ptr_), mode(mode_) {}
|
||||
PointerWrap(unsigned char **ptr_, int mode_) : ptr((u8**)ptr_), mode((Mode)mode_) {}
|
||||
|
||||
ChunkFile(const char *filename, ChunkFileMode mode);
|
||||
~ChunkFile();
|
||||
void SetMode(Mode mode_) {mode = mode_;}
|
||||
Mode GetMode() const {return mode;}
|
||||
u8 **GetPPtr() {return ptr;}
|
||||
|
||||
// Only pass 4-character IDs.
|
||||
bool Descend(const char *id);
|
||||
void Ascend();
|
||||
|
||||
//void Do(int &i);
|
||||
//bool Do(std::string &s);
|
||||
bool Do(void *ptr, int size);
|
||||
|
||||
bool DoArray(void *ptr, int size, int arrSize);
|
||||
|
||||
// Future
|
||||
// bool DoCompressed(void *ptr, int size)
|
||||
void DoVoid(void *data, int size)
|
||||
{
|
||||
switch (mode)
|
||||
{
|
||||
case MODE_READ: memcpy(data, *ptr, size); break;
|
||||
case MODE_WRITE: memcpy(*ptr, data, size); break;
|
||||
case MODE_MEASURE: break; // MODE_MEASURE - don't need to do anything
|
||||
default: break; // throw an error?
|
||||
}
|
||||
(*ptr) += size;
|
||||
}
|
||||
|
||||
// Store maps to file. Very useful.
|
||||
template<class T>
|
||||
bool Do(std::map<unsigned int, T> &x) {
|
||||
return false;
|
||||
void Do(std::map<unsigned int, T> &x) {
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Store vectors.
|
||||
template<class T>
|
||||
bool Do(std::vector<T> &x) {
|
||||
template<class T>
|
||||
void Do(std::vector<T> &x) {
|
||||
}
|
||||
|
||||
|
||||
// Disable size checks to save size for variable size array storing
|
||||
template<class T>
|
||||
bool DoArray(T *x, int arrSize) {
|
||||
return DoArray((void *)x, sizeof(T), arrSize);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void DoArray(T *x, int count) {
|
||||
DoVoid((void *)x, sizeof(T) * count);
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
bool Do(T &x) {
|
||||
template<class T>
|
||||
void Do(T &x) {
|
||||
DoVoid((void *)&x, sizeof(x));
|
||||
}
|
||||
|
||||
int GetCurrentChunkSize();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -118,7 +118,7 @@ void* DynamicLibrary::Get(const char* funcname) const
|
||||
retval = GetProcAddress(library, funcname);
|
||||
//if (!retval)
|
||||
//{
|
||||
//PanicAlert("Did not find function %s in library %s.", funcname, library_file.c_str());
|
||||
// PanicAlert("Did not find function %s in library %s.", funcname, library_file.c_str());
|
||||
//}
|
||||
#else
|
||||
retval = dlsym(library, funcname);
|
||||
|
||||
Reference in New Issue
Block a user