void QPAGenerator::writeBlock(QFontEngineQPA::BlockTag tag, const QByteArray &data)
{
writeUInt16(tag);
writeUInt16(0); // padding
const int padSize = ((data.size() + 3) / 4) * 4 - data.size();
writeUInt32(data.size() + padSize);
dev->write(data);
for (int i = 0; i < padSize; ++i)
writeUInt8(0);
}
void QPAGenerator::writeGMap()
{
const quint16 glyphCount = fe->glyphCount();
writeUInt16(QFontEngineQPA::GMapBlock);
writeUInt16(0); // padding
writeUInt32(glyphCount * 4);
QByteArray &buffer = dev->buffer();
const int numBytes = glyphCount * sizeof(quint32);
qint64 pos = buffer.size();
buffer.resize(pos + numBytes);
qMemSet(buffer.data() + pos, 0xff, numBytes);
dev->seek(pos + numBytes);
}
uint32 TextureDictionary::write(ostream &rw)
{
HeaderInfo header;
header.build = version;
uint32 writtenBytesReturn;
/*
* writtenBytesReturn will always contain the number of bytes
* written in a sub-block, it is used like a return value.
*/
// Texture Dictionary
SKIP_HEADER();
// Struct
{
SKIP_HEADER();
bytesWritten += writeUInt16(texList.size(), rw);
// TODO, wtf is that?
bytesWritten += writeUInt16(0, rw);
WRITE_HEADER(CHUNK_STRUCT);
}
bytesWritten += writtenBytesReturn;
// Texture Natives
for (uint32 i = 0; i < texList.size(); i++) {
if (texList[i].platform == PLATFORM_D3D8 ||
texList[i].platform == PLATFORM_D3D9) {
bytesWritten += texList[i].writeD3d(rw);
} else {
cerr << "can't write platform " <<
texList[i].platform << endl;
}
}
// Extension
{
SKIP_HEADER();
WRITE_HEADER(CHUNK_EXTENSION);
}
bytesWritten += writtenBytesReturn;
WRITE_HEADER(CHUNK_TEXDICTIONARY);
return bytesWritten;
}
void BaseSerializedObj::writeUInt16Array(uint16_t array[], uint64_t s)
{
writeUInt64(s);
uint64_t i = 0;
while ( i!=s )
{
writeUInt16(array[i]);
i++;
}
}
void DataOutputStream::writeInt16(INT16 x)
{
writeUInt16((UINT16)x);
}
void QPAGenerator::writeTaggedQFixed(QFontEngineQPA::HeaderTag tag, QFixed value)
{
writeUInt16(tag);
writeUInt16(sizeof(quint32));
writeUInt32(value.value());
}
void QPAGenerator::writeTaggedUInt8(QFontEngineQPA::HeaderTag tag, quint8 value)
{
writeUInt16(tag);
writeUInt16(sizeof(value));
writeUInt8(value);
}
void QPAGenerator::writeTaggedString(QFontEngineQPA::HeaderTag tag, const QByteArray &string)
{
writeUInt16(tag);
writeUInt16(string.length());
dev->write(string);
}
uint32 NativeTexture::writeD3d(ostream &rw)
{
HeaderInfo header;
header.build = version;
uint32 writtenBytesReturn;
if (platform != PLATFORM_D3D8 &&
platform != PLATFORM_D3D9)
return 0;
// Texture Native
SKIP_HEADER();
// Struct
{
SKIP_HEADER();
bytesWritten += writeUInt32(platform, rw);
bytesWritten += writeUInt32(filterFlags, rw);
char buffer[32];
strncpy(buffer, name.c_str(), 32);
rw.write(buffer, 32);
strncpy(buffer, maskName.c_str(), 32);
rw.write(buffer, 32);
bytesWritten += 2*32;
bytesWritten += writeUInt32(rasterFormat, rw);
/*
if(rasterFormat == RASTER_8888 && !hasAlpha ||
rasterFormat == RASTER_888 && hasAlpha)
cout << "mismatch " << hex << rasterFormat << endl;
*/
if (platform == PLATFORM_D3D8) {
bytesWritten += writeUInt32(hasAlpha, rw);
} else {
if (dxtCompression) {
char fourcc[5] = "DXT0";
fourcc[3] += dxtCompression;
rw.write(fourcc, 4);
bytesWritten += 4;
} else {
// 0x15 or 0x16
bytesWritten += writeUInt32(0x16-hasAlpha, rw);
}
}
bytesWritten += writeUInt16(width[0], rw);
bytesWritten += writeUInt16(height[0], rw);
bytesWritten += writeUInt8(depth, rw);
bytesWritten += writeUInt8(mipmapCount, rw);
bytesWritten += writeUInt8(0x4, rw);
if (platform == PLATFORM_D3D8)
bytesWritten += writeUInt8(dxtCompression, rw);
else
bytesWritten += writeUInt8(
(dxtCompression ? 8 : 0) | hasAlpha, rw);
/* Palette */
if (rasterFormat & RASTER_PAL8 || rasterFormat & RASTER_PAL4) {
uint32 paletteSize = 1 << depth;
rw.write(reinterpret_cast <char *> (palette),
paletteSize*4*sizeof(uint8));
bytesWritten += paletteSize*4*sizeof(uint8);
}
/* Texels */
for (uint32 i = 0; i < mipmapCount; i++) {
/*
uint32 dataSize = width[i]*height[i];
if (!dxtCompression)
dataSize *= depth/8;
else if (dxtCompression == 1)
dataSize /= 2;
*/
uint32 dataSize = dataSizes[i];
bytesWritten += writeUInt32(dataSize, rw);
rw.write(reinterpret_cast <char *> (&texels[i][0]),
dataSize*sizeof(uint8));
bytesWritten += dataSize*sizeof(uint8);
}
WRITE_HEADER(CHUNK_STRUCT);
}
bytesWritten += writtenBytesReturn;
// Extension
{
SKIP_HEADER();
WRITE_HEADER(CHUNK_EXTENSION);
}
bytesWritten += writtenBytesReturn;
WRITE_HEADER(CHUNK_TEXTURENATIVE);
return bytesWritten;
}
bool convertWOFFToSfnt(SharedBuffer* woff, Vector<char>& sfnt)
{
ASSERT_ARG(sfnt, sfnt.isEmpty());
size_t offset = 0;
// Read the WOFF header.
uint32_t signature;
if (!readUInt32(woff, offset, signature) || signature != woffSignature) {
ASSERT_NOT_REACHED();
return false;
}
uint32_t flavor;
if (!readUInt32(woff, offset, flavor))
return false;
uint32_t length;
if (!readUInt32(woff, offset, length) || length != woff->size())
return false;
uint16_t numTables;
if (!readUInt16(woff, offset, numTables))
return false;
if (!numTables || numTables > 0x0fff)
return false;
uint16_t reserved;
if (!readUInt16(woff, offset, reserved) || reserved)
return false;
uint32_t totalSfntSize;
if (!readUInt32(woff, offset, totalSfntSize))
return false;
if (woff->size() - offset < sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t))
return false;
offset += sizeof(uint16_t); // majorVersion
offset += sizeof(uint16_t); // minorVersion
offset += sizeof(uint32_t); // metaOffset
offset += sizeof(uint32_t); // metaLength
offset += sizeof(uint32_t); // metaOrigLength
offset += sizeof(uint32_t); // privOffset
offset += sizeof(uint32_t); // privLength
// Check if the WOFF can supply as many tables as it claims it has.
if (woff->size() - offset < numTables * 5 * sizeof(uint32_t))
return false;
// Write the sfnt offset subtable.
uint16_t entrySelector = 0;
uint16_t searchRange = 1;
while (searchRange < numTables >> 1) {
entrySelector++;
searchRange <<= 1;
}
searchRange <<= 4;
uint16_t rangeShift = (numTables << 4) - searchRange;
if (!writeUInt32(sfnt, flavor)
|| !writeUInt16(sfnt, numTables)
|| !writeUInt16(sfnt, searchRange)
|| !writeUInt16(sfnt, entrySelector)
|| !writeUInt16(sfnt, rangeShift))
return false;
if (sfnt.size() > totalSfntSize)
return false;
if (totalSfntSize - sfnt.size() < numTables * 4 * sizeof(uint32_t))
return false;
size_t sfntTableDirectoryCursor = sfnt.size();
sfnt.grow(sfnt.size() + numTables * 4 * sizeof(uint32_t));
// Process tables.
for (uint16_t i = 0; i < numTables; ++i) {
// Read a WOFF table directory entry.
uint32_t tableTag;
if (!readUInt32(woff, offset, tableTag))
return false;
uint32_t tableOffset;
if (!readUInt32(woff, offset, tableOffset))
return false;
uint32_t tableCompLength;
if (!readUInt32(woff, offset, tableCompLength))
return false;
if (tableOffset > woff->size() || tableCompLength > woff->size() - tableOffset)
return false;
uint32_t tableOrigLength;
if (!readUInt32(woff, offset, tableOrigLength) || tableCompLength > tableOrigLength)
return false;
if (tableOrigLength > totalSfntSize || sfnt.size() > totalSfntSize - tableOrigLength)
return false;
uint32_t tableOrigChecksum;
if (!readUInt32(woff, offset, tableOrigChecksum))
return false;
// Write an sfnt table directory entry.
uint32_t* sfntTableDirectoryPtr = reinterpret_cast<uint32_t*>(sfnt.data() + sfntTableDirectoryCursor);
*sfntTableDirectoryPtr++ = htonl(tableTag);
*sfntTableDirectoryPtr++ = htonl(tableOrigChecksum);
*sfntTableDirectoryPtr++ = htonl(sfnt.size());
*sfntTableDirectoryPtr++ = htonl(tableOrigLength);
sfntTableDirectoryCursor += 4 * sizeof(uint32_t);
if (tableCompLength == tableOrigLength) {
// The table is not compressed.
if (!sfnt.tryAppend(woff->data() + tableOffset, tableCompLength))
return false;
} else {
uLongf destLen = tableOrigLength;
if (!sfnt.tryReserveCapacity(sfnt.size() + tableOrigLength))
return false;
Bytef* dest = reinterpret_cast<Bytef*>(sfnt.end());
sfnt.grow(sfnt.size() + tableOrigLength);
if (uncompress(dest, &destLen, reinterpret_cast<const Bytef*>(woff->data() + tableOffset), tableCompLength) != Z_OK)
return false;
if (destLen != tableOrigLength)
return false;
}
// Pad to a multiple of 4 bytes.
while (sfnt.size() % 4)
sfnt.append(0);
}
return sfnt.size() == totalSfntSize;
}
void QPFGenerator::writeTaggedUInt32(QFontEngineQPF::HeaderTag tag, quint32 value)
{
writeUInt16(tag);
writeUInt16(sizeof(value));
writeUInt32(value);
}
void write(uint16_t v) { writeUInt16(v); };
