void DynamicPatriciaTrieWritingHelper::writeToDictFile(const char *const fileName,
const HeaderPolicy *const headerPolicy, const int unigramCount, const int bigramCount) {
BufferWithExtendableBuffer headerBuffer(0 /* originalBuffer */, 0 /* originalBufferSize */);
const int extendedRegionSize = headerPolicy->getExtendedRegionSize() +
mBuffer->getUsedAdditionalBufferSize();
if (!headerPolicy->writeHeaderToBuffer(&headerBuffer, false /* updatesLastUpdatedTime */,
false /* updatesLastDecayedTime */, unigramCount, bigramCount, extendedRegionSize)) {
return;
}
DictFileWritingUtils::flushAllHeaderAndBodyToFile(fileName, &headerBuffer, mBuffer);
}
/* static */ bool DictFileWritingUtils::createEmptyV3DictFile(const char *const filePath,
const HeaderReadWriteUtils::AttributeMap *const attributeMap) {
BufferWithExtendableBuffer headerBuffer(0 /* originalBuffer */, 0 /* originalBufferSize */);
HeaderPolicy headerPolicy(FormatUtils::VERSION_3, attributeMap);
headerPolicy.writeHeaderToBuffer(&headerBuffer, true /* updatesLastUpdatedTime */,
true /* updatesLastDecayedTime */, 0 /* unigramCount */, 0 /* bigramCount */,
0 /* extendedRegionSize */);
BufferWithExtendableBuffer bodyBuffer(0 /* originalBuffer */, 0 /* originalBufferSize */);
if (!DynamicPatriciaTrieWritingUtils::writeEmptyDictionary(&bodyBuffer, 0 /* rootPos */)) {
return false;
}
return flushAllHeaderAndBodyToFile(filePath, &headerBuffer, &bodyBuffer);
}
void PacketSocket::readHeader()
{
QByteArray headerBuffer(HEADER_SIZE, 0);
int res = _socket->read(headerBuffer.data(), HEADER_SIZE);
if (res != HEADER_SIZE) {
qFatal("unable to read header");
}
_header.Clear();
if (!_header.ParseFromArray(headerBuffer.data(), HEADER_SIZE)) {
qFatal("Failed to parse header");
}
_state = stateReadingBody;
}
bool Ver4PatriciaTrieWritingHelper::writeToDictFile(const char *const dictDirPath,
const int unigramCount, const int bigramCount) const {
const HeaderPolicy *const headerPolicy = mBuffers->getHeaderPolicy();
BufferWithExtendableBuffer headerBuffer(
BufferWithExtendableBuffer::DEFAULT_MAX_ADDITIONAL_BUFFER_SIZE);
const int extendedRegionSize = headerPolicy->getExtendedRegionSize()
+ mBuffers->getTrieBuffer()->getUsedAdditionalBufferSize();
if (!headerPolicy->fillInAndWriteHeaderToBuffer(false /* updatesLastDecayedTime */,
unigramCount, bigramCount, extendedRegionSize, &headerBuffer)) {
AKLOGE("Cannot write header structure to buffer. "
"updatesLastDecayedTime: %d, unigramCount: %d, bigramCount: %d, "
"extendedRegionSize: %d", false, unigramCount, bigramCount,
extendedRegionSize);
return false;
}
return mBuffers->flushHeaderAndDictBuffers(dictDirPath, &headerBuffer);
}
bool Ver4PatriciaTrieWritingHelper::writeToDictFileWithGC(const int rootPtNodeArrayPos,
const char *const dictDirPath) {
const HeaderPolicy *const headerPolicy = mBuffers->getHeaderPolicy();
Ver4DictBuffers::Ver4DictBuffersPtr dictBuffers(
Ver4DictBuffers::createVer4DictBuffers(headerPolicy,
Ver4DictConstants::MAX_DICTIONARY_SIZE));
MutableEntryCounters entryCounters;
if (!runGC(rootPtNodeArrayPos, headerPolicy, dictBuffers.get(), &entryCounters)) {
return false;
}
BufferWithExtendableBuffer headerBuffer(
BufferWithExtendableBuffer::DEFAULT_MAX_ADDITIONAL_BUFFER_SIZE);
if (!headerPolicy->fillInAndWriteHeaderToBuffer(true /* updatesLastDecayedTime */,
entryCounters.getEntryCounts(), 0 /* extendedRegionSize */, &headerBuffer)) {
return false;
}
return dictBuffers->flushHeaderAndDictBuffers(dictDirPath, &headerBuffer);
}
void DynamicPatriciaTrieWritingHelper::writeToDictFileWithGC(const int rootPtNodeArrayPos,
const char *const fileName, const HeaderPolicy *const headerPolicy) {
BufferWithExtendableBuffer newDictBuffer(0 /* originalBuffer */, 0 /* originalBufferSize */,
MAX_DICTIONARY_SIZE);
int unigramCount = 0;
int bigramCount = 0;
if (mNeedsToDecay) {
ForgettingCurveUtils::sTimeKeeper.setCurrentTime();
}
if (!runGC(rootPtNodeArrayPos, headerPolicy, &newDictBuffer, &unigramCount, &bigramCount)) {
return;
}
BufferWithExtendableBuffer headerBuffer(0 /* originalBuffer */, 0 /* originalBufferSize */);
if (!headerPolicy->writeHeaderToBuffer(&headerBuffer, true /* updatesLastUpdatedTime */,
mNeedsToDecay, unigramCount, bigramCount, 0 /* extendedRegionSize */)) {
return;
}
DictFileWritingUtils::flushAllHeaderAndBodyToFile(fileName, &headerBuffer, &newDictBuffer);
}
void CPGSSubFile::ParseFile(CString fn)
{
CFile f;
if (!f.Open(fn, CFile::modeRead | CFile::shareDenyWrite)) {
return;
}
// Header: Sync code | start time | stop time | segment type | segment size
std::array < BYTE, 2 + 2 * 4 + 1 + 2 > header;
const int nExtraSize = 1 + 2; // segment type + segment size
std::vector<BYTE> segBuff;
while (!m_bStopParsing && f.Read(header.data(), (UINT)header.size()) == header.size()) {
// Parse the header
CGolombBuffer headerBuffer(header.data(), (int)header.size());
if (WORD(headerBuffer.ReadShort()) != PGS_SYNC_CODE) {
break;
}
REFERENCE_TIME rtStart = REFERENCE_TIME(headerBuffer.ReadDword()) * 1000 / 9;
REFERENCE_TIME rtStop = REFERENCE_TIME(headerBuffer.ReadDword()) * 1000 / 9;
headerBuffer.ReadByte(); // segment type
WORD wLenSegment = (WORD)headerBuffer.ReadShort();
// Leave some room to add the segment type and size
int nLenData = nExtraSize + wLenSegment;
segBuff.resize(nLenData);
memcpy(segBuff.data(), &header[header.size() - nExtraSize], nExtraSize);
// Read the segment
if (wLenSegment && f.Read(&segBuff[nExtraSize], wLenSegment) != wLenSegment) {
break;
}
// Parse the data (even if the segment size is 0 because the header itself is important)
TRACE_PGSSUB(_T("--------- CPGSSubFile::ParseFile rtStart=%s, rtStop=%s, len=%d ---------\n"),
ReftimeToString(rtStart), ReftimeToString(rtStop), nLenData);
ParseSample(rtStart, rtStop, segBuff.data(), nLenData);
}
}
bool KisLegacyTileCompressor::writeTile(KisTileSP tile, KisPaintDeviceWriter &store)
{
const qint32 tileDataSize = TILE_DATA_SIZE(tile->pixelSize());
const qint32 bufferSize = maxHeaderLength() + 1;
QScopedArrayPointer<quint8> headerBuffer(new quint8[bufferSize]);
bool retval = writeHeader(tile, headerBuffer.data());
Q_ASSERT(retval); // currently the code returns true unconditionally
if (!retval) {
return false;
}
store.write((char *)headerBuffer.data(), strlen((char *)headerBuffer.data()));
tile->lockForRead();
retval = store.write((char *)tile->data(), tileDataSize);
tile->unlock();
return retval;
}