krageon
/
openmw-tes3coop
forked from teamnwah/openmw-tes3coop
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Avoid Mangle for BSA accesses

Browse Source 
The way it was set up was not very efficient, and we're using Ogre for resource
management anyway, so it's best to just use that.
actorid
Chris Robinson 13 years ago
parent 94c3fb81d1
commit a8ebb39883
3 changed files with 282 additions and 231 deletions
Show Stats Download Patch File Download Diff File

7
components/bsa/bsa_archive.cpp
Unescape Escape View File

@ -28,13 +28,11 @@
#include <OgreArchiveFactory.h>
#include <OgreArchiveManager.h>
#include "bsa_file.hpp"
#include <libs/mangle/stream/clients/ogre_datastream.hpp>
namespace
{
using namespace Ogre;
using namespace Mangle::Stream;
using namespace Bsa;
struct ciLessBoost : std::binary_function<std::string, std::string, bool>
@ -239,10 +237,7 @@ public:
// Open the file
StreamPtr strm = narc->getFile(passed.c_str());
// Wrap it into an Ogre::DataStream.
return DataStreamPtr(new Mangle2OgreStream(strm));
return narc->getFile(passed.c_str());
}
bool exists(const String& filename) {

140
components/bsa/bsa_file.cpp
Unescape Escape View File

@ -23,17 +23,95 @@
#include "bsa_file.hpp"
#include <libs/mangle/stream/servers/file_stream.hpp>
#include <libs/mangle/stream/filters/slice_stream.hpp>
#include <stdexcept>
#include <stdlib.h>
#include <assert.h>
#include <OgreDataStream.h>
using namespace std;
using namespace Mangle::Stream;
using namespace Bsa;
class ConstrainedDataStream : public Ogre::DataStream {
std::ifstream mStream;
const size_t mStart;
size_t mPos;
bool mIsEOF;
public:
ConstrainedDataStream(const Ogre::String &fname, size_t start, size_t length)
: mStream(fname.c_str(), std::ios_base::binary), mStart(start), mPos(0), mIsEOF(false)
{
mSize = length;
if(!mStream.seekg(mStart, std::ios_base::beg))
throw std::runtime_error("Error seeking to start of BSA entry");
}
ConstrainedDataStream(const Ogre::String &name, const Ogre::String &fname,
size_t start, size_t length)
: Ogre::DataStream(name), mStream(fname.c_str(), std::ios_base::binary),
mStart(start), mPos(0), mIsEOF(false)
{
mSize = length;
if(!mStream.seekg(mStart, std::ios_base::beg))
throw std::runtime_error("Error seeking to start of BSA entry");
}
virtual size_t read(void *buf, size_t count)
{
mStream.clear();
if(count > mSize-mPos)
{
count = mSize-mPos;
mIsEOF = true;
}
mStream.read(reinterpret_cast<char*>(buf), count);
count = mStream.gcount();
mPos += count;
return count;
}
virtual void skip(long count)
{
if((count >= 0 && (size_t)count <= mSize-mPos) ||
(count < 0 && (size_t)-count <= mPos))
{
mStream.clear();
if(mStream.seekg(count, std::ios_base::cur))
{
mPos += count;
mIsEOF = false;
}
}
}
virtual void seek(size_t pos)
{
if(pos < mSize)
{
mStream.clear();
if(mStream.seekg(pos+mStart, std::ios_base::beg))
{
mPos = pos;
mIsEOF = false;
}
}
}
virtual size_t tell() const
{ return mPos; }
virtual bool eof() const
{ return mIsEOF; }
virtual void close()
{ mStream.close(); }
};
/// Error handling
void BSAFile::fail(const string &msg)
{
@ -74,25 +152,27 @@ void BSAFile::readHeader()
*
*/
assert(!isLoaded);
assert(input);
assert(input->hasSize);
assert(input->hasPosition);
assert(input->isSeekable);
std::ifstream input(filename.c_str(), std::ios_base::binary);
// Total archive size
size_t fsize = input->size();
size_t fsize = 0;
if(input.seekg(0, std::ios_base::end))
{
fsize = input.tellg();
input.seekg(0);
}
if(fsize < 12)
fail("File too small to be a valid BSA archive");
// Get essential header numbers
size_t dirsize, filenum;
{
// First 12 bytes
uint32_t head[3];
input->read(head, 12);
input.read(reinterpret_cast<char*>(head), 12);
if(head[0] != 0x100)
fail("Unrecognized BSA header");
@ -108,20 +188,19 @@ void BSAFile::readHeader()
// Each file must take up at least 21 bytes of data in the bsa. So
// if files*21 overflows the file size then we are guaranteed that
// the archive is corrupt.
if( (filenum*21 > fsize -12) ||
(dirsize+8*filenum > fsize -12) )
if((filenum*21 > fsize -12) || (dirsize+8*filenum > fsize -12) )
fail("Directory information larger than entire archive");
// Read the offset info into a temporary buffer
vector<uint32_t> offsets(3*filenum);
input->read(&offsets[0], 12*filenum);
input.read(reinterpret_cast<char*>(&offsets[0]), 12*filenum);
// Read the string table
stringBuf.resize(dirsize-12*filenum);
input->read(&stringBuf[0], stringBuf.size());
input.read(&stringBuf[0], stringBuf.size());
// Check our position
assert(input->tell() == 12+dirsize);
assert(input.tellg() == 12+dirsize);
// Calculate the offset of the data buffer. All file offsets are
// relative to this. 12 header bytes + directory + hash table
@ -150,44 +229,29 @@ void BSAFile::readHeader()
/// Get the index of a given file name, or -1 if not found
int BSAFile::getIndex(const char *str) const
{
Lookup::const_iterator it;
it = lookup.find(str);
Lookup::const_iterator it = lookup.find(str);
if(it == lookup.end())
return -1;
if(it == lookup.end()) return -1;
else
{
int res = it->second;
assert(res >= 0 && res < static_cast<int> (files.size()));
assert(res >= 0 && (size_t)res < files.size());
return res;
}
}
/// Open an archive file.
void BSAFile::open(const string &file)
{
filename = file;
input = StreamPtr(new FileStream(file));
readHeader();
}
/** Open an archive from a generic stream. The 'name' parameter is
used for error messages.
*/
void BSAFile::open(StreamPtr inp, const string &name)
{
filename = name;
input = inp;
readHeader();
}
StreamPtr BSAFile::getFile(const char *file)
Ogre::DataStreamPtr BSAFile::getFile(const char *file)
{
assert(file);
int i = getIndex(file);
if(i == -1)
fail("File not found: " + string(file));
FileStruct &fs = files[i];
return StreamPtr(new SliceStream(input, fs.offset, fs.fileSize));
const FileStruct &fs = files[i];
return Ogre::DataStreamPtr(new ConstrainedDataStream(filename, fs.offset, fs.fileSize));
}

26
components/bsa/bsa_file.hpp
Unescape Escape View File

@ -24,13 +24,15 @@
#ifndef BSA_BSA_FILE_H
#define BSA_BSA_FILE_H
#include <libs/mangle/stream/stream.hpp>
#include <libs/platform/stdint.h>
#include <libs/platform/strings.h>
#include <string>
#include <vector>
#include <map>
#include <OgreDataStream.h>
namespace Bsa
{
@ -40,7 +42,6 @@ namespace Bsa
class BSAFile
{
public:
/// Represents one file entry in the archive
struct FileStruct
{
@ -50,16 +51,11 @@ class BSAFile
uint32_t fileSize, offset;
// Zero-terminated file name
char* name;
const char *name;
};
typedef std::vector<FileStruct> FileList;
private:
/// The archive source
Mangle::Stream::StreamPtr input;
/// Table of files in this archive
FileList files;
@ -96,30 +92,26 @@ class BSAFile
int getIndex(const char *str) const;
public:
/* -----------------------------------
* BSA management methods
* -----------------------------------
*/
BSAFile()
: input(), isLoaded(false) {}
: isLoaded(false)
{ }
/// Open an archive file.
void open(const std::string &file);
/** Open an archive from a generic stream. The 'name' parameter is
used for error messages.
*/
void open(Mangle::Stream::StreamPtr inp, const std::string &name);
/* -----------------------------------
* Archive file routines
* -----------------------------------
*/
/// Check if a file exists
bool exists(const char *file) const { return getIndex(file) != -1; }
bool exists(const char *file) const
{ return getIndex(file) != -1; }
/** Open a file contained in the archive. Throws an exception if the
file doesn't exist.
@ -127,7 +119,7 @@ class BSAFile
NOTE: All files opened from one archive will share a common file
handle. This is NOT thread safe.
*/
Mangle::Stream::StreamPtr getFile(const char *file);
Ogre::DataStreamPtr getFile(const char *file);
/// Get a list of all files
const FileList &getList() const

Write Preview
Loading…
Cancel
Save