void Font::loadCommonBlock(std::istream &ss, unsigned int blockSize, int version)
{
CommonBlock block;
ReadRaw(ss, block.lineHeight);
ReadRaw(ss, block.base);
ReadRaw(ss, block.scaleW);
ReadRaw(ss, block.scaleH);
ReadRaw(ss, block.pages);
ReadRaw(ss, block.flags);
if (version == 1 || version == 3) // encoded was added in version 2 and removed in version 3 (lol?)
block.flags &= kBlockPacked;
else if (version == 2)
block.flags &= kBlockPacked | kBlockEncoded;
if (version == 3)
{
ReadRaw(ss, block.alphaChnl);
ReadRaw(ss, block.redChnl);
ReadRaw(ss, block.greenChnl);
ReadRaw(ss, block.blueChnl);
}
mLineHeight = static_cast<float>(block.lineHeight);
mBase = static_cast<float>(block.base);
}
void Font::loadFromFile(const char *fname)
{
std::ifstream ss(fname, std::ios::in | std::ios::binary);
std::string dir(fname);
size_t pos = dir.find_last_of("/\\");
if (pos != std::string::npos)
dir = dir.substr(0, pos + 1);
else
dir = "";
// check for a valid header
char magic[3];
ReadRaw(ss, magic);
if (memcmp(magic, "BMF", sizeof(magic)) != 0)
throw std::runtime_error("Invalid font file (no magic code)");
unsigned char version;
ReadRaw(ss, version);
if (version > 3)
throw std::runtime_error("Cannot load font file (unsupported file version)");
while (ss.good())
{
unsigned char blockType;
ReadRaw(ss, blockType);
if (! ss.good()) break;
unsigned int blockSize;
ReadRaw(ss, blockSize);
if (! ss.good())
throw std::runtime_error("Cannot load font file (file is truncated; ends after a block type tag)");
// before version 3, the blockSize included the size field itself
if (version < 3)
blockSize -= 4;
switch (blockType)
{
case kBlockTypeInfo:
loadInfoBlock(ss, blockSize, version);
break;
case kBlockTypeCommon:
loadCommonBlock(ss, blockSize, version);
break;
case kBlockTypePages:
loadPagesBlock(ss, blockSize, version, dir);
break;
case kBlockTypeChars:
loadCharsBlock(ss, blockSize, version);
break;
case kBlockTypeKerning:
loadKerningBlock(ss, blockSize, version);
break;
default:
throw std::runtime_error("Cannot load font file (file contains a block of unknown type)");
break;
}
}
}
//Checks the given sensor values and returns and array of bools.
bool Sensor::GetReading() {
ReadRaw();
UpdateRange();
Normalise();
toTileColour();
return tileWhite;
}
void Font::loadPagesBlock(std::istream &ss, unsigned int blockSize, int version, const std::string &baseDir)
{
// load the texture for the first page
// FIXME: support multiple page fonts??
PagesBlock block;
unsigned int fnameLength = blockSize - sizeof(block);
std::string fname;
fname.reserve(fnameLength);
unsigned int pos = 0;
while (ss.good() && (pos < blockSize))
{
char c;
ReadRaw(ss, c);
pos += 1;
if (c == 0)
break;
else
fname += c;
}
if (pos != blockSize)
throw std::runtime_error("Cannot load font file (pages block is truncated or has an incorrect blockSize)");
mTexture->loadFromFile((baseDir + fname).c_str(), false, Texture::FormatAlpha);
}
// Tests a PTY subprocess with no protocol.
TEST_F(ShellServiceTest, PtyNoProtocolSubprocess) {
// [ -t 0 ] checks if stdin is connected to a terminal.
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"echo foo; echo bar >&2; [ -t 0 ]; echo $?",
SubprocessType::kPty, SubprocessProtocol::kNone));
// [ -t 0 ] == 0 means we have a terminal (PTY).
ExpectLinesEqual(ReadRaw(subprocess_fd_), {"foo", "bar", "0"});
}
/**
* Read the current temperature in degrees F.
*
* @return temperature in units of 0.1 degrees F
*/
int32_t LM92::ReadTempF()
{
int32_t value;
if ((value = ReadRaw()) == -999)
return -999;
// Convert from raw units to degrees F.
// See the LM72_92.xls Spreadsheet in the .../unit_test directory for additional information.
return ((9 * value) / 64) + 320;
}
/**
* Read the current temperature in degrees F.
*
* @return temperature in units of 0.1 degrees F
*/
int32_t LM92::ReadTempC()
{
int32_t value;
if ((value = ReadRaw()) == -999)
return -999;
// Convert from degC to degF.
// See the LM72_92.xls Spreadsheet in the .../unit_test directory for additional information.
return ((5 * value) / 64);
}
unsigned char * VFSHandle_ZIP::Read(unsigned int &length)
{
LocalFileHeader *lfh = m_lfh[m_fileid];
m_stream.clear();
m_stream.seekg(lfh->file_data_offset,std::ios::beg);
unsigned char *buffer = NULL;
if(lfh->compression_method == NO_COMPRESSION){
// Files are just stored
buffer = ReadRaw(m_length);
}else if(lfh->compression_method == DEFLATE_COMPRESSION){
// Files are deflated
// Read compressed data from the disk
unsigned char *src = ReadRaw(lfh->comp_size);
// Allocate a buffer for the decompressed data
buffer = new unsigned char[length];
// setup the z_stream structure
memset(&m_zipstream,0,sizeof(z_stream));
m_zipstream.avail_in = lfh->comp_size;
m_zipstream.next_in = src;
m_zipstream.avail_out = m_length;
m_zipstream.next_out = buffer;
inflateInit2(&m_zipstream,-15);
inflate(&m_zipstream,Z_FINISH);
inflateEnd(&m_zipstream);
delete[] src;
}
return buffer;
}
void Font::loadKerningBlock(std::istream &ss, unsigned int blockSize, int version)
{
KerningPairsBlock::KerningPair info;
unsigned int pos = 0;
while (ss.good() && (pos < blockSize))
{
if (version < 3)
{
unsigned short ids;
ReadRaw(ss, ids);
info.first = ids;
ReadRaw(ss, ids);
info.second = ids;
}
else
{
ReadRaw(ss, info.first);
ReadRaw(ss, info.second);
}
ReadRaw(ss, info.amount);
if (version < 3)
pos += 6;
else
pos += 10;
if (info.first >= 256 || info.second >= 256)
continue;
mKerningPairs.insert(std::make_pair(
CharPair(static_cast<char>(info.first), static_cast<char>(info.second)),
static_cast<float>(info.amount)
));
}
if (pos != blockSize)
throw std::runtime_error("Cannot load font file (kerning block is truncated or has an incorrect blockSize)");
}
size_t wxBZipInputStream::OnSysRead(void* buffer, size_t bufsize)
{
bz_stream* hZip = (bz_stream*)m_hZip;
hZip->next_out = (char*)buffer;
hZip->avail_out = bufsize;
while (hZip->avail_out != 0)
{
if (m_nBufferPos == 0 || m_nBufferPos == WXBZBS)
{
ReadRaw(m_pBuffer, WXBZBS);
m_nBufferPos = 0;
hZip->next_in = m_pBuffer;
hZip->avail_in = WXBZBS;
if (m_parent_i_stream->LastRead() != WXBZBS)
{
// Full amount not read, so do a last
// minute tidy up and decompress what is left
hZip->avail_in = m_parent_i_stream->LastRead();
int nRet = BZ2_bzDecompress(hZip);
if (nRet == BZ_OK || nRet == BZ_STREAM_END)
return bufsize - hZip->avail_out;
else
return 0;
}
}
// Buffer full, decompress some bytes
hZip->next_in = &m_pBuffer[m_nBufferPos];
hZip->avail_in = WXBZBS - m_nBufferPos;
int nRet = BZ2_bzDecompress(hZip);
if (nRet == BZ_OK)
{
m_nBufferPos = WXBZBS - hZip->avail_in;
}
else if(nRet == BZ_STREAM_END)
return bufsize - hZip->avail_out;
else
return 0;
}
return bufsize - hZip->avail_out;
}
RoOptionalUInt32 RoCli::ReadInteger(std::string message, bool isPassword, optional<RoButtonSoundPtr> buttonSound)
{
RoOptionalUtf8 rawInput = ReadRaw(message, isPassword, INTEGER_CHARS, buttonSound);
if (rawInput.is_initialized())
{
char* endChar;
const std::string inputString = rawInput->asUTF8();
uint32 result = strtol(&inputString[0], &endChar, 0);
if (*endChar == 0)
{
return RoOptionalUInt32{ result };
}
}
return RoOptionalUInt32{};
}
size_t wxBZipInputStream::OnSysRead(void* buffer, size_t bufsize)
{
wxInt32 nRead = 0;
((bz_stream*&)hZip)->next_out = &(((char*&)buffer)[nRead]);
((bz_stream*&)hZip)->avail_out = bufsize - nRead;
while (((bz_stream*&)hZip)->avail_out != 0)
{
//wxMessageBox(wxString::Format("%i %i", nRead, ((bz_stream*&)hZip)->avail_out));
if (nBufferPos == 0 || nBufferPos == WXBZBS)
{
ReadRaw(pBuffer, WXBZBS);
nBufferPos = 0;
((bz_stream*&)hZip)->next_in = &pBuffer[nBufferPos];
((bz_stream*&)hZip)->avail_in = WXBZBS - nBufferPos;
if (m_parent_i_stream->LastRead() != WXBZBS)
{
((bz_stream*&)hZip)->avail_in = m_parent_i_stream->LastRead();
int nRet = BZ2_bzDecompress((bz_stream*&)hZip);
if (nRet == BZ_OK || nRet == BZ_STREAM_END)
return bufsize - ((bz_stream*&)hZip)->avail_out;
else
return 0;
}
}
((bz_stream*&)hZip)->next_in = &pBuffer[nBufferPos];
((bz_stream*&)hZip)->avail_in = WXBZBS - nBufferPos;
int nRet = BZ2_bzDecompress((bz_stream*&)hZip);
if (nRet == BZ_OK)
{
nBufferPos += -(nRead - (
nRead += (WXBZBS - nBufferPos - ((bz_stream*&)hZip)->avail_in)
));
}
else if(nRet == BZ_STREAM_END)
return bufsize - ((bz_stream*&)hZip)->avail_out;
else
return 0;
}
return bufsize - ((bz_stream*&)hZip)->avail_out;
}
RoOptionalUtf8 RoCli::ReadString(std::string message, bool isPassword, optional<RoButtonSoundPtr> buttonSound)
{
return ReadRaw(message, isPassword, TEXT_SPECIAL_CHARS, buttonSound);
}
int CMFTRecord::ExtractData(NTFS_ATTRIBUTE ntfsAttr, BYTE *&puchData, DWORD &dwDataLen) {
DWORD dwCurPos = m_dwCurPos;
if (!ntfsAttr.uchNonResFlag) {// residence attribute, this always resides in the MFT table itself
puchData = new BYTE[ntfsAttr.Attr.Resident.dwLength];
dwDataLen = ntfsAttr.Attr.Resident.dwLength;
memcpy(puchData, &m_pMFTRecord[dwCurPos + ntfsAttr.Attr.Resident.wAttrOffset], dwDataLen);
} else {// non-residence attribute, this resides in the other part of the physical drive
if (!ntfsAttr.Attr.NonResident.n64AllocSize) // i don't know Y, but fails when its zero
ntfsAttr.Attr.NonResident.n64AllocSize = (ntfsAttr.Attr.NonResident.n64EndVCN - ntfsAttr.Attr.NonResident.n64StartVCN) + 1;
// ATTR_STANDARD size may not be correct
dwDataLen = ntfsAttr.Attr.NonResident.n64RealSize;
// allocate for reading data
puchData = new BYTE[ntfsAttr.Attr.NonResident.n64AllocSize];
BYTE chLenOffSz; // length & offset sizes
BYTE chLenSz; // length size
BYTE chOffsetSz; // offset size
LONGLONG n64Len, n64Offset; // the actual lenght & offset
LONGLONG n64LCN = 0; // the pointer pointing the actual data on a physical disk
BYTE *pTmpBuff = puchData;
int nRet;
dwCurPos += ntfsAttr.Attr.NonResident.wDatarunOffset;
;
for (;;) {
///// read the length of LCN/VCN and length ///////////////////////
chLenOffSz = 0;
memcpy(&chLenOffSz, &m_pMFTRecord[dwCurPos], sizeof (BYTE));
dwCurPos += sizeof (BYTE);
if (!chLenOffSz)
break;
chLenSz = chLenOffSz & 0x0F;
chOffsetSz = (chLenOffSz & 0xF0) >> 4;
///// read the data length ////////////////////////////////////////
n64Len = 0;
memcpy(&n64Len, &m_pMFTRecord[dwCurPos], chLenSz);
dwCurPos += chLenSz;
///// read the LCN/VCN offset //////////////////////////////////////
n64Offset = 0;
memcpy(&n64Offset, &m_pMFTRecord[dwCurPos], chOffsetSz);
dwCurPos += chOffsetSz;
////// if the last bit of n64Offset is 1 then its -ve so u got to make it -ve /////
if ((((char*) &n64Offset)[chOffsetSz - 1])&0x80)
for (int i = sizeof (LONGLONG) - 1; i > (chOffsetSz - 1); i--)
((char*) &n64Offset)[i] = 0xff;
n64LCN += n64Offset;
n64Len *= m_dwBytesPerCluster;
///// read the actual data /////////////////////////////////////////
/// since the data is available out side the MFT table, physical drive should be accessed
nRet = ReadRaw(n64LCN, pTmpBuff, (DWORD&) n64Len);
if (nRet)
return nRet;
pTmpBuff += n64Len;
}
}
return ERROR_SUCCESS;
}
void Font::loadCharsBlock(std::istream &ss, unsigned int blockSize, int version)
{
CharsBlock::CharInfo c;
vec2i texSize = mTexture->getSize();
unsigned int pos = 0;
while (ss.good() && (pos < blockSize))
{
if (version < 3)
{
unsigned short ids;
ReadRaw(ss, ids);
c.id = ids;
}
else
ReadRaw(ss, c.id);
ReadRaw(ss, c.x);
ReadRaw(ss, c.y);
ReadRaw(ss, c.width);
ReadRaw(ss, c.height);
ReadRaw(ss, c.xoffset);
ReadRaw(ss, c.yoffset);
ReadRaw(ss, c.xadvance);
ReadRaw(ss, c.page);
ReadRaw(ss, c.chnl);
if (version < 3)
pos += 18;
else
pos += 20;
if (c.id >= 256)
continue;
CharInfo &info = mCharMetrics[c.id];
info.draw = true;
info.advance = static_cast<float>(c.xadvance + 1);
info.posTopLeft = vec2f(
static_cast<float>(c.xoffset),
static_cast<float>(c.yoffset)
);
info.posBottomRight = vec2f(
static_cast<float>(c.xoffset + c.width),
static_cast<float>(c.yoffset + c.height)
);
info.texTopLeft = vec2f(
static_cast<float>(c.x) / static_cast<float>(texSize.x),
static_cast<float>(c.y) / static_cast<float>(texSize.y)
);
info.texBottomRight = vec2f(
static_cast<float>(c.x + c.width ) / static_cast<float>(texSize.x),
static_cast<float>(c.y + c.height) / static_cast<float>(texSize.y)
);
}
if (pos != blockSize)
throw std::runtime_error("Cannot load font file (chars block is truncated or has an incorrect blockSize)");
// hard-code for space and tab
mCharMetrics[' '].draw = false;
mCharMetrics['\t'].draw = false;
mCharMetrics['\t'].advance = 4.0f * mCharMetrics[' '].advance;
}
void Font::loadInfoBlock(std::istream &ss, unsigned int blockSize, int version)
{
InfoBlock block;
ReadRaw(ss, block.fontSize);
ReadRaw(ss, block.flags);
ReadRaw(ss, block.charSet);
ReadRaw(ss, block.stretchH);
ReadRaw(ss, block.aa);
ReadRaw(ss, block.paddingUp);
ReadRaw(ss, block.paddingRight);
ReadRaw(ss, block.paddingDown);
ReadRaw(ss, block.paddingLeft);
ReadRaw(ss, block.spacingHoriz);
ReadRaw(ss, block.spacingVert);
if (version >= 2)
ReadRaw(ss, block.outline);
block.flags &= kFontBold | kFontItalic | kFontUnicode | kFontSmooth;
// font face name
unsigned char faceNameLength = blockSize - sizeof(block);
mFaceName.clear();
mFaceName.reserve(faceNameLength);
unsigned int pos = sizeof(block) - 1;
while (ss.good() && (pos < blockSize))
{
char c;
ReadRaw(ss, c);
if (c == 0)
break;
else
mFaceName += c;
}
}
