// Check a few basic cases (2 matching runs in a row, matching run followed
// by a non-matching run, and non-matching run followed by a matching run).
TEST(fxcodec, RLETestNormalInputs) {
CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
EXPECT_TRUE(pEncoders);
std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
uint32_t dest_size = 0;
std::unique_ptr<uint8_t, FxFreeDeleter> decoded_buf;
uint32_t decoded_size = 0;
{
// Case 1: Match, match
const uint8_t src_buf_1[] = {2, 2, 2, 2, 4, 4, 4, 4, 4, 4};
EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_1, &dest_buf, &dest_size));
RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
ASSERT_EQ(sizeof(src_buf_1), decoded_size);
auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
for (uint32_t i = 0; i < decoded_size; i++)
EXPECT_EQ(src_buf_1[i], decoded_buf_span[i]) << " at " << i;
}
{
// Case 2: Match, non-match
const uint8_t src_buf_2[] = {2, 2, 2, 2, 1, 2, 3, 4, 5, 6};
dest_buf.reset();
dest_size = 0;
EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_2, &dest_buf, &dest_size));
decoded_buf.reset();
decoded_size = 0;
RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
ASSERT_EQ(sizeof(src_buf_2), decoded_size);
auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
for (uint32_t i = 0; i < decoded_size; i++)
EXPECT_EQ(src_buf_2[i], decoded_buf_span[i]) << " at " << i;
}
{
// Case 3: Non-match, match
const uint8_t src_buf_3[] = {1, 2, 3, 4, 5, 3, 3, 3, 3, 3};
dest_buf.reset();
dest_size = 0;
EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_3, &dest_buf, &dest_size));
decoded_buf.reset();
decoded_size = 0;
RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
ASSERT_EQ(sizeof(src_buf_3), decoded_size);
auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
for (uint32_t i = 0; i < decoded_size; i++)
EXPECT_EQ(src_buf_3[i], decoded_buf_span[i]) << " at " << i;
}
}
FX_DWORD PDF_DecodeInlineStream(const uint8_t* src_buf, FX_DWORD limit,
int width, int height, CFX_ByteString& decoder,
CPDF_Dictionary* pParam, uint8_t*& dest_buf, FX_DWORD& dest_size)
{
if (decoder == FX_BSTRC("CCITTFaxDecode") || decoder == FX_BSTRC("CCF")) {
ICodec_ScanlineDecoder* pDecoder = FPDFAPI_CreateFaxDecoder(src_buf, limit, width, height, pParam);
return _DecodeAllScanlines(pDecoder, dest_buf, dest_size);
} else if (decoder == FX_BSTRC("ASCII85Decode") || decoder == FX_BSTRC("A85")) {
return _A85Decode(src_buf, limit, dest_buf, dest_size);
} else if (decoder == FX_BSTRC("ASCIIHexDecode") || decoder == FX_BSTRC("AHx")) {
return _HexDecode(src_buf, limit, dest_buf, dest_size);
} else if (decoder == FX_BSTRC("FlateDecode") || decoder == FX_BSTRC("Fl")) {
return FPDFAPI_FlateOrLZWDecode(FALSE, src_buf, limit, pParam, dest_size, dest_buf, dest_size);
} else if (decoder == FX_BSTRC("LZWDecode") || decoder == FX_BSTRC("LZW")) {
return FPDFAPI_FlateOrLZWDecode(TRUE, src_buf, limit, pParam, 0, dest_buf, dest_size);
} else if (decoder == FX_BSTRC("DCTDecode") || decoder == FX_BSTRC("DCT")) {
ICodec_ScanlineDecoder* pDecoder = CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
src_buf, limit, width, height, 0, pParam ? pParam->GetInteger(FX_BSTRC("ColorTransform"), 1) : 1);
return _DecodeAllScanlines(pDecoder, dest_buf, dest_size);
} else if (decoder == FX_BSTRC("RunLengthDecode") || decoder == FX_BSTRC("RL")) {
return RunLengthDecode(src_buf, limit, dest_buf, dest_size);
}
dest_size = 0;
dest_buf = 0;
return (FX_DWORD) - 1;
}
// Check that runs longer than 128 are broken up properly, both matched and
// non-matched.
TEST(fxcodec, RLETestFullLengthInputs) {
CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule();
EXPECT_TRUE(pEncoders);
std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf;
uint32_t dest_size = 0;
std::unique_ptr<uint8_t, FxFreeDeleter> decoded_buf;
uint32_t decoded_size = 0;
{
// Case 1: Match, match
const uint8_t src_buf_1[260] = {1};
EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_1, &dest_buf, &dest_size));
RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
ASSERT_EQ(sizeof(src_buf_1), decoded_size);
auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
for (uint32_t i = 0; i < decoded_size; i++)
EXPECT_EQ(src_buf_1[i], decoded_buf_span[i]) << " at " << i;
}
{
// Case 2: Match, non-match
uint8_t src_buf_2[260] = {2};
for (uint16_t i = 128; i < 260; i++)
src_buf_2[i] = static_cast<uint8_t>(i - 125);
dest_buf.reset();
dest_size = 0;
EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_2, &dest_buf, &dest_size));
decoded_buf.reset();
decoded_size = 0;
RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
ASSERT_EQ(sizeof(src_buf_2), decoded_size);
auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
for (uint32_t i = 0; i < decoded_size; i++)
EXPECT_EQ(src_buf_2[i], decoded_buf_span[i]) << " at " << i;
}
{
// Case 3: Non-match, match
uint8_t src_buf_3[260] = {3};
for (uint8_t i = 0; i < 128; i++)
src_buf_3[i] = i;
dest_buf.reset();
dest_size = 0;
EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_3, &dest_buf, &dest_size));
decoded_buf.reset();
decoded_size = 0;
RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
ASSERT_EQ(sizeof(src_buf_3), decoded_size);
auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
for (uint32_t i = 0; i < decoded_size; i++)
EXPECT_EQ(src_buf_3[i], decoded_buf_span[i]) << " at " << i;
}
{
// Case 4: Non-match, non-match
uint8_t src_buf_4[260];
for (uint16_t i = 0; i < 260; i++)
src_buf_4[i] = static_cast<uint8_t>(i);
dest_buf.reset();
dest_size = 0;
EXPECT_TRUE(pEncoders->RunLengthEncode(src_buf_4, &dest_buf, &dest_size));
decoded_buf.reset();
decoded_size = 0;
RunLengthDecode({dest_buf.get(), dest_size}, &decoded_buf, &decoded_size);
ASSERT_EQ(sizeof(src_buf_4), decoded_size);
auto decoded_buf_span = pdfium::make_span(decoded_buf.get(), decoded_size);
for (uint32_t i = 0; i < decoded_size; i++)
EXPECT_EQ(src_buf_4[i], decoded_buf_span[i]) << " at " << i;
}
}
void PollingWorker::PollRS232()
{
char * readBuf;
char * rawByte;
char * unCompressed;
Header * headerBuffer;
Item * sender;
long numBytesToGet;
char receiveID;
DWORD dwCommEvent, dwBytesTransferred;
Msg * newMsg;
isFinish = 0;
while(!isFinish)
{
SetUpDCB(baudRate);
// set up the mask, EV_RXCHAR is the event when we receive a character
if (!SetCommMask(hComm, EV_RXCHAR))
emit error(QString("Error setting communications mask."), (int)GetLastError());
// wait for a character to come in
if (!WaitCommEvent(hComm, &dwCommEvent, NULL))
emit error(QString("Error waiting for a character."), (int)GetLastError());
// we have a character, read the header to see if its good
else
{
if(!isRaw->isChecked())
{
// set up the header buffer
if(!(headerBuffer = (Header *)malloc(sizeof(struct Header))))
emit error(QString("Error malloccing headerBuffer."), (int)GetLastError());
// get the header
if(!ReadFile(hComm, (BYTE *)headerBuffer, HEADERSIZE, &dwBytesTransferred, 0))
emit error(QString("Error getting the header buffer."), (int)GetLastError());
if(headerBuffer->lSignature == 0xDEADBEEF)
{
// get the data length from the header
numBytesToGet = headerBuffer->lDataLength;
readBuf = (char*)calloc(numBytesToGet,sizeof(char));
if (readBuf == NULL)
emit error(QString("Error mallocing readBuf."), (int)GetLastError());
// get the message
if(!ReadFile(hComm, readBuf, numBytesToGet, &dwBytesTransferred, 0))
emit error(QString("Error getting the message."), (int)GetLastError());
emit error(QString("Bytes gotten"), (int)(dwBytesTransferred));
unCompressed = readBuf;
// calculate the checksum and compare
if(headerBuffer->sChecksum != CalculateChecksum(readBuf, headerBuffer->lDataLength))
{
emit transmitError();
//emit error (QString ("Checksum reports errors"),0);
}
if (headerBuffer->bVersion == 0xFF)
{
if(!(unCompressed = (char *)calloc(headerBuffer->lDataUncompressed,sizeof(char))))
emit error(QString("Error malloccing unCompressed."), (int)GetLastError());
Huffman_Uncompress((unsigned char*)readBuf, (unsigned char*)unCompressed, headerBuffer->lDataLength, headerBuffer->lDataUncompressed);
// For testing purposes.
emit error (QString("We have a Huffman buffer."),0);
}else if (headerBuffer->bVersion == 0xF0)
{
if(!(unCompressed = (char *)calloc(headerBuffer->lDataUncompressed,sizeof(char))))
emit error(QString("Error malloccing unCompressed."), (int)GetLastError());
unCompressed = RunLengthDecode(readBuf, headerBuffer->lDataLength);
// For testing purposes.
emit error (QString("We have an RLE buffer."),0);
}else if (headerBuffer->bVersion == 0x0F)
{
if(!(unCompressed = (char *)calloc(headerBuffer->lDataUncompressed,sizeof(char))))
emit error(QString("Error malloccing unCompressed."), (int)GetLastError());
unCompressed = (char*)DifferentialExpand(readBuf, headerBuffer->lDataLength);
// For testing purposes.
emit error (QString("We have a Differential buffer."),0);
}
else
emit error (QString("We have an uncompressed buffer."),0);
receiveID = GetReceiverId(headerBuffer->lReceiverAddr);
if (headerBuffer->bDataType == 0)
{ // If the data is text.
// create a new message structure and put it on the queue
// not all the header options we need are available - ask Jack!
if(!(newMsg = (Msg *)malloc(sizeof(struct message))))
emit error(QString("Error malloccing newMsg."), (int)GetLastError());
strcpy(newMsg->txt, unCompressed);
newMsg->senderID = headerBuffer->bSenderAddr;
newMsg->receiverID = (short)receiveID;
newMsg->msgNum = rand() % 100;
newMsg->priority = headerBuffer->bPriority;
AddToQueue(newMsg);
// Check if the senderID has already been created. If not, create one.
if ((sender = BSTSearch(root, headerBuffer->bSenderAddr))== NULL)
{
Item * newItem = (Item*)(malloc (sizeof(Item)));
int * count = (int*)(malloc (sizeof(int)));
*count = 1;
newItem->key = headerBuffer->bSenderAddr;
newItem->data = count;
root = BSTInsert(root,newItem);
}
else // If it has been created, increment
*((int*)sender->data) = *((int*)sender->data) + 1;
emit labelEdit(QString("Number of Messages: %1").arg(numberOfMessages));
}
else
{
// we have audio, emit the data, the length of the data, and the sample rate
emit audioReceived(headerBuffer->lDataUncompressed,
unCompressed,
headerBuffer->sSamplesPerSec);
}
}
}
else
{
// in raw mode, just grab chunks of bytes as they come
do
{
if(!(rawByte = (char *)calloc(1, sizeof(char))))
emit error(QString("Error malloccing rawByte."), (int)GetLastError());
if(!ReadFile(hComm, rawByte, 1, &dwBytesTransferred, 0))
emit error(QString("Error getting the raw data."), (int)GetLastError());
if(dwBytesTransferred != 0)
emit messageEdit(*rawByte);
}while(dwBytesTransferred != 0);
}
}
}
emit finished();
}