//---------------------------------------------------------------------
void DeflateStream::seek( size_t pos )
{
if (!mIsCompressedValid)
{
mCompressedStream->seek(pos);
return;
}
if (getAccessMode() & WRITE)
{
mTmpWriteStream->seek(pos);
}
else
{
if (pos == 0)
{
mCurrentPos = 0;
mZStream->next_in = mTmp;
mCompressedStream->seek(0);
mZStream->avail_in = static_cast<uint>(mCompressedStream->read(mTmp, getAvailInForSinglePass()));
inflateReset(mZStream);
}
else
{
skip(pos - tell());
}
}
}
//---------------------------------------------------------------------
void DeflateStream::seek( size_t pos )
{
if (!mIsCompressedValid)
{
mCompressedStream->seek(pos);
return;
}
if (getAccessMode() & WRITE)
{
mTmpWriteStream->seek(pos);
}
else
{
if (pos == 0)
{
mCurrentPos = 0;
mZStream->next_in = mTmp;
mCompressedStream->seek(0);
mZStream->avail_in = mCompressedStream->read(mTmp, OGRE_DEFLATE_TMP_SIZE);
inflateReset(mZStream);
}
else
{
skip(pos - tell());
}
}
}
//---------------------------------------------------------------------
void DeflateStream::init()
{
mpZStream = OGRE_ALLOC_T(z_stream, 1, MEMCATEGORY_GENERAL);
mpZStream->zalloc = OgreZalloc;
mpZStream->zfree = OgreZfree;
if (getAccessMode() == READ)
{
mpTmp = (unsigned char*)OGRE_MALLOC(OGRE_DEFLATE_TMP_SIZE, MEMCATEGORY_GENERAL);
size_t restorePoint = mCompressedStream->tell();
// read early chunk
mpZStream->next_in = mpTmp;
mpZStream->avail_in = mCompressedStream->read(mpTmp, OGRE_DEFLATE_TMP_SIZE);
if (inflateInit(mpZStream) != Z_OK)
{
mIsCompressedValid = false;
}
else
mIsCompressedValid = true;
if (mIsCompressedValid)
{
// in fact, inflateInit on some implementations doesn't try to read
// anything. We need to at least read something to test
Bytef testOut[4];
size_t savedIn = mpZStream->avail_in;
mpZStream->avail_out = 4;
mpZStream->next_out = testOut;
if (inflate(mpZStream, Z_SYNC_FLUSH) != Z_OK)
mIsCompressedValid = false;
// restore for reading
mpZStream->avail_in = savedIn;
mpZStream->next_in = mpTmp;
inflateReset(mpZStream);
}
if (!mIsCompressedValid)
{
// Not compressed data!
// Fail gracefully, fall back on reading the underlying stream direct
destroy();
mCompressedStream->seek(restorePoint);
}
}
else
{
// Write to temp file
char tmpname[L_tmpnam];
tmpnam(tmpname);
mTempFileName = tmpname;
std::fstream *f = OGRE_NEW_T(std::fstream, MEMCATEGORY_GENERAL)();
f->open(tmpname, std::ios::binary | std::ios::out);
mTmpWriteStream = DataStreamPtr(OGRE_NEW FileStreamDataStream(f));
}
}
//---------------------------------------------------------------------
size_t DeflateStream::write(const void* buf, size_t count)
{
if ((getAccessMode() & WRITE) == 0)
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Not a writable stream", "DeflateStream::write");
return mTmpWriteStream->write(buf, count);
}
//---------------------------------------------------------------------
void DeflateStream::close(void)
{
if (getAccessMode() & WRITE)
{
compressFinal();
}
// don't close underlying compressed stream in case used for something else
}
//---------------------------------------------------------------------
void DeflateStream::destroy()
{
if (getAccessMode() == READ)
inflateEnd(mZStream);
OGRE_FREE(mZStream, MEMCATEGORY_GENERAL);
mZStream = 0;
OGRE_FREE(mTmp, MEMCATEGORY_GENERAL);
mTmp = 0;
}
//---------------------------------------------------------------------
bool DeflateStream::eof(void) const
{
if (getAccessMode() & WRITE)
return mTmpWriteStream->eof();
else
{
if (!mIsCompressedValid)
return mCompressedStream->eof();
else
return mCompressedStream->eof() && mZStream->avail_in == 0;
}
}
//---------------------------------------------------------------------
size_t DeflateStream::tell(void) const
{
if (!mIsCompressedValid)
{
return mCompressedStream->tell();
}
else if(getAccessMode() & WRITE)
{
return mTmpWriteStream->tell();
}
else
{
return mCurrentPos;
}
}
//---------------------------------------------------------------------
void DeflateStream::skip(long count)
{
if (!mIsCompressedValid)
{
mCompressedStream->skip(count);
return;
}
if (getAccessMode() & WRITE)
{
mTmpWriteStream->skip(count);
}
else
{
if (count > 0)
{
if (!mReadCache.ff(count))
{
OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
"You can only skip within the cache range in a deflate stream.",
"DeflateStream::skip");
}
}
else if (count < 0)
{
if (!mReadCache.rewind((size_t)(-count)))
{
OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
"You can only skip within the cache range in a deflate stream.",
"DeflateStream::skip");
}
}
}
mCurrentPos = static_cast<size_t>(static_cast<long>(mCurrentPos) + count);
}
//---------------------------------------------------------------------
void DeflateStream::init()
{
mZStream = OGRE_ALLOC_T(z_stream, 1, MEMCATEGORY_GENERAL);
mZStream->zalloc = OgreZalloc;
mZStream->zfree = OgreZfree;
if (getAccessMode() == READ)
{
mTmp = (unsigned char*)OGRE_MALLOC(OGRE_DEFLATE_TMP_SIZE, MEMCATEGORY_GENERAL);
size_t restorePoint = mCompressedStream->tell();
// read early chunk
mZStream->next_in = mTmp;
mZStream->avail_in = static_cast<uint>(mCompressedStream->read(mTmp, getAvailInForSinglePass()));
if (inflateInit(mZStream) != Z_OK)
{
mIsCompressedValid = false;
}
else
mIsCompressedValid = true;
if (mIsCompressedValid)
{
// in fact, inflateInit on some implementations doesn't try to read
// anything. We need to at least read something to test
Bytef testOut[4];
size_t savedIn = mZStream->avail_in;
mZStream->avail_out = 4;
mZStream->next_out = testOut;
if (inflate(mZStream, Z_SYNC_FLUSH) != Z_OK)
mIsCompressedValid = false;
// restore for reading
mZStream->avail_in = static_cast<uint>(savedIn);
mZStream->next_in = mTmp;
inflateReset(mZStream);
}
if (!mIsCompressedValid)
{
// Not compressed data!
// Fail gracefully, fall back on reading the underlying stream direct
destroy();
mCompressedStream->seek(restorePoint);
}
}
else
{
if(mTempFileName.empty())
{
// Write to temp file
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WINRT
char* tmpname = _tempnam(".", "ogre");
if (!tmpname)
{
// Having no file name here will cause various problems later.
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Temporary file name generation failed.", "DeflateStream::init");
}
else
{
mTempFileName = tmpname;
free(tmpname);
}
#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS || OGRE_PLATFORM == OGRE_PLATFORM_APPLE
mTempFileName = macTempFileName();
#else
char tmpname[] = "/tmp/ogreXXXXXX";
if (mkstemp(tmpname) == -1)
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Temporary file name generation failed.", "DeflateStream::init");
mTempFileName = tmpname;
#endif
}
std::fstream *f = OGRE_NEW_T(std::fstream, MEMCATEGORY_GENERAL)();
f->open(mTempFileName.c_str(), std::ios::binary | std::ios::out);
mTmpWriteStream = DataStreamPtr(OGRE_NEW FileStreamDataStream(f));
}
}
//---------------------------------------------------------------------
size_t DeflateStream::read(void* buf, size_t count)
{
if (!mIsCompressedValid)
{
return mCompressedStream->read(buf, count);
}
if (getAccessMode() & WRITE)
{
return mTmpWriteStream->read(buf, count);
}
else
{
size_t restorePoint = mCompressedStream->tell();
// read from cache first
size_t cachereads = mReadCache.read(buf, count);
size_t newReadUncompressed = 0;
if (cachereads < count)
{
mZStream->avail_out = static_cast<uint>(count - cachereads);
mZStream->next_out = (Bytef*)buf + cachereads;
while (mZStream->avail_out)
{
// Pull next chunk of compressed data from the underlying stream
if (!mZStream->avail_in && !mCompressedStream->eof())
{
mZStream->avail_in = static_cast<uint>(mCompressedStream->read(mTmp, getAvailInForSinglePass()));
mZStream->next_in = mTmp;
}
if (mZStream->avail_in)
{
int availpre = mZStream->avail_out;
int status = inflate(mZStream, Z_SYNC_FLUSH);
size_t readUncompressed = availpre - mZStream->avail_out;
newReadUncompressed += readUncompressed;
if (status != Z_OK)
{
// End of data, or error
if (status != Z_STREAM_END)
{
mCompressedStream->seek(restorePoint);
OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
"Error in compressed stream",
"DeflateStrea::read");
}
else
{
// back up the stream so that it can be used from the end onwards
long unusedCompressed = mZStream->avail_in;
mCompressedStream->skip(-unusedCompressed);
}
break;
}
}
}
}
// Cache the last bytes read
mReadCache.cacheData((char*)buf + cachereads, newReadUncompressed);
mCurrentPos += newReadUncompressed + cachereads;
return newReadUncompressed + cachereads;
}
}
void Property::operator=(const Quaternion& value)
{
mada_assert(getValueType() == QuaternionType);
mada_assert(getAccessMode() == ReadWrite);
m_value = value;
}
void Property::operator=(const Vector3& value)
{
mada_assert(getValueType() == Vector3Type);
mada_assert(getAccessMode() == ReadWrite);
m_value = value;
}
void Property::operator=(const String& value)
{
mada_assert(getValueType() == StringType);
mada_assert(getAccessMode() == ReadWrite);
m_value = value;
}
void Property::operator=(float value)
{
mada_assert(getValueType() == FloatType);
mada_assert(getAccessMode() == ReadWrite);
m_value = value;
}
void Property::operator=(bool value)
{
mada_assert(getValueType() == BoolType);
mada_assert(getAccessMode() == ReadWrite);
m_value = value;
}
