bool StandardSerialPortBackend::writeError()
{
// qDebug() << "!d" << tr("DBG -- Serial Port writeError...");
SioWorker::usleep(300);
return writeRawFrame(QByteArray(1, 69));
}
bool StandardSerialPortBackend::writeError()
{
// qDebug() << "!d" << tr("DBG -- Serial Port writeError...");
if(mMethod==HANDSHAKE_SOFTWARE)SioWorker::usleep(mWriteDelay);
else SioWorker::usleep(mCompErrDelay);
return writeRawFrame(QByteArray(1, 69));
}
bool StandardSerialPortBackend::writeDataFrame(const QByteArray &data)
{
// qDebug() << "!d" << tr("DBG -- Serial Port writeDataFrame...");
QByteArray copy(data);
copy.resize(copy.size() + 1);
copy[copy.size() - 1] = sioChecksum(copy, copy.size() - 1);
SioWorker::usleep(50);
return writeRawFrame(copy);
}
bool StandardSerialPortBackend::writeDataNak()
{
// qDebug() << "!d" << tr("DBG -- Serial Port writeDataNak...");
return writeRawFrame(QByteArray(1, 78));
}
bool StandardSerialPortBackend::writeCommandAck()
{
// qDebug() << "!d" << tr("DBG -- Serial Port writeCommandAck...");
return writeRawFrame(QByteArray(1, 65));
}
void HuffmanCodec::encode(BitEncoder* sink, int* raw, int rawFill, bool* userFallback)
{
/** determine dynamic range (min, max)
*/
int rawMin = raw[0];
int rawMax = raw[0];
{
for (int i = 1; i < rawFill; ++i)
{
int x = raw[i];
if (x < rawMin) rawMin = x;
else if (x > rawMax) rawMax = x;
}
}
/** optional fallback to raw data transmission
*/
if (rawMax - rawMin + 1 > rawDynamicRange_)
{
#ifdef FTL_HUFFMANCODEC_PROFILING
print(
"Fallback to unencoded transmission, because out of dynamic range.\n"
" (rawMax - rawMin + 1, rawDynamicRange_) = (%%, %%)\n",
(rawMax - rawMin + 1), rawDynamicRange_
);
#endif // FTL_HUFFMANCODEC_PROFILING
if (!userFallback)
writeRawFrame(sink, raw, rawFill, rawMin, rawMax);
else
*userFallback = true;
return;
}
/** determine symbol frequencies
*/
reset();
for (int i = 0; (i < rawFill) && (codeTableFill_ < rawDiversity_); ++i)
{
int x = raw[i] - rawMin;
if (!codeMap_[x].symbol)
addSymbol(x, 0);
++codeMap_[x].symbol->count;
}
/** optional fallback to raw data transmission
*/
if (codeTableFill_ == rawDiversity_)
{
if (!userFallback)
writeRawFrame(sink, raw, rawFill, rawMin, rawMax);
else
*userFallback = true;
return;
}
/** generate code table
*/
int diversity = codeTableFill_;
generateCodeTable();
#ifdef FTL_HUFFMANCODEC_DEBUG_STATISTICS
for (int i = 0; i < diversity; ++i)
{
FTL_DEBUG << i << ": H(" << codeTable_[i].value << ") = " << codeTable_[i].count << endl;
}
#endif
/** determine output size
*/
int tableSize = 0;
int outSize = 1; // encoding flag
outSize += BitEncoder::bitsPerUIntVlc(rawFill);
outSize += BitEncoder::bitsPerUIntVlc(rawMin);
tableSize += BitEncoder::bitsPerUIntVlc(diversity);
for (int i = 0; i < diversity; ++i)
{
tableSize += BitEncoder::bitsPerUIntVlc(codeTable_[i].value);
tableSize += BitEncoder::bitsPerUIntVlc(codeTable_[i].count);
SymbolNode* sym = codeTable_ + i;
int len = 0;
while ((sym = sym->parent) != 0) ++len;
outSize += len * codeTable_[i].count;
}
outSize += tableSize;
int outSizeBytes = outSize / 8 + (outSize % 8 != 0);
#ifdef FTL_HUFFMANCODEC_PROFILING
print(
"diversity, outSize, table weight = %%, %%, %%\n",
diversity, outSize/8, double(tableSize) / outSize
);
#endif // FTL_HUFFMANCODEC_PROFILING
/** optional fallback to raw data transmission
*/
if (outSizeBytes > encodedCapacity(rawFill, rawMax-rawMin+1))
{
#ifdef FTL_HUFFMANCODEC_PROFILING
print("fallback to unencoded transmission\n");
#endif // FTL_HUFFMANCODEC_PROFILING
if (!userFallback)
writeRawFrame(sink, raw, rawFill, rawMin, rawMax);
else
*userFallback = true;
return;
}
if (userFallback)
*userFallback = false;
/** write header
*/
sink->writeUIntVlc(rawFill);
sink->writeIntVlc(rawMin);
sink->writeIntVlc(rawMax);
sink->writeBit(1); // encoding flag
/** write frequency table
*/
sink->writeUIntVlc(diversity);
for (int i = 0; i < diversity; ++i)
{
sink->writeUIntVlc(codeTable_[i].value);
sink->writeUIntVlc(codeTable_[i].count);
}
/** encode symbols
*/
for (int i = 0; i < rawFill; ++i)
{
int x = raw[i] - rawMin;
SymbolNode* sym = codeMap_[x].symbol;
bitStack_.clear();
while (sym->parent)
{
SymbolNode* parent = sym->parent;
bitStack_.push(parent->rightChild == sym);
sym = parent;
}
while (bitStack_.fill() > 0)
sink->writeBit(bitStack_.pop());
}
}
